realityforge-piston 1.4.1

data/lib/piston/commands/unlock.rb

@@ -0,0 +1,29 @@
+require "piston"
+require "piston/command"
+
+module Piston
+  module Commands
+    class Unlock < Piston::Command
+      def run
+        raise Piston::CommandError, "No targets to run against" if args.empty?
+        svn :propdel, Piston::LOCKED, *args
+        args.each do |dir|
+          logging_stream.puts "Unlocked '#{dir}'"
+        end
+      end
+
+      def self.help
+        "Undoes the changes enabled by lock"
+      end
+
+      def self.detailed_help
+        <<EOF
+usage: unlock DIR [DIR [...]]
+
+  Unlocked folders are free to be updated to the latest revision when
+  updating.
+EOF
+      end
+    end
+  end
+end

data/lib/piston/commands/update.rb

@@ -0,0 +1,131 @@
+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 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 =~ /^\?/
+          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
+
+        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']
+
+        new_remote_rev = info['Last Changed Rev'].to_i
+        return skip(dir, "unchanged from revision #{remote_revision}", false) if remote_revision == new_remote_rev
+
+        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, dir.tmp
+
+        logging_stream.puts "  Updating remote repository to r#{revisions.last}"
+        updates = svn :update, '--ignore-externals', '--revision', revisions.last, 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::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 self.help
+        "Updates all or specified folders to the latest revision"
+      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.
+
+  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(up)
+      end
+    end
+  end
+end

data/lib/piston/version.rb

@@ -0,0 +1,9 @@
+module Piston
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 4
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/transat/parser.rb

@@ -0,0 +1,189 @@
+require "optparse"
+
+module Transat
+  class VersionNeeded < StandardError; end
+
+  class HelpNeeded < StandardError
+    attr_reader :command
+
+    def initialize(command)
+      @command = command
+    end
+  end
+
+  class NoCommandGiven < StandardError
+    def message
+      "No command given"
+    end
+  end
+
+  class UnknownOptions < StandardError
+    attr_reader :command
+
+    def initialize(command, unrecognized_options)
+      @command, @unrecognized_options = command, unrecognized_options
+    end
+
+    def message
+      "Command #{@command} does not accept options #{@unrecognized_options.join(", ")}"
+    end
+  end
+
+  class UnknownCommand < StandardError
+    def initialize(command, parser)
+      @command, @parser = command, parser
+    end
+
+    def message
+      "Unknown command: #{@command.inspect}"
+    end
+  end
+
+  class BaseCommand
+    attr_reader :non_options, :options
+    def initialize(non_options, options)
+      @non_options, @options = non_options, options
+    end
+  end
+
+  class VersionCommand < BaseCommand
+    def run
+      raise VersionNeeded
+    end
+  end
+
+  class HelpCommand < BaseCommand
+    def run
+      raise HelpNeeded.new(non_options.first)
+    end
+  end
+
+  class Parser
+    def initialize(&block)
+      @valid_options, @received_options, @commands = [], {}, {}
+      @option_parser = OptionParser.new
+
+      command(:help, Transat::HelpCommand)
+      command(:version, Transat::VersionCommand)
+      instance_eval(&block) if block_given?
+    end
+
+    def option(name, options={})
+      options[:long] = name.to_s.gsub("_", "-") unless options[:long]
+      @valid_options << name
+      @received_options[name] = nil
+
+      opt_args = []
+      opt_args << "-#{options[:short]}" if options.has_key?(:short)
+      opt_args << "--#{options[:long] || name}"
+      opt_args << "=#{options[:param_name]}" if options.has_key?(:param_name)
+      opt_args << options[:message]
+      case options[:type]
+      when :int, :integer
+        opt_args << Integer
+      when :float
+        opt_args << Float
+      when nil
+        # NOP
+      else
+        raise ArgumentError, "Option #{name} has a bad :type parameter: #{options[:type].inspect}"
+      end
+
+      @option_parser.on(*opt_args.compact) do |value|
+        @received_options[name] = value
+      end
+    end
+
+    def command(name, klass, options={})
+      @commands[name.to_s] = options.merge(:class => klass)
+    end
+
+    def parse_and_execute(args=ARGV)
+      begin
+        command, non_options = parse(args)
+        execute(command, non_options)
+      rescue HelpNeeded
+        $stderr.puts usage($!.command)
+        exit 1
+      rescue VersionNeeded
+        puts "#{program_name} #{version}"
+        exit 0
+      rescue NoCommandGiven, UnknownOptions, UnknownCommand
+        $stderr.puts "ERROR: #{$!.message}"
+        $stderr.puts usage($!.respond_to?(:command) ? $!.command : nil)
+        exit 1
+      end
+    end
+
+    def parse(args)
+      non_options = @option_parser.parse(args)
+      command = non_options.shift
+      raise NoCommandGiven unless command
+      return command, non_options
+    end
+
+    def execute(command, non_options)
+      found = false
+      @commands.each do |command_name, options|
+        command_klass = options[:class]
+        aliases = [command_name]
+        aliases += command_klass.aliases if command_klass.respond_to?(:aliases)
+        return command_klass.new(non_options, @received_options).run if aliases.include?(command)
+      end
+
+      raise UnknownCommand.new(command, self)
+    end
+
+    def usage(command=nil)
+      message = []
+
+      if command then
+        command_klass = @commands[command][:class]
+        help =
+          if command_klass.respond_to?(:aliases) then
+            "#{command} (#{command_klass.aliases.join(", ")})"
+          else
+            "#{command}"
+          end
+        help = "#{help}: #{command_klass.help}" if command_klass.respond_to?(:help)
+        message << help
+        message << command_klass.detailed_help if command_klass.respond_to?(:detailed_help)
+        message << ""
+        message << "Valid options:"
+        @option_parser.summarize(message)
+      else
+        message << "usage: #{program_name.downcase} <SUBCOMMAND> [OPTIONS] [ARGS...]"
+        message << "Type '#{program_name.downcase} help <SUBCOMMAND>' for help on a specific subcommand."
+        message << "Type '#{program_name.downcase} version' to get this program's version."
+        message << ""
+        message << "Available subcommands are:"
+        @commands.sort.each do |command, options|
+          command_klass = options[:class]
+          if command_klass.respond_to?(:aliases) then
+            message << "  #{command} (#{command_klass.aliases.join(", ")})"
+          else
+            message << "  #{command}"
+          end
+        end
+      end
+
+      message.map {|line| line.chomp}.join("\n")
+    end
+
+    def program_name(value=nil)
+      value ? @program_name = value : @program_name
+    end
+
+    def version(value=nil)
+      if value then
+        @version = value.respond_to?(:join) ? value.join(".") : value
+      else
+        @version
+      end
+    end
+
+    def self.parse_and_execute(args=ARGV, &block)
+      self.new(&block).parse_and_execute(args)
+    end
+  end
+end

