Use of Subversion client with sourceforge

             Subversion (SVN) is Centralized, open-source Version Control System. SVN  manages files and directories and changes made to them over a period of time, while supporting to shared development with features like rollback code conflict resolve. As well this allows to recover older versions of the software (data) or examine the history of how the code-base changed. SVN is developed in order to overcome the bugs and misfeatures of CVS.

                 In SVN there are two ends to deal with. One is the Subversion Repository which contains all the managed files and directories, and the other one is commandline or GUI client application to manage files from the client's end. It is important to know the concept of SVN repository before starting work with SVN.

           Repository is a file server which is not behave like an usual one. It has it's own revisioning system. After any authorized person change a file in repository, the state of the code-base will change and it is given a index to identify that state which is new code-base. This index is called revision number. At the initial state of the repository revision number is '0'. For any change in repository the revision number will increase by one (Figure 1). So that people can refer the older versions of the code-base.

Figure 1

Usually repository contain three main directories containing the code-base.

• trunk   - code-base of main development process
• branch - copy of specific revision, to implement new features(which takes some time to finish) concurrently and independently on top of that (Figure 2)
• tag      - some snapshots of the trunk. Can store stable versions of the code-base

Figure 2

Even in branching process, the revision numbers are depend on changes of the branches (Figure 3). How ever at the end of the branching process of a particular branch, containing code should be merge with the main code-base (in trunk).

Figure 3

     Now I think you have an idea on how the repository behave. To access SVN repository there are several methods. Following table shows the URL schemes map to each access method.

Scheme	Access Method
file:///	Direct repository access (on local disk)
http://	Access via WebDAV protocol to Subversionaware Apache server
https://	Same as http://, but with SSL encryption
svn://	Access via custom protocol to an svnserve server
svn+ssh://	Same as svn://, but through an SSH tunnel

              As I mentioned earlier, the second end of SVN is the application, in client's end. I'll explain how we can generally use SVN client applications with Linux & windows environment.

Setup a repository

                  We can get use of sourceforge in order to setup a repository. sourceforge is free repository provider for open-source projects. What you have to do is register for the sourceforge and create a project. Make sure to select the version control system as SVN (default is git) while you are creating the project. sourceforge itself can add folders and files. But since we are in another track forget it for a moment. Under the code tab of your project home page, you can see the command you should use to get a checkout for linux based system. (make sure you have login)

With UBUNTU-10.04 OS

         SVN commandline client can be used with Linux based systems. After installing the SVN commandline client, files can managed via executing the commands in command prompt.

install SVNcommandline client on your machine

$ sudo apt-get install subversion libapache2-svn

first go inside that directory and add source files to the repository.

$ cd /home/source_folder
$ svn import --username=your_username -m "Meaningfull_message_about_the_source_changes_for_users" url_of_repository

note : the repository url you can obtain from the sourceforge (sourceforge -> your project -> code tab)

In sourceforge project your initial file upload will appear as revision number 2. This is due to sourceforge itself create the general folder structure of repository and it will appear as revision number 1.


To start developing with SVN, first create a new folder and then get a checkout from the repository (copy of the latest code-base in repository)

$ sudo mkdir /var/www/myproject
$ cd /var/www
$ svn co --username your_username url_of_repository myproject

Now you can start further implementation on that checkout. If you modify an existing file it will already prepared to commit (upload) to the repository. But if you add a new file or a directory first you have to make prepare it to commit.

$ svn add new_file_1 new_file_2
$ svn ci -m "Meaningful_Message" new_file_1 existing_file_1 existing_file_2

If you want to commit all the files you changed, you use above code without the file paths. A summery of some useful SVN commands are shown below.

information on usage of SVN

$ svn --help

initial commit

$ svn import --username=your_username -m "Message" URL

get a checkout

$ svn co --username your_username URL project_folder

make prepare to commit the newly added files (unversioned files)

$ svn add file_path

see the states of the files (whether versioned or unversioned)

$ svn st

note: The meaning of the symbols shown for statuses,
? - unversioned file
M - locally modified file
A - schedule to add the file

D - schedule to delete the file

G - merged file

C - conflicted file while updating (file is waiting for user resolve the conflict)

! - file is missing or incomplete (removed by non-svn command)
~ - versioned file obstructed by some file of a different kind

I - file ignored

get latest code to working copy without changing local modifications

