piston 1.4.0 → 2.0.1

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], 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,145 @@
+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 after_remember(path)
+        Dir.chdir(self.path) { git(:add, path.relative_path_from(self.path)) }
+      end
+
+      def finalize
+        Dir.chdir(path) { git(:add, ".") }
+      end
+
+      def add(added)
+        Dir.chdir(path) do
+          added.each do |item|
+            item.mkdir unless item.exist?
+            git(:add, item)
+          end
+        end
+      end
+
+      def delete(deleted)
+        Dir.chdir(path) do
+          deleted.each { |item| git(:rm, item) }
+        end
+      end
+
+      def rename(renamed)
+        Dir.chdir(path) do
+          renamed.each { |from, to| git(:mv, from, to) }
+        end
+      end
+
+      def downgrade_to(revision)
+        logger.debug {"Creating a branch to copy changes from remote repository"}
+        Dir.chdir(path) { git(:checkout, '-b', "my-#{revision}", revision) }
+      end
+      
+      def merge_local_changes(revision)
+        from_revision = current_revision
+        Dir.chdir(path) do
+          begin
+            logger.debug {"Saving changes in temporary branch"}
+            git(:commit, '-a', '-m', 'merging')
+            logger.debug {"Return to previous branch"}
+            git(:checkout, revision)
+            logger.debug {"Merge changes from temporary branch"}
+            git(:merge, '--squash', from_revision)
+          rescue Piston::Git::Client::CommandError
+            git(:checkout, revision)
+          ensure
+            logger.debug {"Deleting temporary branch"}
+            git(:branch, '-D', from_revision)
+          end
+        end
+      end
+
+      def locally_modified
+        logger.debug {"Get last changed revision for #{yaml_path}"}
+        # get latest commit for .piston.yml
+        initial_revision = last_changed_revision(yaml_path)
+        logger.debug {"Get last log line for #{path} after #{initial_revision}"}
+        # get latest revisions for this working copy since last update
+        Dir.chdir(path) { not git(:log, '-n', '1', "#{initial_revision}..", '.').empty? }
+      end
+
+      def exclude_for_diff
+        Piston::Git::EXCLUDE
+      end
+
+      def status(subpath=nil)
+        Dir.chdir(path) do
+          git(:status).split("\n").inject([]) do |memo, line|
+            next memo unless line =~ /\s(\w+):\s+(.*)$/
+            memo << [$1, $2]
+          end
+        end
+      end
+
+      protected
+      def current_revision
+        Dir.chdir(path) { git(:branch).match(/^\*\s+(.+)$/)[1] }
+      end
+
+      def last_changed_revision(path)
+        path = Pathname.new(path) unless path.is_a? Pathname
+        path = path.relative_path_from(self.path) unless path.relative?
+        logger.debug {"Get last log line for #{path}"}
+        Dir.chdir(self.path) { git(:log, '-n', '1', path).match(/commit\s+(.*)$/)[1] }
+      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/repository.rb

@@ -0,0 +1,61 @@
+require "piston/revision"
+
+module Piston
+  class Repository
+    class UnhandledUrl < RuntimeError; end
+
+    class << self
+      def logger
+        @@logger ||= Log4r::Logger["handler"]
+      end
+
+      def guess(url)
+        logger.info {"Guessing the repository type of #{url.inspect}"}
+        
+        handler = handlers.detect do |handler|
+          logger.debug {"Asking #{handler}"}
+          handler.understands_url?(url)
+        end
+        
+        raise UnhandledUrl unless handler
+        
+        handler.new(url)
+      end
+
+      @@handlers = Array.new
+      def add_handler(handler)
+        @@handlers << handler
+      end
+
+      def handlers
+        @@handlers
+      end
+    end
+
+    attr_reader :url
+
+    def initialize(url)
+      @url = url
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def at(revision)
+      raise SubclassResponsibilityError, "Piston::Repository#at should be implemented by a subclass."
+    end
+
+    def to_s
+      @url
+    end
+
+    def inspect
+      "Piston::Repository(#{@url})"
+    end
+    
+    def ==(other)
+      url == other.url
+    end
+  end
+end

data/lib/piston/revision.rb

