scout-gear 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ede50b3180404ca069e07dce767799d3b2c38c79c40ef952ac384571bf252e50
+  data.tar.gz: 9bf5db695bcd2ac0a4436d3995c2ad71a76dd51168c82f3382b66fe3258ee7bc
+SHA512:
+  metadata.gz: ff2ad51cc4e556fcfb11c515bc28d26ffa3daf7183de7b23fc47798d9c0d79c7a6763957707a9cc6fb5629f5f2f8b27b689290604647a4f288412ceacd94123e
+  data.tar.gz: 609c9256ecb3e5b900db3635abf63d3d88be9d4a8d8832405446cdb8f15c543443bb45bd6375563b3881c3e4682143fd22573a21ba6877f380ac1167dcc33e68

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.vimproject

@@ -0,0 +1,45 @@
+scout-gear=/$PWD filter="*.rb *.yaml" {
+ Rakefile
+ bin=bin {
+ }
+ lib=lib {
+  scout-gear.rb
+  scout=scout{
+   exceptions.rb
+   meta_extension.rb
+   tmpfile.rb
+   indiferent_hash.rb
+   indiferent_hash=indiferent_hash{
+    case_insensitive.rb
+    options.rb
+   }
+   log.rb
+   log=log{
+    color.rb
+    color_class.rb
+    fingerprint.rb
+    progress.rb
+    progress=progress{
+     report.rb
+     util.rb
+    }
+   }
+   path.rb
+   path=path{
+    find.rb
+   }
+  }
+ }
+ test=test {
+  test_helper.rb
+  scout=scout{
+   test_indiferent_hash.rb
+   indiferent_hash=indiferent_hash{
+    test_options.rb
+   }
+   test_log.rb
+   test_tmpfile.rb
+  }
+ }
+}
+

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2023 Miguel Vazquez
+
+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.

data/README.rdoc

@@ -0,0 +1,19 @@
+= scout-gear
+
+Description goes here.
+
+== Contributing to scout-gear
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2023 Miguel Vazquez. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+require 'juwelier'
+Juwelier::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://guides.rubygems.org/specification-reference/ for more options
+  gem.name = "scout-gear"
+  gem.homepage = "http://github.com/mikisvaz/scout-gear"
+  gem.license = "MIT"
+  gem.summary = %Q{basic gear for scouts}
+  gem.description = %Q{Temporary files, logs, etc.}
+  gem.email = "mikisvaz@gmail.com"
+  gem.authors = ["Miguel Vazquez"]
+
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "rdoc", "~> 3.12"
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "bundler", "~> 1.0"
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "juwelier", "~> 2.1.0"
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_development_dependency "simplecov", ">= 0"
+end
+Juwelier::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+desc "Code coverage detail"
+task :simplecov do
+  ENV['COVERAGE'] = "true"
+  Rake::Task['test'].execute
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "scout-gear #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+1.1.0

data/lib/scout/exceptions.rb

