subcheat 0.3.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Arjan van der Gaag
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,96 @@
+= subcheat
+
+Subcheat is a simple wrapper around Subversion's svn command-line client.
+
+<b>This is hobby project I'm hacking away on. Poke around at your own peril.</b>
+
+== Description
+
+<tt>subcheat</tt> functions the same way svn does. You could alias <tt>subcheat</tt> to <tt>svn</tt> and use <tt>subcheat</tt> from now on without ever noticing it.
+
+<tt>subcheat</tt> adds some subcommands that can make your life a little easier:
+
+* <tt>subcheat undo</tt>: roll-back a commit or range of commits.
+* <tt>subcheat tag</tt>: create, show or delete tags
+* <tt>subcheat branch</tt>: create, show or delete branches
+* <tt>subcheat reintegrate</tt>: merge changes from a branch back into trunk
+* <tt>subcheat rebase</tt>: merge changes from trunk into current branch
+* <tt>subcheat url</tt>: output the current working copy URL
+* <tt>subcheat root</tt>: output the current project root folder
+* <tt>subcheat path</tt>: output the current path in the repository
+* <tt>subcheat revision</tt>: output the current revision number
+
+Also, some existing subcommands are enhanced:
+
+* <tt>subcheat export</tt>: now expands simple tag names to tag URLs
+* <tt>subcheat switch</tt>: now expands simple branch names to branch URLs
+
+=== Examples
+
+Rolling back a commit is basically reverse-merging a revision into the current working copy. The following are equivalent:
+
+  subcheat undo 5000
+  svn merge -r 5000:4999 url/to/current/repo
+
+Managing branches and tags are basic <tt>copy</tt> and <tt>list</tt> operations. The following are equivalent:
+
+  # assume we're in /svn/project/trunk
+  subcheat branch foo
+  svn copy /svn/project/trunk /svn/project/branches/foo
+
+  subcheat branch -d foo
+  svn delete /svn/project/branches/foo
+
+  subcheat branch
+  svn list /svn/project/branches
+
+Note that tags and branches work the same but operate on the +tags+ and +branches+ subdirectories respectively.
+
++reintegrate+ and +rebase+ are two similar tools for managing feature branches. These basically merge changes from a branch into trunk, or the other way around. These commands first determine the revision number that created the branch and then merge from that revision to +HEAD+. So, the following are equivalent:
+
+  # Subcheat
+  subcheat reintegrate foo
+
+  # Regular
+  svn log /svn/project/branches/foo --stop-on-copy
+  # note that revision number that created the branch is 5000
+  svn merge -r 5000:HEAD /svn/project/branches/foo .
+
+Both +reintegrate+ and +rebase+ can accept a revision number as an argument to start the revision range to merge somewhere other than the branch starting point.
+
+== Installation
+
+This project will some day be released as a gem, so you can install it as easily as <tt>sudo gem install subcheat</tt>, but for now you will have to clone the project itself and include <tt>./bin/subcheat</tt> in your path in some way.
+
+Once you've got it set up, you should really alias <tt>svn</tt> to subcheat in your shell.
+
+== Assumptions
+
+Subcheat assumes a particular layout for your repository:
+
+  [root]
+   `- project1
+      `- trunk
+      `- branches
+      `- tags
+   `- project2
+      `- trunk
+      `- branches
+      `- tags
+   `- ...
+
+It might some day be made more flexible, but this works for me right now.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2009 Arjan van der Gaag. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "subcheat"
+    gem.summary = %Q{Wrapper for Subversion CLI}
+    gem.description = %Q{Wrap the Subversion CLI to extract some usage patterns into commands}
+    gem.email = "arjan@arjanvandergaag.nl"
+    gem.homepage = "http://github.com/avdgaag/subcheat"
+    gem.authors = ["Arjan van der Gaag"]
+    gem.add_development_dependency "thoughtbot-shoulda", ">= 0"
+    gem.add_development_dependency "cucumber", ">= 0"
+    gem.add_development_dependency "mocha", ">= 0.9.8"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/test_*.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+
+  task :features => :check_dependencies
+rescue LoadError
+  task :features do
+    abort "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "subcheat #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/bin/subcheat

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.join(File.dirname(__FILE__), *%w{.. lib subcheat})
+Subcheat::Runner.new(*ARGV)

data/features/shortcuts.feature

@@ -0,0 +1,14 @@
+Feature: Subversion shortcuts
+  In order to speed up development
+  As a user
+  I want to enter common subversion commands quicker
+
+  Scenario: updating without externals
+    Given a working copy
+    When I run "subcheat uie"
+    Then subcheat should run "svn update --ignore-externals"
+
+  Scenario: get common working copy information
+    Given a working copy with attribute Revision: 54
+    When I run "subcheat revision"
+    Then subcheat should output "54"

data/features/step_definitions/wrapper_steps.rb

@@ -0,0 +1,24 @@
+Before do
+  Subcheat::Runner.output = StringIO.new
+  Subcheat::Runner.perform_run = false
+end
+
+Given /^a working copy$/ do
+  @wc ||= {}
+end
+
+Given /^(?:a working copy )?with attribute ([^:]+?): (.+?)$/ do |attribute, value|
+  Subcheat::Svn.any_instance.expects(:attr).with(attribute).returns(value)
+end
+
+When /^I run "subcheat([^\"]*)"$/ do |arguments|
+  Subcheat::Runner.new(*arguments.strip.split(/\s+/))
+end
+
+Then /^subcheat should run "([^\"]*)"$/ do |command|
+  assert_equal command, Subcheat::Runner.output.string.gsub(/\s*$/, '')
+end
+
+Then /^subcheat should output "([^\"]*)"$/ do |output|
+  assert_match(/#{output}/, Subcheat::Runner.output.string)
+end

data/features/subcommands.feature

@@ -0,0 +1,19 @@
+Feature: new subcheat subcommands
+  In order to make working with subversion a little easier
+  As a user
+  I want to use simple commands for complex patterns
+
+  Scenario: rolling back a commit
+    Given a working copy with attribute URL: foo
+    When I run "subcheat undo 50"
+    Then subcheat should run "svn merge -r 50:49 foo"
+
+  Scenario: rolling back a commit from a different URL
+    Given a working copy with attribute URL: foo
+    When I run "subcheat undo 50 bar"
+    Then subcheat should run "svn merge -r 50:49 bar"
+
+  Scenario: rolling back a range of commits
+    Given a working copy with attribute URL: foo
+    When I run "subcheat undo 50:60"
+    Then subcheat should run "svn merge -r 60:50 foo"

data/features/support/env.rb

@@ -0,0 +1,5 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'subcheat'
+require 'mocha'
+require 'test/unit/assertions'
+World(Test::Unit::Assertions)

data/features/wrapper.feature

@@ -0,0 +1,19 @@
+Feature: invisibly wrap svn
+  In order to transparently replace svn
+  As a user
+  I want to use normal svn commands
+
+  Scenario: pass through commands
+    Given a working copy
+    When I run "subcheat update"
+    Then subcheat should run "svn update"
+
+ Scenario: pass through commands with arguments
+   Given a working copy
+   When I run "subcheat update . --force"
+   Then subcheat should run "svn update . --force"
+
+ Scenario: pass through default command
+   Given a working copy
+   When I run "subcheat"
+   Then subcheat should run "svn help"

data/lib/subcheat/command.rb

@@ -0,0 +1,108 @@
+module Subcheat
+
+  # == Introduction
+  # A command is a simple combination of a subcommand name and a proc object
+  # that generates a subversion command. When invoking subcheat with a
+  # subcommand the +Command+ object with by that name is looked up and executed
+  # in the context of current directory (usually a working copy.)
+  #
+  # == Usage
+  #
+  # === Command Creation
+  #
+  # Commands are created with a special shorthand syntax:
+  #
+  #   Command.define('subcommand-name') do
+  #     # do something useful here
+  #   end
+  #
+  # Commands are then stored in the +Command+ class, which can be queried:
+  #
+  #   Command.on('subcommand-name')
+  #
+  # The returning subcommand can then be executed given a specific
+  # Subversion context (an instance of <tt>Subcheat::Svn</tt>):
+  #
+  #   Command.on('subcommand-name').call(Svn.new)
+  #
+  # === Writing Commands
+  #
+  # Because commands get executed in a <ttr>Subcheat::SVN</tt> context, they
+  # have access to all its methods and instance variables. See
+  # <tt>Subcheat::SVN</tt> for more information.
+  #
+  # Note that a command should always return either a Subversion command
+  # statement as a string (e.g. "svn status"). If it returns nothing,
+  # nothing will be done.
+  #
+  # Commands can be stored in the <tt>lib/subcheat/commands</tt> directory,
+  # so they will be automatically loaded together with this class. Filenames
+  # are irrelevant.
+  #
+  # === Exceptions
+  #
+  # When something goes wrong, commands can raise a +CommandException+
+  # exception. When querying Command for a non-existant subcommand a
+  # +NoSuchCommand+ exception will be raised.
+  class Command
+    # Name of the subcommand to which this command should respond.
+    attr_reader :subcommand
+
+    # Should the output be executed as a shell command, or printed?
+    attr_reader :execute
+
+    # List of available commands that can be invoked.
+    @commands = []
+
+    class << self
+      # List of all available commands
+      attr_reader :commands
+
+      #:call-seq: define(subcommand, &block)
+      #
+      # Shortcut method to creating and registering a new +Command+ object.
+      #
+      # This will instantiate a new +Command+ with the given subcommand name,
+      # and the given block as its method to execute when invoked.
+      #
+      # Example usage:
+      #
+      #   Command.define('nuke') do
+      #     exec "rm -Rf"
+      #   end
+      #
+      def define(*args, &block)
+        @commands << new(*args, &block)
+      end
+
+      # Query for a +Command+ object by the given subcommand name.
+      #
+      # This will return either a +Command+ object to be invoked, or it will
+      # raise a +NoSuchCommand+ exception.
+      def on(subcommand)
+        command = @commands.select { |c| c.subcommand == subcommand }.first
+        raise NoSuchCommand if command.nil?
+        command
+      end
+    end
+
+    def initialize(subcommand, execute = true, &block) #:nodoc:
+      @subcommand, @execute, @method = subcommand, execute, block
+    end
+
+    # Invoke the +Command+'s method to generate and return a subversion CLI
+    # statement.
+    #
+    # This requires an instance of <tt>Subcheat::Svn</tt> to be passed in,
+    # which will be used as context to execute the method in.
+    def call(svn)
+      Subcheat::Runner.perform_run = false unless execute
+      svn.instance_eval(&@method)
+    end
+  end
+end
+
+# Load command library from the /commands dir
+Dir[File.join(File.dirname(__FILE__), 'commands', '*.rb')].each do |filename|
+  require filename
+end

data/lib/subcheat/commands/branch_and_tag.rb

@@ -0,0 +1,63 @@
+# Manage branches
+#
+#   > svn branch -l
+#
+# List all branches for the current project.
+#
+#   > svn branch -d FB-refactor
+#
+# Remove branch 'FB-refactor'
+#
+#   > svn branch FB-refactor
+#
+# Create branch 'FB-refactor'
+Subcheat::Command.define('branch') do
+  if delete = arguments.delete("-d")
+    raise Subcheat::CommandException, 'No URL to delete given.' unless arguments[0]
+    "svn delete %sbranches/%s %s" % [
+      attr('URL'),
+      arguments[0],
+      arguments[1..-1].join(' ')
+    ]
+  elsif list = arguments.delete('-l') || !arguments.any?
+    "svn list #{base_url}branches/"
+  else
+    "svn copy %s %s %s" % [
+      attr('URL'),
+      base_url + "branches/#{arguments[0]}",
+      arguments[1..-1].join(' ')
+    ]
+  end
+end
+
+# Manage tags
+#
+#   > svn tag -l
+#
+# List all tags for the current project.
+#
+#   > svn tag -d REL-1.0
+#
+# Remove tag 'REL-1.0'
+#
+#   > svn tag REL-1.0
+#
+# Create tag 'REL-1.0'
+Subcheat::Command.define('tag') do
+  if delete = arguments.delete("-d")
+    raise Subcheat::CommandException, 'No URL to delete given.' unless arguments[0]
+    "svn delete %tags/%s %s" % [
+      attr('URL'),
+      arguments[0],
+      arguments[1..-1].join(' ')
+    ]
+  elsif list = arguments.delete('-l') || !arguments.any?
+    "svn list #{base_url}tags/"
+  else
+    "svn copy %s %s %s" % [
+      attr('URL'),
+      base_url + "tags/#{arguments[0]}",
+      arguments[1..-1].join(' ')
+    ]
+  end
+end

data/lib/subcheat/commands/branching.rb

@@ -0,0 +1,48 @@
+# Merge changes from trunk into a branch.
+#
+#   > svn rebase
+#
+# This will merge all changes from trunk to the current working copy from its
+# branch point to the HEAD revision. This will only work when you're inside a
+# branch working copy.
+#
+# You can optionally specify the revision number to merge from:
+#
+#   > svn rebase 5032
+#
+# This will merge from 5032:HEAD.
+Subcheat::Command.define('rebase') do
+  raise Subcheat::CommandException, 'You can only rebase a branch working copy.' unless attr('URL') =~ /branches/
+  logs = log('.', '--stop-on-copy') unless arguments[0]
+  if logs
+    branch_point = logs.scan(/^r(\d+) \|/).flatten.last
+  else
+    raise Subcheat::CommandException, 'Could not calculate branch starting point. Please provide explicitly.' unless arguments[0]
+  end
+  "svn merge -r #{(arguments[0] || branch_point)}:HEAD #{base_url}trunk ."
+end
+
+# Merge changes from a branch back into trunk.
+#
+#   > svn reintegrate FB-refactor
+#
+# This will merge all changes from /branches/FB-refactor from its starting point
+# to the HEAD revision back into the current working copy. This is intended to be used
+# inside a /trunk working copy.
+#
+# Optionally, you can specify the starting point of the merge, rather than using the
+# branch starting point:
+#
+#   > svn reintegrate FB-refactor 5032
+#
+# This will merge in changes from the branch from range 5032:HEAD.
+Subcheat::Command.define('reintegrate') do
+  branch_url = "#{base_url}branches/#{arguments[0]}"
+  logs = log(branch_url, '--stop-on-copy') unless arguments[1]
+  if logs
+    branch_point = logs.scan(/^r(\d+) \|/).flatten.last
+  else
+    raise Subcheat::CommandException, 'Could not calculate branch starting point. Please provide explicitly.' unless arguments[1]
+  end
+  "svn merge -r #{(arguments[1] || branch_point)}:HEAD #{branch_url} ."
+end

data/lib/subcheat/commands/info.rb

@@ -0,0 +1,20 @@
+Subcheat::Command.define('url', false) do
+  attr('URL')
+end
+
+Subcheat::Command.define('revision', false) do
+  attr('Revision')
+end
+
+Subcheat::Command.define('path', false) do
+  attr('URL').sub(attr('Repository Root'), '')
+end
+
+Subcheat::Command.define('root', false) do
+  attr('Repository Root')
+end
+
+Subcheat::Command.define('--version') do
+  puts 'Subcheat ' + Subcheat.version
+  'svn --version'
+end

data/lib/subcheat/commands/shortcuts.rb

@@ -0,0 +1,57 @@
+Subcheat::Command.define('uie') do
+  "svn update --ignore-externals #{arguments.join(' ')}"
+end
+
+# Check Out Project: shortcut to check out a working copy from the repository
+#
+#   > svn cop my-project
+#
+# This will checkout the ^/my-project/trunk folder to the my-project dir in
+# the current directory. You may specify a specific branch or tags:
+#
+#   > svn cop my-project/tags/REL-1.0
+#
+# You may also specify the directory name to create the new working copy in:
+#
+#   > svn cop my-project new-dir
+Subcheat::Command.define('cop') do
+  raise 'NYI'
+  url = 'http://repo/' + arguments[0]
+  url += '/trunk' unless url =~ /trunk|tags|branches/
+  dir = arguments[0].gsub(/^www\.|\.(?:nl|fr|be|com).*$/i, '')
+  arguments.insert(1, dir) if (arguments[1] && arguments[1] =~ /^-+/) || arguments[1].nil?
+  "svn checkout #{url} #{arguments[1..-1].join(' ')}"
+end
+
+# Enable exporting of tags
+#
+#   > svn export REL-1.0 ~/Desktop/export
+#
+# This will now export the 'REL-1.0' tag from the 'tags' directory of the repo.
+# def export(args)
+#   args[1] = project_root_url + '/tags/' + args[1] if args[1] =~ /^[a-zA-Z\-_0-9]+$/
+# end
+Subcheat::Command.define('export') do
+  if arguments[0] =~ /^[a-zA-Z\-_0-9]+$/
+    "svn export %stags/%s %s" % [
+      base_url,
+      arguments[0],
+      arguments[1..-1].join(' ')
+    ]
+  end
+end
+
+# Enable switching to branch names.
+#
+#   > svn switch FB-refactor
+#
+# This will now switch the current working copy to the 'FB-refactor' branch.
+Subcheat::Command.define('switch') do
+  if arguments[0] =~ /^[a-zA-Z\-_0-9]+$/
+    "svn switch %sbranches/%s %s" % [
+      base_url,
+      arguments[0],
+      arguments[1..-1].join(' ')
+    ]
+  end
+end

data/lib/subcheat/commands/undo.rb

@@ -0,0 +1,22 @@
+# Undo a commit or range of commits.
+#
+# This reverse-merges one or more revision into the current working copy.
+#
+#   > svn undo 45
+#   > svn undo 45:50
+#
+# This will merge in 45:44 and 50:45 respectively. The source to merge from
+# is the current working copy URL by default, but you may specify your own:
+#
+#   > svn undo 5034 ^/my-project/trunk
+Subcheat::Command.define('undo') do
+  revision, url = arguments[0], arguments[1]
+  revision = case revision
+    when /^\d+$/: "#{revision}:#{revision.to_i - 1}"
+    when /^\d+:\d+$/: revision.split(':').reverse.join(':')
+    else
+      raise Subcheat::CommandException, "Bad revision: #{revision}"
+  end
+  url ||= attr('URL')
+  "svn merge -r #{revision} #{url}"
+end

data/lib/subcheat/exceptions.rb

@@ -0,0 +1,14 @@
+module Subcheat
+  # General-purpose program-specific exception.
+  Exception        = Class.new(Exception)
+
+  # Raised when looking for a custom command that does not exist.
+  NoSuchCommand    = Class.new(Exception)
+
+  # Raised when trying to have subversion work on a directory
+  # that is not a working copy.
+  NotAWorkingCopy  = Class.new(Exception)
+
+  # General-purpose exception that commands can raise to halt execution.
+  CommandException = Class.new(Exception)
+end

data/lib/subcheat/runner.rb

@@ -0,0 +1,71 @@
+module Subcheat
+  # the Runner handles this program's input and output, and selects and
+  # invokes the commands to run.
+  #
+  # == Program flow
+  #
+  # 1. The user invokes subcheat via the command line: <tt>subcheat foo</tt>
+  # 2. The CLI creates a new runner.
+  # 3. The +Runner+ finds a custom Command by the name +foo+ and invokes it.
+  # 4. The +Command+ returns a Subversion command to be executed.
+  # 5. The +Runner+ executes the command and exits.
+  #
+  # If no custom command for the given subcommand name was found, it will
+  # be passed along to +svn+ itself. This way, subcheat is a transparent
+  # wrapper around +svn+.
+  #
+  # == Testing
+  #
+  # You can control where output is sent by overriding +output+, which
+  # defaults to <tt>$stdin</tt>. You can also prevent the actual
+  # execution of commands by setting +perform_run+ to +false+.
+  class Runner
+    class << self
+      # Usually <tt>$stdin</tt>, but might be overridden
+      attr_accessor :output
+
+      # Switch that controls whether commands are executed in the system,
+      # or simply sent to the output stream.
+      attr_accessor :perform_run
+
+      # Print something to the output stream
+      def write(msg)
+        self.output.puts(msg)
+      end
+
+      # Run a command in the system.
+      # Setting +perform_run+ to +false+ will make it just output the command,
+      # rather than executing it.
+      def run(command)
+        (perform_run.nil? || perform_run) ? exec(command) : self.write(command)
+      end
+    end
+
+    # Create a new runner by passing it all the arguments that the
+    # command-line client received.
+    #
+    # The first argument is the name of the subcommand, and defaults to
+    # 'help'. The rest are arguments passed to the subcommand.
+    #
+    # Creating a new runner will immediately run the given subcommand.
+    def initialize(*args)
+      # Default to $stdout
+      self.class.output = $stdout if self.class.output.nil?
+
+      # Gather subcommand and arguments
+      subcommand, *arguments = args
+      subcommand ||= 'help'
+      arguments  ||= []
+
+      begin
+        self.class.run Command.on(subcommand).call(Svn.new(arguments))
+      rescue NotAWorkingCopy
+        # ...
+      rescue NoSuchCommand
+        self.class.run "svn #{subcommand} #{arguments.join(' ')}".strip
+      rescue CommandException
+        puts $!
+      end
+    end
+  end
+end

data/lib/subcheat/svn.rb

@@ -0,0 +1,51 @@
+module Subcheat
+  class Svn
+
+    # The arguments passed to the subcommand
+    attr_accessor :arguments
+
+    def initialize(arguments)
+      @arguments = arguments
+    end
+
+    # Shortcut method to the base url for the current project in the current repo.
+    def base_url
+      attr('URL').split(/branches|tags|trunk/).first
+    end
+
+    # Interact with Subversion through the command-line interface +svn+.
+    module Cli
+      # Extract a working copy attribute, like URL or revision number.
+      def attr(name)
+        info[/^#{name}: (.+?)$/, 1]
+      end
+
+      # Read the Subversion logs for a given path.
+      def log(repo, *arguments)
+        svn("log #{repo} #{[*arguments].join(' ')}")
+      end
+
+      # Retrieve information about the working copy.
+      def info
+        @info ||= svn('info')
+      end
+
+    private
+
+      # Execute a subversion command in the shell, or raise an exception if
+      # the target path is not actually a subversion working copy.
+      #--
+      # TODO: make this customizable, since users might sometimes ask for
+      #       information about other paths than the current path.
+      def svn(subcommand)
+        output = `svn #{subcommand}`
+        raise Subcheat::NotAWorkingCopy if output.empty?
+        output
+      end
+    end
+
+    # other modules may implement other ways of working with subversion
+    # (like using the ruby bindings) but we choose the command-line client.
+    include Cli
+  end
+end

