francois-piston 2.0.0

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/commands/base.rb

@@ -0,0 +1,44 @@
+module Piston
+  module Commands
+    class Base
+      class << self
+        def logger
+          @@logger ||= Log4r::Logger["main"]
+        end
+      end
+
+      attr_reader :options
+
+      def initialize(options={})
+        @options = options
+        logger.debug {"#{self.class.name} with options #{options.inspect}"}
+      end
+
+      def verbose
+        @options[:verbose]
+      end
+
+      def force
+        @options[:force]
+      end
+
+      def quiet
+        @options[:quiet]
+      end
+
+      def logger
+        self.class.logger
+      end
+      
+      def guess_wc(wcdir)
+        Piston::WorkingCopy.guess(wcdir)
+      end
+      
+      def working_copy!(wcdir)
+        wc = guess_wc(wcdir)
+        wc.validate!
+        wc
+      end
+    end
+  end
+end

data/lib/piston/commands/convert.rb

@@ -0,0 +1,26 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    class Convert < Piston::Commands::Base
+      attr_reader :options
+
+      def run(targets)
+        targets = Array.new unless targets
+        wc = Piston::Svn::WorkingCopy.new(Dir.pwd)
+        importer = Piston::Commands::Import.new(options)
+        returning(Array.new) do |conversions|
+          wc.externals.each_pair do |dir, args|
+            next unless targets.empty? || targets.detect {|target| dir.to_s.include?(target.to_s) }
+            conversions << dir
+
+            logger.info "Importing #{dir.relative_path_from(wc.path)} from #{args[:url]}"
+            importer.run(args[:url], args[:revision], dir)
+          end
+
+          wc.remove_external_references(*targets)
+        end
+      end
+    end
+  end
+end

data/lib/piston/commands/diff.rb

@@ -0,0 +1,12 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    class Diff < Piston::Commands::Base
+      def run
+        working_copy = working_copy!(options[:wcdir])
+        working_copy.diff
+      end
+    end
+  end
+end

data/lib/piston/commands/import.rb

@@ -0,0 +1,43 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    class Import < Piston::Commands::Base
+      attr_reader :options
+
+      def repository_type
+        options[:repository_type]
+      end
+
+      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
+
+      def run(repository_url, target_revision, wcdir)
+        repository = select_repository(repository_url)
+        revision = repository.at(target_revision)
+
+        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)
+
+        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
+    end
+  end
+end

data/lib/piston/commands/info.rb

@@ -0,0 +1,14 @@
+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
+    end
+  end
+end

data/lib/piston/commands/lock_unlock.rb

@@ -0,0 +1,21 @@
+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
+    end
+  end
+end

data/lib/piston/commands/status.rb

@@ -0,0 +1,40 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    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
+        Pathname.glob(wcdir + '**/.piston.yml') do |path|
+          repos[path.dirname] = Hash.new
+        end
+
+        # Then, get their properties
+        repos.each_pair do |path, props|
+          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
+
+        # Display the results
+        repos.each_pair do |path, props|
+          printf "%1s%1s %6s %s (%s)\n", props[:locally_modified],
+              props[:remotely_modified], props["lock"] ? 'locked' : '', path, props["repository_url"]
+        end
+
+        puts "No pistonized folders found in #{wcdir}" if repos.empty?
+      end
+
+      def show_updates
+        options[:show_updates]
+      end
+    end
+  end
+end

data/lib/piston/commands/update.rb

@@ -0,0 +1,34 @@
+require "piston/commands/base"
+
+module Piston
+  module Commands
+    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
+    end
+  end
+end

data/lib/piston/commands/upgrade.rb

@@ -0,0 +1,20 @@
+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
+    end
+  end
+end

data/lib/piston/git.rb

@@ -0,0 +1,13 @@
+require "piston/git/client"
+require "piston/git/repository"
+require "piston/git/commit"
+require "piston/git/working_copy"
+
+module Piston
+  module Git
+    URL = "url"
+    COMMIT = "commit"
+    BRANCH = "branch"
+    EXCLUDE = [".git"]
+  end
+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