scout-essentials 1.0.0

data/lib/scout/log.rb

@@ -0,0 +1,441 @@
+require_relative 'log/color'
+require_relative 'log/fingerprint'
+require_relative 'log/progress'
+require_relative 'log/trap'
+
+require 'io/console'
+
+module Log
+  class << self
+    attr_accessor :severity
+    attr_writer :tty_size, :logfile
+  end
+
+  SEVERITY_NAMES ||= begin
+                       names = %w(DEBUG LOW MEDIUM HIGH INFO WARN ERROR NONE )
+                       names.each_with_index do |name,i|
+                         eval "#{ name } = #{ i }"
+                       end
+                       names
+                     end
+  def self.default_severity
+    @@default_severity ||= begin
+                             file = File.join(ENV["HOME"], '.scout/etc/log_severity')
+                             if File.exist? file
+                               File.open(file) do |f|
+                                 SEVERITY_NAMES.index f.read.strip
+                               end
+                             else
+                               INFO
+                             end
+                           end
+    @@default_severity
+  end
+
+  case ENV['SCOUT_LOG']
+  when 'DEBUG'
+    self.severity = DEBUG
+  when 'LOW'
+    self.severity = LOW
+  when 'MEDIUM'
+    self.severity = MEDIUM
+  when 'HIGH'
+    self.severity = HIGH
+  when nil
+    self.severity = default_severity
+  else
+    self.severity = default_severity
+  end
+
+
+
+  def self.tty_size
+    @@tty_size ||= Log.ignore_stderr do
+      size = begin
+               IO.console.winsize.last
+             rescue Exception
+               begin
+                 res = `tput li`
+                 res = nil if res == ""
+                 res || ENV["TTY_SIZE"] || 80
+               rescue Exception
+                 ENV["TTY_SIZE"] || 80
+               end
+             end
+      size = size.to_i if String === size
+      size
+    end
+  end
+
+
+  def self.last_caller(stack)
+    line = nil
+    pos ||= 0
+    while line.nil? or line =~ /scout\/log\.rb/ and stack.any?
+      line = stack.shift
+    end
+    line ||= caller.first
+    line.gsub('`', "'")
+  end
+
+  def self.get_level(level)
+    case level
+    when Numeric
+      level.to_i
+    when String
+      begin
+        Log.const_get(level.upcase)
+      rescue
+        Log.exception $!
+      end
+    when Symbol
+      get_level(level.to_s)
+    end || 0
+  end
+
+  def self.with_severity(level)
+    orig = Log.severity
+    begin
+      Log.severity = level
+      yield
+    ensure
+      Log.severity = orig
+    end
+  end
+
+  def self.logfile(file=nil)
+    if file.nil?
+      @logfile ||= nil
+    else
+      case file
+      when String
+        @logfile = File.open(file, :mode => 'a')
+        @logfile.sync = true
+      when IO, File
+        @logfile = file
+      else
+        raise "Unkown logfile format: #{file.inspect}"
+      end
+    end
+  end
+
+  def self.up_lines(num = 1)
+    nocolor ? "" : "\033[#{num+1}F\033[2K"
+  end
+
+  def self.down_lines(num = 1)
+    nocolor ? "" : "\033[#{num+1}E"
+  end
+
+  def self.return_line
+    nocolor ? "" : "\033[1A"
+  end
+
+  def self.clear_line(out = STDOUT)
+    out.puts Log.return_line << " " * (Log.tty_size || 80) << Log.return_line unless nocolor
+  end
+
+  MUTEX = Mutex.new
+  def self.log_write(str)
+    MUTEX.synchronize do
+      if logfile.nil?
+        begin
+          STDERR.write str
+        rescue
+        end
+      else
+        logfile.write str
+      end
+    end
+  end
+
+  def self.log_puts(str)
+    MUTEX.synchronize do
+      if logfile.nil?
+        begin
+          STDERR.puts str
+        rescue
+        end
+      else
+        logfile.puts str
+      end
+    end
+  end
+
+  LAST = "log"
+  def self.logn(message = nil, severity = MEDIUM, &block)
+    return if severity < self.severity
+    message ||= block.call if block_given?
+    return if message.nil?
+
+    time = Time.now.strftime("%m/%d/%y-%H:%M:%S.%L")
+
+    sev_str = severity.to_s
+
+    if ENV["SCOUT_DEBUG_PID"] == "true"
+      prefix = time << "["  << Process.pid.to_s << "]" << color(severity) << "["  << sev_str << "]" << color(0)
+    else
+      prefix = time << color(severity) << "["  << sev_str << "]" << color(0)
+    end
+    message = "" << highlight << message << color(0) if severity >= INFO
+    str = prefix << " " << message.to_s
+
+    log_write str
+
+    Log::LAST.replace "log"
+    nil
+  end
+
+  def self.log(message = nil, severity = MEDIUM, &block)
+    return if severity < self.severity
+    message ||= block.call if block_given?
+    return if message.nil?
+    message = message + "\n" unless message[-1] == "\n"
+    self.logn message, severity, &block
+  end
+
+  def self.log_obj_inspect(obj, level, file = $stdout)
+    stack = caller
+
+    line = Log.last_caller stack
+
+    level = Log.get_level level
+    name = Log::SEVERITY_NAMES[level] + ": "
+    Log.log Log.color(level, name, true) << line, level
+    Log.log "", level
+    Log.log Log.color(level, "=> ", true) << obj.inspect, level
+    Log.log "", level
+  end
+
+  def self.log_obj_fingerprint(obj, level, file = $stdout)
+    stack = caller
+
+    line = Log.last_caller stack
+
+    level = Log.get_level level
+    name = Log::SEVERITY_NAMES[level] + ": "
+    Log.log Log.color(level, name, true) << line, level
+    Log.log "", level
+    Log.log Log.color(level, "=> ", true) << Log.fingerprint(obj), level
+    Log.log "", level
+  end
+
+  def self.debug(message = nil, &block)
+    log(message, DEBUG, &block)
+  end
+
+  def self.low(message = nil, &block)
+    log(message, LOW, &block)
+  end
+
+  def self.medium(message = nil, &block)
+    log(message, MEDIUM, &block)
+  end
+
+  def self.high(message = nil, &block)
+    log(message, HIGH, &block)
+  end
+
+  def self.info(message = nil, &block)
+    log(message, INFO, &block)
+  end
+
+  def self.warn(message = nil, &block)
+    log(message, WARN, &block)
+  end
+
+  def self.error(message = nil, &block)
+    log(message, ERROR, &block)
+  end
+
+  def self.exception(e)
+    stack = caller
+    backtrace = e.backtrace || []
+    if ENV["SCOUT_ORIGINAL_STACK"] == 'true'
+      error([e.class.to_s, e.message].compact * ": " )
+      error("BACKTRACE [#{Process.pid}]: " << Log.last_caller(stack) << "\n" + color_stack(backtrace)*"\n")
+    else
+      error("BACKTRACE [#{Process.pid}]: " << Log.last_caller(stack) << "\n" + color_stack(backtrace.reverse)*"\n")
+      error([e.class.to_s, e.message].compact * ": " )
+    end
+  end
+
+  def self.deprecated(m)
+    stack = caller
+    warn("DEPRECATED: " << Log.last_caller(stack))
+    warn("* " << (m || "").to_s)
+  end
+
+  def self.color_stack(stack)
+    stack.collect do |line|
+      line = line.sub('`',"'")
+      color = :green if line =~ /workflow/
+      color = :blue if line =~ /scout-/
+      color = :cyan if line =~ /rbbt-/
+      if color
+        Log.color color, line
+      else
+        line
+      end
+    end unless stack.nil?
+  end
+
+  def self.tsv(tsv, example = false)
+    log_puts Log.color :magenta, "TSV log: " << Log.last_caller(caller).gsub('`',"'")
+    log_puts Log.color(:blue, "=> "<< Log.fingerprint(tsv), true)
+    log_puts Log.color(:cyan, "=> " << tsv.summary)
+    if example && ! tsv.empty?
+      key = case example
+            when TrueClass, :first, "first"
+              tsv.keys.first
+            when :random, "random"
+              tsv.keys.shuffle.first
+            else
+              example
+            end
+
+      values = tsv[key]
+      values = [values] if tsv.type == :flat || tsv.type == :single
+      if values.nil?
+        log_puts Log.color(:blue, "Key (#{tsv.key_field}) not present: ") + key
+      else
+        log_puts Log.color(:blue, "Key (#{tsv.key_field}): ") + key
+        tsv.fields.zip(values).each do |field,value|
+          log_puts Log.color(:magenta, field + ": ") + (Array === value ? value * ", " : value.to_s)
+        end
+      end
+    end
+  end
+
+  def self.stack(stack)
+    if ENV["SCOUT_ORIGINAL_STACK"] == 'true'
+      log_puts Log.color :magenta, "Stack trace [#{Process.pid}]: " << Log.last_caller(caller)
+      color_stack(stack).each do |line|
+        log_puts line
+      end
+    else
+      log_puts Log.color :magenta, "Stack trace [#{Process.pid}]: " << Log.last_caller(caller)
+      color_stack(stack.reverse).each do |line|
+        log_puts line
+      end
+    end
+  end
+
+  def self.count_stack
+    if ! $count_stacks
+      Log.debug "Counting stacks at: " << caller.first
+      return
+    end
+    $stack_counts ||= {}
+    head = $count_stacks_head
+    stack = caller[1..head+1]
+    stack.reverse.each do |line,i|
+      $stack_counts[line] ||= 0
+      $stack_counts[line] += 1
+    end
+  end
+
+  def self.with_stack_counts(head = 10, total = 100)
+    $count_stacks_head = head
+    $count_stacks = true
+    $stack_counts = {}
+    res = yield
+    $count_stacks = false
+    Log.debug "STACK_COUNTS:\n" + $stack_counts.sort_by{|line,c| c}.reverse.collect{|line,c| [c, line] * " - "}[0..total] * "\n"
+    $stack_counts = {}
+    res
+  end
+end
+
+def ppp(message)
+  stack = caller
+  puts "#{Log.color :cyan, "PRINT:"} " << stack.first
+  puts ""
+  if message.length > 200 or message.include? "\n"
+    puts Log.color(:cyan, "=>|") << "\n" << message.to_s
+  else
+    puts Log.color(:cyan, "=> ") << message.to_s
+  end
+  puts ""
+end
+
+def fff(object)
+  stack = caller
+  Log.debug{"#{Log.color :cyan, "FINGERPRINT:"} " << stack.first}
+  Log.debug{""}
+  Log.debug{require 'scout/util/misc'; "=> " << Log.fingerprint(object) }
+  Log.debug{""}
+end
+
+def ddd(obj, file = $stdout)
+  Log.log_obj_inspect(obj, :debug, file)
+end
+
+def lll(obj, file = $stdout)
+  Log.log_obj_inspect(obj, :low, file)
+end
+
+def mmm(obj, file = $stdout)
+  Log.log_obj_inspect(obj, :medium, file)
+end
+
+def iii(obj=nil, file = $stdout)
+  Log.log_obj_inspect(obj, :info, file)
+end
+
+def wwww(obj=nil, file = $stdout)
+  Log.log_obj_inspect(obj, :warn, file)
+end
+
+def eee(obj=nil, file = $stdout)
+  Log.log_obj_inspect(obj, :error, file)
+end
+
+def ddf(obj=nil, file = $stdout)
+  Log.log_obj_fingerprint(obj, :debug, file)
+end
+
+def llf(obj=nil, file = $stdout)
+  Log.log_obj_fingerprint(obj, :low, file)
+end
+
+def mmf(obj=nil, file = $stdout)
+  Log.log_obj_fingerprint(obj, :medium, file)
+end
+
+def iif(obj=nil, file = $stdout)
+  Log.log_obj_fingerprint(obj, :info, file)
+end
+
+def wwwf(obj=nil, file = $stdout)
+  Log.log_obj_fingerprint(obj, :warn, file)
+end
+
+def eef(obj=nil, file = $stdout)
+  Log.log_obj_fingerprint(obj, :error, file)
+end
+
+def sss(level, &block)
+  if block_given?
+    Log.with_severity level, &block
+  else
+    Log.severity = level
+  end
+end
+
+$scout_debug_log = false
+def ccc(obj=nil, file = $stdout)
+  if block_given?
+    old_scout_debug_log = $scout_debug_log
+    $scout_debug_log = 'true'
+    begin
+      yield
+    ensure
+      $scout_debug_log = old_scout_debug_log
+    end
+  else
+    Log.log_obj_inspect(obj, :info, file) if $scout_debug_log
+  end
+end
+
+

