Commits

J. Bruce Fields  committed e34caac

user-manual: add section ID's

Any section lacking an id gets an annoying warning when you build
the manual. More seriously, the table of contents then generates
volatile id's which change with every build, with the effect that
we get URL's that change all the time.

The ID's are manually generated and sometimes inconsistent, but
that's OK.

XXX: what to do about the preface?

Signed-off-by: "J. Bruce Fields" <bfields@citi.umich.edu>

  • Participants
  • Parent commits 953f3d6

Comments (0)

Files changed (1)

File Documentation/user-manual.txt

 $ man git-clone
 ------------------------------------------------
 
+[[git-quick-start]]
 Git Quick Start
 ===============
 
 This is a quick summary of the major commands; the following chapters
 will explain how these work in more detail.
 
+[[quick-creating-a-new-repository]]
 Creating a new repository
 -------------------------
 
 $ cd project
 -----------------------------------------------
 
+[[managing-branches]]
 Managing branches
 -----------------
 
 -----------------------------------------------
 
 
+[[exploring-history]]
 Exploring history
 -----------------
 
 				# repeat until done.
 -----------------------------------------------
 
+[[making-changes]]
 Making changes
 --------------
 
 $ git commit -a	   # use latest content of all tracked files
 -----------------------------------------------
 
+[[merging]]
 Merging
 -------
 
 $ git pull . test  # equivalent to git merge test
 -----------------------------------------------
 
+[[sharing-your-changes]]
 Sharing your changes
 --------------------
 
 $ git push example test
 -----------------------------------------------
 
+[[repository-maintenance]]
 Repository maintenance
 ----------------------
 
 $ git gc
 -----------------------------------------------
 
+[[repositories-and-branches]]
 Repositories and Branches
 =========================
 
+[[how-to-get-a-git-repository]]
 How to get a git repository
 ---------------------------
 
 In most of the following, examples will be taken from one of the two
 repositories above.
 
+[[how-to-check-out]]
 How to check out a different version of a project
 -------------------------------------------------
 
 with no way to find the history it used to point to; so use this command
 carefully.
 
+[[understanding-commits]]
 Understanding History: Commits
 ------------------------------
 
 history, including file data and directory contents, is stored in an object
 with a name that is a hash of its contents.
 
+[[understanding-reachability]]
 Understanding history: commits, parents, and reachability
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 that Y is a descendent of X, or that there is a chain of parents
 leading from commit Y to commit X.
 
+[[history-diagrams]]
 Understanding history: History diagrams
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 If we need to talk about a particular commit, the character "o" may
 be replaced with another letter or number.
 
+[[what-is-a-branch]]
 Understanding history: What is a branch?
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 However, when no confusion will result, we often just use the term
 "branch" both for branches and for branch heads.
 
+[[manipulating-branches]]
 Manipulating branches
 ---------------------
 
 make up a name for the new branch.   You can still create a new branch
 (or tag) for this version later if you decide to.
 
+[[examining-remote-branches]]
 Examining branches from a remote repository
 -------------------------------------------
 
 repository.  It will not touch any of your own branches--not even the
 "master" branch that was created for you on clone.
 
+[[fetching-branches]]
 Fetching branches from other repositories
 -----------------------------------------
 
 text editor.  (See the "CONFIGURATION FILE" section of
 gitlink:git-config[1] for details.)
 
+[[exploring-git-history]]
 Exploring git history
 =====================
 
 We start with one specialized tool that is useful for finding the
 commit that introduced a bug into a project.
 
+[[using-bisect]]
 How to use bisect to find a regression
 --------------------------------------
 
 then test, run "bisect good" or "bisect bad" as appropriate, and
 continue.
 
+[[naming-commits]]
 Naming commits
 --------------
 
 e05db0fd4f31dde7005f075a84f96b360d05984b
 -------------------------------------------------
 
+[[creating-tags]]
 Creating tags
 -------------
 
 should create a tag object instead; see the gitlink:git-tag[1] man
 page for details.
 
+[[browsing-revisions]]
 Browsing revisions
 ------------------
 
 multiple independent lines of development, the particular order that
 commits are listed in may be somewhat arbitrary.
 
+[[generating-diffs]]
 Generating diffs
 ----------------
 
 not reachable from test, then the combined result of these patches
 will not be the same as the diff produced by the git-diff example.
 
