Book Image

Git: Mastering Version Control

By : Aske Olsson, Jakub Narębski, Ferdinando Santacroce, Rasmus Voss
Book Image

Git: Mastering Version Control

By: Aske Olsson, Jakub Narębski, Ferdinando Santacroce, Rasmus Voss

Overview of this book

Git is one of the most popular types of Distributed Version Control System. Since its inception, it has attracted skilled developers due to its robust, powerful, and reliable features. Like most powerful tools, Git can be hard to approach for the newcomers. However, this learning path will help you overcome this fear and become adept at all the basic and advanced tasks in Git. This course starts with an introduction to version control systems before you delve deeply into the essentials of Git. This serves as a primer for the topics to follow such as branching and merging, creating and managing a GitHub personal repository, and fork and pull requests. You'll also learn how to migrate from SVN using Git tools or TortoiseGit and migrate from other VCSs, concluding with a collection of resources, links, and appendices. As you progress on to the next module, you will learn how you can automate the usual Git processes by utilizing the hook system built into Git. It also covers advanced repository management, including different options to rewrite the history of a Git repository before you discover how you can work offline with Git, how to track what is going on behind the scenes, and how to use the stash for different purposes. Moving forward, you will gain deeper insights into Git's architecture, its underlying concepts, behavior, and best practices. It gives 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. 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. This Learning Path is a blend of content, all packaged up keeping your journey in mind. It includes content from the following Packt products: • Git Essentials, Ferdinando Santacroce • Git Version Control Cookbook, Aske Olsson and Rasmus Voss • Mastering Git, Jakub Nar?bski

Related Content you might be interested in

Current Title:

