Contents

PDF Reviewing with Confluence
1. Patches to existing plugins
2. Confluence PDF Review plugin
3. Windows webdav PDF reviewing script
Subversion repository refactoring
1. Refactoring repository at server
  1. Creating date stamps for ‘null’ revisions to support date-based queries (svn log)
2. Relocating client working copies
Subversion client tools
1. svn-tree-tool (was svn-rebase)

Calendar Plugin patch to work with Confluence 4

See https://bitbucket.org/abutcher/confluence-calendar/wiki

PDF Reviewing with Confluence

Plugins

Enhancements to existing Confluence plugins to support Review Tracking

Enhancement to PDF Space Export plugin supporting ‘Start PDF Review’ option which kicks off the review tracking plugin.

confluence-flyingpdf-review-hack

Enhancement to Documentation Theme to expose Settings class for programmatic configuration of theme properties.

doctheme-hack

Review Tracking for Confluence Spaces

Install the above plugins first.

pdfreview-plugin-for-confluence

PDF Review Client Scripts

Download the latest installer:

PDF Review Client Scripts Setup

Subversion repository refactoring

SVN Client: SVN switch relocate supporting repo and path rewriting

Download the latest perl script:

SVN hard relocate with path rewriting

SVN Server: Svndumpfilter4 enhancements

Download the latest python script:

Enhanced svndumpfilter4 with path rewriting

Creating date stamps for ‘null’ revisions to support date-based queries (svn log)

Download the latest sh script:

file:svn-stamp-missing-dates.sh See comment at top of script for usage.

Subversion client tools

SVN Tree Tool (formerly SVN Rebase)

See doc below.

Download the zsh script here (tested on linux and windows with svn 1.7.1)

Create symlinks svn-rebase, svn-reintegrate and svn-cherry-pick to svn-tree-tool to shortcut mode selection.

Alternatively pass —rebase, —reintegrate, or —cherry-pick to select the mode of operation.

