Book Image

Mastering Git

5 (1)
Book Image

Mastering Git

5 (1)

Overview of this book

Git is one of the most popular types of Source Code Management (SCM) and Distributed Version Control System (DVCS). Despite the powerful and versatile nature of the tool enveloping strong support for nonlinear development and the ability to handle large projects efficiently, it is a complex tool and often regarded as “user-unfriendly”. Getting to know the ideas and concepts behind the architecture of Git will help you make full use of its power and understand its behavior. Learning the best practices and recommended workflows should help you to avoid problems and ensure trouble-free development. The book scope is meticulously designed to help you gain deeper insights into Git's architecture, its underlying concepts, behavior, and best practices. Mastering Git starts with a quick implementation example of using Git for a collaborative development of a sample project to establish the foundation knowledge of Git operational tasks and concepts. Furthermore, as you progress through the book, the tutorials provide detailed descriptions of various areas of usage: from archaeology, through managing your own work, to working with other developers. This book also helps augment your understanding to examine and explore project history, create and manage your contributions, set up repositories and branches for collaboration in centralized and distributed version control, integrate work from other developers, customize and extend Git, and recover from repository errors. By exploring advanced Git practices, you will attain a deeper understanding of Git’s behavior, allowing you to customize and extend existing recipes and write your own.
Table of Contents (19 chapters)
Mastering Git
Credits
About the Author
About the Reviewer
www.PacktPub.com
Preface
Index

Index

A

  • 34ac2 branching point / Branch points
  • ancestry references / Ancestry references
  • annotated tag / Creating a tag
  • annotated tags
    • about / Branches and tags, Annotated tags
  • anonymous Git protocol
    • about / Anonymous Git protocol
  • attribute macros
    • defining / Defining attribute macros
  • author
    • versus committer / Predefined and user defined output formats
  • authors
    • mapping / Summarizing contributions

B

  • bare repositories
    • about / Bare repositories
  • binary files
    • identifying / Identifying binary files and end-of-line conversions
  • blame command
    • about / Blame – the line-wise history of a file
  • Blob object
    • about / Git objects
  • branch
    • about / Branches and tags
    • rewinding / Discarding changes and rewinding branch
  • branch, rebasing
    • about / Rebasing a branch
    • merge, versus rebase / Merge versus rebase
    • types of rebase / Types of rebase
    • advanced rebasing techniques / Advanced rebasing techniques
  • branch changes
    • discarding / Discarding changes and rewinding branch
  • branches
    • creating / Creating a new branch
    • merging / Merging a branch (no conflicts)
    • unpublished merge, undoing / Undoing an unpublished merge
    • working with / Working with branches
    • new branch, creating / Creating a new branch
    • orphan branches, creating / Creating orphan branches
    • selecting / Selecting and switching to a branch
    • switching / Selecting and switching to a branch
    • obstacles, switching to / Obstacles to switching to a branch
    • anonymous branches / Anonymous branches
    • Git checkout DWIM-mery / Git checkout DWIM-mery
    • listing / Listing branches
    • rewinding / Rewinding or resetting a branch
    • resetting / Rewinding or resetting a branch
    • deleting / Deleting a branch
    • branch name, changing / Changing the branch name
    • about / Types and purposes of branches
    • types / Types and purposes of branches
    • purposes / Types and purposes of branches
    • long-lived branches / Long-running, perpetual branches
    • short-lived branches / Short-lived branches
    • workflows / Branching workflows and release engineering
    • release engineering / Branching workflows and release engineering
  • branches, interacting in remote repositories
    • about / Interacting with branches in remote repositories
    • upstream / Upstream and downstream
    • downstream / Upstream and downstream
    • refspec / Remote-tracking branches and refspec, Refspec – remote to local branch mapping specification
    • remote-tracking branches / Remote-tracking branches
    • fetching and pulling, versus pushing / Fetching and pulling versus pushing
    • current branches, fetching / Pull – fetch and update current branch
    • current branches, updating / Pull – fetch and update current branch
    • current branches, pushing in nonbare remote repository / Pushing to the current branch in a nonbare remote repository
    • default fetch refspec / The default fetch refspec and push modes
    • push modes / The default fetch refspec and push modes, Push modes and their use
    • fetching tags / Fetching and pushing branches and tags, Fetching tags and automatic tag following
    • fetching branches / Fetching branches
    • automatic tag following / Fetching tags and automatic tag following
    • pushing branches / Pushing branches and tags
    • pushing tags / Pushing branches and tags
  • branches, merging
    • about / Merging branches
    • no divergence / No divergence – fast-forward and up-to-date cases
    • merge commit, creating / Creating a merge commit
    • merge strategies / Merge strategies and their options
    • merge drivers / Reminder – merge drivers
    • merges, signing / Reminder – signing merges and merging tags
    • tags, merging / Reminder – signing merges and merging tags
  • branch head / Working with branches
    • rewinding / Rewinding the branch head, softly
    • resetting / Resetting the branch head and the index
  • branching workflow
    • Bugfix / Deciding what to base your work on
    • new feature / Deciding what to base your work on
  • branch operation
    • about / Branches and tags
  • branch points
    • about / Branch points
  • branch references
    • about / Branch and tag references
  • bugs
    • finding, with git bisect / Finding bugs with git bisect
  • built-in attributes
    • about / Other built-in attributes
  • bundle
    • about / Offline transport with bundles
    • used, for updating existing repository / Using bundle to update an existing repository
    • utilizing / Utilizing bundle to help with the initial clone

