piston 1.4.0 → 2.0.1

data/lib/piston/commands/import.rb

@@ -1,74 +1,65 @@
-require "piston"
-require "piston/command"
+require "piston/commands/base"
 
 module Piston
   module Commands
-    class Import < Piston::Command
-      def run
-        raise Piston::CommandError, "Missing REPOS_URL argument" if args.empty?
+    class Import < Piston::Commands::Base
+      attr_reader :options
 
-        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
+      def repository_type
+        options[:repository_type]
+      end
 
-        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
+      def select_repository(repository_url)
+        if repository_type then
+          logger.info {"Forced repository type to #{repository_type}"}
+          repository_class_name = "Piston::#{repository_type.downcase.capitalize}::Repository"
+          repository_class = repository_class_name.constantize
+          repository_class.new(repository_url)
+        else
+          logger.info {"Guessing the repository type"}
+          Piston::Repository.guess(repository_url)
         end
+      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
+      def run(repository_url, target_revision, wcdir)
+        repository = select_repository(repository_url)
+        revision = repository.at(target_revision)
 
-        logging_stream.puts "Exported r#{his_revision} from '#{repos}' to '#{dir}'"
-      end
+        wcdir = File.expand_path(wcdir.nil? ? repository.basename : wcdir)
+        logger.info {"Guessing the working copy type"}
+        logger.debug {"repository_url: #{repository_url.inspect}, target_revision: #{target_revision.inspect}, wcdir: #{wcdir.inspect}"}
+        working_copy = guess_wc(wcdir)
 
-      def self.help
-        "Prepares a folder for merge tracking"
+        if working_copy.exist? && !force then
+          logger.fatal "Path #{working_copy} already exists and --force not given.  Aborting..."
+          abort
+        end
+        
+        working_copy.import(revision, options[:lock])
+        logger.info {"Imported #{revision} from #{repository}"}
       end
 
-      def self.detailed_help
-        <<EOF
-usage: import REPOS_URL [DIR]
+      def start(*args)
+        repository_url = args.shift
+        wcdir          = args.shift
 
-  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.
+        raise ArgumentError, "Required REPOSITORY argument missing" if repository_url.blank?
 
-  If the local folder already exists, this command will abort with an error.
-EOF
-      end
+        begin
+          self.run(repository_url, options[:revision] || options[:commit] || :head, wcdir)
+        rescue Piston::Repository::UnhandledUrl => e
+          supported_types = Piston::Repository.handlers.collect do |handler|
+            handler.repository_type
+          end
+          puts "Unsure how to handle:"
+          puts "\t#{repository_url.inspect}."
+          puts "You should try using --repository-type. Supported types are:"
+          supported_types.each do |type|
+            puts "\t#{type}"
+          end
 
-      def self.aliases
-        %w(init)
+          exit 1
+        end
       end
     end
   end

data/lib/piston/commands/info.rb

@@ -0,0 +1,24 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    class Info < Piston::Commands::Base
+      attr_reader :options
+
+      def run(wcdir)
+        working_copy = working_copy!(wcdir)
+        working_copy.info.to_yaml
+      end
+
+			def start(*args)
+				args.flatten.map {|d| Pathname.new(d).expand_path}.each do |wcdir|
+					begin
+						run(wcdir)
+					rescue Piston::WorkingCopy::NotWorkingCopy
+						puts "#{wcdir} is not a working copy"
+					end
+				end
+			end
+    end
+  end
+end

data/lib/piston/commands/lock_unlock.rb

@@ -0,0 +1,26 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    class LockUnlock < Piston::Commands::Base
+      attr_reader :options
+
+      def run(lock)
+        working_copy = working_copy!(File.expand_path(options[:wcdir]))
+
+        values = working_copy.recall
+        values["lock"] = lock
+        working_copy.remember(values, values["handler"])
+        working_copy.finalize
+
+        text = lock ? "Locked" : "Unlocked"
+        logger.info "#{text} #{working_copy} against automatic updates"
+      end
+
+			def start(*args)
+				options[:wcdir] = args.first
+				run(true)
+			end
+    end
+  end
+end

