realityforge-piston 1.4.1

data/lib/piston/command_error.rb

@@ -0,0 +1,6 @@
+require "piston"
+
+module Piston
+  # Raised whenever an argument is not correct during processing.
+  class CommandError < ArgumentError; end
+end

data/lib/piston/commands/convert.rb

@@ -0,0 +1,80 @@
+require "piston"
+require "piston/command"
+require "piston/commands/import"
+
+module Piston
+  module Commands
+    class Convert < Piston::Command
+      def run
+        if args.empty? then
+          svn(:propget, '--recursive', 'svn:externals').each_line do |line|
+            next unless line =~ /^([^ ]+)\s-\s/
+            args << $1
+          end
+        end
+
+        return logging_stream.puts("No svn:externals defined in this folder or any of it's subfolders") if args.empty?
+
+        args.each do |dir|
+          externals = svn(:propget, 'svn:externals', dir)
+          next skip_no_externals(dir) if externals.chomp.empty?
+
+          operations = Array.new
+          externals.each_line do |external|
+            external.chomp!
+            next if external.empty?
+            next skip_no_match(external) unless external =~ /^([^ ]+)\s+(?:-r\s*(\d+)\s+)?(.*)$/
+
+            local, revision, repos = $1, $2, $3
+            lock = true if revision
+            local_dir = File.join(dir, local)
+            if File.exists?(local_dir)
+              raise Piston::CommandError, "#{local_dir.inspect} is not a directory" unless File.directory?(local_dir)
+              status = svn(:status, local_dir)
+              raise Piston::CommandError, "#{local_dir.inspect} has local modifications:\n#{status}\nYour must revert or commit before trying again." unless status.empty?
+              info = YAML::load(svn(:info, local_dir))
+              revision = info['Last Changed Rev'] unless revision
+              FileUtils.rm_rf(local_dir)
+            end
+
+            operations << [local_dir, revision, repos, lock]
+          end
+
+          operations.each do |local_dir, revision, repos, lock|
+            logging_stream.puts "Importing '#{repos}' to #{local_dir} (-r #{revision || 'HEAD'}#{' locked' if lock})"
+            import = Piston::Commands::Import.new([repos, local_dir], {})
+            import.revision = revision
+            import.verbose, import.quiet, import.logging_stream =  self.verbose, self.quiet, self.logging_stream
+            import.lock = lock
+            import.run
+            logging_stream.puts
+          end
+        end
+
+        svn :propdel, 'svn:externals', *args
+        logging_stream.puts "Done converting existing svn:externals to Piston"
+      end
+
+      def skip_no_externals(dir)
+        logging_stream.puts "Skipping '#{dir}' - no svn:externals definition"
+      end
+
+      def skip_no_match(external)
+        logging_stream.puts "#{external.inspect} did not match Regexp"
+      end
+
+      def self.help
+        "Converts existing svn:externals into Piston managed folders"
+      end
+
+      def self.detailed_help
+        <<EOF
+usage: convert [DIR [...]]
+
+  Converts folders which have the svn:externals property set to Piston managed 
+  folders.
+EOF
+      end
+    end
+  end
+end

data/lib/piston/commands/diff.rb

@@ -0,0 +1,55 @@
+require "piston"
+require "piston/command"
+require 'find'
+
+module Piston
+  module Commands
+    class Diff < Piston::Command
+      def run
+        (args.empty? ? find_targets : args).each do |dir|
+          diff dir
+        end
+      end
+
+      def diff(dir)
+        return unless File.directory?(dir)
+        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
+
+        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']
+
+        logging_stream.puts "  Checking out repository at revision #{remote_revision}"
+        svn :checkout, '--ignore-externals', '--quiet', '--revision', remote_revision, repos, dir.tmp
+
+        puts run_diff(dir.tmp, dir)
+
+        logging_stream.puts "  Removing temporary files / folders"
+        FileUtils.rm_rf dir.tmp
+
+      end
+
+      def run_diff(dir1, dir2)
+        `diff -urN --exclude=.svn #{dir1} #{dir2}`
+      end
+
+      def self.help
+        "Shows the differences between the local repository and the pristine upstream"
+      end
+
+      def self.detailed_help
+        <<EOF
+usage: diff [DIR [...]]
+
+  This operation has the effect of producing a diff between the pristine upstream
+  (at the last updated revision) and your local version.  In other words, it
+  gives you the changes you have made in your repository that have not been
+  incorporated upstream.
+EOF
+      end
+    end
+  end
+end

data/lib/piston/commands/import.rb

