cerberus 0.3.5 → 0.3.6

data/lib/cerberus/scm/cvs.rb

@@ -1,48 +1,48 @@
-require 'cerberus/utils'
-
-class Cerberus::SCM::CVS
-  def initialize(path, config = {})
-    raise "Path can't be nil" unless path
-
-    @path, @config = path.strip, config
-    @encoded_path = (@path.include?(' ') ? "\"#{@path}\"" : @path)
-  end
-
-  def installed?
-    exec_successful? "#{@config[:bin_path]}cvs --version"
-  end
-
-  def update!
-    if test(?d, @path + '/CVS')
-      @status = execute("update")
-    else
-      FileUtils.mkpath(@path) unless test(?d,@path)
-      @status = execute("checkout", nil, @config[:scm, :url])
-    end
-  end
-
-  def has_changes?
-    @status =~ /^[U|P|C] (.*)/
-  end
-
-  def current_revision
-    raise NotImplementedError
-  end
-
-  def url
-    raise NotImplementedError
-  end
-
-  def last_commit_message
-    raise NotImplementedError
-  end
-
-  def last_author
-    raise NotImplementedError
-  end
-
-  private
-  def execute(command, parameters = nil, pre_parameters = nil)
-    `#{@config[:bin_path]}cvs #{command} #{pre_parameters} #{@encoded_path} #{parameters}`
-  end
-end
+require 'cerberus/utils'
+
+class Cerberus::SCM::CVS
+  def initialize(path, config = {})
+    raise "Path can't be nil" unless path
+
+    @path, @config = path.strip, config
+    @encoded_path = (@path.include?(' ') ? "\"#{@path}\"" : @path)
+  end
+
+  def installed?
+    exec_successful? "#{@config[:bin_path]}cvs --version"
+  end
+
+  def update!
+    if test(?d, @path + '/CVS')
+      @status = execute("update")
+    else
+      FileUtils.mkpath(@path) unless test(?d,@path)
+      @status = execute("checkout", nil, @config[:scm, :url])
+    end
+  end
+
+  def has_changes?
+    @status =~ /^[U|P|C] (.*)/
+  end
+
+  def current_revision
+    raise NotImplementedError
+  end
+
+  def url
+    raise NotImplementedError
+  end
+
+  def last_commit_message
+    raise NotImplementedError
+  end
+
+  def last_author
+    raise NotImplementedError
+  end
+
+  private
+  def execute(command, parameters = nil, pre_parameters = nil)
+    `#{@config[:bin_path]}cvs #{command} #{pre_parameters} #{@encoded_path} #{parameters}`
+  end
+end

data/lib/cerberus/scm/darcs.rb

