Version Control with Git. Powerful tools and techniques for collaborative software development. 2nd Edition

Kup polskie wydanie:

Spis treści ebooka

• Version Control with Git
• Preface
  • Audience
  • Assumed Framework
  • Book Layout and Omissions
  • Conventions Used in This Book
  • Using Code Examples
  • Safari Books Online
  • How to Contact Us
  • Acknowledgments
  • Attributions
• 1. Introduction
  • Background
  • The Birth of Git
  • Precedents
  • Timeline
  • Whats in a Name?
• 2. Installing Git
  • Using Linux Binary Distributions
    • Debian/Ubuntu
    • Other Binary Distributions
  • Obtaining a Source Release
  • Building and Installing
  • Installing Git on Windows
    • Installing the Cygwin Git Package
    • Installing Standalone Git (msysGit)
• 3. Getting Started
  • The Git Command Line
  • Quick Introduction to Using Git
    • Creating an Initial Repository
    • Adding a File to Your Repository
    • Configuring the Commit Author
    • Making Another Commit
    • Viewing Your Commits
    • Viewing Commit Differences
    • Removing and Renaming Files in Your Repository
    • Making a Copy of Your Repository
  • Configuration Files
    • Configuring an Alias
  • Inquiry
• 4. Basic Git Concepts
  • Basic Concepts
    • Repositories
    • Git Object Types
    • Index
    • Content-Addressable Names
    • Git Tracks Content
    • Pathname Versus Content
    • Pack Files
  • Object Store Pictures
  • Git Concepts at Work
    • Inside the .git Directory
    • Objects, Hashes, and Blobs
    • Files and Trees
    • A Note on Gits Use of SHA1
    • Tree Hierarchies
    • Commits
    • Tags
• 5. File Management and the Index
  • Its All About the Index
  • File Classifications in Git
  • Using git add
  • Some Notes on Using git commit
    • Using git commit --all
    • Writing Commit Log Messages
  • Using git rm
  • Using git mv
  • A Note on Tracking Renames
  • The .gitignore File
  • A Detailed View of Gits Object Model and Files
• 6. Commits
  • Atomic Changesets
  • Identifying Commits
    • Absolute Commit Names
    • refs and symrefs
    • Relative Commit Names
  • Commit History
    • Viewing Old Commits
    • Commit Graphs
      • Using gitk to View the Commit Graph
    • Commit Ranges
  • Finding Commits
    • Using git bisect
    • Using git blame
    • Using Pickaxe
• 7. Branches
  • Reasons for Using Branches
  • Branch Names
    • Dos and Donts in Branch Names
  • Using Branches
  • Creating Branches
  • Listing Branch Names
  • Viewing Branches
  • Checking out Branches
    • A Basic Example of Checking out a Branch
    • Checking out When You Have Uncommitted Changes
    • Merging Changes into a Different Branch
    • Creating and Checking out a New Branch
    • Detached HEAD Branches
  • Deleting Branches
• 8. Diffs
  • Forms of the git diff Command
  • Simple git diff Example
  • git diff and Commit Ranges
  • git diff with Path Limiting
  • Comparing How Subversion and Git Derive diffs
• 9. Merges
  • Merge Examples
    • Preparing for a Merge
    • Merging Two Branches
    • A Merge with a Conflict
  • Working with Merge Conflicts
    • Locating Conflicted Files
    • Inspecting Conflicts
      • git diff with conflicts
      • git log with conflicts
    • How Git Keeps Track of Conflicts
    • Finishing Up a Conflict Resolution
    • Aborting or Restarting a Merge
  • Merge Strategies
    • Degenerate Merges
    • Normal Merges
      • Recursive merges
      • Octopus merges
    • Specialty Merges
    • Applying Merge Strategies
    • Merge Drivers
  • How Git Thinks About Merges
    • Merges and Gits Object Model
    • Squash Merges
    • Why Not Just Merge Each Change One by One?
• 10. Altering Commits
  • Caution About Altering History
  • Using git reset
  • Using git cherry-pick
  • Using git revert
  • reset, revert, and checkout
  • Changing the Top Commit
  • Rebasing Commits
    • Using git rebase -i
    • rebase Versus merge
• 11. The Stash and the Reflog
  • The Stash
  • The Reflog
• 12. Remote Repositories
  • Repository Concepts
    • Bare and Development Repositories
    • Repository Clones
    • Remotes
    • Tracking Branches
  • Referencing Other Repositories
    • Referring to Remote Repositories
    • The refspec
  • Example Using Remote Repositories
    • Creating an Authoritative Repository
    • Make Your Own Origin Remote
    • Developing in Your Repository
    • Pushing Your Changes
    • Adding a New Developer
    • Getting Repository Updates
      • The fetch step
      • The merge or rebase step
      • Should you merge or rebase?
  • Remote Repository Development Cycle in Pictures
    • Cloning a Repository
    • Alternate Histories
    • NonFast-Forward Pushes
    • Fetching the Alternate History
    • Merging Histories
    • Merge Conflicts
    • Pushing a Merged History
  • Remote Configuration
    • Using git remote
    • Using git config
    • Using Manual Editing
  • Working with Tracking Branches
    • Creating Tracking Branches
    • Ahead and Behind
  • Adding and Deleting Remote Branches
  • Bare Repositories and git push