data/piston.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |spec|
+  spec.name           = 'realityforge-piston'
+  spec.version        = Piston::VERSION::STRING
+  spec.authors        = ['Francois Beausoleil','Peter Donald']
+  spec.email          = ["francois@teksol.info", "peter@realityforge.org"]
+  spec.homepage       = "http://github.com/realityforge/piston"
+  spec.summary        = "Piston is a utility that eases vendor branch management in subversion."
+  spec.description    = <<-TEXT
+Piston is a utility that eases vendor branch management in subversion.
+  TEXT
+  spec.files          = Dir['{contrib,bin,lib,spec}/**/*', '*.gemspec'] +
+                        ['LICENSE', 'README.rdoc', 'CHANGELOG', 'Rakefile']
+  spec.require_paths  = ['lib']
+
+  spec.bindir = "bin"                               # Use these for applications.
+  spec.executables = ["piston"]
+  spec.default_executable = "piston"
+  
+  spec.has_rdoc         = true
+  spec.extra_rdoc_files = 'README.rdoc', 'LICENSE', 'CHANGELOG'
+  spec.rdoc_options     = '--title', "#{spec.name} #{spec.version}", '--main', 'README.rdoc'
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: realityforge-piston
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 1
+    - 4
+    - 1
+  version: 1.4.1
+platform: ruby
+authors: 
+  - Francois Beausoleil
+  - Peter Donald
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-28 00:00:00 +10:00
+default_executable: piston
+dependencies: []
+
+description: |
+  Piston is a utility that eases vendor branch management in subversion.
+
+email: 
+  - francois@teksol.info
+  - peter@realityforge.org
+executables: 
+  - piston
+extensions: []
+
+extra_rdoc_files: 
+  - README.rdoc
+  - LICENSE
+  - CHANGELOG
+files: 
+  - contrib/piston
+  - bin/piston
+  - lib/piston.rb
+  - lib/core_ext/range.rb
+  - lib/core_ext/string.rb
+  - lib/piston/command.rb
+  - lib/piston/command_error.rb
+  - lib/piston/version.rb
+  - lib/piston/commands/convert.rb
+  - lib/piston/commands/diff.rb
+  - lib/piston/commands/import.rb
+  - lib/piston/commands/lock.rb
+  - lib/piston/commands/status.rb
+  - lib/piston/commands/switch.rb
+  - lib/piston/commands/unlock.rb
+  - lib/piston/commands/update.rb
+  - lib/transat/parser.rb
+  - piston.gemspec
+  - LICENSE
+  - README.rdoc
+  - CHANGELOG
+  - Rakefile
+has_rdoc: true
+homepage: http://github.com/realityforge/piston
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+  - --title
+  - realityforge-piston 1.4.1
+  - --main
+  - README.rdoc
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Piston is a utility that eases vendor branch management in subversion.
+test_files: []
+