scout-essentials 1.7.1 → 1.8.0

data/doc/SimpleOPT.md

@@ -0,0 +1,236 @@
+# SimpleOPT (SOPT)
+
+SimpleOPT (module SOPT) is a lightweight command-line option definition and parsing helper. It provides:
+
+- a small DSL to declare command options (long names, optional single/multi-letter shortcuts),
+- automatic generation of usage/documentation text,
+- parsing of ARGV-style option lists (boolean flags and string-valued options),
+- helpers to build option docs from compact strings or heredocs,
+- storage of option metadata (types, descriptions, defaults, shortcuts),
+- convenience functions to parse/require options in scripts.
+
+SOPT is split across several files:
+- accessor — stores option metadata and simple mutators
+- parse — parsing option-definition strings and registering options
+- doc — builds usage/documentation output
+- get — consumes ARGV-like arrays to produce parsed options
+- setup — parse a help string (heredoc) and auto-consume ARGV
+
+Important storage/accessors (module-level):
+- SOPT.inputs — ordered list of long option names
+- SOPT.shortcuts — map from shortcut string -> long option name
+- SOPT.input_shortcuts[long] — chosen shortcut for a long name
+- SOPT.input_types[long] — :string or :boolean
+- SOPT.input_descriptions[long] — description string
+- SOPT.input_defaults[long] — default values (used in docs)
+- SOPT.GOT_OPTIONS — IndiferentHash accumulating consumed options across consumes
+- SOPT.all (internal map for future use)
+
+Utility accessors: SOPT.reset, SOPT.delete_inputs.
+
+---
+
+## Declaring options
+
+SOPT supports two main declaration styles:
+
+1) Programmatic registration via SOPT.parse or SOPT.register
+- parse accepts a compact definition string (see below) and registers options.
+- register(short, long, asterisk, description) registers one option:
+  - `short` may be nil or a single/multi-letter string (SOPT will try to pick a unique short if you pass nil or true)
+  - `long` is the long option name (string)
+  - `asterisk` truthy value => treat the option as a string-valued option (type :string). falsy => boolean.
+  - `description` is the human-readable description.
+
+2) Declaration via SOPT.setup with a help/heredoc string
+- setup parses a help text in the common manpage-ish format: optional summary line, optional `$` synopsys line, description paragraphs, then option lines starting with a dash (one or more).
+- Example format (see tests):
+  ```
+  Test application
+
+  $ test cmd -arg 1
+
+  It does some imaginary stuff
+
+  -a--arg* Argument
+  -a2--arg2* Argument
+  ```
+  - Lines with `-s--long* Description` register options; `*` after `--long` marks a string-valued option.
+
+parse() supports two separators for entries:
+- newline-separated entries, or colon-separated entries (when string has no newlines).
+
+parse() expects each entry to contain short and long names in the pattern `-(short)--(long)(*)?` and optional trailing description.
+
+Examples:
+- SOPT.parse("-f--first* first arg:-f--fun") registers two options with long names "first" (string) and "fun".
+- If you pass '*' in the name pattern, the option is treated as a string-valued input (input_types[long] = :string). Otherwise it is boolean.
+
+SOPT.register handles choosing a unique shortcut:
+- SOPT.fix_shortcut picks a non-conflicting short string (initially the first char, then adds additional characters if needed, skipping punctuation characters).
+- If fix_shortcut cannot find a unique short, it may return nil — the option will be registered with no shortcut.
+
+---
+
+## Parsing command-line arguments
+
+Primary function: SOPT.consume(args = ARGV)
+
+Behavior:
+- Scans through an array of tokens (defaults to ARGV) and removes recognized option tokens from the args array.
+- Recognizes:
+  - `--key=value` and `-k=value`
+  - `--key value` (if option type is :string) or `-k value`
+  - boolean flags: `--flag` sets true, `--flag=false` or `--flag=false` will be interpreted as false.
+- When parsing, it finds which long option corresponds to the given token:
+  - token key string resolved either directly in SOPT.inputs or via SOPT.shortcuts lookup.
+  - if the token is not a registered option it is skipped (left in args).
+- For :string-typed options, the parser will consume the next token as the value if no `=` was provided.
+- For boolean options: if a token immediately following the flag is one of F/false/FALSE/no the parser will warn and treat that token as the value; otherwise presence sets true.
+- After parsing, returned options are normalized:
+  - IndiferentHash.setup is run on the options hash and keys are converted to symbols via keys_to_sym!
+  - The parsed options are merged into SOPT.GOT_OPTIONS (cumulative across calls).
+- SOPT.consume returns the parsed options hash (IndiferentHash).
+
+Example:
+```ruby
+SOPT.parse("-f--first* first arg:-f--fun")
+args = "-f myfile --fun".split(" ")
+opts = SOPT.consume(args)
+# opts[:first] == "myfile"
+# opts[:fun] == true
+```
+
+Utility:
+- SOPT.get(opt_str) — convenience: parse(opt_str) then consume(ARGV) (useful inline to define and parse immediately).
+- SOPT.require(options, *parameters) — raise ParameterException if one of the listed parameter names is not present in options (useful to assert required options).
+
+---
+
+## Documentation / usage generation
+
+SOPT can generate usage/help text:
+
+- SOPT.input_format(name, type, default, shortcut)
+  - builds a colored option usage fragment, e.g. "-n,--name=<type> (default: ...)"
+  - type values used: :string, :boolean (boolean prints [=false] in usage), :tsv/:text/:array treated specially.
+
+- SOPT.input_doc(inputs, input_types, input_descriptions, input_defaults, input_shortcuts)
+  - Builds a formatted options block for the help text for a list of inputs.
+
+- SOPT.input_array_doc(input_array)
+  - Accepts an array of arrays: [name, type, description, default, options]
+    - options may be a shortcut or an options hash (with :shortcut or other info).
+  - Produces formatted help entries.
+
+- SOPT.doc
+  - Produces a full manpage-style documentation string containing SYNOPSYS, DESCRIPTION and OPTIONS using the stored SOPT.* metadata (command, summary, synopsys, description, inputs, types, defaults).
+  - SOPT.usage prints doc text and exits.
+
+- SOPT.setup(str)
+  - Conveniently builds the command doc from a help heredoc, registers options, and calls SOPT.consume to parse current ARGV.
+
+Colors and layout use the framework's Log and Misc helpers (Log.color, Misc.format_definition_list, etc.). The doc generation includes default values in option usage.
+
+---
+
+## Metadata & helpers
+
+- SOPT.inputs — list of long option names (strings).
+- SOPT.shortcuts — map of chosen shortcut => long option (strings).
+- SOPT.input_shortcuts[long] — the chosen shortcut for the given long option.
+- SOPT.input_types[long] — :string or :boolean
+- SOPT.input_descriptions[long] — documentation string for the option
+- SOPT.input_defaults[long] — documented default value (not used by parser automatically)
+- SOPT.GOT_OPTIONS — IndiferentHash accumulating parsed options between calls
+
+Mutators / maintenance helpers:
+- SOPT.reset — clears internal maps (@shortcuts and @all).
+- SOPT.delete_inputs(list_of_inputs) — remove listed inputs and related metadata from SOPT registry.
+
+---
+
+## Edge cases and notes
+
+- Shortcut selection:
+  - If you pass `nil` or request automatic shortcuts, SOPT.fix_shortcut attempts to choose a unique shortcut starting from the first char and adding letters if collisions exist. It may return multi-letter shortcuts.
+  - fix_shortcut skips punctuation chars (., -, _) when building multi-letter shortcuts.
+  - If a unique shortcut cannot be chosen (rare), no shortcut is registered for the option.
+
+- Option value parsing:
+  - `*` in the option definition (parse/register) means the option is string-valued; otherwise it is boolean.
+  - For booleans, presence sets true; to specify false on the command line either use `--flag=false` or provide `false` (or `F`/`no`) token after the flag — the parser will accept these but warns that `--flag=[true|false]` is preferred.
+  - If a string option is given without an explicit `=` and the next token is missing, the value will become `nil` (the parser consumes next token if present).
+
+- Default handling:
+  - input_defaults are only used for documentation output. The parser does not automatically apply defaults to parsed options; callers should fill in defaults after parsing if desired.
+
+- Normalization:
+  - Parsed options are converted to an IndiferentHash and keys are converted to symbols (`keys_to_sym!`), so consumers can access with either symbol or string keys (but tests expect symbol keys after consume).
+
+- GOT_OPTIONS:
+  - SOPT.GOT_OPTIONS accumulates parsed options across multiple consumes; useful for scripts that call consume more than once or want a global snapshot.
+
+- Documentation parsing (setup):
+  - SOPT.setup expects a particular structure: optional summary line, optional `$` synopsys line, description paragraphs, followed by option lines beginning with `-`.
+  - It calls SOPT.parse on the options block and SOPT.consume to parse current ARGV.
+
+- Error handling:
+  - SOPT.require raises ParameterException (from the surrounding framework) if a required option is missing.
+
+---
+
+## Examples
+
+Define options and parse ARGV:
+
+```ruby
+# declare from compact string and parse ARGV
+SOPT.parse("-f--first* first arg:-s--silent Silent flag")
+opts = SOPT.consume(ARGV)
+# opts[:first]  => "value" (if provided)
+# opts[:silent] => true/false
+```
+
+Define options from a help heredoc and auto-consume:
+
+```ruby
+SOPT.setup <<-EOF
+My command summary
+
+$ mycmd [options] args
+
+This does interesting work
+
+-f--first*  First input file
+-s--silent  Run quietly
+EOF
+
+# SOPT.setup registers options and consumes ARGV
+# Use SOPT.GOT_OPTIONS or result of consume to access parsed options
+```
+
+Quick inline parse+consume:
+
+```ruby
+SOPT.get("-f--first* first arg:-s--silent")
+# Equivalent to SOPT.parse(...) followed by SOPT.consume(ARGV)
+```
+
+Require an option:
+
+```ruby
+opts = SOPT.consume(ARGV)
+SOPT.require(opts, :first)  # raises ParameterException if :first missing
+```
+
+Produce usage:
+
+```ruby
+puts SOPT.doc   # assemble doc string from registered inputs and descriptions
+SOPT.usage      # prints doc and exits
+```
+
+---
+
+This covers the common usage patterns and API surface of SimpleOPT. Use SOPT.parse/register to declare options programmatically for small utilities; use SOPT.setup to derive declarations from a help/heredoc and auto-parse ARGV for typical script workflows.

