Introduction to Git and GitHub

Git and GitHub

Don ProfOctober 01, 2020

Version Control Systems (VCS)

use the cat command to see the code

cat rearrange1.py

//use the diff command to see the difference

diff rearrange.1.py rearrange2.py

//use diff -u to see the unified form of the difference

diff -u validations1.py validations2.py

wdiff highligts the words that have changed in the file

>> meld

>>KDiff3

>>vimdiff

all these are graphical tools for difference

Applying Changes

diff -u old_file new_file>change.diff

This generates the difference into a file called change.diff

You can use patch to apply the changes

patch cpu_usage.py < cpu_usage.diff

Meaning it used the new files in the cpu_usage.diff and added it to the cpu_usage.py

VCS

Version Control System

Commit is making edits to multiple files and treat that collection of edits as a single change.

Files are organsied in repositories

Its stores histories of the code.

Git

Git can be used for;

  • Standalone program
  • As a Server
  • As a client

https://git-scm.com/

Source Control Management

Examples of vcs

Subverion

Mercurial

>>git --version //use cmd to check whether you have git installed on the computer.

On windows git comes with a file called MinGW64 already installed

you download git on windows from gitforwindows.org website

Git was developed by Linus Torvalds

Within a VCS, project files are organized in centralized locations called _____ where they can be called upon later. //repositories

Using Git

git config --global user.email "me@example.com"
git config --global user.name "My Name"

//this is to tell git who you are. it is like setting a user name for your git access.

$ git init //Create a repository 
or use
$ git clone //clone an old repository
---------------------------------------

$ mkdir checks //make a directory called checks
$ cd checks // change directory to checks
$ git init // initial a git repository

For linux the command is ls -la to list all hidden files

$ dir /a .git/

It is a database that stores your repository.

The area outside your .git is called the working tree. It is the current version of your project (sandbox).

Staging area (also called index): A file maintained by Git that contains all of the information about what files and changes are going to go into your next commit

$ cp ../disk_usage.py  //this would copy the py file to the directory  // for cmd use copy
$ ls -l //this is to list the files in the directory
git add disk_usage.py //this would add the py file to the staging area

$ git commit 

-----------------
for cmd
$ copy C:\Users\MediaAdmin\AndroidStudioProjects\MyDemo\app\src\main\java\com\example\mydemo

$ dir /a

$git add MyActivity.java

$ git commit

kjl;k

In windows to exit out of the commit interface.

//press esc
$:wq //to save write and quit
  • Git directory - contains history of all files and changes.
  • Working tree - contains the current state of the object.
  • Staging area - changes that have been marked to be included in the next commit

Modified state - Changes have been made but havent been commited yet

Staging state - the changes to those files are marked for tracking

Commit - The changes are made.

$git commit - m 'Added periods' //this one makes you write the notes for the commit right away.

How to write a commit message

The first line is the summary of the commit message <52 Characters

empty line

Full details < 72 characters

