X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=dgit.git;a=blobdiff_plain;f=dgit-maint-debrebase.7.pod;h=4a0b5a52a3fec3b415f31320af91eacb8788dc9a;hp=f5023e849ba5c6c271069e713a929bdf9c3974a4;hb=209b87ba971701dffcd97a7fd9593cea51f62000;hpb=7ba46bbf3be9e1bb01cfa50e46ec2f67a46b6eda

diff --git a/dgit-maint-debrebase.7.pod b/dgit-maint-debrebase.7.pod
index f5023e84..4a0b5a52 100644
--- a/dgit-maint-debrebase.7.pod
+++ b/dgit-maint-debrebase.7.pod
@@ -134,6 +134,32 @@ using git-diff(1) to compare the imported tarball to the release tag.
 
 =back
 
+=head3 Using untagged upstream commits
+
+=over 4
+
+Sometimes upstream does not tag their releases, or you want to package
+an unreleased git snapshot.  In such a case you can create your own
+upstream release tag, of the form B<upstream/>I<ver>, where I<ver> is
+the upstream version you plan to put in I<debian/changelog>.  The
+B<upstream/> prefix ensures that your tag will not clash with any tags
+upstream later creates.
+
+For example, suppose that the latest upstream release is 1.2.2 and you
+want to package git commit ab34c21 which was made on 2013-12-11.  A
+common convention is to use the upstream version number
+1.2.2+git20131211.ab34c21 and so you could use
+
+=over 4
+
+    % git tag -s upstream/1.2.2+git20131211.ab34c21 ab34c21
+
+=back
+
+to obtain a release tag, and then proceed as above.
+
+=back
+
 =head2 When upstream releases only tarballs
 
 Because we want to work in git, we need a virtual upstream branch with
@@ -209,47 +235,84 @@ patching the upstream source.
 This section explains how to convert an existing Debian package to
 this workflow.  It should be skipped when debianising a new package.
 
-=head2 No existing git history
+If you have an existing git history that you have pushed to an
+ordinary git server like B<salsa.debian.org>, we start with that.  If
+you don't already have it locally, you'll need to clone it, and obtain
+the corresponding orig.tar from the archive:
+
+=over 4
+
+    % git clone salsa.debian.org:Debian/foo
+    % cd foo
+    % dgit setup-new-tree
+    % origtargz
+
+=back
+
+If you don't have any existing git history, or you have history only
+on the special B<dgit-repos> server, we start with B<dgit clone>:
 
 =over 4
 
     % dgit clone foo
     % cd foo
+
+=back
+
+Then we make new upstream tags available:
+
+=over 4
+
     % git remote add -f upstream https://some.upstream/foo.git
 
 =back
 
-=head2 Existing git history using another workflow
+We now use a B<git debrebase convert-from-*> command to convert your
+existing history to the git-debrebase(5) data model.  Which command
+you should use depends on some facts about your repository:
+
+=over 4
 
-First, if you don't already have the git history locally, clone it,
-and obtain the corresponding orig.tar from the archive:
+=item (A) There is no delta queue.
+
+If there do not exist any Debian patches, use
 
 =over 4
 
-    % git clone salsa.debian.org:Debian/foo
-    % cd foo
-    % origtargz
+    % git debrebase convert-from-gbp
 
 =back
 
-If your tree is patches-unapplied, some conversion work is needed.
-You can use
+=item (B) There is a delta queue, and patches are unapplied.
+
+This is the standard git-buildpackage(1) workflow: there are Debian
+patches, but the upstream source is committed to git without those
+patches applied.  Use
 
 =over 4
 
-    git debrebase convert-from-gbp
+    % git debrebase convert-from-gbp
 
 =back
 
-Then make new upstream tags available:
+If you were not previously using dgit to upload your package (i.e. you
+were not using the workflow described in dgit-maint-gbp(7)), and you
+happen to have run B<dgit fetch sid> in this clone of the repository,
+you will need to pass I<--fdiverged> to this command.
+
+=item (C) There is a delta queue, and patches are applied.
+
+Use
 
 =over 4
 