C

  • carriage return (CR) character / Formatting and whitespace
  • centralized workflow
    • about / The centralized workflow, Pushing to a public repository
    • advantages / The centralized workflow
    • disadvantages / The centralized workflow
  • changes
    • searching, in revision / Searching changes in revisions
    • including / Including, formatting, and summing up changes
    • formatting / Including, formatting, and summing up changes
    • summing up / Including, formatting, and summing up changes
    • stashing away / Stashing away your changes
    • integrating / Integrating changes
    • submitting / Submitting and describing changes
    • describing / Submitting and describing changes
    • peer review, completing / The art of the change review
  • changes, combining
    • methods / Methods of combining changes
  • changeset
    • copying / Copying and applying a changeset
    • applying / Copying and applying a changeset
    • copy, creating / Cherry-pick – creating a copy of a changeset
    • revert / Revert – undoing an effect of a commit
    • series of commits, applying from patches / Applying a series of commits from patches
    • cherry-picking / Cherry-picking and reverting a merge
    • merge, reverting / Cherry-picking and reverting a merge
  • changes examining, commit
    • about / Examining the changes to be committed
    • working directory, status / The status of the working directory
    • changes to be committed / The status of the working directory
    • changes not staged for commit / The status of the working directory
    • untracked files / The status of the working directory
    • differences, examining / Examining differences from the last revision
    • unified diff output format / Unified Git diff format
  • changes upstream
    • publishing / Publishing your changes upstream
  • child / Directed Acyclic Graphs
  • chunk
    • about / Configuring diff output
  • client-side hooks
    • about / Automating Git with hooks
    • commit process hooks / Commit process hooks
    • for applying patches from e-mails / Hooks for applying patches from e-mails
    • pre-rebase hook / Other client-side hooks
    • pre-push hook / Other client-side hooks
    • post-checkout hook / Other client-side hooks
    • post-merge hook / Other client-side hooks
  • code review (code collaboration) tool
    • about / Tools to manage Git repositories
  • collaborative workflows
    • about / Collaborative workflows
    • centralized workflow / The centralized workflow
    • peer-to-peer workflow / The peer-to-peer or forking workflow
    • integration-manager workflow / The maintainer or integration manager workflow
    • hierarchical workflow / The hierarchical or dictator and lieutenants workflows
  • combined diff format / Examining differences – the combined diff format
  • command line
    • about / Git on the command line
  • command substitution / Triple-dot notation
  • comments
    • responding to / Responding to reviews and comments
  • commit
    • creating / Creating a new commit
    • DAG view / The DAG view of creating a new commit
    • index / The index – a staging area for commits
    • changes, examining / Examining the changes to be committed
    • selective commit / Selective commit
    • amending / Amending a commit, Removing or amending a commit
    • removing / Removing or amending a commit
    • splitting, with reset command / Splitting a commit with reset
    • reverting / Reverting a commit
    • faulty merge, reverting / Reverting a faulty merge
    • reverted merges, recovering / Recovering from reverted merges
  • commit-msg hook
    • about / Commit process hooks
  • commit contents
    • matching / Matching commit contents
  • commit object
    • about / Git objects
  • commit parents
    • about / Commit parents
  • commit process hooks
    • about / Commit process hooks
    • pre-commit hook / Commit process hooks
    • prepare-commit-msg hook / Commit process hooks
    • commit-msg hook / Commit process hooks
    • post-commit hook / Commit process hooks
  • commits
    • about / Directed Acyclic Graphs
    • squashing, with reset command / Squashing commits with reset
    • moving, to feature branch / Moving commits to a feature branch
  • committer
    • versus author / Predefined and user defined output formats
  • commit tools
    • about / Types of graphical tools
  • commit walker downloader / Local transport
  • Common Vulnerabilities and Exposures (CVE) / Matching commit contents
    • about / Writing a good commit message
  • content-addressed storage / Content-addressed storage
  • contributions
    • summarizing / Summarizing contributions
  • Coordinated Universal Time (UTC)
    • about / Git objects
  • credential helpers
    • about / Credential helpers
  • credentials
    • about / Credentials/password management
  • credentials/password management
    • about / Credentials/password management
    • asking for password / Asking for passwords
    • public key authentication, for SSH / Public key authentication for SSH
    • credential helpers / Credential helpers
  • credentials helpers
    • about / Credential helpers and remote helpers
  • current push mode
    • about / The current push mode for the blessed repository workflow

