4. The first steps with EGit

Create a new Java project called de.vogella.git.first in Eclipse. Create the de.vogella.git.firstpackage and the following class.

package de.vogella.git.first; 
public class GitTest {
  public static void main(String[] args) {
    System.out.println("Git is fun"); 
  }
} 

Right click on your project, select Team → Share Project → Git. On the next dialog press the Createbutton.

EGit will propose an directory outside your workspace. Enter your project name as Name for your local Git repository. Select the Finish button.

The wizard shows you the settings for your local Git repository. Select the Finish button to put your repository under Git version control.

You have created a local Git repository. The git repository is in this case directly stored in the specified folder in a .git folder. The following screenshot shows the directory structure based on the tree -acommand.

Create a .gitignore file in your project with the following content.

bin .metadata 

All files and directories which apply to the pattern described in this file will be ignored by Git. In this example all files in the bin and the .metadata directory will be ignored.

The Git Staging View allows to stage changes and to commit them.

Open the Git Staging View via the menu Window → Show View → Other → Git → Git Staging.

Mark all files which have changed on drag them into the Staged Changes area.

Write a descriptive commmit message and press the Commit button which is hightlighted in the following screenshot.

Now the first version of your Java project is under version control.

Change the System.out.println message in your GitTest class.

package de.vogella.git.first; 
public class GitTest { 
  public static void main(String[] args) { 
    System.out.println("Git is cool"); 
  }
} 

Drag the file which you have changed into the Staged Changes area, write a good commit message and press the commit button.

This change will now be in your local Git repository.

Open the Git repository view via the following menu entries: Window → Show View → Other → Git → Git Staging.

Select your project, right click on it and select Show in → History to see the timeline of changes.

If you select a commit you see the commit message and the involved files.

Via right mouse click on an individual file you can compare this file with its ancestor (the commit before that) or with the current version in the workspace.

5. Commit messages

The commit message describes the changes done by a commit and is used as the first point of checking the history of a Git repository.

A commit message should therefore be descriptive and informative without repeating the code changes.

A commit message should have a header and a body. The header should be less than 50 characters and the body should wrap its text at 72 so that the commit messages is displayed well on the command line. The body should be separated by the header with an empty line.

The body should contain the reason why the change was made.

The commit message should be in present tense, e.g. "Add better error handling" instead of "Added better error handling".

The following can serve as an example for a commit message.

Short summary (less than 50 characters) Detailed explanation, if required, line break at around 72 characters more stuff to describe... 

6. Repository view

7. Clone existing project

8. Using EGit

Once you have placed a project under version control you can start using team operations on your project. The team operations are available via right mouse click on your project. You can:

EGit supports merging of branches to add the changes of one branch into another if this branch has not been changed. Select your project and Team → Merge to start the merge dialog.

If you pull in changes or merge a branch and you have conflicting changes, EGit will highlight the affected files. EGit also supports the resolution of these merge conflicts.

Right click on a file with merge conflicts and select Team → Merge Tool.

This opens a dialog, asking you which merge mode you would like to use. The easiest way to see the conflicting changes is to use the Use HEAD (the last local version) of conflicting files as merge mode. This way you see the original changes on the left side and the conflicting changes on the right side.

You can manually edit the text on the left side or use the Copy current change from right to left button to copy the conflicting changes from right to left.

Once you have manually merged the changes, select Team → Add from the context menu of the resource to mark the conflicts as resolved and commit the merge resolution via Team → Commit.

Git amend allows to adjust the last commit. For example you can change the commit message. The Git Staging view allows to perform the Git amend command via the the highlighted button in the following screenshot.

8.5. View the resource history

Select a resource and select Show in (Alt+Shift+W) -> History to see the commit history of this resource.

9. Branching

Git allows you to create branches, e.g. independent copies of the source code which can be changed independently from each other. The default branch is called master.

Git allows you to create branches very fast and cheaply in terms of resource consumption. Developers are encouraged to use branches frequently.

Right-click your project and select Team → Branch to create new branches or to switch between existing branches.

10. Git repository for multiple projects

Eclipse allows to work with projects which are not included in the workspace.

To put several Eclipse projects into the same Git repository you can create a folder inside or outside your workspace and create the projects inside this folder. You can create a Git repository for this folder and all projects in this folder will be handled by the same repository. The best practice is to put the Git repository outsite of the Eclipse workspace.

You can import these projects into your workspace via File → Import → Git → Projects from Git

To add a new Eclipse project to an existing Git repository, select the project, right click on it and selectTeam → Share → Git and select the existing Git repository.

EGit moves the projects to the repository and imports the project automatically into your workspace.

11. Tutorial: Create Git repository for multiple projects

12. Using EGit with Github

Github is a popular hosting provider for Git projects and if you repository is public to everyone Github hosting is free. To use GitHub create an account on the Github Website. During the sign-up you will be asked to provide a "passphase". This "passphase" is later needed to push to Github from your local repository.

Create a new repository on Github, e.g. "de.vogella.git.github".

After creation of your new repository Github tells you what to do if you would inport via the command line. As we are going to use EGit we can ignore this information.

Create a new project "de.vogella.git.github" and put it under version control. Right-mouse click on your project and select "Team" -> "Push". A dialog pops up. Maintain the following data. Adjust the hightlighted line so that you are using your user and your project name.

git+ssh://git@github.com/vogella/de.vogella.git.github 

Maintain your passphase which you maintained during the Github setup.

Select your branch (you should currently only have master if you followed my tutorial), press "Add all branches spec" and select next.

Press finish.

If you now select your github Dashboard and then your project you should see the commited files.

Use the same URI you use to push to Github to clone the project into another workspace.

13. Mylyn integration with Github

14. Hacking EGit - Getting the source code