@@ -1,70 +1,70 @@
-require 'cerberus/utils'
-
-class Cerberus::SCM::Darcs
-  def initialize(path, config = {})
-    raise "Path can't be nil" unless path
-
-    @path, @config = path.strip, config
-    @encoded_path = (@path.include?(' ') ? "\"#{@path}\"" : @path)
-  end
-
-  def installed?
-    exec_successful? "#{@config[:bin_path]}darcs --version"
-  end
-
-  def update!
-    if test(?d, @path + '/_darcs')
-      @status = execute('pull', '-v -a')
-    else
-      FileUtils.rm_rf(@path) if test(?d,@path)
-      FileUtils.mkpath(File.basename(@path)) unless test(?d,File.basename(@path))
-
-      encoded_url = (@config[:scm, :url].include?(' ') ? "\"#{@config[:scm, :url]}\"" : @config[:scm, :url])
-      @status = execute("get", "--partial #{encoded_url}")
-    end
-
-    extract_last_commit_info
-  end
-
-  def has_changes?
-    return false if @status =~ /No remote changes to pull in!/
-    return true if @status =~ /We have the following new \(to them\) patches:/
-    return true if @status =~ /Copying patch \d+ of \d+\.\.\. done!/
-    return false
-  end
-
-  def current_revision
-    @date
-  end
-
-  def url
-    @path
-  end
-
-  def last_commit_message
-    @message
-  end
-
-  def last_author
-    @author
-  end
-
-  def output
-    @status
-  end
-
-  private
-  def execute(command, parameters = nil, with_path = true)
-    cmd = "#{@config[:bin_path]}darcs #{command} #{parameters} --repodir=#{@encoded_path}"
-    `#{cmd}`
-  end
-
-  def extract_last_commit_info
-    xml_message = execute('changes', "--last 1 --xml-output")
-    require 'rexml/document'
-    xml = REXML::Document.new(xml_message)
-    @author = xml.elements["changelog/patch/@author"].value
-    @date = xml.elements["changelog/patch/@date"].value
-    @message = xml.elements["changelog/patch/name"].get_text.value
-  end
-end
+require 'cerberus/utils'
+
+class Cerberus::SCM::Darcs
+  def initialize(path, config = {})
+    raise "Path can't be nil" unless path
+
+    @path, @config = path.strip, config
+    @encoded_path = (@path.include?(' ') ? "\"#{@path}\"" : @path)
+  end
+
+  def installed?
+    exec_successful? "#{@config[:bin_path]}darcs --version"
+  end
+
+  def update!
+    if test(?d, @path + '/_darcs')
+      @status = execute('pull', '-v -a')
+    else
+      FileUtils.rm_rf(@path) if test(?d,@path)
+      FileUtils.mkpath(File.basename(@path)) unless test(?d,File.basename(@path))
+
+      encoded_url = (@config[:scm, :url].include?(' ') ? "\"#{@config[:scm, :url]}\"" : @config[:scm, :url])
+      @status = execute("get", "--partial #{encoded_url}")
+    end
+
+    extract_last_commit_info
+  end
+
+  def has_changes?
+    return false if @status =~ /No remote changes to pull in!/
+    return true if @status =~ /We have the following new \(to them\) patches:/
+    return true if @status =~ /Copying patch \d+ of \d+\.\.\. done!/
+    return false
+  end
+
+  def current_revision
+    @date
+  end
+
+  def url
+    @path
+  end
+
+  def last_commit_message
+    @message
+  end
+
+  def last_author
+    @author
+  end
+
+  def output
+    @status
+  end
+
+  private
+  def execute(command, parameters = nil, with_path = true)
+    cmd = "#{@config[:bin_path]}darcs #{command} #{parameters} --repodir=#{@encoded_path}"
+    `#{cmd}`
+  end
+
+  def extract_last_commit_info
+    xml_message = execute('changes', "--last 1 --xml-output")
+    require 'rexml/document'
+    xml = REXML::Document.new(xml_message)
+    @author = xml.elements["changelog/patch/@author"].value
+    @date = xml.elements["changelog/patch/@date"].value
+    @message = xml.elements["changelog/patch/name"].get_text.value
+  end
+end

data/lib/cerberus/scm/svn.rb

