book

Git: Mastering Version Control

Name: Git: Mastering Version Control
ISBN: 9781787123205

by Ferdinando Santacroce, Aske Olsson, Rasmus Voss, Jakub Narębski

October 2016

Beginner

861 pages

20h 37m

English

Packt Publishing

Read now

Unlock full access

Git: Mastering Version Control
Table of Contents
Git: Mastering Version Control
Git: Mastering Version Control
Credits
Preface
What this learning path covers
What you need for this learning path
Who this learning path is for
Reader feedback
Customer support
Downloading the example codeErrataPiracyQuestions

I. Module 1
1. Getting Started with Git
Installing Git
Running our first Git command
Setting up a new repositoryAdding a fileCommit the added fileModify a committed file
Summary
2. Git Fundamentals – Working Locally
Repository structure and file status life cycleThe working directoryFile statusesThe staging areaUnstaging a fileThe time metaphorThe pastThe presentThe future
Working with repositories
Unstaging a file
Viewing the history
Anatomy of a commitThe commit snapshotThe commit hashAuthor, e-mail, and dateCommit messagesCommitting a bunch of filesIgnoring some files and folders by defaultHighlighting an important commit – Git tags
Taking another way – Git branching
Anatomy of branchesLooking at the current branchesCreating a new branchSwitching from branch to branchUnderstanding what happens under the hoodA bird's eye view to branchesTyping is boring – Git aliasesMerging branchesMerge is not the end of the branchExercisesExercise 2.1What you will learnScenarioResultsExercise 2.2What you will learnScenarioResultsDeal with branches' modificationsDiffing branchesUsing a visual diff toolResolving merge conflictsEdit collisionsResolving a removed file conflictKeeping the edited fileResolving conflicts by removing the file
Stashing
Summary
3. Git Fundamentals – Working Remotely
Working with remotesSetting up a new GitHub accountCloning a repositoryUploading modifications to remotesWhat do I send to the remote when I push?Pushing a new branch to the remoteThe originTracking branchesDownloading remote changesChecking for modifications and downloading themApplying downloaded changesGoing backward: publish a local repository to GitHubAdding a remote to a local repositoryPushing a local branch to a remote repositorySocial coding – collaborate using GitHubForking a repositorySubmitting pull requestsCreating a pull request
Summary
4. Git Fundamentals – Niche Concepts, Configurations, and Commands
Dissecting the Git configurationConfiguration architectureConfiguration levelsSystem levelGlobal levelRepository levelListing configurationsEditing configuration files manuallySetting up other environment configurationsBasic configurationsTypos autocorrectionPush defaultDefining the default editorOther configurations
Git aliases
Shortcuts to common commandsCreating commandsgit unstagegit undogit lastgit difflastAdvanced aliases with external commandsRemoving an aliasAliasing the git command itself
Git references
Symbolic referencesAncestry referencesThe first parentThe second parent
World-wide techniques
Changing the last commit messageTracing changes in a fileCherry picking
Tricks
Bare repositoriesConverting a regular repository to a bare oneBackup repositoriesArchiving the repositoryBundling the repository
Summary
5. Obtaining the Most – Good Commits and Workflows
The art of committingBuilding the right commitMake only one change per commitSplit up features and tasksWrite commit messages before starting to codeInclude the whole change in one commitDescribe the change, not what you have doneDon't be afraid to commitIsolate meaningless commitsThe perfect commit messageWriting a meaningful subjectAdding bulleted details lines, when neededTie other useful informationSpecial messages for releasesConclusions
Adopting a workflow – a wise act
Centralized workflowsHow they workFeature branch workflowGitFlowThe master branchHotfixes branchesThe develop branchThe release branchThe feature branchesConclusionThe GitHub flowAnything in the master branch is deployableCreating descriptive branches off of the masterPushing to named branches constantlyOpening a pull request at any timeMerging only after a pull request reviewDeploying immediately after reviewConclusionsOther workflowsThe Linux kernel workflow
Summary
6. Migrating to Git
Before startingPrerequisites
Working on a Subversion repository using Git
Creating a local Subversion repositoryChecking out the Subversion repository with svn clientCloning a Subversion repository from GitSetting up a local Subversion serverAdding a tag and a branchCommitting a file to Subversion using Git as a client
Using Git with a Subversion repository
Migrating a Subversion repository
Retrieving the list of Subversion usersCloning the Subversion repositoryPreserving the ignored file listPushing to a local bare Git repositoryArranging branches and tagsRenaming the trunk branch to masterConverting Subversion tags to Git tagsPushing the local repository to a remote
Comparing Git and Subversion commands
Summary
7. Git Resources
Git GUI clientsWindowsGit GUITortoiseGitGitHub for WindowsAtlassian SourceTreeCmderMac OS XLinux
Building up a personal Git server with web interface
The SCM Manager
Learning Git in a visual manner
Git on the Internet
Git community on Google+GitMinutes and Thomas Ferris Nicolaisen's blogFerdinando Santacroce's blog
Summary
II. Module 2
1. Navigating Git
Introduction
Git's objects
Getting readyHow to do it...The commit objectThe tree objectThe blob objectThe branchThe tag objectHow it works...There's more...See also
The three stages
Getting readyHow to do it…How it works…See also
Viewing the DAG
Getting readyHow to do it...How it works...See also
Extracting fixed issues
Getting readyHow to do it...How it works...There's more...
Getting a list of the changed files
Getting readyHow to do it...How it works...There's more...See also
Viewing history with Gitk
Getting readyHow to do it...How it works...There's more...
Finding commits in history
Getting readyHow to do it...How it works...There's more...
Searching through history code
Getting readyHow to do it...How it works...There's more...
2. Configuration
Configuration targetsGetting readyHow to do it...How it works...There's more...
Querying the existing configuration
Getting readyHow to do it...How it works...There's more...
Templates
Getting readyHow to do it...How it works...
A .git directory template
Getting readyHow to do it...How it works...See also
A few configuration examples
Getting readyHow to do it...Rebase and merge setupExpiry of objectsAutocorrectHow it works...There's more...
Git aliases
Getting readyHow to do it...How it works...There's more...
The refspec exemplified
Getting readyHow to do it...How it works...
3. Branching, Merging, and Options
Introduction
Managing your local branches
Getting readyHow to do it…How it works…There's more...
Branches with remotes
Getting readyHow to do it…There's more...
Forcing a merge commit
Getting readyHow to do it...There's more…
Using git rerere to merge known conflicts
How to do it…There's more...
The difference between branches
Getting readyHow to do it…There's more…
4. Rebase Regularly and Interactively, and Other Use Cases
Introduction
Rebasing commits to another branch
Getting readyHow to do it…How it works
Continuing a rebase with merge conflicts
How to do itHow it worksThere's more…
Rebasing selective commits interactively
Getting readyHow to do itThere's more…
Squashing commits using an interactive rebase
Getting readyHow to do it...There's more…
Changing the author of commits using a rebase
Getting readyHow to do it...How it works...
Auto-squashing commits
Getting readyHow to do it...There's more…
5. Storing Additional Information in Your Repository
Introduction
Adding your first Git note
Getting readyHow to do it…There's more...
Separating notes by category
Getting readyHow to do it...How it works...
Retrieving notes from the remote repository
Getting readyHow to do it...How it works...
Pushing notes to a remote repository
How to do it...There's more...
Tagging commits in the repository
Getting readyHow to do it...There's more...
6. Extracting Data from the Repository
Introduction
Extracting the top contributor
Getting readyHow to do it...There's more...
Finding bottlenecks in the source tree
Getting readyHow to do it...There's more...
Grepping the commit messages
Getting readyHow to do it...
The contents of the releases
How to do it...How it works...
7. Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts
Introduction
Using a branch description in the commit message
Getting readyHow to do it...
Creating a dynamic commit message template
Getting readyHow to do it...There's more...
Using external information in the commit message
Getting readyHow to do it...
Preventing the push of specific commits
Getting readyHow to do it...There's more...
Configuring and using Git aliases
How to do it...How it works...
Configuring and using Git scripts
How to do it...
Setting up and using a commit template
Getting readyHow to do it...
8. Recovering from Mistakes
Introduction
Undo – remove a commit completely
Getting readyHow to do it...How it works…
Undo – remove a commit and retain the changes to files
Getting readyHow to do it...How it works…
Undo – remove a commit and retain the changes in the staging area
Getting readyHow to do it...How it works…
Undo – working with a dirty area
Getting readyHow to do it...How it works…See also
Redo – recreate the latest commit with new changes
Getting readyHow to do it...How it works...There is more…
Revert – undo the changes introduced by a commit
Getting readyHow to do it...How it works...There's more...
Reverting a merge
Getting readyHow to do it...How it works...There is more...See also
Viewing past Git actions with git reflog
Getting readyHow to do it...How it works...
Finding lost changes with git fsck
Getting readyHow to do it...How it works...See also
9. Repository Maintenance
Introduction
Pruning remote branches
Getting readyHow to do it...How it works…There's more…
Running garbage collection manually
Getting readyHow to do it...How it works…
Turning off automatic garbage collection
Getting readyHow to do it...
Splitting a repository
Getting readyHow to do it...How it works…There's more…
Rewriting history – changing a single file
Getting readyHow to do it...How it works…
Back up your repositories as mirror repositories
Getting readyHow to do it...How it works…There's more…
A quick submodule how-to
Getting readyHow to do it...There's more…
Subtree merging
Getting readyHow to do it...How it works…See also
Submodule versus subtree merging
10. Patching and Offline Sharing
Introduction
Creating patches
Getting readyHow to do it...How it works…There's more…
Creating patches from branches
Getting readyHow to do it...How it works…There's more…
Applying patches
Getting readyHow to do it...How it works…There's more…
Sending patches
Getting readyHow to do it...How it works…There's more…
Creating Git bundles
Getting readyHow to do it...How it works…
Using a Git bundle
Getting readyHow to do it…There's more…
Creating archives from a tree
Getting readyHow to do it...There's more…
11. Git Plumbing and Attributes
Introduction
Displaying the repository information
Getting readyHow to do it...There's more…
Displaying the tree information
Getting readyHow to do it...
Displaying the file information
Getting readyHow to do it...There's more…
Writing a blob object to the database
Getting readyHow to do it...How it works…There's more…
Writing a tree object to the database
Getting readyHow to do it...How it works…
Writing a commit object to the database
Getting readyHow to do it...How it works…
Keyword expansion with attribute filters
Getting readyHow to do it...How it works…There's more…
Metadata diff of binary files
Getting readyHow to do it...How it works…There's more…
Storing binaries elsewhere
Getting readyHow to do it...How it works…There's more…See also
Checking the attributes of a file
Getting readyHow to do it...
Attributes to export an archive
Getting readyHow to do it...There's more…
12. Tips and Tricks
Introduction
Using git stash
Getting readyHow to do it...How it works…There's more…
Saving and applying stashes
Getting readyHow to do it...There's more…
Debugging with git bisect
Getting readyHow to do it...There's more…
Using the blame command
Getting readyHow to do it...There's more…
Color UI in the prompt
Getting readyHow to do it...There's more…
Autocompletion
Getting readyLinuxMacWindowsHow to do it...How it works…There's more…
Bash prompt with status information
Getting readyHow to do it...How it works…There's more…See also
More aliases
Getting readyHow to do it...
Interactive add
Getting readyHow to do it...There's more…
Interactive add with Git GUI
Getting readyHow to do it...
Ignoring files
Getting readyHow to do it...There's more…See also…
Showing and cleaning ignored files
Getting readyHow to do it...There's more…
III. Module 3
1. Git Basics in Practice
An introduction to version control and Git
Git by example
Repository setupCreating a Git repositoryCloning the repository and creating the first commitPublishing changesExamining history and viewing changesRenaming and moving filesUpdating your repository (with merge)Creating a tagResolving a merge conflictAdding files in bulk and removing filesUndoing changes to a fileCreating a new branchMerging a branch (no conflicts)Undoing an unpublished merge
Summary
2. Exploring Project History
Directed Acyclic GraphsWhole-tree commitsBranches and tagsBranch pointsMerge commits
Single revision selection
HEAD – the implicit revisionBranch and tag referencesSHA-1 and the shortened SHA-1 identifierAncestry referencesReverse ancestry references: the git describe outputReflog shortnamesUpstream of remote-tracking branchesSelecting revision by the commit message
Selecting the revision range
Single revision as a revision rangeDouble dot notationMultiple points – including and excluding revisionsThe revision range for a single revisionTriple-dot notation
Searching history
Limiting the number of revisionsMatching revision metadataTime-limiting optionsMatching commit contentsCommit parentsSearching changes in revisionsSelecting types of change
History of a file
Path limitingHistory simplificationBlame – the line-wise history of a file
Finding bugs with git bisect
Selecting and formatting the git log output
Predefined and user defined output formatsIncluding, formatting, and summing up changesSummarizing contributionsViewing a revision and a file at revision
Summary
3. Developing with Git
Creating a new commitThe DAG view of creating a new commitThe index – a staging area for commitsExamining the changes to be committedThe status of the working directoryExamining differences from the last revisionUnified Git diff formatSelective commitSelecting files to commitInteractively selecting changesCreating a commit step by stepAmending a commit
Working with branches
Creating a new branchCreating orphan branchesSelecting and switching to a branchObstacles to switching to a branchAnonymous branchesGit checkout DWIM-meryListing branchesRewinding or resetting a branchDeleting a branchChanging the branch name
Summary
4. Managing Your Worktree
Ignoring filesMarking files as intentionally untrackedWhich types of file should be ignored?Listing ignored filesIgnoring changes in tracked files
File attributes
Identifying binary files and end-of-line conversionsDiff and merge configurationGenerating diffs and binary filesConfiguring diff outputPerforming a 3-way mergeTransforming files (content filtering)Obligatory file transformationsKeyword expansion and substitutionOther built-in attributesDefining attribute macros
Fixing mistakes with the reset command
Rewinding the branch head, softlyRemoving or amending a commitSquashing commits with resetResetting the branch head and the indexSplitting a commit with resetSaving and restoring state with the WIP commitDiscarding changes and rewinding branchMoving commits to a feature branchUndoing a merge or a pullSafer reset – keeping your changesRebase changes to an earlier revision
Stashing away your changes
Using git stashStash and the staging areaStash internalsUn-applying a stashRecovering stashes that were dropped erroneously
Managing worktrees and the staging area
Examining files and directoriesSearching file contentsUn-tracking, un-staging, and un-modifying filesResetting a file to the old versionCleaning the working area
Multiple working directories
Summary
5. Collaborative Development with Git
Collaborative workflowsBare repositoriesInteracting with other repositoriesThe centralized workflowThe peer-to-peer or forking workflowThe maintainer or integration manager workflowThe hierarchical or dictator and lieutenants workflows
Managing remote repositories
The origin remoteListing and examining remotesAdding a new remoteUpdating information about remotesRenaming remotesChanging the remote URLsChanging the list of branches tracked by remoteSetting the default branch of remoteDeleting remote-tracking branchesSupport for triangular workflows
Transport protocols
Local transportSmart transportsNative Git protocolSSH protocolSmart HTTP(S) protocolOffline transport with bundlesCloning and updating with bundleUsing bundle to update an existing repositoryUtilizing bundle to help with the initial cloneRemote transport helpersTransport relay with remote helpersUsing foreign SCM repositories as remotesCredentials/password managementAsking for passwordsPublic key authentication for SSHCredential helpers
Publishing your changes upstream
Pushing to a public repositoryGenerating a pull requestExchanging patches
Chain of trust
Content-addressed storageLightweight, annotated, and signed tagsLightweight tagsAnnotated tagsSigned tagsPublishing tagsTag verificationSigned commitsMerging signed tags (merge tags)
Summary
6. Advanced Branching Techniques
Types and purposes of branchesLong-running, perpetual branchesIntegration, graduation, or progressive-stability branchesPer-release branches and per-release maintenanceHotfix branches for security fixesPer-customer or per-deployment branchesAutomation branchesMob branches for anonymous push accessThe orphan branch trickShort-lived branchesTopic or feature branchesBugfix branchesDetached HEAD – the anonymous branch
Branching workflows and release engineering
The release and trunk branches workflowThe graduation, or progressive-stability branches workflowThe topic branches workflowGraduation branches in a topic branch workflowBranch management for a release in a topic branch workflowGit-flow – a successful Git branching modelFixing a security issue
Interacting with branches in remote repositories
Upstream and downstreamRemote-tracking branches and refspecRemote-tracking branchesRefspec – remote to local branch mapping specificationFetching and pulling versus pushingPull – fetch and update current branchPushing to the current branch in a nonbare remote repositoryThe default fetch refspec and push modesFetching and pushing branches and tagsFetching branchesFetching tags and automatic tag followingPushing branches and tagsPush modes and their useThe simple push mode – the defaultThe matching push mode for maintainersThe upstream push mode for the centralized workflowThe current push mode for the blessed repository workflow
Summary
7. Merging Changes Together
Methods of combining changesMerging branchesNo divergence – fast-forward and up-to-date casesCreating a merge commitMerge strategies and their optionsReminder – merge driversReminder – signing merges and merging tagsCopying and applying a changesetCherry-pick – creating a copy of a changesetRevert – undoing an effect of a commitApplying a series of commits from patchesCherry-picking and reverting a mergeRebasing a branchMerge versus rebaseTypes of rebaseAdvanced rebasing techniques
Resolving merge conflicts
The three-way mergeExamining failed mergesConflict markers in the worktreeThree stages in the indexExamining differences – the combined diff formatHow do we get there: git log --mergeAvoiding merge conflictsUseful merge optionsRerere – reuse recorded resolutionsDealing with merge conflictsAborting a mergeSelecting ours or theirs versionScriptable fixes – manual file remergingUsing graphical merge toolsMarking files as resolved and finalizing mergesResolving rebase conflictsgit-imerge – incremental merge and rebase for git
Summary
8. Keeping History Clean
An introduction to Git internalsGit objectsThe plumbing and porcelain Git commandsEnvironment variables used by GitEnvironment variables affecting global behaviorEnvironment variables affecting repository locationsEnvironment variables affecting committing
Rewriting history
Amending the last commitAn interactive rebaseReordering, removing, and fixing commitsSquashing commitsSplitting commitsTesting each rebased commitExternal tools – patch management interfacesScripted rewrite with the git filter-branchRunning the filter-branch without filtersAvailable filter types for filter-branch and their useExamples of using the git filter-branchExternal tools for large-scale history rewritingRemoving files from the history with BFG Repo CleanerEditing the repository history with reposurgeonThe perils of rewriting published historyThe consequences of upstream rewriteRecovering from an upstream history rewrite
Amending history without rewriting
Reverting a commitReverting a faulty mergeRecovering from reverted mergesStoring additional information with notesAdding notes to a commitHow notes are storedOther categories and uses of notesRewriting history and notesPublishing and retrieving notesUsing the replacements mechanismThe replacements mechanismExample – joining histories with git replaceHistorical note – graftsPublishing and retrieving replacements
Summary
9. Managing Subprojects – Building a Living Framework
Managing library and framework dependenciesManaging dependencies outside GitManually importing the code into your projectA Git subtree for embedding the subproject codeCreating a remote for a subprojectAdding a subproject as a subtreeCloning and updating superprojects with subtreesGetting updates from subprojects with a subtree mergeShowing changes between a subtree and its upstreamSending changes to the upstream of a subtreeThe Git submodules solution: repository inside repositoryGitlinks, .git files, and the git submodule commandAdding a subproject as a submoduleCloning superprojects with submodulesUpdating submodules after superproject changesExamining changes in a submoduleGetting updates from the upstream of the submoduleSending submodule changes upstreamTransforming a subfolder into a subtree or submoduleSubtrees versus submodulesUse cases for subtreesUse cases for submodulesThird-party subproject management solutions
Managing large Git repositories
Handling repositories with a very long historyUsing shallow clones to get truncated historyCloning only a single branchHandling repositories with large binary filesSplitting the binary asset folder into a separate submoduleStoring large binary files outside the repository
Summary
10. Customizing and Extending Git
Git on the command lineGit-aware command promptCommand-line completion for GitAutocorrection for Git commandsMaking the command line prettierAlternative command line
Graphical interfaces
Types of graphical toolsGraphical diff and merge toolsGraphical interface examples
Configuring Git
Command-line options and environment variablesGit configuration filesThe syntax of Git configuration filesAccessing the Git configurationBasic client-side configurationThe rebase and merge setup, configuring pullPreserving undo information – the expiry of objectsFormatting and whitespaceServer-side configurationPer-file configuration with gitattributes
Automating Git with hooks
Installing a Git hookA template for repositoriesClient-side hooksCommit process hooksHooks for applying patches from e-mailsOther client-side hooksServer-side hooks
Extending Git
Command aliases for GitAdding new Git commandsCredential helpers and remote helpers
Summary
11. Git Administration
Repository maintenance
Data recovery and troubleshooting
Recovering a lost commitTroubleshooting Git
Git on the server
Server-side hooksThe pre-receive hookPush-to-update hook for pushing to nonbare repositoriesThe update hookThe post-receive hookThe post-update hook (legacy mechanism)Using hooks to implement the Git-enforced policyEnforcing the policy with server-side hooksEarly notices about policy violations with client-side hooksSigned pushesServing Git repositoriesLocal protocolSSH protocolAnonymous Git protocolSmart HTTP(S) protocolDumb protocolsRemote helpersTools to manage Git repositoriesTips and tricks for hosting repositoriesReducing the size taken by repositoriesSpeeding up smart protocols with pack bitmapsSolving the large nonresumable initial clone problem
Augmenting development workflows
Summary
12. Git Best Practices
Starting a projectDividing work into repositoriesSelecting the collaboration workflowChoosing which files to keep under version control
Working on a project
Working on a topic branchDeciding what to base your work onSplitting changes into logically separate stepsWriting a good commit messagePreparing changes for submission
Integrating changes
Submitting and describing changesThe art of the change reviewResponding to reviews and comments
Other recommendations
Don't panic, recovery is almost always possibleDon't change the published historyNumbering and tagging releasesAutomate what is possible
Summary
A. Bibliography
Index

Content preview from Git: Mastering Version Control

Applying patches

Now we know how to create patches from commits. It is time to learn to apply them.

Getting ready

We'll use the repository from the previous examples along with the generated patches as follows:

$ cd offline-sharing 
$ git checkout master
$ ls -1a
.
..
.git
Makefile
README.md
another_pi.c
latest-commit
math.c
not-on-master

How to do it...

First, we'll checkout the develop branch and apply the patch generated from the master branch (0001-Calculate-pi-with-more-digits.patch) in the first example. We use the Git command am to apply the patches; am is short for apply from mailbox:

$ git checkout develop
Your branch is up-to-date with 'origin/develop'.
$ git am latest-commit/0001-Calculate-pi-with-more-digits.patch
Applying: Calculate ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Git Version Control Cookbook - Second Edition

Publisher Resources

ISBN: 9781787123205

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills