Git guide / tutorial for collaboration workflow

Question

1. What I'm trying to do:

I work with two friends on a university project, they made some changes to the code. I've also made a lot of changes to the code, most of which I want to keep.

I'm new to git and don't know where to start. My friend suggested I use:

git pull origin

When I do that I get:

error: Your local changes to the following files would be overwritten by merge:
Please, commit your changes or stash them before you can merge

I read somewhere on stackoverflow: How do you git fetch then merge? "Error: Your local changes to the following files would be overwritten by merge"

That if I don't commit changes to local repository, they'll be lost?

1. How do you commit locally?
2. How do I merge changes(Is there a way I could use beyond compare please)?
3. How do I upload the changes?

Thanks

This is what it looks like now:

Arthur Wulf@SUPERWOLF-PC /c/Current Project/study-wise (master|MERGING)
$ git pull origin master
M       .pydevproject
U       src/app.yaml
M       src/getters/__init__.pyc
M       src/index.yaml
M       src/model/ClassM.pyc
M       src/model/CourseM.py
M       src/model/CourseM.pyc
M       src/model/GeneralM.pyc
M       src/model/LectureM.py
M       src/model/LectureM.pyc
M       src/model/PostClassM.py
A       src/model/PostClassM.pyc
M       src/model/QuestionM.py
M       src/model/QuestionM.pyc
M       src/model/StudentM.py
M       src/model/StudentM.pyc
M       src/model/TopicM.py
M       src/model/TopicM.pyc
M       src/model/__init__.pyc
M       src/setters/__init__.pyc
A       src/setters/setQuestionStats.py
D       src/setters/setRemoveOldData.py
A       src/setters/setStartNewClass.py
A       src/setters/setStudentAnswer.py
D       src/setters/setTopicChanged.py
A       src/setters/setUpdateTopicStats.py
M       src/view/allCourses.html
M       src/view/lecture.html
U       src/view/prof.html
M       src/view/question.html
Pull is not possible because you have unmerged files.
Please, fix them up in the work tree, and then use 'git add/rm <file>'
as appropriate to mark resolution, or use 'git commit -a'.

What I do not understand is how do I beyond compare the files on my local side with the ones on the online origin repository side and merge them?

Answer 1

The right thing to do is to commit all your changes locally, and then try pulling again. That error is there to protect you from losing local changes that haven't been committed. Creating a commit (committing) is like creating a new snapshot of your code, after which that state is safely recorded.

To answer your questions:

1) How do you commit locally?

Look at the output of git status. If there are any files listed as "Untracked files" that you want to keep in git, use git add <filename>... to indicate that you want them in the next commit. Then look at the files listed as "Changes not staged for commit" - these are files that were already in the repository that you've changed. You can again do git add <filename>... for each of those to indicate that you want exactly that version of that file in the commit that you're preparing. (If you make a further modification to a file, you would have to git add that file again to stage the new contents of the file for the commit.)

Finally, you should run git commit. That will open up an editor where you should enter a helpful commit message - when you save that file and exit the editor, your commit should be created. Then you can run git pull origin master, as you originally wanted to.

(As a shortcut, if you do git commit -a, all the changes to files that were already in the repository will be staged for the commit without you having to git add them.)

2) How do I merge changes(Is there a way I could use beyond compare please)?

The git pull origin master command that you tried actually does two things:

1. Fetches the branch master from the remote repository called origin
2. Merges the state of that fetched branch into your current branch.

git is good at avoiding complaining about spurious conflicts, but if you do need help dealing with them, look into git mergetool.

3) How do I upload the changes?

You can do that with git push origin master.

Answer 2

There is a great online book that explains git: Pro Git

So I prefer teaching fishing over giving a fish

Answer 3

git pull origin

pull (fetch + merge) retrieves the latest from the remote (origin) and merges it with your code. You cannot merge in new code if the branch you work in has uncommited changes. You can check the branch status using:

git status

to commit locally, usually I do

git add .                          //stage all files
git commit -a -m "local commit"    //commit all staged

this is a local commit to your local repo. Then you can do the pull which will try to merge your recent commit with the remote changes.

The pull is like a commit in a sense that the event of the pull is recorded in the history of the repo. It WILL try to merge changes (I seldom see overwrites) on the files in your branch but like I said, like a commit, the event is recorded and you can just revert.

To upload changes, you can do a push, where remote is the alias of the server to push as stored in your GIT and branch is the branch to push.

git push [remote] [branch]

And seeing that you have discussed with @zerkms with GIT clients, I personally use msysGit which is GIT for Windows. It has a GUI as well as a command line.

Answer 4

While you are feeling your way around you should avoid git pull because it does both a fetch (which you want) and a merge (which you probably don't want).

You will need to have a chat with your friends as to what workflow will fit you best - have a look at the git tutorial [git help tutorial works on Git for Windows] and gitworkflows [git help workflows], and of course Nvie's A successful Git branching model (with pictures, though it may be more advanced than you need).

The key is to avoid using a common branch ("our_work") for development hacking when separate "my_branch", "his_branch", and "her_branch", etc. will give each of you the freedom you need, and at the same time you can also have branches for "feature_1", etc., that you use as a team as the features mature in a coordinated manner.

In addition, watch out for the distinction between the branches which are pushed automatically, and the branches that are fetched automatically. They probably are not what you think.