D

  • data recovery
    • about / Data recovery and troubleshooting
    • lost commit, recovering / Recovering a lost commit
  • default branch
    • setting, of remote / Setting the default branch of remote
  • detached HEAD situation
    • about / Branches and tags
  • development workflows
    • augmenting / Augmenting development workflows
  • diff
    • revision range notation, using in / Triple-dot notation
  • diff configuration
    • about / Diff and merge configuration
  • diffing binary files / Generating diffs and binary files
  • diff output
    • configuring / Configuring diff output
  • Directed Acyclic Graph (DAG)
    • about / Directed Acyclic Graphs
  • directed edges / Directed Acyclic Graphs
  • directed graph
    • about / Directed Acyclic Graphs
  • directories
    • examining / Examining files and directories
  • distributed version control systems / An introduction to version control and Git
  • distributed version control systems (DVCS)
    • about / Directed Acyclic Graphs
  • double dot notation / Double dot notation
  • Do What I Mean (DWIM) / Git checkout DWIM-mery
  • do what I mean (DWIM)
    • about / Available filter types for filter-branch and their use
  • dumb protocols
    • about / Dumb protocols

E

  • Easy Git (eg) / Alternative command line
  • end-of-line conversions
    • identifying / Identifying binary files and end-of-line conversions
  • end of line (eol) characters / Identifying binary files and end-of-line conversions
  • environment variables
    • affecting global behavior / Environment variables affecting global behavior
    • affecting repository locations / Environment variables affecting repository locations
    • affecting committing / Environment variables affecting committing
  • external tools
    • for large-scale history rewriting / External tools for large-scale history rewriting

F

  • failed merges
    • examining / Examining failed merges
    • conflict markers, in worktree / Conflict markers in the worktree
    • three stages, in index / Three stages in the index
    • differences, examining / Examining differences – the combined diff format
    • git log / How do we get there: git log --merge
  • feature branch
    • commits, moving to / Moving commits to a feature branch
    • about / Working on a topic branch
  • file attributes
    • about / File attributes
  • file contents
    • searching / Searching file contents
  • file history
    • about / History of a file
    • path limiting / Path limiting
    • simplification / History simplification
  • file identity / Blame – the line-wise history of a file
  • file manager integration (or graphical shell integration)
    • about / Types of graphical tools
  • files
    • viewing, at revision / Viewing a revision and a file at revision
    • ignoring / Ignoring files, Which types of file should be ignored?
    • un-tracking / Ignoring files, Un-tracking, un-staging, and un-modifying files
    • re-tracking / Ignoring files
    • marking, as intentionally untracked (ignored) / Marking files as intentionally untracked
    • transforming / Transforming files (content filtering)
    • examining / Examining files and directories
    • un-staging / Un-tracking, un-staging, and un-modifying files
    • un-modifying / Un-tracking, un-staging, and un-modifying files
    • resetting, to old version / Resetting a file to the old version
    • removing from history, with BFG Repo Cleaner / Removing files from the history with BFG Repo Cleaner
  • Filesystem Hierarchy Standard (FHS) / Git configuration files
  • filter-branch
    • running, without filters / Running the filter-branch without filters
  • filters
    • about / Scripted rewrite with the git filter-branch
  • filter types
    • used, for filter-branch / Available filter types for filter-branch and their use
    • using / Available filter types for filter-branch and their use
  • foreign SCM repositories
    • using, as remotes / Using foreign SCM repositories as remotes