@@ -0,0 +1,75 @@
+require "piston"
+require "piston/command"
+
+module Piston
+  module Commands
+    class Import < Piston::Command
+      def run
+        raise Piston::CommandError, "Missing REPOS_URL argument" if args.empty?
+
+        repos, dir = args.shift, args.shift
+        raise Piston::CommandError, "Too many arguments" unless args.empty?
+        dir = File.basename(URI.parse(repos).path) unless dir
+
+        if File.exists?(dir) then
+          raise Piston::CommandError, "Target folder already exists" unless force
+          svn :revert, '--recursive', dir
+          FileUtils.rm_rf(dir)
+        end
+
+        my_info = YAML::load(svn(:info, File.join(dir, '..')))
+        my_revision = YAML::load(svn(:info, my_info['URL']))['Revision']
+        raise Piston::CommandError, "#{File.expand_path(File.join(dir, '..'))} is out of date - run svn update" unless my_info['Revision'] == my_revision
+
+        info = YAML::load(svn(:info, repos))
+        his_revision = revision || info['Revision']
+        options = [:export]
+        options << ['--revision', his_revision] 
+        options << '--quiet'
+        options << repos
+        options << dir
+        export = svn options
+        export.each_line do |line|
+          next unless line =~ /Exported revision (\d+)./i
+          @revision = $1
+          break
+        end
+
+        # Add so we can set properties
+        svn :add, '--non-recursive', '--force', '--quiet', dir
+
+        # Set the properties
+        svn :propset, Piston::ROOT, repos, dir
+        svn :propset, Piston::UUID, info['Repository UUID'], dir
+        svn :propset, Piston::REMOTE_REV, his_revision, dir
+        svn :propset, Piston::LOCAL_REV, my_revision, dir
+        svn :propset, Piston::LOCKED, revision, dir if lock
+
+        # Finish adding.  If we get an error, at least the properties will be
+        # set and the user can handle the rest
+        svn :add, '--force', '--quiet', dir
+
+        logging_stream.puts "Exported r#{his_revision} from '#{repos}' to '#{dir}'"
+      end
+
+      def self.help
+        "Prepares a folder for merge tracking"
+      end
+
+      def self.detailed_help
+        <<EOF
+usage: import REPOS_URL [DIR]
+
+  Exports the specified REPOS_URL (which must be a Subversion repository) to
+  DIR, defaulting to the last component of REPOS_URL if DIR is not present.
+
+  If the local folder already exists, this command will abort with an error.
+EOF
+      end
+
+      def self.aliases
+        %w(init)
+      end
+    end
+  end
+end

data/lib/piston/commands/lock.rb

@@ -0,0 +1,30 @@
+require "piston"
+require "piston/command"
+
+module Piston
+  module Commands
+    class Lock < Piston::Command
+      def run
+        raise Piston::CommandError, "No targets to run against" if args.empty?
+
+        args.each do |dir|
+          remote_rev = svn(:propget, Piston::REMOTE_REV, dir).chomp.to_i
+          svn :propset, Piston::LOCKED, remote_rev, dir
+          logging_stream.puts "'#{dir}' locked at revision #{remote_rev}"
+        end
+      end
+
+      def self.help
+        "Lock one or more folders to their current revision"
+      end
+
+      def self.detailed_help
+        <<EOF
+usage: lock DIR [DIR [...]]
+
+  Locked folders will not be updated to the latest revision when updating.
+EOF
+      end
+    end
+  end
+end

data/lib/piston/commands/status.rb