@@ -0,0 +1,83 @@
+module Piston
+  class Revision
+    include Enumerable
+
+    class << self
+      def logger
+        @@logger ||= Log4r::Logger["handler"]
+      end
+    end
+
+    attr_reader :repository, :revision, :recalled_values, :dir
+
+    def initialize(repository, revision, recalled_values={})
+      @repository, @revision, @recalled_values = repository, revision, recalled_values
+    end
+    
+    def url
+      repository.url
+    end
+    
+    def name
+      @revision
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def to_s
+      "revision #{@revision}"
+    end
+
+    def inspect
+      "Piston::Revision(#{@repository.url}@#{@revision})"
+    end
+
+    # Retrieve a copy of this repository into +dir+.
+    def checkout_to(dir)
+      logger.debug {"Checking out #{@repository}@#{@revision} into #{dir}"}
+      @dir = dir.kind_of?(Pathname) ? dir : Pathname.new(dir)
+    end
+
+    # Update a copy of this repository to revision +to+.
+    def update_to(to, lock)
+      raise SubclassResponsibilityError, "Piston::Revision#update_to should be implemented by a subclass."
+    end
+
+    # What values does this revision want to remember for the future ?
+    def remember_values
+      logger.debug {"Generating remember values"}
+      {}
+    end
+
+    # Yields each file of this revision in turn to our caller.
+    def each
+    end
+
+    # Copies +relpath+ (relative to ourselves) to +abspath+ (an absolute path).
+    def copy_to(relpath, abspath)
+      raise ArgumentError, "Revision #{revision} of #{repository.url} was never checked out -- can't iterate over files" unless @dir
+
+      Pathname.new(abspath).dirname.mkpath
+      FileUtils.cp(@dir + relpath, abspath)
+    end
+
+    # Copies +abspath+ (an absolute path) to +relpath+ (relative to ourselves).
+    def copy_from(abspath, relpath)
+      raise ArgumentError, "Revision #{revision} of #{repository.url} was never checked out -- can't iterate over files" unless @dir
+
+      target = @dir + relpath
+      Pathname.new(target).dirname.mkpath
+      FileUtils.cp(abspath, target)
+    end
+
+    def remotely_modified
+      raise SubclassResponsibilityError, "Piston::Revision#remotely_modified should be implemented by a subclass."
+    end
+
+    def exclude_for_diff
+      raise SubclassResponsibilityError, "Piston::Revision#exclude_for_diff should be implemented by a subclass."
+    end
+  end
+end

data/lib/piston/svn/client.rb

@@ -0,0 +1,88 @@
+require "singleton"
+
+module Piston
+  module Svn
+    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 svnadmin(*args)
+        run_cmd :svnadmin, *args
+      end
+
+      def svn(*args)
+        run_cmd :svn, *args
+      end
+
+      def svnlook(*args)
+        run_cmd :svnlook, *args
+      end
+
+      def svnversion(*args)
+        run_cmd :svnversion, *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?
+            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/svn/repository.rb

@@ -0,0 +1,67 @@
+require "uri"
+
+module Piston
+  module Svn
+    class Repository < Piston::Repository
+      # Register ourselves as a repository handler
+      Piston::Repository.add_handler self
+
+      class << self
+        def understands_url?(url)
+          uri = URI.parse(url)
+          case uri.scheme
+          when "svn", /^svn\+/
+            true
+          when "http", "https", "file"
+            # Have to contact server to know
+            result = svn(:info, url) rescue :failed
+            result == :failed ? false : true
+          else
+            # Don't know how to handle this scheme.
+            # Let someone else handle it
+          end
+        end
+
+        def client
+          @@client ||= Piston::Svn::Client.instance
+        end
+
+        def svn(*args)
+          client.svn(*args)
+        end
+        
+        def repository_type
+          'svn'
+        end
+      end
+
+      def svn(*args)
+        self.class.svn(*args)
+      end
+
+      def at(revision)
+        if revision.respond_to?(:keys) then
+          rev = revision[Piston::Svn::REMOTE_REV]
+          Piston::Svn::Revision.new(self, rev, revision)
+        else
+          case
+          when revision == :head
+            Piston::Svn::Revision.new(self, "HEAD")
+          when revision.to_i != 0
+            Piston::Svn::Revision.new(self, revision.to_i)
+          else
+            raise ArgumentError, "Invalid revision argument: #{revision.inspect}"
+          end
+        end
+      end
+
+      def basename
+        if self.url =~ /trunk|branches|tags/ then
+          self.url.sub(%r{/(?:trunk|branches|tags).*$}, "").split("/").last
+        else
+          self.url.split("/").last
+        end
+      end
+    end
+  end
+end