data/lib/subcheat.rb

@@ -0,0 +1,12 @@
+# Require all subcheat components
+%w{exceptions runner svn command}.each do |filename|
+  require File.join(File.dirname(__FILE__), 'subcheat', filename)
+end
+
+module Subcheat
+  # Report the version number from /VERSION
+  def version
+    File.read(File.join(File.dirname(__FILE__), *%w{.. VERSION}))
+  end
+  extend self
+end

data/test/helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'subcheat'
+
+class Test::Unit::TestCase
+  def disable_running_of_commands
+    Subcheat::Runner.output = StringIO.new
+    Subcheat::Runner.perform_run = false
+  end
+
+  def subcheat_output
+    Subcheat::Runner.output.string.chomp
+  end
+end

data/test/test_command.rb

@@ -0,0 +1,21 @@
+require 'helper'
+
+class TestRunner < Test::Unit::TestCase
+  context "creating a command" do
+    should "create a command" do
+      old_count = Subcheat::Command.commands.size
+      Subcheat::Command.define('name') { puts 'foo' }
+      assert_equal(old_count + 1, Subcheat::Command.commands.size)
+    end
+  end
+
+  context 'finding commands' do
+    should 'return a command for a name' do
+      assert_instance_of(Subcheat::Command, Subcheat::Command.on('undo'))
+    end
+
+    should 'raise when loading non-exstant commands' do
+      assert_raise(Subcheat::NoSuchCommand) { Subcheat::Command.on('foo') }
+    end
+  end
+end