+[[viewing-old-file-versions]]
 Viewing old file versions
 -------------------------
 
 Before the colon may be anything that names a commit, and after it
 may be any path to a file tracked by git.
 
+[[history-examples]]
 Examples
 --------
 
+[[checking-for-equal-branches]]
 Check whether two branches point at the same history
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
 will return no commits when the two branches are equal.
 
+[[finding-tagged-descendants]]
 Find first tagged version including a given fix
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 from v1.5.0-rc2, but not from v1.5.0-rc0.
 
 
+[[Developing-with-git]]
 Developing with git
 ===================
 
+[[telling-git-your-name]]
 Telling git your name
 ---------------------
 
 details on the configuration file.)
 
 
+[[creating-a-new-repository]]
 Creating a new repository
 -------------------------
 
 $ git status	    # a brief per-file summary of the above.
 -------------------------------------------------
 
+[[creating-good-commit-messages]]
 Creating good commit messages
 -----------------------------
 
 the first line on the Subject line and the rest of the commit in the
 body.
 
+[[how-to-merge]]
 How to merge
 ------------
 
 The above is all you need to know to resolve a simple merge.  But git
 also provides more information to help resolve conflicts:
 
+[[conflict-resolution]]
 Getting conflict-resolution help during a merge
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 itself have been merged into another branch, as doing so may confuse
 further merges.
 
+[[fast-forwards]]
 Fast-forward merges
 -------------------
 
 moved forward to point at the head of the merged-in branch, without
 any new commits being created.
 
+[[fixing-mistakes]]
 Fixing mistakes
 ---------------
 
 	change, and cannot correctly perform repeated merges from
 	a branch that has had its history changed.
 
+[[reverting-a-commit]]
 Fixing a mistake with a new commit
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 this is an advanced topic to be left for
 <<cleaning-up-history,another chapter>>.
 
+[[checkout-of-path]]
 Checking out an old version of a file
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 
 which will display the given version of the file.
 
+[[ensuring-good-performance]]
 Ensuring good performance
 -------------------------
 
 to recompress the archive.  This can be very time-consuming, so
 you may prefer to run git-gc when you are not doing other work.
 
+
+[[ensuring-reliability]]
 Ensuring reliability
 --------------------
 
+[[checking-for-corruption]]
 Checking the repository for corruption
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 For more about dangling objects, see <<dangling-objects>>.
 
 
+[[recovering-lost-changes]]
 Recovering lost changes
 ~~~~~~~~~~~~~~~~~~~~~~~
 
+[[reflogs]]
 Reflogs
 ^^^^^^^
 
 same project, the reflog history is not shared: it tells you only about
 how the branches in your local repository have changed over time.
 
+[[dangling-objects]]
 Examining dangling objects
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 ------------------------------------------------
 
 
+[[sharing-development]]
 Sharing development with others
 ===============================
 
 
 are roughly equivalent.  The former is actually very commonly used.
 
+[[submitting-patches]]
 Submitting patches to a project
 -------------------------------
 
 Consult the mailing list for your project first to determine how they
 prefer such patches be handled.
 
+[[importing-patches]]
 Importing patches to a project
 ------------------------------
 
 and remote.<name>.push options in gitlink:git-config[1] for
 details.
 
+[[setting-up-a-shared-repository]]
 Setting up a shared repository
 ------------------------------
 
 link:cvs-migration.txt[git for CVS users] for instructions on how to
 set this up.
 
+[[setting-up-gitweb]]
 Allow web browsing of a repository
 ----------------------------------
 
 project's files and history without having to install git; see the file
 gitweb/INSTALL in the git source tree for instructions on setting it up.
 
+[[sharing-development-examples]]
 Examples
 --------
 
 However, there is a situation in which it can be useful to violate this
 assumption.
 
+[[patch-series]]
 Creating the perfect patch series
 ---------------------------------
 
 use them, and then explain some of the problems that can arise because
 you are rewriting history.
 
+[[using-git-rebase]]
 Keeping a patch series up to date using git-rebase
 --------------------------------------------------
 
 $ git rebase --abort
 -------------------------------------------------
 
+[[modifying-one-commit]]
 Modifying a single commit
 -------------------------
 
 "modified" existing commits; instead, you have replaced the old commits with
 new commits having new object names.
 
