scout-essentials 1.0.0

data/lib/scout/indiferent_hash.rb

@@ -0,0 +1,96 @@
+require_relative 'indiferent_hash/options'
+require_relative 'indiferent_hash/case_insensitive'
+
+module IndiferentHash
+
+  def self.setup(hash)
+    hash.extend IndiferentHash 
+    hash
+  end
+
+  def merge(other)
+    new = self.dup
+    IndiferentHash.setup(new)
+    other.each do |k,value|
+      new[k] = value
+    end
+    new
+  end
+
+  def []=(key,value)
+    delete(key)
+    super(key,value)
+  end
+
+  def _default?
+    @_default ||= self.default or self.default_proc
+  end
+
+  def [](key)
+    res = super(key) 
+    return res unless res.nil? or (_default? and not keys.include? key)
+
+    case key
+    when Symbol, Module
+      super(key.to_s)
+    when String
+      super(key.to_sym)
+    else
+      res
+    end
+  end
+
+  def values_at(*key_list)
+    key_list.inject([]){|acc,key| acc << self[key]}
+  end
+
+  def include?(key)
+    case key
+    when Symbol, Module
+      super(key) || super(key.to_s)
+    when String
+      super(key) || super(key.to_sym)
+    else
+      super(key)
+    end
+  end
+
+  def delete(key)
+    case key
+    when Symbol, Module
+      v = super(key) 
+      v.nil? ? super(key.to_s) : v
+    when String
+      v = super(key)
+      v.nil? ? super(key.to_sym) : v
+    else
+      super(key)
+    end
+  end
+
+  def clean_version
+    clean = {}
+    each do |k,v|
+      clean[k.to_s] = v unless clean.include? k.to_s
+    end
+    clean
+  end
+
+  def slice(*list)
+    ext_list = []
+    list.each do |e|
+      case e
+      when Symbol
+        ext_list << e
+        ext_list << e.to_s
+      when String
+        ext_list << e
+        ext_list << e.to_sym
+      else
+        ext_list << e
+      end
+    end
+    IndiferentHash.setup(super(*ext_list))
+  end
+end
+

data/lib/scout/log/color.rb

