1) GIT: Version Control ()

➢ Introduction

• What is Git

• About Version Control System and Types

• Difference between CVCS and DVCS

• A short history of GIT

• GIT Basics

• GIT Command Line

➢ Installing Git

• Installing on Linux

• Installing on Windows

• Initial setup

➢ Git Essentials

• Creating repository

• Cloning, check-in and committing

• Fetch pull and remote

• Branching

• Creating the Branches, switching the branches, merging the branches.

Hands On:

GIT Installation, Version Control, Working with remote repository

Version control allows you to record changes to a file or set of files over time enabling you to go back to a specific version if required. Git is a Distributed Version Control System. This means that instead of having a snapshot of the latest files, you have a complete mirror of the repository on your local machine. The repository keeps track of the changes, when they occurred and who by. Having the complete repository on your local machine reduces delays due to network traffic and enables you to continue working when disconnected.

Step 1 - Git Init

To store a directory under version control you need to create a repository. With Git you initialize a repository in the top-level directory for a project.

Task

As this is a new project, a new repository needs to be created. Use the git init command to create a repository.

Note:

After initializing a repository, a new hidden sub-directory called .git is created. This sub-directory contains the metadata that Git uses to store it's information. If you're interested in the details then use the command line to explore the contents.

Step 2 - Git Status

When a directory is part of a repository it is called a Working Directory. A working directory contains the latest downloaded version from the repository together with any changes that have yet to be committed. As you're working on a project, all changes are made in this working directory.

You can view which files have changed between your working directory and what's been previously committed to the repository using the command git status.

The output of this command is called the "working tree status".

Note : All files are "un-tracked" by Git until it's been told otherwise. The details of how is covered in the next step.

Step 3 - Git Add

To save, or commit, files into your Git repository you first need to add them to the staging area. Git has three areas, a working directory, a staging area and the repository itself. Users move, otherwise referred to as promote, changes from the working directory, to a staging area before committing them into the repository.

One of the key approaches with Git is that commits are focused, small and frequent. The staging area helps to maintain this workflow by allowing you to only promote certain files at a time instead of all the changes in your working directory.

Step 4 - Git Commit

Once a file has been added to the staging area it needs to be committed to the repository. The command git commit -m "commit message" moves files from staging to the repository and records the time/date, author and a commit message that can be used to add additional context and reasoning to the changes such as a bug report number.

Only changes added to the staging area will be committed, any files in the working directory that have not been staged will not be included.

Task

Use git commit -m "<commit message>" to commit the staged file.

Note:

Each commit is assigned a SHA-1 hash which enables you to refer back to the commit in other commands.

Step 5 - Git Ignore

Sometimes there are particular files or directories you never want to commit, such as local development configuration. To ignore these files you create a .gitignorefile in the root of the repository.

The .gitignore file allows you to define wildcards for the files you wish to ignore, for example *.tmp will ignore all files with the extension .tmp.

Any files matching a defined wildcard will not be displayed in a git status output and be ignored when attempting the git add command.

Task

Add and commit a .gitignore file to the repository to ignore all *.tmp files.

Protip

The .gitignore should be committed to the repository to ensure the rules apply across different machines.

Hands on :

GIT installation :

1. apt-get install git #### From Ubuntu Machine and apt-get is the package installation command

2. yum install git ##### From Redhat machine and yum is pacakage installation command.

3. download the git.exe ### From windows machine.

Create a folder # mkdir git-demo
Change directory # cd git-demo
Initialize the git # git init
Create a simple file named git1.txt # touch git1.txt
check the status now # git status

Untracked files:

(use "git add <file>..." to include in what will be committed)

git1.txt

Add the newly created file # git add .

Check the status of the file now #git status

Changes to be committed:

(use "git reset HEAD <file>..." to unstage)

new file: git1.txt

Save the file under git version control #git commit -m " my first git file"
git config --global user.email "01.anuj@gmail.com" ## give ur email id git to track.
git config --global user.name "Ranga" ## Give ur name git to track who is doing what.
git status ### check the status of the file (untracked or added )
git log ## to check the logs.
git commit -m " my first git file" ## Give meaningful messages.
git status
git log --oneline ## it will just display you the commit ID and messages.
git status
git log
git ls-files
touch git2.txt
git ls-files
git add .
git ls-files
git commit -m "my second commit"
git status
git remote add origin https://github.com/rkidambi11/gitdemo.git ## Add your Repo
git remote -v ## check on which remote repo you are currently.
git push -u origin master ## Push your local folder and file to remote Repo
git checkout -b newbranch
git branch
git push -u origin newbranch