$ commit log`//used check commit history messages

Linux kernel documentation

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/Documentation/process/submitting-patches.rst?id=HEAD

http://stopwritingramblingcommitmessages.com/

https://robots.thoughtbot.com/5-useful-tips-for-a-better-commit-message

https://help.github.com/articles/setting-your-email-in-git/

https://help.github.com/articles/keeping-your-email-address-private/

Graded assessment

Install Git

Before you install Git on your Linux VM, you need to first make sure that you have a fresh index of the packages available to you. To do that, run:

sudo apt update
content_copy

Now, you can install Git on your Linux host using apt by running the following command:

sudo apt install git
content_copy

For any prompts, continue by clicking Y.

Check the installed version of git by using the command below:

git --version
content_copy

Click Check my progress to verify the objective.

Initialize a new repository

Create a directory to store your project in. To do this, use the following command:

mkdir my-git-repo
content_copy

Now navigate to the directory you created.

cd my-git-repo
content_copy

Next, initialize a new repository by using the following command:

git init
content_copy

The git init command creates a new Git repository. In our case, it transformed the current directory into a Git repository. It can also be used to convert an existing, unversioned project to a Git repository or to initialize a new, empty repository.

Executing git init creates a .git subdirectory in the current working directory, which contains all of the necessary Git metadata for the new repository. This metadata includes subdirectories for objects, refs, and template files. A HEAD file is also created which points to the currently checked out commit.

If you've already run git init on a project directory containing a .git subdirectory, you can safely run git init again on the same project directory. The operation is what we call idempotent; running it again doesn't override an existing .git configuration.

Configure Git

Git uses a username to associate commits with an identity. It does this by using the git config command. To set Git username use the following command:

git config --global user.name "Name"
content_copy

Replace Name with your name. Any future commits you push to GitHub from the command line will now be represented by this name. You can use git config to even change the name associated with your Git commits. This will only affect future commits and won't change the name used for past commits.

Let's set your email address to associate it with your Git commits.

git config --global user.email "user@example.com"
content_copy

Replace user@example.com with your email-id. Any future commits you now push to GitHub will be associated with this email address. You can even use git config to change the user email associated with your Git commits.

Git Operations

Let's now create a text file named README. We will be using the nano editor for this.

nano README
content_copy

Type any text within the file, or you can use the following text:

This is my first repository.
content_copy

Save the file by pressing Ctrl-o, Enter key, and Ctrl-x.

Git is now aware of the files in the project. We can check the status using the following command:

git status
content_copy

This command displays the status of the working tree. It also shows changes that have been staged, changes that haven't been staged, and files that aren't tracked by Git.

5cf139a07416b65b.png

You can now see the file you created, README, under the section Untracked files. Git isn't tracking the files yet. To track the files, we have to commit these files by adding them to the staging area.

Now let's add the file to the staging area using the following command:

git add README
content_copy

This command adds changes from the working tree to the staging area i.e., it gathers and prepares files for Git before committing them. In other words, it updates the index with the current content found in the working tree to prepare the content that's staged for the next commit.

You can now view the status of the working tree using the command: git status. This now shows the file README in green i.e., the file is now in the staging area and yet to be committed.

60729e998d1fc32d.png

However, git add doesn't affect the repository in any serious way because changes are not actually recorded until you commit them.

Let's now commit the changes. A Git commit is equivalent to the term "Save".

Commit the changes using the following command:

git commit
content_copy

This now opens an editor, asking you to type a commit message. Every commit has an associated commit message. A commit message is a log message from the user describing the changes.

Enter the commit message of your choice or you can use the following text:

This is my first commit!
content_copy

Once you have entered the commit message, save it by pressing Ctrl-o and Enter key. To exit click Ctrl-x.

The git commit command captures a snapshot of the project's currently staged changes i.e., it stores the current contents of the index in a new commit along with the commit message.

Click Check my progress to verify the objective.

First commit

Check my progress

You have successfully committed your file!

Let's now re-edit the file again to understand the process better. Open the file README using nano editor.

nano README
content_copy

Now add another line of description for your repository below the earlier entered line. Add the description of your choice or you can use the following text:

A repository is a location where all the files of a particular project are stored.
content_copy

Save and exit the editor by pressing Ctrl-o, Enter key, and Ctrl-x.

Now, let's repeat the previous process. As mentioned earlier, you can always check the status of your repository by using:

git status
content_copy

To understand the difference, compare with the earlier scenario where you added the new file to the repository.

6c368d6fe0393c80.png

Git tracks the changes and displays that the file has been modified. You can view the changes made to file using the following command:

git diff README
content_copy

You can see the differences between the older file and the new file. New additions are denoted by green-colored text and a + sign at the start of the line. Any replacements/removal are denoted by text in red-colored text and a - sign at the start of the line.

Now, we will add these changes to the staging area.

git add README
content_copy

View the status of the repository using the following command:

git status
content_copy

Git now shows the same file in green-colored text. This means the changes are staged and ready to be committed.

Let's commit the file now by entering the commit message with the command itself, unlike the previous commit.

git commit -m "This is my second commit."
content_copy

The command git commit with -m flag takes the commit message, too. This is different to the command without flag, where you had to type the commit message within the editor. If multiple -m flags are given to the command, it concatenates the values as separate paragraphs.

To view all the commits use the following command:

git log
content_copy

Git log command shows the commit history of the repository. It shows all the commits on the repository represented by a unique commit ID at the top of each commit. It also shows the author, date, and time and the commit message associated with the commits.

You also have various options to limit the output of this command. The output can be filtered based on the last number of commits, author, commit message, etc.

Click Check my progress to verify the objective.

Second commit

Check my progress

Congratulations!

Congrats! You've successfully installed the Git, initialized a repository, and performed basic Git operations. Now that you know how to do this, it will be easier for you and your team to work on a huge project with multiple functionalities and modules.

End your lab

When you have completed your lab, click End Lab. Qwiklabs removes the resources you’ve used and cleans the account for you.

You will be given an opportunity to rate the lab experience. Select the applicable number of stars, type a comment, and then click Submit.

The number of stars indicates the following:

  • 1 star = Very dissatisfied
  • 2 stars = Dissatisfied
  • 3 stars = Neutral
  • 4 stars = Satisfied
  • 5 stars = Very satisfied

You can close the dialog box if you don't want to provide feedback.

For feedback, suggestions, or corrections, please use the Support tab.

21/11/2020

git commit -a //a shortcut to stage any changes to tracked files and commit them in one step

//It doesnt work on new files.

$cd scripts
$atom all_checks.py
$git commit -a -m "Call check_reboot from main`, exit with 1 on error"
//This would commit directly together with -m