G

  • .gitignore templates
    • reference link / Which types of file should be ignored?
  • Gerrit
    • about / Other categories and uses of notes
  • Git
    • about / Branches and tags
    • environment variables, using / Environment variables used by Git
    • troubleshooting / Troubleshooting Git
  • Git, automating
    • about / Automating Git with hooks
    • Git hook, installing / Installing a Git hook
    • template, for repositories / A template for repositories
    • client-side hooks / Client-side hooks
    • server-side hooks / Server-side hooks
  • Git, extending
    • about / Extending Git
    • command aliases / Command aliases for Git
    • new commands, adding / Adding new Git commands
    • remote helpers / Credential helpers and remote helpers
    • credentials helpers / Credential helpers and remote helpers
  • Git, on command line
    • about / Git on the command line
    • Git-aware command prompt / Git-aware command prompt
    • command-line completion, for Git / Command-line completion for Git
    • auto correction, for Git commands / Autocorrection for Git commands
    • command line, customizing / Making the command line prettier
    • alternative porcelain / Alternative command line
  • Git-enforced policy
    • implementing, hooks used / Using hooks to implement the Git-enforced policy
    • enforcing, with server-side hooks / Enforcing the policy with server-side hooks
    • policy violations, notifying with client-side hooks / Early notices about policy violations with client-side hooks
  • Git-flow
    • about / Git-flow – a successful Git branching model
  • git-media tool
    • reference link / Obligatory file transformations
  • gitattributes / Unified Git diff format
  • Git attributes file
    • about / Per-file configuration with gitattributes
  • git bisect
    • bugs, finding with / Finding bugs with git bisect
  • Git by example / Git by example
  • Git configuration
    • about / Configuring Git
    • command-line options / Command-line options and environment variables
    • environment variables / Command-line options and environment variables
    • configuration files / Git configuration files
    • configuration files syntax / The syntax of Git configuration files
    • accessing / Accessing the Git configuration
    • basic client-side configuration / Basic client-side configuration
    • merge / The rebase and merge setup, configuring pull
    • pull, configuring / The rebase and merge setup, configuring pull
    • undo information, preserving / Preserving undo information – the expiry of objects
    • formatting / Formatting and whitespace
    • whitespace / Formatting and whitespace
    • server-side configuration / Server-side configuration
    • per-file configuration, with gitattributes / Per-file configuration with gitattributes
  • git filter-branch
    • using / Examples of using the git filter-branch
  • git filter-branch command
    • filter types, defining / Available filter types for filter-branch and their use
  • Git hook
    • installing / Installing a Git hook
  • Git hosting solutions
    • about / Tools to manage Git repositories
  • gitignore files
    • about / Marking files as intentionally untracked
  • gitignore templates
    • URL / Choosing which files to keep under version control
  • Git internals
    • defining / An introduction to Git internals
    • Git objects / Git objects
    • plumbing command / The plumbing and porcelain Git commands
    • porcelain command / The plumbing and porcelain Git commands
  • Git Queues(gq) / Alternative command line
  • Git Quilt (Guilt)
    • about / External tools – patch management interfaces
  • Git repositories
    • managing / Managing large Git repositories
    • hosting / Git on the server
    • server-side hooks / Server-side hooks
    • hooks, for implementing Git-enforced policy / Using hooks to implement the Git-enforced policy
    • signed pushes / Signed pushes
    • serving / Serving Git repositories
    • local protocol / Local protocol
    • SSH protocol / SSH protocol
    • anonymous Git protocol / Anonymous Git protocol
    • smart HTTP(S) protocol / Smart HTTP(S) protocol
    • dumb protocols / Dumb protocols
    • remote helpers / Remote helpers
    • tools, for managing / Tools to manage Git repositories
    • tips and tricks, for hosting / Tips and tricks for hosting repositories
  • Git repositories, handling with large binary files
    • about / Handling repositories with large binary files
    • binary asset folder, splitting into seperate submodule / Splitting the binary asset folder into a separate submodule
    • large binary files, storing outside repository / Storing large binary files outside the repository
  • Git repositories, handling with long history
    • about / Handling repositories with a very long history
    • shallow clones, using / Using shallow clones to get truncated history
    • single branch, cloning / Cloning only a single branch
  • Git repository management solutions
    • about / Tools to manage Git repositories
  • git stash
    • using / Using git stash
  • Git submodules solution
    • git submodule command / Gitlinks, .git files, and the git submodule command
    • .git files / Gitlinks, .git files, and the git submodule command
    • subproject, adding as submodule / Adding a subproject as a submodule
    • superprojects, cloning with submodules / Cloning superprojects with submodules
    • submodules, updating after superproject changes / Updating submodules after superproject changes
    • changes, examining in submodule / Examining changes in a submodule
    • updates, from upstream of submodule / Getting updates from the upstream of the submodule
    • submodule changes upstream, sending / Sending submodule changes upstream
  • GNU Portability Library (Gnulib) / Performing a 3-way merge
  • graduation branches workflow
    • about / The graduation, or progressive-stability branches workflow
  • graphical blame
    • about / Types of graphical tools
  • graphical history viewer
    • about / Types of graphical tools
  • graphical interface, Git
    • about / Graphical interfaces
    • graphical tools / Types of graphical tools
    • graphical diff tools / Graphical diff and merge tools
    • graphical merge tools / Graphical diff and merge tools
    • examples / Graphical interface examples
  • graphical tools
    • graphical history viewer / Types of graphical tools
    • graphical blame / Types of graphical tools
    • commit tools / Types of graphical tools