+[[reordering-patch-series]]
 Reordering or selecting from a patch series
 -------------------------------------------
 
 Then modify, reorder, or eliminate patches as preferred before applying
 them again with gitlink:git-am[1].
 
+[[patch-series-tools]]
 Other tools
 -----------
 
 purpose of maintaining a patch series.  These are outside of the scope of
 this manual.
 
+[[problems-with-rewriting-history]]
 Problems with rewriting history
 -------------------------------
 
 For true distributed development that supports proper merging,
 published branches should never be rewritten.
 
+[[advanced-branch-management]]
 Advanced branch management
 ==========================
 
+[[fetching-individual-branches]]
 Fetching individual branches
 ----------------------------
 
 "fast-forward" to the commit given by example.com's master branch.  So
 next we explain what a fast-forward is:
 
-[[fast-forwards]]
+[[fast-forwards-2]]
 Understanding git history: fast-forwards
 ----------------------------------------
 
 unless you've already created a reference of your own pointing to
 them.
 
+[[forcing-fetch]]
 Forcing git fetch to do non-fast-forward updates
 ------------------------------------------------
 
 old version of example/master pointed at may be lost, as we saw in
 the previous section.
 
+[[remote-branch-configuration]]
 Configuring remote branches
 ---------------------------
 
 Git depends on two fundamental abstractions: the "object database", and
 the "current directory cache" aka "index".
 
+[[the-object-database]]
 The Object Database
 -------------------
 
 
 The object types in some more detail:
 
+[[blob-object]]
 Blob Object
 -----------
 
 A blob is typically created when gitlink:git-update-index[1]
 is run, and its data can be accessed by gitlink:git-cat-file[1].
 
+[[tree-object]]
 Tree Object
 -----------
 
 its data can be accessed by gitlink:git-ls-tree[1].
 Two trees can be compared with gitlink:git-diff-tree[1].
 
+[[commit-object]]
 Commit Object
 -------------
 
 A commit is created with gitlink:git-commit-tree[1] and
 its data can be accessed by gitlink:git-cat-file[1].
 
+[[trust]]
 Trust
 -----
 
 
 To assist in this, git also provides the tag object...
 
+[[tag-object]]
 Tag Object
 ----------
 
 gitlink:git-verify-tag[1].
 
 
+[[the-index]]
 The "index" aka "Current Directory Cache"
 -----------------------------------------
 
 
 
 
+[[the-workflow]]
 The Workflow
 ------------
 
 from the database or from the working directory. Thus there are four
 main combinations: 
 
+[[working-directory-to-index]]
 working directory -> index
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 it will only update the fields that are used to quickly test whether
 an object still matches its old backing store object.
 
+[[index-to-object-database]]
 index -> object database
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 use that tree to re-generate the index at any time by going in the
 other direction:
 
+[[object-database-to-index]]
 object database -> index
 ~~~~~~~~~~~~~~~~~~~~~~~~
 
 earlier. However, that is only your 'index' file: your working
 directory contents have not been modified.
 
+[[index-to-working-directory]]
 index -> working directory
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Finally, there are a few odds and ends which are not purely moving
 from one representation to the other:
 
+[[tying-it-all-together]]
 Tying it all together
 ~~~~~~~~~~~~~~~~~~~~~
 
 ------------
 
 
+[[examining-the-data]]
 Examining the data
 ------------------
 
 
 to see what the top commit was.
 
+[[merging-multiple-trees]]
 Merging multiple trees
 ----------------------
 
 `git-write-tree`.
 
 
+[[merging-multiple-trees-2]]
 Merging multiple trees, continued
 ---------------------------------
 
 
 and that is what higher level `git merge -s resolve` is implemented with.
 
+[[pack-files]]
 How git stores objects efficiently: pack files
 ----------------------------------------------
 
 The gitlink:git-gc[1] command performs packing, pruning, and more for
 you, so is normally the only high-level command you need.
 
-[[dangling-objects]]
+[[dangling-objects-2]]
 Dangling objects
 ----------------
 
 contrast, running "git prune" while somebody is actively changing the 
 repository is a *BAD* idea).
 
+[[glossary]]
 include::glossary.txt[]
 
+[[todo]]
 Notes and todo list for this manual
 ===================================