piston 1.4.0 → 2.0.1

data/lib/piston/svn/working_copy.rb

@@ -0,0 +1,184 @@
+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 + "*").to_s].each do |item|
+          svn(:add, item)
+        end
+      end
+
+      def add(added)
+        added.each do |item|
+          target = path + item
+          target.mkdir unless target.exist?
+          svn(:add, target)
+        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/svn.rb

@@ -0,0 +1,15 @@
+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"
+    EXCLUDE     = [".svn"]
+  end
+end

data/lib/piston/version.rb

@@ -1,11 +1,13 @@
-require "piston"
-
-module Piston
+module Piston #:nodoc:
   module VERSION #:nodoc:
-    MAJOR = 1
-    MINOR = 4
-    TINY  = 0
+    def self.config
+      @@version ||= YAML.load_file(File.dirname(__FILE__) + "/../../VERSION.yml")
+    end
+
+    def self.read_version
+      "%s.%s.%s" % [config[:major], config[:minor], config[:patch]]
+    end
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING = read_version
   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

data/lib/piston.rb

@@ -1,70 +1,19 @@
-# Copyright (c) 2006 Francois Beausoleil <francois@teksol.info>
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+require "subclass_responsibility_error"
 
-# $HeadURL: svn+ssh://rubyforge.org/var/svn/piston/tags/1.4.0/lib/piston.rb $
-# $Id: piston.rb 139 2008-02-07 15:28:24Z fbos $
+require "piston/repository"
+require "piston/revision"
+require "piston/working_copy"
 
-require 'yaml'
-require 'uri'
-require 'fileutils'
+require "piston/git"
+require "piston/svn"
+require "piston/commands"
 
-PISTON_ROOT = File.dirname(__FILE__)
-Dir[File.join(PISTON_ROOT, 'core_ext', '*.rb')].each do |file|
-  require file
-end
-
-require "piston/version"
-require "piston/command"
-require "piston/command_error"
-
-require "transat/parser"
-Dir[File.join(PISTON_ROOT, "piston", "commands", "*.rb")].each do |file|
-  require file.gsub(PISTON_ROOT, "")[1..-4]
-end
+require "pathname"
 
 module Piston
-  ROOT        = "piston:root"
-  UUID        = "piston:uuid"
-  REMOTE_REV  = "piston:remote-revision"
-  LOCAL_REV   = "piston:local-revision"
-  LOCKED      = "piston:locked"
-end
-
-PistonCommandLineProcessor = Transat::Parser.new do
-  program_name "Piston"
-  version [Piston::VERSION::STRING]
-
-  option :verbose, :short => :v, :default => true, :message => "Show subversion commands and results as they are executed"
-  option :quiet, :short => :q, :default => false, :message => "Do not output any messages except errors"
-  option :revision, :short => :r, :param_name => "REVISION", :type => :int
-  option :show_updates, :short => :u, :message => "Query the remote repository for out of dateness information"
-  option :lock, :short => :l, :message => "Close down and lock the imported directory from further changes"
-  option :dry_run, :message => "Does not actually execute any commands"
-  option :force, :message => "Force the command to run, even if Piston thinks it would cause a problem"
-
-  command :switch, Piston::Commands::Switch, :valid_options => %w(lock dry_run force revision quiet verbose)
-  command :update, Piston::Commands::Update, :valid_options => %w(lock dry_run force revision quiet verbose)
-  command :diff,   Piston::Commands::Diff,   :valid_options => %w(lock dry_run force revision quiet verbose)
-  command :import, Piston::Commands::Import, :valid_options => %w(lock dry_run force revision quiet verbose)
-  command :convert, Piston::Commands::Convert, :valid_options => %w(lock verbose dry_run)
-  command :unlock, Piston::Commands::Unlock, :valid_options => %w(force dry_run verbose)
-  command :lock, Piston::Commands::Lock, :valid_options => %w(force dry_run revision verbose)
-  command :status, Piston::Commands::Status, :valid_options => %w(show_updates verbose)
+  class << self
+    def version_message
+      "Piston %s\nCopyright 2006-2008, Francois Beausoleil <francois@teksol.info>\nhttp://piston.rubyforge.org/\nDistributed under an MIT-like license." % Piston::VERSION::STRING
+    end
+  end
 end

data/lib/subclass_responsibility_error.rb

@@ -0,0 +1,2 @@
+class SubclassResponsibilityError < RuntimeError
+end

data/test/integration_helpers.rb

@@ -0,0 +1,36 @@
+require "pathname"
+PISTON_ROOT = Pathname.new(File.dirname(__FILE__)).parent.realpath
+
+def logger
+  @logger ||= Log4r::Logger["test"]
+end
+
+def runcmd(cmd, *args)
+  cmdline = [cmd]
+  cmdline += args
+  cmdline = cmdline.flatten.map {|s| s.to_s}.join(" ")
+  logger.debug "> #{cmdline}"
+
+  output = `#{cmdline}`
+  logger.debug "< #{output}"
+  return output if $?.success?
+  raise CommandFailed, "Could not run %s, exit status: <%d>\n===\n%s\n===" % [cmdline.inspect, $?.exitstatus, output]
+end
+
+def svn(*args)
+  runcmd(:svn, *args)
+end
+
+def svnadmin(*args)
+  runcmd(:svnadmin, *args)
+end
+
+def git(*args)
+  runcmd(:git, *args)
+end
+
+def piston(*args)
+  runcmd(:ruby, "-I", PISTON_ROOT + "lib", PISTON_ROOT + "bin/piston", *args)
+end
+
+class CommandFailed < RuntimeError; end

data/test/spec_suite.rb

@@ -0,0 +1,4 @@
+dir = File.dirname(__FILE__)
+Dir["#{dir}/**/test_*.rb"].each do |file|
+  require file
+end