francois-piston 2.0.0

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).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

data/lib/piston/svn/working_copy.rb

@@ -0,0 +1,182 @@
+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
+
+        def old_repositories(*directories)
+          repositories = []
+          unless directories.empty?
+            folders = svn(:propget, '--recursive', Piston::Svn::ROOT, *directories)
+            folders.each_line do |line|
+              next unless line =~ /^(.+) - \S+/
+              logger.debug {"Found repository #{$1}"}
+              repositories << $1
+            end
+          end
+          repositories
+        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
+        logger.debug {"Creating #{path}"}
+        begin
+          svn(:mkdir, path)
+        rescue Piston::Svn::Client::CommandError
+          logger.error do
+            "Folder #{path} could not be created.  Is #{path.parent} a working copy? (Tip: svn mkdir it)"
+          end
+          raise
+        end
+      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
+
+      def add(added)
+        added.each do |item|
+          svn(:add, path + item)
+        end
+      end
+
+      def delete(deleted)
+        deleted.each do |item|
+          svn(:rm, path + item)
+        end
+      end
+
+      def rename(renamed)
+        renamed.each do |from, to|
+          svn(:mv, path + from, path + to)
+        end
+      end
+
+      def downgrade_to(revision)
+        logger.debug {"Downgrading to revision when last update was made"}
+        svn(:update, '--revision', revision, path)
+      end
+
+      def merge_local_changes(revision)
+        logger.debug {"Update to #{revision} in order to merge local changes"}
+        svn(:update, "--non-interactive", path)
+      end
+
+      def status(subpath=nil)
+        svn(:status, path + subpath.to_s).split("\n").inject([]) do |memo, line|
+          next memo unless line =~ /^\w.+\s(.*)$/
+          memo << [$1, $2]
+        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 remove_external_references(*targets)
+        svn(:propdel, "svn:externals", *targets)
+      end
+
+      def locally_modified
+        logger.debug {"Get last changed revision for #{yaml_path}"}
+        # get latest revision 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
+        log = svn(:log, '--revision', "#{initial_revision}:HEAD", '--quiet', '--limit', '2', path)
+        log.count("\n") > 3
+      end
+
+      def exclude_for_diff
+        Piston::Svn::EXCLUDE
+      end
+
+      def upgrade
+        props = Hash.new
+        svn(:proplist, '--verbose', path).each_line do |line|
+          if line =~ /(piston:[-\w]+)\s*:\s*(.*)$/
+            props[$1] = $2
+            svn(:propdel, $1, path)
+          end
+        end
+        remember({:repository_url => props[Piston::Svn::ROOT], :lock => props[Piston::Svn::LOCKED] || false, :repository_class => Piston::Svn::Repository.name}, {Piston::Svn::REMOTE_REV => props[Piston::Svn::REMOTE_REV], Piston::Svn::UUID => props[Piston::Svn::UUID]})
+      end
+
+      protected
+      def current_revision
+        data = svn(:info, path)
+        YAML.load(data)["Revision"].to_i
+      end
+
+      def last_changed_revision(path)
+        data = svn(:info, yaml_path)
+        YAML.load(data)["Last Changed Rev"].to_i
+      end
+    end
+  end
+end

data/lib/piston/version.rb

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

data/lib/piston/working_copy.rb

