scout-gear 9.1.0 → 10.0.1

data/lib/scout/misc/format.rb

@@ -1,255 +0,0 @@
-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
-
-  CHAR_SENCONDS = ENV["SCOUT_NOCOLOR"] == "true" ? "sec" : "″"
-  def self.format_seconds_short(time)
-    if time < 0.0001
-      "%.5g" % time + CHAR_SENCONDS
-    elsif time < 60
-      "%.2g" % time + CHAR_SENCONDS
-    else
-      format_seconds(time)
-    end
-  end
-
-
-  
-  MAX_TTY_LINE_WIDTH = 100
-  def self.format_paragraph(text, size = nil, indent = nil, offset = nil)
-    size ||= Log.tty_size || MAX_TTY_LINE_WIDTH
-    size = MAX_TTY_LINE_WIDTH if size > MAX_TTY_LINE_WIDTH
-    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,  indent = nil, size = nil, color = :yellow)
-    if size.nil?
-      base_size = MAX_TTY_LINE_WIDTH
-      base_indent = indent || (base_size / 3)
-      size = base_size - base_indent
-    end
-
-    indent ||= base_indent || size / 3
-
-    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, indent = nil, size = nil, color = :yellow, sep = "\n\n")
-    indent ||= 30
-    size ||= (Log.tty_size || MAX_TTY_LINE_WIDTH) - indent
-    entries = []
-    defs.each do |dt,dd|
-      text = format_definition_list_item(dt,dd,indent, size,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/helper.rb

@@ -1,31 +0,0 @@
-module Misc
-  def self.intersect_sorted_arrays(a1, a2)
-    e1, e2 = a1.shift, a2.shift
-    intersect = []
-    while true
-      break if e1.nil? or e2.nil?
-      case e1 <=> e2
-      when 0
-        intersect << e1
-        e1, e2 = a1.shift, a2.shift
-      when -1
-        e1 = a1.shift while not e1.nil? and e1 < e2
-      when 1
-        e2 = a2.shift
-        e2 = a2.shift while not e2.nil? and e2 < e1
-      end
-    end
-    intersect
-  end
-
-  def self.counts(array)
-    counts = {}
-    array.each do |e|
-      counts[e] ||= 0
-      counts[e] += 1
-    end
-
-    counts
-  end
-
-end

data/lib/scout/misc/insist.rb

@@ -1,56 +0,0 @@
-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["SCOUT_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/monitor.rb

@@ -1,66 +0,0 @@
-module Misc
-  def self.pid_alive?(pid)
-    !! Process.kill(0, pid) rescue false
-  end
-
-  def self.benchmark(repeats = 1, message = nil)
-    require 'benchmark'
-    res = nil
-    begin
-      measure = Benchmark.measure do
-        repeats.times do
-          res = yield
-        end
-      end
-      if message
-        puts "#{message }: #{ repeats } repeats"
-      else
-        puts "Benchmark for #{ repeats } repeats (#{caller.first})"
-      end
-      puts measure
-    rescue Exception
-      puts "Benchmark aborted"
-      raise $!
-    end
-    res
-  end
-
-  def self.profile(options = {})
-    require 'ruby-prof'
-    profiler = RubyProf::Profile.new
-    profiler.start
-    begin
-      res = yield
-    rescue Exception
-      puts "Profiling aborted"
-      raise $!
-    ensure
-      result = profiler.stop
-      printer = RubyProf::FlatPrinter.new(result)
-      printer.print(STDOUT, options)
-    end
-
-    res
-  end
-
-  def self.exec_time(&block)
-    start = Time.now
-    eend = nil
-    begin
-      yield
-    ensure
-      eend = Time.now
-    end
-    eend - start
-  end
-
-  def self.wait_for_interrupt
-    while true
-      begin
-        sleep 1
-      rescue Interrupt
-        break
-      end
-    end
-  end
-end

data/lib/scout/misc/system.rb

@@ -1,73 +0,0 @@
-require 'sys/proctable'
-
-module Misc
-
-  def self.hostname
-    @@hostname ||= begin
-                     `hostname`.strip
-                   end
-  end
-
-  def self.children(ppid = nil)
-    ppid ||= Process.pid
-    Sys::ProcTable.ps.select{ |pe| pe.ppid == ppid }
-  end
-
-  def self.env_add(var, value, sep = ":", prepend = true)
-    if ENV[var].nil?
-      ENV[var] = value
-    elsif ENV[var] =~ /(#{sep}|^)#{Regexp.quote value}(#{sep}|$)/
-      return
-    else
-      if prepend
-        ENV[var] = value + sep + ENV[var]
-      else
-        ENV[var] += sep + value
-      end
-    end
-  end
-
-  def self.with_env(var, value, &block)
-    old_value = ENV[var]
-    begin
-      ENV[var] = value
-      yield
-    ensure
-      ENV[var] = old_value
-    end
-  end
-  
-  def self.update_git(gem_name = 'scout-gear')
-    gem_name = 'scout-gear' if gem_name.nil?
-    dir = File.join(__dir__, '../../../../', gem_name)
-    return unless Open.exist?(dir)
-    Misc.in_dir dir do
-      begin
-        begin
-          CMD.cmd_log('git pull')
-        rescue
-          raise "Could not update #{gem_name}"
-        end
-
-        begin
-          CMD.cmd_log('git submodule update')
-        rescue
-          raise "Could not update #{gem_name} submodules"
-        end
-
-
-        begin
-          CMD.cmd_log('rake install')
-        rescue
-          raise "Could not install updated #{gem_name}"
-        end
-      rescue
-        Log.warn $!.message
-      end
-    end
-  end
-
-  def self.processors
-    Etc.nprocessors
-  end
-end

data/lib/scout/misc.rb

@@ -1,10 +0,0 @@
-require_relative 'misc/format'
-require_relative 'misc/insist'
-require_relative 'misc/digest'
-require_relative 'misc/filesystem'
-require_relative 'misc/monitor'
-require_relative 'misc/system'
-require_relative 'misc/helper'
-
-module Misc
-end

data/lib/scout/named_array.rb

@@ -1,138 +0,0 @@
-require_relative 'meta_extension'
-module NamedArray
-  extend MetaExtension
-  extension_attr :fields, :key
-
-  def self.field_match(field, name)
-    if (String === field) && (String === name)
-      field == name || 
-        field.start_with?(name) || field.include?("(" + name + ")") ||
-        name.start_with?(field) || name.include?("(" + field + ")")
-    else
-      field == name
-    end
-  end
-
-  def self.identify_name(names, selected, strict: false)
-    res = (Array === selected ? selected : [selected]).collect do |field|
-      case field
-      when nil
-        0
-      when Range
-        field
-      when Integer
-        field
-      when Symbol
-        field == :key ? field : identify_name(names, field.to_s)
-      when (names.nil? and String)
-        if field =~ /^\d+$/
-          identify_field(key_field, fields, field.to_i)
-        else
-          raise "No name information available and specified name not numeric: #{ field }"
-        end
-      when Symbol
-        names.index{|f| f.to_s == field.to_s }
-      when String
-        pos = names.index{|f| f.to_s == field }
-        next pos if pos
-        if field =~ /^\d+$/
-          next identify_names(names, field.to_i)
-        end
-        next pos if strict
-        pos = names.index{|name| field_match(field, name) }
-        next pos if pos
-        nil
-      else
-        raise "Field '#{ Log.fingerprint field }' was not understood. Options: (#{ Log.fingerprint names })"
-      end
-    end
-
-    Array === selected ? res : res.first
-  end
-
-  def identify_name(selected)
-    NamedArray.identify_name(fields, selected)
-  end
-
-  def positions(fields)
-    if Array ==  fields
-      fields.collect{|field|
-        NamedArray.identify_name(@fields, field)
-      }
-    else
-      NamedArray.identify_name(@fields, fields)
-    end
-  end
-
-  def [](key)
-    pos = NamedArray.identify_name(@fields, key)
-    return nil if pos.nil?
-    super(pos)
-  end
-
-  def concat(other)
-    super(other)
-    self.fields.concat(other.fields) if NamedArray === other
-    self
-  end
-
-  def to_hash
-    hash = {}
-    self.fields.zip(self) do |field,value|
-      hash[field] = value
-    end
-    IndiferentHash.setup hash
-  end
-
-  def values_at(*positions)
-    super(*identify_name(positions))
-  end
-
-  def self._zip_fields(array, max = nil)
-    return [] if array.nil? or array.empty? or (first = array.first).nil?
-
-    max = array.collect{|l| l.length }.max if max.nil?
-
-    rest = array[1..-1].collect{|v|
-      v.length == 1 & max > 1 ? v * max : v
-    }
-
-    first = first * max if first.length == 1 and max > 1
-
-    first.zip(*rest)
-  end
-
-  def self.zip_fields(array)
-    if array.length < 10000
-      _zip_fields(array)
-    else
-      zipped_slices = []
-      max = array.collect{|l| l.length}.max
-      array.each_slice(10000) do |slice|
-        zipped_slices << _zip_fields(slice, max)
-      end
-      new = zipped_slices.first
-      zipped_slices[1..-1].each do |rest|
-        rest.each_with_index do |list,i|
-          new[i].concat list
-        end
-      end
-      new
-    end
-  end
-
-  def self.add_zipped(source, new)
-    source.zip(new).each do |s,n|
-      s.concat(n)
-    end
-    source
-  end
-
-  def method_missing(name, *args)
-    if identify_name(name)
-      return self[name]
-    else
-      return super(name, *args)
-    end
-  end
-end