data/test/test_runner.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+class TestRunner < Test::Unit::TestCase
+  context 'No arguments' do
+    setup do
+      disable_running_of_commands
+    end
+
+    should 'run help by default' do
+      Subcheat::Runner.new
+      assert_equal('svn help', subcheat_output)
+    end
+  end
+
+  context 'unwrapped commands' do
+    setup do
+      disable_running_of_commands
+    end
+
+    should 'pass through commands' do
+      Subcheat::Runner.new('status')
+      assert_equal('svn status', subcheat_output)
+    end
+
+    should 'pass through arguments' do
+      Subcheat::Runner.new('status --ignore-externals')
+      assert_equal('svn status --ignore-externals', subcheat_output)
+    end
+  end
+
+  context 'wrapped commands' do
+    setup do
+      disable_running_of_commands
+    end
+
+    should 'find and call associated command' do
+      Subcheat::Command.expects(:on).with('undo').returns(stub(:call => 'foo'))
+      Subcheat::Runner.new('undo', '55')
+      assert_equal('foo', subcheat_output)
+    end
+  end
+end

data/test/test_subcheat.rb

@@ -0,0 +1,8 @@
+require 'helper'
+
+class TestSubcheat < Test::Unit::TestCase
+  should 'report version number' do
+    File.expects(:read).returns('foo')
+    assert_equal 'foo', Subcheat.version
+  end
+end

