jeremylightsmith-piston 1.9.3

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,48 @@
+module Piston
+  class Revision
+    include Enumerable
+
+    class << self
+      def logger
+        @@logger ||= Log4r::Logger["handler"]
+      end
+    end
+
+    attr_reader :repository, :revision, :recalled_values
+
+    def initialize(repository, revision, recalled_values={})
+      @repository, @revision, @recalled_values = repository, revision, recalled_values
+    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}"}
+    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(path)
+        @wcpath = path.kind_of?(Pathname) ? path : Pathname.new(path)
+        answer = svn(:checkout, "--revision", revision, repository.url, path)
+        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 #{path}\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 @wcpath
+
+        svn(:ls, "--recursive", @wcpath).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 @wcpath
+
+        Pathname.new(abspath).dirname.mkpath
+        FileUtils.cp(@wcpath + 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,55 @@
+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)
+        info = svn(:info, path)
+        return unless info =~ /\(not a versioned resource\)/i || info.empty?
+        svn(:add, path)
+      end
+
+      def finalize
+        targets = []
+        Dir[path + "*"].each do |item|
+          svn(:add, item)
+        end
+      end
+      
+    end
+  end
+end

data/lib/piston/version.rb

@@ -0,0 +1,9 @@
+module Piston #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 1
+    MINOR = 9
+    TINY  = 3
+
+    STRING = [MAJOR, MINOR, TINY].join(".")
+  end
+end

data/lib/piston/working_copy.rb

@@ -0,0 +1,129 @@
+module Piston
+  class WorkingCopy
+    class UnhandledWorkingCopy < RuntimeError; end
+    class NotWorkingCopy < RuntimeError; end
+
+    class << self
+      def logger
+        @@logger ||= Log4r::Logger["handler"]
+      end
+
+      def guess(path)
+        path = path.kind_of?(Pathname) ? path : Pathname.new(path.to_s)
+        logger.info {"Guessing the working copy type of #{path.inspect}"}
+        handler = handlers.detect do |handler|
+          logger.debug {"Asking #{handler.name} if it understands #{path}"}
+          handler.understands_dir?(path)
+        end
+
+        raise UnhandledWorkingCopy, "Don't know what working copy type #{path} is." if handler.nil?
+        handler.new(path)
+      end
+
+      @@handlers = Array.new
+      def add_handler(handler)
+        @@handlers << handler
+      end
+
+      def handlers
+        @@handlers
+      end
+      private :handlers
+    end
+
+    attr_reader :path
+
+    def initialize(path)
+      @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      logger.debug {"Initialized on #{@path}"}
+    end
+
+    def logger
+      self.class.logger
+    end
+
+    def to_s
+      "Piston::WorkingCopy(#{@path})"
+    end
+
+    def exist?
+      @path.exist? && @path.directory?
+    end
+    
+    def pistonized?
+      yaml_path.exist? && yaml_path.file?
+    end
+
+    def validate!
+      raise NotWorkingCopy unless self.pistonized?
+      self
+    end
+
+    # Creates the initial working copy for pistonizing a new repository.
+    def create
+      logger.debug {"Creating working copy at #{path}"}
+    end
+
+    # Copy files from +revision+.  +revision+ must
+    # #respond_to?(:each), and return each file that is to be copied.
+    # Only files must be returned.
+    #
+    # Each item yielded by Revision#each must be a relative path.
+    #
+    # WorkingCopy will call Revision#copy_to with the full path to where the
+    # file needs to be copied.
+    def copy_from(revision)
+      revision.each do |relpath|
+        target = path + relpath
+        target.dirname.mkdir rescue nil
+
+        logger.debug {"Copying #{relpath} to #{target}"}
+        revision.copy_to(relpath, target)
+      end
+    end
+
+    # Stores a Hash of values that can be retrieved later.
+    def remember(values, handler_values)
+      values["format"] = 1
+
+      # Stringify keys
+      values.keys.each do |key|
+        values[key.to_s] = values.delete(key)
+      end
+
+      logger.debug {"Remembering #{values.inspect} as well as #{handler_values.inspect}"}
+      File.open(yaml_path, "wb") do |f|
+        f.write(values.merge("handler" => handler_values).to_yaml)
+      end
+
+      logger.debug {"Calling \#after_remember on #{yaml_path}"}
+      after_remember(yaml_path)
+    end
+
+    # Callback after #remember is done, to do whatever the
+    # working copy needs to do with the file.
+    def after_remember(path)
+    end
+
+    # Recalls a Hash of values from the working copy.
+    def recall
+      YAML.load(File.read(yaml_path))
+    end
+
+    def finalize
+      logger.debug {"Finalizing #{path}"}
+    end
+    
+    # Returns basic information about this working copy.
+    def info
+      recall
+    end
+    
+
+    protected
+    # The path to the piston YAML file.
+    def yaml_path
+      path + ".piston.yml"
+    end
+  end
+end