12:12 <echo-area> hello, is there any explaination of stacked
                  branches besides the documentation?
12:13 <echo-area> the secion "using stacked branches" in the bzr
                  manual doesn't explain it well, and many examples
                  in it don't work
12:16 <spiv> echo-area: those docs are the best I know of, but I'm
             happy to answer questions here
12:18 <spiv> echo-area: the primary use case is pushing to a server
             where a trunk already exists (so most of your branch's
             revisions are already on the server), but you don't
             have write access to that repository
12:19 <spiv> echo-area: so you can push (using the --stacked and
             --stacked-on options, or specially configure the
             remote .bzr directory) just the revisions unique to
             your branch to the server.
12:20 <spiv> echo-area: launchpad for instance creates those
             specially configured .bzr directories automatically,
             so if I push a new branch to ~spiv/bzr/..., it will
             automatically be stacked on the bzr trunk.



12:31 <spiv> echo-area: There are uses for branches that don't
             involve committing to them
12:32 <spiv> echo-area: e.g. the scenario I described earlier
             (pushing to a server that has a suitable repository
             for stacking-on, but that you do not have permissions
             to write to)



13:39 <echo-area> spiv: I have not reproduced that scenario
                  successfully yet.  I did this:
13:39 <echo-area> bzr init-repo --no-trees test-repo
13:39 <echo-area> bzr init test-repo/trunk
13:39 <echo-area> bzr init-repo test-branch
13:40 <echo-area> bzr branch test-repo/trunk test-branch/trunk
13:41 <echo-area> cd test-branch/trunk   <-- and work here, commit
13:42 <echo-area> then I did (in test-branch/trunk)   bzr push
                  --stacked ../../test-repo
13:43 <echo-area> I got messages like these:
13:43 <echo-area> Ignoring request for a stacked branch as
                  repository already exists at the destination
                  location.
13:43 <echo-area> All changes applied successfully.
13:43 <echo-area> Pushed up to revision 4.
13:44 <echo-area> but as I made another branch of test-repo/trunk,
                  I didn't see the new revisions unique to
                  test-branch/trunk
13:47 <spiv> echo-area: that's not the scenario I was referring to
13:48 <spiv> echo-area: because in that scenario you can (and did)
             push directly into the original repo (test-repo)
13:49 <spiv> echo-area: I'm referring to a case like a server
             shared by several developers, but only one (or perhaps
             a non-human system account, like a gatekeeper bot) has
             access to the integration branch everyone branches off
13:50 <echo-area> spiv: should I make test-repo a stacked branch,
                  and so that pushing onto it is the same as
                  pushing to the stacked-on branch of test-repo?
13:50 <spiv> echo-area: e.g. if the trunk is on /srv/project/trunk
             on a host, and /srv/project is a repo made with
             init-repo, but you don't have access to write to
             /srv/project
13:52 <spiv> echo-area: but you can read from it, so you can do
             e.g. "bzr branch sftp://host/srv/project/trunk
             local-branch", work on that, and then push it up with
             "bzr push sftp://host/home/myuser/my-branch --stacked
             --stacked-on=sftp://host/home/myuser/my-branch"
13:53 <spiv> echo-area: in that case making local-branch will still
             copy the full history, but you don't have to push the
             full history back to the server, you use stacking to
             point to the history the server already has
13:54 <spiv> (and also you don't waste space on the server by
             keeping a second copy of the history)



15:23 <echo-area> spiv: please take a look at this, does it
                  elaborate the scenario you mentioned:
15:23 <echo-area> bzr init-repo test-repo
15:23 <echo-area> bzr init test-repo/trunk
15:23 <echo-area> bzr init-repo stacked-repo
15:24 <echo-area> bzr branch --stacked test-repo/trunk
                  stacked-repo/trunk
15:24 <echo-area> bzr init-repo local
15:24 <echo-area> bzr branch test-repo/trunk local/trunk
15:24 <echo-area> cd local/trunk   <--- work here
15:24 <spiv> echo-area: it doesn't make much sense to create a
             stacked branch in a shared repo (i.e. a directory
             you've made with init-repo)
15:25 <echo-area> (in local/trunk)  bzr push
                  ../../stacked-repo/trunk
15:26 <echo-area> spiv: so a stacked branch is better put in its
                  own directory?
15:26 <spiv> (I guess I can imagine uses for it, but it's certainly
             not how I would choose to explain it)
15:26 <spiv> echo-area: I'd ignore init-repo entirely, really
15:27 <spiv> echo-area: (for explaining how stacking works, not in
             general)
15:28 <spiv> I'm not sure what you're asking, exactly.
15:29 <spiv> I guess you're trying to test your understanding of
             stacking by constructing a scenario that uses it?
15:33 <echo-area> spiv: in your last example, "bzr push
                  sftp://host/home/myuser/my-branch --stacked
                  --stacked-on=sftp://host/home/myuser/my-branch",
                  are the following statements true or not?  1)
                  sftp://host/home/myuser/my-branch contains the
                  full history too; 2) only the local revisions
                  that have not been synced will be transfered
                  during that push, the previous history will come
                  from my-branch on host; and 3) full history will
                  be tran
15:33 <echo-area> sfered in a normal push.
15:34 <echo-area> spiv: kind of.  I want to figure out the things
                  not explained explicitly in your example, hoping
                  to help myself fully understand stacked branches
15:37 <spiv> 1) no, it only contains the history not in the
             stacked-on location (plus some small overhead), b)
             yes, only the history not already in
             sftp://host/home/myuser/my-branch and not already in
             its stacked-on location is pushed, 3) it depends; full
             history is transferred in a normal push when there is
             no shared repository (or that shared repository is
             empty or otherwise contains none of the relevant
             history)
15:38 <echo-area> spiv: so sftp://host/home/myuser/my-branch is a
                  stacked branch too?
15:39 <spiv> To clarify for 3, I mean a normal *initial* push.
             Obviously subsequent pushes to the same branch don't
             have to re-transfer data that was already transferred.
15:39 <spiv> echo-area: what do you mean "too"?  I think that's the
             only stacked branch in my example.
15:40 <spiv> echo-area: oh, I see I made a silly typo in my example
15:40 <spiv> echo-area: that command ought to have been "bzr push
             sftp://host/home/myuser/my-branch --stacked
             --stacked-on=sftp://host/srv/project/trunk"
15:40 <spiv> echo-area: I guess that was rather confusing!
15:41 <echo-area> spiv: should be  bzr push --stacked
                  --stacked-on=sftp://host/srv/project/trunk
                  sftp://host/myuser/myproject, right?
15:42 <spiv> echo-area: right
15:42 <echo-area> spiv: whoa, I think I understand that now.  Thank
                  you!