skn_utils 5.7.0 → 5.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: '01339ef95f65037a1a9951185b69a8ee2fb9160c'
-  data.tar.gz: fd2bd2b6b3ae66f17b268f6f23abd2d1a8c0e69b
+SHA256:
+  metadata.gz: bdbe2b2318e4841c25afdec1e118cc19ff445f8a8b1e08d116715f5b9df0f56e
+  data.tar.gz: d42c5e55def5f8c2789714d1fada2f341f59665ba633192732b9e6b48816e253
 SHA512:
-  metadata.gz: cb6089054a1e97e7e21d03df41c6622e253487fee45e9799217c8cff211dcb8ca63c39776e15c89876edd88e22a9a22c099a133328bb5786801a0d53ce682924
-  data.tar.gz: 288b6c71971afd3f0b84b5524d0c96ceec28b7db93a8183ea6c9e31e0a00a974b0eb11f8acbcda03f7b3d0b5160de6e244ec78b7fca13d43f75a63951765e72c
+  metadata.gz: b48e34a868729ed2fe63cc77c456a9b9eef99540355d4de6135c7cd5fe96c88b78519cc8384f2eb13c0a29b9652b4e84fbc1624a4674df0ec73c4f95d3762392
+  data.tar.gz: c435de19604f41834446ca04084ffc7a559267786974130edc03ad2a540f07eb08111571b13995f67e6bcfc122b215a3d5bb5cf26a905d1e3e85b31e4f0dfad3

data/README.md

@@ -75,7 +75,7 @@ use-cases.
  
 
 ## History
-    2/3/2030 V5.7.0
+    2/3/2020 V5.7.0
     Added
     * RSpec XML_Matchers to spec/support folders
     * Update ConcurrentJobs JobCommands to support HTTP Headers
@@ -201,39 +201,31 @@ Ruby's Hash object is already extremely flexible, even more so with the addition
             - enables `SknSettings.root`
         - `env:  !ruby/string:SknUtils::EnvStringHandler <%= ENV.fetch('RACK_ENV', 'development') %>`
             - enables `SknSettings.env.production?` ...