@@ -0,0 +1,112 @@
+class ScoutDeprecated < StandardError; end
+class ScoutException < StandardError; end
+
+class FieldNotFoundError < StandardError;end
+
+class TryAgain < StandardError; end
+class StopInsist < Exception
+  attr_accessor :exception
+  def initialize(exception)
+    @exception = exception
+  end
+end
+
+class Aborted < StandardError; end
+
+class ProcessFailed < StandardError; 
+  attr_accessor :pid, :msg
+  def initialize(pid = Process.pid, msg = nil)
+    @pid = pid
+    @msg = msg
+    if @pid
+      if @msg
+        message = "Process #{@pid} failed - #{@msg}"
+      else
+        message = "Process #{@pid} failed"
+      end
+    else
+      message = "Failed to run #{@msg}"
+    end
+    super(message)
+  end
+end
+
+class ConcurrentStreamProcessFailed < ProcessFailed
+  attr_accessor :concurrent_stream
+  def initialize(pid = Process.pid, msg = nil, concurrent_stream = nil)
+    super(pid, msg)
+    @concurrent_stream = concurrent_stream
+  end
+end
+
+class OpenURLError < StandardError; end
+
+class DontClose < Exception; end
+
+class KeepLocked < Exception
+  attr_accessor :payload
+  def initialize(payload)
+    @payload = payload
+  end
+end
+
+class KeepBar < Exception
+  attr_accessor :payload
+  def initialize(payload)
+    @payload = payload
+  end
+end
+
+#class ParameterException < ScoutException; end
+#
+#class MissingParameterException < ParameterException
+#  def initialize(parameter)
+#    super("Missing parameter '#{parameter}'")
+#  end
+#end
+#class ClosedStream < StandardError; end
+#class OpenGzipError < StandardError; end
+#
+#
+#class TryThis < StandardError
+#  attr_accessor :payload
+#  def initialize(payload = nil)
+#    @payload = payload
+#  end
+#end
+#
+#class SemaphoreInterrupted < TryAgain; end
+#class LockInterrupted < TryAgain; end
+#
+#class RemoteServerError < StandardError; end
+#
+#class DependencyError < Aborted
+#  def initialize(msg)
+#    if defined? Step and Step === msg
+#      step = msg
+#      new_msg = [step.path, step.messages.last] * ": "
+#      super(new_msg)
+#    else
+#      super(msg)
+#    end
+#  end
+#end
+#
+#class DependencyScoutException < ScoutException
+#  def initialize(msg)
+#    if defined? Step and Step === msg
+#      step = msg
+#
+#      new_msg = nil
+#      new_msg = [step.path, step.messages.last] * ": "
+#
+#      super(new_msg)
+#    else
+#      super(msg)
+#    end
+#  end
+#end
+#
+#
+#
+#

data/lib/scout/indiferent_hash/case_insensitive.rb

@@ -0,0 +1,30 @@
+module CaseInsensitiveHash
+
+  def self.setup(hash)
+    hash.extend CaseInsensitiveHash
+  end
+
+  def downcase_keys
+    @downcase_keys ||= begin
+                         down = {} 
+                         keys.collect{|key| 
+                           down[key.to_s.downcase] = key 
+                         }
+                         down
+                       end
+  end
+
+  def [](key, *rest)
+    value = super(key, *rest)
+    return value unless value.nil?
+    key_downcase = key.to_s.downcase
+    super(downcase_keys[key_downcase])
+  end
+
+  def values_at(*keys)
+    keys.collect do |key|
+      self[key]
+    end
+  end
+  
+end

data/lib/scout/indiferent_hash/options.rb