data/doc/TmpFile.md

@@ -0,0 +1,154 @@
+# TmpFile
+
+TmpFile provides small helpers to create and manage temporary files and directories used throughout the framework. It offers safe temporary-path generation, scoped helpers that create and remove temporary files/dirs automatically, and a persistence-path helper (tmp_for_file) used by caching/persistence code to build stable cache filenames.
+
+Files: lib/scout/tmpfile.rb
+
+---
+
+## Key constants & configuration
+
+- TmpFile.MAX_FILE_LENGTH = 150 — max length used by tmp_for_file before truncating and appending a digest.
+- TmpFile.tmpdir — base temporary directory used by tmp utilities (defaults to user tmp under $HOME: `~/tmp/scout/tmpfiles`).
+  - You can set: `TmpFile.tmpdir = "/some/dir"`.
+
+Helpers:
+- TmpFile.user_tmp(subdir = nil) — returns user-scoped base tmp dir (under $HOME/tmp/scout). If `subdir` provided it is appended.
+
+---
+
+## Filename helpers
+
+- TmpFile.random_name(prefix = 'tmp-', max = 1_000_000_000)
+  - Return a random name with the given prefix and a random integer (0..max).
+
+- TmpFile.tmp_file(prefix = 'tmp-', max = 1_000_000_000, dir = nil)
+  - Returns a path inside `dir` (defaults to `TmpFile.tmpdir`) composed of prefix + random number.
+  - If `dir` is a Path it will be `.find`ed.
+
+---
+
+## Scoped helpers
+
+These helpers create temporary files/directories, yield them to the caller, and delete them afterward (by default).
+
+- TmpFile.with_file(content = nil, erase = true, options = {}) { |tmpfile| ... }
+  - Create a temporary file path and optionally pre-populate it with `content`.
+  - Parameters:
+    - `content`:
+      - If String: write content into file.
+      - If IO/StringIO: read its contents and write into tmp file.
+      - If nil: tmp file is created empty.
+      - If `content` is a Hash, it is treated as options (content=nil).
+    - `erase` (default true): remove the tmp file after the block completes.
+    - `options` (Hash):
+      - `:prefix` — filename prefix (default `'tmp-'`).
+      - `:max` — random suffix max integer.
+      - `:tmpdir` — directory to write the tmp file into.
+      - `:extension` — append `.extension` to tmp file name.
+  - Behavior:
+    - Ensures tmpdir exists (Open.mkdir).
+    - Handles IO content safely by reading readpartial until EOF.
+    - Yields the tmp file path (string) to the block.
+    - After the block returns, removes the tmp file when `erase` is true and file exists.
+  - Examples:
+    ```ruby
+    TmpFile.with_file("Hello") do |file|
+      puts File.read(file)  # => "Hello"
+    end
+    ```
+
+- TmpFile.with_dir(erase = true, options = {}) { |tmpdir| ... }
+  - Create a temporary directory (using tmp_file for a unique name), yield its path, and remove it after block if `erase` true.
+  - `options[:prefix]` may change directory name prefix.
+  - Example:
+    ```ruby
+    TmpFile.with_dir do |dir|
+      # dir is a path to a temporary directory
+    end
+    ```
+
+- TmpFile.in_dir(*args) { |dir| ... }
+  - Convenience that creates a temporary directory and executes the block with the current working directory changed to that directory (uses `Misc.in_dir` internally).
+
+---
+
+## Persistence path helper
+
+- TmpFile.tmp_for_file(file, tmp_options = {}, other_options = {})
+  - Generates a stable temporary/persistent filename for a logical file name plus options. Used by persistence/caching logic to build consistent cache files per logical input and options.
+  - Returns a Path (string extended with Path) under the chosen persistence directory.
+  - Parameters:
+    - `file` — logical filename or Path used to build the identifier.
+    - `tmp_options` may include:
+      - `:file` — return value override (internal)
+      - `:prefix` — prefix for the identifier (default: based on file)
+      - `:key` — optional key appended in identifier (`[...]`).
+      - `:dir` — base directory for persistence (defaults to `TmpFile.tmpdir`).
+    - `other_options` — additional options whose digest will be appended to the filename (used to make identifier unique for variations like filters).
+    - Special handling:
+      - Replaces path separators with `SLASH_REPLACE` (character `·`) to make a single filename.
+      - Truncates long filenames (over MAX_FILE_LENGTH) and appends a short digest to avoid filesystem limits.
+      - Appends a digest of `other_options` (unless empty) to ensure uniqueness when options differ.
+  - Use cases:
+    - Build cache file path for a content produced from input + parameters.
+    - Example (simplified):
+      ```ruby
+      p = TmpFile.tmp_for_file("data.tsv", dir: Path.setup("var/cache"))
+      ```
+
+---
+
+## Behavior / edge cases
+
+- `with_file` and `with_dir` remove created resources after the block only if `erase` true and the file/dir exists.
+- `with_file` supports passing options as the first argument (if `content` is a Hash).
+- `with_file` writes IO content using `readpartial` in chunks (handles large IOs without loading entire contents into memory).
+- `tmp_for_file` uses a safe character `SLASH_REPLACE` (`'·'`) for replaced `/` characters — results in single-file names representing nested logical paths.
+- `tmp_for_file` truncates overly long identifiers and appends a digest of the remainder to keep the filename length reasonable.
+- The helper returns a Path-like value when `persistence_dir` is a Path.
+
+---
+
+## Examples (from tests)
+
+- Create a temporary file with content:
+  ```ruby
+  TmpFile.with_file("Hello World!") do |file|
+    assert_equal "Hello World!", File.read(file)
+  end
+  ```
+
+- Create a temporary file from an IO and consume into another temporary:
+  ```ruby
+  TmpFile.with_file("Hello") do |file1|
+    Open.open(file1) do |io|
+      TmpFile.with_file(io) do |file2|
+        assert_equal "Hello", File.read(file2)
+      end
+    end
+  end
+  ```
+
+- Temporary directory and change into it:
+  ```ruby
+  TmpFile.in_dir do |dir|
+    # current working directory is dir inside the block
+  end
+  ```
+
+- Build a persistent cache path for a logical filename + options:
+  ```ruby
+  cache_path = TmpFile.tmp_for_file("input.tsv", dir: Path.setup("var/cache"))
+  ```
+
+---
+
+## Implementation notes
+
+- TmpFile uses `Open` utilities to create directories and write files.
+- `tmp_file` returns plain string paths; callers often wrap them in Path.setup when needed.
+- Filenames are sanitized (spaces replaced with `_`) and slashes replaced with `·` for single-file representation of nested paths in `tmp_for_file`.
+- The module is intentionally minimal but used pervasively by other framework components like Persist and Resource to generate stable temporary / cache paths.
+
+Use TmpFile helpers when you need temporary files/dirs or stable cache filenames with predictable cleanup behavior.