data/lib/scout/meta_extension.rb

@@ -0,0 +1,100 @@
+module MetaExtension
+  def self.extended(base)
+    meta = class << base; self; end
+
+    base.class_variable_set("@@extension_attrs", []) unless base.class_variables.include?("@@extension_attrs")
+
+    meta.define_method(:extension_attr) do |*attrs|
+      self.class_variable_get("@@extension_attrs").concat attrs
+      attrs.each do |a|
+        self.attr_accessor a
+      end
+    end
+
+    meta.define_method(:extended) do |obj|
+      attrs = self.class_variable_get("@@extension_attrs")
+
+      obj.instance_variable_set(:@extension_attrs, []) unless obj.instance_variables.include?(:@extension_attrs)
+      extension_attrs = obj.instance_variable_get(:@extension_attrs)
+      extension_attrs.concat attrs
+    end
+
+    meta.define_method(:setup) do |*args,&block|
+      if block_given?
+        obj, rest = block, args
+      else
+        obj, *rest = args
+      end
+      obj = block if obj.nil?
+      obj.extend base unless base === obj
+
+      attrs = self.class_variable_get("@@extension_attrs")
+
+      return if attrs.nil? || attrs.empty?
+
+      if rest.length == 1 && Hash === (rlast = rest.last) && 
+          ((! (rlkey = rlast.keys.first).nil? && attrs.include?(rlkey.to_sym)) ||
+           (! attrs.length != 1 ))
+
+        pairs = rlast
+      else
+        pairs = attrs.zip(rest)
+      end
+
+      pairs.each do |name,value|
+        obj.instance_variable_set("@#{name}", value)
+      end
+
+      obj
+    end
+
+    base.define_method(:extension_attr_hash) do 
+      attr_hash = {}
+      @extension_attrs.each do |name|
+        attr_hash[name] = self.instance_variable_get("@#{name}")
+      end
+      attr_hash
+    end
+
+    base.define_method(:annotate) do |other|
+      attr_values = @extension_attrs.collect do |a|
+        self.instance_variable_get("@#{a}")
+      end
+      base.setup(other, *attr_values)
+    end
+
+    base.define_method(:purge) do
+      new = self.dup
+
+      if new.instance_variables.include?(:@extension_attrs)
+        new.instance_variable_get(:@extension_attrs).each do |a|
+          new.remove_instance_variable("@#{a}")
+        end
+        new.remove_instance_variable("@extension_attrs")
+      end
+
+      new
+    end
+  end
+
+  def self.is_extended?(obj)
+    obj.respond_to?(:extension_attr_hash)
+  end
+
+  def self.purge(obj)
+    case obj
+    when nil
+      nil
+    when Array
+      obj.collect{|e| purge(e) }
+    when Hash
+      new = {}
+      obj.each do |k,v|
+        new[k] = purge(v)
+      end
+      new
+    else
+      is_extended?(obj) ? obj.purge : obj
+    end
+  end
+end