$ svn up

note: If any file is about to conflict (overwrite) commandline client itself give some options to user to agree,
p - mark the conflict to be resolved later (postpone)
df - show all changes made to merged file (diff-full)
e - change merged file in an editor (edit)
r - accept merged version of file (resolved)
mf - accept my version of entire file and ignore their changes (mine-full)
tf - accept their version of entire file and lose my changes (theirs-full)
l - launch external tool to resolve conflict (launch)
h - show this list (help)

resolve conflicted file before commit (after postpone conflict we can manually resolve it)

$ svn resolved conflicted_file_path

commit all local changes

$ svn ci -m "Message"

note: to commit specific files, add file paths at the end of the above command separating each by a space

remove all the local changes of a working copy (become to base revision)

$ svn revert -R .

note: to revert specific file replace '-R .' with file path

information on base revision (revision of working copy on top)

$ svn info

modifications between working copy and base revision

$ svn diff

get file differences to a file

$ svn diff > ~/Desktop/path/filename.diff

apply patch (diff file) to working copy

$ svn patch -p0 ~/Desktop/path/filename.diff

With Widows 7 OS

             SVN GUI client can be used for windows based systems. TortoiseSVN is the GUI client of SVN. After Installing Tortoise SVN on a machine, files can be managed in UI level. To start the development, go to any directory, under which this project should be created, then right click and select 'SVN checkout' option. Then you can give the repository URL and the local project directory name. If you have already created a project in sourceforge, from the SVN command appeared under 'code' tab, you can fetch out the repository URL.


After any improvement in the code, the corresponding file and all it's parent directories are shown as modified by a red mark on the file or directory. Using the right click options, the modified code can be committed (SVN commit) even while neglecting some of the modified files by selecting them. As well you can see lot of SVN operations can be done from this interface (Figure 4).

Figure 4

 So if you are new to SVN, hope this will helpful to you.

Version Control Systems (Source/Revision Control Systems)

                                Version Control Systems are playing an important role in software source controlling. Most of the software industry used Version Control Systems to keep their source code in a central space so that any authorized person can access to it and do the changes in source files concurrently. The main purpose of a Version Control System is to enable collaborative editing and sharing of data, and keep the older states of the software code base (keep revisions).


                    In a project with large number of remote developers, there is a big probability to accidentally overwrite each other's changes in a regular file system (Figure 1). That's how the Version Control Systems come in to the picture in order to solve this problem.

Figure 1

                          So, to avoid above problem Version Control Systems used a strategy called Lock-Modify-Unlock model (Figure 2). This repository allows only one person to change specific file at a time. To do this it is using a lock system. The user who is going to change a file must lock the file so that any other user cannot lock the file again (it means file can be read but cannot change). After he made the change and commit the file to the repository he must unlock the particular file.

Figure 2

                                   But in this model, the developing process will be unnecessarily serialized, and by mistakes some users may not unlock a file, though others are waiting for unlocking that files. As well concurrent developing of two files by different users cannot have idea of each other file which have some dependencies between them.


                  Therefore another method called Copy-Modify-Merge model (Figure 3) is used as alternative to this problem. In here, users can concurrently develop the same file and commit it by after merging the new changes in repository to the working copy (locally changed copy).

Figure 3                                                                    

                            Version Control Systems such as SVN and CVS are using the above method to file managing.Using this method user have the full control of managing codes in conflicts (overwrite some code).

                  It's possible to classify the Version Control Systems as Centralized and Distributed. Centralized Version Control Systems means there is only one repository which developers are directly deals with. But in Distributed Version Control Systems are some kind of modification of the concept of Centralized Version Control Systems. The concept is to having two levels of Source Control Systems rather than one. So that, without all ways connecting with the main  Source Control System(main repository in server), using an own Source Control System(local host) until completing any specific work (can be a story of project). So that the main repository contains only working copies of the software. As well the operations (commit, revert) are faster due to using the own Source Control System more than Centralized Control System.

Some examples for Version Control Systems are as follows.

(ref : http://www.smashingmagazine.com/2008/09/18/the-top-7-open-source-version-control-systems/)

1). CVS (Concurrent Versioning Systems)

          Older technology. Simple system for make sure files and revisions kept up to date.

2). SVN (Subversion)

          Popular Version Control System. Most of the open-source projects use SVN.