• 13. Repository Management
  • A Word About Servers
  • Publishing Repositories
    • Repositories with Controlled Access
    • Repositories with Anonymous Read Access
      • Publishing repositories using git-daemon
      • Publishing repositories using an HTTP daemon
      • Publishing a repository using Smart HTTP
      • Publishing via Git and HTTP daemons
    • Repositories with Anonymous Write Access
    • Publishing Your Repository to GitHub
  • Repository Publishing Advice
  • Repository Structure
    • The Shared Repository Structure
    • Distributed Repository Structure
    • Repository Structure Examples
  • Living with Distributed Development
    • Changing Public History
    • Separate Commit and Publish Steps
    • No One True History
  • Knowing Your Place
    • Upstream and Downstream Flows
    • The Maintainer and Developer Roles
    • MaintainerDeveloper Interaction
    • Role Duality
  • Working with Multiple Repositories
    • Your Own Workspace
    • Where to Start Your Repository
    • Converting to a Different Upstream Repository
    • Using Multiple Upstream Repositories
    • Forking Projects
      • Isnt forking a project bad?
      • Reconciling forks
      • Forking projects at GitHub
• 14. Patches
  • Why Use Patches?
  • Generating Patches
    • Patches and Topological Sorts
  • Mailing Patches
  • Applying Patches
  • Bad Patches
  • Patching Versus Merging
• 15. Hooks
  • Installing Hooks
    • Example Hooks
    • Creating Your First Hook
  • Available Hooks
    • Commit-Related Hooks
    • Patch-Related Hooks
    • Push-Related Hooks
    • Other Local Repository Hooks
• 16. Combining Projects
  • The Old Solution: Partial Checkouts
  • The Obvious Solution: Import the Code into Your Project
    • Importing Subprojects by Copying
    • Importing Subprojects with git pull -s subtree
    • Submitting Your Changes Upstream
  • The Automated Solution: Checking out Subprojects Using Custom Scripts
  • The Native Solution: gitlinks and git submodule
    • Gitlinks
    • The git submodule Command
• 17. Submodule Best Practices
  • Submodule Commands
  • Why Submodules?
  • Submodules Preparation
  • Why Read Only?
  • Why Not Read Only?
  • Examining the Hashes of Submodule Commits
  • Credential Reuse
  • Use Cases
  • Multilevel Nesting of Repos
  • Submodules on the Horizon
• 18. Using Git with Subversion Repositories
  • Example: A Shallow Clone of a Single Branch
    • Making Your Changes in Git
    • Fetching Before Committing
    • Committing Through git svn rebase
  • Pushing, Pulling, Branching, and Merging with git svn
    • Keeping Your Commit IDs Straight
    • Cloning All the Branches
    • Sharing Your Repository
    • Merging Back into Subversion
      • How dcommit handles merges
  • Miscellaneous Notes on Working with Subversion
    • svn:ignore Versus .gitignore
    • Reconstructing the git-svn Cache
• 19. Advanced Manipulations
  • Using git filter-branch
    • Examples Using git filter-branch
      • Using git filter-branch to expunge a file
      • Using filter-branch to edit a commit message
    • filter-branch Pitfalls
  • How I Learned to Love git rev-list
    • Date-Based Checkout
      • Date-based checkout cautions
    • Retrieve Old Version of a File
  • Interactive Hunk Staging
  • Recovering a Lost Commit
    • The git fsck Command
    • Reconnecting a Lost Commit
• 20. Tips, Tricks, and Techniques
  • Interactive Rebase with a Dirty Working Directory
  • Remove Left-Over Editor Files
  • Garbage Collection
  • Split a Repository
  • Tips for Recovering Commits
  • Subversion Conversion Tips
    • General Advice
    • Remove a Trunk After an SVN Import
    • Removing SVN Commit IDs
  • Manipulating Branches from Two Repositories
  • Recovering from an Upstream Rebase
  • Make Your Own Git Command
  • Quick Overview of Changes
  • Cleaning Up
  • Using git-grep to Search a Repository
  • Updating and Deleting refs
  • Following Files that Moved
  • Keep, But Dont Track, This File
  • Have You Been Here Before?
• 21. Git and GitHub
  • Repo for Public Code
  • Creating a GitHub Repository
  • Social Coding on Open Source
  • Watchers
  • News Feed
  • Forks
  • Creating Pull Requests
  • Managing Pull Requests
  • Notifications
  • Finding Users, Projects, and Code
  • Wikis
  • GitHub Pages (Git for Websites)
  • In-Page Code Editor
  • Subversion Bridge
  • Tags Automatically Becoming Archives
  • Organizations
  • REST API
  • Social Coding on Closed Source
  • Eventual Open Sourcing
  • Coding Models
  • GitHub Enterprise
  • GitHub in Sum
• Index
• About the Authors
• Colophon
• Copyright

pokaż cały spis treści

ukryj recenzje