@@ -1,83 +1,83 @@
-require 'cerberus/utils'
-
-class Cerberus::SCM::SVN
-  def initialize(path, config = {})
-    raise "Path can't be nil" unless path
-
-    @path, @config = path.strip, config
-    @encoded_path = (@path.include?(' ') ? "\"#{@path}\"" : @path)
-  end
-
-  def installed?
-    exec_successful? "#{@config[:bin_path]}svn --version"
-  end
-
-  def update!
-    if test(?d, @path + '/.svn') #check first that it was not locked 
-      execute("cleanup") if locked?
-      say "Could not unlock svn directory #{@encoded_path}. Please do it manually." if locked? #In case if we could not unlock from command line - ask user to do it
-    end
-
-    if test(?d, @path + '/.svn')
-      @status = execute("update")
-    else
-      FileUtils.mkpath(@path) unless test(?d,@path)
-      @status = execute("checkout", nil, @config[:scm, :url])
-    end
-  end
-
-  def has_changes?
-    @status =~ /[A-Z]\s+[\w\/]+/ ? true : false
-  end
-
-  def current_revision
-    info['Revision'].to_i
-  end
-
-  def url
-    info['URL']
-  end
-
-  def last_commit_message
-    message = execute("log", "--limit 1 -v")
-    #strip first line that contains command line itself (svn log --limit ...)
-    if (idx = message.index('-'*72))
-      message[idx..-1]
-    else
-      message
-    end
-  end
-
-  def last_author
-    info['Last Changed Author']
-  end
-
-  private
-  def locked?
-    execute("st") =~ /^..L/
-  end
-
-  def info
-    unless @info
-      output = execute("info")
-      @info = YAML.load(output)
-
-      if not @info.is_a?(Hash) or @info['Repository UUID'].nil? #.size > 8
-        say "Could not parse svn output. Seems source directory #{@encoded_path} is corrupted.\n#{output}"
-      end
-    end
-    @info
-  end
-    
-  def execute(command, parameters = nil, pre_parameters = nil)
-    `#{@config[:bin_path]}svn #{command} #{auth_options()} #{pre_parameters} #{@encoded_path} #{parameters}`
-  end
-
-  def auth_options
-    auth = []
-    auth << "--username #{@config[:scm, :user_name]}" if @config[:scm, :user_name]
-    auth << "--password #{@config[:scm, :password]}" if @config[:scm, :password]
-
-    auth.join(' ')
-  end
-end
+require 'cerberus/utils'
+
+class Cerberus::SCM::SVN
+  def initialize(path, config = {})
+    raise "Path can't be nil" unless path
+
+    @path, @config = path.strip, config
+    @encoded_path = (@path.include?(' ') ? "\"#{@path}\"" : @path)
+  end
+
+  def installed?
+    exec_successful? "#{@config[:bin_path]}svn --version"
+  end
+
+  def update!
+    if test(?d, @path + '/.svn') #check first that it was not locked 
+      execute("cleanup") if locked?
+      say "Could not unlock svn directory #{@encoded_path}. Please do it manually." if locked? #In case if we could not unlock from command line - ask user to do it
+    end
+
+    if test(?d, @path + '/.svn')
+      @status = execute("update")
+    else
+      FileUtils.mkpath(@path) unless test(?d,@path)
+      @status = execute("checkout", nil, @config[:scm, :url])
+    end
+  end
+
+  def has_changes?
+    @status =~ /[A-Z]\s+[\w\/]+/ ? true : false
+  end
+
+  def current_revision
+    info['Revision'].to_i
+  end
+
+  def url
+    info['URL']
+  end
+
+  def last_commit_message
+    message = execute("log", "--limit 1 -v")
+    #strip first line that contains command line itself (svn log --limit ...)
+    if (idx = message.index('-'*72))
+      message[idx..-1]
+    else
+      message
+    end
+  end
+
+  def last_author
+    info['Last Changed Author']
+  end
+
+  private
+  def locked?
+    execute("st") =~ /^..L/
+  end
+
+  def info
+    unless @info
+      output = execute("info")
+      @info = YAML.load(output)
+
+      if not @info.is_a?(Hash) or @info['Repository UUID'].nil? #.size > 8
+        say "Could not parse svn output. Seems source directory #{@encoded_path} is corrupted.\n#{output}"
+      end
+    end
+    @info
+  end
+    
+  def execute(command, parameters = nil, pre_parameters = nil)
+    `#{@config[:bin_path]}svn #{command} #{auth_options()} #{pre_parameters} #{@encoded_path} #{parameters}`
+  end
+
+  def auth_options
+    auth = []
+    auth << "--username #{@config[:scm, :user_name]}" if @config[:scm, :user_name]
+    auth << "--password #{@config[:scm, :password]}" if @config[:scm, :password]
+
+    auth.join(' ')
+  end
+end

data/lib/cerberus/utils.rb