3). git

          A fast populating, open-source Distributed Version Control System.

4). Mercurial

          Open-source Distributed Version Control System. Very faster and much simpler system than 'git'.

5). Bazaar

          Distributed Version Control System with different types of workflow than other Distributed Version Control Systems.

6). LibreSource

          Web portal, with a built-in subversion repositories. Useful for manage collaborative projects.

7). Monotone

          Fairly easy to learn. Places higher value on integrity than performance.

                               I think you may have some idea on Version Control Systems. And I'm willing to have another article soon on use of Subversion client.

Doctrine ගැන දැනගනිමු. (Doctrine Object Relational Mapper)

                  Doctrine කියන්නේ ORM (Object Relational Mapper) එකක්. Doctrine ගැන වැඩි විස්තර කතාකරන්න කලින් ORM කියන්නේ මොකක්ද කියලා බලමු. Database එකක තියෙන data වල යම් පොදු සම්බන්ධතවක් තියෙනවා(relational databases). නමුත් PHP language එක ඒ වගේම symfony framework එක සැකසිලා තියෙන්නේ Object Oriented concept එක පාවිච්චි කරන්න පුලුවන් විදියට. ඉතින් මේ database එකට Object Oriented විදියට access කරන්න නම් මේ object logic එක relational logic එකකට හරවන්න පුලුවන් interface එකක් ඌනේ වෙනවා. මේ interface එක අපිට ORM එකක් කියලා හදුන්වන්න පුලුවන්.

                                           මම symfony ගැන ලියපු ලිපියේ සදහන් කරලා තියෙනව වගේ Doctrine කියන ORM එක පාවිච්චි කරල අපිට පහසුවෙන්ම database transactions කරගන්න පුලුවන්. මේ කියන Doctrine, database එක එක්ක කරන ගනුදෙනුව සරලව අපිට මේ විදියට හිතන්න පුලුවනි. Database එකේ table එකක් හරියට PHP class එකකට අනුරෑපී වෙනවා. ඒ table එකේ තියෙන attributes හරියට PHP class එකේ properties වලට අනුරෑපී වෙනවා. මේ කිව PHP class එකේ object එකක් කියන්නේ මේ table එකේ තියෙන record එකකට map කරන්න පුලුවනි.

අපි දැන් උදාහරණ කීපයක් අරගෙන බලමු කොහොමද මේ database transactions පහසුවෙන් කරගන්නේ කියලා.

1). employee කියන table එකට අලුත් record එකක් add කරන ආකාරය,

               $employee = new Employee();                          ------- a

               $employee->setFirstName('David');                   ------- b

               $employee->setLastName('Wintson');

               $employee->setEmail('david@hotmail.com');

               $employee->save();                                           ------- c    

a) employee කියන table එක map වුන Employee class එකේ object එකක් හදාගන්න.

b) class එකේ තියෙන properties වලට වෙන වෙනම getter, setter methods තියෙනවා. මේ behaviors පාවිච්චි  කරලා අපිට properties වලට values set කරන්න පුලුවන්.

c) දැන් අපි හදාගත්ත object එක database table එකේ record එකක් විදියට save කරන්න පුලුවන්.

2). employee table එකේ id එක 5 වෙන record එක Employee object එකක් විදියට ගන්න ආකාරය,

               $employee = Doctrine :: getTable('Employee')->find(5);

දැන් මේ object එකෙන් එකේ තියෙන properties පාවිච්චි කරන්න පුලුවන්

               $firstName = $employee->getFirstName();

               $lastName  = $employee->getLastName();

3). 'Sells' Department එකට අයත් hometown එක 'Kandy' වන Employee list එක ලබාගන්න Query එකක් ලියන ආකාරය, (department table එකෙන්  employee table එකට foreign key එකක් තියෙනවා)

             $employeeList = Doctrine_Query :: create()

                                          ->from('Employee e')

                                          ->leftJoin('e.Department ed')

                                          ->where('ed.name = ?', 'Sells')

                                          ->andWhere('ed.hometown = ?', 'Kandy')

                                          ->execute();

    $employeeList කියන්නේ Doctrine collection එකක්. ඒ කිව්වේ elements විදියට objects තියෙන array එකක්. foreach loop එකක් පාවිච්චි කරලා මේ array එකේ තියෙන object ව්ලින් අපිට ඌන දේ කරගන්න පුලුවන්.