H

  • HEAD command
    • about / HEAD – the implicit revision
    • FETCH_HEAD / HEAD – the implicit revision
    • ORIG_HEAD / HEAD – the implicit revision
  • HEAD pointer
    • about / Branches and tags
  • helpers mechanism
    • about / Credential helpers and remote helpers
  • hierarchical workflow
    • about / The hierarchical or dictator and lieutenants workflows
    • advantages / The hierarchical or dictator and lieutenants workflows
    • disadvantages / The hierarchical or dictator and lieutenants workflows
  • history
    • searching / Searching history
    • rewriting / Rewriting history, Rewriting history and notes
    • last commit, amending / Amending the last commit
    • interactive rebase / An interactive rebase
  • history, without rewriting
    • amending / Amending history without rewriting
  • hook
    • about / Automating Git with hooks
    • client-side hooks / Automating Git with hooks
    • server-side hooks / Automating Git with hooks
    • pre hooks / Automating Git with hooks
    • post hooks / Automating Git with hooks

I

  • IDE integration
    • about / Types of graphical tools
  • ignored files
    • examining / Listing ignored files, Ignoringignored filesexamining changes in tracked files
  • ignore patterns / Adding files in bulk and removing files
  • index / The index – a staging area for commits
    • about / Ignoring files
    • resetting / Resetting the branch head and the index
  • information
    • updating, of remotes / Updating information about remotes
  • integration branches / The graduation, or progressive-stability branches workflow
  • integration manager workflow
    • about / The maintainer or integration manager workflow
    • advantages / The maintainer or integration manager workflow
    • disadvantages / The maintainer or integration manager workflow
  • interactive rebase / Amending a commit, Squashing commits with reset
    • about / An interactive rebase
    • commits, reordering / Reordering, removing, and fixing commits
    • commits, removing / Reordering, removing, and fixing commits
    • commits, fixing / Reordering, removing, and fixing commits
    • commits, squashing / Squashing commits
    • commits, splitting / Splitting commits
    • rebased commit, testing / Testing each rebased commit

K

  • keyword expansion / Keyword expansion and substitution
  • keyword substitution / Keyword expansion and substitution

L

  • leaf nodes / Directed Acyclic Graphs
  • lieutenants
    • about / The hierarchical or dictator and lieutenants workflows
  • lightweight tag
    • about / Lightweight tags
  • line-ending / Formatting and whitespace
  • list of branches
    • modifying, tracked by node / Changing the list of branches tracked by remote
  • local protocol
    • about / Local protocol
  • local transport
    • about / Local transport
  • long-lived branches
    • integration / Integration, graduation, or progressive-stability branches
    • graduation / Integration, graduation, or progressive-stability branches
    • progressive-stability / Integration, graduation, or progressive-stability branches
    • per-release branches / Per-release branches and per-release maintenance
    • per-release maintenance / Per-release branches and per-release maintenance
    • hotfix branches / Hotfix branches for security fixes
    • per-deployment branches / Per-customer or per-deployment branches
    • per-customer branches / Per-customer or per-deployment branches
    • automation branches / Automation branches
    • mob branches, for anonymous push access / Mob branches for anonymous push access
    • orphan branch trick / The orphan branch trick

M

  • maint branch / Branch points
  • management of remotes
    • about / Types of graphical tools
  • master branch / Branch points
  • matching push mode
    • about / The matching push mode for maintainers
  • merge
    • undoing / Undoing a merge or a pull
  • merge commits
    • about / Merge commits
  • merge configuration
    • about / Diff and merge configuration
  • merge conflict, resolving
    • about / Resolving a merge conflict
    • files, adding in bulk / Adding files in bulk and removing files
    • files, removing / Adding files in bulk and removing files
    • file changes, undoing / Undoing changes to a file
  • merge conflicts
    • resolving / Resolving merge conflicts
    • about / Resolving merge conflicts
    • three-way merge / The three-way merge
    • failed merges, examining / Examining failed merges
    • avoiding / Avoiding merge conflicts
    • merge options / Useful merge options
    • rerere (reuse recorded resolutions) / Rerere – reuse recorded resolutions
    • dealing with / Dealing with merge conflicts
    • merge, aborting / Aborting a merge
    • version, selecting / Selecting ours or theirs version
    • manual file remerging / Scriptable fixes – manual file remerging
    • scriptable fixes / Scriptable fixes – manual file remerging
    • graphical merge tools, using / Using graphical merge tools
    • files, marking as resolved / Marking files as resolved and finalizing merges
    • merges, finalizing / Marking files as resolved and finalizing merges
    • rebase conflicts, resolving / Resolving rebase conflicts
    • git-imerge / git-imerge – incremental merge and rebase for git
  • mixed reset / Resetting the branch head and the index
  • multiple working directories / Multiple working directories

