svnbranch 0.2.0

data/bin/svnbranch

@@ -0,0 +1,848 @@
+#!/usr/bin/ruby -w
+# -*- Ruby -*-
+#
+# PURPOSE:  Manage Subversion branches with ease.
+#
+# USAGE:
+#   See man page, or type 'svnbranch help'
+#
+# REQUIREMENT:
+#   RubyGems gem
+#   Watcher gem
+#   Common Subversion repository naming conventions, i.e.:
+#     repos/project/trunk/<main code here>
+#     repos/project/branches/<optional sub-branch>/<branch-name>/<branch-code>
+#     repos/project/tags/<optional sub-branch>/<branch-name>-PRE/<branch-code>
+#     repos/project/tags/<optional sub-branch>/<branch-name>-POST/<branch-code>
+#
+# Created by Karrick McDermott on 2008-07-31.
+# Copyright (c) 2008 All rights reserved.
+######################################################################
+
+# Standard Ruby Installation
+require 'fileutils'
+require 'open3'
+
+# Third-party Gems
+require 'rubygems'
+require 'watcher'
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), '..', 'lib', 'svnbranch'))
+
+######################################################################
+# CONSTANTS
+RSYNC_OPTS = "-a --delete --delete-excluded --exclude '*~' --exclude '#*#'"
+SSH_OPTS='-q -o PasswordAuthentication=no -o StrictHostKeyChecking=no -o ConnectTimeout=2'
+
+######################################################################
+def branch_exists? (repos, branch)
+  # NOTE:  This works for any subdirectory on the Subversion repository,
+  #        including the trunk, branches, and tags.
+
+  # assume branch exists
+  branch_exists = true
+
+  $watcher.verbose("Looking for repository branch [#{branch}]") do
+    # Use begin / rescue rather than Watcher in order to stifle expected
+    # error messages that occur if branch doesn't exist.
+    begin
+      subversion("svn ls #{repos}/#{branch}")
+    rescue
+      # execute will throw if branch missing
+      # If here, then branch was not found
+      branch_exists = false
+    end
+  end
+
+  return branch_exists
+end
+
+######################################################################
+def close_branch! (force = false)
+  # Example:  We are in a branch other than the trunk, and decide to
+  #           call svnbranch, when work is perceived complete on a branch:
+  #           $ svnbranch close
+
+  branch_path = nil
+  repos = nil
+  post_tag = nil
+
+  $watcher.verbose("Checking work environment") do
+    current_dir = inspect_current_work_directory
+    repos = current_dir[:repos]
+    $watcher.debug("repository  = [#{repos}]")
+    # "https://svn.example.com/svn/project_name"
+    branch_path = current_dir[:branch]
+    $watcher.debug("branch_path = [#{branch_path}]")
+    # "trunk"
+    # "branches/bug-fixes/BUG-1234"
+
+    if branch_path == 'trunk'
+      msg = "Cannot close a branch when you are in the trunk"
+      raise RuntimeError.new(msg)
+    end
+
+    # Check for Subversion commit in this directory
+    verify_subversion_commit(Dir.getwd())
+
+    # NOTE:  Expect branch_path like below:
+    #   branches/bug-fixes/BUG-1234
+    branch_path_split = branch_path.split(/\//)
+    branch_name = branch_path_split.pop # capture the right-most element
+    branch_path_split.shift  # discard the prefix (branches | tags)
+    sub_branch = branch_path_split.join('/')  # reassemble
+
+    # If sub-branch empty, then no sub-branch
+    sub_branch = '/' + sub_branch unless sub_branch == ''
+
+    pre_tag = "tags#{sub_branch}/#{branch_name}-PRE"
+    post_tag = "tags#{sub_branch}/#{branch_name}-POST"
+
+    msg = "Verifying branch exists [#{branch_path}]"
+    $watcher.verbose(msg) do
+      [branch_path, pre_tag].each do |b|
+        unless branch_exists?(repos, b)
+          msg = "Resource missing [#{b}] on Subversion server;"
+          raise RuntimeError.new(msg)
+        end
+      end
+    end
+
+    msg = "Verifying branch not yet closed [#{branch_path}]"
+    $watcher.verbose(msg) do
+      if branch_exists?(repos, post_tag)
+        if force
+          remove_branch!(repos, post_tag)
+        else
+          msg = "Resource already exists [#{post_tag}];"
+          msg << " use '-f' to force overwrite"
+          raise RuntimeError.new(msg)
+        end
+      end
+    end
+  end
+
+  # Tag post-work for branch for later merge purposes
+  tag_branch!(repos, branch_path, post_tag)
+end
+
+######################################################################
+def command_exists? (cmd)
+  # determine whether the [cmd] utility exists on system
+  command_exists = false
+
+  $watcher.verbose("Looking for [#{cmd}] utilitiy on system") do
+    # Use begin / rescue rather than Watcher in order to stifle expected
+    # error messages that occur if branch doesn't exist.
+    begin
+      command_exists = execute("which #{cmd}").first.strip
+    rescue
+      # execute will throw if branch missing
+      # If here, then branch was not found
+    end
+  end
+
+  return command_exists
+end
+
+######################################################################
+def copy_branch! (repos, existing_branch, new_branch)
+  msg = "Copying Subversion branch [#{existing_branch}]"
+  msg << " to [#{new_branch}]"
+  $watcher.verbose(msg) do
+    existing_branch = repos + '/' + existing_branch
+    new_branch = repos + '/' + new_branch
+    cmd = "svn copy -m \"#{msg}\" #{existing_branch} #{new_branch}"
+    # NOTE:  Not a 'safe' command because modifies server
+    subversion(cmd, false)
+  end
+end
+
+######################################################################
+def copy_dir! (src, dst)
+  # src -- source directory for copy
+  # dst -- destination directory for copy
+
+  src = File.expand_path(src)
+  dst = File.expand_path(dst)
+  parent = File.expand_path(File.join(dst,'..'))
+
+  msg = "Verifying parent directory [#{parent}] exists"
+  $watcher.debug(msg) do
+    
+  end
+
+  msg = "Copying working directory to new branch directory"
+  $watcher.debug(msg) do
+    # Use [rsync] if available (much more efficient)
+    if command_exists?('rsync') == false
+      copy_dir_with_ruby!(src, dst)
+    else
+      copy_dir_with_rsync!(src, dst)
+    end
+  end
+end
+
+######################################################################
+def copy_dir_with_rsync! (src, dst)
+  # src -- source directory for copy
+  # dst -- destination directory for copy
+
+  # Note:  No need to remove existsing directory or files because
+  # rsync will take care of it.
+
+  msg = "Copying data from [#{src}] to [#{dst}] using Rsync"
+  $watcher.verbose(msg) do
+    cmd = "rsync #{RSYNC_OPTS} #{src}/ #{dst}"
+    execute(cmd)
+  end
+end
+
+######################################################################
+def copy_dir_with_ruby! (src, dst)
+  # src -- source directory for copy
+  # dst -- destination directory for copy
+
+  # Must remove dst if present
+  if File.exists?(dst)
+    $watcher.verbose("Removing previous directory [#{dst}]") do
+      #FileUtils.remove_entry_secure(dst)
+      FileUtils.remove_entry(dst)
+    end
+  end
+
+  msg = "Copying data from [#{src}] to [#{dst}] using Ruby"
+  $watcher.verbose(msg) do
+#    FileUtils.cp_r(src, dst)
+    FileUtils.copy_entry(src, dst, preserve = true)
+  end
+end
+
+######################################################################
+# create_branch!
+#
+# force   -- forces creation of new branch regardless of uncommitted changes
+# new_dir -- true  => create a local copy of branch
+#            false => re-use current working directory
+######################################################################
+def create_branch! (new_branch_name, force, new_dir = true)
+  # Example:  We are in trunk, and decide call svnbranch, as below:
+  #           $ svnbranch create bug-fixes/BUG-1234
+
+  # new_branch_name -- bug-fixes/BUG-1234
+
+
+  start_dir = File.expand_path(Dir.getwd())
+  if new_dir == true
+    parent_dir = File.join(start_dir, '..')
+    $watcher.debug("parent_dir = [#{parent_dir}]")
+    new_dir = File.expand_path(File.join(parent_dir, 'branches', new_branch_name))
+    $watcher.debug("new_dir = [#{new_dir}]")
+    verify_path!(File.expand_path(File.join(new_dir,'..')))
+  end
+
+  # new_branch_path -- branches/bug-fixes/BUG-1234
+  # new_pre_tag     -- tags/bug-fixes/BUG-1234-PRE
+  # new_post_tag    -- tags/bug-fixes/BUG-1234-POST
+  new_branch_path = "branches/#{new_branch_name}"
+  new_pre_tag = "tags/#{new_branch_name}-PRE"
+  new_post_tag = "tags/#{new_branch_name}-POST"
+
+  # parent_branch_path
+  #  if no sub-branches -> ""
+  #  if    sub-branches -> "pat/experimental"
+  path_array = new_branch_path.split(/\//)
+  path_array.pop
+  parent_branch_path = path_array.join('/')
+  $watcher.debug("parent_branch_path = [#{parent_branch_path}]")
+  path_array.shift
+  parent_tags_path = path_array.unshift('tags').join('/')
+  $watcher.debug("parent_tags_path = [#{parent_tags_path}]")
+
+  repos = nil
+  working_branch = nil
+
+  $watcher.verbose("Checking work environment") do
+    if new_branch_name == 'trunk'
+      msg = "Cannot create a trunk branch"
+      raise RuntimeError.new(msg)
+    end
+
+    # repos           -- https://svn.example.com/svn/project
+    # working_branch
+    #  trunk
+    #  pat/experimental
+    current_dir = inspect_current_work_directory
+    repos = current_dir[:repos]
+    $watcher.debug("repository     = [#{repos}]")
+    working_branch = current_dir[:branch]
+    $watcher.debug("working_branch = [#{working_branch}]")
+    
+    # Verify local changes committed
+    if not subversion_committed?(start_dir) and not force
+      msg = "Files in this branch have not been committed;"
+      msg << " use '-f' for force override"
+      raise RuntimeError.new(msg)
+    end
+
+    # Verify / create branch and sub-branches on repository server
+    verify_branch!(repos, parent_branch_path)
+    verify_branch!(repos, parent_tags_path)
+
+    msg = "Verifying branch [#{new_branch_name}] doesn't already exist"
+    $watcher.verbose(msg) do
+      # Ensure branch, PRE-branch, and POST-branch don't exist
+      [new_branch_path, new_pre_tag, new_post_tag].each do |b|
+        # NOTE: Okay to use [branch_exists?] for a tag...
+        if branch_exists?(repos, b)
+          if force
+            remove_branch!(repos, b)
+          else
+            msg = "Resource already exists [#{b}]; check your"
+            msg << " <new-branch> argument, or use '-f' to force overwrite"
+            raise RuntimeError.new(msg)
+          end
+        end
+      end
+    end
+  end
+
+  # Duplicate existing branch on Subversion server
+  copy_branch!(repos, working_branch, new_branch_path)
+
+  # Tag pre-work for branch for later merge purposes
+  tag_branch!(repos, new_branch_path, new_pre_tag)
+
+  if new_dir == false
+    # re-use current working directory
+    switch_branch!(repos, start_dir, new_branch_path)
+  else
+    # When do this?
+    # NOTE:  Although it would be prudent to perform this prior to
+    #        directory duplication so to prevent merging remote updates
+    #        twice, (once for new branch, and once when merging back
+    #        with working_branch), there is a small possibility that user
+    #        would not want this.  THE JURY IS OUT!
+    update_branch!(repos, working_branch) if false
+
+    # Duplicate existing working directory on this host
+    copy_dir!(start_dir, new_dir)
+
+    # Go to new_branch_dir, and tell Subversion to switch it 
+    # to new branch
+    switch_branch!(repos, new_dir, new_branch_path)
+  end
+end
+
+######################################################################
+def delete_branch! (branch_name)
+  # Example:  We are in the trunk, and decide to delete all
+  #           references to a different branch.
+  #           $ svnbranch delete bug-fixes/BUG-1234
+
+  # sub_branch      -- bug-fixes
+  # branch_name     -- BUG-1234
+
+  $watcher.verbose("Checking work environment") do
+    current_dir = inspect_current_work_directory
+    repos = current_dir[:repos]
+    $watcher.debug("repository  = [#{repos}]")
+    #  "https://svn.example.com/svn/project_name"
+
+    branch_path = "branches/#{branch_name}"
+    #   branches/bug-fixes/BUG-1234
+    pre_tag = "tags/#{branch_name}-PRE"
+    #   tags/bug-fixes/BUG-1234-PRE
+    post_tag = "tags/#{branch_name}-POST"
+    #   tags/bug-fixes/BUG-1234-POST
+
+    # Use branch_path from method parameter, not working directory
+    $watcher.debug("branch_path = [#{branch_path}]")
+    $watcher.debug("pre_tag  = [#{pre_tag}]")
+    $watcher.debug("post_tag  = [#{post_tag}]")
+    
+    $watcher.verbose("Deleteing branch [#{branch_path}]") do
+      [branch_path, pre_tag, post_tag].each do |b|
+        if branch_exists?(repos, b)
+          msg = "Deleteing resource [#{b}]"
+          $watcher.verbose(msg) do
+            cmd = "svn rm -m \"#{msg}\" #{repos}/#{b}"
+            # NOTE:  Not a 'safe' command because modifies server
+            subversion(cmd, false)
+          end
+        end
+      end
+    end
+  end
+end
+
+######################################################################
+# execute -- execute a command
+def execute (command)
+  std_out = ''
+  std_err = ''
+
+  $watcher.debug('[' + command + ']') do
+    Open3.popen3(command) do |stdin, stdout, stderr|
+      # read from stdout and stderr (IO classes)
+      std_out = stdout.readlines
+      std_err = stderr.readlines
+    end
+
+    # log the output lines if debugging
+    if std_out.class == Array
+      std_out.each { |line| $watcher.debug(line.strip) }
+    else
+      $watcher.debug(std_out.inspect)
+    end
+  end
+
+  # filter out pseudo-terminal errors
+  std_err.delete_if { |e| e =~ /^Pseudo-terminal/ }
+
+  # check for remaining errors
+  if std_err.length > 0
+    # log the output lines if debugging
+    if std_err.class == Array
+      std_err.each { |line| $watcher.debug(line.strip) }
+    else
+      $watcher.debug(std_err.inspect)
+    end
+    raise RuntimeError.new(std_err.join("\n"))
+  end
+
+  # return the output lines as an array
+  std_out
+end
+
+######################################################################
+def inspect_current_work_directory
+  repos = nil
+  url = nil
+  $watcher.verbose("Inspecting current Subversion work directory") do
+    subversion("svn info").each do |line|
+      if line =~ /^URL: (.*)$/
+        url = $1
+        $watcher.debug("Repository URL: #{$1}") if $DEBUG
+      end
+    end
+    
+    if url == nil
+      msg = "Current directory does not appear to be a Subversion"
+      msg << " working directory"
+      raise RuntimeError.new(msg)
+    end
+  end
+
+  # NOTE:  Current branch may be either [trunk] or some different name.
+  #        If different name, then it should be a member of the
+  #        [branches] subdirectory on the Subversion server.
+
+  # Break up the URL to a repository parent directory and branch name
+  # Example: "https://svn.example.com/svn/project/trunk"
+  #          $1 --> "https://svn.example.com/svn/project"
+  #          $2 --> "trunk"
+  # Example: "https://svn.example.com/svn/project/branches/bug-fixes/BUG-1234"
+  #          $1 --> "https://svn.example.com/svn/project"
+  #          $2 --> "branches/bug-fixes/BUG-1234"
+  md = url.match(/(.*)\/(branches\/.*|trunk)/)
+  return {:repos => md[1], :branch => md[2]}
+end
+
+######################################################################
+def man_page
+  found = false
+  $:.each do |path|
+    if not found
+      filename = File.join(path,'..','man1',File.basename($0)+'.1')
+      filename = File.expand_path(filename)
+      $watcher.debug("Looking for [#{filename}]") do
+        if File.exists?(filename)
+          found = true
+          system("man #{filename}")
+        end
+      end
+    end
+  end
+end
+
+######################################################################
+def make_repository_path! (repos, branch)
+  $watcher.verbose("Creating repository branch [#{branch}]") do
+    cmd = "svn mkdir --parents"
+    cmd << " -m \"Creating repository sub-branch [#{branch}]\""
+    cmd << " #{repos}/#{branch}"
+    # NOTE:  Not a 'safe' command because modifies server
+    subversion(cmd, false)
+  end
+end
+
+######################################################################
+def merge_branch! (merge_branch)
+  # Example:  We are in a branch, and decide to merge in the changes
+  #           from a different branch into this directory.
+  #           $ svnbranch merge bug-fixes/BUG-1234
+
+  # merge_branch    -- bug-fixes/BUG-1234
+  # sub_branch      -- bug-fixes
+  # branch_name     -- BUG-1234
+
+  repos = nil
+  working_branch = nil
+  merge_branch_path = "branches/#{merge_branch}"
+  #   branches/bug-fixes/BUG-1234
+  merge_pre_tag = "tags/#{merge_branch}-PRE"
+  #   tags/bug-fixes/BUG-1234-PRE
+  merge_post_tag = "tags/#{merge_branch}-POST"
+  #   tags/bug-fixes/BUG-1234-POST
+
+  $watcher.verbose("Checking work environment") do
+    if merge_branch == 'trunk'
+      msg = "Cannot merge the trunk branch into a different branch."
+      raise RuntimeError.new(msg)
+    end
+
+    current_dir = inspect_current_work_directory
+    repos = current_dir[:repos]
+    $watcher.debug("repository  = [#{repos}]")
+    # "https://svn.example.com/svn/project_name"
+    working_branch = current_dir[:branch]
+    # "trunk"
+    # "branches/2.1-maint"
+
+    msg = "Verifying branch exists [#{merge_branch_path}]"
+    $watcher.verbose(msg) do
+      [merge_branch_path, merge_pre_tag, merge_post_tag].each do |b|
+        unless branch_exists?(repos, b)
+          msg = "Resource missing [#{b}]; check your"
+          msg << " <merge-branch> argument"
+          raise RuntimeError.new(msg)
+        end
+      end
+    end
+
+    # Update this Subversion work directory
+    update_branch!(repos, working_branch)
+  end
+
+  # Pull in diff from PRE to POST into this work directory
+  msg = "Merging changes from branch [#{merge_branch}] into "
+  msg << "working directory [#{Dir.getwd()}]"
+  $watcher.verbose(msg) do
+    # NOTE:  This gets the diffs between the PRE- and POST- tags, then applies
+    #        those changes to the current directory.
+    # NOTE:  Because the destination working directory is left off of this
+    #        command, Subversion will apply the diffs to the current
+    #        directory.  It is imperative to be in the working directory when
+    #        the below command is invoked.
+    cmd = "svn merge #{repos}/#{merge_pre_tag} #{repos}/#{merge_post_tag}"
+    subversion(cmd)
+  end
+
+  msg = "The changes for [#{merge_branch}] have been merged into the"
+  msg << " working directory [#{Dir.getwd()}]"
+  $watcher.always(msg)
+  $watcher.always("=================================================================")
+  $watcher.always("= NOW BUILD, TEST, AND RESOLVE PROBLEMS BEFORE YOU COMMIT!      =")
+  $watcher.always("= (Do *not* re-merge the same merge branch into this directory) =")
+  $watcher.always("= Please add the below line into your next commit log:          =")
+  $watcher.always("=   \"Merged [#{merge_branch}] into [#{working_branch}].\"         =")
+  $watcher.always("=============================================================
+====")
+end
+
+######################################################################
+# Remove traces of a branch (or tag) if it exists
+def remove_branch! (repos, branch)
+  if branch_exists?(repos, branch)
+    msg = "Removing Subversion branch [#{branch}]"
+    $watcher.verbose(msg) do
+      cmd = "svn rm -m \"#{msg}\" #{repos}/#{branch}"
+      # NOTE:  Not a 'safe' command because modifies server
+      subversion(cmd, false)
+    end
+  end
+end
+
+######################################################################
+# Easily turn off execution of subversion commands while developing
+# A 'safe' command doesn't change Subversion repository on server.
+def subversion (command, safe = true)
+  if safe or not $DEBUG
+    return execute(command)
+  else
+    return $watcher.debug("SIMULATE: [#{command}]")
+  end
+end
+
+######################################################################
+def subversion_committed? (branch_dir)
+  subversion_committed = false
+
+  msg = "Determining whether changes committed back to branch"
+  msg << " [#{branch_dir}]"
+  $watcher.verbose(msg) do
+    # Use begin / rescue rather than Watcher to stifle expected
+    # error messages when branch doesn't exist.
+    begin
+      cmd = "svn status #{branch_dir}"
+      # status = subversion(cmd).split(/\n/).delete_if do |line|
+      status = subversion(cmd).delete_if do |line|
+        line =~ /(^X\s+)|(^\s*$)|(^Performing\s)|(^\?\s+README.txt)/
+      end
+
+      if status.length > 0
+        # NOT NEEDED SINCE status COMMAND LISTS
+        # status.each { |line| $watcher.debug(line) }
+        raise RuntimeError.new("Must commit changes to branch first") 
+      end
+
+      # execute will throw if branch missing
+      # If here, then branch was found
+      subversion_committed = true
+    rescue
+      # no-op
+    end
+  end
+
+  return subversion_committed
+end
+
+######################################################################
+def switch_branch! (repos, branch_dir, branch_path)
+  # branch_dir    -- Subversion work directory where switch
+  # branch_path   -- Subversion branch path
+
+  msg = "Switching [#{branch_dir}] directory to newly created "
+  msg << "branch [#{branch_path}]"
+  $watcher.verbose(msg) do
+    cmd = "svn switch #{repos}/#{branch_path} #{branch_dir}"
+    subversion(cmd)
+  end
+end
+
+######################################################################
+def switch_this_dir! (branch_name)
+  # branch_name    -- branch name to switch to
+
+  repos = nil
+
+  # If trunk specified, no 'branches' prefix is required.
+  if branch_name == 'trunk'
+    branch_path = branch_name
+  else
+    branch_path = "branches/#{branch_name}"
+  end
+  $watcher.debug("branch_path  = [#{branch_path}]")
+
+  $watcher.verbose("Checking work environment") do
+    current_dir = inspect_current_work_directory
+    repos = current_dir[:repos]
+    $watcher.debug("repository  = [#{repos}]")
+    # "https://svn.example.com/svn/project_name"
+    working_branch = current_dir[:branch]
+    # "trunk"
+    # "branches/2.1-maint"
+
+    # Check for Subversion commit in this directory
+    verify_subversion_commit(Dir.getwd())
+
+    # Verify / create branch and sub-branches on repository server
+    verify_branch!(repos, branch_path)
+  end
+
+  switch_branch!(repos, Dir.getwd(), branch_path)
+end
+
+######################################################################
+def tag_branch! (repos, branch, tag)
+  # branch   -- branch into which changes are placed
+  # tag      -- tag to use to mark the start or end of branch
+  #             (for merging)
+
+  status = if tag =~ /-PRE$/
+             'the start of '
+           elsif tag =~ /-POST$/
+             'the end of '
+           else
+             ''
+           end
+
+  msg = "Creating Subversion tag to mark #{status}[#{branch}]"
+  $watcher.verbose(msg) do
+    branch = repos + '/' + branch
+    tag = repos + '/' + tag
+    cmd = "svn copy -m \"#{msg}\" #{branch} #{tag}"
+    # NOTE:  Not a 'safe' command because modifies server
+    subversion(cmd, false)
+  end
+end
+
+######################################################################
+def update_branch! (repos, branch_name)
+  msg = "Updating Subversion work directory from [#{branch_name}]"
+  $watcher.verbose(msg) do
+    subversion("svn up")
+  end
+end
+
+######################################################################
+def verify_branch! (repos, branch)
+  # Ensures branch exists on repository, or throws exception
+
+  # This block sets up our condition handling mechanism:
+  #   Make 2 passes: if first fails because of missing branch,
+  #   attempt to create the branch.
+  #   For other failures, re-raise exception.
+  params = {:failure => :error, :tries => 2, :proc => lambda do |e|
+      if e.message =~ /branch not found/
+        make_repository_path!(repos, branch)
+      else
+        # if not a simple "branch not found" error, then punt
+        raise
+      end
+    end
+  }
+  
+  # This code does the verification, and invokes condition handling
+  $watcher.verbose("Verifying repository branch [#{branch}]", params) do
+    unless branch_exists?(repos, branch)
+      raise RuntimeError.new("branch not found [#{branch}]")
+    end
+  end
+end
+
+######################################################################
+def verify_path! (path)
+  # Ensures path exists on local system, or throws exception
+
+  # This block sets up our condition handling mechanism:
+  #   Make 2 passes: if first fails because of missing path,
+  #   attempt to create the path.
+  #   For other failures, re-raise exception.
+  params = {:failure => :error, :tries => 2, :proc => lambda do |e|
+      if e.message =~ /path not found/
+        FileUtils.mkdir_p(path)
+      else
+        # if not a simple "path not found" error, then punt
+        raise
+      end
+    end
+  }
+  
+  # This code does the verification, and invokes condition handling
+  $watcher.verbose("Verifying path exists [#{path}]", params) do
+    unless File.directory?(path)
+      raise RuntimeError.new("path not found [#{path}]")
+    end
+  end
+end
+
+######################################################################
+def verify_subversion_commit (branch_dir)
+  msg = "Verifying data in this Subversion working directory are"
+  msg << " committed [#{branch_dir}]"
+  $watcher.verbose(msg) do
+    unless subversion_committed?(branch_dir)
+      msg = "Must commit changes to working directory first."
+      raise RuntimeError.new(msg)
+    end
+  end
+end
+
+######################################################################
+# DO NOT ENCLOSE; MUST RUN AT TOP-LEVEL OF FILE FOR BIN INSTALLATION.
+# if $0 == __FILE__
+  start_dir = Dir.getwd()
+
+  force = false        # Do not force a change if error
+  switch = false       # Switch present working directory
+  options = true
+  verbosity = :verbose
+
+# $DEBUG = true
+
+  while options
+    case ARGV[0]
+    when '-d' : verbosity = :debug ; ARGV.shift
+    when '-f' : force = true ; ARGV.shift
+    when '-s', '--switch' : switch = true ; ARGV.shift
+    when '-v' : verbosity = :verbose ; ARGV.shift
+    when '--version'
+      puts Svnbranch::VERSION
+      exit
+    when '-q' : verbosity = :always ; ARGV.shift
+    else options = false
+    end
+  end
+
+  $watcher = Watcher.create(:verbosity => verbosity,
+                            :warn_symbol => 'WARNING',
+                            :error_symbol => 'ERROR')
+
+  begin
+    errors = false
+    $watcher.debug("Validating command line arguments") do
+      msg = "usage:\n"
+      case ARGV.shift
+      when '-h', '--help', 'help'
+        man_page
+        exit
+      when 'create'
+        if ARGV.length == 1
+          create_branch!(ARGV.shift, force, !switch)
+        else
+          msg << "  #{File.basename($0)} [ -s ] create [<sub-branch>/]<new-branch>\n\n"
+          STDERR.puts msg
+          raise ArgumentError.new("Invalid command line arguments")
+        end
+      when 'close'
+        if switch == false and ARGV.length == 0
+          close_branch!(force)
+        else
+          msg << "  #{File.basename($0)} close\n\n"
+          STDERR.puts msg
+          raise ArgumentError.new("Invalid command line arguments")
+        end
+      when 'merge'
+        if switch == false and ARGV.length == 1
+          merge_branch!(ARGV.shift)
+        else
+          msg << "  #{File.basename($0)} merge [<sub-branch>/]<merge-branch>\n\n"
+          STDERR.puts msg
+          raise ArgumentError.new("Invalid command line arguments")
+        end
+      when 'delete'
+        if switch == false and ARGV.length == 1
+          delete_branch!(ARGV.shift)
+        else
+          msg << "  #{File.basename($0)} delete [<sub_branch>/]<doomed-branch>\n\n"
+          STDERR.puts msg
+          raise ArgumentError.new("Invalid command line arguments")
+        end
+      when 'switch'
+        if switch == false and ARGV.length == 1
+          switch_this_dir!(ARGV.shift)
+        else
+          msg << "  #{File.basename($0)} switch [<sub_branch>/]<switch-branch>\n\n"
+          STDERR.puts msg
+          raise ArgumentError.new("Invalid command line arguments")
+        end
+      else
+        msg << "  #{File.basename($0)} [ -s ] create [<sub-branch>/]<new-branch>\n"
+        msg << "  #{File.basename($0)} close\n"
+        msg << "  #{File.basename($0)} merge [<sub-branch>/]<merge-branch>\n"
+        msg << "  #{File.basename($0)} delete [<sub_branch>/]<doomed-branch>\n"
+        msg << "  #{File.basename($0)} switch [<sub_branch>/]<switch-branch>\n\n"
+        STDERR.puts msg
+        raise ArgumentError.new("Invalid command line arguments")
+      end
+    end
+  rescue
+    errors = true
+    Dir.chdir(start_dir)
+  end
+
+  exit errors == false
+#end