scout-gear 1.1.0

data/lib/scout/log/color.rb

@@ -0,0 +1,169 @@
+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({green: "#00cd00" , red: "#cd0000" , yellow: "#ffd700" })
+  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
+    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| n = 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["RBBT_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}"}
+  HIGHLIGHT = "\033[1m"
+
+  def self.uncolor(str)
+    "" << Term::ANSIColor.uncolor(str)
+  end
+
+  def self.reset_color
+    reset
+  end
+
+  def self.color(severity, str = nil, reset = false)
+    return str.dup || "" if nocolor 
+    color = reset ? Term::ANSIColor.reset : ""
+    color << SEVERITY_COLOR[severity] if Integer === severity
+    color << Term::ANSIColor.send(severity) if Symbol === severity and Term::ANSIColor.respond_to? severity 
+    if str.nil?
+      color
+    else
+      color + str.to_s + self.color(0)
+    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,59 @@
+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 IO
+      (obj.respond_to?(:filename) and obj.filename ) ? "<IO:" + (obj.filename || obj.inspect + rand(100000)) + ">" : obj.inspect
+    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
+    else
+      obj.to_s
+    end
+  end
+end