--- a/lib/piston.rb
+++ b/lib/piston.rb
@@ -12,6 +12,18 @@ module Piston
     end
   end
 
+  class RepositoryUuidChanged < PistonError
+    def initialize(url, expected_uuid, actual_uuid)
+      super "The repository at #{url} changed UUID from #{expected_uuid} to #{actual_uuid} -- Piston will not update/switch"
+    end
+  end
+
+  class MissingRepositoryLocation < PistonError
+    def initialize(url)
+      super "Repository location #{url} does not exist anymore"
+    end
+  end
+
   REMOTE_UUID = "piston:remote-uuid"
   REMOTE_ROOT = "piston:remote-root"
   REMOTE_REVISION = "piston:remote-revision"

--- a/lib/piston/commands/update.rb
+++ b/lib/piston/commands/update.rb
@@ -1,145 +1,107 @@
 require "piston"
-require "piston/command"
-require 'find'
 
 module Piston
   module Commands
-    class Update < Piston::Command
-      def run
-        (args.empty? ? find_targets : args).each do |dir|
-          update dir
-        end
-      end
-
-      def find_targets
-        targets = Array.new
-        svn(:propget, '--recursive', Piston::ROOT).each_line do |line|
-          next unless line =~ /^([^ ]+)\s-\s.*$/
-          targets << $1
-        end
-
-        targets
+    class Update
+      def initialize(paths=nil, options={})
+        @options = options
+        @paths = paths.kind_of?(Enumerable) ? paths : [paths]
+        @wcs = @paths.map {|path| Piston::WorkingCopy.new(path, :logger => options[:logger])}
       end
 
-      def update(dir)
-        return unless File.directory?(dir)
-        return skip(dir, "locked") unless svn(:propget, Piston::LOCKED, dir) == ''
-        status = svn(:status, '--show-updates', dir)
-        new_local_rev = nil
-        new_status = Array.new
-        status.each_line do |line|
-          if line =~ /status.+\s(\d+)$/i then
-            new_local_rev = $1.to_i
-          else
-            new_status << line unless line =~ /^\?/
+      def run
+        @wcs.each do |wc|
+          begin
+            update(wc)
+          rescue
+            raise if @wcs.size == 1
+            warn {$!.message}
           end
         end
-        raise "Unable to parse status\n#{status}" unless new_local_rev
-        return skip(dir, "pending updates -- run \"svn update #{dir}\"\n#{new_status}") if new_status.size > 0
+      end
 
-        logging_stream.puts "Processing '#{dir}'..."
-        repos = svn(:propget, Piston::ROOT, dir).chomp
-        uuid = svn(:propget, Piston::UUID, dir).chomp
-        remote_revision = svn(:propget, Piston::REMOTE_REV, dir).chomp.to_i
-        local_revision = svn(:propget, Piston::LOCAL_REV, dir).chomp.to_i
-        local_revision = local_revision.succ
+      def update(wc)
+        info {"Updating #{wc}"}
+        vrepos = Piston::Repository.new(wc.propget(Piston::REMOTE_ROOT), :logger => @options[:logger])
 
-        logging_stream.puts "  Fetching remote repository's latest revision and UUID"
-        info = YAML::load(svn(:info, repos))
-        return skip(dir, "Repository UUID changed\n  Expected #{uuid}\n  Found    #{info['Repository UUID']}\n  Repository: #{repos}") unless uuid == info['Repository UUID']
+        check_preconditions!(vrepos, wc)
 
-        new_remote_rev = info['Last Changed Rev'].to_i
-        return skip(dir, "unchanged from revision #{remote_revision}", false) if remote_revision == new_remote_rev
+        new_vendor_head = vrepos.last_changed_rev
+        vwc = Piston::WorkingCopy.new(wc.up.path + ".#{File.basename(wc.path)}.tmp", :logger => @options[:logger])
+        prior_vendor_head = wc.propget(Piston::REMOTE_REVISION)
+        vwc.checkout(vrepos.url, prior_vendor_head)
+        vwc.update(new_vendor_head)
+        changes = vwc.log(prior_vendor_head.succ .. new_vendor_head)
+        debug { changes.inspect }
+        changes.each do |op, filename|
+          case op
+          when :add
+            if File.directory?(vwc.wc_path(filename)) then
+              wc.mkdir(filename)
+            else
+              wc.create!(filename, File.read(vwc.wc_path(filename)))
+            end
 
