Git log¶

No options: reverse chronological order. Automatically piped to pager.

Rarely used with no options.

git log --stat – shows files that participted in each commit. Commit hash, author, date, files, +/- for lines per change.

Extremely tedius to page our way back through changes.

Milestone marker for class: if we stopped now, you should have a pretty good basic workflow for getting around day-to-day.

More advanced usage:

``git log --diff-filter=A`` -- Same filters as ``git diff``

git log --pretty=raw – raw, full, fuller, and even custom with sprintf

git log -3 – limits number of commits to 3 in this case.

git log --author=evan@wiredrive.com – all commits authored by me.

git log --author=Evan – all commits by me by using my name.

Ignoring Files¶

Flat text file called .gitignore

Per project: in project root

Example:

*.log
*.tmp

Ignores all files with .log and .tmp exensions.

Note git status -u – show me all files, don’t simplify, lists out all files below folders.

Applies, at evaluation time in memory.

You can add .gitignore files to subfolders, behave like .gitconfig:

Top has weakest precidence, bottom has highest precidence.

They’re evaluated as if concatenated end-to-end.

.gitignore can exist in any number of directories and subdirectories with no limit.

Git does not track empty directories.

How do you track empty directories? “holding it open with a toothpick.”

Usually the easiest way is to touch a .gitignore in that directory.

Preconfigured .gitignore files: https://github.com/github/gitignore

System-wide?

git config --global core.excudesfile "~/.gitignore"

Have to enable, can’t just create the file.

Removing Files¶

Closure to the add command

Basis for refactoring and renaming

rm <filename>

git rm <filename> – put deletion into staging, if file doensn’t exist, just adds deletion to staging area

example::

rm <files> git add -u .

git add -u grabs all removed files.

git rm <fileame> removes the file and stages that file.

If you want it back:

git reset --hard – we’ll come back to this, but it returns everything that is tracked to their last committed state. Blows away everything that’s staged.

note: untracked files are untouched.

There is no move primitive in git.

git mv <src> <dst> – a ‘composed’ command for convenience.

Same as:

``mv <src> <dst> ; git add <dst>``

Rename flagged as soon as file is re-added. Git is good at detecting similar content.

There’s a pretty funny discussion on the git mailinglist as to why there is no move primitive. Might be worth a look. (See slides).

git log --stat -M – shows renames in history.

Mindset should be that no matter how accurate we are when committing to history, there’s always a chance that the committer has been mistaken at commit time. Just move it to the display layer.

Q: Can you set a threshold on the similarity filter? A: Yes, git log --stat -M90.

git log -2 --stat -C --find-copies-harder – Tells it to look harder for copy detection on top of rename detection.

This stuff can be used for the simplification of merges and is relevant for refactoring.

Questions¶

• Can you reset an individual file?

git checkout -- <filename>

git checkout HEAD -- source/

What’s the difference between

git checkout -- <filename>

and

git checkout HEAD -- <filename>

Nothing, HEAD is assumed.

• Other questions on collaboration, binaries and design...

Netork Interactions¶

Everything begins locally in git then layers on things like remotes and collaboration.

Almost all activities happen offline. Offline activities have to be pushed to remotes.

Exercises¶

Cloning and collaborating:

git clone https://githubstudents:students987@github.com/githubstudents/hellogitworld.git

git branch evanculver

git push -u – tells git to track it.

<BREAK>

Example of git’s speed by adding 3000 files and pushing them to remote.

After pushing, we can almost instantly get references to those files, but they’re just references.

git fetch origin git checkout thousands

When checking out, the state of the filesystem is being modified. By switching between the thousands branch and mine, > 3000 files are being created/destroyed

“Once mastered, the concepts of local, remote and upstream branches, the rest falls into place”

Local and remote live on your box.

Typing git fetch, your local cache is updated against what’s upstream or remote to you.

git fetch === git fetch origin

Creating a funky situation¶

git checkout -b evanculver2

<edit a particular line>

<add, commit>

git checkout -b evanculver

<edit same line as before>

<add, commit>

git merge evanculver2

EEEEK –> merge conflict

“Make the file appear as a logical combination of those two disparate pieces”

Pull requests and workflow¶

Pull requests aren’t limited to cross-repository merges. Pull requests make perfect sense within a single repository for forced code-review.

Rebase¶

Simulates members taking turns working? Actually not stupid, just sounds ridiculous.

Branching: you usually wait as long as possible to branch, and you try to get your changes merged back in as soon as possible (because your VCS sucks).

Rebasing rewrites history, keeps a consistent, straight history.

Merge commits become integration commits by layering merges on to the end via fast-forward (instead of merge made by recursive).

Fast-forward means that only one of the two branches changed since the branch occurred.

No merge commits are created.

git checkout feature/some-feature git rebase master

“Take all of the stuff in the feature branch, hibernate it, delete it, start it at the end of master then replay all of the work in the feature branch on master.”

“Rework your work so that it makes more sense for your team.”

git checkout feature/some-feature git rebase -i HEAD~5

“Rebase seems like a tool to replay history.”