@@ -0,0 +1,224 @@
+require_relative 'color_class'
+require_relative '../indiferent_hash'
+
+require 'term/ansicolor'
+
+module Colorize
+  def self.colors=(colors)
+    @colors = colors
+  end
+
+  def self.colors
+    @colors ||= IndiferentHash.setup(Hash[<<-EOF.split("\n").collect{|l| l.split(" ")}])
+green #00cd00
+red #cd0000
+yellow #ffd700
+blue #0000cd
+path blue
+EOF
+  end
+
+  def self.diverging_colors=(colors)
+    @diverging_colors = colors
+  end
+
+  def self.diverging_colors
+    @diverging_colors ||=<<~EOF.split("\n")
+      #a6cee3
+      #1f78b4
+      #b2df8a
+      #33a02c
+      #fb9a99
+      #e31a1c
+      #fdbf6f
+      #ff7f00
+      #cab2d6
+      #6a3d9a
+      #ffff99
+      #b15928
+    EOF
+  end
+
+  def self.from_name(color)
+    return color if color =~ /^#?[0-9A-F]+$/i
+    return colors[color.to_s] if colors.include?(color.to_s)
+
+    case color.to_s
+    when "white"
+      '#000'
+    when "black"
+      '#fff'
+    when 'green'
+      colors["green3"]
+    when 'red'
+      colors["red3"]
+    when 'yellow'
+      colors["gold1"]
+    when 'blue'
+      colors["RoyalBlue"]
+    else
+      colors[color.to_s] || color.to_s
+    end
+  end
+
+  def self.continuous(array, start = "#40324F", eend = "#EABD5D", percent = false)
+    start_color = Color.new from_name(start)
+    end_color = Color.new from_name(eend)
+
+    if percent
+      array = array.collect{|v| n = v.to_f; n = n > 100 ? 100 : n; n < 0.001 ? 0.001 : n}
+    else
+      array = array.collect{|v| v.to_f }
+    end
+    max = array.max
+    min = array.min
+    range = max - min
+    array.collect do |v|
+      ratio = (v.to_f-min) / range
+      start_color.blend end_color, ratio
+    end
+  end
+
+  def self.gradient(array, value, start = :green, eend = :red, percent = false)
+    index = array.index value
+    colors = continuous(array, start, eend, percent)
+    colors[index]
+  end
+
+  def self.rank_gradient(array, value, start = :green, eend = :red, percent = false)
+    index = array.index value
+    sorted = array.sort
+    array = array.collect{|e| sorted.index e}
+    colors = continuous(array, start, eend, percent)
+    colors[index]
+  end
+
+
+  def self.distinct(array)
+    colors = diverging_colors.collect{|c| Color.new c }
+
+    num = array.uniq.length
+    times = num / 12
+
+    all_colors = colors.dup
+    factor = 0.3 / times
+    times.times do
+      all_colors.concat  colors.collect{|n| n.darken(factor) }
+    end
+
+    value_color = Hash[*array.uniq.zip(all_colors).flatten]
+
+    value_color.values_at(*array)
+  end
+
+  def self.tsv(tsv, options = {})
+    values = tsv.values.flatten
+    if Numeric === values.first or (values.first.to_f != 0 and values[0] != "0" and values[0] != "0.0")
+      value_colors = IndiferentHash.process_to_hash(values){continuous(values)}
+    else
+      value_colors = IndiferentHash.process_to_hash(values){distinct(values)}
+    end
+
+    if tsv.type == :single
+      Hash[*tsv.keys.zip(value_colors.values_at(*values)).flatten]
+    else
+      Hash[*tsv.keys.zip(values.collect{|vs| value_colors.values_at(*vs)}).flatten]
+    end
+  end
+end
+
+module Log
+  extend Term::ANSIColor
+
+  class << self
+    attr_accessor :nocolor
+  end
+
+  self.nocolor = ENV["SCOUT_NOCOLOR"] == 'true'
+
+  WHITE, DARK, GREEN, YELLOW, RED = Color::SOLARIZED.values_at :base0, :base00, :green, :yellow, :magenta
+
+  SEVERITY_COLOR = [reset, cyan, green, magenta, blue, yellow, red] #.collect{|e| "\033[#{e}"}
+  CONCEPT_COLORS = IndiferentHash.setup({
+    :title => magenta,
+    :path => blue,
+    :input => cyan,
+    :value => green,
+    :integer => green,
+    :negative => red,
+    :float => green,
+    :waiting => yellow,
+    :started => cyan,
+    :start => cyan,
+    :done => green,
+    :error => red,
+    :time => cyan,
+    :task => yellow,
+    :workflow => yellow,
+  })
+  HIGHLIGHT = "\033[1m"
+
+  def self.uncolor(str)
+    "" << Term::ANSIColor.uncolor(str)
+  end
+
+  def self.reset_color
+    reset
+  end
+
+  def self.color(color, str = nil, reset = false)
+    return str.dup || "" if nocolor
+
+    if (color == :integer || color == :float) && Numeric === str
+      color = if str < 0
+                :red
+              elsif str > 1
+                :cyan
+              else
+                :green
+              end
+    end
+
+    if color == :status
+      color = case str.to_sym
+              when :done
+                :green
+              when :error, :aborted
+                :red
+              when :waiting, :queued
+                :yellow
+              when :started, :streamming
+                :cyan
+              when :start
+                :title
+              else
+                :cyan
+              end
+    end
+
+    color = SEVERITY_COLOR[color] if Integer === color
+    color = CONCEPT_COLORS[color] if CONCEPT_COLORS.include?(color)
+    color = Term::ANSIColor.send(color) if Symbol === color and Term::ANSIColor.respond_to?(color)
+
+    str = str.to_s unless str.nil?
+    return str if Symbol === color
+    color_str = reset ? Term::ANSIColor.reset : ""
+    color_str << color
+    if str.nil?
+      color_str
+    else
+      color_str + str.to_s + Term::ANSIColor.reset
+    end
+  end
+
+  def self.highlight(str = nil)
+    if str.nil?
+      return "" if nocolor
+      HIGHLIGHT
+    else
+      return str if nocolor
+      HIGHLIGHT + str + color(0)
+    end
+  end
+
+end

data/lib/scout/log/color_class.rb

