scout-gear 1.2.0 → 5.1.1

data/lib/scout/misc/format.rb

@@ -0,0 +1,226 @@
+module Misc
+  COLOR_LIST = %w(#BC80BD #CCEBC5 #FFED6F #8DD3C7 #FFFFB3 #BEBADA #FB8072 #80B1D3 #FDB462 #B3DE69 #FCCDE5 #D9D9D9)
+
+  def self.colors_for(list)
+    unused = COLOR_LIST.dup
+
+    used = {}
+    colors = list.collect do |elem|
+      if used.include? elem
+        used[elem]
+      else
+        color = unused.shift
+        used[elem]=color
+        color
+      end
+    end
+
+    [colors, used]
+  end
+
+  def self.format_seconds(time, extended = false)
+    seconds = time.to_i
+    str = [seconds/3600, seconds/60 % 60, seconds % 60].map{|t|  "%02i" % t }.join(':')
+    str << ".%02i" % ((time - seconds) * 100) if extended
+    str
+  end
+
+  def self.format_paragraph(text, size = 80, indent = 0, offset = 0)
+    i = 0
+    size = size + offset + indent
+    re = /((?:\n\s*\n\s*)|(?:\n\s*(?=\*)))/
+      text.split(re).collect do |paragraph|
+      i += 1
+      str = if i % 2 == 1
+              words = paragraph.gsub(/\s+/, "\s").split(" ")
+              lines = []
+              line = " "*offset
+              word = words.shift
+              while word
+                word = word[0..size-indent-offset-4] + '...' if word.length >= size - indent - offset
+                while word and Log.uncolor(line).length + Log.uncolor(word).length <= size - indent
+                  line << word << " "
+                  word = words.shift
+                end
+                offset = 0
+                lines << ((" " * indent) << line[0..-2])
+                line = ""
+              end
+              (lines * "\n")
+            else
+              paragraph
+            end
+      offset = 0
+      str
+      end*""
+  end
+
+  def self.format_definition_list_item(dt, dd, size = 80, indent = 20, color = :yellow)
+    dd = "" if dd.nil?
+    dt = Log.color color, dt if color
+    dt = dt.to_s  unless dd.empty?
+    len = Log.uncolor(dt).length
+
+    if indent < 0
+      text = format_paragraph(dd, size, indent.abs-1, 0)
+      text = dt << "\n" << text
+    else
+      offset = len - indent
+      offset = 0 if offset < 0
+      text = format_paragraph(dd, size, indent.abs+1, offset)
+      text[0..len-1] = dt
+    end
+    text
+  end
+
+  def self.format_definition_list(defs, size = 80, indent = 20, color = :yellow, sep = "\n\n")
+    entries = []
+    defs.each do |dt,dd|
+      text = format_definition_list_item(dt,dd,size,indent,color)
+      entries << text
+    end
+    entries * sep 
+  end
+
+  def self.camel_case(string)
+    return string if string !~ /_/ && string =~ /[A-Z]+.*/
+      string.split(/_|(\d+)/).map{|e| 
+        (e =~ /^[A-Z]{2,}$/ ? e : e.capitalize) 
+      }.join
+  end
+
+  def self.camel_case_lower(string)
+      string.split('_').inject([]){ |buffer,e| 
+        buffer.push(buffer.empty? ? e.downcase : (e =~ /^[A-Z]{2,}$/ ? e : e.capitalize)) 
+      }.join
+  end
+
+  def self.snake_case(string)
+    return nil if string.nil?
+    string = string.to_s if Symbol === string
+    string.
+      gsub(/([A-Z]{2,})([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z])([A-Z])/,'\1_\2').
+      gsub(/\s/,'_').gsub(/[^\w]/, '').
+      split("_").collect{|p| p.match(/[A-Z]{2,}/) ? p : p.downcase } * "_"
+  end
+
+  # source: https://gist.github.com/ekdevdes/2450285
+  # author: Ethan Kramer (https://github.com/ekdevdes)
+  def self.humanize(value, options = {})
+    if options.empty?
+      options[:format] = :sentence
+    end
+
+    values = value.to_s.split('_')
+    values.each_index do |index|
+      # lower case each item in array
+      # Miguel Vazquez edit: Except for acronyms
+      values[index].downcase! unless values[index].match(/[a-zA-Z][A-Z]/)
+    end
+    if options[:format] == :allcaps
+      values.each do |value|
+        value.capitalize!
+      end
+
+      if options.empty?
+        options[:seperator] = " "
+      end
+
+      return values.join " "
+    end
+
+    if options[:format] == :class
+      values.each do |value|
+        value.capitalize!
+      end
+
+      return values.join ""
+    end
+
+    if options[:format] == :sentence
+      values[0].capitalize! unless values[0].match(/[a-zA-Z][A-Z]/)
+
+      return values.join " "
+    end
+
+    if options[:format] == :nocaps
+      return values.join " "
+    end
+  end
+
+  def self.fixascii(string)
+    if string.respond_to?(:encode)
+      self.fixutf8(string).encode("ASCII-8BIT") 
+    else
+      string
+    end
+  end
+
+  def self.to_utf8(string)
+    string.encode("UTF-16BE", :invalid => :replace, :undef => :replace, :replace => "?").encode('UTF-8')
+  end
+
+  def self.fixutf8(string)
+    return nil if string.nil?
+    return string if string.respond_to?(:encoding) && string.encoding.to_s == "UTF-8" && (string.respond_to?(:valid_encoding?) && string.valid_encoding?) ||
+                     (string.respond_to?(:valid_encoding) && string.valid_encoding)
+
+    if string.respond_to?(:encode)
+      string.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+    else
+      require 'iconv'
+      @@ic ||= Iconv.new('UTF-8//IGNORE', 'UTF-8')
+      @@ic.iconv(string)
+    end
+  end
+
+  def self.humanize_list(list)
+    return "" if list.empty?
+    if list.length == 1
+      list.first
+    else
+      list[0..-2].collect{|e| e.to_s} * ", " << " and " << list[-1].to_s
+    end
+  end
+
+  def self.parse_sql_values(txt)
+    io = StringIO.new txt.strip
+
+    values = []
+    fields = []
+    current = nil
+    quoted = false
+    while c = io.getc
+      if quoted
+        if c == "'"
+          quoted = false
+        else
+          current << c
+        end
+      else
+        case c
+        when "("
+          current = ""
+        when ")"
+          fields << current
+          values << fields
+          fields = []
+          current = nil
+        when ','
+          if not current.nil?
+            fields << current
+            current = ""
+          end
+        when "'"
+          quoted = true
+        when ";"
+          break
+        else
+          current << c
+        end
+      end
+    end
+    values
+  end
+end

data/lib/scout/misc/insist.rb

@@ -0,0 +1,56 @@
+module Misc
+  def self.insist(times = 4, sleep = nil, msg = nil)
+    sleep_array = nil
+
+    try = 0
+    begin
+      begin
+        yield
+      rescue Exception
+        if Array === times
+          sleep_array = times
+          times = sleep_array.length
+          sleep = sleep_array.shift
+        end
+
+        if sleep.nil?
+          sleep_array = ([0] + [0.001, 0.01, 0.1, 0.5] * (times / 3)).sort[0..times-1]
+          sleep = sleep_array.shift
+        end
+        raise $!
+      end
+    rescue TryAgain
+      sleep sleep
+      retry
+    rescue StopInsist
+      raise $!.exception
+    rescue Aborted, Interrupt
+      if msg
+        Log.warn("Not Insisting after Aborted: #{$!.message} -- #{msg}")
+      else
+        Log.warn("Not Insisting after Aborted: #{$!.message}")
+      end
+      raise $!
+    rescue Exception
+      Log.exception $! if ENV["RBBT_LOG_INSIST"] == 'true'
+      if msg
+        Log.warn("Insisting after exception: #{$!.class} #{$!.message} -- #{msg}")
+      elsif FalseClass === msg
+        nil
+      else
+        Log.warn("Insisting after exception:  #{$!.class} #{$!.message}")
+      end
+
+      if sleep and try > 0
+        sleep sleep
+        sleep = sleep_array.shift || sleep if sleep_array
+      else
+        Thread.pass
+      end
+
+      try += 1
+      retry if try < times
+      raise $!
+    end
+  end
+end

data/lib/scout/misc.rb

@@ -1,13 +1,7 @@
-module Misc
-  def self.in_dir(dir)
-    old_pwd = FileUtils.pwd
-    begin
-      FileUtils.mkdir_p dir unless File.exist?(dir)
-      FileUtils.cd dir
-      yield
-    ensure
-      FileUtils.cd old_pwd
-    end
-  end
+require_relative 'misc/format'
+require_relative 'misc/insist'
+require_relative 'misc/digest'
+require_relative 'misc/filesystem'
 
+module Misc
 end

data/lib/scout/open/lock.rb

@@ -0,0 +1,61 @@
+require_relative '../path'
+require_relative '../log'
+require_relative '../exceptions'
+require 'lockfile'
+
+module Open
+  def self.lock(file, unlock = true, options = {})
+    unlock, options = true, unlock if Hash === unlock
+    return yield if file.nil? and not Lockfile === options[:lock]
+
+    if Lockfile === file
+      lockfile = file
+    else
+      file = file.find if Path === file
+      FileUtils.mkdir_p File.dirname(File.expand_path(file)) unless File.exist? File.dirname(File.expand_path(file))
+
+      case options[:lock]
+      when Lockfile
+        lockfile = options[:lock]
+      when FalseClass
+        lockfile = nil
+        unlock = false
+      when Path, String
+        lock_path = options[:lock].find
+        lockfile = Lockfile.new(lock_path, options)
+      else
+        lock_path = File.expand_path(file + '.lock')
+        lockfile = Lockfile.new(lock_path, options)
+      end
+    end
+
+    begin
+      lockfile.lock unless lockfile.nil? || lockfile.locked?
+    rescue Aborted, Interrupt
+      raise LockInterrupted
+    end
+
+    res = nil
+
+    begin
+      res = yield lockfile
+    rescue KeepLocked
+      unlock = false
+      res = $!.payload
+    ensure
+      if unlock 
+        begin
+          if lockfile.locked?
+            lockfile.unlock 
+          else
+          end
+        rescue Exception
+          Log.warn "Exception unlocking: #{lockfile.path}"
+          Log.exception $!
+        end
+      end
+    end
+
+    res
+  end
+end

data/lib/scout/open/remote.rb

@@ -0,0 +1,120 @@
+require_relative '../misc'
+require_relative '../path'
+require_relative '../cmd'
+
+module Open
+  class << self
+    attr_accessor :remote_cache_dir
+    
+    def remote_cache_dir
+      @remote_cache_dir ||= Path.setup("var/cache/open-remote/").find
+    end
+  end
+
+  def self.remote?(file)
+    !! (file =~ /^(?:https?|ftp|ssh):\/\//)
+  end
+
+  def self.ssh?(file)
+    !! (file =~ /^ssh:\/\//)
+  end
+
+  def self.ssh(file, options = {})
+    m = file.match(/ssh:\/\/([^:]+):(.*)/)
+    server = m[1]
+    file = m[2]
+    CMD.cmd("ssh '#{server}' cat '#{file}'", :pipe => true, :autojoin => true)
+  end
+
+  def self.wget(url, options = {})
+    if ! (options[:force] || options[:nocache]) && cache_file = in_cache(url, options)
+      return file_open(cache_file)
+    end
+
+    Log.low "WGET:\n -URL: #{ url }\n -OPTIONS: #{options.inspect}"
+    options = IndiferentHash.add_defaults options, "--user-agent=" => 'rbbt', :pipe => true, :autojoin => true
+
+    wait(options[:nice], options[:nice_key]) if options[:nice]
+    options.delete(:nice)
+    options.delete(:nice_key)
+
+    pipe  = options.delete(:pipe)
+    quiet = options.delete(:quiet)
+    post  = options.delete(:post)
+    cookies = options.delete(:cookies)
+    nocache = options.delete(:nocache)
+
+    options["--quiet"]     = quiet if options["--quiet"].nil?
+    options["--post-data="] ||= post if post
+
+    if cookies
+      options["--save-cookies"] = cookies
+      options["--load-cookies"] = cookies
+      options["--keep-session-cookies"] = true
+    end
+
+    stderr = case
+             when options['stderr']
+               options['stderr'] 
+             when options['--quiet']
+               false
+             else
+               nil
+             end
+
+    begin
+      wget_options = options.dup
+      wget_options = wget_options.merge( '-O' => '-') unless options.include?('--output-document')
+      wget_options[:pipe] = pipe unless pipe.nil?
+      wget_options[:stderr] = stderr unless stderr.nil?
+
+      io = CMD.cmd("wget '#{ url }'", wget_options)
+      if nocache && nocache.to_s != 'update'
+        io
+      else
+        add_cache(url, io, options)
+        open_cache(url, options)
+      end
+    rescue
+     STDERR.puts $!.backtrace.inspect
+     raise OpenURLError, "Error reading remote url: #{ url }.\n#{$!.message}"
+    end
+  end
+
+  def self.digest_url(url, options = {})
+    params = [url, options.values_at("--post-data", "--post-data="), (options.include?("--post-file")? Open.read(options["--post-file"]).split("\n").sort * "\n" : "")]
+    Misc.digest([url, params])
+  end
+
+  def self.cache_file(url, options)
+    File.join(self.remote_cache_dir, digest_url(url, options))
+  end
+
+  def self.in_cache(url, options = {})
+    filename = cache_file(url, options)
+    if File.exist? filename
+      return filename 
+    else
+      nil
+    end
+  end
+ 
+  def self.remove_from_cache(url, options = {})
+    filename = cache_file(url, options)
+    if File.exist? filename
+      FileUtils.rm filename 
+    else
+      nil
+    end
+  end
+  
+  def self.add_cache(url, data, options = {})
+    filename = cache_file(url, options)
+    Open.sensible_write(filename, data, :force => true)
+  end
+
+  def self.open_cache(url, options = {})
+    filename = cache_file(url, options)
+    Open.open(filename)
+  end
+end