Step 1 - Git Remote

Remote repositories allow you to share changes from or to your repository. Remote locations are generally a build server, a team members machine or a centralized store such as Github.com. Remotes are added using the git remote command with a friendly name and the remote location, typically a HTTPS URL or a SSH connection for example https://github.com/rkidambi11/gitdemo.git or git@github.com:rkidambi11/gitdemo.git

Step 2 - Git Push

When you're ready to share your commits you need to push them to a remote repository via git push. A typical Git workflow would be to perform multiple small commits as you complete a task and push to a remote at relevant points, such as when the task is complete, to ensure synchronisation of the code within the team.

The git push command is followed by two parameters. The first parameter is the friendly name of the remote repository we defined in the first step. The second parameter is the name of the branch. By default all git repositories have a master branch where the code is worked on.

Step 3 - Git Pull

Where git push allows you to push your changes to a remote repository, git pull works in the reverse fashion. git pull allows you to sync changes from a remote repository into your local version.

The changes from the remote repository are automatically merge into the branch you're currently working on.

Task

Pull the changes from the remote into your master branch.

Step 4 - Git Log

As described in the previous scenario you can use the git log command to see the history of the repository. The git show command will allow you to view the changes made in each commit.

In this example, the output from git logshows a new commit by "Ranga" with the message "Fix for Bug #1234". The output of git show highlights the new lines added to the file in green.

Step 5 - Git Fetch

The command git pull is a combination of two different commands, git fetch and git merge. Fetch downloads the changes from the remote repository into a separate branch named remotes/<remote-name>/<remote-branch-name>. The branch can be accessed using git checkout.

Using git fetch is a great way to review the changes without affecting your current branch. The naming format of branches is flexible enough that you can have multiple remotes and branches with the same name and easily switch between them.

Stash

Scenario :

Edit the file1.txt and add it

got to remote fil1.txt and edit it from remote.

come to gitbash and run below command

$ git pull origin master ---- >>> See the error

Please commit your changes or stash them before you merge

Paras@DESKTOP-7N7KERE MINGW64 ~/project (master)

$ git pull origin master

From https://github.com/rkidambi11/project

* branch master -> FETCH_HEAD

error: Your local changes to the following files would be overwritten by merge:

file4

Please commit your changes or stash them before you merge.

Aborting

Updating 63d9786..e5c9cef

Paras@DESKTOP-7N7KERE MINGW64 ~/project (master)

$ git push origin +master

Total 0 (delta 0), reused 0 (delta 0)

To https://github.com/rkidambi11/project.git

+ 8d08804...e5c9cef master -> master (forced update)

##########Problem Statement ###############

Three Developers are working in Aperture Technology co. . Their company want a better Source Code Management System,because the earlier tool had the tendency to save redundant code. Multiple Developers working simultaneously on same block of code also caused problems. You are Mike, and your manager has given you the task of moving the company’s code base to git and Github.

Action Items:

•Create a local git repository and move the entire code base to it.

•Create a new branch for a new feature you want to add to the application.

•Merge back the created branch with the master branch•Create a remote repository.

•Push the local repository to company’s remote repository

Link to download the code :

https://github.com/rkidambi11/Assignment_Git/blob/master/sample-project.zip

Solution:

Module 1 : Version Control -GIT

Move to your Source Code directory and initialize a git repo in that folder

Syntax: git init

2.Add all the files in the repository to the staging area

Syntax: git add .

3.Now commit these files to the local repository

Syntax: git commit

4. Create a new feature branch and switch to it

Syntax: git branch branchName git checkout branchName

5. Make the required changes to the source files and the do a git diff to check all the changes Syntax: git diff

6. Now add the changed files to the staging area

Syntax: git add fileName

OR git add .

7. Commit the changes

Syntax: git commit

8. Now switch back to master and merge the feature branch back into master

Syntax: git merge branchName

9. Now, create a remote repository on you Github account.

10. Add the remote repository to you local repo.

Syntax: git remote add origin repoURL

11. Push the local repository onto the remote Repository

Syntax: git push -u origin master