data/test/test_svn.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+class TestRunner < Test::Unit::TestCase
+  context 'a working copy' do
+    setup do
+      @info = <<-EOS
+Path: .
+URL: https://some-kind-of-svn.com/svn/project_name/branches/languages
+Repository Root: https://some-kind-of-svn.com/svn
+Repository UUID: 11af7ba9-5ee7-4c51-9542-47637e3bfceb
+Revision: 8049
+Node Kind: directory
+Schedule: normal
+Last Changed Author: Andy
+Last Changed Rev: 5019
+Last Changed Date: 2009-12-11 15:12:57 +0100 (vr, 11 dec 2009)
+
+EOS
+      @svn = Subcheat::Svn.new([])
+      @svn.stubs(:info).returns(@info)
+    end
+
+    should "read attributes" do
+      assert_equal('https://some-kind-of-svn.com/svn/project_name/branches/languages', @svn.attr('URL'))
+      assert_equal('8049', @svn.attr('Revision'))
+    end
+
+    should 'find project base URL' do
+      assert_equal('https://some-kind-of-svn.com/svn/project_name/', @svn.base_url)
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification 
+name: subcheat
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Arjan van der Gaag
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-10 00:00:00 +01:00
+default_executable: subcheat
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  version_requirements: *id003
+description: Wrap the Subversion CLI to extract some usage patterns into commands
+email: arjan@arjanvandergaag.nl
+executables: 
+- subcheat
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/subcheat
+- features/shortcuts.feature
+- features/step_definitions/wrapper_steps.rb
+- features/subcommands.feature
+- features/support/env.rb
+- features/wrapper.feature
+- lib/subcheat.rb
+- lib/subcheat/command.rb
+- lib/subcheat/commands/branch_and_tag.rb
+- lib/subcheat/commands/branching.rb
+- lib/subcheat/commands/info.rb
+- lib/subcheat/commands/shortcuts.rb
+- lib/subcheat/commands/undo.rb
+- lib/subcheat/exceptions.rb
+- lib/subcheat/runner.rb
+- lib/subcheat/svn.rb
+- test/helper.rb
+- test/test_command.rb
+- test/test_runner.rb
+- test/test_subcheat.rb
+- test/test_svn.rb
+has_rdoc: true
+homepage: http://github.com/avdgaag/subcheat
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Wrapper for Subversion CLI
+test_files: 
+- test/helper.rb
+- test/test_command.rb
+- test/test_runner.rb
+- test/test_subcheat.rb
+- test/test_svn.rb