Git...

• System for distributed, decentralized version control
• Facilitates collaboration and non-linear development
• Each "clone" repository is complete - full history, logs, etc.
• Every "clone" is a backup
• Can access via command line or GUI

Distributed version control?

• Compare changes to files over time.
• Keep a backup of earlier versions of files.
• Revert to earlier versions of files.
• Safely experiment.

Version control systems track changes to a file or files over time. This means you can:

Decentralized...

Decentralized...

Understanding Git

Repository

• The data structure Git uses to record everything 
• Stored in the same directory as the project itself, in a hidden .git subdirectory
• Once a repository is initialized, Git will track all changes in the project directory

Also called a 'repo'

Commit

• The files themselves 
• The directory structure
• A commit object (the tree, the parent commit hash, the author and date of the commit, the commit message)
• A SHA key - a 40 character string that uniquely identifies the commit.

A snapshot of the state of a project at a point in time. It includes:

Remote

Collaborating with others (and managing your own code/files on GitHub) involves managing these remote repositories - 'pushing' and 'pulling' code from your machine to and from these remotes.

A remote repository, or 'remote', is a version of your project stored on the internet, or a network, or anywhere other than your machine, to which your local repo is linked. This remote repository is often named 'origin.'

Three Git States

• Modified: You've made changes to files or the directory, but haven't staged them yet.
• Staged: Git takes a snapshot of the modified files and places them in a 'staging area' to be included in the next commit. 
• Committed: Git takes the snapshots of the files in the staging area and commits them to the repository.

Working spaces...

Remote

Local

Upstream

Repository

Local

Repository

Index

(Staging)

Workspace

Stash

Working with branches is good!  Branches allow you to work away from the main line of development.

Branches

Let's learn some Git commands!

git init

Initialize a new local git repository

$ git init starfish
Initialized empty Git repository in /Users/kirschbombe/Sites/
starfish/.git/
$ 

git add

Add a file to the staging area

$ git add rays.txt

OR

$ git add .

git commit

Add files from the staging area to your local repository

$ git commit -m "add rays.txt"
[master (root-commit) f9d6e54] add rays.txt
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 rays.txt
$

git status

Shows the current status of your repository files (unstaged & staged)

$ git status
On branch master

Initial commit

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)

	new file:   rays.txt

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

	test.txt

$ 

rm & mv

$ git rm my-first-file
rm 'my-first-file'

$ git status
On branch my-new-feature
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	deleted:    my-first-file

$ git mv my-first-file other-name

$ git status
On branch my-new-feature
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

	renamed:    my-first-file -> other-name

$ git log
commit 5e31a9080c7f0a9b0390cd7dd2aa8e59a28a7328
Author: Yves Laroche <yves.laroche@logicnow.com>
Date:   Tue Feb 2 20:02:08 2016 +0000

    My first commit

# Short
$ git log --oneline
5e31a90 My first commit

# Limit number of commits
$ git log -10
$ git log --since=1.week
$ git log --after='2016-01-10'

git log

History of commits sent to the repository

$ cat starfish/.gitignore
# Ignore modules, themes, vendors
/core
/modules
/themes
/vendor

# Ignore config files
sites/*/settings*.php
sites/*/services*.yml

# Ignora private files
sites/*/files
sites/*/private

.gitignore

Files that git should ignore

Git workflow

Working with branches

git branch

List, create, name, and delete branches.

$ git branch develop

Create a new branch named develop

$ git branch
  develop
* master

List all branches

git checkout

Switch to another branch, like the one we just created using git branch

$ git checkout develop
Switched to branch 'develop'

$ 

git checkout -b

Create and switch to a new branch. 

$ git checkout -b feature
Switched to a new branch 'feature'
$

The same as git branch feature + git checkout feature

git merge

Merge one branch into another

$ git checkout master

To merge the branch "feature" into the branch "master":

$ git merge --no-ff feature

GitHub...

• Cloud-based git repository hosting service
• Free for public repositories
• Features: documentation, bug tracking, task management and other collaboration tools
• gh-pages for hosting web content

Create repository

It's easy to create a new repo in GitHub. There are two options:

Create a new project in GitHub

 ~ OR ~

Create a new repo in GitHub as the remote for an existing local project

Fork an existing repo

Forking a repo results in a clone of someone else's repo in your GitHub account. The two remain connected, so you can pull from 'upstream' or send 'pull requests' to the upstream repo. 

Origin

Your 'fork' of the original repository. A clone of the original repository that lives on GitHub.

Upstream

The original repository (if applicable)

The local repository on your computer will usually have (at least) two remotes: an origin and an upstream.

Pull request

Pull requests send a message to the 'upstream' asking to merge changes from your repo into theirs. This give the repo owner control over what changes will be accepted, while allowing others to contribute.

Remote repositories

Remotes

• Remote repo that is synched with our local repo
• Necessary for working collaboratively
• Push/pull the data from the remote repo to the local repo

Local

Remote (origin)

pull

push

Remember the working spaces...

Remote

Local

Upstream

Repository

Local

Repository

Index

(Staging)

Workspace

Stash

git clone

Create a copy of a git repo

$ git clone git@git.bcash.com.br/bcash/api.git

git push

Push commits from local repo to remote repo

$ git push origin master

git fetch

Downloads the objects and refs (branches & tags) from the remote to the local repo

Fetch does not merge the new commits from the remote.

$ git fetch origin

git pull

Imports remote commits to local repo and merges into working directory

$ git pull

git pull is the same as:

$ git fetch origin
$ git merge

git push

Push commits from local repo to the remote

$ git push origin master

git remote

Specifies a remote for your local repo to track.

$ git remote add origin https://git.bcash.com.br/fabio.nowaki/teste.git

With no arguments, it will show a list of existing remotes.

$ git remote
origin
$