scout-gear 1.1.1 → 2.0.0

data/lib/scout/log/progress/util.rb

@@ -81,7 +81,6 @@ module Log
 
     def self.with_bar(max, options = {})
       bar = new_bar(max, options)
-      res = nil
       begin
         error = false
         keep = false

data/lib/scout/log.rb

@@ -35,7 +35,7 @@ module Log
   def self.last_caller(stack)
     line = nil
     pos ||= 0
-    while line.nil? or line =~ /scout\/helper\/log\.rb/ and stack.any? 
+    while line.nil? or line =~ /scout\/log\.rb/ and stack.any? 
       line = stack.shift 
     end
     line ||= caller.first

data/lib/scout/meta_extension.rb

@@ -13,9 +13,23 @@ module MetaExtension
 
     meta.define_method(:setup) do |obj,*rest|
       obj.extend base
-      self.class_variable_get("@@extension_attrs").zip(rest).each do |name,value|
+      attrs = self.class_variable_get("@@extension_attrs")
+
+      return if attrs.nil? || attrs.empty?
+
+      if rest.length == 1 && Hash === (rlast = rest.last) && 
+          ! (rlkey = rlast.keys.first).nil? &&
+          attrs.include?(rlkey.to_sym)
+
+        pairs = rlast
+      else
+        pairs = attrs.zip(rest)
+      end
+
+      pairs.each do |name,value|
         obj.instance_variable_set("@#{name}", value)
       end
+
       obj
     end
 

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

@@ -0,0 +1,14 @@
+require_relative 'misc/format'
+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
+
+end

data/lib/scout/path/find.rb

@@ -1,65 +1,120 @@
+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).
-      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).
+      sub('{LIBDIR}', path.libdir || (path.pkgdir.respond_to?(:libdir) && path.pkgdir.libdir) || Path.caller_lib_dir).
       sub('{REMOVE}/', '').
       sub('{REMOVE}', '').gsub(/\/+/,'/')
   end
 
