skn_utils 5.4.0 → 5.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: faaa010ea403a5bfbf20386ee86a9c68e8982da1
-  data.tar.gz: 909be6bef4b46a41bfd293d35a3059396d4adba5
+SHA256:
+  metadata.gz: bdbe2b2318e4841c25afdec1e118cc19ff445f8a8b1e08d116715f5b9df0f56e
+  data.tar.gz: d42c5e55def5f8c2789714d1fada2f341f59665ba633192732b9e6b48816e253
 SHA512:
-  metadata.gz: 46f92868aaecee7ece92b3d1c4b5bc33b5643e8c2de3a5f442e5141edb2b45d5a4cb8d4bd29e24241a34001b253abec38fe381e8ca8d798dc8eb6d662fdc12c2
-  data.tar.gz: 81c41c8dda9b50797a76005a29cb329b2d8bc9da0af585d1848124a54606ac1f3a9d8bb8bb1d6ec5b2806df0002d673849425ca68290121e4ac327c7b94f784d
+  metadata.gz: b48e34a868729ed2fe63cc77c456a9b9eef99540355d4de6135c7cd5fe96c88b78519cc8384f2eb13c0a29b9652b4e84fbc1624a4674df0ec73c4f95d3762392
+  data.tar.gz: c435de19604f41834446ca04084ffc7a559267786974130edc03ad2a540f07eb08111571b13995f67e6bcfc122b215a3d5bb5cf26a905d1e3e85b31e4f0dfad3

data/.rspec

@@ -1,2 +1,4 @@
 --color
 --require spec_helper
+--format html
+--out coverage/rspec_results.html

data/README.md