@@ -0,0 +1,334 @@
+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)
+        try_path = path.exist? ? path : path.parent
+        logger.info {"Guessing the working copy type of #{try_path.inspect}"}
+        handler = handlers.detect do |handler|
+          logger.debug {"Asking #{handler.name} if it understands #{try_path}"}
+          handler.understands_dir?(try_path)
+        end
+
+        raise UnhandledWorkingCopy, "Don't know what working copy type #{path} is." if handler.nil?
+        handler.new(File.expand_path(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)
+      if path.kind_of?(Pathname)
+        raise ArgumentError, "#{path} must be absolute" unless path.absolute?
+        @path = path
+      else
+        @path = Pathname.new(File.expand_path(path))
+      end
+      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
+
+    def repository
+      values = self.recall
+      repository_class = values["repository_class"]
+      repository_url = values["repository_url"]
+      repository_class.constantize.new(repository_url)
+    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
+
+    # Copy files to +revision+ to keep local changes.  +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_from with the full path from where the
+    # file needs to be copied.
+    def copy_to(revision)
+      revision.each do |relpath|
+        source = path + relpath
+
+        logger.debug {"Copying #{source} to #{relpath}"}
+        revision.copy_from(source, relpath)
+      end
+    end
+
+    # add some files to working copy
+    def add(added)
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#add should be implemented by a subclass."
+    end
+
+    # delete some files from working copy
+    def delete(deleted)
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#delete should be implemented by a subclass."
+    end
+
+    # rename some files in working copy
+    def rename(renamed)
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#rename should be implemented by a subclass."
+    end
+
+    # Downgrade this working copy to +revision+.
+    def downgrade_to(revision)
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#downgrade_to should be implemented by a subclass."
+    end
+
+    # Merge remote changes with local changes in +revision+.
+    def merge_local_changes(revision)
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#merge_local_changes should be implemented by a subclass."
+    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, "w+") 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(yaml_path)
+    end
+
+    def finalize
+      logger.debug {"Finalizing #{path}"}
+    end
+
+    # Returns basic information about this working copy.
+    def info
+      recall
+    end
+
+    def import(revision, lock)
+      lock ||= false
+      repository = revision.repository
+      tmpdir = temp_dir_name
+      begin
+        logger.info {"Checking out the repository"}
+        revision.checkout_to(tmpdir)
+
+        logger.debug {"Creating the local working copy"}
+        create
+
+        logger.info {"Copying from #{revision}"}
+        copy_from(revision)
+
+        logger.debug {"Remembering values"}
+        remember(
+          {:repository_url => repository.url, :lock => lock, :repository_class => repository.class.name},
+          revision.remember_values
+        )
+
+        logger.debug {"Finalizing working copy"}
+        finalize
+
+        logger.info {"Checked out #{repository.url.inspect} #{revision.name} to #{path.to_s}"}
+      ensure
+        logger.debug {"Removing temporary directory: #{tmpdir}"}
+        tmpdir.rmtree rescue nil
+      end
+    end
+
+    # Update this working copy from +from+ to +to+, which means merging local changes back in
+    # Return true if changed, false if not
+    def update(revision, to, lock)
+      lock ||= false
+      tmpdir = temp_dir_name
+      begin
+        logger.info {"Checking out the repository at #{revision.revision}"}
+        revision.checkout_to(tmpdir)
+
+        revision_to_return = current_revision
+        revision_to_downgrade = last_changed_revision(yaml_path)
+        logger.debug {"Downgrading to #{revision_to_downgrade}"}
+        downgrade_to(revision_to_downgrade)
+
+        logger.debug {"Copying old changes to temporary directory in order to keep them"}
+        copy_to(revision)
+
+        logger.info {"Looking changes from #{revision.revision} to #{to.revision}"}
+        added, deleted, renamed = revision.update_to(to.revision)
+
+        logger.info {"Updating working copy"}
+
+        # rename before copy because copy_from will copy these files
+        logger.debug {"Renaming files"}
+        rename(renamed)
+
+        logger.debug {"Copying files from temporary directory"}
+        copy_from(revision)
+
+        logger.debug {"Adding new files to version control"}
+        add(added)
+
+        logger.debug {"Deleting files from version control"}
+        delete(deleted)
+
+        # merge local changes updating to revision before downgrade was made
+        logger.debug {"Merging local changes"}
+        merge_local_changes(revision_to_return)
+
+        remember(recall.merge(:lock => lock), to.remember_values)
+
+        status = status(path)
+        logger.debug { {:added => added, :deleted => deleted, :renamed => renamed, :status => status}.to_yaml }
+        !status.empty?
+      ensure
+        logger.debug {"Removing temporary directory: #{tmpdir}"}
+        tmpdir.rmtree rescue nil
+      end
+    end
+
+    def diff
+      tmpdir = temp_dir_name
+      begin
+        logger.info {"Checking out the repository at #{revision.revision}"}
+        revision = repository.at(:head)
+        revision.checkout_to(tmpdir)
+
+        excludes = (['.piston.yml'] + exclude_for_diff + revision.exclude_for_diff).uniq.collect {|pattern| "--exclude=#{pattern}"}.join ' '
+        system("diff -urN #{excludes} '#{tmpdir}' '#{path}'")
+      ensure
+        logger.debug {"Removing temporary directory: #{tmpdir}"}
+        tmpdir.rmtree rescue nil
+      end
+    end
+
+    def diff
+      tmpdir = temp_dir_name
+      begin
+        logger.info {"Checking out the repository at #{revision.revision}"}
+        revision = repository.at(:head)
+        revision.checkout_to(tmpdir)
+
+        excludes = (['.piston.yml'] + exclude_for_diff + revision.exclude_for_diff).uniq.collect {|pattern| "--exclude=#{pattern}"}.join ' '
+        system("diff -urN #{excludes} '#{tmpdir}' '#{path}'")
+      ensure
+        logger.debug {"Removing temporary directory: #{tmpdir}"}
+        tmpdir.rmtree rescue nil
+      end
+    end
+
+    def diff
+      tmpdir = temp_dir_name
+      begin
+        logger.info {"Checking out the repository at #{revision.revision}"}
+        revision = repository.at(:head)
+        revision.checkout_to(tmpdir)
+
+        excludes = (['.piston.yml'] + exclude_for_diff + revision.exclude_for_diff).uniq.collect {|pattern| "--exclude=#{pattern}"}.join ' '
+        system("diff -urN #{excludes} '#{tmpdir}' '#{path}'")
+      ensure
+        logger.debug {"Removing temporary directory: #{tmpdir}"}
+        tmpdir.rmtree rescue nil
+      end
+    end
+
+    def temp_dir_name
+      path.parent + ".#{path.basename}.tmp"
+    end
+
+    def locally_modified
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#locally_modified should be implemented by a subclass."
+    end
+
+    def remotely_modified
+      repository.at(recall["handler"]).remotely_modified
+    end
+
+    def exclude_for_diff
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#exclude_for_diff should be implemented by a subclass."
+    end
+
+    protected
+    # The path to the piston YAML file.
+    def yaml_path
+      path + ".piston.yml"
+    end
+
+    # The current revision of this working copy.
+    def current_revision
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#current_revision should be implemented by a subclass."
+    end
+
+    # The last revision which +path+ was changed in
+    def last_changed_revision(path)
+      raise SubclassResponsibilityError, "Piston::WorkingCopy#last_changed_revision should be implemented by a subclass."
+    end
+  end
+end