@@ -1,156 +1,156 @@
-require 'yaml'
-
-module Cerberus
-  module Utils
-    def say(msg)
-      STDERR << msg
-      exit 1
-    end
-
-    def os
-      case RUBY_PLATFORM
-      when /mswin/
-        :windows
-      else
-        :unix
-      end
-    end
-
-    def dump_yml(file, what, overwrite = true)
-      if overwrite or not File.exists?(file)
-        FileUtils.mkpath(File.dirname(file))
-        File.open(file, 'w') {|f| YAML::dump(what, f) } 
-      end
-    end
-
-    def load_yml(file_name, default = {})
-      File.exists?(file_name) ? YAML::load(IO.read(file_name)) : default
-    end
-
-    def silence_stream(stream)
-      old_stream = stream.dup
-      stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
-      stream.sync = true
-      yield
-    ensure
-      stream.reopen(old_stream)
-    end
-
-    def exec_successful?(cmd)
-      begin
-        `#{cmd}`
-        return true
-      rescue
-        return false
-      end
-    end
-
-    def interpret_state(state, with_default = true)
-       case 
-       when state == 'all'
-         [:setup, :successful, :revival, :broken, :failed]
-       when state == 'none'
-         []
-       when state == 'default' && with_default
-         [:setup, :revival, :broken, :failed] #the same as 'all' except successful
-       else
-         state.scan(/\w+/).map{|s| s.to_sym}
-       end
-    end
-  end
-end
-
-include Cerberus::Utils
-
-alias __exec `
-def `(cmd)
-  begin
-    __exec(cmd)
-  rescue Exception => e           
-    raise "Unable to execute: #{cmd}"
-  end
-end
-
-class Hash
-  def deep_merge!(second)
-    second.each_pair do |k,v|
-      if self[k].is_a?(Hash) and second[k].is_a?(Hash)
-        self[k].deep_merge!(second[k])
-      else
-        self[k] = second[k]
-      end
-    end
-  end
-end
-
-class HashWithIndifferentAccess < Hash
-  def initialize(constructor = {})
-    if constructor.is_a?(Hash)
-      super()
-      update(constructor)
-    else
-      super(constructor)
-    end
-  end
- 
-  def default(key)
-    self[key.to_s] if key.is_a?(Symbol)
-  end  
-
-  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-  
-  def []=(key, value)
-    regular_writer(convert_key(key), convert_value(value))
-  end
-
-  def update(other_hash)
-    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
-    self
-  end
-  
-  alias_method :merge!, :update
-
-  def key?(key)
-    super(convert_key(key))
-  end
-
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?, :key?
-
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
-  end
-
-  def values_at(*indices)
-    indices.collect {|key| self[convert_key(key)]}
-  end
-
-  def dup
-    HashWithIndifferentAccess.new(self)
-  end
-  
-  def merge(hash)
-    self.dup.update(hash)
-  end
-
-  def delete(key)
-    super(convert_key(key))
-  end
-    
-  protected
-    def convert_key(key)
-      key.kind_of?(Symbol) ? key.to_s : key
-    end
-    def convert_value(value)
-      value.is_a?(Hash) ? HashWithIndifferentAccess.new(value) : value
-    end
-end
-
-
-class IO
-  def self.write(filename, str)
-    File.open(filename, 'w'){|f| f.write str}
-  end
-end
+require 'yaml'
+
+module Cerberus
+  module Utils
+    def say(msg)
+      STDERR << msg << "\n"
+      exit 1
+    end
+
+    def os
+      case RUBY_PLATFORM
+      when /mswin/
+        :windows
+      else
+        :unix
+      end
+    end
+
+    def dump_yml(file, what, overwrite = true)
+      if overwrite or not File.exists?(file)
+        FileUtils.mkpath(File.dirname(file))
+        File.open(file, 'w') {|f| YAML::dump(what, f) } 
+      end
+    end
+
+    def load_yml(file_name, default = {})
+      File.exists?(file_name) ? YAML::load(IO.read(file_name)) : default
+    end
+
+    def silence_stream(stream)
+      old_stream = stream.dup
+      stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+      stream.sync = true
+      yield
+    ensure
+      stream.reopen(old_stream)
+    end
+
+    def exec_successful?(cmd)
+      begin
+        `#{cmd}`
+        return true
+      rescue
+        return false
+      end
+    end
+
+    def interpret_state(state, with_default = true)
+       case 
+       when state == 'all'
+         [:setup, :successful, :revival, :broken, :failed]
+       when state == 'none'
+         []
+       when state == 'default' && with_default
+         [:setup, :revival, :broken, :failed] #the same as 'all' except successful
+       else
+         state.scan(/\w+/).map{|s| s.to_sym}
+       end
+    end
+  end
+end
+
+include Cerberus::Utils
+
+alias __exec `
+def `(cmd)
+  begin
+    __exec(cmd)
+  rescue Exception => e           
+    raise "Unable to execute: #{cmd}"
+  end
+end
+
+class Hash
+  def deep_merge!(second)
+    second.each_pair do |k,v|
+      if self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        self[k].deep_merge!(second[k])
+      else
+        self[k] = second[k]
+      end
+    end
+  end
+end
+
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+ 
+  def default(key)
+    self[key.to_s] if key.is_a?(Symbol)
+  end  
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+  
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+  
+  alias_method :merge!, :update
+
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+  
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  def delete(key)
+    super(convert_key(key))
+  end
+    
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+    def convert_value(value)
+      value.is_a?(Hash) ? HashWithIndifferentAccess.new(value) : value
+    end
+end
+
+
+class IO
+  def self.write(filename, str)
+    File.open(filename, 'w'){|f| f.write str}
+  end
+end