data/lib/scout/annotation/annotated_object.rb

@@ -4,6 +4,10 @@ module Annotation
       @annotation_types ||= []
     end
 
+    def base_type
+      annotation_types.last
+    end
+
     def annotation_hash
       attr_hash = {}
       @annotations.each do |name|
@@ -56,6 +60,10 @@ module Annotation
         new.remove_instance_variable(:@container)
       end
 
+      if new.instance_variables.include?(:@container_index)
+        new.remove_instance_variable(:@container_index)
+      end
+
       new
     end
 

data/lib/scout/annotation/annotation_module.rb

@@ -41,6 +41,7 @@ module Annotation
       end
       obj = block if obj.nil?
       return nil if obj.nil?
+      obj = obj.dup if obj.frozen?
       begin
         obj.extend self unless self === obj
       rescue TypeError

data/lib/scout/cmd.rb

@@ -35,7 +35,7 @@ module CMD
         if test
           CMD.cmd(test + " ")
         else
-          CMD.cmd("#{cmd} --help")
+          CMD.cmd("bash -c 'command -v #{cmd}'")
         end
       rescue
         if claim
@@ -111,12 +111,12 @@ module CMD
       when value.nil? || FalseClass === value
         next
       when TrueClass === value
-        string << "#{option} "
+        string += "#{option} "
       else
         if option.to_s.chars.to_a.last == "="
