rscm 0.4.5 → 0.5.0

data/lib/rscm/command_line.rb

@@ -1,113 +1,136 @@
-require 'rscm/platform'
-
-module RSCM
-  module CommandLine
-    QUOTE_REPLACEMENT = (Platform.family == "mswin32") ? "\"" : "\\\""
-    LESS_THAN_REPLACEMENT = (Platform.family == "mswin32") ? "<" : "\\<"
-    class OptionError < StandardError; end
-    class ExecutionError < StandardError
-      attr_reader :cmd, :dir, :exitstatus, :stderr      
-      def initialize(cmd, dir, exitstatus, stderr); @cmd, @dir, @exitstatus, @stderr = cmd, dir, exitstatus, stderr; end
-      def to_s
-        "\ndir       : #{@dir}\n" +
-        "command   : #{@cmd}\n" +
-        "exitstatus: #{@exitstatus}\n" +
-        "STDERR TAIL START\n#{@stderr}\nSTDERR TAIL END\n"
-      end
-    end
-    
-    # Executes +cmd+.
-    # If the +:stdout+ and +:stderr+ options are specified, a line consisting
-    # of a prompt (including +cmd+) will be appended to the respective output streams will be appended 
-    # to those files, followed by the output itself. Example:
-    #
-    #   CommandLine.execute("echo hello world", {:stdout => "stdout.log", :stderr => "stderr.log"})
-    #
-    # will result in the following being written to stdout.log:
-    #
-    #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
-    #   hello world
-    #
-    # -and to stderr.log:
-    #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
-    #
-    # If a block is passed, the stdout io will be yielded to it (as with IO.popen). In this case the output
-    # will not be written to the stdout file (even if it's specified):
-    #
-    #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
-    #   [output captured and therefore not logged]
-    #
-    # If the exitstatus of the command is different from the value specified by the +:exitstatus+ option
-    # (which defaults to 0) then an ExecutionError is raised, its message containing the last 400 bytes of stderr 
-    # (provided +:stderr+ was specified)
-    #
-    # You can also specify the +:dir+ option, which will cause the command to be executed in that directory
-    # (default is current directory).
-    #
-    # You can also specify a hash of environment variables in +:env+, which will add additional environment variables
-    # to the default environment.
-    # 
-    # Finally, you can specify several commands within one by separating them with '&&' (as you would in a shell).
-    # This will result in several lines to be appended to the log (as if you had executed the commands separately).
-    #
-    # See the unit test for more examples.
-    def execute(cmd, options={}, &proc)
-      raise "Can't have newline in cmd" if cmd =~ /\n/
-      options = {
-        :dir => Dir.pwd,
-        :env => {},
-        :exitstatus => 0
-      }.merge(options)
-      
-      options[:stdout] = File.expand_path(options[:stdout]) if options[:stdout]
-      options[:stderr] = File.expand_path(options[:stderr]) if options[:stderr]
-
-      commands = cmd.split("&&").collect{|c| c.strip}
-      Dir.chdir(options[:dir]) do
-        stdout_opt = options[:stdout] ? ">> #{options[:stdout]}" : ""
-        stderr_opt = options[:stderr] ? "2>> #{options[:stderr]}" : ""
-        capture_info_command = (block_given? && options[:stdout])? "echo [output captured and therefore not logged] >> #{options[:stdout]} && " : ""
-
-        full_cmd = commands.collect do |c|
-          escaped_command = c.gsub(/"/, QUOTE_REPLACEMENT).gsub(/</, LESS_THAN_REPLACEMENT)
-          stdout_prompt_command = options[:stdout] ? "echo #{RSCM::Platform.prompt} #{escaped_command} >> #{options[:stdout]} && " : ""
-          stderr_prompt_command = options[:stderr] ? "echo #{RSCM::Platform.prompt} #{escaped_command} >> #{options[:stderr]} && " : ""
-          redirected_command = block_given? ? "#{c} #{stderr_opt}" : "#{c} #{stdout_opt} #{stderr_opt}"
-
-          stdout_prompt_command + capture_info_command + stderr_prompt_command + redirected_command
-        end.join(" && ")
-
-        options[:env].each{|k,v| ENV[k]=v}
-        begin
-          IO.popen(full_cmd) do |io|
-            if(block_given?)
-              return(proc.call(io))
-            else
-              io.read
-            end
-          end
-        rescue Errno::ENOENT => e
-          File.open(options[:stderr], "a") {|io| io.write(e.message)}
-          raise ExecutionError.new(cmd, options[:dir], nil, e.message)
-        ensure
-          if($?.exitstatus != options[:exitstatus])
-            error_message = "#{options[:stderr]} doesn't exist"
-            if options[:stderr] && File.exist?(options[:stderr])
-              File.open(options[:stderr]) do |errio|
-                begin
-                  errio.seek(-1200, IO::SEEK_END)
-                rescue Errno::EINVAL
-                  # ignore - it just means we didn't have 400 bytes.
-                end
-                error_message = errio.read
-              end
-            end
-            raise ExecutionError.new(cmd, options[:dir], $?.exitstatus, error_message)
-          end
-        end
-      end
-      $?.exitstatus
-    end
-    module_function :execute
-  end
+require 'rscm/platform'
+
+module RSCM
+  module CommandLine
+    QUOTE_REPLACEMENT = (Platform.family == "mswin32") ? "\"" : "\\\""
+    LESS_THAN_REPLACEMENT = (Platform.family == "mswin32") ? "<" : "\\<"
+    class OptionError < StandardError; end
+    class ExecutionError < StandardError
+      attr_reader :cmd, :dir, :exitstatus, :stderr      
+      def initialize(cmd, full_cmd, dir, exitstatus, stderr)
+        @cmd, @full_cmd, @dir, @exitstatus, @stderr = cmd, full_cmd, dir, exitstatus, stderr
+      end
+      def to_s
+        "\ndir : #{@dir}\n" +
+        "command : #{@cmd}\n" +
+        "executed command : #{@full_cmd}\n" +
+        "exitstatus: #{@exitstatus}\n" +
+        "STDERR TAIL START\n#{@stderr}\nSTDERR TAIL END\n"
+      end
+    end
+    
+    # Executes +cmd+.
+    # If the +:stdout+ and +:stderr+ options are specified, a line consisting
+    # of a prompt (including +cmd+) will be appended to the respective output streams will be appended 
+    # to those files, followed by the output itself. Example:
+    #
+    #   CommandLine.execute("echo hello world", {:stdout => "stdout.log", :stderr => "stderr.log"})
+    #
+    # will result in the following being written to stdout.log:
+    #
+    #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
+    #   hello world
+    #
+    # -and to stderr.log:
+    #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
+    #
+    # If a block is passed, the stdout io will be yielded to it (as with IO.popen). In this case the output
+    # will not be written to the stdout file (even if it's specified):
+    #
+    #   /Users/aslakhellesoy/scm/buildpatterns/repos/damagecontrol/trunk aslakhellesoy$ echo hello world
+    #   [output captured and therefore not logged]
+    #
+    # If the exitstatus of the command is different from the value specified by the +:exitstatus+ option
+    # (which defaults to 0) then an ExecutionError is raised, its message containing the last 400 bytes of stderr 
+    # (provided +:stderr+ was specified)
+    #
+    # You can also specify the +:dir+ option, which will cause the command to be executed in that directory
+    # (default is current directory).
+    #
+    # You can also specify a hash of environment variables in +:env+, which will add additional environment variables
+    # to the default environment.
+    # 
+    # Finally, you can specify several commands within one by separating them with '&&' (as you would in a shell).
+    # This will result in several lines to be appended to the log (as if you had executed the commands separately).
+    #
+    # See the unit test for more examples.
+    def execute(cmd, options={}, &proc)
+      raise "Can't have newline in cmd" if cmd =~ /\n/
+      options = {
+        :dir => Dir.pwd,
+        :env => {},
+        :mode => 'r',
+        :exitstatus => 0
+      }.merge(options)
+      
+      options[:stdout] = File.expand_path(options[:stdout]) if options[:stdout]
+      options[:stderr] = File.expand_path(options[:stderr]) if options[:stderr]
+
+      commands = cmd.split("&&").collect{|c| c.strip}
+      if options[:dir].nil?
+        e(cmd, commands, options, &proc)
+      else
+        Dir.chdir(options[:dir]) do
+          e(cmd, commands, options, &proc)
+        end
+      end
+    end
+    module_function :execute
+
+  private
+
+    def e(cmd, commands, options, &proc)
+      stdout_opt = options[:stdout] ? ">> #{options[:stdout]}" : ""
+      stderr_opt = options[:stderr] ? "2>> #{options[:stderr]}" : ""
+      capture_info_command = (block_given? && options[:stdout])? "echo [output captured and therefore not logged] >> #{options[:stdout]} && " : ""
+
+      full_cmd = commands.collect do |c|
+        escaped_command = c.gsub(/"/, QUOTE_REPLACEMENT).gsub(/</, LESS_THAN_REPLACEMENT)
+        stdout_prompt_command = options[:stdout] ? "echo #{RSCM::Platform.prompt} #{escaped_command} >> #{options[:stdout]} && " : ""
+        stderr_prompt_command = options[:stderr] ? "echo #{RSCM::Platform.prompt} #{escaped_command} >> #{options[:stderr]} && " : ""
+        redirected_command = block_given? ? "#{c} #{stderr_opt}" : "#{c} #{stdout_opt} #{stderr_opt}"
+
+        stdout_prompt_command + capture_info_command + stderr_prompt_command + redirected_command
+      end.join(" && ")
+
+      options[:env].each{|k,v| ENV[k]=v}
+      begin
+        STDOUT.puts "#{RSCM::Platform.prompt} #{cmd}" if options[:stdout].nil?
+        IO.popen(full_cmd, options[:mode]) do |io|
+          if(block_given?)
+            return(proc.call(io))
+          else
+            io.each_line do |line|
+              STDOUT.puts line if options[:stdout].nil?
+            end
+          end
+        end
+
+        if($?.exitstatus != options[:exitstatus])
+          error_message = "#{options[:stderr]} doesn't exist"
+          if options[:stderr] && File.exist?(options[:stderr])
+            File.open(options[:stderr]) do |errio|
+              begin
+                errio.seek(-1200, IO::SEEK_END)
+              rescue Errno::EINVAL
+                # ignore - it just means we didn't have 400 bytes.
+              end
+              error_message = errio.read
+            end
+          end
+          raise ExecutionError.new(cmd, full_cmd, options[:dir] || Dir.pwd, $?.exitstatus, error_message)
+        end
+      rescue Errno::ENOENT => e
+        unless options[:stderr].nil?
+          File.open(options[:stderr], "a") {|io| io.write(e.message)}
+        else
+          STDERR.puts e.message
+          STDERR.puts e.backtrace.join("\n")
+        end
+        raise ExecutionError.new(cmd, full_cmd, options[:dir] || Dir.pwd, nil, e.message)
+      end
+    end
+    module_function :e
+
+  end
 end

data/lib/rscm/revision.rb

@@ -1,206 +1,103 @@
 require 'rscm/time_ext'
 require 'rscm/revision_file'
+require 'yaml'
 
 module RSCM
-
-  # A collection of Revision.
-  class Revisions
+  # Represents a collection of RevisionFile that were committed at the 
+  # same time, or "more or less at the same time" for non-atomic 
+  # SCMs (such as CVS and StarTeam). See Revisions for how to emulate
+  # atomicity for non-atomic SCMs.
+  class Revision
     include Enumerable
 
-    attr_accessor :revisions
-
-    def initialize(revisions=[])
-      @revisions = revisions
-    end
+    attr_writer :identifier
+    attr_accessor :developer
+    attr_accessor :message
     
-    # Accepts a visitor that will receive callbacks while
-    # iterating over this instance's internal structure.
-    # The visitor should respond to the following methods:
-    #
-    # * visit_revisions(revisions)
-    # * visit_revision(revision)
-    # * visit_file(file)
-    #
-    def accept(visitor)
-      visitor.visit_revisions(self)
-      self.each{|revision| revision.accept(visitor)}
-    end
-
-    def [](file)
-      @revisions[file]
+    def initialize(identifier=nil, time=nil)
+      @identifier = identifier
+      @time = time
+      @files = []
     end
 
-    def each(&block)
-      @revisions.each(&block)
+    def add(file)
+      raise "Can't add #{file} to this revision" unless accept? file
+      @files << file
+      self.developer = file.developer if file.developer
+      self.message = file.message if file.message
     end
     
-    def reverse
-      r = clone
-      r.revisions = @revisions.dup.reverse
-      r
+    def identifier(min_or_max = :max)
+      @identifier || time(min_or_max)
     end
     
-    def length
-      @revisions.length
+    # The time of this revision. Depending on the value of +min_or_max+,
+    # (should be :min or :max), returns the min or max time of this
+    # revision. (min or max only matters for non-transactional scms)
+    def time(min_or_max = :max)
+      @time || self.collect{|file| file.time}.__send__(min_or_max)
     end
 
-    def ==(other)
-      return false if !other.is_a?(self.class)
-      @revisions == other.revisions
-    end
-    
-    def empty?
-      @revisions.empty?
-    end
-    
-    # The set of developers that contributed to all of the contained Revision s.
-    def developers
-      result = []
-      each do |revision|
-        result << revision.developer unless result.index(revision.developer)
-      end
-      result
-    end
-    
-    def first
-      @revisions.first
-    end
-    
-    def last
-      @revisions.last
+    # Sets the time for this revision. Should only be used by atomic SCMs.
+    # Non-atomic SCMs should <b>not</b> invoke this method, but instead create
+    # revisions by adding RscmFile objects to a Revisions object.
+    def time=(t)
+      raise "time must be a Time object - it was a #{t.class.name} with the string value #{t}" unless t.is_a?(Time)
+      raise "can't set time to an inferiour value than the previous value" if @time && (t < @time)
+      @time = t
     end
     
-    # The latest Revision (with the latest time)
-    # or nil if there are none.
-    def latest
-      result = nil
-      each do |revision|
-        result = revision if result.nil? || result.time < revision.time
-      end
-      result
-    end
+    # Whether +file+ can be added to this instance.
+    def accept?(file) #:nodoc:
+      return true if empty? || @time
 
-    # Adds a File or a Revision.
-    # If the argument is a File and no corresponding Revision exists,
-    # a new Revision is created, added, and the File is added to that Revision -
-    # and then finally the newly created Revision is returned.
-    # Otherwise nil is returned.
-    def add(file_or_revision)
-      if(file_or_revision.is_a?(Revision))
-        @revisions << file_or_revision
-        return file_or_revision
-      else
-        revision = @revisions.find { |a_revision| a_revision.can_contain?(file_or_revision) }
-        if(revision.nil?)
-          revision = Revision.new
-          @revisions << revision
-          revision << file_or_revision
-          return revision
-        end
-        revision << file_or_revision
-        return nil
-      end
-    end
-    
-    def push(*file_or_revisions)
-      file_or_revisions.each { |file_or_revision| self << (file_or_revision) }
-      self
-    end
+      close_enough_to_min = (time(:min) - file.time).abs <= 60
+      close_enough_to_max = (time(:max) - file.time).abs <= 60
+      close_enough = close_enough_to_min or close_enough_to_max
 
-    # Sorts the revisions according to time
-    def sort!
-      @revisions.sort!
-      self
+      close_enough and
+      self.developer == file.developer and
+      self.message == file.message
     end
 
-  end
-
-  # Represents a collection of File that were committed at the same time.
-  # Non-transactional SCMs (such as CVS and StarTeam) emulate Revision
-  # by grouping File s that were committed by the same developer, with the
-  # same commit message, and within a "reasonably" small timespan.
-  class Revision
-    include Enumerable
-
-    attr_reader :files
-    attr_accessor :identifier
-    attr_accessor :developer
-    attr_accessor :message
-    attr_accessor :time
-
-    def initialize(files=[])
-      @files = files
-    end
-    
-    def accept(visitor)
-      visitor.visit_revision(self)
-      @files.each{|file| file.accept(visitor)}
+    def ==(other)
+      self.to_s == other.to_s
     end
 
-    def << (file)
-      @files << file
-      if(self.time.nil? || self.time < file.time unless file.time.nil?)
-        self.time = file.time
-        self.identifier = self.time if(self.identifier.nil? || self.identifier.is_a?(Time))
+    # String representation that can be used for debugging.
+    def to_s
+      if(@to_s.nil?)
+        min = time(:min)
+        max = time(:max)
+        t = (min==max) ? min : "#{min}-#{max}"
+        @to_s = "#{identifier} | #{developer} | #{t} | #{message}\n"
+        self.each do |file|
+          @to_s << " " << file.to_s << "\n"
+        end
+        @to_s
       end
-      self.developer = file.developer if file.developer
-      self.message = file.message if file.message
-    end
-
-    def [] (index)
-      @files[index]
+      @to_s
     end
 
-    # Iterates over all the RevisionFile objects
     def each(&block)
       @files.each(&block)
     end
-    
-    def pop
-      @files.pop
+
+    def [](n)
+      @files[n]
     end
-    
+
     def length
       @files.length
     end
-    alias :size :length
-
-    def time=(t)
-      raise "time must be a Time object - it was a #{t.class.name} with the string value #{t}" unless t.is_a?(Time)
-      raise "can't set time to an inferiour value than the previous value" if @time && (t < @time)
-      @time = t
-    end
-    
-    def ==(other)
-      other.is_a?(self.class) && 
-      @developer == other.developer &&
-      @identifier == other.identifier &&
-      @message == other.message &&
-      @time == other.time &&
-      @files == other.files
-    end
 
-    def <=>(other)
-      @time <=> other.time
+    def pop
+      @files.pop
     end
 
-    # Whether this instance can contain a File. Used
-    # by non-transactional SCMs.
-    def can_contain?(file) #:nodoc:
-      self.developer == file.developer &&
-      self.message == file.message &&
-      (self.time - file.time).abs < 60
+    def empty?
+      @files.empty?
     end
 
-    # String representation that can be used for debugging.
-    def to_s
-      result = "#{identifier} | #{developer} | #{time} | #{message}\n"
-      self.each do |file|
-        result << " " << file.to_s << "\n"
-      end
-      result
-    end
-    
   end
-
 end