scout-essentials 1.0.0

data/lib/scout/misc/format.rb

@@ -0,0 +1,255 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -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["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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,73 @@
+module Misc
+
+  def self.hostname
+    @@hostname ||= begin
+                     `hostname`.strip
+                   end
+  end
+
+  def self.children(ppid = nil)
+    require 'sys/proctable'
+
+    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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,138 @@
+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