scout-gear 1.2.0 → 2.0.0

data/lib/scout/misc/format.rb

@@ -0,0 +1,227 @@
+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.rb

@@ -1,3 +1,4 @@
+require_relative 'misc/format'
 module Misc
   def self.in_dir(dir)
     old_pwd = FileUtils.pwd

data/lib/scout/path/find.rb

@@ -1,25 +1,27 @@
+require_relative '../indiferent_hash'
 module Path
+
   def _parts
     @_parts ||= self.split("/")
   end
 
   def _subpath
-    @subpath ||= _parts.length > 1 ? _parts[1..-1] * "/" : _parts[0]
+    @subpath ||= _parts.length > 1 ? _parts[1..-1] * "/" : _parts[0] || ""
   end
   
   def _toplevel
-    @toplevel ||= _parts.length > 1 ? _parts[0] : nil
+    @toplevel ||= _parts.length > 1 ? _parts[0] : ""
   end
 
   def self.follow(path, map)
-    map.sub('{PKGDIR}', path.pkgdir || Path.default_pkgdir).
-      sub('{RESOURCE}', path.to_s).
+    map.sub('{PKGDIR}', path.pkgdir.respond_to?(:subdir) ? path.pkgdir.pkgdir : path.pkgdir || Path.default_pkgdir).
+      sub('{RESOURCE}', path.pkgdir.to_s).
       sub('{PWD}', FileUtils.pwd).
       sub('{TOPLEVEL}', path._toplevel).
       sub('{SUBPATH}', path._subpath).
       sub('{BASENAME}', File.basename(path)).
       sub('{PATH}', path).
-      sub('{LIBDIR}', path.libdir || Path.caller_lib_dir).
+      sub('{LIBDIR}', path.libdir || (path.pkgdir.respond_to?(:libdir) && path.pkgdir.libdir) || Path.caller_lib_dir).
       sub('{REMOVE}/', '').
       sub('{REMOVE}', '').gsub(/\/+/,'/')
   end
@@ -48,11 +50,16 @@ module Path
     @@search_order ||= (path_maps.keys & map_search) + (path_maps.keys - map_search)
   end
 
+  def self.add_path(name, map)
+    @@path_maps[name] = map
+    @@search_order = nil
+  end
+
   SLASH = "/"[0]
   DOT = "."[0]
   def located?
     # OPEN RESOURCE
-    self.slice(0,1) == SLASH || (self.char(0,1) == DOT && self.char(1,2) == SLASH) # || (resource != Rbbt && (Open.remote?(self) || Open.ssh?(self)))
+    self.slice(0,1) == SLASH || (self.slice(0,1) == DOT && self.slice(1,2) == SLASH) # || (resource != Rbbt && (Open.remote?(self) || Open.ssh?(self)))
   end
 
   def annotate_found_where(found, where)
@@ -85,13 +92,13 @@ module Path
 
   def find(where = nil)
     return self if located?
+    return find_all if where == 'all' || where == :all
     return follow(where) if where
 
-
     Path.search_order.each do |map_name|
       found = follow(map_name, false)
 
-      return annotate_found_where(found, map_name) if File.exist?(found) || File.directory?(real_path)
+      return annotate_found_where(found, map_name) if File.exist?(found) || File.directory?(found)
     end
 
     return follow(:default)
@@ -110,5 +117,4 @@ module Path
       .collect{|where| find(where) }
       .select{|file| file.exist? }.uniq
   end
-
 end

data/lib/scout/path/util.rb

@@ -31,12 +31,11 @@ module Path
   end
 
   def glob_all(pattern = nil, caller_lib = nil, search_paths = nil)
-    search_paths ||= Path.search_paths
+    search_paths ||= Path.path_maps
     search_paths = search_paths.dup
 
-    location_paths = {}
     search_paths.keys.collect do |where| 
-      found = find(where, Path.caller_lib_dir, search_paths)
+      found = find(where)
       paths = pattern ? Dir.glob(File.join(found, pattern)) : Dir.glob(found) 
 
       paths = paths.collect{|p| self.annotate p }
@@ -46,7 +45,7 @@ module Path
         p.where = where
       end if found.original and pattern
 
-      location_paths[where] = paths
-    end
+      paths
+    end.flatten.uniq
   end
 end

data/lib/scout/path.rb

@@ -4,16 +4,17 @@ require_relative 'path/util'
 
 module Path
   extend MetaExtension
-  extension_attr :pkgdir, :libdir
+  extension_attr :pkgdir, :libdir, :path_maps
 
   def self.caller_lib_dir(file = nil, relative_to = ['lib', 'bin'])
     
     if file.nil?
       caller_dup = caller.dup
       while file = caller_dup.shift
-        break unless file =~ /scout\/(?:resource\.rb|workflow\.rb)/ or
-          file =~ /scout\/path\.rb/ or
-          file =~ /scout\/persist.rb/
+        break unless file =~ /(?:scout|rbbt)\/(?:resource\.rb|workflow\.rb)/ or
+          file =~ /(?:scout|rbbt)\/(?:.*\/)?path\.rb/ or
+          file =~ /(?:scout|rbbt)\/(?:.*\/)?path\/(?:find|refactor|util)\.rb/ or
+          file =~ /(?:scout|rbbt)\/persist.rb/
       end
       file = file.sub(/\.rb[^\w].*/,'.rb')
     end