N

  • native Git protocol
    • about / Native Git protocol
  • nodes
    • about / Directed Acyclic Graphs
  • nodes, DAG
    • root nodes / Directed Acyclic Graphs
    • leaf nodes / Directed Acyclic Graphs
  • notes
    • additional information, storing with / Storing additional information with notes
    • adding, to commit / Adding notes to a commit
    • storing / How notes are stored
    • using / Other categories and uses of notes
    • rewriting / Rewriting history and notes
    • publishing / Publishing and retrieving notes
    • retrieving / Publishing and retrieving notes
    • fetching / Publishing and retrieving notes
  • number of revisions
    • limiting / Limiting the number of revisions

O

  • obligatory file transformations
    • about / Obligatory file transformations
  • offline transport, with bundles
    • about / Offline transport with bundles
  • old version
    • files, resetting to / Resetting a file to the old version
  • OpenDocument Format (ODF) files / Transforming files (content filtering)
  • orphan branches / Directed Acyclic Graphs
  • output
    • selecting / Selecting and formatting the git log output
    • formatting / Selecting and formatting the git log output

P

  • parent / Directed Acyclic Graphs
  • patches
    • exchanging / Exchanging patches
  • patch management interfaces
    • defining / External tools – patch management interfaces
  • peer-to-peer workflow
    • about / The peer-to-peer or forking workflow
    • advantages / The peer-to-peer or forking workflow
    • disadvantages / The peer-to-peer or forking workflow
  • plumbing / Listing branches
  • plumbing command / The plumbing and porcelain Git commands
  • plumbing commands
    • versus porcelain commands / Listing ignored files
  • porcelain command / The plumbing and porcelain Git commands
  • porcelain commands
    • versus plumbing commands / Listing ignored files
  • Portable Object / Other built-in attributes
  • post-commit hook
    • about / Commit process hooks
  • post-receive hook
    • about / The post-receive hook
  • post-update hook
    • about / The post-update hook (legacy mechanism)
  • post hooks
    • about / Automating Git with hooks
  • pre-commit hook
    • about / Commit process hooks
  • pre-push hook
    • about / Other client-side hooks
  • pre-rebase hook
    • about / Other client-side hooks
  • pre-receive hook
    • about / The pre-receive hook
  • predefined revision formats
    • about / Predefined and user defined output formats
  • pre hooks
    • about / Automating Git with hooks
  • prepare-commit-msg hook
    • about / Commit process hooks
  • Pretty Good Privacy (PGP)
    • about / Other categories and uses of notes
  • problems
    • Wrong problem / The art of the change review
    • Does not work / The art of the change review
    • Fails best practices / The art of the change review
  • progressive-stability branches / The graduation, or progressive-stability branches workflow
  • progressive-stability branches workflow
    • about / The graduation, or progressive-stability branches workflow
  • project
    • starting / Starting a project
    • work, dividing into repositories / Dividing work into repositories
    • collaboration workflow, selecting / Selecting the collaboration workflow
    • generated files, tracking / Choosing which files to keep under version control
    • working / Working on a project
    • topic branch, working / Working on a topic branch
    • base, deciding / Deciding what to base your work on
    • changes, splitting into logically separate steps / Splitting changes into logically separate steps
    • good commit message, writing / Writing a good commit message
    • changes, preparing for submission / Preparing changes for submission
  • public key authentication
    • about / Public key authentication for SSH
  • public repository
    • pushing to / Pushing to a public repository
  • published history
    • rewriting / The perils of rewriting published history
    • consequences, of upstream rewrite / The consequences of upstream rewrite
    • upstream history rewrite, recovering / Recovering from an upstream history rewrite
  • pull
    • undoing / Undoing a merge or a pull
  • pull request
    • generating / Generating a pull request
  • push-to-update hook
    • about / Push-to-update hook for pushing to nonbare repositories
  • pushing
    • about / Pushing to a public repository
  • push modes
    • about / Push modes and their use
    • simple push mode / The simple push mode – the default
    • matching push mode / The matching push mode for maintainers
    • upstream push mode / The upstream push mode for the centralized workflow
    • current push mode / The current push mode for the blessed repository workflow

