pivotal-piston 1.9.4

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/import.rb

@@ -0,0 +1,42 @@
+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])
+      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(wcdir, lock)
+        working_copy = working_copy!(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/update.rb

@@ -0,0 +1,29 @@
+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
+
+        repository_class = values["repository_class"]
+        repository_url = values["repository_url"]
+        repository = repository_class.constantize.new(repository_url)
+        from_revision = repository.at(values["handler"])
+        to_revision = repository.at(to)
+
+        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}"}
+
+        working_copy.update(to_revision, options[:lock])
+      end
+    end
+  end
+end

data/lib/piston/git.rb

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

data/lib/piston/git/client.rb

@@ -0,0 +1,77 @@
+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 =~ /\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)
+            return stdout.read if cmd =~ /status/ && cmdstatus.exitstatus == 1
+            raise CommandError, "#{cmd.inspect} exited with status: #{cmdstatus.exitstatus}\n#{stderr.read}" unless cmdstatus.success?
+            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?
+          out
+        end
+      end
+    end
+  end
+end

data/lib/piston/git/commit.rb

@@ -0,0 +1,74 @@
+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 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
+          logger.debug {"in dir #{@dir}"}
+          git(:checkout, "-b", branch_name, commit)
+          response = git(:log, "-n", "1")
+          @sha1 = $1 if response =~ /commit\s+([a-f\d]{40})/i
+        end
+
+        def remember_values
+          { 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 copy_to(relpath, abspath)
+          Pathname.new(abspath).dirname.mkpath
+          FileUtils.cp(@dir + relpath, abspath)
+        end
+      end
+    end
+  end
+end

data/lib/piston/git/repository.rb

@@ -0,0 +1,63 @@
+require "piston/git/commit"
+require "uri"
+
+module Piston
+  module Git
+    class Repository < Piston::Repository
+      Piston::Repository.add_handler self
+
+      class << self
+        def understands_url?(url)
+          uri = URI.parse(url) rescue nil
+          return true if uri && %w(git).include?(uri.scheme)
+
+          begin
+            response = git("ls-remote", "--heads", url.sub(/\?.+$/, ""))
+            return false if response.nil? || response.strip.chomp.empty?
+            !!(response =~ /[a-f\d]{40}\s/)
+          rescue Piston::Git::Client::CommandError
+            false
+          end
+        end
+
+        def client
+          @@client ||= Piston::Git::Client.instance
+        end
+
+        def git(*args)
+          client.git(*args)
+        end
+        
+        def repository_type
+          'git'
+        end
+      end
+
+      attr_reader :branchname
+
+      def initialize(url)
+        @branchname = url.split("?")[1]
+        super(url.sub(/\?.+$/, ""))
+      end
+
+      def git(*args)
+        self.class.git(*args)
+      end
+
+      def at(commit)
+        case commit
+        when Hash
+          Piston::Git::Commit.new(self, commit[Piston::Git::COMMIT])
+        when :head
+          Piston::Git::Commit.new(self, "HEAD")
+        else
+          Piston::Git::Commit.new(self, commit)
+        end
+      end
+
+      def basename
+        self.url.split("/").last.sub(".git", "")
+      end
+    end
+  end
+end

data/lib/piston/git/working_copy.rb

@@ -0,0 +1,86 @@
+require "piston/working_copy"
+require "piston/git/client"
+
+module Piston
+  module Git
+    class WorkingCopy < Piston::WorkingCopy
+      # Register ourselves as a handler for working copies
+      Piston::WorkingCopy.add_handler self
+
+      class << self
+        def understands_dir?(dir)
+          path = dir
+          begin
+            begin
+              logger.debug {"git status on #{path}"}
+              Dir.chdir(path) do
+                response = git(:status)
+                return true if response =~ /# On branch /
+              end
+            rescue Errno::ENOENT
+              # NOP, we assume this is simply because the folder hasn't been created yet
+              path = path.parent
+              retry unless path.to_s == "/"
+              return false
+            end
+          rescue Piston::Git::Client::BadCommand
+            # NOP, as we return false below
+          rescue Piston::Git::Client::CommandError
+            # This is certainly not a Git repository
+            false
+          end
+
+          false
+        end
+
+        def client
+          @@client ||= Piston::Git::Client.instance
+        end
+
+        def git(*args)
+          client.git(*args)
+        end
+      end
+
+      def git(*args)
+        self.class.git(*args)
+      end
+
+      def create
+        path.mkpath rescue nil
+      end
+
+      def exist?
+        path.directory?
+      end
+
+      def finalize
+        Dir.chdir(path) { git(:add, ".") }
+      end
+
+      protected
+      def do_update(to, lock)
+        puts "tmpdir: #{to.dir}"
+        puts "exist? #{to.dir.exist?}"
+        puts "file? #{to.dir.file?}"
+        puts "directory? #{to.dir.directory?}"
+        path.children.reject {|item| ['.git', '.piston.yml'].include?(item.basename.to_s)}.each do |item|
+          puts "rm -rf #{item}"
+          FileUtils.rm_rf(item)
+        end
+        to.dir.children.reject {|item| item.basename.to_s == '.git'}.each do |item|
+          puts "cp -r #{item} #{path}"
+          FileUtils.cp_r(item, path)
+        end
+        Dir.chdir(path) do
+          repository = to.repository
+          remember(
+            {:repository_url => repository.url, :lock => lock, :repository_class => repository.class.name},
+            to.remember_values
+          )
+          git(:add, ".")
+        end
+      end
+    end
+  end
+end