@@ -0,0 +1,269 @@
+# Copyright (c) 2007 McClain Looney
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+
+# Implements a color (r,g,b + a) with conversion to/from web format (eg #aabbcc), and
+# with a number of utilities to lighten, darken and blend values.
+class Color
+
+  attr_reader :r, :g, :b, :a
+
+  # Table for conversion to hex
+  HEXVAL = (('0'..'9').to_a).concat(('A'..'F').to_a).freeze
+  # Default value for #darken, #lighten etc.
+  BRIGHTNESS_DEFAULT = 0.2
+
+  SOLARIZED = {
+    :base03 =>     '#002b36',
+    :base02 =>     '#073642',
+    :base01 =>     '#586e75',
+    :base00 =>     '#657b83',
+    :base0 =>      '#839496',
+    :base1 =>      '#93a1a1',
+    :base2 =>      '#eee8d5',
+    :base3 =>      '#fdf6e3',
+    :yellow =>     '#b58900',
+    :orange =>     '#cb4b16',
+    :red =>        '#dc322f',
+    :magenta =>    '#d33682',
+    :violet =>     '#6c71c4',
+    :blue =>       '#268bd2',
+    :cyan =>       '#2aa198',
+    :green =>      '#859900',
+  }
+
+  # Constructor.  Inits to white (#FFFFFF) by default, or accepts any params
+  # supported by #parse.
+  def initialize(*args)
+    @r = 255
+    @g = 255
+    @b = 255
+    @a = 255
+
+    if args.size.between?(3,4)
+      self.r = args[0]
+      self.g = args[1]
+      self.b = args[2]
+      self.a = args[3] if args[3]
+    else
+      set(*args)
+    end
+  end
+
+  # All-purpose setter - pass in another Color, '#000000', rgb vals... whatever
+  def set(*args)
+    val = Color.parse(*args)
+    unless val.nil?
+      self.r = val.r
+      self.g = val.g
+      self.b = val.b
+      self.a = val.a
+    end
+    self
+  end
+
+  # Test for equality, accepts string vals as well, eg Color.new('aaa') == '#AAAAAA' => true
+  def ==(val)
+    val = Color.parse(val)
+    return false if val.nil?
+    return r == val.r && g == val.g && b == val.b && a == val.a
+  end
+
+  # Setters for individual channels - take 0-255 or '00'-'FF' values
+  def r=(val); @r = from_hex(val); end
+  def g=(val); @g = from_hex(val); end
+  def b=(val); @b = from_hex(val); end
+  def a=(val); @a = from_hex(val); end
+
+  # Attempt to read in a string and parse it into values
+  def self.parse(*args)
+    case args.size
+
+    when 0 then
+      return nil
+
+    when 1 then
+      val = args[0]
+
+      # Trivial parse... :-)
+      return val if val.is_a?(Color)
+
+      # Single value, assume grayscale
+      return Color.new(val, val, val) if val.is_a?(Numeric)
+
+      # Assume string
+      str = val.to_s.upcase
+      str = str[/[0-9A-F]{3,8}/] || ''
+      case str.size
+      when 3, 4 then
+        r, g, b, a = str.scan(/[0-9A-F]/)
+      when 6,8 then
+        r, g, b, a = str.scan(/[0-9A-F]{2}/)
+      else
+        return nil
+      end
+
+      return Color.new(r,g,b,a || 255)
+
+    when 3,4 then
+      return Color.new(*args)
+
+    end
+    nil
+  end
+
+  def inspect
+    to_s(true)
+  end
+
+  def to_s(add_hash = true)
+    trans? ? to_rgba(add_hash) : to_rgb(add_hash)
+  end
+
+  def to_rgb(add_hash = true)
+    (add_hash ? '#' : '') + to_hex(r) + to_hex(g) + to_hex(b)
+  end
+
+  def to_rgba(add_hash = true)
+    to_rgb(add_hash) + to_hex(a)
+  end
+
+  def opaque?
+    @a == 255
+  end
+
+  def trans?
+    @a != 255
+  end
+
+  def grayscale?
+    @r == @g && @g == @b
+  end
+
+  # Lighten color towards white.  0.0 is a no-op, 1.0 will return #FFFFFF
+  def lighten(amt = BRIGHTNESS_DEFAULT)
+    return self if amt <= 0
+    return WHITE if amt >= 1.0
+    val = Color.new(self)
+    val.r += ((255-val.r) * amt).to_i
+    val.g += ((255-val.g) * amt).to_i
+    val.b += ((255-val.b) * amt).to_i
+    val
+  end
+
+  # In place version of #lighten
+  def lighten!(amt = BRIGHTNESS_DEFAULT)
+    set(lighten(amt))
+    self
+  end
+
+  # Darken a color towards full black.  0.0 is a no-op, 1.0 will return #000000
+  def darken(amt = BRIGHTNESS_DEFAULT)
+    return self if amt <= 0
+    return BLACK if amt >= 1.0
+    val = Color.new(self)
+    val.r -= (val.r * amt).to_i
+    val.g -= (val.g * amt).to_i
+    val.b -= (val.b * amt).to_i
+    val
+  end
+
+  # In place version of #darken
+  def darken!(amt = BRIGHTNESS_DEFAULT)
+    set(darken(amt))
+    self
+  end
+
+  # Convert to grayscale, using perception-based weighting
+  def grayscale
+    val = Color.new(self)
+    val.r = val.g = val.b = (0.2126 * val.r + 0.7152 * val.g + 0.0722 * val.b)
+    val
+  end
+
+  # In place version of #grayscale
+  def grayscale!
+    set(grayscale)
+    self
+  end
+
+  # Blend to a color amt % towards another color value, eg
+  # red.blend(blue, 0.5) will be purple, white.blend(black, 0.5) will be gray, etc.
+  def blend(other, amt)
+    other = Color.parse(other)
+    return Color.new(self) if amt <= 0 || other.nil?
+    return Color.new(other) if amt >= 1.0
+    val = Color.new(self)
+    val.r += ((other.r - val.r)*amt).to_i
+    val.g += ((other.g - val.g)*amt).to_i
+    val.b += ((other.b - val.b)*amt).to_i
+    val
+  end
+
+  # In place version of #blend
+  def blend!(other, amt)
+    set(blend(other, amt))
+    self
+  end
+
+  # Class-level version for explicit blends of two values, useful with constants
+  def self.blend(col1, col2, amt)
+    col1 = Color.parse(col1)
+    col2 = Color.parse(col2)
+    col1.blend(col2, amt)
+  end
+
+  protected
+
+  # Convert int to string hex, eg 255 => 'FF'
+  def to_hex(val)
+    HEXVAL[val / 16] + HEXVAL[val % 16]
+  end
+
+  # Convert int or string to int, eg 80 => 80, 'FF' => 255, '7' => 119
+  def from_hex(val)
+    if val.is_a?(String)
+      # Double up if single char form
+      val = val + val if val.size == 1
+      # Convert to integer
+      val = val.hex
+    end
+    # Clamp
+    val = 0 if val < 0
+    val = 255 if val > 255
+    val
+  end
+
+  public
+
+  # Some constants for general use
+  WHITE = Color.new(255,255,255).freeze
+  BLACK = Color.new(0,0,0).freeze
+
+end
+
+# "Global" method for creating Color objects, eg:
+#   new_color = rgb(params[:new_color])
+#   style="border: 1px solid <%= rgb(10,50,80).lighten %>"
+def rgb(*args)
+  Color.parse(*args)
+end
+
+