data/lib/piston/commands/status.rb

@@ -1,75 +1,50 @@
-require "piston"
-require "piston/command"
-require 'pp'
+require "piston/commands/base"
 
 module Piston
   module Commands
-    class Status < Piston::Command
-      def run
-        # First, find the list of pistoned folders
-        folders = svn(:propget, '--recursive', Piston::ROOT, *args)
+    class Status < Piston::Commands::Base
+      def run(wcdir)
+        # Get the working copy handler to search pistonized folders inside it
+        handler = guess_wc(wcdir).class
+        
+        # First, find the list of pistonized folders
         repos = Hash.new
-        repo = nil
-        folders.each_line do |line|
-          next unless line =~ /(\w.*) - /
-          repos[$1] = Hash.new
+        Pathname.glob(wcdir + '**/.piston.yml') do |path|
+          repos[path.dirname] = Hash.new
         end
 
         # Then, get their properties
-        repo = nil
-        svn(:proplist, '--verbose', *repos.keys).each_line do |line|
-          case line
-          when /'([^']+)'/
-            repo = repos[$1]
-          when /(piston:[-\w]+)\s*:\s*(.*)$/
-            repo[$1] = $2
-          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
+          logger.debug {"Get info of #{path}"}
+          working_copy = handler.new(path)
+          working_copy.validate!
+          props.update(working_copy.info)
+          props[:locally_modified] = 'M' if working_copy.locally_modified
+          props[:remotely_modified] = 'M' if show_updates and working_copy.remotely_modified
         end
 
-        # And their remote status, if required
-        repos.each_pair do |path, 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]
+          printf "%1s%1s %6s %s (%s)\n", props[:locally_modified],
+              props[:remotely_modified], props["lock"] ? 'locked' : '', path, props["repository_url"]
         end
 
-        logging_stream.puts "No pistoned folders found" if repos.empty?
-      end
-
-      def self.help
-        "Determines the current status of each pistoned directory"
+        puts "No pistonized folders found in #{wcdir}" if repos.empty?
       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
+      def show_updates
+        options[:show_updates]
       end
 
-      def self.aliases
-        %w(st)
-      end
+			def start(*args)
+				args.flatten.map {|d| Pathname.new(d).expand_path}.each do |wcdir|
+					begin
+						run(wcdir)
+					rescue Piston::WorkingCopy::NotWorkingCopy
+						puts "#{wcdir} is not a working copy"
+					end
+				end
+			end
     end
   end
 end

data/lib/piston/commands/update.rb

@@ -1,131 +1,44 @@
-require "piston"
-require "piston/command"
-require 'find'
+require "piston/commands/base"
 
 module Piston
   module Commands
-    class Update < Piston::Command
-      def run
-        (args.empty? ? find_targets : args).each do |dir|
-          update dir
+    class Update < Piston::Commands::Base
+      # +wcdir+ is the working copy we're going to change.
+      # +to+ is the new target revision we want to be at after update returns.
+      def run(wcdir, to)
+        working_copy = working_copy!(wcdir)
+
+        logger.debug {"Recalling previously saved values"}
+        values = working_copy.recall
+        return "#{wcdir} is locked: not updating" if values["lock"]
+
+        repository    = working_copy.repository
+        from_revision = repository.at(values["handler"])
+        to_revision   = repository.at(to)
+        to_revision.resolve!
+
+        logger.debug {"Validating that #{from_revision} exists and is capable of performing the update"}
+        from_revision.validate!
+
+        logger.info {"Updating from #{from_revision} to #{to_revision}"}
+
+        changed = working_copy.update(from_revision, to_revision, options[:lock])
+        if changed then
+          logger.info {"Updated #{wcdir} to #{to_revision}"}
+        else
+          logger.info {"Upstream #{repository} was unchanged from #{from_revision}"}
         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