-          string << "#{option}'#{value}' "
+          string += "#{option}'#{value}' "
         else
-          string << "#{option} '#{value}' "
+          string += "#{option} '#{value}' "
         end
       end
     end
@@ -130,6 +130,7 @@ module CMD
     options    = IndiferentHash.add_defaults options, :stderr => Log::DEBUG
     in_content = options.delete(:in)
     stderr     = options.delete(:stderr)
+    sudo       = options.delete(:sudo)
     post       = options.delete(:post)
     pipe       = options.delete(:pipe)
     log        = options.delete(:log)
@@ -172,9 +173,13 @@ module CMD
 
     cmd_options = process_cmd_options options
     if cmd =~ /'\{opt\}'/
-      cmd.sub!('\'{opt}\'', cmd_options)
+      cmd = cmd.sub('\'{opt}\'', cmd_options)
     else
-      cmd << " " << cmd_options
+      cmd += " " + cmd_options
+    end
+
+    if sudo
+      cmd = "sudo " + cmd
     end
 
     in_content = StringIO.new in_content if String === in_content
@@ -247,9 +252,8 @@ module CMD
 
       sout
     else
-
+      err = ""
       if bar
-        err = ""
         err_thread = Thread.new do
           while not serr.eof?
             line = serr.gets
@@ -259,26 +263,28 @@ module CMD
           serr.close
         end
       elsif log and Integer === stderr