R

  • rebase
    • about / The consequences of upstream rewrite
  • recommendations
    • defining / Other recommendations
    • recovering possibility / Don't panic, recovery is almost always possible
    • published history, changing / Don't change the published history
    • releases, numbering / Numbering and tagging releases
    • releases, tagging / Numbering and tagging releases
    • automating / Automate what is possible
  • references (refs)
    • about / Branches and tags
  • reflog / An introduction to version control and Git
  • reflog shortnames / Reflog shortnames
  • refspec / Refspec – remote to local branch mapping specification
  • refspecs / Listing and examining remotes
  • release branches workflow
    • about / The release and trunk branches workflow
  • release candidates / The release and trunk branches workflow
  • remote
    • about / The origin remote
    • default branch, setting of / Setting the default branch of remote
  • remote-tracking branches
    • about / Branches and tags
    • upstreaming / Upstream of remote-tracking branches
  • remote Git repository
    • adding / Adding a new remote
  • remote helpers
    • about / Credential helpers and remote helpers, Remote helpers
  • remote repositories
    • managing / Managing remote repositories
  • remotes
    • about / Branches and tags
    • listing / Listing and examining remotes
    • examining / Listing and examining remotes
    • information, updating of / Updating information about remotes
    • renaming / Renaming remotes
    • foreign SCM repositories, using as / Using foreign SCM repositories as remotes
  • remote tracking branches
    • deleting / Deleting remote-tracking branches
  • remote transport helpers
    • about / Remote transport helpers
  • remote URLs
    • modifying / Changing the remote URLs
  • rename detection / Blame – the line-wise history of a file
  • rename tracking / Blame – the line-wise history of a file
  • replacements mechanism
    • using / Using the replacements mechanism
    • defining / The replacements mechanism
    • histories, joining with git replace / Example – joining histories with git replace
    • grafts, defining / Historical note – grafts
    • publishing / Publishing and retrieving replacements
    • retrieving / Publishing and retrieving replacements
  • repositories
    • interacting with / Interacting with other repositories
    • comparing / Environment variables affecting repository locations
  • repository
    • updating, bundle used / Using bundle to update an existing repository
  • repository history
    • editing, with reposurgeon / Editing the repository history with reposurgeon
  • repository maintenance
    • about / Repository maintenance
  • repository setup
    • about / Repository setup
    • Git repository, creating / Creating a Git repository
    • repository, cloning / Cloning the repository and creating the first commit
    • first commit, creating / Cloning the repository and creating the first commit
    • changes, publishing / Publishing changes, Examining history and viewing changes, Renaming and moving files
    • repository, updating / Updating your repository (with merge)
    • tag, creating / Creating a tag
  • reposurgeon
    • repository history, editing with / Editing the repository history with reposurgeon
  • repo tool
    • URL / Third-party subproject management solutions
  • Request For Comments (RFC)
    • about / Submitting and describing changes
  • reset command
    • about / Fixing mistakes with the reset command
    • commits, squashing with / Squashing commits with reset
    • commit, splitting with / Splitting a commit with reset
  • reverse ancestry references / Reverse ancestry references: the git describe output
  • review
    • responding to / Responding to reviews and comments
  • reviewer preferences
    • about / The art of the change review
  • revision
    • changes, saving in / Searching changes in revisions
    • viewing / Viewing a revision and a file at revision
  • revision metadata
    • matching / Matching revision metadata
  • revision range
    • selecting / Selecting the revision range
    • single revision, using as / Single revision as a revision range
    • for single revision / The revision range for a single revision
  • revision range notation
    • using, in diff / Triple-dot notation
  • revisions
    • including / Multiple points – including and excluding revisions
    • excluding / Multiple points – including and excluding revisions
  • root nodes / Directed Acyclic Graphs

S

  • safer reset
    • about / Safer reset – keeping your changes
    • changes, rebasing to earlier revision / Rebase changes to an earlier revision
  • scripted rewrite
    • used, with git filter-branch / Scripted rewrite with the git filter-branch
  • Secure Shell (SSH)
    • about / SSH protocol
  • selective commit
    • about / Selective commit
    • files, sending to / Selecting files to commit
    • changes, selecting interactively / Interactively selecting changes
    • creating step by step, with staging area / Creating a commit step by step
  • semantic versioning
    • URL / Numbering and tagging releases
  • server-side hooks
    • about / Automating Git with hooks, Server-side hooks, Server-side hooks
    • pre-receive hook / The pre-receive hook
    • push-to-update hook / Push-to-update hook for pushing to nonbare repositories
    • update hook / The update hook
    • post-receive hook / The post-receive hook
    • post-update hook / The post-update hook (legacy mechanism)
  • SHA-1 hash function / SHA-1 and the shortened SHA-1 identifier
  • shallow clone
    • about / Historical note – grafts
  • shell prompt / Git-aware command prompt
  • short-lived branches
    • about / Short-lived branches
    • feature branches / Topic or feature branches
    • topic branches / Topic or feature branches
    • bugfix branches / Bugfix branches
    • anonymous branches / Detached HEAD – the anonymous branch
  • shortened SHA-1 identifier / SHA-1 and the shortened SHA-1 identifier
  • signed commits
    • about / Signed commits
  • signed pushes
    • about / Signed pushes
  • signed tag / Creating a tag
    • verifying / Tag verification
  • signed tags
    • about / Branches and tags, Lightweight, annotated, and signed tags, Signed tags
    • merging / Merging signed tags (merge tags)
  • simple push mode
    • about / The simple push mode – the default
  • single revision
    • using, as revision range / Single revision as a revision range
  • single revision selection
    • about / Single revision selection
    • ancestry references / Ancestry references
    • by commit message / Selecting revision by the commit message
  • smart HTTP(S) protocol
    • about / Smart HTTP(S) protocol, Smart HTTP(S) protocol
  • smart transports
    • about / Smart transports
    • native Git protocol / Native Git protocol
    • SSH protocol / SSH protocol
    • smart HTTP(S) protocol / Smart HTTP(S) protocol
  • SSH protocol
    • about / SSH protocol
  • Stacked Git (StGit)
    • about / External tools – patch management interfaces
  • staging area
    • about / Stash and the staging area
    • managing / Managing worktrees and the staging area
  • stash
    • about / Stash and the staging area
    • un-applying / Un-applying a stash
  • stashes
    • recovering / Recovering stashes that were dropped erroneously
  • stash internals
    • about / Stash internals
  • state
    • saving, with WIP commit / Saving and restoring state with the WIP commit
    • restoring, with WIP commit / Saving and restoring state with the WIP commit
  • StGit / Amending a commit
  • subfolder
    • transforming, into subtree or submodule / Transforming a subfolder into a subtree or submodule
  • submodules
    • use cases / Use cases for submodules
  • subtrees
    • versus submodules / Subtrees versus submodules
    • use cases / Use cases for subtrees

