scout-gear 9.1.0 → 10.0.1

data/lib/scout/log/color.rb

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

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

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