-        err = ""
         err_thread = Thread.new do
           while not serr.eof?
-            err << serr.gets
+            err += serr.gets
           end
           serr.close
         end
       else
         Open.consume_stream(serr, true)
         err_thread = nil
-        err = ""
       end
 
       ConcurrentStream.setup sout, :pids => pids, :threads => [in_thread, err_thread].compact, :autojoin => autojoin, :no_fail => no_fail
 
       begin
         out = StringIO.new sout.read
+        status = wait_thr.value
+
+        sout.join
         sout.close unless sout.closed?
+        sout.annotate(out)
 
-        status = wait_thr.value
+        out.exit_status = status.exitstatus
         if status && ! status.success? && ! no_fail
           if !err.empty?
             raise ProcessFailed.new pid, "#{cmd} failed with error status #{status.exitstatus}.\n#{err}"
@@ -288,6 +294,7 @@ module CMD
         else
           Log.log err, stderr if Integer === stderr and log
         end
+        out.std_err = err if save_stderr
         out
       ensure
         post.call if post

data/lib/scout/concurrent_stream.rb

@@ -9,7 +9,7 @@ module AbortedStream
 end
 
 module ConcurrentStream
-  attr_accessor :threads, :pids, :callback, :abort_callback, :filename, :joined, :aborted, :autojoin, :lock, :no_fail, :pair, :thread, :stream_exception, :log, :std_err, :next
+  attr_accessor :threads, :pids, :callback, :abort_callback, :filename, :joined, :aborted, :autojoin, :lock, :no_fail, :pair, :thread, :stream_exception, :log, :std_err, :next, :exit_status
 
   def self.setup(stream, options = {}, &block)
     threads, pids, callback, abort_callback, filename, autojoin, lock, no_fail, pair, next_stream = IndiferentHash.process_options options, :threads, :pids, :callback, :abort_callback, :filename, :autojoin, :lock, :no_fail, :pair, :next