data/lib/scout/misc/digest.rb

@@ -0,0 +1,63 @@
+module Misc
+  MAX_ARRAY_DIGEST_LENGTH = 100_000
+  def self.digest_str(obj)
+    if obj.respond_to?(:digest_str)
+      obj.digest_str
+    else
+      case obj
+      when String
+        #'\'' << obj << '\''
+        if Path === obj || ! Open.exists?(obj)
+          '\'' << obj << '\''
+        else
+          "File MD5: #{Misc.file_md5(obj)}"
+        end
+      when Integer, Symbol
+        obj.to_s
+      when Array
+        if obj.length > MAX_ARRAY_DIGEST_LENGTH
+          length = obj.length
+          mid = length/2
+          sample_pos = [1, 2, mid, length-2, length-1]
+          "[#{length}:" << obj.values_at(*sample_pos).inject(""){|acc,o| acc.empty? ? Misc.digest_str(o) : acc << ', ' << Misc.digest_str(o) } << ']'
+        else
+          '[' << obj.inject(""){|acc,o| acc.empty? ? Misc.digest_str(o) : acc << ', ' << Misc.digest_str(o) } << ']'
+        end
+      when Hash
+        '{' << obj.inject(""){|acc,p| s = Misc.digest_str(p.first) << "=" << Misc.digest_str(p.last); acc.empty? ? s : acc << ', ' << s } << '}'
+      when Integer
+        obj.to_s
+      when Float
+        if obj % 1 == 0
+          obj.to_i.to_s
+        elsif obj.abs > 10
+          "%.1f" % obj
+        elsif obj.abs > 1
+          "%.3f" % obj
+        else
+          "%.6f" % obj
+        end
+      when TrueClass
+        "true"
+      when FalseClass
+        "false"
+      else
+        obj.inspect
+      end
+    end
+  end
+
+  def self.digest(obj)
+    str = String === obj ? obj : Misc.digest_str(obj)
+    Digest::MD5.hexdigest(str)
+  end
+
+  def self.file_md5(file)
+    file = file.find if Path === file
+    file = File.expand_path(file)
+    #md5file = file + '.md5'
+    Persist.persist("MD5:#{file}", :string) do
+      Digest::MD5.file(file).hexdigest
+    end
+  end
+end

data/lib/scout/misc/filesystem.rb

@@ -0,0 +1,25 @@
+module Misc
+  def self.in_dir(dir)
+    old_pwd = FileUtils.pwd
+    begin
+      FileUtils.mkdir_p dir unless File.exist?(dir)
+      FileUtils.cd dir
+      yield
+    ensure
+      FileUtils.cd old_pwd
+    end
+  end
+
+  def self.path_relative_to(basedir, path)
+    path = File.expand_path(path) unless path.slice(0,1) == "/"
+    basedir = File.expand_path(basedir) unless basedir.slice(0,1) == "/"
+
+    basedir += "/" unless basedir.slice(-2,-1) == "/"
+
+    if path.start_with?(basedir)
+      return path.slice(basedir.length, basedir.length)
+    else
+      return nil
+    end
+  end
+end