-    % git remote add -f upstream https://some.upstream/foo.git
+    % git debrebase convert-from-dgit-view
+
+=back
 
 =back
 
-Now you simply need to ensure that your git HEAD is dgit-compatible,
+Finally, you need to ensure that your git HEAD is dgit-compatible,
 i.e., it is exactly what you would get if you deleted .git, invoked
 B<dpkg-buildpackage -S>, and then unpacked the resultant source
 package.
@@ -258,11 +321,9 @@ To achieve this, you might need to delete
 I<debian/source/local-options>.  One way to have dgit check your
 progress is to run B<dgit build-source>.
 
-The first dgit push will require I<--overwrite>.
-
 =head1 GIT CONFIGURATION
 
-git-debrebase does not yet support using B<git merge> to merge
+git-debrebase(1) does not yet support using B<git merge> to merge
 divergent branches of development (see "OTHER MERGES" in
 git-debrebase(5)).  You should configure git such that B<git pull>
 does not try to merge:
@@ -292,10 +353,14 @@ release, and importing that release using git-debrebase(1).
 
 =over 4
 
-    % git remote update
+    % git fetch --tags upstream
 
 =back
 
+If you want to package an untagged upstream commit (because upstream
+does not tag releases or because you want to package an upstream
+development snapshot), see "Using untagged upstream commits" above.
+
 =head3 When upstream releases only tarballs
 
 You will need the I<debian/gbp.conf> from "When upstream releases only
@@ -323,7 +388,7 @@ or if you have a working watch file
 
 =over 4
 
-    % git debrebase new-upstream-v0 1.2.3
+    % git debrebase new-upstream 1.2.3
 
 =back
 
@@ -340,9 +405,10 @@ release:
 
 =back
 
-Pass I<--stat> just to see the list of changed files, which is useful
-to determine whether there are any new or deleted files to may need
-accounting for in your copyright file.
+Also, diff with I<--name-status> and I<--diff-filter=ADR> to see
+just the list of added or removed files, which is useful to determine
+whether there are any new or deleted files that may need accounting
+for in your copyright file.
 
 If you obtained a tarball from upstream, you are ready to try a build.
 If you merged a git tag from upstream, you will first need to generate
@@ -400,17 +466,24 @@ git remote such as B<salsa.debian.org>,
 Note that each time you conclude a debrebase you introduce a
 pseudomerge into your git history, which may make it harder to read.
 Try to do all of the editing of the delta queue that you think will be
-needed for this upload in a single debrebase, so that there is a
-single debrebase stitch.
+needed for this editing session in a single debrebase, so that there
+is a single debrebase stitch.
 
 =head1 BUILDING AND UPLOADING
 
 You can use dpkg-buildpackage(1) for test builds.  When you are ready
-to build for an upload, use B<dgit sbuild>.
+to build for an upload, use B<dgit sbuild>, B<dgit pbuilder> or B<dgit
+cowbuilder>.
 
 Upload with B<dgit push> or B<dgit push-source>.  Remember to pass
 I<--new> if the package is new in the target suite.
 
+In some cases where you used B<git debrebase convert-from-gbp> since
+the last upload, it is not possible for dgit to make your history
+fast-forwarding from the history on B<dgit-repos>.  In such cases you
+will have to pass I<--overwrite> to dgit.  git-debrebase will normally
+tell you if this will be needed.
+
 Right before uploading, if you did not just already do so, you might
 want to have git-debrebase(1) shuffle your branch such that the Debian
 delta queue appears right at the tip of the branch you will push:
@@ -429,9 +502,11 @@ you're using that.
 
 =head1 HANDLING DFSG-NON-FREE MATERIAL
 
-This covers only DFSG-non-free material.  Material which is legally
-dangerous (for example, files which are actually illegal) cannot be
-handled this way.
+=head2 Illegal material
+
+Here we explain how to handle material that is merely DFSG-non-free.
+Material which is legally dangerous (for example, files which are
+actually illegal) cannot be handled this way.
 
 If you encounter possibly-legally-dangerous material in the upstream
 source code you should seek advice.  It is often best not to make a