@@ -0,0 +1,82 @@
+require "piston"
+require "piston/command"
+require 'pp'
+
+module Piston
+  module Commands
+    class Status < Piston::Command
+      def run
+        # First, find the list of pistoned folders
+        folders = svn(:propget, '--recursive', Piston::ROOT, *args)
+        repos = Hash.new
+        folders.each_line do |line|
+          next unless line =~ /(\w.*) - /
+          repos[$1] = Hash.new
+        end
+
+        # Then, get their properties
+        repo = nil
+        last_piston_key = nil
+        svn(:proplist, '--verbose', *repos.keys).each_line do |line|
+          case line
+          when /'([^']+)'/
+            repo = repos[$1]
+          when /(piston:[-\w]+)\s*:\s*(.*)$/
+            repo[$1] = $2
+            when /(piston:[-\w]+)\s$/
+              last_piston_key = $1
+            when /^\s*(.*)\s*$/
+              repo[last_piston_key] = $1 if last_piston_key
+              last_piston_key = nil
+            else
+              last_piston_key = nil
+          end
+        end
+
+        # Determine their local status
+        repos.each_pair do |path, props|
+          log = svn(:log, '--revision', "#{props[Piston::LOCAL_REV]}:HEAD", '--quiet', '--limit', '2', path)
+          props[:locally_modified] = 'M' if log.count("\n") > 3
+        end
+
+        # And their remote status, if required
+        repos.values.each do |props|
+          log = svn(:log, '--revision', "#{props[Piston::REMOTE_REV]}:HEAD", '--quiet', '--limit', '2', props[Piston::ROOT])
+          props[:remotely_modified] = 'M' if log.count("\n") > 3
+        end if show_updates
+
+        # Display the results
+        repos.each_pair do |path, props|
+          logging_stream.printf "%1s%1s    %5s %s (%s)\n", props[:locally_modified],
+              props[:remotely_modified], props[Piston::LOCKED], path, props[Piston::ROOT]
+        end
+
+        logging_stream.puts "No pistoned folders found" if repos.empty?
+      end
+
+      def self.help
+        "Determines the current status of each pistoned directory"
+      end
+
+      def self.detailed_help
+        <<EOF
+usage: status [DIR [DIR...]]
+
+  Shows the status of one, many or all pistoned folders.  The status is
+  returned in columns.
+
+  The first column's values are:
+     :  Locally unchanged (space)
+    M:  Locally modified since importing
+
+  The second column's values are blanks, unless the --show-updates is passed.
+    M:  Remotely modified since importing
+EOF
+      end
+
+      def self.aliases
+        %w(st)
+      end
+    end
+  end
+end

data/lib/piston/commands/switch.rb

@@ -0,0 +1,139 @@
+require "piston"
+require "piston/command"
+
+module Piston
+  module Commands
+    class Switch < Piston::Command
+      def run
+        new_root, dir = args.shift, args.shift
+        raise Piston::CommandError, "Expected two arguments only to switch.  Unrecognized arguments: #{args.inspect}" unless args.empty?
+        raise Piston::CommandError, "Expected a new vendor repository URL." if new_root.nil?
+        raise Piston::CommandError, "Expected a directory to update." if dir.nil?
+        switch(dir, new_root)
+      end
+
+      def switch(dir, new_repos)
+        return unless File.directory?(dir)
+        return skip(dir, "locked") unless svn(:propget, 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 =~ /^\?/
+          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
+
+        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
+
+        new_info = YAML::load(svn(:info, new_repos))
+        raise Piston::CommandError, "Switching repositories is not supported at this time\nYou initially imported from #{uuid}, but are now importing from #{new_info['Repository UUID']}" unless uuid == new_info['Repository UUID']
+
+        logging_stream.puts "  Fetching remote repository's latest revision and UUID"
+        info = YAML::load(svn(:info, "#{repos}@#{remote_revision}"))
+        return skip(dir, "Repository UUID changed\n  Expected #{uuid}\n  Found    #{info['Repository UUID']}\n  Repository: #{repos}") unless uuid == info['Repository UUID']
+
+        new_remote_rev = new_info['Last Changed Rev'].to_i
+        revisions = (remote_revision .. (revision || new_remote_rev))
+
+        logging_stream.puts "  Restoring remote repository to known state at r#{revisions.first}"
+        svn :checkout, '--ignore-externals', '--quiet', '--revision', revisions.first, "#{repos}@#{remote_revision}", dir.tmp
+
+        logging_stream.puts "  Updating remote repository to #{new_repos}@#{revisions.last}"
+        updates = svn :switch, '--revision', revisions.last, new_repos, dir.tmp
+
+        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
+
+          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
+          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
+
+        logging_stream.puts "  Removing temporary files / folders"
+        FileUtils.rm_rf dir.tmp
+
+        logging_stream.puts "  Updating Piston properties"
+        svn :propset, Piston::ROOT, new_repos, dir
+        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
+
+        logging_stream.puts "  Updated to r#{revisions.last} (#{changes} changes)"
+      end
+
+      def copy(dir, file)
+        FileUtils.cp(File.join(dir.tmp, file), File.join(dir, file))
+      end
+
+      def skip(dir, msg, header=true)
+        logging_stream.print "Skipping '#{dir}': " if header
+        logging_stream.puts msg
+      end
+
+      def self.help
+        "Switches a single directory to a new repository root"
+      end
+
+      def self.detailed_help
+        <<EOF
+usage: switch NEW_REPOSITORY_ROOT DIR
+
+  This operation changes the remote location from A to B, keeping local
+  changes.  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.
+
+  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
+      end
+
+      def self.aliases
+        %w(sw)
+      end
+    end
+  end
+end