scout-gear 1.1.0

data/lib/scout/log.rb

@@ -0,0 +1,362 @@
+require_relative 'log/color'
+require_relative 'log/fingerprint'
+require_relative 'log/progress'
+
+require 'io/console'
+
+module Log
+  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
+
+  class << self
+    attr_accessor :logfile, :severity
+    attr_writer :tty_size
+  end
+
+
+  def self.tty_size
+    @tty_size = begin
+                  IO.console.winsize.last
+                rescue
+                  begin
+                    `tput li`
+                  rescue
+                    80
+                  end
+                end
+  end
+
+
+  def self.last_caller(stack)
+    line = nil
+    pos ||= 0
+    while line.nil? or line =~ /scout\/helper\/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
+
+  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
+
+    prefix = time << color(severity) << "["  << sev_str << "]" << color(0)
+    message = "" << highlight << message << color(0) if severity >= INFO
+    str = prefix << " " << message.to_s
+
+    if logfile.nil?
+      STDERR.write str
+    else
+      logfile.write str 
+    end
+    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
+    if ENV["RBBT_ORIGINAL_STACK"] == 'true'
+      error([e.class.to_s, e.message].compact * ": " )
+      error("BACKTRACE [#{Process.pid}]: " << Log.last_caller(stack) << "\n" + color_stack(e.backtrace)*"\n")
+    else
+      error("BACKTRACE [#{Process.pid}]: " << Log.last_caller(stack) << "\n" + color_stack(e.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-/
+      Log.color color, line
+    end unless stack.nil?
+  end
+
+  def self.tsv(tsv, example = false)
+    STDERR.puts Log.color :magenta, "TSV log: " << Log.last_caller(caller).gsub('`',"'")
+    STDERR.puts Log.color(:blue, "=> "<< Log.fingerprint(tsv), true) 
+    STDERR.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?
+        STDERR.puts Log.color(:blue, "Key (#{tsv.key_field}) not present: ") + key
+      else
+        STDERR.puts Log.color(:blue, "Key (#{tsv.key_field}): ") + key
+        tsv.fields.zip(values).each do |field,value|
+          STDERR.puts Log.color(:magenta, field + ": ") + (Array === value ? value * ", " : value.to_s)
+        end
+      end
+    end
+  end
+
+  def self.stack(stack)
+    if ENV["RBBT_ORIGINAL_STACK"] == 'true'
+      STDERR.puts Log.color :magenta, "Stack trace [#{Process.pid}]: " << Log.last_caller(caller)
+      color_stack(stack).each do |line|
+        STDERR.puts line
+      end
+    else
+      STDERR.puts Log.color :magenta, "Stack trace [#{Process.pid}]: " << Log.last_caller(caller)
+      color_stack(stack.reverse).each do |line|
+        STDERR.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
+
+  case ENV['RBBT_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 = INFO
+  else
+    self.severity = ENV['RBBT_LOG'].to_i
+  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
+

data/lib/scout/meta_extension.rb

@@ -0,0 +1,29 @@
+module MetaExtension
+  def self.extended(base)
+    meta = class << base; self; end
+
+    base.class_variable_set("@@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(:setup) do |obj,*rest|
+      obj.extend base
+      self.class_variable_get("@@extension_attrs").zip(rest).each do |name,value|
+        obj.instance_variable_set("@#{name}", value)
+      end
+      obj
+    end
+
+    base.define_method(:annotate) do |other|
+      attr_values = meta.class_variable_get("@@extension_attrs").collect do |a|
+        self.instance_variable_get("@#{a}")
+      end
+      base.setup(other, *attr_values)
+    end
+  end
+end

data/lib/scout/path/find.rb

@@ -0,0 +1,65 @@
+module Path
+  def _parts
+    @_parts ||= self.split("/")
+  end
+
+  def _subpath
+    @subpath ||= _parts.length > 1 ? _parts[1..-1] * "/" : _parts[0]
+  end
+  
+  def _toplevel
+    @toplevel ||= _parts.length > 1 ? _parts[0] : nil
+  end
+
+  def self.follow(path, map)
+    map.sub('{PKGDIR}', path.pkgdir).
+      sub('{RESOURCE}', path.to_s).
+      sub('{PWD}', FileUtils.pwd).
+      sub('{TOPLEVEL}', path._toplevel).
+      sub('{SUBPATH}', path._subpath).
+      sub('{BASENAME}', File.basename(path)).
+      sub('{PATH}', path).
+      sub('{LIBDIR}', path.libdir).
+      sub('{REMOVE}/', '').
+      sub('{REMOVE}', '').gsub(/\/+/,'/')
+  end
+
+  PATH_MAPS = IndiferentHash.setup({
+    :current => File.join("{PWD}", "{TOPLEVEL}", "{SUBPATH}"),
+    :user    => File.join(ENV['HOME'], ".{PKGDIR}", "{TOPLEVEL}", "{SUBPATH}"),
+    :global  => File.join('/', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+    :usr   => File.join('/usr/', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+    :local   => File.join('/usr/local', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+    :fast   => File.join('/fast', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+    :cache   => File.join('/cache', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+    :bulk   => File.join('/bulk', "{TOPLEVEL}", "{PKGDIR}", "{SUBPATH}"),
+    :lib     => File.join('{LIBDIR}', "{TOPLEVEL}", "{SUBPATH}"),
+    :base   => File.join(Path.caller_lib_dir(__FILE__), "{TOPLEVEL}", "{SUBPATH}"),
+    :default => :user
+  })
+
+  MAP_SEARCH = %w(current workflow user local global lib fast cache bulk)
+
+  def _follow(map_name)
+    map = PATH_MAPS[map_name]
+    while Symbol === map
+      map = PATH_MAPS[map]
+    end
+    Path.follow(self, map)
+  end
+
+  def find(where = nil)
+    return _follow(where) if where
+
+    all_maps = PATH_MAPS.keys
+    search_order = MAP_SEARCH & all_maps + (all_maps - MAP_SEARCH)
+
+    search_order.each do |name|
+      map = PATH_MAPS[name]
+      real_path = _follow(map)
+      return real_path if File.exists?(real_path)
+    end
+
+    return _follow(:default)
+  end
+end

data/lib/scout/path.rb

@@ -0,0 +1,62 @@
+require_relative 'meta_extension'
+
+module Path
+  extend MetaExtension
+  extension_attr :pkgdir, :libdir
+
+  def self.caller_lib_dir(file = nil, relative_to = ['lib', 'bin'])
+    
+    if file.nil?
+      caller_dup = caller.dup
+      while file = caller_dup.shift
+        break unless file =~ /scout\/(?:resource\.rb|workflow\.rb)/ or
+          file =~ /scout\/path\.rb/ or
+          file =~ /scout\/persist.rb/
+      end
+      file = file.sub(/\.rb[^\w].*/,'.rb')
+    end
+
+    relative_to = [relative_to] unless Array === relative_to
+    file = File.expand_path(file)
+    return Path.setup(file) if relative_to.select{|d| File.exist? File.join(file, d)}.any?
+
+    while file != '/'
+      dir = File.dirname file
+
+      return dir if relative_to.select{|d| File.exist? File.join(dir, d)}.any?
+
+      file = File.dirname file
+    end
+
+    return nil
+  end
+
+  def self.setup(path, pkgdir = 'scout', libdir = nil)
+    path.extend Path
+    path.pkgdir = pkgdir
+    path.libdir = libdir || Path.caller_lib_dir
+    path
+  end
+
+  def join(subpath, prevpath = nil)
+    subpath = subpath.to_s if Symbol === subpath
+    prevpath = prevpath.to_s if Symbol === prevpath
+
+    subpath = File.join(prevpath.to_s, subpath) if prevpath
+    new = File.join(self, subpath)
+    self.annotate(new)
+    new
+  end
+
+  alias [] join
+  alias / join
+
+  def method_missing(name, prev = nil, *args, &block)
+    if block_given? || name.to_s.start_with?('to_')
+      super name, prev, *args, &block
+    else
+      join(name, prev)
+    end
+  end
+
+end

data/lib/scout/tmpfile.rb

@@ -0,0 +1,96 @@
+require 'fileutils'
+
+module TmpFile
+  def self.user_tmp(subdir = nil)
+    if subdir
+      File.join(ENV["HOME"],"/tmp/scout", subdir)
+    else
+      File.join(ENV["HOME"],"/tmp/scout")
+    end
+  end
+
+  def self.tmpdir=(tmpdir)
+    @tmpdir = tmpdir
+  end
+
+  def self.tmpdir
+    @tmpdir ||= self.user_tmp('tmpfiles')
+  end
+
+  # Creates a random file name, with the given suffix and a random number
+  # up to +max+
+  def self.random_name(prefix = 'tmp-', max = 1_000_000_000)
+    n = rand(max)
+    prefix + n.to_s
+  end
+
+  # Creates a random filename in the temporary directory
+  def self.tmp_file(prefix = 'tmp-', max = 1_000_000_000, dir = nil)
+    dir ||= TmpFile.tmpdir
+    File.expand_path(File.join(dir, random_name(prefix, max)))
+  end
+
+  def self.with_file(content = nil, erase = true, options = {})
+    if content.is_a?(Hash)
+      options = content
+      content = nil
+      erase = true
+    end
+    if erase.is_a?(Hash)
+      options = erase
+      erase = true
+    end
+
+    prefix = options[:prefix] || 'tmp-'
+    tmpdir = options[:tmpdir] || TmpFile.tmpdir
+    max = options[:max] || 1_000_000_000
+    tmpfile = tmp_file prefix, max, tmpdir
+    tmpfile += ".#{options[:extension]}" if options[:extension]
+
+    FileUtils.mkdir_p tmpdir
+    if IO === content
+      File.open(tmpfile, 'wb') do |f|
+        begin
+          while c = content.readpartial(1024)
+            f << c
+          end
+        rescue EOFError
+        end
+      end
+    elsif !content.nil?
+      File.open(tmpfile, 'w') { |f| f.write content }
+    end
+
+    result = yield(tmpfile)
+
+    FileUtils.rm_rf tmpfile if File.exist?(tmpfile) && erase
+
+    result
+  end
+
+  def self.with_dir(erase = true, options = {})
+    prefix = options[:prefix] || 'tmpdir-'
+    tmpdir = tmp_file prefix
+
+    FileUtils.mkdir_p tmpdir
+
+    result = yield(tmpdir)
+
+    FileUtils.rm_rf tmpdir if File.exist?(tmpdir) && erase
+
+    result
+  end
+
+  def self.in_dir(*args)
+    with_dir(*args) do |dir|
+      old_pwd = FileUtils.pwd
+      begin
+        FileUtils.mkdir_p dir unless File.exist?(dir)
+        FileUtils.cd dir
+        yield dir
+      ensure
+        FileUtils.cd old_pwd
+      end
+    end
+  end
+end

data/lib/scout-gear.rb

@@ -0,0 +1,3 @@
+require_relative 'scout/indiferent_hash'
+require_relative 'scout/tmpfile'
+require_relative 'scout/log'

data/scout-gear.gemspec

@@ -0,0 +1,78 @@
+# Generated by juwelier
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: scout-gear 1.1.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "scout-gear".freeze
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Miguel Vazquez".freeze]
+  s.date = "2023-03-24"
+  s.description = "Temporary files, logs, etc.".freeze
+  s.email = "mikisvaz@gmail.com".freeze
+  s.executables = ["scout".freeze]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".vimproject",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bin/scout",
+    "lib/scout-gear.rb",
+    "lib/scout/exceptions.rb",
+    "lib/scout/indiferent_hash.rb",
+    "lib/scout/indiferent_hash/case_insensitive.rb",
+    "lib/scout/indiferent_hash/options.rb",
+    "lib/scout/log.rb",
+    "lib/scout/log/color.rb",
+    "lib/scout/log/color_class.rb",
+    "lib/scout/log/fingerprint.rb",
+    "lib/scout/log/progress.rb",
+    "lib/scout/log/progress/report.rb",
+    "lib/scout/log/progress/util.rb",
+    "lib/scout/meta_extension.rb",
+    "lib/scout/path.rb",
+    "lib/scout/path/find.rb",
+    "lib/scout/tmpfile.rb",
+    "scout-gear.gemspec",
+    "test/scout/indiferent_hash/test_options.rb",
+    "test/scout/log/test_progress.rb",
+    "test/scout/path/test_find.rb",
+    "test/scout/test_indiferent_hash.rb",
+    "test/scout/test_log.rb",
+    "test/scout/test_meta_extension.rb",
+    "test/scout/test_path.rb",
+    "test/scout/test_tmpfile.rb",
+    "test/test_helper.rb"
+  ]
+  s.homepage = "http://github.com/mikisvaz/scout-gear".freeze
+  s.licenses = ["MIT".freeze]
+  s.rubygems_version = "3.2.15".freeze
+  s.summary = "basic gear for scouts".freeze
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_development_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_development_dependency(%q<bundler>.freeze, ["~> 1.0"])
+    s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+    s.add_development_dependency(%q<simplecov>.freeze, [">= 0"])
+  else
+    s.add_dependency(%q<rdoc>.freeze, ["~> 3.12"])
+    s.add_dependency(%q<bundler>.freeze, ["~> 1.0"])
+    s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+    s.add_dependency(%q<simplecov>.freeze, [">= 0"])
+  end
+end
+