head is the point to the current branch

git -p // the -p is from patch

git show //displays info about the commit and the associated patch.

and the key.

git log --stat //it would show some stats in the commit

git diff //it to show the difference in the lines. show only unstaged changes by default
git add -p //this would add the patch
git diff --staged // changes that are staged, but not committed.

git rm //this is to remove/delete a file

git mv [old name] [new name] //to rename or move a file

.gitignore //This is a gitignore file

23/11/2020

git checkout //to change a file back to its former state... before it is staged.

with the -p // you can go through the previous ones.

it is also effectively used to switch branches.

git reset //to change a file that has already been staged.

git commit --amend //it overwrites the previous commit --use it in private repository

touch //command in linux to create a file

git revert HEAD //for a rollback

git log -p -2 //-p is for the patch -2 limits the output to the last 2 entries

The id names is called a Hash which is calculated using an algorithm called the SHA1

The id's are composed of 40 characters

git show [id] //you can just use the starting of the id too

24/11/2020

Explore repository

There is a Git repository named food-scripts consisting of a couple of food-related Python scripts.

Navigate to the repository using the following command:

cd ~/food-scripts
content_copy

Now, list the files using the ls command. There are three files named favorite_foods.log, food_count.py, and food_question.py.

75dd0326f2eee979.png

Let's explore each file. Use the cat command to view each file.

  1. favorite_foods.log: This file consists of a list of food items. You can view it using the following command:
cat favorite_foods.log
content_copy

Output:

47403089d228e2c1.png
  1. food_count.py: This script returns a list of each food and the number of times the food appeared in the favorite_foods.log file.

Let's execute the script food_count.py:

./food_count.py
content_copy

Output:

1c36a02d5ebaef5d.png
  1. food_question.py: This prints a list of foods and prompts the user to enter one of those foods as their favorite. It then returns an answer of how many others in the list like that same food.

Run the following command to see the output of food_question.py script:

./food_question.py
content_copy

Output:

5079d715c2f97126.png

Uh oh , this gives us an error. One of your colleagues reports that this script was working fine until the most recent commit. We'll be fixing this error later during the lab.

Understanding the repository