@@ -34,15 +35,20 @@ module Path
   end
 
   def self.default_pkgdir
-    @@default_pkgdir = 'scout'
+    @@default_pkgdir ||= 'scout'
   end
+  
+  def self.default_pkgdir=(pkgdir)
+    @@default_pkgdir = pkgdir
+  end
+
 
   def pkgdir
     @pkgdir ||= Path.default_pkgdir
   end
 
   def libdir
-    @libdir ||= Path.caller_lib_dir
+    @libdir
   end
 
   def join(subpath, prevpath = nil)
@@ -50,7 +56,7 @@ module Path
     prevpath = prevpath.to_s if Symbol === prevpath
 
     subpath = File.join(prevpath.to_s, subpath) if prevpath
-    new = File.join(self, subpath)
+    new = self.empty? ? subpath : File.join(self, subpath)
     self.annotate(new)
     new
   end

data/lib/scout/simple_opt/accessor.rb

@@ -0,0 +1,54 @@
+module SOPT
+  class << self
+    attr_accessor :inputs, :input_shortcuts, :input_types, :input_descriptions, :input_defaults
+  end
+
+  def self.all
+    @all ||= {}
+  end
+
+  def self.shortcuts
+    @shortcuts ||= {}
+  end
+  
+  def self.inputs 
+    @inputs ||= []
+  end
+
+  def self.input_shortcuts 
+    @input_shortcuts ||= {}
+  end
+
+  def self.input_types 
+    @input_types ||= {}
+  end
+
+  def self.input_descriptions 
+    @input_descriptions ||= {}
+  end
+
+  def self.input_defaults 
+    @input_defaults ||= {}
+  end
+
+  def self.reset
+    @shortcuts = {}
+    @all = {}
+  end
+
+  def self.delete_inputs(inputs)
+    inputs.each do |input|
+      input = input.to_s
+      self.shortcuts.delete self.input_shortcuts.delete(input)
+      self.inputs.delete input
+      self.input_types.delete input
+      self.input_defaults.delete input
+      self.input_descriptions.delete input
+    end
+  end
+
+  def self.usage
+    puts SOPT.doc
+    exit 0
+  end
+end

data/lib/scout/simple_opt/doc.rb

@@ -0,0 +1,120 @@
+require_relative '../log'
+module SOPT
+
+  class << self
+    attr_accessor :command, :summary, :synopsys, :description
+  end
+
+  def self.command
+    @command ||= File.basename($0)
+  end
+
+  def self.summary
+    @summary ||= ""
+  end
+
+  def self.synopsys
+    @synopsys ||= begin
+                    "#{command} " <<
+                    inputs.collect{|name|
+                      "[" << input_format(name, input_types[name] || :string, input_defaults[name], input_shortcuts[name]).sub(/:$/,'') << "]"
+                    } * " "
+                  end
+  end
+
+  def self.description
+    @description ||= "Missing"
+  end
+
+  def self.input_format(name, type = nil, default = nil, short = nil)
+    input_str = (short.nil? or short.empty?) ? "--#{name}" : "-#{short},--#{name}"
+    input_str = Log.color(:blue, input_str)
+    extra = case type
+    when nil
+      ""
+    when :boolean
+      "[=false]" 
+    when :tsv, :text
+      "=<file|->"
+    when :array
+      "=<list|file|->"
+    else
+      "=<#{ type }>"
+    end
+    #extra << " (default: #{Array === default ? (default.length > 3 ? default[0..2]*", " + ', ...' : default*", " ): default})" if default != nil
+    extra << " (default: #{Misc.fingerprint(default)})" if default != nil
+    input_str << Log.color(:green, extra)
+  end
+
+  def self.input_doc(inputs, input_types = nil, input_descriptions = nil, input_defaults = nil, input_shortcuts = nil)
+    type = description = default = nil
+    shortcut = ""
+    seen = []
+    inputs.collect do |name|
+      next if seen.include? name
+      seen << name
+
+      type = input_types[name] unless input_types.nil?
+      description = input_descriptions[name] unless input_descriptions.nil?
+      default = input_defaults[name] unless input_defaults.nil?
+
+      name = name.to_s
+
+      case input_shortcuts
+      when nil, FalseClass
+        shortcut = nil
+      when Hash
+        shortcut = input_shortcuts[name] 
+      when TrueClass
+        shortcut = fix_shortcut(name[0], name)
+      end
+
+      type = :string if type.nil?
+      register(shortcut, name, type, description) unless self.inputs.include? name
+
+      name  = SOPT.input_format(name, type.to_sym, default, shortcut) 
+      description 
+      Misc.format_definition_list_item(name, description, 80, 31, nil)
+    end * "\n"
+  end
+
+  def self.doc
+    doc = <<-EOF
+#{Log.color :magenta}#{command}(1) -- #{summary}
+#{"=" * (command.length + summary.length + 7)}#{Log.color :reset}
+
+#{ Log.color :magenta, "## SYNOPSYS"}
+
+#{Log.color :blue, synopsys}
+
+#{ Log.color :magenta, "## DESCRIPTION"}
+
+#{Misc.format_paragraph description}
+
+#{ Log.color :magenta, "## OPTIONS"}
+
+#{input_doc(inputs, input_types, input_descriptions, input_defaults, input_shortcuts)}
+    EOF
+  end
+
+  def self.doc
+    doc = <<-EOF
+#{Log.color :magenta}#{command}(1) -- #{summary}
+#{"=" * (command.length + summary.length + 7)}#{Log.color :reset}
+
+    EOF
+
+    if synopsys and not synopsys.empty?
+      doc << Log.color(:magenta, "## SYNOPSYS") << "\n\n"
+      doc << Log.color(:blue, synopsys) << "\n\n"
+    end
+
+    if description and not description.empty?
+      doc << Log.color(:magenta, "## DESCRIPTION") << "\n\n"
+      doc << Misc.format_paragraph(description) << "\n\n"
+    end
+
+    doc << Log.color(:magenta, "## OPTIONS") << "\n\n"
+    doc << input_doc(inputs, input_types, input_descriptions, input_defaults, input_shortcuts)
+  end
+end