Small book image
Git: Mastering Version Control
Aske Olsson | Jakub Narębski | Ferdinando Santacroce | Rasmus Voss
Oct, 2016 | 14 hours 21 minutes
No titles found
Table of Contents (36 chapters)
Git: Mastering Version Control
Git: Mastering Version Control
Credits
Credits
Preface
Preface
Free Chapter
1
Getting Started with Git
Getting Started with Git
Installing Git
Running our first Git command
Summary
2
Git Fundamentals – Working Locally
Git Fundamentals – Working Locally
Repository structure and file status life cycle
Working with repositories
Viewing the history
Taking another way – Git branching
Stashing
Summary
3
Git Fundamentals – Working Remotely
Git Fundamentals – Working Remotely
Working with remotes
Summary
4
Git Fundamentals – Niche Concepts, Configurations, and Commands
Git Fundamentals – Niche Concepts, Configurations, and Commands
Dissecting the Git configuration
Git aliases
Git references
World-wide techniques
Tricks
Summary
5
Obtaining the Most – Good Commits and Workflows
Obtaining the Most – Good Commits and Workflows
The art of committing
Adopting a workflow – a wise act
Summary
6
Migrating to Git
Migrating to Git
Before starting
Working on a Subversion repository using Git
Using Git with a Subversion repository
Migrating a Subversion repository
Comparing Git and Subversion commands
Summary
7
Git Resources
Git Resources
Git GUI clients
Building up a personal Git server with web interface
Learning Git in a visual manner
Git on the Internet
Summary
8
Navigating Git
Navigating Git
Introduction
Git's objects
The three stages
Viewing the DAG
Extracting fixed issues
Getting a list of the changed files
Viewing history with Gitk
Finding commits in history
Searching through history code
9
Configuration
Configuration
Configuration targets
Querying the existing configuration
Templates
A .git directory template
A few configuration examples
Git aliases
The refspec exemplified
10
Branching, Merging, and Options
Branching, Merging, and Options
Introduction
Managing your local branches
Branches with remotes
Forcing a merge commit
Using git rerere to merge known conflicts
The difference between branches
11
Rebase Regularly and Interactively, and Other Use Cases
Rebase Regularly and Interactively, and Other Use Cases
Introduction
Rebasing commits to another branch
Continuing a rebase with merge conflicts
Rebasing selective commits interactively
Squashing commits using an interactive rebase
Changing the author of commits using a rebase
Auto-squashing commits
12
Storing Additional Information in Your Repository
Storing Additional Information in Your Repository
Introduction
Adding your first Git note
Separating notes by category
Retrieving notes from the remote repository
Pushing notes to a remote repository
Tagging commits in the repository
13
Extracting Data from the Repository
Extracting Data from the Repository
Introduction
Extracting the top contributor
Finding bottlenecks in the source tree
Grepping the commit messages
The contents of the releases
14
Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts
Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts
Introduction
Using a branch description in the commit message
Creating a dynamic commit message template
Using external information in the commit message
Preventing the push of specific commits
Configuring and using Git aliases
Configuring and using Git scripts
Setting up and using a commit template
15
Recovering from Mistakes
Recovering from Mistakes
Introduction
Undo – remove a commit completely
Undo – remove a commit and retain the changes to files
Undo – remove a commit and retain the changes in the staging area
Undo – working with a dirty area
Redo – recreate the latest commit with new changes
Revert – undo the changes introduced by a commit
Reverting a merge
Viewing past Git actions with git reflog
Finding lost changes with git fsck
16
Repository Maintenance
Repository Maintenance
Introduction
Pruning remote branches
Running garbage collection manually
Turning off automatic garbage collection
Splitting a repository
Rewriting history – changing a single file
Back up your repositories as mirror repositories
A quick submodule how-to
Subtree merging
Submodule versus subtree merging
17
Patching and Offline Sharing
Patching and Offline Sharing
Introduction
Creating patches
Creating patches from branches
Applying patches
Sending patches
Creating Git bundles
Using a Git bundle
Creating archives from a tree
18
Git Plumbing and Attributes
Git Plumbing and Attributes
Introduction
Displaying the repository information
Displaying the tree information
Displaying the file information
Writing a blob object to the database
Writing a tree object to the database
Writing a commit object to the database
Keyword expansion with attribute filters
Metadata diff of binary files
Storing binaries elsewhere
Checking the attributes of a file
Attributes to export an archive
19
Tips and Tricks
Tips and Tricks
Introduction
Using git stash
Saving and applying stashes
Debugging with git bisect
Using the blame command
Color UI in the prompt
Autocompletion
Bash prompt with status information
More aliases
Interactive add
Interactive add with Git GUI
Ignoring files
Showing and cleaning ignored files
20
Git Basics in Practice
Git Basics in Practice
An introduction to version control and Git
Git by example
Summary
21
Exploring Project History
Exploring Project History
Directed Acyclic Graphs
Single revision selection
Selecting the revision range
Searching history
History of a file
Finding bugs with git bisect
Selecting and formatting the git log output
Summary
22
Developing with Git
Developing with Git
Creating a new commit
Working with branches
Summary
23
Managing Your Worktree
Managing Your Worktree
Ignoring files
File attributes
Fixing mistakes with the reset command
Stashing away your changes
Managing worktrees and the staging area
Multiple working directories
Summary
24
Collaborative Development with Git
Collaborative Development with Git
Collaborative workflows
Managing remote repositories
Transport protocols
Publishing your changes upstream
Chain of trust
Summary
25
Advanced Branching Techniques
Advanced Branching Techniques
Types and purposes of branches
Branching workflows and release engineering
Interacting with branches in remote repositories
Summary
26
Merging Changes Together
Merging Changes Together
Methods of combining changes
Resolving merge conflicts
Summary
27
Keeping History Clean
Keeping History Clean
An introduction to Git internals
Rewriting history
Amending history without rewriting
Summary
28
Managing Subprojects – Building a Living Framework
Managing Subprojects – Building a Living Framework
Managing library and framework dependencies
Managing large Git repositories
Summary
29
Customizing and Extending Git
Customizing and Extending Git
Git on the command line
Graphical interfaces
Configuring Git
Automating Git with hooks
Extending Git
Summary
30
Git Administration
Git Administration
Repository maintenance
Data recovery and troubleshooting
Git on the server
Augmenting development workflows
Summary
31
Git Best Practices
Git Best Practices
Starting a project
Working on a project
Integrating changes
Other recommendations
Summary
Bibliography
Bibliography
Index
Index

Rebasing commits to another branch

To start with, we are going to perform a very simple rebase where we will introduce a new file, commit this file, make a change to it, and then commit it again so that we end up with 2 new commits.

Getting ready

Before we start, we need a repository to work in. You can use a previous clone of jgit, but to get a close to identical output from the example, you can clone the jgit repository.

The jgit repository can be cloned as follows:

$ git clone https://git.eclipse.org/r/jgit/jgit chapter4
$ cd chapter4

How to do it…

We start by creating a local branch and then make two commits by performing the following steps; these are the commits that we want to rebase onto another branch:

  1. Check out a new branch, rebaseExample, that tracks origin/stable-3.1:

     $ git checkout -b rebaseExample --track origin/stable-3.1
Branch rebaseExample set up to track remote branch stable-  3.1  from origin.
Switched to a new branch 'rebaseExample'

  2. Make two commits on the rebaseExample...

Previous Section
End of Section 3
Next Section