O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

Git Recipes: A Problem-Solution Approach

Book Description

Whether you're relatively new to git or you need a refresher, or if you just need a quick, handy reference for common tasks in git, Git Recipes is just the reference book you need.

With recipes to cover any task you can think of, including working with GitHub and git on BitBucket, Git Recipes shows you how to work with large repositories, new repositories, forks, clones, conflicts, differences, and it even gives you practical scenarios you may find yourself dealing with while using git.

If you work with Git at all, you need this hands-on, practical reference for all things Git.

What you'll learn

  • How to work with both well-known and local repositories

  • How to deal with issues like dangling revisions and disjointed branches

  • How to pinpoint who made specific changes

  • How to deal with textual and binary conflicts

  • How to work with hosted solutions like GitHub and BitBucket

  • How to work with git in large groups

  • Who this book is for

    People who need a quick, practical reference for everything related to Git.

    Table of Contents

    1. Title Page
    2. Dedication
    3. Contents at a Glance
    4. Contents
    5. About the Author
    6. About the Technical Reviewer
    7. Acknowledgments
    8. CHAPTER 1: Getting Started with Git
      1. What is git?
      2. 1-1. Installing git on Windows
      3. 1-2. Installing git on Linux
      4. 1-3. Installing git on OS X
      5. 1-4. Accessing the manual
      6. 1-5. Configuring git
    9. CHAPTER 2: Working with Well-Known Repositories
      1. 2-1. Cloning a repository hosted on Github
      2. 2-2. Cloning a repository hosted on Bitbucket
      3. 2-3. Cloning a local repository
      4. 2-4. Copying a local repository
      5. 2-5. Exploring the contents of a git repository
      6. 2-6. Deleting and restoring the contents of the working directory
      7. 2-7. Cloning a bare repository
      8. 2-8. Exploring the history with a git log command
      9. 2-9. Analyzing a repository with git log and shortlog commands
      10. 2-10. Defining aliases for the commands discussed in Recipes 2-8 and 2-9
      11. 2-11. Analyzing one of the popular repositories
      12. 2-12. Visualizing the history of a repository
      13. 2-13. Removing a .git directory
      14. Summary
    10. CHAPTER 3: Creating Local Repositories with Linear History
      1. 3-1. Creating your first repository
      2. 3-2. Creating the git snapshot alias
      3. 3-3. Using the git snapshot alias in your daily work
      4. 3-4. Mapping names
      5. 3-5. Restoring revisions with git reset
      6. 3-6. Restoring revisions with git checkout
      7. 3-7. Creating a git s alias
      8. 3-8. Working with reflog
      9. 3-9. Creating a new repository in an existing project
      10. 3-10. Losing uncommitted changes
      11. 3-11. Creating a git simple-commit alias
      12. 3-12. Loosing commits
      13. Summary
    11. CHAPTER 4: Managing Files
      1. 4-1. Staging and committing a new file
      2. 4-2. Staging and committing a modified file
      3. 4-3. Committing a modified file
      4. 4-4. Staging and committing a removed file
      5. 4-5. Committing a file removed with the standard rm command
      6. 4-6. Converting an unmodified file into an untracked file
      7. 4-7. Staging and committing a file renamed with git mv
      8. 4-8. Committing a file renamed with the standard mv command
      9. 4-9. Staging all files
      10. 4-10. Working with mixed states
      11. Summary
    12. CHAPTER 5: Branches
      1. 5-1. Creating and switching branches
      2. 5-2. Cloning a repository with branches
      3. 5-3. Creating a clone-with-branches alias
      4. 5-4. Committing in a detached HEAD state
      5. 5-5. Resetting and cleaning a branch
      6. 5-6. Switching branches in a dirty repository without conflicts
      7. 5-7. Switching branches in a dirty repository with conflicts
      8. 5-8. Committing in a wrong branch
      9. 5-9. Deleting local branches
      10. 5-10. Using a branch as a backup
      11. 5-11. Renaming branches
      12. 5-12. Checking out a file from a different branch
      13. 5-13. Switching branches in a bare repository
      14. Summary
    13. CHAPTER 6: Merging Branches
      1. 6-1. Implementing a new feature in a branch
      2. 6-2. Fast-forwarding branches
      3. 6-3. Undoing fast-forward
      4. 6-4. Developing in parallel diverged branches
      5. 6-5. Merging diverged branches
      6. 6-6. Avoiding a fast-forward merge
      7. 6-7. Diverging multiple branches
      8. 6-8. Merging multiple branches
      9. Summary
    14. CHAPTER 7: Rebasing Branches
      1. 7-1. Rebasing divergent branches
      2. 7-2. Manually rebasing divergent branches
      3. 7-3. Joining divergent branches into linear history
      4. 7-4. Diverging three branches
      5. 7-5. Partial rebasing
      6. 7-6. Creating bulbs for divergent branches
      7. 7-7. Creating bulbs in subbranches
      8. 7-8. Rebasing branches with bulbs
      9. 7-9. Preserving merges during rebase
      10. Summary
    15. CHAPTER 8: Modifying the History
      1. 8-1. Amending the most recent revision
      2. 8-2. Removing n most recent revisions
      3. 8-3. Squashing many revisions into one revision
      4. 8-4. Splitting one revision into many revisions
      5. 8-5. Reordering revisions
      6. 8-6. Removing several revisions
      7. 8-7. Editing an old revision
      8. 8-8. Reverting revisions
      9. 8-9. Reverting merge commit revisions
      10. 8-10. Cherry-picking revisions
      11. 8-11. Squashing a branch
      12. 8-12. Re-using a reverted branch
      13. Summary
    16. CHAPTER 9: Resolving Conflicts
      1. 9-1. Creating conflicting changes in text files
      2. 9-2. Resolving textual conflict after merging
      3. 9-3. Resolving textual conflict after rebasing
      4. 9-4 Creating conflicting changes in binary files
      5. 9-5. Resolving a binary conflict during merging
      6. 9-6. Resolving a binary conflict during rebasing
      7. 9-7. Forcing a binary mode during merge
      8. Summary
    17. CHAPTER 10: Remote Repositories and Synchronization
      1. 10-1. Manual cloning
      2. 10-2. Coworking with a central repository
      3. 10-3. Generating (n-1) merge commits for one commit
      4. 10-4. Keeping the history linear
      5. 10-5. Coworking without a central repository
      6. 10-6. Working with remote branches
      7. 10-7. Using remote branches for contributions
      8. 10-8. Accepting contributions
      9. 10-9. Appending commits to a remote branch
      10. 10-10. Rewriting history with $ git push -f
      11. 10-11. Finishing the work on the remote branch
      12. 10-12. Pushing to non-bare repositories
      13. Summary
    18. CHAPTER 11: Hosting git Git Repositories
      1. 11-1. Installing VirtualBox and Vagrant
      2. 11-2. Running virtual Linux
      3. 11-3. Compiling git on a virtual machine
      4. 11-4. Hosting git repositories over ssh
      5. 11-5. Simplifying ssh authorization with authorized_keys
      6. 11-6. Hosting git repositories with git daemon
      7. 11-7. Hosting git repositories over http
      8. 11-8. Using Gitweb CGI application
      9. 11-9. Using a cgit CGI application
      10. 11-10. Working with gitolite
      11. Summary
    19. CHAPTER 12: Working with Github.com
      1. 12-1. Creating a Github account
      2. 12-2. Configuring a Github account with SSH keys
      3. 12-3. Creating a Github-hosted repository for a new project
      4. 12-4. Creating a Github-hosted repository for an existing project
      5. 12-5. Creating an organization account on Github
      6. 12-6. Creating a new project hosted by an organization
      7. 12-7. Sending pull requests
      8. 12-8. Reworking your pull requests
      9. 12-9. Accepting a pull request
      10. How It Works
      11. Summary
    20. CHAPTER 13: More Recipes
      1. 13-1. Working with the $ git diff command
      2. 13-2. Committing files without line-ending conversion
      3. 13-3. Checking out files without line-ending conversion
      4. 13-4. Converting line endings to CRLF in the working directory during checkout and committing the change
      5. 13-5. Converting line endings to LF and committing the change
      6. 13-6. Unintended conversion of all line endings
      7. 13-7. Defining line endings for individual files and directories
      8. 13-8. Ignoring automatically generated files
      9. 13-9. Customizing a project with .dist files
      10. 13-10. Using the .git/info/exclude file
      11. 13-11. Using tags
      12. 13-12. Exporting repositories to zipped archives
      13. Summary
    21. Index