data/lib/scout/simple_opt/get.rb

@@ -0,0 +1,57 @@
+module SOPT
+  GOT_OPTIONS= IndiferentHash.setup({})
+  def self.current_options=(options)
+    @@current_options = options
+  end
+  def self.consume(args = ARGV)
+    i = 0
+    @@current_options ||= {}
+    while i < args.length do
+      current = args[i]
+      break if current == "--"
+      if m = current.match(/--?(.+?)(?:=(.+))?$/)
+        key = $1
+        value = $2
+
+        input = inputs.include?(key)? key : shortcuts[key]
+
+        if input.nil?
+          i += 1
+          next
+        else
+          args.delete_at i
+        end
+      else
+        i += 1
+        next
+      end
+
+      if input_types[input] == :string
+        value = args.delete_at(i) if value.nil?
+        @@current_options[input] = value
+      else
+        if value.nil? and %w(F false FALSE no).include?(args[i])
+          Log.warn "Boolean values are best specified as #{current}=[true|false], not #{ current } [true|false]. Token '#{args[i]}' following '#{current}' automatically assigned as value" 
+          value = args.delete_at(i)
+        end
+        @@current_options[input] = %w(F false FALSE no).include?(value)? false : true
+      end
+    end
+
+    IndiferentHash.setup @@current_options
+    GOT_OPTIONS.merge! @@current_options
+
+    @@current_options
+  end
+  
+  def self.get(opt_str)
+    SOPT.parse(opt_str)
+    SOPT.consume(ARGV)
+  end
+
+  def self.require(options, *parameters)
+    parameters.flatten.each do |parameter|
+      raise ParameterException, "Parameter '#{ Log.color :blue, parameter }' not given" if options[parameter].nil?
+    end
+  end
+end

data/lib/scout/simple_opt/parse.rb

@@ -0,0 +1,66 @@
+module SOPT
+  def self.fix_shortcut(short, long)
+    return short unless short and shortcuts.include?(short)
+
+    current = shortcuts.select{|s,l| l == long}.collect{|s,l| s }.first
+    return current if current
+
+    chars = long.chars.to_a
+    current = [chars.shift]
+    short = current * ""
+
+    if (shortcuts.include?(short) and not shortcuts[short] == long) 
+      if long.index "-" or long.index "_"
+        parts = long.split(/[_-]/)
+        acc = parts.collect{|s| s[0] } * ""
+        return acc unless shortcuts.include? acc
+      elsif m = long.match(/(\d+)/)
+        n = m[0]
+        acc = long[0] + n
+        return acc unless shortcuts.include? acc
+      end
+    end
+
+    while shortcuts.include?(short) && shortcuts[short] != long 
+      next_letter = chars.shift
+      next_letter = chars.shift while %w(. - _).include?(next_letter)
+      return nil if next_letter.nil?
+      current << next_letter
+      short = current * ""
+    end
+
+    return nil if shortcuts.include? short
+
+    short
+  end
+
+  def self.register(short, long, asterisk, description)
+    short = fix_shortcut(short, long)
+    shortcuts[short] = long if short
+    inputs << long
+    input_shortcuts[long] = short
+    input_descriptions[long] = description
+    input_types[long] = asterisk ? :string : :boolean
+  end
+
+  def self.parse(opt_str)
+    info = {}
+
+    inputs = []
+    if opt_str.include? "\n"
+      re = /\n+/
+    else
+      re = /:/
+    end
+    opt_str.split(re).each do |entry|
+      entry.strip!
+      next if entry.empty?
+      names, _sep, description = entry.partition /\s+/
+      short, long, asterisk = names.match(/\s*(?:-(.+))?(?:--(.+?))([*])?$/).values_at 1,2,3 
+
+      inputs << long
+      register short, long, asterisk, description
+    end
+    inputs
+  end
+end