data/lib/scout/log/fingerprint.rb

@@ -0,0 +1,69 @@
+require 'digest/md5'
+module Log
+  def self.fingerprint(obj)
+    return obj.fingerprint if obj.respond_to?(:fingerprint)
+
+    case obj
+    when nil
+      "nil"
+    when TrueClass
+      "true"
+    when FalseClass
+      "false"
+    when Symbol
+      ":" << obj.to_s
+    when String
+      if obj.length > 100
+        digest = Digest::MD5.hexdigest(obj)
+        "'" << obj.slice(0,30) << "<...#{obj.length} - #{digest[0..4]}...>" << obj.slice(-10,30)<< "'"
+      else 
+        "'" << obj << "'"
+      end
+    when ConcurrentStream
+      name = obj.inspect + " " + obj.object_id.to_s
+      name += " #{obj.filename}" if obj.filename
+      name
+    when IO
+      (obj.respond_to?(:filename) and obj.filename ) ? "<IO:" + (obj.filename || obj.inspect + rand(100000)) + ">" : obj.inspect + " " + obj.object_id.to_s
+    when File
+      "<File:" + obj.path + ">"
+    when Array
+      if (length = obj.length) > 10
+        "[#{length}--" <<  (obj.values_at(0,1, length / 2, -2, -1).collect{|e| fingerprint(e)} * ",") << "]"
+      else
+        "[" << (obj.collect{|e| fingerprint(e) } * ", ") << "]"
+      end
+    when Hash
+      if obj.length > 10
+        "H:{"<< fingerprint(obj.keys) << ";" << fingerprint(obj.values) << "}"
+      else
+        new = "{"
+        obj.each do |k,v|
+          new << fingerprint(k) << '=>' << fingerprint(v) << ' '
+        end
+        if new.length > 1
+           new[-1] =  "}"
+        else
+          new << '}'
+        end
+        new
+      end
+    when Float
+      if obj.abs > 10
+        "%.1f" % obj
+      elsif obj.abs > 1
+        "%.3f" % obj
+      else
+        "%.6f" % obj
+      end
+    when Thread
+      if obj["name"]
+        obj["name"]
+      else
+        obj.inspect
+      end
+    else
+      obj.to_s
+    end
+  end
+end