මේ උදාහරණ කිහිපයෙන් පැහැදිලි වෙනවා ඇති SQL query ලියනවට වඩා Doctrine query ලියන එක කොච්චර ලේසිද කියලා.

              මේ කියන Doctrine interface එක database transactions කරන්නේ PDO (PHP Data Object) කියන තව interface එකක් හරහා. මේ PDO interface එක නිසා අපේ application එක පාවිච්චි කරලා තියෙන DBMS එක මත depend වෙන්නේ නැතිව එකේ තියෙන data වලට access කිරීමේ හැකියාව Doctrine වලට ලැබිල තියෙනවා. ඒක Doctrine වල තියෙන විශේෂ ලක්ෂනයක්. අපිට කෙලින්ම PDO වලින් වුනත් මේ DBMS independent data accessing කරගන්න පුලුවන්. ඒ වුනත් ඒකට වඩා DQL (Doctrine Query Language) එක high level.

                               ඉතින් Doctrine ගැන මම දැනගත්ත දේවල් ටිකක් තම මේ ලිපියේ සදහන් කරලා තියෙන්නේ. මේ ලිපිය හරහා ඔබට ORM කියන concept එක ගැනත් යම් දැනුමක් ලැබෙන්න ඇති. මෙය ඔබේ දැනුමට වැදගත් වේවි කියලා හිතනවා.

symfony ගැන බිදක්... (symfony Framework)

                   සරලවම කිව්වොත් symfony කියන්නේ web applications  නිර්මාණය කිරීම සදහා වන, PHP වලින් ලියන ලද framework එකක්. Pure PHP පාවිච්චි කරනවට වඩා symfony පාවිච්චි කරන එකෙන් අපිට ගොඩක් පහසුකම් සැලසෙනවා. අපේ application එක එක හොද පාලනයක් ඇතිව හසුරුවන්න, පැහැදිලි code එකක් ලියන්න, ඒ වගේම MVC (Model-View-Controller) architecture එකට අනුකූලව application ලියන්න symfony අපට උදව් වෙනවා. අපිට application එක භාගයක් develop කරල තියෙද්දී වුනත් DBMS එක වෙනස් කරගන්න අවශ්‍යය වුනොත් (උදා :- MySQL වල ඉදන් Oracle වලට) ඒකට පවා symfony අපිට පහසුකම් සලසනවා. ඒ තරම් ලොකු configurability එකක් symfony පාවිච්චි කරල තියෙන application එකකට තියෙනවා.

                             symfony application එකක් configure කිරීම සදහා පාවිච්චි කරල තියෙන්නේ  YML (YAML) කියන file format එක. YML කියන්නේ භාවිතයට සහ තේරුම්ගැනීමට ඉතමත් පහසු, XML වලටත් වඩා සරලව data දක්වන්න පුලුවන් markup language එකක්. අපේ application එකේ database එක නිර්මාණය කරන එකත් මේවගේ සරල YML file එකකින් කරගන්න පුලුවන්.

         symfony වල විශේෂත්වයක් තමයි internationalization වලට support කරන එක. ඒ කිව්වේ අපිට පහසුවෙන් application එකේ language එක change කරගන්න පුලුවන්. ඒ සදහා අපි වෙනම XML file එකක් පාවිච්චි කරනවා අදාල වචන ටික store කරගන්න.

                   ඒ වගේම  තවත් දෙයක් තමයි symfony පාවිච්චි කරලා හදන form එකක තියෙන widgets (HTML form elements) වලට වෙන වෙනම server side validation rules add කරන්න පුලුවන් වීම. මේ නිසා අපිට client side validation නැති වුනත් data  validate කරන්න additional codes ලියන්න අවශ්‍යය වෙන්නේ නැහැ. ඒ වගේම application එකට එවන unauthorised data වලිනුත් application එක ආරක්ෂාකරගන්න පුලුවන් මේ validators තියෙන නිසා.

                symfony වල MVC architecture එක ගෑන පොඩ්ඩක් සදහන් කලොත්, DBMS සමග data transaction  කිරීමත්, application එකේ business logic එක ක්‍රියාත්මකවීමත් Model Layer එකෙනුත්, ඒ  data පාවිච්චි කරල Graphical User Interface එකේ ඒවා පෙන්වන එක View Layer එකෙනුත්, application එකට එන request handle කිරීම සහ ඒ අනුව response එකක් දීම Control Layer එකෙනුත් සිදු වෙනවා.

                   symfony framework එක ඈතුලේ, databse transactions පහසුවෙන් කරගන්න Doctrine කියන ORM (Object Relational Mapper) එක පාවිච්චි කරල තියෙනවා. හරියට java වල ORM එකක් විදියට  hibernate පාවිච්චි කරනව වගේ. Doctrine ගැන තවත් ලිපියකින් කතාකරන්න බලාපොරොත්තු වෙනවා.

                             ලිපියේ මුලින් සදහන් කරල තියෙන විදියට DBMS එක මාරු කරන විදිය ගැන පොඩ්ඩක් කතාකලොත්, ඒ විදියට database එක මාරුකරගන්න හැකිවෙන්නේ අපේ database එක සහ Doctrine භාවිතා කරලා තියෙන Model Layer එකත් අතර PDO(PHP Data Object) Layer එකක් තියෙන නිසා. මේ PDO Layer එක නිසා අපි පාවිච්චි කරන DBMS එක ගැන තැකීමකින් තොරව එහි තියෙන data වලට access කරන්න පුලුවන්. මේ හැකියාව symfony වලට ලෑබිලා තියෙන්නේ data transactions වලට ORM එකක් පාවිච්චි කරලා තියෙන නිසායි.

                     symfony ගැන මා දන්න දේවලින් ටිකක් ඔබ එක්ක බෙදාගන්න එක තමයි මේ ලිපියේ අරමුණ. ඔබ මේ ලිපිය කියවීමෙන් ඒ මගේ අරමුණ සාර්තක වුනානම් ලිපිය පිලිබද ඔබේ අදහස දැනගැනීමට කැමැත්තෙමි.

