Git: Mastering Version Control

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

Git: Mastering Version Control

Git: Mastering Version Control

Credits

Preface

Free Chapter

Getting Started with Git

Getting Started with Git

Running our first Git command

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

Git Fundamentals – Working Remotely

Git Fundamentals – Working Remotely

Working with remotes

Git Fundamentals – Niche Concepts, Configurations, and Commands

Git Fundamentals – Niche Concepts, Configurations, and Commands

Dissecting the Git configuration

World-wide techniques

Obtaining the Most – Good Commits and Workflows

Obtaining the Most – Good Commits and Workflows

The art of committing

Adopting a workflow – a wise act

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

Git Resources

Git GUI clients

Building up a personal Git server with web interface

Learning Git in a visual manner

Git on the Internet

Navigating Git

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

Configuration

Configuration targets

Querying the existing configuration

A .git directory template

A few configuration examples

The refspec exemplified

Branching, Merging, and Options

Branching, Merging, and Options

Managing your local branches

Branches with remotes

Forcing a merge commit

Using git rerere to merge known conflicts

The difference between branches

Rebase Regularly and Interactively, and Other Use Cases

Rebase Regularly and Interactively, and Other Use Cases

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

Storing Additional Information in Your Repository

Storing Additional Information in Your Repository

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

Extracting Data from the Repository

Extracting Data from the Repository

Extracting the top contributor

Finding bottlenecks in the source tree

Grepping the commit messages

The contents of the releases

Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts

Enhancing Your Daily Work with Git Hooks, Aliases, and Scripts

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

Recovering from Mistakes

Recovering from Mistakes

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

Repository Maintenance

Repository Maintenance

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

Patching and Offline Sharing

Patching and Offline Sharing

Creating patches

Creating patches from branches

Applying patches

Sending patches

Creating Git bundles

Using a Git bundle

Creating archives from a tree

Git Plumbing and Attributes

Git Plumbing and Attributes

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

Tips and Tricks

Tips and Tricks

Using git stash

Saving and applying stashes

Debugging with git bisect

Using the blame command

Color UI in the prompt

Bash prompt with status information

Interactive add

Interactive add with Git GUI

Showing and cleaning ignored files

Git Basics in Practice

Git Basics in Practice

An introduction to version control and Git

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

Developing with Git

Developing with Git

Creating a new commit

Working with branches

Managing Your Worktree

Managing Your Worktree

File attributes

Fixing mistakes with the reset command

Stashing away your changes

Managing worktrees and the staging area

Multiple working directories

Collaborative Development with Git

Collaborative Development with Git

Collaborative workflows

Managing remote repositories

Transport protocols

Publishing your changes upstream

Advanced Branching Techniques

Advanced Branching Techniques

Types and purposes of branches

Branching workflows and release engineering

Interacting with branches in remote repositories

Merging Changes Together

Merging Changes Together

Methods of combining changes

Resolving merge conflicts

Keeping History Clean

Keeping History Clean

An introduction to Git internals

Rewriting history

Amending history without rewriting

Managing Subprojects – Building a Living Framework

Managing Subprojects – Building a Living Framework

Managing library and framework dependencies

Managing large Git repositories

Customizing and Extending Git

Customizing and Extending Git

Git on the command line

Graphical interfaces

Configuring Git

Automating Git with hooks

Git Administration

Git Administration

Repository maintenance

Data recovery and troubleshooting

Git on the server

Augmenting development workflows

Git Best Practices

Git Best Practices

Starting a project

Working on a project

Integrating changes

Other recommendations

Bibliography

Index

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Introduction

It is possible to correct mistakes made in Git the with git push context (without exposing them if the mistake is found before sharing or publishing the change). If the mistake is already pushed, it is still possible to undo the changes made to the commit that introduced the mistake.

We'll also look at the reflog command and how we can use that and git fsck to recover lost information.

There is no git undo command in core Git. One of the reasons being ambiguity on what needs to be undone, for example, the last commit, the added file, and so on. If you want to undo the last commit, how should that be done? Should the changes introduced to the files by the commit be deleted? For instance, just roll back to the last known good commit, or should they be kept so that could be changed for a better commit or should the commit message simply be reworded?. In this chapter, we'll explore the possibilities to undo a commit in several ways depending on what we want to achieve. We'll explore...