pivotal-piston 1.9.4

data/lib/piston/repository.rb

@@ -0,0 +1,57 @@
+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
+      "Piston::Repository(#{@url})"
+    end
+    
+    def ==(other)
+      url == other.url
+    end
+  end
+end

data/lib/piston/revision.rb

@@ -0,0 +1,53 @@
+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
+      "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
+
+    # 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)
+    end
+  end
+end

data/lib/piston/svn.rb

@@ -0,0 +1,14 @@
+require "piston/svn/client"
+require "piston/svn/repository"
+require "piston/svn/revision"
+require "piston/svn/working_copy"
+
+module Piston
+  module Svn
+    ROOT        = "piston:root"
+    UUID        = "piston:uuid"
+    REMOTE_REV  = "piston:remote-revision"
+    LOCAL_REV   = "piston:local-revision"
+    LOCKED      = "piston:locked"
+  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 =~ /\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,74 @@
+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 Failed, "Did not get the revision I wanted to checkout.  Subversion checked out #{$1}, I wanted #{revision}"
+          end
+        else
+          raise Failed, "Could not checkout revision #{revision} from #{repository.url} to #{dir}\n#{answer}"
+        end
+      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).each do |relpath|
+          next if relpath =~ %r{/$}
+          yield relpath.chomp
+        end
+      end
+
+      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
+
+      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
+    end
+  end
+end

data/lib/piston/svn/working_copy.rb

@@ -0,0 +1,108 @@
+require "yaml"
+
+module Piston
+  module Svn
+    class WorkingCopy < Piston::WorkingCopy
+      # Register ourselves as a handler for working copies
+      Piston::WorkingCopy.add_handler self
+
+      class << self
+        def understands_dir?(dir)
+          result = svn(:info, dir) rescue :failed
+          result == :failed ? false : true
+        end
+
+        def client
+          @@client ||= Piston::Svn::Client.instance
+        end
+
+        def svn(*args)
+          client.svn(*args)
+        end
+      end
+
+      def svn(*args)
+        self.class.svn(*args)
+      end
+
+      def exist?
+        result = svn(:info, path) rescue :failed
+        logger.debug {"result: #{result.inspect}"}
+        return false if result == :failed
+        return false if result.nil? || result.chomp.strip.empty?
+        return true if YAML.load(result).has_key?("Path")
+      end
+
+      def create
+        svn(:mkdir, path)
+      end
+
+      def after_remember(path)
+        begin
+          info = svn(:info, path)
+        rescue Piston::Svn::Client::CommandError
+        ensure
+          return unless info =~ /\(not a versioned resource\)/i || info =~ /\(is not under version control\)/i || info.blank?
+          svn(:add, path)
+        end
+      end
+
+      def finalize
+        targets = []
+        Dir[path + "*"].each do |item|
+          svn(:add, item)
+        end
+      end
+
+      # Returns all defined externals (recursively) of this WC.
+      # Returns a Hash:
+      #   {"vendor/rails" => {:revision => :head, :url => "http://dev.rubyonrails.org/svn/rails/trunk"},
+      #    "vendor/plugins/will_paginate" => {:revision => 1234, :url => "http://will_paginate.org/svn/trunk"}}
+      def externals
+        externals = svn(:proplist, "--recursive", "--verbose")
+        return Hash.new if externals.blank?
+        returning(Hash.new) do |result|
+          YAML.load(externals).each_pair do |dir, props|
+            next if props["svn:externals"].blank?
+            next unless dir =~ /Properties on '([^']+)'/
+            basedir = self.path + $1
+            exts = props["svn:externals"]
+            exts.split("\n").each do |external|
+              data = external.match(/^([^\s]+)\s+(?:(?:-r|--revision)\s*(\d+)\s+)?(.+)$/)
+              case data.length
+              when 4
+                subdir, rev, url = data[1], data[2].nil? ? :head : data[2].to_i, data[3]
+              else
+                raise SyntaxError, "Could not parse svn:externals on #{basedir}: #{external}"
+              end
+
+              result[basedir + subdir] = {:revision => rev, :url => url}
+            end
+          end
+        end
+      end
+
+      def merge_changes(to)
+        data = svn(:info, yaml_path)
+        info = YAML.load(data)
+        initial_revision = info["Last Changed Rev"].to_i
+        logger.debug {"Going to merge #{initial_revision} to #{to.revision}"}
+        svn(:merge, "--revision", "#{initial_revision}:#{to.revision}", path, path)
+        logger.debug {"after merge"}
+      end
+
+      def remove_external_references(*targets)
+        svn(:propdel, "svn:externals", *targets)
+      end
+      
+      protected
+      def do_update(to, lock)
+        logger.info "Copying new changes in place"
+        copy_from(to)
+        logger.info "Merging local changes into working copy"
+        merge_changes(to)
+        remember(recall.merge(:lock => lock), to.remember_values)
+      end
+    end
+  end
+end