Let's use the following Git operations to understand the workflow of the repository:

  • git status
  • git log
  • git branch

Git status: This displays paths that have differences between the index file and the current HEAD commit; paths that have differences between the working tree and the index file; and paths in the working tree that are not tracked by Git. You can view the status of the working tree using the command: [git status]

git status
content_copy

You can now view the status of the working tree.

Git log: This lists the commits done in the repository in reverse chronological order; that is, the most recent commits show up first. This command lists each commit with its SHA-1 checksum, the author's name and email, date, and the commit message.

You can see logs by using the following command:

git log
content_copy

Output:

37aaa3162a88b121.png

Enter q to exit.

Git branch: Branches are a part of the everyday development process on the master branch. Git branches effectively function as a pointer to a snapshot of your changes. When you want to add a new feature or fix a bug, no matter how big or small, you spawn a new branch to encapsulate your changes. This makes it difficult for unstable code to get merged into the main codebase.

Configure Git

Before we move forward with the lab, let's configure Git. Git uses a username to associate commits with an identity. It does this by using the git config command. Set the Git username with the following command:

git config user.name "Name"
content_copy

Replace Name with your name. Any future commits you push to GitHub from the command line will now be represented by this name. You can even use git config to change the name associated with your Git commits. This will only affect future commits and won't change the name used for past commits.

Let's set your email address to associate them with your Git commits.

git config user.email "user@example.com"
content_copy

Replace user@example.com with your email-id. Any future commits you now push to GitHub will be associated with this email address. You can also use git config to change the user email associated with your Git commits.

Add a new feature

In this section, we'll be modifying the repository to add a new feature, without affecting the current iteration. This new feature is designed to improve the food count (from the file food_count.py) output. So, create a branch named improve-output using the following command:

git branch improve-output
content_copy

Move to the improve-output branch from the master branch.

git checkout improve-output
content_copy

Here, you can modify the script file without disturbing the existing code. Once modified and tested, you can update the master branch with a working code.

Now, open food_count.py in the nano editor using the following command:

nano food_count.py
content_copy

Add the line below before printing for loop in the food_count.py script:

print("Favourite foods, from most popular to least popular")
content_copy

Save the file by pressing Ctrl-o, the Enter key, and Ctrl-x. Then run the script food_count.py again to see the output:

./food_count.py
content_copy

Output:

food_count_output.png

After running the food_count.py script successfully, commit the changes from the improve-output branch by adding this script to the staging area using the following command:

git add food_count.py
content_copy

Now, commit the changes you've done in the improve-output branch.

git commit -m "Adding a line in the output describing the utility of food_count.py script"
content_copy

Output:

12899198fa08815f.png

Click Check my progress to verify the objective.

Add a feature

Check my progress

Fix the script

In this section, we'll fix the script food_question.py, which displayed an error when executing it. You can run the file again to view the error.

./food_question.py
content_copy

Output:

5079d715c2f97126.png

This script gives us the error: "NameError: name 'item' is not defined" but your colleague says that the file was running fine before the most recent commit they did.

In this case, we'll revert back the previous commit.

For this, check the git log history so that you can revert back to the commit where it was working fine.

git log
content_copy

Output:

e89b58d398338a9d.png

Here, you'll see the commits in reverse chronological order and find the commit having "Rename item variable to food_item" as a commit message. Make sure to note the commit ID for this particular commit.

Enter q to exit.

To revert, use the following command:

git revert [commit-ID]
content_copy

Replace [commit-ID] with the commit ID you noted earlier.

This creates a new commit again. You can continue with the default commit message on the screen or add your own commit message.

Then continue by clicking Ctrl-o, the Enter key, and Ctrl-x.

Now, run food_question.py again and verify that it's working as intended.

./food_question.py
content_copy

Output:

cedea93d17157044.png

Merge operation

Before merging the branch improve-output, switch to the master branch from the current branch improve-output branch using the command below:

git checkout master
content_copy

Merge the branch improve-output into the master branch.