@@ -2,68 +2,94 @@
 [![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
-A 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 and Hash notational accessors to each key's value.  Additional key/value pairs can be added post-create
- by simply assigning it; `obj.my_new_var = "some value"`
-
-* Transforms the initialing hash into accessible 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 hash 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.
-* Best described as dot notation wrapper over a Ruby (Concurrent-Ruby) Hash.
 
-Ruby's Hash object is already extremely flexible, even more so with the addition of dot-notation.  As I work more with Ruby outside of Rails, I'm finding more use cases for the capabilities of this gem.  Here are a few examples:
-
-1. Application settings containers, SknSettings.  Loads Yaml file based on `ENV['RACK_ENV']` value, or specified file-key.
-    - Replaces Config and/or RBConfig Gems for yaml based settings
-1. Substitute for Rails.root, via a little ERB/YAML/Marshal statement in settings.yml file, and a helper class
-    - settings.yml (YAML)
-        - `root: <%= Dir.pwd %>`
-            - 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.
-
-
-## Available Classes
-* SknSuccess
-* SknFailure
+`SknUtils` is a collection of pure-ruby utility classes and modules, with limited 
+dependencies, to augment the development of Ruby applications.  Examples of these 
+utilities in action can be found in my related projects `SknServices`, `SknWebApp`, 
+and `SknBase`.
+
+* Most classes are standalone modules, or cleary documented, and can be copy/pasted into your project.
+*   The exchange or handoff of values between objects is addressed via the `NestedResults` 
+class which implements dot-notation and nesting over a concurrent hash: A ruby Hash can 
+use any valid ruby object as a key or value. 
+*   `NestedResults` is later sub-classed as `Configuration` to provide application level 
+settings using YAML files with a API simular to the RbConfig gem.
+*   Object or method return values can be enclosed in `SknSuccess` or `SknFailure` classes 
+to prevent or minimize nil returns.
+*   Precise microsecond `duration`s, Number to `as_human_size`, and a `catch_exceptions` 
+retry-able feature are implemented on the SknUtils class directly for ease of use.
+*   `Configurable` module extends any class or module with configurable attribute method 
+as needed, with a set of defaults methods which emulate Rails.env, Rails.logger, and 
+Rails.root functionality.
+*   `CoreObjectExtensions` simular to ActiveSupport's, `#present?` and `#blank?` are 
+automatically applied, unless already present, when SknUtils gem is loaded.
+*   `SknRegistry` class is an advanced feature which allows you to manually register 
+classes, procs, or any value with a user-defined `label`.  Initialization and dependency injection 
+requirements of service-like classes can be included in this registration process allowing 
+them to be centrally maintained.  The `label` can be any valid ruby value; like a 
+classname, symbol, or string as needed
+*   `NullObject`, `NotifierBase`, and `Wrappable` are interesting classes which you might want to explore further.
+* `ConcurrentJobs` is a feature implemented to allow concurrent/multi-threaded execution of jobs.  The included 
+companion classes focus on HTTP GET,PUT,POST, and DELETE jobs as an example of how to use the `ConcurrentJobs` feature. 
+
+All classes and modules have RSpec test coverage (90+) of their originally intended 
+use-cases.    
+
+
+### Available Classes
 * SknSettings
     * SknUtils::Configuration
     * SknUtils::EnvStringHandler
-* SknRegistry
-    * SknContainer
 * SknHash
     * SknUtils::ResultBean
     * SknUtils::PageControls
     * SknUtils::NestedResult
-* SknUtils::NullObject
-* SknUtils::CoreObjectExtensions
+* SknRegistry
+    * SknContainer
+* SknSuccess
+* SknFailure
 * SknUtils::Configurable
-
-## Available Class.Methods
+* SknUtils::CoreObjectExtensions
+* SknUtils::NullObject
+* SknUtils::NotifierBase
+* SknUtils::Wrappable
+* SknUtils::ConcurrentJobs
+    * SknUtils::JobWrapper      (via ConcurrentJobs)
+    * SknUtils::CommandJSONPost (via JobCommands)
+    * SknUtils::CommandFORMPost
+    * SknUtils::CommandJSONGet
+    * SknUtils::CommandJSONPut
+    * SknUtils::CommandFORMDelete
+    * SknUtils::HttpProcessor
+
+### Available Class.Methods
 * SknUtils.catch_exceptions()
 * SknUtils.as_human_size()
 * SknUtils.duration(start_time=nil)
 
-
+### Available RSpec Helpers
+* spec/support/xml_matchers.rb
+    * expect(bundle).to have_xpath('//witnesses/witness/role')
+    * expect(bundle).to have_nodes('//witnesses/witness/role', 3)
+    * expect(bundle).to match_xpath('//lossInformation/date', "2020-01-28")
+ 
 
 ## History
+    2/3/2020 V5.7.0
+    Added
+    * RSpec XML_Matchers to spec/support folders
+    * Update ConcurrentJobs JobCommands to support HTTP Headers
+    
+    2/24/2019 V5.5.0
+    Added
+    * ConcurrentJobs feature set  
+    - Executes (HTTP/any) jobs in parallel
+
+    1/2/2019 V5.4.1
+    Added
+    - Wrappable module for evaluation. 
+    - Ruby comment # frozen_string_literal, everywhere
+     
     12/16/2018 V5.4.0
     Added :duration() utils to SknUtils module: 
         #duration()            #=> returns start_time value 
@@ -154,27 +180,66 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 	06/2015  V1.5.1 commit #67ef656
 	Last Version to depend on Rails (ActiveModel) for #to_json and #to_xml serialization
 
+### NestedResult class; dynamic key/value container
+A class implementing a Ruby PORO (Plain Old Ruby Object) that can be instantiated at runtime with a hash.  Creates
+ a nested object with Dot and Hash notational accessors to each key's value.  Additional key/value pairs can be added post-create
+ by simply assigning it; `obj.my_new_var = "some value"`
+
+* Transforms the initialing hash into accessible 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 hash 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.
+* Best described as dot notation wrapper over a Ruby (Concurrent-Ruby) Hash.
+
+Ruby's Hash object is already extremely flexible, even more so with the addition of dot-notation.  As I work more with Ruby outside of Rails, I'm finding more use cases for the capabilities of this gem.  Here are a few examples:
+
+1. Application settings containers, SknSettings.  Loads Yaml file based on `ENV['RACK_ENV']` value, or specified file-key.
+    - Replaces Config and/or RBConfig Gems for yaml based settings
+1. Substitute for Rails.root, via a little ERB/YAML/Marshal statement in settings.yml file, and a helper class
+    - settings.yml (YAML)
+        - `root: <%= Dir.pwd %>`
+            - enables `SknSettings.root`
+        - `env:  !ruby/string:SknUtils::EnvStringHandler <%= ENV.fetch('RACK_ENV', 'development') %>`
+            - enables `SknSettings.env.production?` ...
+
+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`
+        SknUtils::CommandJSONPost    # HTTP Post Command class expecting `json` return, located inside `job_commands`
+        SknUtils::CommandFORMPost    # HTTP Post Command class expecting `form` data return, located inside `job_commands`
+        SknUtils::CommandFORMDelete  # HTTP Delete Command class expecting `form` data return, located inside `job_commands`
+        SknUtils::HttpProcessor      # Command driven HTTP processing object supporting GET,PUT,POST, and DELETE
+        SknUtils::JobWrapper         # Outer wrapper class to capture catastrophic exceptions (syntax normally)
 
 
 ## 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.
   ################
@@ -239,21 +304,27 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 ```
 
 
-## Public Methods: SknContainer 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:
@@ -261,15 +332,84 @@ 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
+            - SknContainer.substitute(:the_instance, MyClass.new)              
+          - #restore! clears all mocked entries.  #restore! is an alias for #unregister_mock!
+            - SknContainer.restore!
+
+
+## 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
+           #register_jobs(cmds, callable)   - Array of Command to be executed by single callable
+           #register_job(&block)            - Adds callable block to internal worker queue
+           #render_jobs                     - Collect results from all jobs into a Result object
+           #elapsed_time_string             - "0.012 seconds" string showing duration of last #render_jobs call
+           
+           SknUtils::Result                 - Contains individual results from each job executed
+              #success?                     - Determines if any job failed
+              #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.              
+    
+Example here:
+    
+```ruby
+begin
+  # CommandJSONPost, CommandFORMGet, CommandJSONGet,
+  # CommandJSONPut, CommandFORMDelete
+  commands = [
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/posts"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/comments"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/todos/1"),
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/users")
+  ]
+
+  # Initialize the queue with Async Workers by default
+  provider = SknUtils::ConcurrentJobs.call
+
+  # Populate WorkQueue
+  provider.register_jobs(commands, SknUtils::HttpProcessor) # mis-spelling these params result in an immediate exception (line 43 below)
+
+  # Execute WorkQueue
+  result = provider.render_jobs
+
+  if result.success?
+    puts "Success: true"
+    puts "Values: #{result.values}"
+    puts "Messages: #{result.messages}"
+  else
+    puts "Success: false - errors: #{result.messages.join(', ')}"
+    puts "Values: #{result.values}"
+  end
 
+#  result.values
+rescue => e
+  $stderr.puts e.message, e.backtrace
+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 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
@@ -302,9 +442,15 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
      #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
@@ -324,6 +470,7 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 
 
 ## NestedResult Basic features include:
+
 ```ruby
  - provides the hash or dot notation methods of accessing values:
 
@@ -365,6 +512,7 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 
 * 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:
     ----------------------------------------------------      -----------------------------------------------------------------
@@ -389,6 +537,7 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 ```
 
 * Expected usage
+
 ```ruby
        result =  SknUtils::NestedResult.new({
                            success: true,
@@ -404,6 +553,7 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 
 
 * Wrap additional methods around the core NestedResult feature set
+
 ```ruby
        class MyPackage < SknUtils::NestedResult
           def initialize(params={})
@@ -420,10 +570,11 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
 ## Installation
 
 runtime prereqs:
-* V4+ None
-* V3+ None
-* V2+ None
-* V1+ gem 'active_model', '~> 3.0'
+*   V5+ None
+*   V4+ None
+*   V3+ None
+*   V2+ None
+*   V1+ gem 'active_model', '~> 3.0'
 
 
 Add this line to your application's Gemfile:

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/bin/concurrent_test_block

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+#
+# file: concurrent_test_block
+#
+
+require 'bundler/setup'
+require 'skn_utils'
+
+
+# ##
+# MainLine
+# ##
+#
+begin
+  # CommandJSONPost, CommandFORMGet, CommandJSONGet,
+  # CommandJSONPut, CommandFORMDelete
+  commands = [
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/posts"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/comments"),
+      SknUtils::CommandJSONGet.call(full_url: "https://jsonplaceholder.typicode.com/todos/1"),
+      SknUtils::CommandJSONGet.call(full_url: "http://jsonplaceholder.typicode.com/users")
+  ]
+
+  # Initialize the queue with Async Workers by default
+  provider = SknUtils::ConcurrentJobs.call
+
+  # Populate WorkQueue
+  commands.each do |command|
+    provider.register_job do
+      begin
+        SknUtils::HttpProcessor.call(command)   # mis-spelling these params result in [SknFailure, SknFailure, ...] results
+      rescue => ex
+        $stderr.puts ex
+        SknFailure.(ex.class.name, "#{ex.message}; #{ex.backtrace[0]}")
+      end
+    end
+  end
+
+  # Execute WorkQueue
+  result = provider.render_jobs
+
+  if result.success?
+    puts "Success: true"
+    puts "Values: #{result.values}"
+    puts "Messages: #{result.messages}"
+  else
+    puts "Success: false - errors: #{result.messages.join(', ')}"
+    puts "Values: #{result.values}"
+  end
+
+#  result.values
+rescue => e
+  $stderr.puts e.message, e.backtrace
+end