-1. Since SknSettings is by necessity a global constant, it can serve as Session Storage to keep system objects; like a ROM-RB instance.
-1. In-Memory Key-Store, use it to cache active user objects, or active Integration passwords, and/or objects that are not serializable.
-1. Command registries used to dispatch command requests to proper command handler. see example app [SknBase](https://github.com/skoona/skn_base/blob/master/strategy/services/content/command_handler.rb)
-```ruby
-    SknSettings.command_handler = {
-                            Commands::RetrieveAvailableResources  => method(:resources_metadata_service),
-                            Commands::RetrieveResourceContent  => method(:resource_content_service)
-                           }
-    ...
-    SknSettings.command_handler[ cmd.class ].call( cmd )
-    -- or --
-    SknSettings.command_handler.key?( cmd.class ) && 
-      cmd.valid? ? SknSettings.command_handler[ cmd.class ].call( cmd ) : command_not_found_action()
-```
+
 There are many more use cases for Ruby's Hash that this gem just makes easier to implement.
 
 
 ## Public Components
     SknUtils::NestedResult           # Primary Key/Value Container with Dot/Hash notiation support.
-        SknHash                      # Wrapper for name only, WITHOUT SknUtils namespace, inherits from SknUtils::NestedResult
-        SknUtils::ResultBean         # Wrapper for name only, inherits from SknUtils::NestedResult
-        SknUtils::PageControls       # Wrapper for name only, inherits from SknUtils::NestedResult
-        SknUtils::DottedHash         # Wrapper for name only, inherits from SknUtils::NestedResult
+        SknHash                      # Wrapper in name only, WITHOUT SknUtils namespace, inherits from SknUtils::NestedResult
+        SknUtils::ResultBean         # Wrapper in name only, inherits from SknUtils::NestedResult
+        SknUtils::PageControls       # Wrapper in name only, inherits from SknUtils::NestedResult
+        SknUtils::DottedHash         # Wrapper in name only, inherits from SknUtils::NestedResult
 
-    SknUtils::Configurable           # Basic one-level class configuration Module
+    SknSettings                      # Multi-level application Configuration class, Key/Value Container with Dot/Hash notiation support.
+                                     - Reads YAML files from ./config/ directory based by environment (RACK_ENV)
+                                     - INITIALIZED WHEN GEM LOADS    
 
-    SknSettings                      # Multi-level application Configuration class, Key/Value Container with Dot/Hash notiation support.    
+    SknUtils::Configurable           # Add Class writers/getters to any Class, think class configuration
 
-    SknContainer/SknRegistry         # Basic Key/Value container which #registers and #resolves procs, classes, and/or object
+    SknContainer/SknRegistry         # Key/Value container which #registers and #resolves procs, classes, and/or object
+                                     - Allows definition in one place, and label references as needed; dependency injection
+                                     - INITIALIZED WHEN GEM LOADS    
 
-    SknSuccess                       # Three attribute value containers for return codes   -- #value, #message, #success
+    SknSuccess                       # Three attribute value containers for consistant return codes   -- #value, #message, #success
                                        - Extra #payload method returns value as NestResult if value is_a Hash 
     SknFailure                       # Three attribute value containers for return codes   -- #value, #message, #success
+    
     SknUtils::ConcurrentJobs         # Async/Sync Job executor pool with HTTP support
         SknUtils::CommandJSONGet     # HTTP Get Command class expecting `json` return, located inside `job_commands`
         SknUtils::CommandJSONPut     # HTTP Put Command class expecting `json` return, located inside `job_commands`
@@ -245,7 +237,9 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 
 
 ## Public Methods: SknUtils::Configurable module
- For making an arbitrary class configurable and then specifying those configuration values. 
+For making an arbitrary class configurable and then specifying those configuration values. Intended to be used at the application 
+level, similar to the use of `Rails`, or for classes that would benefit from a configuration value when objects are created from it. 
+
 ```ruby
   # (1) First establish the method names of class values desired.
   ################
@@ -310,21 +304,27 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 ```
 
 
-## Public Methods: SknRegistry ONLY
-    `SknContainer` is global constant assigned to an instantiated instance of `SknRegistry`.
-    Returns the keyed value as the original instance/value or if provided a proc the result of calling that proc.
-    To register a class or object for global retrieval, use the following API.  Also review the RSpecs for additional useage info.
+## Public Methods: SknContainer and/or SknRegistry class
+`SknContainer` is global constant assigned to an instantiated instance of `SknRegistry`.  `SknRegistry` can 
+be instantiated in the regular way via `SknRegistry.new`; and is included in the SknConfigurable root options 
+by default under the key `registry`.
+
+Either returns the labeled value as the original instance/value or if provided with a proc, the result of calling that proc.
+To register, and `label`, a class or object for retrieval, use the following API.  Also review the RSpecs for 
+additional useage info.
     
       #register(key, contents = nil, options = {})
         - example: 
             SknContainer.register(:some_klass, MyClass)                   -- class as value
             SknContainer.register(:the_instance, MyClass.new)             -- Object Instance as value 
-            SknContainer.register(:unique_instance, -> {MyClass.new})     -- New Object Instance for each #resolve 
+            SknContainer.register(:unique_instance, -> {MyClass.new}, call: true)  -- New Object Instance for each #resolve 
+            SknContainer.register(:unique_instance2, ->(parms) {MyClass.new(parms)}, call: false)  -- New Object with parms for each #resolve 
+            SknContainer.register(:some_proc, -> {MyClass.new}, call: false) -- Return uncalled proc for each #resolve 
 
             SknContainer                                                  -- #register returns self to enable chaining
                 .register(:unique_instance, -> {MyClass.new})
-                  .register(:the_instance, MyClass.new)
-                    .register(:some_klass, MyClass)    
+                .register(:the_instance, MyClass.new)
+                .register(:some_klass, MyClass)    
             
       #resolve(key)
         - example:
@@ -332,20 +332,24 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
             instance = SknContainer.resolve(:some_klass).new
             
             obj_instance1 = SknContainer.resolve(:unique_instance) 
-            obj_instance2 = SknContainer.resolve(:unique_instance)
+            obj_instance2 = SknContainer.resolve(:unique_instance2).call(parms)
             
             same_instance = SknContainer.resolve(:the_instance)
+   
+                some_proc = SknContainer.resolve(:some_proc).call
 
       * Testing Support:
-          - #substitute(...) allows you to mock an existing entry. #substitute is an alias for #register_mock              
+          - #substitute(...) allows you to mock an existing entry. #substitute is an alias for #register_mock
+            - SknContainer.substitute(:the_instance, MyClass.new)              
           - #restore! clears all mocked entries.  #restore! is an alias for #unregister_mock!
+            - SknContainer.restore!
 
 
-## Public Methods: SknUtils::ConcurrentJobs ONLY
-    `ConcurrentJobs` behaves as a concurrent thread pool by using Concurrent::Promise from the `concurrent-ruby` gem. 
-    Enables the definition of Procs, or any callable class, which will be executed in parrallel the available jobs 
-    loaded into ConcurrentJobs.  Meant to reduce user-sensitive response times when multiple APIs must be invoked. 
-    Also review the RSpecs for additional useage info.
+## Public Methods: SknUtils::ConcurrentJobs classes
+`ConcurrentJobs` behaves as a concurrent thread pool by using Concurrent::Promise from the `concurrent-ruby` gem. 
+Enables the definition of Procs, or any callable class, which will be executed in parrallel with the available jobs 
+loaded into ConcurrentJobs.  Meant to reduce user-sensitive response times when multiple APIs must be invoked. 
+Also review the RSpecs for additional useage info.
     
         SknUtils::ConcurrentJobs
            #call(async: true)               - Instantiate ConcurrentJobs with Async Workers, false for Sync Workers
@@ -359,11 +363,12 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
               #messages                     - Retrieves messages from job results, assumed present when job fails
               #values                       - Returns an array of individual results from job executions
 
-    Commands and HttpProcessors are included to demonstrate Job creating patterns.  ConcurrentJobs is not restricted
-    to Http calls or the command to command handler pattern.  Using the #register_job method you can pass callable BLOCK
-    and it will be executed when #render_jobs is invoked.  HttpProcessor is what I needed and triggered me to add this feature.              
+Commands and HttpProcessors are included to demonstrate Job creating patterns.  ConcurrentJobs is not restricted
+to Http calls or the command to command handler pattern.  Using the #register_job method you can pass callable BLOCK
+and it will be executed when #render_jobs is invoked.  HttpProcessor is what I needed and triggered me to add this feature.              
+    
+Example here:
     
-    Example here:
 ```ruby
 begin
   # CommandJSONPost, CommandFORMGet, CommandJSONGet,
@@ -401,10 +406,10 @@ end
 ```    
 
 
+## Public Methods: SknSettings class
+SknSettings is a global constant containing an initialized Object of SknUtils::Configuration using defaults. 
+To change the 'development'.yml default please use the following method early or in the case of Rails in 'application.rb
 
-## Public Methods: SknSettings ONLY
-    SknSettings is a global constant containing an initialized Object of SknUtils::Configuration using defaults
-    To change the 'development'.yml default please use the following method early or in the case of Rails in 'application.rb
       #load_config_basename!(config_name) -- Where config_name is the name of yml files stored in the `./config/settings` directory
       #config_path!(path)                 -- Where path format is './<dirs>/', default is: './config/'
                                              and contains a settings.yml file and a 'path/settings/' directory
@@ -437,9 +442,15 @@ end
      #prepend_source!(file_path_or_hash)               -- self, adds yaml_file or hash to start of filelist (:reload! required)
      -------------------------------------------------
 
+    Usage
+     -------------------------------------------------
+     Dot notation of yaml file contents
+     SknSettings.version   # => version's value
+     -------------------------------------------------
 
 ## Public Methods: SknUtils::NestedResult, SknHash & SknSettings
-    Each concrete Class supports the following utility methods:
+Each concrete Class supports the following utility methods:
+    
       #to_hash                       -- returns a hash of current key/value pairs, including nested
       #to_json                       -- returns a json string of current key/value pairs, including nested
       #hash_from(:base_key)          -- exports the internal hash starting with this base level key
@@ -459,6 +470,7 @@ end
 
 
 ## NestedResult Basic features include:
+
 ```ruby
  - provides the hash or dot notation methods of accessing values:
 
@@ -500,6 +512,7 @@ end
 
 * The NestedResult produces these effects when given a params hash;
 * Follow VALUES that are Hashes, Arrays of Hashes, and Arrays of Arrays of Hashes
+
 ```ruby
     drb = SknUtils::NestedResult.new(params)                          Basic dot notation:
     ----------------------------------------------------      -----------------------------------------------------------------
@@ -524,6 +537,7 @@ end
 ```
 
 * Expected usage
+
 ```ruby
        result =  SknUtils::NestedResult.new({
                            success: true,
@@ -539,6 +553,7 @@ end
 
 
 * Wrap additional methods around the core NestedResult feature set
+
 ```ruby
        class MyPackage < SknUtils::NestedResult
           def initialize(params={})

data/_config.yml

@@ -1,9 +1,10 @@
 title: SknUtils
 email: skoona@gmail.com
 description: > # this means to ignore newlines until "baseurl:"
-  Ruby GEM containing utilitarian classes to help build Ruby applications.  SknUtils::NestedResult is the primary class.  It is 
-  a threadsafe wrapper over Ruby's Hash with dot.notation, ?.presence, and nested deep-merge features added.  I use it for application 
-  settings via YAML files, and as a container for persistent objects.
+  Collection of pure-ruby utility classes and modules, with limited
+  dependencies, to augment the development of Ruby applications. Value containers supporting nested dot.notation access
+  over hashes, and utilities offering dependency injection/lookup, and language extensions support running in a non-rails
+  environment.  Plus, examples of null objects, class customization, and concurrent processing.
 baseurl: ""
 url: https://skoona.github.io/SknServices
 
@@ -21,4 +22,3 @@ github:
 author:
   name:       "James Scott, Jr. (a.k.a Skoona)"
   url:        https://keybase.io/skoona
-

data/lib/skn_utils/concurrent_jobs.rb

@@ -16,7 +16,8 @@ module SknUtils
     def call
       @blk.call
     rescue => ex
-      SknFailure.(ex.class.name, { cause: ex.message, backtrace: ex.backtrace[0..8]})
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
     end
   end
 
@@ -28,7 +29,8 @@ module SknUtils
     def call
       @blk.value
     rescue => ex
-      SknFailure.(ex.class.name, { cause: ex.message, backtrace: ex.backtrace[0..8]})
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
     end
   end
 
@@ -50,11 +52,20 @@ module SknUtils
     end
   end
 
+  class CallableWrapperJob
+    def self.call(callable, command)
+      callable.call(command)
+    rescue => ex
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
+    end
+  end
   class JobWrapper
     def self.call(command, callable)
       callable.call(command)
     rescue => ex
-      SknFailure.(ex.class.name, { cause: ex.message, backtrace: ex.backtrace[0..8]})
+      failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+      SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
     end
   end
 
@@ -93,7 +104,8 @@ module SknUtils
           res = worker.call
           acc.push( res.nil? ? SknFailure.("Unknown", {cause: "Nil Return Value to render Jobs", backtrace: []}) : res )
         rescue => ex
-          acc.push SknFailure.(ex.class.name, { cause: ex.message, backtrace: ex.backtrace[0..8]})
+          failures = ex.backtrace.map {|x| x.split("/").last }.join(",")
+          acc.push SknFailure.(ex.class.name, { cause: ex.message, backtrace: failures})
         end
       end
       @elapsed_time_string = SknUtils.duration(stime)

data/lib/skn_utils/configurable.rb

@@ -63,6 +63,7 @@ module SknUtils
   # - metadata =  platform metadata container
   # - userdata =  user area
   # - metrics  =  platform metrics container
+  # - ...
   # #with(*user_attrs, enable_root: true|false) - defaults to enable of Main Class Attrs
   # ##
   # User-Defined Attrs

data/lib/skn_utils/job_commands.rb

@@ -3,6 +3,47 @@
 # Ref: https://yukimotopress.github.io/http
 
 module SknUtils
+  # #################################################
+  #
+  class CommandJSONPDelete
+    def self.call(options)  # {full_url:,username:,userpass:,payload:,headers:}
+      new(options)
+    end
+
+    def json?
+      true
+    end
+
+    def uri
+      @_uri
+    end
+
+    def request
+      req = @_headers.nil? ? Net::HTTP::Delete.new(uri.request_uri) : Net::HTTP::Delete.new(uri.request_uri, @_headers)        # Generate HTTPRequest object
+      req.basic_auth(@_username, @_userpass) if credentials?
+      req.content_type = 'application/json'
+      req.body = formatted_data
+      req
+    end
+
+    private
+
+    def initialize(opts={})
+      @_username = opts[:username]
+      @_userpass = opts[:userpass]
+      @_headers  = opts[:headers]
+      @_uri      = URI.parse( opts[:full_url])
+      @_data     = opts[:payload]
+    end
+
+    def formatted_data
+      @_data.respond_to?(:to_json) ? @_data.to_json : @_data
+    end
+
+    def credentials?
+      !(@_username.nil? || @_userpass.nil?)
+    end
+  end
 
   # #################################################
   #

data/lib/skn_utils/version.rb

@@ -4,7 +4,7 @@
 module SknUtils
   class Version
     MAJOR = 5
-    MINOR = 7
+    MINOR = 8
     PATCH = 0
 
     def self.to_s

data/skn_utils.gemspec

@@ -1,48 +1,49 @@
+# frozen_string_literal: true
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-# lib = File.expand_path('../lib', __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'skn_utils/version'
+
+require_relative 'lib/skn_utils/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'skn_utils'
   spec.version       = SknUtils::VERSION
   spec.author        = 'James Scott Jr'
   spec.email         = 'skoona@gmail.com'  
-  spec.summary       = <<-EOF
-SknUtils contains a small collection of Ruby utilities, the first being a NestedResult a key/value container.
-EOF
-
-  spec.description   = <<-EOF
-The intent of the NestedResult class is to be a container for data values composed of key/value pairs, 
-with easy access to its contents, and on-demand transformation back to the hash (#to_hash).
+  spec.summary       = <<-DESC
+Ruby utilities for dependency injection/lookup, class customizations, and dot.notion access over nested hashes.
+  DESC
+  spec.description   = <<-DESC
+Value containers supporting nested dot.notation access over hashes, and utilities offering dependency injection/lookup, and 
+language extensions support running in a non-rails environment.  Plus, examples of null objects, class customization, 
+and concurrent processing.
 
 Review the RSpec tests, and or review the README for more details.
-EOF
-  spec.post_install_message = <<-EOF
+  DESC
+
+  spec.post_install_message = <<-DESC
 This version includes modified versions of SknUtils::ResultBean, SknUtils::PageControls classes, which inherit from  
 SknUtils::NestedResult class.  SknUtils::NestedResult replaces those original classes and consolidates their function.  
-EOF
+  DESC
+
   spec.homepage      = "https://github.com/skoona/skn_utils"
   spec.license       = "MIT"
   spec.platform      = Gem::Platform::RUBY
-  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files          = `git ls-files -z`.split("\x0")
   spec.executables   = []
-  spec.test_files    = spec.files.grep(%r{^(spec)/})
-  spec.require_paths = ['lib']
+  spec.test_files     = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = %w[lib]
+  spec.extra_rdoc_files = Dir["README.md", "CODE_OF_CONDUCT.md", "LICENSE"]
 
   spec.add_runtime_dependency 'deep_merge', '~> 1'
   spec.add_runtime_dependency 'concurrent-ruby', '~> 1'
   spec.add_runtime_dependency 'thor', '~> 0'
 
-  spec.add_development_dependency "bundler",   "~> 1"
-  spec.add_development_dependency "rake",      "~> 10"
-  spec.add_development_dependency "rspec",     '~> 3'
-  spec.add_development_dependency "pry",       "~> 0"
+  spec.add_development_dependency "bundler",   ">= 1"
+  spec.add_development_dependency "rake",      ">= 12.3.3"
+  spec.add_development_dependency "rspec",     '>= 3'
+  spec.add_development_dependency "pry",       ">= 0"
   spec.add_development_dependency "pry-coolline"
-  spec.add_development_dependency "simplecov", "~> 0"
-  spec.add_development_dependency 'benchmark-ips', '~> 2'
+  spec.add_development_dependency "simplecov", ">= 0"
+  spec.add_development_dependency 'benchmark-ips', '>= 2'
   spec.add_development_dependency 'webmock'
 
-
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skn_utils
 version: !ruby/object:Gem::Version
-  version: 5.7.0
+  version: 5.8.0
 platform: ruby
 authors:
 - James Scott Jr
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-03 00:00:00.000000000 Z
+date: 2020-05-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge
@@ -56,56 +56,56 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -126,28 +126,28 @@ dependencies:
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2'
 - !ruby/object:Gem::Dependency
@@ -164,14 +164,18 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "The intent of the NestedResult class is to be a container for data values
-  composed of key/value pairs, \nwith easy access to its contents, and on-demand transformation
-  back to the hash (#to_hash).\n\nReview the RSpec tests, and or review the README
+description: "Value containers supporting nested dot.notation access over hashes,
+  and utilities offering dependency injection/lookup, and \nlanguage extensions support
+  running in a non-rails environment.  Plus, examples of null objects, class customization,
+  \nand concurrent processing.\n\nReview the RSpec tests, and or review the README
   for more details.\n"
 email: skoona@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- README.md
+- CODE_OF_CONDUCT.md
+- LICENSE
 files:
 - ".gitignore"
 - ".rspec"
@@ -180,7 +184,6 @@ files:
 - Gemfile
 - LICENSE
 - README.md
-- README.rdoc
 - Rakefile
 - _config.yml
 - bin/bench_nested_result.rb
@@ -266,11 +269,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
-summary: SknUtils contains a small collection of Ruby utilities, the first being a
-  NestedResult a key/value container.
+summary: Ruby utilities for dependency injection/lookup, class customizations, and
+  dot.notion access over nested hashes.
 test_files:
 - spec/factories/environments/development.yml
 - spec/factories/environments/production.yml

data/README.rdoc

@@ -1,379 +0,0 @@
-[![Gem Version](https://badge.fury.io/rb/skn_utils.svg)](http://badge.fury.io/rb/skn_utils)
-
-= SknUtils
-==== SknUtils::NestedResult class; dynamic key/value container
-The intent of this gem is to be a container of data results or key/value pairs, with easy access to its contents, and on-demand transformation back to the hash (#to_hash).
-
-Ruby Gem containing a Ruby PORO (Plain Old Ruby Object) that can be instantiated at runtime with an input hash.  This library creates
- an Object with Dot or Hash notational accessors to each key's value.  Additional key/value pairs can be added post-create
- by 'obj.my_new_var = "some value"', or simply assigning it.
-
-* Transforms the initialization hash into accessable object instance values, with their keys as method names.
-* If the key's value is also a hash, it too will become an Object.
-* if the key's value is a Array of Hashes, or Array of Arrays of Hashes, each element of the Arrays will become an Object.
-* The current key/value (including nested) pairs are returned via #to_hash or #to_json when and if needed.
-
-
-== New Features
-    03/2017  V3.0.0
-    Added SknUtils::NestedResult to replace, or be an alternate, to ResultBean, GenericBean, PageControls, ValueBean, and AttributeHelper.
-    NestedResult overcome issues with serialization via Marshal and Yaml/Psych.
-    NestedResult will properly encode all hash based key/value pairs of input and decodes it via #to_h or #to_json
-    NestedResult encodes everything given no matter how deeply its nested, unlike the prior version where you had control over nesting.
-
-    10/2016  V2.0.6
-    Added an SknUtils::NullObject and SknUtils::nullable?(value) extracted from [Avdi Grimm's Confident Code](https://gist.github.com/jschoolcraft/979827)
-    The NullObject class has great all around utility, check out it's specs!
-
-    08/2016  V2.0.3
-    Added an exploritory ActionService class and RSpec test, triggered by reading [Kamil Lelonek](https://blog.lelonek.me/what-service-objects-are-not-7abef8aa2f99#.p64vudxq4)
-    I don't support his approach, but the CreateTask class caught my attention as a Rubyist.
-
-    12/2015  V2.0
-	All references to ActiveRecord or Rails has been removed to allow use in non-Rails environments
-    as a result serialization is done with standard Ruby Hash serialization methods; by first transforming
-    object back to a hash using its #to_hash method.
-
-	06/2015  V1.5.1 commit #67ef656
-	Last Version to depend on Rails (ActiveModel) for #to_json and #to_xml serialization
-
-
-== Configuration Options
-    None required other than initialization hash
-
-
-== Public Methods
-    Each concrete Class supports the following utility methods:
-      #to_hash                       -- returns a hash of current key/value pairs, including nested
-      #to_json                       -- returns a json string of current key/value pairs, including nested
-      #hash_from(:base_key)          -- exports the internal hash starting with this base level key
-      #obj.obj2.hash_from(:base)     -- exports the internal hash starting from this nested base level key
-      #[]                            -- returns value of attr, when #[<attr_name_symbol>]
-      #[]=(attr, value)              -- assigns value to existing attr, or creates a new key/value pair
-      #<attr>?                       -- detects true/false presence? of attr, and non-blank existance of attr's value; when #address?
-      #<attr>                        -- returns value of named attribute
-      #<attr> = (value)              -- assigns value to existing attr, or creates a new key/value pair
-      -- Where <attr> is a key value from the initial hash, or a key that was/will be dynamically added
-
-
-
-== Public Components
-    SknUtils::NestedResult                # >= V 3.0.0 Primary Key/Value Container with Dot/Hash notiation support.
-
-
-    *** <= V 2.0.6 Depreciated, will be removed in next release ***
-
-    Inherit from NestedResultBase or instantiate an pre-built Class:
-      SknUtils::ResultBean                # => Not Serializable and follows hash values only.
-      SknUtils::PageControls              # => Serializable and follows hash values and arrays of hashes.
-      SknUtils::GenericBean               # => Serializable and follows hash values only.
-      SknUtils::ValueBean                 # => Serializable and DOES NOT follows hash values.
-    or Include SknUtils::AttributeHelpers # => Adds getter/setters, and hash notation access to instance vars of any object.
-
-
-== Basic features include:
-```ruby
- - provides the hash or dot notation methods of accessing values:
-
-     $ obj = SknUtils::NestedResult.new({value1: "some value", value2: {one: 1, two: "two"}})
-     $ x = obj.value1
-     $ x = obj.value2.one
-     $ x = obj["value1"]
-     $ x = obj[:value1]
-
- - enables serialization:
-    Internally supports #to_hash and #to_json
-
-    $ person = SknUtils::NestedResult.new({name: "Bob"})
-    $ person.to_hash             # => {"name"=>"Bob"}
-    $ person.to_json             # => "{\"name\":\"Bob\"}"
-    $ dmp = Marshal.dump(person) # => "\x04\bo:\x1ASknUtils::NestedResult\x06:\n@nameI\"\bBob\x06:\x06ET"
-    $ person2 = Marshal.load(dmp) # => #<SknUtils::NestedResult:0x007faede906d40 @name="Bob">
-
- - post create additions:
-
-    'obj = SknUtils::NestedResult.new({value1: "some value", value2: {one: 1, two: "two"}})
-    'x = obj.one'                          --causes NoMethodError
-    'x = obj.one = 'some other value'      --creates a new instance value with accessors
-    'x = obj.one = {key1: 1, two: "two"}'  --creates a new ***bean as the value of obj.one
-    'y = obj.one.two'                      --returns "two"
-    'y = obj.one[:two]                     --returns "two"
-    'y = obj.one['two']                    --returns "two"
-
- - supports predicates <attr>? method patterns:  target must exist and have a non-empty/valid value
-
-    $ obj = SknUtils::NestedResult.new({name: "Something", active: false, phone: "2609998888"})'
-    $ obj.name?'       # => true         -- true or false, like obj.name.present?
-    $ obj.active?      # => true         -- your asking if method exist with a valid value, not what the value is!
-    $ obj.street?      # => false
-```
-
-
-== Usage:
-
-* The NestedResult produces these effects when given a params hash;
-* Follow VALUES that are Hashes, Arrays of Hashes, and Arrays of Arrays of Hashes
-```ruby
-    drb = SknUtils::NestedResult.new(params)                          Basic dot notation:
-    ----------------------------------------------------      -----------------------------------------------------------------
-
-    * params = {one: 1,                                         drb.one      = 1
-                two: { one: 1, two: "two"},                     drb.two      = <SknUtils::NestedResult>
-                                                                drb.two.two  = 'two'
-
-                three: [ {one: 'one', two: 2},                  drb.three.first.one  = 'one'
-                         {three: 'three', four: 4}              drb.three[1].four = 4
-                       ],                                       drb.three.last.three = 'three'
-
-                four: [
-                        [ {one: 'one', two: 2},                 drb.four.first.first.one  = 'one'
-                          {three: 'three', four: 4} ],          drb.four.first.last.four = 4
-                        [ { 5: 'five', 6: 'six'},               drb.four[1][0][5] = 'five'     # number keys require hash notation :[]
-                          {five: '5', six: 6} ]                 drb.four[1].last.six = 6
-                      ],
-           'five' => [1, 2, 3]                                  drb.five = [1, 2, 3]
-                6 => 'number key'                               drb[6] = 'number key'
-               }
-```
-
-* Expected usage
-```ruby
-       result =  SknUtils::NestedResult.new({
-                           success: true,
-                           message: "",
-                           payload: {package: 'of key/value pairs from operations'}
-       })
-       ...
-
-       if result.success && result.payload.package?
-        # do something with result.payload
-       end
-```
-
-
-* Wrap additional methods around the core NestedResult feature set
-```ruby
-       class MyPackage < SknUtils::NestedResult
-          def initialize(params={})
-            super
-          end
-
-          def additional_method
-            # do something
-          end
-       end
-```
-
-
-== Installation
-
-runtime prereqs:
-    V3+ None
-    V2+ None
-    V1+ gem 'active_model', '~> 3.0'
-
-
-Add this line to your application's Gemfile:
-```ruby
-gem 'skn_utils'
-```
-
-
-And then execute:
-    $ bundle
-
-
-Or install it yourself as:
-    $ gem install skn_utils
-
-
-== Build
-
-1. $ git clone git@github.com:skoona/skn_utils.git
-2. $ cd skn_utils
-3. $ gem install bundler
-4. $ bundle install
-5. $ bundle exec rspec
-6. $ gem build skn_utils.gemspec
-7. $ gem install skn_utils
-* Done
-
-
-== Console Workout
-
-Start with building gem first.
-```bash
-$ cd skn_utils
-$ bin/console
-
-[1] pry(main)> rb = SknUtils::NestedResult.new({sample: [{one: "one", two: "two"},{one: 1, two: 2}] })
-[2] pry(main)> pg = SknUtils::NestedResult.new({sample: [{three: 3, four: 4},{five: 'five', two: 'two'}] })
-[3] pry(main)> pg.sample.first.three
-[4] pry(main)> rb.sample.first.one
-[5] pry(main)> rb.sample.first[:one]
-[6] pry(main)> rb.hash_from(:sample)
-[7] pry(main)> rb.sample?
-[8] pry(main)> rb.sample[0].one?
-
-[n] pry(main)> exit
-* Done
-```
-
-== Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
-
-
-== License
-
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
-=== Notes:
-```ruby
-class ApplicationSchema < Dry::Validation::Schema
-  configure do |config|
-    option :record
-    option :machine_repository, Machine
-    option :user_repository, User
-    option :temporary_token_repository, TemporaryToken
-
-    config.messages_file = 'config/locales/validations.yml'
-  end
-
-...
-
-end
-
-module Sessions
-  AuthenticateUserSchema = Dry::Validation.Schema(ApplicationSchema) do
-    required(:email).filled(:str?)
-    required(:password).filled(:str?)
-
-    validate(exists?: :email) do |email|
-      user_repository.find_by(email: email).present?
-    end
-  end
-end
-```
-
-from: Andy Holland @AMHOL, roda-action
-```ruby
-class Roda
-  ContainerError = Class.new(::Exception)
-
-  module RodaPlugins
-    # The container plugin allows your application to
-    # act as a container, you can register values
-    # with your application (container) and resolve them later.
-    #
-    # If you register something that responds to call, the result of
-    # call will be returned each time you resolve it.
-    #
-    # Example:
-    #
-    #   plugin :container
-    #
-    #   class UserRepository
-    #     def self.first
-    #       { name: 'Jack' }
-    #     end
-    #   end
-    #
-    #   MyApplication.register(:user_repository, UserRepository)
-    #   MyApplication.resolve(:user_repository).first
-    #
-    #   class PersonRepository
-    #     def first
-    #       { name: 'Gill' }
-    #     end
-    #   end
-    #
-    #   MyApplication.register(:person_repository, -> { PersonRepository.new })
-    #   MyApplication.resolve(:person_repository).first
-    module Container
-      class Container < RodaCache
-        def register(key, contents = nil, options = {}, &block)
-          if block_given?
-            item = block
-            options = contents if contents.is_a?(::Hash)
-          else
-            item = contents
-          end
-
-          self[key] = Content.new(item, options)
-        end
-
-        def resolve(key)
-          content = self.fetch(key) do
-            fail ::Roda::ContainerError, "Nothing registered with the name #{key}"
-          end
-
-          content.call
-        end
-      end
-
-      class Content
-        attr_reader :item, :options
-
-        def initialize(item, options = {})
-          @item, @options = item, {
-            call: item.is_a?(::Proc)
-          }.merge(options)
-        end
-
-        def call
-          if options[:call] == true
-            item.call
-          else
-            item
-          end
-        end
-      end
-
-      module ClassMethods
-        attr_reader :container
-        private :container
-
-        def self.extended(subclass)
-          subclass.instance_variable_set(:@container, Container.new)
-          super
-        end
-
-        def inherited(subclass)
-          subclass.instance_variable_set(:@container, container)
-          super
-        end
-
-        def instance
-          Thread.current[:__container__]
-        end
-
-        def register(key, contents = nil, options = {}, &block)
-          container.register(key, contents, options, &block)
-        end
-
-        def resolve(key)
-          container.resolve(key)
-        end
-
-        def detach_container
-          @container = container.dup
-        end
-      end
-
-      module InstanceMethods
-        def call(*args, &block)
-          Thread.current[:__container__] = self.class.send(:container).dup
-          super
-        end
-      end
-    end
-
-    register_plugin(:container, Container)
-  end
-end
-```