අනාගතය අදයි...

මොහොතින් මොහොත ජීවිතය නොනෑවතී ඉදිරියටම ගලයනවා. ඉපදුන දවසෙ ඉදන් අද වෙනකන් කොච්චර දේවල් කරන්න ඈතිද? කොච්චර දේවල් දකින්න ඈතිද? කොච්චර දේවල් අහන්න ඈතිද? ඒ අහපු-දෑකපු, කරපු-කියපු දේවල් වලින් කොතරම් අත්දෑකීම් ලබාගන්න ඈතිද? එහෙම ලබගත්තු අත්දෑකීම් වලට පින් සිද්ද වෙන්න අද අපි යමක් කමක් දන්න පුද්ගලයෙක් වෙලා සමාජයේ ජීවත් වෙනවා.
          ඒත් එක මොහොතක් හිතල බලන්න. ඒ ලබාගත්තු අත්දෑකීම් වලින් පන්නරය ලබන්නට හේතු වෙච්ච තමන්ගෙම ආදරනීය අම්මා, තාත්තා, සහෝදරයෝ වෙනුවෙන්, කොච්චර කෑපකිරීමක් තමන් කරල තියෙනවද? ජීවිතේ කෙලවර කොතනද කියල අපි කාටවත් කියන්න බෑහෑ. අද දවසේ හදිසියේම ජීවිතයට සමු දෙන්නට උනොත්, තමන් ඒ අය වෙනුවෙන් කරපු කෑපකිරීම් වලින් සෑහීමකට පත් වෙන්නට පුලුවන්ද? ඒ වගේම තමන් අද ඉන්න තත්වේ ලබාගන්නට හේතු වුනේ නිදහස් අධයාපනය නම් ඒ උතුම් නිදහස් අOHපනය රෑක ගෑනීමට ඔබ කෙතරම් දායක වී ඈතිද? තමන් ඉගෙනගත්තු ඒ විදු භූමියට කෙතරම් උදව් කර ඈතිද? ඒ කරපු දේවල් වලින් සෑහීමකට පත් වෙන්නට පුලුවන්ද?
               පරාර්ථකාමී වෙන්න කොච්චර අමාරුද? ඒත් ලේසියෙන්ම ආත්මර්ථකාමී වෙන්නනම් පුලුවනි. පොඩ්ඩක් හිතල බලන්න තමන් මොනවගේ කෙනෙක්ද වෙන්න ඕනේ කියලා. අමතක කරන්න එපා, අපේ අනාගතය අදයි...