@@ -439,22 +514,65 @@ fuss on a public mailing list (at least, not at first).  Instead,
 email your archive administrators.  For Debian that is
  To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org
 
-=head2 When upstream tags releases in git
+=head2 DFSG-non-free: When upstream tags releases in git
+
+Our approach is to maintain a DFSG-clean upstream branch, and create
+tags on this branch for each release that we want to import.  We then
+import those tags per "Importing the release", above.  In the case of
+a new package, we base our initial Debianisation on our first
+DFSG-clean tag.
 
-We create a DFSG-clean tag to import to master:
+For the first upstream release that requires DFSG filtering:
 
 =over 4
 
-    % git checkout -b pre-dfsg 1.2.3
+    % git checkout -b upstream-dfsg 1.2.3
     % git rm evil.bin
     % git commit -m "upstream version 1.2.3 DFSG-cleaned"
     % git tag -s 1.2.3+dfsg
     % git checkout master
-    % git branch -D pre-dfsg
 
 =back
 
-=head2 When upstream releases only tarballs
+Now either proceed with "Importing the release" on the 1.2.3+dfsg tag,
+or in the case of a new package,
+
+=over 4
+
+    % git branch --unset-upstream
+    % git reset --hard 1.2.3+dfsg
+
+=back
+
+and proceed with "INITIAL DEBIANISATION".
+
+For subsequent releases (whether or not they require additional
+filtering):
+
+=over 4
+
+    % git checkout upstream-dfsg
+    % git merge 1.2.4
+    % git rm further-evil.bin # if needed
+    % git commit -m "upstream version 1.2.4 DFSG-cleaned" # if needed
+    % git tag -s 1.2.4+dfsg
+    % git checkout master
+    % # proceed with "Importing the release" on 1.2.4+dfsg tag
+
+=back
+
+Our upstream-dfsg branch cannot be pushed to B<dgit-repos>, but since
+we will need it whenever we import a new upstream version, we must
+push it somewhere.  Assuming that you have already set up an origin
+remote per the above,
+
+=over 4
+
+    % git push --follow-tags -u origin master upstream-dfsg
+
+=back
+
+=head2 DFSG-non-free: When upstream releases only tarballs
 
 The easiest way to handle this is to add a B<Files-Excluded> field to
 I<debian/copyright>, and a B<uversionmangle> setting in
@@ -472,10 +590,14 @@ In the simplest case,
 
 =back
 
-If that fails, because your branch and the NMUers work represent
+If that fails, because your branch and the NMUers' work represent
 divergent branches of development, you have a number of options.  Here
 we describe the two simplest.
 
+Note that you should not try to resolve the divergent branches by
+editing files in I<debian/patches>.  Changes there would either cause
+trouble, or be overwritten by git-debrebase(1).
+
 =head2 Rebasing your work onto the NMU
 
 =over 4
@@ -505,25 +627,49 @@ I<--overwrite>.
 Above we noted that each time you conclude a debrebase, you introduce
 a pseudomerge into your git history, which may make it harder to read.
 
-A convention you can use to minimise the number of pseudomerges is to
-debrebase only right before you upload.
+A simple convention you can use to minimise the number of pseudomerges
+is to B<git debrebase conclude> only right before you upload or push
+to B<salsa.debian.org>.
+
+It is possible, though much less convenient, to reduce the number of
+pseudomerges yet further.  We debrebase only (i) when importing a new
+release, and (ii) right before uploading.  Instead of editing the
+existing delta queue, you append fixup commits (and reversions of
+commits) that alter the upstream source to the required state.  You
+can push and pull to and from B<salsa.debian.org> during this.  Just
+before uploading, you debrebase, once, to tidy everything up.
+
+=head2 The debian/patches directory
+
+In this workflow, I<debian/patches> is purely an output of
+git-debrebase(1).  You should not make changes there.  They will
+either cause trouble, or be ignored and overwritten by
+git-debrebase(1).
 
