Git

When we introduced version control systems we said we were going to consider one system based on the central repository model (Subversion) and one distributed system (Git).

Git has been around since 2005, and was originally developed by Linus Torvald, the creator of Linux.

Git has a nice website for publically hosting git repositories known as GitHub. Repositories on this sites get their own issue tracker (with rss feed) and wiki.

Git uses many commands in a similar way to svn; however, there are some key differences which we will see as we go along.

To begin to set up a git repository move to where you would like to have your repository and type:

git init name_of_git_repository.

If you cd into this directory and do an ls -a to see hidden files, you will see a .git folder.

This is where git keeps track of stuff, unlike svn, each subfolder of your repository doesn't get a .git folder -- svn allows you to check out sub-folders of a repository, with git you essentially always check out a whole everything in a whole branch.

If you want to let someone to get a copy of your repository, you copy the repository folder on to a usb key (a key without Stuxnet please), give it to the person you want to have the repository.

The person that wants to get your repository, might have an existing repository that they want to get your stuff into or might be starting from scratch. They issue a commands like:

git clone path_to_clone_from to_folder #from scratch case
git pull path_to_from_repos branch_name_you_want_to_pull_into #existing case
git checkout branch #makes branch the current branch in the repository you are working on

Notice sharing can be done locally without the need for a central repository, you can zip your git folders and e-mail, git even has its own e-mail commands.

To see information about git commands, you can type 'git help', or 'git command --help'

Configuring your Repository

To find out how our repository is set-up without trying to understand the contents of our .git folder, we can use the git config command:
```
git config -l #lists current config settings.
git config setting_name new_value #changes a setting
```
Git will take a stab at figuring out who you are, but you will probably want to adjust the settings user.name and user.email to properly identify yourself when you commit changes:
```
git config --global user.name "Your Name Comes Here"
git config --global user.email you@yourdomain.example.com
```

Adding, Moving Files

Like svn, git doesn't manage files unless you tell git about them:

git add file_or_folder 
#folders added recursively, 
#.gitignore can be used to list files you don't want added or managed.
git clean #gets rid of files git doesn't know about
git rm file  #removes the file from the repository, with -f deletes from filesystem
git mv loc1 loc2 #moves file from loc1 to loc2
git checkout [rev] file #gets the [rev] version of the file into the current branch
#-f overwrites uncommitted changes.

In svn revisions count up starting with revision 0, if you commit changes to a subfolder or branch, it still adds 1 to the global revision count.
Git revision numbers are super-unmeaningful 20 byte SHA-1 hashes. Fortunately, you only need to use prefixes of a given hash number which are enough to uniquely identify a given branch.

Committing changes

Adding files, removing files, modifying files, each make changes to your copy of the repository after the last revision.
This revision is called HEAD in addition to its SHA-1 name.

To make a new revision of a given branch, you use the git commit command:

git commit -m "Commit message" 
git commit -a -m "Commit message" #the -a adds any unmanaged files to the repository

The new revision will incorporate all the changes you made since the previous revision.
You can use the same formats for commit messages as we had with svn.
If you want to undo any changes you have made since the last commit, you can use the command:
```
git reset --hard HEAD
```
Notice unlike svn, commits happen locally only on your machine.
To find out information about commits you can use the "git log" command.
To find out what has changed since the last commit you can use "git status"
To see the changes between two revisions, you can use "git diff rev1 rev2"
To see who has been modifying a file, you can use "git blame file".

Branches, Merging Branches

You can find out what branches exist in your repository by typing the command:
```
git branch
```
To make a new branch you can use the command: git branch my_new_branch_name
As we said before, you use "git checkout branchname" to switch between branches.
By default, if your repository has anything in it, it will have a master branch.
To merge branch branchname with the currently checked-out branch, you can type "git merge branchname"
git will tell you if there are conflicts. "git diff" will tell you which files were messed up by the merge.
After fixing the files, to resolve the conflicts type "git commit -a".

Making patches, final comments

To make a patch with git you use the command:
```
git format-patch rev1 rev2
```
To apply a patch to the current branch, you use
```
git apply < file_with_patch
```
Like svn, git repositories can be put on a server and made accessible remotely. This is what (Github does).
This is either done using git daemon, or using WebDAV extension to http. In either case, you can do your "git clone" with a url rather than a filesystem path.
If you've cloned such a repository, and made and commited modifications, and now want to send them back to the remote repository, you use the command "git push" or "git push remote_branch_name local_branch_name".
Unlike svn, where we might have a folder tags which has our different release project, with git we often directly make tagged revision of the master branch.
The production server than does a git pull of that tag.

To create such a tag you might do,

git tag -a tag_name revision -m "message about creating tag"

"git tag -l" lists what tags one has.
By default, when you do a git push, tags are not sent. To send them, use "git push --tags"

Git

Outline

Git

Configuring your Repository

Adding, Moving Files

Committing changes

Branches, Merging Branches

Making patches, final comments