-  PATH_MAPS = IndiferentHash.setup({
-    :current => File.join("{PWD}", "{TOPLEVEL}", "{SUBPATH}"),
-    :user    => File.join(ENV['HOME'], ".{PKGDIR}", "{TOPLEVEL}", "{SUBPATH}"),
-    :global  => File.join('/', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
-    :usr   => File.join('/usr/', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
-    :local   => File.join('/usr/local', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
-    :fast   => File.join('/fast', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
-    :cache   => File.join('/cache', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
-    :bulk   => File.join('/bulk', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
-    :lib     => File.join('{LIBDIR}', "{TOPLEVEL}", "{SUBPATH}"),
-    :base   => File.join(Path.caller_lib_dir(__FILE__), "{TOPLEVEL}", "{SUBPATH}"),
-    :default => :user
-  })
-
-  MAP_SEARCH = %w(current workflow user local global lib fast cache bulk)
-
-  def _follow(map_name)
-    map = PATH_MAPS[map_name]
+  def self.path_maps
+    @@path_maps ||= IndiferentHash.setup({
+      :current => File.join("{PWD}", "{TOPLEVEL}", "{SUBPATH}"),
+      :user    => File.join(ENV['HOME'], ".{PKGDIR}", "{TOPLEVEL}", "{SUBPATH}"),
+      :global  => File.join('/', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+      :usr     => File.join('/usr/', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+      :local   => File.join('/usr/local', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+      :fast    => File.join('/fast', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+      :cache   => File.join('/cache', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+      :bulk    => File.join('/bulk', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+      :lib     => File.join('{LIBDIR}', "{TOPLEVEL}", "{SUBPATH}"),
+      :base    => File.join(Path.caller_lib_dir(__FILE__), "{TOPLEVEL}", "{SUBPATH}"),
+      :default => :user
+    })
+  end
+
+  def self.map_search
+    @@map_search ||= %w(current workflow user local global lib fast cache bulk)
+  end
+
+  def self.search_order
+    @@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.slice(0,1) == DOT && self.slice(1,2) == SLASH) # || (resource != Rbbt && (Open.remote?(self) || Open.ssh?(self)))
+  end
+
+  def annotate_found_where(found, where)
+    self.annotate(found).tap{|p| 
+      p.instance_variable_set("@where", where) 
+      p.instance_variable_set("@original", self.dup) 
+    }
+  end
+
+  def where
+    @where
+  end
+
+  def original
+    @original
+  end
+
+  def follow(map_name = :default, annotate = true)
+    map = Path.path_maps[map_name]
     while Symbol === map
-      map = PATH_MAPS[map]
+      map_name = map
+      map = Path.path_maps[map_name]
     end
-    Path.follow(self, map)
+    found = Path.follow(self, map)
+
+    annotate_found_where(found, map_name)  if annotate
+
+    found
   end
 
   def find(where = nil)
-    return _follow(where) if where
+    return self if located?
+    return find_all if where == 'all' || where == :all
+    return follow(where) if where
 
-    all_maps = PATH_MAPS.keys
-    search_order = MAP_SEARCH & all_maps + (all_maps - MAP_SEARCH)
+    Path.search_order.each do |map_name|
+      found = follow(map_name, false)
 
-    search_order.each do |name|
-      map = PATH_MAPS[name]
-      real_path = _follow(map)
-      return real_path if File.exists?(real_path)
+      return annotate_found_where(found, map_name) if File.exist?(found) || File.directory?(found)
     end
 
-    return _follow(:default)
+    return follow(:default)
+  end
+
+  def exist?
+    # OPEN
+    found = self.find
+    File.exist?(found) || File.directory?(found)
+  end
+
+  alias exists? exist?
+
+  def find_all(caller_lib = nil, search_paths = nil)
+    Path.search_order
+      .collect{|where| find(where) }
+      .select{|file| file.exist? }.uniq
   end
 end

data/lib/scout/path/util.rb

@@ -0,0 +1,51 @@
+module Path
+  def directory?
+    return nil unless self.exist?
+    File.directory?(self.find)
+  end
+
+  def dirname
+    self.annotate(File.dirname(self))
+  end
+
+  def basename
+    self.annotate(File.basename(self))
+  end
+
+
+  def glob(pattern = '*')
+    if self.include? "*"
+      self.glob_all
+    else
+      return [] unless self.exist? 
+      found = self.find
+      exp = File.join(found, pattern)
+      paths = Dir.glob(exp).collect{|f| self.annotate(f) }
+
+      paths.each do |p|
+        p.original = File.join(found.original, p.sub(/^#{found}/, ''))
+      end if found.original
+
+      paths
+    end
+  end
+
+  def glob_all(pattern = nil, caller_lib = nil, search_paths = nil)
+    search_paths ||= Path.path_maps
+    search_paths = search_paths.dup
+
+    search_paths.keys.collect do |where| 
+      found = find(where)
+      paths = pattern ? Dir.glob(File.join(found, pattern)) : Dir.glob(found) 
+
+      paths = paths.collect{|p| self.annotate p }
+
+      paths = paths.each do |p|
+        p.original = File.join(found.original, p.sub(/^#{found}/, ''))
+        p.where = where
+      end if found.original and pattern
+
+      paths
+    end.flatten.uniq
+  end
+end

data/lib/scout/path.rb

@@ -1,17 +1,20 @@
 require_relative 'meta_extension'
+require_relative 'path/find'
+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
@@ -31,11 +34,21 @@ module Path
     return nil
   end
 
-  def self.setup(path, pkgdir = 'scout', libdir = nil)
-    path.extend Path
-    path.pkgdir = pkgdir
-    path.libdir = libdir || Path.caller_lib_dir
-    path
+  def self.default_pkgdir
+    @@default_pkgdir ||= 'scout'
+  end
+  
+  def self.default_pkgdir=(pkgdir)
+    @@default_pkgdir = pkgdir
+  end
+
+
+  def pkgdir
+    @pkgdir ||= Path.default_pkgdir
+  end
+
+  def libdir
+    @libdir
   end
 
   def join(subpath, prevpath = nil)
@@ -43,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