@@ -0,0 +1,132 @@
+module IndiferentHash
+  def self.add_defaults(options, defaults = {})
+    options ||= {}
+    IndiferentHash.setup(options)
+    case
+    when Hash === options
+      new_options = options.dup
+    when String === options
+      new_options = string2hash options
+    else
+      raise "Format of '#{options.inspect}' not understood. It should be a hash"
+    end
+
+    defaults.each do |key, value|
+      next if options.include? key
+
+      new_options[key] = value 
+    end
+
+    new_options
+
+    options.replace new_options
+  end
+
+  def self.process_options(hash, *keys)
+    IndiferentHash.setup(hash)
+
+    defaults = keys.pop if Hash === keys.last
+    hahs = IndiferentHash.add_defaults hash, defaults if defaults
+
+    if keys.length == 1
+      hash.include?(keys.first.to_sym) ? hash.delete(keys.first.to_sym) : hash.delete(keys.first.to_s) 
+    else
+      keys.collect do |key| hash.include?(key.to_sym) ? hash.delete(key.to_sym) : hash.delete(key.to_s) end
+    end
+  end
+
+  def self.pull_keys(hash, prefix)
+    new = {}
+    hash.keys.each do |key|
+      if key.to_s =~ /#{ prefix }_(.*)/
+        case
+        when String === key
+          new[$1] = hash.delete key
+        when Symbol === key
+          new[$1.to_sym] = hash.delete key
+        end
+      else
+        if key.to_s == prefix.to_s
+          new[key] = hash.delete key
+        end
+      end
+    end
+
+    IndiferentHash.setup(new)
+  end
+
+  def self.zip2hash(list1, list2)
+    hash = {}
+    list1.each_with_index do |e,i|
+      hash[e] = list2[i]
+    end
+    IndiferentHash.setup(hash)
+  end
+
+  def self.positional2hash(keys, *values)
+    if Hash === values.last
+      extra = values.pop
+      inputs = IndiferentHash.zip2hash(keys, values)
+      inputs.delete_if{|k,v| v.nil? or (String === v and v.empty?)}
+      inputs = IndiferentHash.add_defaults inputs, extra
+      inputs.delete_if{|k,v| not keys.include?(k) and not (Symbol === k ? keys.include?(k.to_s) : keys.include?(k.to_sym))}
+      inputs
+    else
+      IndiferentHash.zip2hash(keys, values)
+    end
+  end
+
+  def self.array2hash(array, default = nil)
+    hash = {}
+    array.each do |key, value|
+      value = default.dup if value.nil? and not default.nil?
+      hash[key] = value
+    end
+    IndiferentHash.setup(hash)
+  end
+
+  def self.process_to_hash(list)
+    result = yield list
+    zip2hash(list, result)
+  end
+
+  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] * "="
+    }.compact * "#"
+  end
+
+  def self.string2hash(string)
+    options = {}
+
+    string.split('#').each do |str|
+      key, sep, value = str.partition "="
+
+      key = key[1..-1].to_sym if key[0] == ":"
+
+      options[key] = true and next if value.empty?
+      options[key] = value[1..-1].to_sym and next if value[0] == ":"
+      options[key] = Regexp.new(/#{value[1..-2]}/) and next if value[0] == "/" and value[-1] == "/"
+      options[key] = value[1..-2] and next if value =~ /^['"].*['"]$/
+      options[key] = value.to_i and next if value =~ /^\d+$/
+      options[key] = value.to_f and next if value =~ /^\d*\.\d+$/
+      options[key] = true and next if value == "true"
+      options[key] = false and next if value == "false"
+      options[key] = value and next 
+
+      options[key] = begin
+                       saved_safe = $SAFE
+                       $SAFE = 0
+                       eval(value)
+                     rescue Exception
+                       value
+                     ensure
+                       $SAFE = saved_safe
+                     end
+    end
+
+    IndiferentHash.setup(options)
+  end
+end

data/lib/scout/indiferent_hash.rb

@@ -0,0 +1,107 @@
+require_relative 'indiferent_hash/options'
+require_relative 'indiferent_hash/case_insensitive'
+
+module IndiferentHash
+
+  def self.setup(hash)
+    hash.extend IndiferentHash 
+    hash
+  end
+
+  def merge(other)
+    new = self.dup
+    IndiferentHash.setup(new)
+    other.each do |k,value|
+      new[k] = value
+    end
+    new
+  end
+
+  def []=(key,value)
+    delete(key)
+    super(key,value)
+  end
+
+  def _default?
+    @_default ||= self.default or self.default_proc
+  end
+
+  def [](key)
+    res = super(key) 
+    return res unless res.nil? or (_default? and not keys.include? key)
+
+    case key
+    when Symbol, Module
+      super(key.to_s)
+    when String
+      super(key.to_sym)
+    else
+      res
+    end
+  end
+
+  def values_at(*key_list)
+    key_list.inject([]){|acc,key| acc << self[key]}
+  end
+
+  def include?(key)
+    case key
+    when Symbol, Module
+      super(key) || super(key.to_s)
+    when String
+      super(key) || super(key.to_sym)
+    else
+      super(key)
+    end
+  end
+
+  def delete(key)
+    case key
+    when Symbol, Module
+      super(key) || super(key.to_s)
+    when String
+      super(key) || super(key.to_sym)
+    else
+      super(key)
+    end
+  end
+
+  def clean_version
+    clean = {}
+    each do |k,v|
+      clean[k.to_s] = v unless clean.include? k.to_s
+    end
+    clean
+  end
+end
+
+module CaseInsensitiveHash
+
+  def self.setup(hash)
+    hash.extend CaseInsensitiveHash
+  end
+
+  def downcase_keys
+    @downcase_keys ||= begin
+                         down = {} 
+                         keys.collect{|key| 
+                           down[key.to_s.downcase] = key 
+                         }
+                         down
+                       end
+  end
+
+  def [](key, *rest)
+    value = super(key, *rest)
+    return value unless value.nil?
+    key_downcase = key.to_s.downcase
+    super(downcase_keys[key_downcase])
+  end
+
+  def values_at(*keys)
+    keys.collect do |key|
+      self[key]
+    end
+  end
+  
+end