-Before that point, instead of editing the existing delta queue, you
-append fixup commits (and reversions of commits) that alter the
-upstream source to the required state.  You can freely push and pull
-from B<salsa.debian.org> during this.  Just before uploading, you
-debrebase, once, to tidy everything up.
+I<debian/patches> will often be out-of-date because git-debrebase(1)
+will only regenerate it when it needs to.  So you should not rely on
+the information in that directory.  When preparing patches to forward
+upstream, you should use git-format-patch(1) on git commits, rather
+than sending files from I<debian/patches>.
 
 =head2 Upstream branches
 
-Except in the case where upstream releases only tarballs, we do not
-maintain a separate 'upstream' branch (unless you also happen to be
-involved in upstream development).  We work with upstream tags rather
-than any branches, except temporary branches used to prepare patches
-for forwarding upstream, for example.
+In this workflow, we specify upstream tags rather than any branches.
 
-The thought behind this is that from Debian's point of view, upstream
-releases are immutable points in history, better represented by tags.
+Except when (i) upstream releases only tarballs, (ii) we require DFSG
+filtering, or (iii) you also happen to be involved in upstream
+development, we do not maintain any local branch corresponding to
+upstream, except temporary branches used to prepare patches for
+forwarding, and the like.
+
+The idea here is that from Debian's point of view, upstream releases
+are immutable points in history.  We want to make sure that we are
+basing our Debian package on a properly identified upstream version,
+rather than some arbitrary commit on some branch.  Tags are more
+useful for this.
+
+Upstream's branches remain available as the git remote tracking
+branches for your upstream remote, e.g. I<remotes/upstream/master>.
 
 =head2 The first ever dgit push
 
@@ -533,6 +679,62 @@ avoids introducing a new origin commit into your git history.  (This
 origin commit would represent the most recent non-dgit upload of the
 package, but this should already be represented in your git history.)
 
+=head2 Inspecting the history
+
+The git history made by git-debrebase can seem complicated.
+Here are some suggestions for helpful invocations of gitk and git.
+They can be adapted for other tools like tig(1), git-log(1), magit, etc.
+
+History of package in Debian, disregarding history from upstream:
+
+=over
+
+    % gitk --first-parent
+
+In a laundered branch, the delta queue is at the top.
+
+=back
+
+History of the packaging, excluding the delta queue:
+
+    % gitk :/debian :!/debian/patches
+
+Just the delta queue (i.e. Debian's changes to upstream):
+
+    % gitk --first-parent -- :/ :!/debian
+
+Full history including old versions of the delta queue:
+
+=over
+
+    % gitk --date-order
+
+The "Declare fast forward" commits you see have an older history
+(usually, an older delta queue) as one parent,
+and a newer history as the other.
+--date-order makes gitk show the delta queues in the right order.
+
+=back
+
+Complete diff since the last upload:
+
+=over
+
+    % git diff dgit/dgit/sid..HEAD -- :/ :!/debian/patches
+
+This includes changes to upstream files.
+
+=back
+
+Interdiff of delta queue since last upload, if you really want it:
+
+    % git debrebase make-patches
+    % git diff dgit/dgit/sid..HEAD -- debian/patches
+
+And of course there is:
+
+    % git debrebase status
+
 =head2 Alternative ways to start a debrebase
 
 Above we started an interactive debrebase by invoking git-debrebase(1)
@@ -559,17 +761,23 @@ using git-rebase(1) directly.  For example,
 
 =over 4
 
-    % git debrebase launder
+    % git debrebase
     % git rebase -i HEAD~5      # there are 4 Debian patches
 
 =back
 
 If you take this approach, you should be very careful not to start the
-rebase too early.
+rebase too early,
+including before the most recent pseudomerge.
+git-rebase without a base argument will often
+start the rebase too early,
+and should be avoided.
+Run git-debrebase instead.
+See also "ILLEGAL OPERATIONS" in git-debrebase(5).
 
 =head1 SEE ALSO
 
-dgit(1), dgit(7)
+dgit(1), dgit(7), git-debrebase(1), git-debrebase(5)
 
 =head1 AUTHOR