+			def start(*args)
+				args.flatten.map {|d| Pathname.new(d).expand_path}.each do |wcdir|
+					begin
+						run(wcdir, options[:revision] || options[:commit] || :head)
+					rescue Piston::WorkingCopy::NotWorkingCopy
+						puts "#{wcdir} is not a working copy"
+					end
+				end
+			end
     end
   end
 end

data/lib/piston/commands/upgrade.rb

@@ -0,0 +1,26 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    class Upgrade < Piston::Commands::Base
+      def run(*directories)
+        # piston 1.x managed only subversion repositories
+        directories = directories.select { |dir| Piston::Svn::WorkingCopy.understands_dir? dir }
+
+        repositories = Piston::Svn::WorkingCopy.old_repositories(*directories)
+        repositories.each do |repository|
+          logger.debug {"Upgrading repository #{repository}"}
+          Piston::Svn::WorkingCopy.new(repository).upgrade
+        end
+
+        repositories
+      end
+
+			def start(*args)
+				targets = args.flatten.map {|d| Pathname.new(d).expand_path}
+				run(targets)
+				puts "#{targets.length} directories upgraded"
+			end
+    end
+  end
+end

data/lib/piston/commands.rb

@@ -0,0 +1,4 @@
+dir = File.dirname(__FILE__)
+Dir["#{dir}/commands/**/*.rb"].each do |f|
+  require f.gsub("#{File.expand_path("#{File.dirname(f)}/../..")}/", "")
+end

data/lib/piston/git/client.rb

@@ -0,0 +1,76 @@
+require "singleton"
+
+module Piston
+  module Git
+    class Client
+      include Singleton
+
+      class CommandError < RuntimeError; end
+      class Failed < CommandError; end
+      class BadCommand < CommandError; end
+
+      def logger
+        @logger ||= Log4r::Logger["handler::client"]
+      end
+
+      def out_logger
+        @out_logger ||= Log4r::Logger["handler::client::out"]
+      end
+
+      def git(*args)
+        run_cmd :git, *args
+      end
+
+      private
+      def run_cmd(executable, *args)
+        args.collect! {|arg| arg.to_s =~ /\s|\*|\?|"|\n|\r/ ? %Q('#{arg}') : arg}
+        args.collect! {|arg| arg ? arg : '""'}
+        cmd = %Q|#{executable} #{args.join(' ')}|
+        logger.debug {"> " + cmd}
+
+        original_language = ENV["LANGUAGE"]
+        begin
+          ENV["LANGUAGE"] = "C"
+          value = run_real(cmd)
+          out_logger.info {"< " + value} unless (value || "").strip.empty?
+          return value
+        ensure
+          ENV["LANGUAGE"] = original_language
+        end
+      end
+
+      begin
+        raise LoadError, "Not implemented on Win32 machines" if RUBY_PLATFORM =~ /mswin32/
+
+          begin
+            require "rubygems"
+          rescue LoadError
+            # NOP -- attempt to load without Rubygems
+          end
+
+        require "open4"
+
+        def run_real(cmd)
+          begin
+            pid, stdin, stdout, stderr = Open4::popen4(cmd)
+            _, cmdstatus = Process.waitpid2(pid)
+            raise CommandError, "#{cmd.inspect} exited with status: #{cmdstatus.exitstatus}\n#{stderr.read}" unless cmdstatus.success? || cmdstatus.exitstatus == 1
+            return stdout.read
+          rescue Errno::ENOENT
+            raise BadCommand, cmd.inspect
+          end
+        end
+
+      rescue LoadError
+        # On platforms where open4 is unavailable, we fallback to running using
+        # the backtick method of Kernel.
+        def run_real(cmd)
+          out = `#{cmd}`
+          raise BadCommand, cmd.inspect if $?.exitstatus == 127
+          raise Failed, "#{cmd.inspect} exited with status: #{$?.exitstatus}" unless $?.success? || $?.exitstatus == 1
+          out
+        end
+      end
+    end
+  end
+end

data/lib/piston/git/commit.rb

@@ -0,0 +1,114 @@
+require "piston/git/client"
+require "piston/revision"
+require "fileutils"
+
+module Piston
+  module Git
+    class Commit < Piston::Revision
+      class InvalidCommit < RuntimeError; end
+      class Gone < InvalidCommit; end
+
+      alias_method :commit, :revision
+      attr_reader :sha1
+
+      def initialize(repository, revision, recalled_values={})
+        super
+        @revision = 'master' if @revision.upcase == 'HEAD'
+      end
+
+      def client
+        @client ||= Piston::Git::Client.instance
+      end
+
+      def git(*args)
+        client.git(*args)
+      end
+
+      def recalled_commit_id
+        recalled_values[Piston::Git::COMMIT]
+      end
+
+      def validate!
+        begin
+          data = git("ls-remote", @repository.url)
+          self
+        rescue Piston::Git::Client::CommandError
+          raise Piston::Git::Commit::Gone, "Repository at #{@repository.url} does not exist anymore"
+        end
+      end
+
+      def name
+        commit[0,7]
+      end
+
+      def branch_name
+        "my-#{commit}"
+      end
+
+      def checkout_to(dir)
+        super
+        git(:clone, repository.url, @dir)
+        Dir.chdir(@dir) do
+          git(:checkout, "-b", branch_name, commit)
+          response = git(:log, "-n", "1")
+          @sha1 = $1 if response =~ /commit\s+([a-f\d]{40})/i
+        end
+      end
+
+      def update_to(commit)
+        raise ArgumentError, "Commit #{self.commit} of #{repository.url} was never checked out -- can't update" unless @dir
+        
+        Dir.chdir(@dir) do
+          logger.debug {"Saving old changes before updating"}
+          git(:commit, '-a', '-m', 'old changes')
+          logger.debug {"Merging old changes with #{commit}"}
+          git(:merge, '--squash', commit)
+          output = git(:status)
+          added = output.scan(/new file:\s+(.*)$/).flatten
+          deleted = output.scan(/deleted:\s+(.*)$/).flatten
+          renamed = output.scan(/renamed:\s+(.+) -> (.+)$/)
+          [added, deleted, renamed]
+        end
+      end
+
+      def remember_values
+        # find last commit for +commit+ if it wasn't checked out
+        @sha1 = git('ls-remote', repository.url, commit).match(/\w+/)[0] unless @sha1
+        # if ls-remote returns nothing, +commit+ must be a commit, not a branch
+        @sha1 = commit unless @sha1
+        { Piston::Git::COMMIT => @sha1, Piston::Git::BRANCH => commit }
+      end
+
+      def each
+        raise ArgumentError, "Never cloned + checked out" if @dir.nil?
+        @dir.find do |path|
+          Find.prune if path.to_s =~ %r{/[.]git}
+          next if @dir == path
+          next if File.directory?(path)
+          yield path.relative_path_from(@dir)
+        end
+      end
+
+      def remotely_modified
+        branch = recalled_values[Piston::Git::BRANCH]
+        logger.debug {"Get last commit in #{branch} of #{repository.url}"}
+        commit = git('ls-remote', repository.url, branch).match(/\w+/)
+        # when we update to a commit, instead latest commit of a branch, +branch+ will be a commit, and ls-remote can return nil
+        commit = commit[0] unless commit.nil?
+        commit != self.commit
+      end
+
+      def exclude_for_diff
+        Piston::Git::EXCLUDE
+      end
+
+      def to_s
+        "commit #{sha1}"
+      end
+
+      def resolve!
+        # NOP, because @sha1 is what we want
+      end
+    end
+  end
+end