For windows it is useful to create cmd files svn-rebase.cmd, svn-reintegrate.cmd, svn-cherry-pick.cmd on the PATH which run svn-tree-tool with the appropriate option via zsh passing though any additional params.



 ---------------------------------------------------------------------
 svn-tree-tool
 [shortcuts: svn-rebase, svn-reintegrate, svn-cherry-pick]
 ---------------------------------------------------------------------

   Atomically, and external to a user's working copy, rebase a branch
   against its ancestor branch (rebase mode), reintegrate a branch
   back to its ancestor branch (reintegrate mode) or push changesets
   from one branch to another (cherry-pick mode).  Details of the
   modes and their behaviours and options are described below.

   A temporary working copy is generated to perform the requested
   operation and the user is able to view the changes to be committed
   prior to performing the commit.  The svn command line client is
   used to perform the required operations and a standard commit is
   done to make changes to the repository.  As such the user's editor
   and other local configuration will be used as expected.

   With the exception of the re-branching feature of the reintegrate
   mode and the record option of the cherry-pick mode, all operations
   are done atomically within one commit.  (Rebranching is a
   convenience feature to re-branch a topic branch after it has been
   reintegrated -- as such it makes a second commit.  Cherry-pick
   recording makes a second commit to mark the cherry-picked commit
   as already merged into the source branch.  This prevents a
   subsequent target-to-source merge from considering the cherry-pick
   commit eligible for merging back to the source avoiding
   unnecessary conflict resolution.)

 ---------------------------------------------------------------------
 Synopsis:
 ---------------------------------------------------------------------

 svn-tree-tool
    [-q] [-v [-v]] [--help [-v]]
    [--abort]
    <mode-of-operation> <operation-arguments>

 <mode-of-operation> <operation-arguments> is of one of the
 following forms:

      --rebase [<branch-spec>] [--as <new-branch-name-or-uri>] [--force]
  or  --cherry-pick [<branch-spec>] --to <branch-uri> [-rA,B-C,D:E,F,...]
  or  --reintegrate [<branch-spec>] [-rA,B-C,D:E,F,... | [--delete|--rebranch|--rebranch-as <new-branch-name-or-uri>]]

 <mode-of-operation> can be implied by running the program under a
 different name.  Running as 'svn-rebase' implies the --rebase mode
 of operation.  Running as 'svn-reintegrate' implies the
 --reintegrate mode of operation.  Running as 'svn-cherry-pick'
 implies the --cherry-pick mode of operation.

 <branch-spec> should either be omitted, to use the root
 checkout path of the current directory's working copy, or be of one
 of the following forms:

      [--sub-tree] [<working-copy-path>]
  or  <branch-uri>

 <branch-uri> may be a full URL (such as http://server/repo/path) or
 repository-relative (such as ^/path).

 See below for general options and details of each mode.


 ---------------------------------------------------------------------
 General options
 ---------------------------------------------------------------------

 -q  Be queit.  Suppresses INFO messages.

 -v  Be verbose.  Specifically, in addition to standard progress
     messages, the command lines for individual svn commands are
     echoed at TRACE level.

 -vv Be extra-verbose.  Output of operations is shown.  Mostly for
     debugging the script itself though could be useful to users
     in some cases.

 --abort
     Terminate an operation in progress and deletes any working state
     files for the operation.

 --sub-tree
     When specifying a working-copy-path (or inferring . by specifying
     no path arguments), --sub-tree prevents the script looking for
     the base of the checkout.  I.e. the rebase happens at the given
     path rather than at the base of the checkout.  This is not
     recommended as will generate additional mergeinfo noise at the
     given path.

 -r<revision-spec>
     Cherry-pick branch changes onto the branch ancestor during
     --reintegrate (or any arbitrary branch during --cherry-pick).
     <revision-spec> is a comma separated list of revisions or
     revision ranges.  Revision ranges may be specified as inclusive
     changesets <first>-<second> or as baseline to baseline
     <base-state>:<next-state>.

 --help
     This usage info.  Pass -v to include also examples.


 ---------------------------------------------------------------------
 Rebasing (--rebase)
 ---------------------------------------------------------------------

 Replaces a topic branch with a copy of the most recent state of it's
 ancestor branch and merges all topic branch changes to it.

     [ancestor]  A---B---D---F     >   A---B---D---F
                      \            >                \
     [topic]           C---E---G   >                 C'---E'---G'

 --as <new-branch-name-or-uri>
     Rather than rebasing the branch into the same path, --as allows
     to specify a different path for the rebased result and leaves
     the current branch unchanged.  If not specified as a URL, the
     name is used to create a branch alongside the existing one.

     [topic]           C---E---G   >         C---E---G
                      /            >        /
     [ancestor]  A---B---D---F     >   A---B---D---F
                                   >                \
     [newtopic]                    >                 C'---E'---G'

     If you specify a non-tip revision in <branch-uri> you are
     required to specify this option (or --force) to prevent (or
     acknowledge) HEAD commit loss:  For example, consider the above
     example but with topic@E specified as <branch-uri>.

     [topic]           C---E---G   >         C---E---G
                      /            >        /
     [ancestor]  A---B---D---F     >   A---B---D---F
                                   >                \
     [newtopicuptoE]               >                 C'---E'

     With --as newtopicuptoE no commits are lost but the rebase only
     replays up to commit E to the new topic branch.

     See below for --force.

 --force
     Acknowledge that a rebase result will make existing commits
     unreachable without a specifying peg revision.  This is
     necessary if specifying a non-tip revision when replacing the
     topic branch or when replacing an existing unrelated branch with
     the result of the requested rebase.

     Rebasing topic@E replacing itself with --force.  --force is
     required to acknowledge that G will be omitted from the rebase
     result.

     [ancestor]  A---B---D---F     >   A---B---D---F
                      \            >                \
     [topic]           C---E---G   >                 C'---E'

     In order to subsequently reach G you would have to specify @C,
     @E, or @G as a peg revision to identify the branch instance
     where G still exists.


 ---------------------------------------------------------------------
 Reintegrating (--reintegrate)
 ---------------------------------------------------------------------

 Merge all eligible changesets (or cherry-pick a sub-set of
 changesets) from the topic branch back onto its ancestor branch.

     [ancestor]  A---B---D---F     >   A---B---D---F---H
                      \            >        \         /
     [topic]           C---E---G   >         C---E---G---

 --delete
     Modifies the default --reintegrate behaviour to additionally
     delete the topic branch in the same commit as the reintegration
     merge.  I.e. the topic branch is merged to its ancestor and
     deleted in one atomic operation.

        [ancestor]  A---B---D---F     >   A---B---D---F---H
                         \            >        \         /
        [topic]           C---E---G   >         C---E---G-X

 --rebranch
     As per --reintegrate --delete but in addition makes a second
     commit that recreates the branch from the reintegrated base.

        [ancestor]  A---B---D---F     >   A---B---D---F---H
                         \            >        \         / \
        [topic]           C---E---G   >         C---E---G   I---

 --rebranch-as <new-branch-name-or-uri>
     As per --reintegrate but in addition makes a second commit that
     creates a new branch from the reintegrated base.  If not
     specified as a URL, the name is used to create a branch
     alongside the existing one.

        [topic]           C---E---G   >         C---E---G---
                         /            >        /         \
        [ancestor]  A---B---D---F     >   A---B---D---F---H
                                      >                    \
        [newtopic]                    >                     I---


 ---------------------------------------------------------------------
 Pushing to others (--cherry-pick)
 ---------------------------------------------------------------------

 --to <uri>
     Like --reintegrate but merge branch changes to an alternative
     path instead of to the branch's ancestor.  If no revision (-r)
     argument is given then all eligible branch changes are pushed.

     By default --cherry-pick will make a second commit to record on
     the source branch that the cherry-pick has occurred.  This is
     useful to subversion in the case of subsequent merges from the
     target branch in the other direction.

     The following graph shows an example of pushing revisions F and
     H from 'here' to 'there' (creating merge revision K on 'there')

        [here]   A--B---D--F--H--J--   >   A--B---D--F--H--J--
                     \                 >       \     \   \
                      \                >        \     ¯¯¯¯¯¯\
        [there]        C--E--G--I      >         C--E--G--I--K

     By default a second commit will record that K already exists on
     'here' so that it won't be eligible for any future merge.

        [here]   A--B---D--F--H--J--   >   A--B---D--F--H--J---[L]-
                     \     \   \       >       \     \   \     /
                      \     ¯¯¯¯¯¯\    >        \     ¯¯¯¯¯¯\ /
        [there]        C--E--G--I--K   >         C--E--G--I--K--

     The commit [L] on 'here' records only that K has been merged,
     it includes no content changes.

 --no-source-record
     Cause --cherry-pick to stop after the cherry pick merge and not
     make the source path commit.  This is useful if you know that
     the target will never be merged back to the source.

 Examples: ----------------------------------------------------------

 The following examples assume current directory is
 /path/to/checkout/some/path and that it points at
 the URL svn://server/branches/xyz.

 1. Specifying a source branch.

   svn-rebase
   svn-rebase /some/other/wc/some/path

     Atomically rebases working copy branch against its source at the
     root level (i.e. at /path/to/checkout and /some/other/wc).

   svn-rebase --sub-tree
   svn-rebase --sub-tree /some/other/wc/some/path

     Atomically rebases working copy branch sub-tree against its
     source at the current directory (i.e. at
     /path/to/checkout/some/path and /some/other/wc/some/path).

   svn-rebase svn://some-server/repo/branches/test

     Atomically rebases /branches/test against its source in the repo
     at some-server.

 2. Using a different name for the rebase result

   svn-rebase --as abc
   svn-rebase --as svn://server/branches/abc

     As rebase above but instead of deleting and recreating
     svn://server/branches/xyz, creates instead
     svn://server/branches/abc.

 3. Reintegrating a branch

   svn-reintegrate
   svn-reintegrate svn://server/branches/xyz

     Merge the current branch back to its source keeping the branch
     as is.

   svn-reintegrate --delete
   svn-reintegrate --delete svn://server/branches/xyz

     As above but the commit resulting from this will remove the
     reintegrated branch.  Remember to switch any wc you may have
     pointing at the branch or pass --rebranch to recreate.

   svn-reintegrate --rebranch
   svn-reintegrate --rebranch svn://server/branches/xyz

     As above but creates a subsequent commit recreating the
     branch from the source path after reintegration.

 4. Reintegration parts of a branch

   svn-reintegrate -r10:15,19,24-26

     Reintegrate the following changesets from the branch:
       a) Those starting after revision 10 on the branch
          upto revision 15,
       b) Revision 19
       c) Changesets 24-26 inclusive.
     This leaves the branch unmodified.

 5. Pushing to another branch

   svn-cherry-pick --to svn://server/branches/abc
   svn-cherry-pick --to svn://server/branches/abc -r10:15,19,24-26

     The first line pushes all unmerged branch changes to the 'abc'
     branch.  The second pushes only the revisions described above.