svn-command 0.0.3

data/Readme

@@ -0,0 +1,251 @@
+= <i>Enhanced Subversion command</i> -- an +svn+ command wrapper
+
+[*Environment*:]           Command line 
+[<b>Project site</b>:]     http://rubyforge.org/projects/svncommand
+[<b>Documentation</b>:]    http://svncommand.rubyforge.org/
+[<b>Wiki</b>:]             http://wiki.qualitysmith.com/svn-command
+[<b>Author</b>:]           Tyler Rick
+
+== Introduction
+
+This is a replacement <tt>svn</tt> <b>command-line client</b> meant to be used instead of the standard +svn+ command.
+
+== Installation
+
+=== Prerequisites
+
+Currently a _patched_ version of Console::Command is required. The patched vesion is available on riblet.qualitysmith.com at:
+
+  /usr/lib/ruby/gems/1.8/gems/facets-1.8.51/lib/facets/more/command.rb
+
+(These changes will hopefully be absorbed into the next release.)
+
+=== Installation: Per system
+
+  sudo gem install svn-command 
+
+You also need to make those files executable (once per _system_):
+
+  sudo chmod a+x /usr/lib/ruby/gems/1.8/gems/svn-command-0.0.3/bin/*
+
+(We can't just set <tt>executables = "svn"</tt> because that would cause it to wipe out the existing executable at <tt>/usr/bin/svn</tt>! If you know of a better, more automatic solution to this, please let the developers know!)
+
+And for some reason I seem to have to restart my terminal after doing the chmod step for bash to detect the svn command in that new location.
+
+=== Installation: Per user
+
+*Important*: You need the gem's +bin+ directory to be added to the <b><i>front</i></b> of your path. This requires adding/editing a <tt>PATH=</tt> command in your <tt>~/.bash_profile</tt>. For example:
+
+  export PATH=/usr/lib/ruby/gems/1.8/gems/svn-command-0.0.3/bin:$PATH
+
+(I'm not sure if this is possible to automate with the <tt>gem install</tt> process or not. But in the meantime you need to do it manually.)
+
+You'll know it's working by way of two signs:
+* Your +svn+ command will be noticeably slower
+* When you type svn <tt>help</tt>, it will say:
+    You are using svn-command, a replacement/wrapper for the standard svn command.
+
+== Features
+
+Changes to existing subcommands:
+* <tt>svn diff</tt> output is in _color_ (requires +colordiff+, see below)
+* <tt>svn diff</tt> includes the differences from your *externals* too (consistent with how <tt>svn status</tt> includes them) so that you don't forget to commit those changes too!
+* <tt>svn status</tt> output filters out distracting, useless output about externals (if you want a list of externals, use <tt>svn externals</tt>
+
+New subcommands:
+* <tt>svn each_unadded</tt> (+eu+) -- goes through each unadded (<tt>?</tt>) file reported by <tt>svn status</tt> and asks you what to do with them (add, delete, ignore).
+* <tt>svn externals</tt>
+* <tt>svn edit_externals</tt> (+ee+)
+* <tt>svn externalize</tt>
+* <tt>svn set_message</tt> / <tt>svn get_message</tt> / <tt>svn edit_message</tt>
+* <tt>svn ignore</tt>
+* <tt>svn view_commits</tt> (gives you output from both svn log and from svn diff for the given changesets)
+
+(RDoc question: how do I make the identifiers like Subversion::SvnCommand#externalize into links??)
+
+== Usage
+
+=== <tt>svn st</tt>
+
+_Without_ this gem installed (really long):
+
+  ?      gemables/subversion/ruby_subversion.rb
+   M     gemables/subversion
+  M      gemables/subversion/lib/subversion.rb
+  A      gemables/subversion/bin
+  A      gemables/subversion/bin/svn
+  X      plugins/database_log4r/tasks/shared
+  X      plugins/surveys/doc/template
+  X      plugins/surveys/tasks/shared
+  X      gemables/dev_scripts/tasks/shared
+  X      gemables/dev_scripts/lib/subversion
+
+  Performing status on external item at 'plugins/database_log4r/tasks/shared'
+
+  Performing status on external item at 'plugins/surveys/tasks/shared'
+
+  Performing status on external item at 'gemables/subversion/doc_include/template'
+
+  Performing status on external item at 'gemables/dev_scripts/tasks/shared'
+
+  Performing status on external item at 'applications/underlord/vendor/plugins/rails_smith'
+  X      applications/underlord/vendor/plugins/rails_smith/tasks/shared
+  X      applications/underlord/vendor/plugins/rails_smith/lib/subversion
+  X      applications/underlord/vendor/plugins/rails_smith/doc_include/template
+
+  Performing status on external item at 'applications/underlord/vendor/plugins/rails_smith/tasks/shared'
+  M      applications/underlord/vendor/plugins/rails_smith/tasks/shared/base.rake
+
+<b>_With_</b> this gem installed (_much_ shorter and sweeter):
+
+  ?      gemables/subversion/ruby_subversion.rb
+   M     gemables/subversion
+  M      gemables/subversion/lib/subversion.rb
+  A      gemables/subversion/bin
+  A      gemables/subversion/bin/svn
+  M      applications/underlord/vendor/plugins/rails_smith/tasks/shared/base.rake
+
+=== <tt>svn each_unadded</tt>
+
+My personal favorite. This command is useful for keeping your working copies clean -- getting rid of all those accumulated temp files (or *ignoring* or *adding* them if they're something that _all_ users of this repository should be aware of).
+
+It simply goes through each "unadded" file (each file reporting a status of <tt>?</tt>) reported by <tt>svn status</tt> and asks you what you want to do with them -- *add*, *delete*, or *ignore*.
+
+  > svn each_unadded
+
+  What do you want to do with plugins/database_log4r/doc?
+    (shows preview)
+  (a)dd, (d)elete, add to svn:(i)ignore property, or [Enter] to do nothing > i
+  Ignoring...
+
+  What do you want to do with applications/underlord/db/schema.rb?
+    (shows preview)
+  (a)dd, (d)elete, add to svn:(i)ignore property, or [Enter] to do nothing > a
+  Adding...
+
+  What do you want to do with applications/underlord/vendor/plugins/exception_notification?
+    (shows preview)
+  (a)dd, (d)elete, add to svn:(i)ignore property, or [Enter] to do nothing > d
+  Are you pretty much *SURE* you want to 'rm -rf applications/underlord/vendor/plugins/exception_notification'? (y)es, (n)o > y
+  Deleting...
+
+For *files*, it will show a preview of the _contents_ of that file (limited to the first 3000 characters); for *directories*, it will show a _directory_ _listing_. By looking at the preview, you should hopefully be able to decide whether you want to keep the file or junk it.
+
+===externalize / externals / edit_externals
+
+Shortcut for creating an svn:external...
+
+  your_project/vendor/ > svn externalize http://code.qualitysmith.com/gemables/svn-command --as svn
+
+Between that and externals / edit_externals, that's all you ever really need! (?)
+
+  > svn externals
+  /home/tyler/code/plugins/rails_smith/tasks
+    * shared                        http://code.qualitysmith.com/gemables/shared_tasks/tasks
+  /home/tyler/code/plugins/rails_smith/doc_include
+    * template                      http://code.qualitysmith.com/gemables/template/doc/template
+  /home/tyler/code/plugins/rails_smith
+    * svn-command                   http://code.qualitysmith.com/gemables/svn-command
+  
+Oops, I externalled it in the wrong place!
+
+  > svn edit_externals
+  /home/tyler/code/plugins/rails_smith/tasks
+    * shared                        http://code.qualitysmith.com/gemables/shared_tasks/tasks
+  Do you want to edit svn:externals for this directory? y/N > [Enter]
+
+  /home/tyler/code/plugins/rails_smith/doc_include
+    * template                      http://code.qualitysmith.com/gemables/template/doc/template
+  Do you want to edit svn:externals for this directory? y/N > [Enter]
+
+  /home/tyler/code/plugins/rails_smith
+    * svn-command                   http://code.qualitysmith.com/gemables/svn-command
+  Do you want to edit svn:externals for this directory? y/N > [y]
+  (remove that line using your favorite editor (which of course is +vim+), save, quit)
+
+You can also pass a directory name to edit_externals to edit the svn:externals property for that directory:
+
+  > svn edit-externals vendor/plugins
+
+===get_message / set_message / edit_message
+
+<b>Pre-requisite for set_message/edit_message</b>: Your repository must have a <tt>pre-revprop-change</tt> hook file.
+
+Useful if you made a mistake or forgot something in your commit message and want to edit it... 
+
+For example, maybe you tried to do a multi-line commit message with -m but it didn't interpret your "\n"s as newline characters. Just run svn edit_message and fix it interactively!
+
+  svn get_message -r 2325
+is the same as:
+  svn propget -r 2325 --revprop svn:log
+
+If you *just* committed it and you want to edit the message for the most-recently committed revision ("head"), there is an even quicker way to do it:
+
+You can do this:
+  svn edit_message -r head
+or just this:
+  svn edit_message
+
+===Help
+
+You can, of course, get a lits of the custom commands that have been added by using <tt>svn help</tt>. They will be listed at the end.
+
+===Global options
+
+* --no-color (since color is on by default)
+* --dry-run  (see what /usr/bin/svn command it _would_ have executed if you weren't just doing a dry run -- useful for debugging if nothing else)
+* --debug    (sets $debug = true)
+
+==colordiff
+
++colordiff+ is used to colorize <tt>svn diff</tt> commands (+ lines are blue; - lines are red)
+
+Found at:
+* http://www.pjhyett.com/articles/2006/06/16/colored-svn-diff
+* http://colordiff.sourceforge.net/
+
+Suggestion: change the colors in <tt>/etc/colordiffrc</tt> to be more readable:
+  plain=white
+  newtext=green
+  oldtext=red
+  diffstuff=cyan
+  cvsstuff=magenta
+
+==Bash command completion
+
+If you want command completion for the svn subcommands (and I don't blame you if you don't -- the default command completion is <i>much faster</i> and already gives you completion for filenames!), just add this line to your <tt>~/.bashrc</tt> :
+
+  complete -C /usr/bin/command_completion_for_svn_command -o default svn
+
+It's really rudimentary right now and could be much improved, but at least it's a start.
+
+==Known problems
+
+It doesn't support options that are given in this format:
+  --diff-cmd=colordiff
+only this format:
+  --diff-cmd colordiff
+This is a limitation of Console::Command.
+
+=== Slowness
+
+Is it slower than just running /usr/bin/svn directly? You betcha it is!
+
+  > time svn foo
+  real    0m0.493s
+
+  > time /usr/bin/svn foo
+  real    0m0.019s
+
+But... as with most things written in Ruby, it's all more about *productivity* than raw execution speed. _Hopefully_ the productivity gains you get from using this wrapper will more than make up for the 0.5 s extra you have to wait for the svn command. :-) If not, I guess it's not for you.
+
+==To do
+
+Take the best ideas from these and incorporate:
+* /usr/lib/ruby/gems/1.8/gems/rscm-0.5.1/lib/rscm/scm/subversion.rb
+* /usr/lib/ruby/gems/1.8/gems/rscm-0.5.1/lib/rscm/scm/subversion_log_parser.rb
+* /usr/lib/ruby/gems/1.8/gems/lazysvn-0.1.3/lib/subversion.rb
+
+Possibly switch to LazySvn.
+
+http://wiki.qualitysmith.com/svn-command

data/bin/command_completion_for_svn_command

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'svn_command'
+
+subcommands = (Subversion::SvnCommand.public_instance_methods - Object.methods).sort
+
+# COMP_LINE will be something like 'svn sta' (what they started to type).
+exit 0 unless /^svn\b/ =~ ENV["COMP_LINE"]
+after_match = $'
+
+# Since we only want our custom completion for the first argument passed to svn (because we want it to fall back to using default completion for all subsequent args), we need to check what the COMP_LINE is:
+exit 0 if /^svn\s[\w=-]* / =~ ENV["COMP_LINE"]
+# 'svn --diff-cmd=whatever ' =~ /^svn\b [\w=-]* / => 0
+
+subcommand_match = (after_match.empty? || after_match =~ /\s$/) ? nil : after_match.split.last
+subcommands = subcommands.select { |t| /^#{Regexp.escape subcommand_match}/ =~ t } if subcommand_match
+
+puts subcommands
+exit 0

data/bin/rscm_test

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'rscm'
+require 'pp'
+
+#scm = RSCM::Subversion.new("http://code.qualitysmith.com/gemables")
+
+subversion = RSCM::Subversion.new()
+subversion.checkout_dir = '.'
+puts "working copy revision = #{subversion.label}"
+puts "url = #{subversion.repourl}"
+puts "up to date? = #{subversion.uptodate?(nil)}"
+
+
+#revisions = scm.revisions(Time.utc(2007, 01, 10, 12, 34, 22)) # For Subversion, you can also pass a revision number (int)
+#revisions.each do |revision|
+#  pp revision
+#end

data/bin/svn

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require_gem 'facets', '>=1.8.20'
+require 'facets/core/kernel/require_local'
+require_local '../lib/svn_command.rb'
+Subversion::SvnCommand.execute

data/lib/attribute_accessors.rb

@@ -0,0 +1,44 @@
+# Extends the module object with module and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+class Module # :nodoc:
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+  
+  def mattr_writer(*syms)
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+        
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+  
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/lib/my_wrapper.rb

@@ -0,0 +1,72 @@
+require 'rubygems'
+require_gem 'facets', '>=1.8.51'
+require 'facets/more/command'
+require 'pp'
+require 'stringio'
+
+class MyWrapperCommand < Console::Command
+
+  def initialize(*args)
+    @missing_options = []
+    super
+  end
+
+  #-----------------------------------------------------------------------------------------------------------------------------
+  # Default/dynamic behavior
+  
+  # Any subcommands that we haven't implemented here will simply be passed on to the built-in svn command.
+#  def method_missing(subcommand, *args)
+#    puts "in method_missing(#{subcommand}, #{args.inspect})"
+#    p options
+#    exec subcommand, *args 
+#  end
+
+  def option_missing(option_name, args)
+    puts "in option_missing (#{option_name.inspect}, #{args.inspect})"
+
+    # The following hackery is necessary because we really don't know the arity (how many subsequent tokens it should eat) of the option -- we don't know anything about the options, in fact; that's why we've landed in option_missing.
+    # This is kind of a hokey solution, but for any unrecognized options/args (which will be *all* of them unless we list the available options in the subcommand module), we just eat all of the args, store them in @missing_options, and later we will add them back on.
+    # What's annoying about it this solution is that *everything* after the first unrecognized option comes in as args, even if they are args for the subcommand and not for the *option*!
+    # But...it seems to work to just pretend they're options.
+    # It seems like this is mostly a problem for *wrappers* that try to use Console::Command. Sometimes you just want to *pass through all args and options* unchanged and just filter the output somehow.
+    # Command doesn't make that super-easy though. If an option (--whatever) isn't defined, then the only way to catch it is in option_missing. And since we can't the arity unless we enumerate all options, we have to hokily treat the first option as having unlimited arity.
+    #   Alternatives considered: 
+    #     * Assume arity of 0. Then I'm afraid it would extract out all the option flags and leave the args that were meant for the args dangling there out of order ("-r 1 -m 'hi'" => "-r -m", "1 'hi'")
+    #     * Assume arity of 1. Then if it was really 0, it would pick up an extra arg that really wasn't supposed to be an arg for the *option*.
+    # Solution for wrappers:?
+    #   pass_through :some_built_in_subcommand
+    #   Tells Command to not parse options out of args -- just pass *all* args (options and all) on to the subcommand's method(*args).
+    # Ideally, we wouldn't be using option_missing at all because all options would be listed in the respective subcommand module...but we're too lazy to list them all out, so this is just seemed like the easiest way to do things....
+
+    @missing_options << "#{option_name}" << args
+    @missing_options.flatten!
+
+    return arity = args.size
+  end
+
+  #-----------------------------------------------------------------------------------------------------------------------------
+  module Diff
+    def __color
+      @diff_command = 'colordiff'
+    end
+  end
+  def diff(*args)
+    puts "in diff (#{args.inspect})"
+    args << '--diff-cmd' << @diff_command if @diff_command
+    exec 'diff', *args
+  end
+
+  #-----------------------------------------------------------------------------------------------------------------------------
+  # Helpers
+
+private
+  def exec(*args)
+    args = ['svn'] + args + @missing_options
+    # options comes last because once the options parsing starts, it eats all args up to the very end
+    puts "This is the command we would execute at this point, if this weren't just a demonstration"
+    p args
+  end
+
+
+end
+MyWrapperCommand.execute

data/lib/subversion.rb

@@ -0,0 +1,335 @@
+# Tested by: ../test/subversion_test.rb
+$loaded ||= {}; if !$loaded[File.expand_path(__FILE__)]; $loaded[File.expand_path(__FILE__)] = true;
+
+require 'fileutils'
+require 'rexml/document'
+require 'rexml/xpath'
+require 'rubygems'
+
+require_gem 'facets', '>=1.8.51'
+require 'facets/core/kernel/require_local'
+require 'facets/core/enumerable/uniq_by'
+require 'facets/core/kernel/silence_stream'
+
+require_gem 'our_extensions', '>=0.0.2'
+require 'capture_output'
+
+# Had a lot of trouble getting ActiveSupport to load without giving errors! Eventually gave up on that idea since I only needed it for mattr_accessor and Facets supplies that.
+#require_gem 'activesupport'  # mattr_accessor
+#require 'active_support'
+#require 'active_support/core_ext/module/attribute_accessors'
+#require 'facets/core/class/cattr'
+require_local "attribute_accessors"
+
+# Wraps the Subversion shell commands for Ruby.
+module Subversion
+  # True if you want output from svn to be colorized (useful if output is for human eyes, but not useful if using the output programatically)
+  @@color = false
+  mattr_accessor :color
+
+  # If true, will only output which command _would_ have been executed but will not actually execute it.
+  @@dry_run = false
+  mattr_accessor :dry_run
+
+  # If true, will print all commands to the screen before executing them.
+  @@print_commands = false
+  mattr_accessor :print_commands
+
+  # Adds the given items to the repository. Items may contain wildcards.
+  def self.add(*args)
+    execute "add #{args.join ' '}"
+  end
+
+  # Sets the svn:ignore property based on the given +patterns+.
+  # Each pattern is both the path (where the property gets set) and the property itself.
+  # For instance:
+  #   "log/*.log" would add "*.log" to the svn:ignore property on the log/ directory.
+  #   "log" would add "log" to the svn:ignore property on the ./ directory.
+  def self.ignore(*patterns)
+    
+    patterns.each do |pattern|
+      path = File.dirname(pattern)
+      path += '/' if path == '.'
+      pattern = File.basename(pattern)
+      add_to_property 'ignore', path, pattern
+    end
+    nil
+  end
+  def self.unignore(*patterns)
+    raise NotImplementedError
+  end
+
+  # Adds the given repo URL (http://svn.yourcompany.com/path/to/something) as an svn:externals.
+  #
+  # Options may include:
+  # * +:as+ - overrides the default behavior of naming the checkout based on the last component of the repo path
+  # * +:local_path+ - specifies where to set the externals property. Defaults to './'
+  #
+  def self.externalize(repo_url, options = {})
+    options[:local_path] ||= './'
+    options[:as] ||= File.basename(repo_url)
+    options[:as] = options[:as].ljust(29)
+    add_to_property 'externals', options[:local_path], "#{options[:as]} #{repo_url}"
+  end
+
+  # Removes the given items from the repository and the disk. Items may contain wildcards.
+  def self.remove(*args)
+    execute "rm #{args.join ' '}"
+  end
+
+  # Removes the given items from the repository and the disk. Items may contain wildcards.
+  # To do: add a :force => true option to remove
+  def self.remove_force(*args)
+    execute "rm --force #{args.join ' '}"
+  end
+
+  # Removes the given items from the repository BUT NOT THE DISK. Items may contain wildcards.
+  def self.remove_without_delete(*args)
+    # resolve the wildcards before iterating
+    args.collect {|path| Dir[path]}.flatten.each do |path|
+      entries_file = "#{File.dirname(path)}/.svn/entries"
+      File.chmod(0644, entries_file)
+
+      xmldoc = REXML::Document.new(IO.read(entries_file))
+      # first attempt to delete a matching entry with schedule == add
+      unless xmldoc.root.elements.delete "//entry[@name='#{File.basename(path)}'][@schedule='add']"
+        # then attempt to alter a missing schedule to schedule=delete
+        entry = REXML::XPath.first(xmldoc, "//entry[@name='#{File.basename(path)}']")
+        entry.attributes['schedule'] ||= 'delete' if entry
+      end
+      # write back to the file
+      File.open(entries_file, 'w') { |f| xmldoc.write f, 0 }
+
+      File.chmod(0444, entries_file)
+    end
+  end
+
+  # Reverts the given items in the working copy. Items may contain wildcards.
+  def self.revert(*args)
+    execute "revert #{args.join ' '}"
+  end
+
+  # Marks the given items as being executable. Items may _not_ contain wildcards.
+  def self.make_executable(*paths)
+    paths.each do |path|
+      self.set_property 'executable', '', path
+    end
+  end
+  def self.make_not_executable(*paths)
+    paths.each do |path|
+      self.delete_property 'executable', path
+    end
+  end
+
+  # Returns the status of items in the working directories +paths+. Returns the raw output from svn (use <tt>split("\n")</tt> if you want an array).
+  def self.status(*args)
+    args = ['./'] if args.empty?
+    execute("status #{args.join ' '}")
+  end
+
+  def self.status_against_server(*args)
+    args = ['./'] if args.empty?
+    self.status('-u', *args)
+  end
+
+  def self.update(*args)
+    args = ['./'] if args.empty?
+    execute("update #{args.join ' '}")
+  end
+
+  def self.status_the_section_before_externals(path = './')
+    status = status(path) || ''
+    status.sub!(/(Performing status.*)/m, '')
+  end
+
+  # Returns an array of external *items*
+  # Example:
+  #   gemables/our_extensions/tasks/shared
+  #   gemables/our_extensions/doc_include/template
+  def self.externals_items(path = './')
+    status = status_the_section_before_externals(path)
+    return [] if status.nil?
+    status.select { |line|
+      line =~ /^X/
+    }.map { |line|
+      # Just keep the filename part
+      line =~ /^X\s+(.+)/
+      $1
+    }
+  end
+
+  # Returns an array of ExternalsContainer objects representing all externals *containers* in the working directory specified by +path+.
+  def self.externals_containers(path = './')
+    # Using self.externals_items is kind of a cheap way to do this, and it results in some redundancy that we have to filter out
+    # (using uniq_by), but it seemed more efficient than the alternative (traversing the entire directory tree and querying for
+    # `svn prepget svn:externals` at each stop to see if the directory is an externals container).
+    self.externals_items(path).map { |external_dir|
+      ExternalsContainer.new(external_dir + '/..')
+    }.uniq_by { |external|
+      external.container_dir
+    }
+  end
+
+  # Returns the local modifications to the working directory specified by +path+.
+  def self.diff(*args)
+    args = ['./'] if args.empty?
+    #puts("diff #{"--diff-cmd colordiff" if color} #{args.join ' '}")
+    execute("diff #{"--diff-cmd colordiff" if color} #{args.join ' '}")
+  end
+
+  # It's easy to get/set properties, but less easy to add to a property. This method uses get/set to simulate add.
+  # It will uniquify lines, removing duplicates. (:todo: what if we want to set a property to have some duplicate lines?)
+  def self.add_to_property(property, path, *new_lines)
+    # :todo: I think it's possible to have properties other than svn:* ... so if property contains a prefix (something:), use it; else default to 'svn:'
+    
+    # Get the current properties
+    lines = self.get_property(property, path).split "\n"
+    puts "Existing lines: #{lines.inspect}" if $debug
+
+    # Add the new lines, delete empty lines, and uniqueify all elements
+    lines.concat(new_lines).uniq!
+    puts "After concat(new_lines).uniq!: #{lines.inspect}" if $debug
+
+    lines.delete ''
+    # Set the property
+    puts "About to set propety to: #{lines.inspect}" if $debug
+    self.set_property property, lines.join("\n"), path
+  end
+
+  def self.get_property(property, path = './')
+    execute "propget svn:#{property} #{path}"
+  end
+  def self.delete_property(property, path = './')
+    execute "propdel svn:#{property} #{path}"
+  end
+  def self.set_property(property, value, path = './')
+    execute "propset svn:#{property} '#{value}' #{path}"
+  end
+
+  def self.make_directory(dir)
+    execute "mkdir #{dir}"
+  end
+
+  def self.help(*args)
+    execute "help #{args.join(' ')}"
+  end
+
+  def self.log(*args)
+    args = ['./'] if args.empty?
+    execute "log #{args.join(' ')}"
+  end
+  def self.latest_revision(*args)
+    args = ['./'] if args.empty?
+    matches = /Status against revision:\s+(\d+)/m.match(status_against_server(args))
+    matches && matches[1]
+  end
+
+  def self.info(*args)
+    args = ['./'] if args.empty?
+    execute "info #{args.join(' ')}"
+  end
+
+  # :todo: needs some serious unit-testing love
+  def self.base_url(path_or_url = './')
+    base_url = nil    # needed so that base_url variable isn't local to if block!
+    started_using_dot_dots = false
+    loop do
+      matches = /URL: (.+)/.match(info(path_or_url))
+      if matches && matches[1]
+        base_url = matches[1]
+      else
+        break base_url
+      end
+
+      # Keep going up the path, one directory at a time, until `svn info` no longer returns a URL (will probably eventually return 'svn: PROPFIND request failed')
+      if path_or_url.include?('/') && !started_using_dot_dots
+        path_or_url = File.dirname(path_or_url)
+      else
+        started_using_dot_dots = true
+        path_or_url = File.join(path_or_url, '..')
+      end
+      #puts 'going up to ' + path_or_url
+    end
+  end
+
+  # The location of the executable to be used
+  def self.executable
+    @@executable ||=
+      ENV['PATH'].split(':').each do |dir|
+#        if File.exist?(executable = "#{dir}/svn")
+#          puts executable
+#        end
+        if File.exist?(executable = "#{dir}/svn") and   #
+           `file #{executable}` !~ /ruby/               # We want to wrap the svn command provided by Subversion, not our custom replacement for that.
+          return executable
+        end
+      end
+    #
+  end
+
+protected
+  def self.execute(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    method = options.delete(:method) || :capture
+
+    command = "#{executable} #{args.join ' '}"
+    actually_execute(method, command)
+  end
+  # This abstraction exists to assist with unit tests. Test cases can simply override this function so that no external commands need to be executed.
+  def self.actually_execute(method, command)
+    if Subversion.dry_run && !$ignore_dry_run_option
+      puts "In execute(). Was about to execute this command via method :#{method}:"
+      p command
+    end
+    if Subversion.print_commands
+      p command
+    end
+
+    valid_options = [:capture, :exec, :popen]
+    case method
+      when :capture
+        silence_stream($stderr) {
+          `#{command}` 
+        }
+      when :exec
+        #Kernel.exec *args
+        Kernel.exec command
+      when :popen
+        # To do: rather than `...`, which waits until command is finished before you get any output, maybe do popen and output the output in realtime!
+        IO.popen(command, 'r') do |pipe|
+          pipe.read
+        end
+      else
+        raise ArgumentError.new(":method option must be one of #{valid_options.inspect}")
+    end unless (Subversion.dry_run && !$ignore_dry_run_option)
+  end
+end
+
+module Subversion
+  # Represents an "externals container", which is a directory that has the <tt>svn:externals</tt> property set to something useful.
+  # Each ExternalsContainer contains a set of "entries", which are the actual directories listed in the <tt>svn:externals</tt>
+  # property and are "pulled into" the directory.
+  class ExternalsContainer
+    attr_reader :container_dir
+    attr_reader :entries
+
+    def initialize(external_dir)
+      @container_dir = File.expand_path(external_dir)
+      @entries = Subversion.get_property("externals", @container_dir)
+      #p @entries
+    end
+
+    def to_s
+      "#{container_dir}\n" +
+        entries.chomp.map { |line|
+          "  * " + line
+        }.join
+    end
+
+    def ==(other)
+      self.container_dir == other.container_dir
+    end
+  end
+end
+
+end