@@ -117,6 +117,7 @@ module ConcurrentStream
       @pids.each do |pid|
         begin
           Process.waitpid(pid, Process::WUNTRACED)
+          self.exit_status = $?.exitstatus
           stream_raise_exception ConcurrentStreamProcessFailed.new(pid, "Error in waitpid", self) unless $?.success? or no_fail
         rescue Errno::ECHILD
         end
@@ -250,6 +251,7 @@ module ConcurrentStream
         end
         close if done
       end
+      join if autojoin && (closed? || @stream_exception)
     end
   end
 

data/lib/scout/config.rb

@@ -116,8 +116,8 @@ module Scout::Config
 
     File.expand_path(file)
 
-    tokens << ("file:" << file)
-    tokens << ("line:" << file << ":" << line.sub(/:in \`.*/,''))
+    tokens << ("file:" + file)
+    tokens << ("line:" + file << ":" << line.sub(/:in \`.*/,''))
 
     entries = CACHE[key.to_s]
     priorities = {}

data/lib/scout/indiferent_hash/options.rb

@@ -88,8 +88,8 @@ module IndiferentHash
   def self.hash2string(hash)
     hash.sort_by{|k,v| k.to_s}.collect{|k,v| 
       next unless %w(Symbol String Float Fixnum Integer Numeric TrueClass FalseClass Module Class Object).include? v.class.to_s
-      [ Symbol === k ? ":" << k.to_s : k.to_s.chomp,
-        Symbol === v ? ":" << v.to_s : v.to_s.chomp] * "="
+      [ Symbol === k ? ":" + k.to_s : k.to_s.chomp,
+        Symbol === v ? ":" + v.to_s : v.to_s.chomp] * "="
     }.compact * "#"
   end
 

data/lib/scout/indiferent_hash.rb

@@ -157,5 +157,21 @@ module IndiferentHash
 
     super(*full_list)
   end
+
+  def dig(*keys)
+    current = self
+    while keys.any?
+      first = keys.shift
+      current = current[first]
+      break if current.nil?
+      IndiferentHash.setup(current) if Hash === current
+    end
+    current
+  end
+
+  def self.dig(obj, *keys)
+    IndiferentHash.setup obj
+    obj.dig(*keys)
+  end
 end
 

data/lib/scout/log/color.rb

@@ -141,6 +141,8 @@ module Log
   SEVERITY_COLOR = [reset, cyan, green, magenta, blue, yellow, red] #.collect{|e| "\033[#{e}"}
   CONCEPT_COLORS = IndiferentHash.setup({
     :title => magenta,
+    :subtitle => yellow,
+    :body => blue,
     :path => blue,
     :input => cyan,
     :value => green,
@@ -161,7 +163,7 @@ module Log
   HIGHLIGHT = "\033[1m"
 
   def self.uncolor(str)
-    "" << Term::ANSIColor.uncolor(str)
+    "" + Term::ANSIColor.uncolor(str)
   end
 
   def self.reset_color
@@ -169,7 +171,7 @@ module Log
   end
 
   def self.color(color, str = nil, reset = false)
-    return str.dup || "" if nocolor
+    return str.to_s.dup if nocolor
 
     if (color == :integer || color == :float) && Numeric === str
       color = if str < 0
@@ -205,7 +207,7 @@ module Log
     str = str.to_s unless str.nil?
     return str if Symbol === color
     color_str = reset ? Term::ANSIColor.reset.dup : ""
-    color_str << color if color
+    color_str += color if color
     if str.nil?
       color_str
     else

data/lib/scout/log/fingerprint.rb

@@ -14,15 +14,15 @@ module Log
     when FalseClass
       "false"
     when Symbol
-      ":" << obj.to_s
+      ":" + obj.to_s
     when String
       if obj.length > FP_MAX_STRING
         digest = Digest::MD5.hexdigest(obj)
         middle = "<...#{obj.length} - #{digest[0..4]}...>"
         s = (FP_MAX_STRING - middle.length) / 2
-        "'" << obj.slice(0,s-1) << middle << obj.slice(-s, obj.length )<< "'"
+        "'" + obj.slice(0,s-1) + middle + obj.slice(-s, obj.length ) + "'"
       else 
-        "'" << obj << "'"
+        "'" + obj + "'"
       end
     when ConcurrentStream
       name = obj.inspect + " " + obj.object_id.to_s
@@ -34,22 +34,22 @@ module Log
       "<File:" + obj.path + ">"
     when Array
       if (length = obj.length) > FP_MAX_ARRAY
-        "[#{length}--" <<  (obj.values_at(0,1, length / 2, -2, -1).collect{|e| fingerprint(e)} * ",") << "]"
+        "[#{length}--" + (obj.values_at(0,1, length / 2, -2, -1).collect{|e| fingerprint(e)} * ",") + "]"
       else
-        "[" << (obj.collect{|e| fingerprint(e) } * ", ") << "]"
+        "[" + (obj.collect{|e| fingerprint(e) } * ", ") + "]"
       end
     when Hash
       if obj.length > FP_MAX_HASH
-        "H:{"<< fingerprint(obj.keys) << ";" << fingerprint(obj.values) << "}"
+        "H:{" + fingerprint(obj.keys) + ";" + fingerprint(obj.values) + "}"
       else
         new = "{"
         obj.each do |k,v|
-          new << fingerprint(k) << '=>' << fingerprint(v) << ' '
+          new += fingerprint(k) + '=>' + fingerprint(v) + ' '
         end
         if new.length > 1
            new[-1] =  "}"
         else
-          new << '}'
+          new += '}'
         end
         new
       end