data/lib/piston/svn/revision.rb

@@ -0,0 +1,112 @@
+require "piston/revision"
+require "fileutils"
+
+module Piston
+  module Svn
+    class Revision < Piston::Revision
+      class InvalidRevision < RuntimeError; end
+      class RepositoryMoved < InvalidRevision; end
+      class UuidChanged < InvalidRevision; end
+
+      def client
+        @client ||= Piston::Svn::Client.instance
+      end
+
+      def svn(*args)
+        client.svn(*args)
+      end
+
+      def name
+        "r#{revision}"
+      end
+
+      def checkout_to(dir)
+        super
+        answer = svn(:checkout, "--revision", revision, repository.url, dir)
+        if answer =~ /Checked out revision (\d+)[.]/ then
+          if revision == "HEAD" then
+            @revision = $1.to_i
+          elsif revision != $1.to_i then
+            raise InvalidRevision, "Did not get the revision I wanted to checkout.  Subversion checked out #{$1}, I wanted #{revision}"
+          end
+        else
+          raise InvalidRevision, "Could not checkout revision #{revision} from #{repository.url} to #{dir}\n#{answer}"
+        end
+      end
+
+      def update_to(revision)
+        raise ArgumentError, "Revision #{self.revision} of #{repository.url} was never checked out -- can't update" unless @dir
+        
+        answer = svn(:update, "--non-interactive", "--revision", revision, @dir)
+        if answer =~ /(Updated to|At) revision (\d+)[.]/ then
+          if revision == "HEAD" then
+            @revision = $2.to_i
+          elsif revision != $2.to_i then
+            raise InvalidRevision, "Did not get the revision I wanted to update.  Subversion update to #{$1}, I wanted #{revision}"
+          end
+        else
+          raise InvalidRevision, "Could not update #{@dir} to revision #{revision} from #{repository.url}\n#{answer}"
+        end
+        added = relative_paths(answer.scan(/^A\s+(.*)$/).flatten)
+        deleted = relative_paths(answer.scan(/^D\s+(.*)$/).flatten)
+        renamed = []
+        [added, deleted, renamed]
+      end
+
+      def remember_values
+        str = svn(:info, "--revision", revision, repository.url)
+        raise Failed, "Could not get 'svn info' from #{repository.url} at revision #{revision}" if str.nil? || str.chomp.strip.empty?
+        info = YAML.load(str)
+        { Piston::Svn::UUID => info["Repository UUID"],
+          Piston::Svn::REMOTE_REV => info["Revision"]}
+      end
+
+      def each
+        raise ArgumentError, "Revision #{revision} of #{repository.url} was never checked out -- can't iterate over files" unless @dir
+
+        svn(:ls, "--recursive", @dir).split("\n").each do |relpath|
+          next if relpath =~ %r{/$}
+          yield relpath.chomp
+        end
+      end
+
+      def validate!
+        data = svn(:info, "--revision", revision, repository.url)
+        info = YAML.load(data)
+        actual_uuid = info["Repository UUID"]
+        raise RepositoryMoved, "Repository at #{repository.url} does not exist anymore:\n#{data}" if actual_uuid.blank?
+        raise UuidChanged, "Expected repository at #{repository.url} to have UUID #{recalled_uuid} but found #{actual_uuid}" if recalled_uuid != actual_uuid
+      end
+
+      def recalled_uuid
+        recalled_values[Piston::Svn::UUID]
+      end
+
+      def remotely_modified
+        logger.debug {"Get last revision in #{repository.url}"}
+        data = svn(:info, repository.url)
+        info = YAML.load(data)
+        latest_revision = info["Last Changed Rev"].to_i
+        revision < latest_revision
+      end
+
+      def exclude_for_diff
+        Piston::Svn::EXCLUDE
+      end
+
+      def resolve!
+        logger.debug {"Resolving #{@revision} to it's real value"}
+        return if @revision.to_i == @revision && !@revision.blank?
+        data = YAML.load(svn(:info, repository.url))
+        @revision = data["Last Changed Rev"].to_i
+        logger.debug {"Resolved #{@revision}"}
+        @revision
+      end
+
+      private
+      def relative_paths(paths)
+        paths.map { |item| Pathname.new(item).relative_path_from(@dir) }
+      end
+    end
+  end
+end