-        revisions = (remote_revision .. (revision || new_remote_rev))
+          when :modify
+            wc.edit!(filename, File.read(vwc.wc_path(filename)))
 
-        logging_stream.puts "  Restoring remote repository to known state at r#{revisions.first}"
-        svn :checkout, '--ignore-externals', '--quiet', '--revision', revisions.first, repos, dir.tmp
+          when :delete
+            wc.delete(filename)
 
-        logging_stream.puts "  Updating remote repository to r#{revisions.last}"
-        updates = svn :update, '--ignore-externals', '--revision', revisions.last, dir.tmp
+          when :move
+            from, to = filename.to_a.flatten
+            wc.move(from, to)
 
-        logging_stream.puts "  Processing adds/deletes"
-        merges = Array.new
-        changes = 0
-        updates.each_line do |line|
-          next unless line =~ %r{^([A-Z]).*\s+#{Regexp.escape(dir.tmp)}[\\/](.+)$}
-          op, file = $1, $2
-          changes += 1
+          when :copy
+            from, to = filename.to_a.flatten
+            wc.copy(from, to)
 
-          case op
-          when 'A'
-            if File.directory?(File.join(dir.tmp, file)) then
-              svn :mkdir, '--quiet', File.join(dir, file)
-            else
-              copy(dir, file)
-              svn :add, '--quiet', '--force', File.join(dir, file)
-            end
-          when 'D'
-            svn :remove, '--quiet', '--force', File.join(dir, file)
           else
-            copy(dir, file)
-            merges << file
+            raise SyntaxError, "Unknown repository operation: #{op.inspect}"
           end
         end
 
-        # Determine if there are any local changes in the pistoned directory
-        log = svn(:log, '--quiet', '--revision', (local_revision .. new_local_rev).to_svn, '--limit', '2', dir)
-
-        # If none, we skip the merge process
-        if local_revision < new_local_rev && log.count("\n") > 3 then
-          logging_stream.puts "  Merging local changes back in"
-          merges.each do |file|
-            begin
-              svn(:merge, '--quiet', '--revision', (local_revision .. new_local_rev).to_svn,
-                  File.join(dir, file), File.join(dir, file))
-            rescue RuntimeError
-              next if $!.message =~ /Unable to find repository location for/
-            end
-          end
-        end
+        prior_local_head = wc.propget(Piston::LOCAL_REVISION).to_i.succ 
+        new_local_head = wc.youngest
+        changes.map {|op, filename| filename if op == :modify}.compact.each do |filename|
+          wc.merge(filename, prior_local_head .. new_local_head)
+        end unless prior_local_head == new_local_head
 
-        logging_stream.puts "  Removing temporary files / folders"
-        FileUtils.rm_rf dir.tmp
+        wc.propset(Piston::REMOTE_REVISION, new_vendor_head)
+        wc.propset(Piston::LOCAL_REVISION, new_local_head) unless prior_local_head == new_local_head
+        vwc.destroy!
+      end
 
-        logging_stream.puts "  Updating Piston properties"
-        svn :propset, Piston::REMOTE_REV, revisions.last, dir
-        svn :propset, Piston::LOCAL_REV, new_local_rev, dir
-        svn :propset, Piston::LOCKED, revisions.last, dir if lock
+      def check_preconditions!(vrepos, wc)
+        local_vendor_uuid = wc.propget(Piston::REMOTE_UUID)
+        raise UnknownRepository.new(vrepos.url) unless vrepos.exists?
 
-        logging_stream.puts "  Updated to r#{revisions.last} (#{changes} changes)"
+        vendor_uuid = vrepos.uuid
+        raise RepositoryUuidChanged.new(vrepos.url, local_vendor_uuid, vendor_uuid) unless local_vendor_uuid == vendor_uuid 
       end
 
-      def copy(dir, file)
-        FileUtils.cp(File.join(dir.tmp, file), File.join(dir, file))
+      def debug(&block)
+        self.logger.debug(&block) if self.logger
       end
 
-      def skip(dir, msg, header=true)
-        logging_stream.print "Skipping '#{dir}': " if header
-        logging_stream.puts msg
+      def info(&block)
+        self.logger.info(&block) if self.logger
       end
 
-      def self.help
-        "Updates all or specified folders to the latest revision"
+      def warn(&block)
+        self.logger.warn(&block) if self.logger
       end
 
-      def self.detailed_help
-        <<EOF
-usage: update [DIR [...]]
-
-  This operation has the effect of downloading all remote changes back to our
-  working copy.  If any local modifications were done, they will be preserved.
-  If merge conflicts occur, they will not be taken care of, and your subsequent
-  commit will fail.
+      def error(&block)
+        self.logger.error(&block) if self.logger
+      end
 
-  Piston will refuse to update a folder if it has pending updates.  Run
-  'svn update' on the target folder to update it before running Piston
-  again.
-EOF
+      def fatal(&block)
+        self.logger.fatal(&block) if self.logger
       end
 
-      def self.aliases
-        %w(up)
+      def logger
+        @options[:logger]
       end
     end
   end

--- /dev/null
+++ b/spec/update_spec.rb
@@ -0,0 +1,242 @@
+require File.dirname(__FILE__) + "/spec_helper"
+require "piston/commands/import"
+require "piston/commands/update"
+
+describe Piston::Commands::Update, "#run" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+
+  it "should find all pistonized folders and update them in turn"
+end
+
+describe Piston::Commands::Update, "#run('vendor')" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+  it_should_behave_like "A working copy against a local repository"
+
+  before do
+    Piston::Commands::Import.new(@upstream.url, @wc.wc_path("vendor"), :revision => 1, :logger => logger).run
+    @wc.commit "Pistonized vendor@r1"
+    @vendor = @wc.down("vendor")
+
+    @command = Piston::Commands::Update.new(@wc.wc_path("vendor"), :logger => logger)
+  end
+
+  after do
+    @wc.destroy!
+  end
+
+  it "should receive new folders" do
+    @upwc.mkdir("lib")
+    @upwc.create!("lib/calc.c", "int calc() { /* TBD */ }")
+    @upwc.commit
+    @command.run
+    status = @wc.status.map {|st| st.sub(@wc.path, "")}
+    status.sort.should == [
+        " M     /vendor",
+        "A      /vendor/lib",
+        "A      /vendor/lib/calc.c",
+        "A      /vendor/LICENSE",
+        "A      /vendor/README",
+        "M      /vendor/main.c",
+        "M      /vendor/CHANGELOG"].sort 
+  end
+end
+
+describe Piston::Commands::Update, "#run('vendor')" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+  it_should_behave_like "A working copy against a local repository"
+
+  before do
+    Piston::Commands::Import.new(@upstream.url, @wc.wc_path("vendor"), :revision => 1, :logger => logger).run
+    @wc.commit "Pistonized vendor@r1"
+    @vendor = @wc.down("vendor")
+
+    @command = Piston::Commands::Update.new(@wc.wc_path("vendor"), :logger => logger)
+  end
+
+  after do
+    @wc.destroy!
+  end
+
+  it "should delete deleted files" do
+    @upwc.delete("CHANGELOG")
+    @upwc.commit
+    @command.run
+    status = @wc.status.map {|st| st.sub(@wc.path, "")}
+    status.should include("D      /vendor/CHANGELOG") 
+  end
+end
+
+describe Piston::Commands::Update, "#run('vendor')" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+  it_should_behave_like "A working copy against a local repository"
+
+  before do
+    Piston::Commands::Import.new(@upstream.url, @wc.wc_path("vendor"), :revision => 1, :logger => logger).run
+    @wc.commit "Pistonized vendor@r1"
+    @vendor = @wc.down("vendor")
+
+    @command = Piston::Commands::Update.new(@wc.wc_path("vendor"), :logger => logger)
+  end
+
+  after do
+    @wc.destroy!
+  end
+
+  it "should move files" do
+    @upwc.move("CHANGELOG", "Changelog.txt")
+    @upwc.commit
+    @command.run
+    status = @wc.status.map {|st| st.sub(@wc.path, "")}
+    status.should include("D      /vendor/CHANGELOG") 
+    status.should include("A  +   /vendor/Changelog.txt") 
+  end
+end
+
+describe Piston::Commands::Update, "#run('vendor')" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+  it_should_behave_like "A working copy against a local repository"
+
+  before do
+    Piston::Commands::Import.new(@upstream.url, @wc.wc_path("vendor"), :revision => 1, :logger => logger).run
+    @wc.commit "Pistonized vendor@r1"
+    @vendor = @wc.down("vendor")
+
+    @command = Piston::Commands::Update.new(@wc.wc_path("vendor"), :logger => logger)
+  end
+
+  after do
+    @wc.destroy!
+  end
+
+  it "should copy files" do
+    @upwc.copy("CHANGELOG", "old-changelog.txt")
+    @upwc.commit
+    @command.run
+    status = @wc.status.map {|st| st.sub(@wc.path, "")}
+    status.should include("A  +   /vendor/old-changelog.txt") 
+  end
+end
+
+describe Piston::Commands::Update, "#run('vendor')" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+  it_should_behave_like "A working copy against a local repository"
+
+  before do
+    Piston::Commands::Import.new(@upstream.url, @wc.wc_path("vendor"), :revision => 1, :logger => logger).run
+    @wc.commit "Pistonized vendor@r1"
+    @vendor = @wc.down("vendor")
+
+    @command = Piston::Commands::Update.new(@wc.wc_path("vendor"), :logger => logger)
+  end
+
+  after do
+    @wc.destroy!
+  end
+
+  it "should reject the update if the repository UUID is not as expected" do
+    @vendor.propset(Piston::REMOTE_UUID, "some-random-string")
+    lambda { @command.run }.should raise_error(Piston::RepositoryUuidChanged)
+  end
+
+  it "should reject the update when the repository is gone" do
+    @upstream.destroy!
+    lambda { @command.run }.should raise_error(Piston::UnknownRepository)
+  end
+end
+
+describe Piston::Commands::Update, "#run('vendor')" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+  it_should_behave_like "A working copy against a local repository"
+
+  before do
+    Piston::Commands::Import.new(@upstream.url, @wc.wc_path("vendor"), :revision => 1, :logger => logger).run
+    @wc.commit "Pistonized vendor@r1"
+    @vendor = @wc.down("vendor")
+
+    @command = Piston::Commands::Update.new(@wc.wc_path("vendor"), :logger => logger)
+    @command.run
+  end
+
+  after do
+    @wc.destroy!
+  end
+
+  it "should receive vendor's HEAD changes" do
+    status = @wc.status
+    status.map! do |st|
+      st.sub(@wc.path, "")
+    end
+    status.sort.should == [
+        " M     /vendor",
+        "A      /vendor/LICENSE",
+        "A      /vendor/README",
+        "M      /vendor/main.c",
+        "M      /vendor/CHANGELOG"].sort 
+  end
+
+  it "should record new vendor's HEAD" do
+    @vendor.propget(Piston::REMOTE_REVISION).to_i.should == @upstream.youngest
+  end
+
+  it "should record new local HEAD (unchanged, since no changes in local repos)" do
+    @vendor.propget(Piston::LOCAL_REVISION).to_i.should == 0
+  end
+end
+
+describe Piston::Commands::Update, "#run('vendor') when local modifications have been made" do
+  it_should_behave_like "An upstream repository with no copies/renames"
+  it_should_behave_like "A working copy against a local repository"
+
+  before do
+    Piston::Commands::Import.new(@upstream.url, @wc.wc_path("vendor"), :revision => 1, :logger => logger).run
+    @wc.commit "Pistonized vendor@r1"
+    @vendor = @wc.down("vendor")
+
+    @vendor.edit!("main.c", <<EOF
+/**
+ *
+ * main.c:  the main program file.
+ * 
+ * This program does absolutely nothing.
+ *
+ */
+#include <stdio.h>
+
+int main(int argc, char** argv) {
+  return 0;
+}
+EOF
+)
+    @vendor.commit
+    @vendor.update
+
+    @command = Piston::Commands::Update.new(@wc.wc_path("vendor"), :logger => logger)
+    @command.run
+  end
+
+  it "should record new local HEAD" do
+    @vendor.propget(Piston::LOCAL_REVISION).to_i.should == 2
+  end
+
+  it "should merge local modifications" do
+    File.read(@vendor.wc_path("main.c")).should == <<EOF
+/**
+ *
+ * main.c:  the main program file.
+ * 
+ * This program does absolutely nothing.
+ *
+ */
+#include <stdio.h>
+
+/** Main program file */
+int main(int argc, char** argv) {
+  return do_work(argc);
+}
+
+int do_work(int argc) {
+  return 2*argc;
+}
+EOF
+  end
+end