git merge improve-output
content_copy

Output:

f1ea7fd1a1500f03.png

Now, all your changes made in the improve-output branch are on the master branch.

./food_question.py
content_copy

Output:

5216220ceb4627f1.png

To get the status from the master branch, use the command below:

git status
content_copy

Output:

c18b4c4d4dd08623.png

To track the git commit logs, use the following command:

git log
content_copy

Output:

b78661eaf4c93cf1.png

Click Check my progress to verify the objective.

Revert changes

Check my progress

Congratulations!

In this lab, you successfully created a branch from the master branch to add a new feature. You also rolled back a commit to where the script worked fine, and then merged it to the master branch. This will help as you work with colleagues who are simultaneously on the same repository.

10/12/2020

Forking and detect function behavior

For this exercise, you need to fork an existing repository: google/it-cert-automation-practice.

  • Open Github. If you don't already have a Github account, create one by entering a username, email, and password. If you already have a Github account proceed to the next step.
  • Log in to your account from the Github login page.

A fork is a copy of a repository. Forking a repository allows you to freely experiment with changes without affecting the original project.

Forking a repository is a simple two-step process. We've created a repository for you to practice with!

That's it! Now, you have a fork of the original google/it-cert-automation-practice repository.

First, clone the repository using the following command:

git clone https://github.com/[git-username]/it-cert-automation-practice.git
content_copy

Note: If you enabled two-factor authentication in your Github account you won't be able to push via HTTPS using your account’s password. Instead you need to generate a personal access token. This can be done in the application settings of your Github account. Using this token as your password should allow you to push to your remote repository via HTTPS. Use your username as usual. Note down this personal access token as we would need it further in the lab. For more help to generate a personal access token, click here.

Output:

Go to the it-cert-automation-practice directory using the following command:

cd ~/it-cert-automation-practice
content_copy

First, verify that you have already setup a remote for the upstream repository, and an origin.Type the following command and press Enter. You'll see the current configured remote repository for your fork.

git remote -v
content_copy

Output:

In terms of source control, you're "downstream" when you copy (clone, checkout, etc) from a repository. Information is flowed "downstream" to you.

When you make changes, you usually want to send them back "upstream" so they make it into that repository so that everyone pulling from the same source is working with all the same changes. This is mostly a social issue of how everyone can coordinate their work rather than a technical requirement of source control. You want to get your changes into the main project so you're not tracking divergent lines of development.

Setting the upstream for a fork you have created using the following command:

git remote add upstream https://github.com/[git-username]/it-cert-automation-practice.git
content_copy

To verify the new upstream repository you've specified for your fork, type git remote -v again. You should see the URL for your fork as origin, and the URL for the original repository as upstream.

git remote -v
content_copy

Output:

Configure Git

Git uses a username to associate commits with an identity. It does this by using the git config command. Set the Git username with the following command:

git config --global user.name "Name"
content_copy

Replace Name with your name. Any future commits you push to GitHub from the command line will now be represented by this name. You can even use git config to change the name associated with your Git commits. This will only affect future commits and won't change the name used for past commits.

Let's set your email address to associate them with your Git commits.

git config --global user.email "user@example.com"
content_copy

Replace user@example.com with your email-id. Any future commits you now push to GitHub will be associated with this email address. You can also use git config to change the user email associated with your Git commits.

Fix the script

In this section we are going to fix an issue that has been filed. Navigate to the issue, and have a look at it.

Branches allow you to add new features or test out ideas without putting your main project at risk. In order to add new changes into the repo directory it-cert-automation-practice/Course3/Lab4/, create a new branch named improve-username-behavior in your forked repository using the following command:

git branch improve-username-behavior
content_copy

Go to the improve-username-behavior branch from the master branch.

git checkout improve-username-behavior
content_copy

Now, navigate to the working directory Lab4/.

cd ~/it-cert-automation-practice/Course3/Lab4
content_copy

List the files in directory Lab4.

ls
content_copy

Output:

Now, open the validations.py script.

cat validations.py
content_copy

Output:

This script should validate usernames if they start with an letter only.

Here, you can check the validate_user function's behavior by calling the function. To edit the validations.py Python script, open it in a nano editor using the following command:

nano validations.py
content_copy

Now, add the following lines of code at the end of the script:

print(validate_user("blue.kale", 3)) # True
print(validate_user(".blue.kale", 3)) # Currently True, should be False
print(validate_user("red_quinoa", 4)) # True
print(validate_user("_red_quinoa", 4)) # Currently True, should be False
content_copy

Once you've finished writing this script, save the file by pressing Ctrl-o, the Enter key, and Ctrl-x.

Now, run the validations.py on the python3 interpreter.

python3 validations.py
content_copy

Output:

Here, as we see the output, it function returns true even if the username doesnot start with an letter. Here we need to change the check of the first character as only letters are allowed in the first character of the username.

Continue by opening validations.py in the nano editor using the following command:

nano validations.py
content_copy

There are lots of ways to fix the code; ultimately, you'll want to add additional conditional checks to validate the first character doesn't start with either of the forbidden characters. You can choose whichever way you'd like to implement this.

Once you've finished writing this script, save the file by pressing Ctrl-o, the Enter key, and Ctrl-x.

Now, run the validations.py.

python3 validations.py
content_copy

Output:

Now, you've fixed the function behavior!

Commit the changes

Once the issue is fixed and verified, create a new commit by adding the file to the staging area. You can check the status using the following command:

git status
content_copy

The git status command shows the different states of the files in your working directory and staging area, like files that are modified but unstaged and files that are staged but not yet committed.

You can now see that the validations.py has been modified.

Now, let's add the file to the staging area using the following command:

git add validations.py
content_copy

Use the git add command to add content from the working directory into the staging area for the next commit.

git status
content_copy

Output:

Let's now commit the changes. A git commit is like saving your work.

Commit the changes using the following command:

git commit
content_copy

This now opens up an editor that asks you to type a commit message. Every commit has an associated commit message, which is a log message from the user describing the changes.

Enter a commit message of your choice and append a line: "Closes: #1" at the beginning to indicate that you're closing the issue. Adding this keyword has an additional effect when using Github to manage your repos, which will automatically close the issue for you (for more information, please see the documentation here).

Closes: #1
Updated validations.py python script.
Fixed the behavior of validate_user function in validations.py.
content_copy

Once you've entered the commit message, save it by pressing Ctrl-o and the Enter key. To exit, click Ctrl-x.

Output:

Push changes

You forked a repository and made changes to the fork. Now you can ask that the upstream repository accept your changes by creating a pull request. Now, let's push the changes.

git push origin improve-username-behavior
content_copy

Note: If you have enabled two-factor authentication in your Github account, use the personal access token generated earlier during the lab as the password. If you have not noted down the personal access token earlier, go to your Github homepage > Settings > Developer settings > Personal access tokens. Now click on the token you generated earlier and click 'Regenerate token'. Use your username as usual.

Output:

Then, from GitHub, create a pull request from your forked repository [git-username]/it-cert-automation-practice that includes a description of your change. Your branch improve-username-behavior is now able to merge into the master branch. It should look like the image below:

After initializing a pull request, you'll see a review page that shows a high-level overview of the changes between your branch (the compare branch) and the repository's base branch. You can add a summary of the proposed changes, review the changes made by commits, add labels, milestones, and assignees, and @mention individual contributors or teams.

Once you've created a pull request, you can push commits from your topic branch to add them to your existing pull request. These commits will appear in chronological order within your pull request and the changes will be visible in the "Files changed" tab.

Other contributors can review your proposed changes, add review comments, contribute to the pull request discussion, and even add commits to the pull request.

You can see information about the branch's current deployment status and past deployment activity on the "Conversation" tab.

Note: PR won't be merged on the master branch so that other users can also make a similar change to fix the issue.