T

  • tab completion / Command-line completion for Git
  • tag
    • about / Branches and tags
  • tag object
    • about / Branches and tags, Git objects
  • tag objects
    • about / Annotated tags, Git objects
  • tag operation
    • about / Branches and tags
  • tag references
    • about / Branch and tag references
  • tags
    • publishing / Publishing tags
  • third-party subproject management solutions / Third-party subproject management solutions
  • time-limiting options
    • about / Time-limiting options
  • tips and tricks, for hosting repositories
    • about / Tips and tricks for hosting repositories
    • size taken by repositories, reducing / Reducing the size taken by repositories
    • smart protocols, speeding up with pack bitmaps / Speeding up smart protocols with pack bitmaps
    • large nonresumable initial clone problem, solving / Solving the large nonresumable initial clone problem
  • topic branch
    • about / Working on a topic branch
  • topic branches workflow
    • about / The topic branches workflow
    • graduation branches / Graduation branches in a topic branch workflow
    • branch management / Branch management for a release in a topic branch workflow
  • tracked files
    • about / Ignoring files
  • tracking-related variables
    • GIT_TRACE / Troubleshooting Git
    • GIT_TRACE_PACKET / Troubleshooting Git
    • GIT_TRACE_SETUP / Troubleshooting Git
    • GIT_TRACE_PERFORMANCE / Troubleshooting Git
  • transport protocols
    • about / Transport protocols
    • local transport / Local transport
    • smart transports / Smart transports
    • offline transport with bundles / Offline transport with bundles
    • remote transport helpers / Remote transport helpers
  • transport relay
    • with remote helpers / Transport relay with remote helpers
  • tree object
    • about / Git objects
  • tree objects
    • about / Git objects
  • triangular workflows
    • about / Support for triangular workflows
  • triple dot notation / Triple-dot notation
  • troubleshooting, Git
    • about / Data recovery and troubleshooting, Troubleshooting Git
  • trunk / The release and trunk branches workflow
  • trunk branches workflow
    • about / The release and trunk branches workflow

U

  • update hook
    • about / The update hook
  • upstream push mode
    • about / The upstream push mode for the centralized workflow
  • user-defined revision formats
    • about / Predefined and user defined output formats

V

  • Version control system / An introduction to version control and Git
  • Version control system (VCS)
    • about / Directed Acyclic Graphs

W

  • 3-way merge
    • performing / Performing a 3-way merge
  • web interfaces
    • about / Tools to manage Git repositories
  • whitespace / Formatting and whitespace
  • whole-tree commits
    • about / Whole-tree commits
  • WIP commit
    • state, saving with / Saving and restoring state with the WIP commit
    • state, restoring with / Saving and restoring state with the WIP commit
  • workflows, branches
    • release ranches workflow / The release and trunk branches workflow
    • trunk branches workflow / The release and trunk branches workflow
    • graduation branches workflow / The graduation, or progressive-stability branches workflow
    • progressive-stability branches workflow / The graduation, or progressive-stability branches workflow
    • topic branches workflow / The topic branches workflow
    • Git-flow / Git-flow – a successful Git branching model
    • security issue, fixing / Fixing a security issue
  • working area
    • cleaning / Cleaning the working area
  • worktree
    • about / Ignoring files
  • worktrees
    • managing / Managing worktrees and the staging area