skn_utils 5.4.1 → 5.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a38f9d3fd144a0b4d591b492fd5dd4ba2c9e448a
-  data.tar.gz: 9d5bdceb553ee84f17d37c8f8b3c06d1126f831e
+  metadata.gz: 9a78df2df5ed11a61cea3d00b0f3543295e3ce5b
+  data.tar.gz: eb021f9d1f707e8e08411b542b05959061322d25
 SHA512:
-  metadata.gz: c1d14426f03a6b19cb668f596ccf777352e78295c3c36c7dbe11b56939e90e0b79adb3676b09ab16a61f3167b8089c2f97a40ef846185ac17b527bac04edab04
-  data.tar.gz: 296386960a3ee3d438334fb1a0ded9ae275632ce5bbf6f486cbdbdab18b5904d6f82c9b33373a0632e7c14e34156230ba2b6c1c9008c27305ba7541f15b0435b
+  metadata.gz: 0ee33852c9675b13b64a8beb22fdd26fa6afd09994ee4809e4d2fc84bbc46201f469f9b715f4a7ba2291abadd3f5de36f6d98d257c3cc1f085b29f4f7c316374
+  data.tar.gz: d7ff622a8c1dc13ab5a0438c08b5f9f0e5fc04f32c989bcc8ab32d8d08243cae69c1cd6ce985c0a7871b7784f56a181d6ed6ab8879282e9c139588cbd4112f95

data/.rspec

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

data/README.md

@@ -2,68 +2,81 @@
 [![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`.
+
+*   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)
 
 
-
 ## History
+    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,6 +167,43 @@ 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?` ...
+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.
@@ -171,6 +221,14 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
     SknSuccess                       # Three attribute value containers for 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
@@ -239,8 +297,8 @@ 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.
+## 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.
     
@@ -266,9 +324,69 @@ There are many more use cases for Ruby's Hash that this gem just makes easier to
             same_instance = SknContainer.resolve(:the_instance)
 
 
+## 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.
+    
+        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 ONLY
-    SknSettings is global constant containing an initialized Object of SknUtils::Configuration using defaults
+    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/'
@@ -420,10 +538,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/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

data/bin/concurrent_test_grouped

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+# file: concurrent_test_grouped
+#
+
+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
+  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

data/bin/concurrent_test_procs

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+#
+# file: concurrent_test_procs
+#
+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
+  work_proc = ->(cmd) { SknSuccess.(cmd.uri.request_uri, "Ok") }  # mis-spelling these params result in [SknFailure, SknFailure, ...] results
+  provider.register_jobs(commands, work_proc)
+
+  # 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

data/bin/concurrent_test_wrapped

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+#
+# file: concurrent_test_wrapped
+#
+
+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
+      SknUtils::JobWrapper.call(command, SknUtils::HttpProcessor)  # mis-spelling these params result in [nil, nil, ...] results
+    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

data/lib/skn_utils.rb

@@ -10,9 +10,12 @@ require 'time'
 require 'concurrent'
 unless defined?(Rails)
   begin
+    require "uri"
+    require "net/http"
+    require 'net/https'
     require 'deep_merge'
   rescue LoadError => e
-    puts e.message
+    $stderr.puts e.message, e.backtrace
   end
 end
 require 'skn_utils/core_extensions'
@@ -29,6 +32,10 @@ require 'skn_utils/configuration'
 require 'skn_utils/configurable'
 require 'skn_utils/wrappable'
 
+require "skn_utils/job_commands"
+require "skn_utils/http_processor"
+require "skn_utils/concurrent_jobs"
+
 require 'skn_hash'
 require 'skn_registry'
 require 'skn_container'
@@ -51,7 +58,7 @@ module SknUtils
       [SknFailure, SknFailure].any? {|o| res.kind_of?(o) } ? res : SknSuccess.( res )
 
     rescue StandardError, ScriptError => error
-      puts "#{retry_count} - #{error.class.name}:#{error.message}"
+      $stderr.puts "#{retry_count} - #{error.class.name}:#{error.message}"
       if retry_count <= attempts
         retry_count+= 1
         sleep(pause_between)
@@ -89,3 +96,4 @@ module SknUtils
   end
 
 end
+

data/lib/skn_utils/concurrent_jobs.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+# ##
+#
+#
+# See JobCommands, HttpProcessor, ...
+# See ./bin/par_test_[block|grouped|wrapped] examples
+#
+
+module SknUtils
+
+  class SyncWorker
+    def initialize(&blk)
+      @blk = blk
+    end
+
+    def call
+      @blk.call
+    end
+  end
+
+  class AsyncWorker
+    def initialize(&blk)
+      @blk = Concurrent::Promise.execute(&blk)
+    end
+
+    def call
+      @blk.value
+    end
+  end
+
+  class Result
+    def initialize(merged)
+      @merged = merged
+    end
+
+    def success?
+      @merged.all?(&:success) rescue false
+    end
+
+    def messages
+      @merged.map(&:message)&.compact rescue []
+    end
+
+    def values
+      @merged
+    end
+  end
+
+  class JobWrapper
+    def self.call(command, callable)
+      callable.call(command)
+    rescue => ex
+      SknFailure.(ex.class.name, "#{ex.message}; #{ex.backtrace[0]}")
+    end
+  end
+
+  class ConcurrentJobs
+    attr_reader :elapsed_time_string
+
+    def self.call(async: true)
+      worker = async ? AsyncWorker : SyncWorker
+      new(worker: worker)
+    end
+
+    def initialize(worker:)
+      @worker  = worker
+      @workers = []
+    end
+
+    # commands: array of command objects related to callable
+    # callable: callable class or proc, ex:SknUtils::HttpProcessor
+    # callable must return SknSuccess || SknFailure
+    def register_jobs(commands, callable)
+      commands.each do |command|
+        register_job do
+          JobWrapper.call(command,callable)
+        end
+      end
+    end
+
+    def register_job(&blk)
+      @workers << @worker.new(&blk)
+    end
+
+    def render_jobs
+      stime = SknUtils.duration
+      merged = @workers.each_with_object([]) do |worker, acc|
+        acc.push( worker.call )
+      end
+      @elapsed_time_string = SknUtils.duration(stime)
+      Result.new(merged)
+    rescue => e
+      Result.new(merged || [])
+    end
+  end
+end

data/lib/skn_utils/http_processor.rb

@@ -0,0 +1,34 @@
+# ##
+#
+#
+module SknUtils
+
+  class HttpProcessor
+
+    def self.call(command)
+      completion = false
+
+      response = Net::HTTP.start( command.uri.host,command.uri.port,
+                                  use_ssl: command.uri.scheme.eql?("https")
+      ) do |http|
+        http.open_timeout = 5           # in seconds, for internal http timeouts
+        http.read_timeout = 15          # in seconds
+        if command.uri.scheme.eql?("https")
+          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        end
+        http.request(command.request)
+      end
+
+      if ( response.kind_of?(Net::HTTPClientError) or response.kind_of?(Net::HTTPServerError) )
+        completion = SknFailure.call(response.code, response.message)
+      else
+        payload = command.json? ? JSON.load(response.body) : response.body
+        completion = SknSuccess.call(payload, response.class.name)
+      end
+
+      completion
+    rescue => exception
+      SknFailure.call(command.uri.request_uri, "#{exception.message}; #{exception.backtrace[0]}")
+    end
+  end
+end

data/lib/skn_utils/job_commands.rb

@@ -0,0 +1,201 @@
+# ##
+#
+# Ref: https://yukimotopress.github.io/http
+
+module SknUtils
+
+  # #################################################
+  #
+  class CommandJSONPost
+    def self.call(options)  # {full_url:,username:,userpass:,payload:}
+      new(options)
+    end
+
+    def json?
+      true
+    end
+
+    def uri
+      @_uri
+    end
+
+    def request
+      req = Net::HTTP::Post.new(uri.path)        # 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]
+      @_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
+
+
+  # #################################################
+  #
+  class CommandFORMPost
+    def self.call(options)  # {full_url:,username:,userpass:,payload:}
+      new(options)
+    end
+
+    def json?
+      false
+    end
+
+    def uri
+      @_uri
+    end
+
+    def request
+      req = Net::HTTP::Post.new(uri.path)        # Generate HTTPRequest object
+      req.basic_auth(@_username, @_userpass) if credentials?
+      req.content_type = 'application/x-www-form-urlencoded'
+      req.set_form_data(formatted_data)
+      req
+    end
+
+    private
+
+    def initialize(opts={})
+      @_username = opts[:username]
+      @_userpass = opts[:userpass]
+      @_uri      = URI.parse( opts[:full_url])
+      @_data     = opts[:payload]
+    end
+
+    def formatted_data
+      @_data
+    end
+
+    def credentials?
+      !(@_username.nil? || @_userpass.nil?)
+    end
+  end
+
+
+  # #################################################
+  #
+  class CommandJSONGet
+    def self.call(options)  # {full_url:,username:,userpass:}
+      new(options)
+    end
+
+    def json?
+      true
+    end
+
+    def uri
+      @_uri
+    end
+
+    def request
+      req = Net::HTTP::Get.new(uri.request_uri)
+      req.basic_auth(@_username, @_userpass) if credentials?
+      req
+    end
+
+    private
+
+    def initialize(opts={})
+      @_username = opts[:username]
+      @_userpass = opts[:userpass]
+      @_uri      = URI.parse( opts[:full_url])
+    end
+
+    def credentials?
+      !(@_username.nil? || @_userpass.nil?)
+    end
+  end
+
+
+  # #################################################
+  #
+  class CommandJSONPut
+    def self.call(options)  # {full_url:,username:,userpass:,payload:}
+      new(options)
+    end
+
+    def json?
+      true
+    end
+
+    def uri
+      @_uri
+    end
+
+    def request
+      req = Net::HTTP::Put.new(uri.path)        # 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]
+      @_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
+
+
+  # #################################################
+  #
+  class CommandFORMDelete
+    def self.call(options)  # {full_url:,username:,userpass:}
+      new(options)
+    end
+
+    def json?
+      false
+    end
+
+    def uri
+      @_uri
+    end
+
+    def request
+      req = Net::HTTP::Delete.new(uri.request_uri)
+      req.basic_auth(@_username, @_userpass) if credentials?
+      req
+    end
+
+    private
+
+    def initialize(opts={})
+      @_username = opts[:username]
+      @_userpass = opts[:userpass]
+      @_uri      = URI.parse( opts[:full_url])
+    end
+
+    def credentials?
+      !(@_username.nil? || @_userpass.nil?)
+    end
+  end
+end

data/lib/skn_utils/version.rb

@@ -4,8 +4,8 @@
 module SknUtils
   class Version
     MAJOR = 5
-    MINOR = 4
-    PATCH = 1
+    MINOR = 5
+    PATCH = 0
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/skn_utils.gemspec

@@ -39,7 +39,10 @@ EOF
   spec.add_development_dependency "rake",      "~> 10"
   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 'webmock'
+
 
 end

data/spec/lib/skn_utils/concurrent_jobs_spec.rb

@@ -0,0 +1,277 @@
+##
+# spec/lib/skn_utils/as_human_size_spec.rb
+#
+
+
+describe SknUtils::ConcurrentJobs, 'Run Multiple Jobs' do
+
+  let(:commands) {
+    [
+        SknUtils::CommandJSONPost.call(full_url: "http://example.com/posts", payload: {one: 1}),
+        SknUtils::CommandFORMPost.call(full_url: "http://example.com/posts", payload: {one: 1}),
+        SknUtils::CommandJSONGet.call(full_url: "http://example.com/posts/1"),
+        SknUtils::CommandJSONPut.call(full_url: "http://example.com/posts", payload: {one: 1}),
+        SknUtils::CommandFORMDelete.call(full_url: "http://example.com/posts/1")
+    ]
+  }
+
+  let(:test_proc) {
+    ->(cmd) { SknSuccess.(cmd.uri.request_uri, "Ok") }
+  }
+
+  let(:inline_failure_proc) {
+    ->(cmd) { SknFailure.(cmd.uri.request_uri, "Failure") }
+  }
+
+  let(:catastrophic_proc) {
+    ->(cmd) { SomeUnkownThing.(cmd.uri.request_uri, "Catastrophic") }
+  }
+
+  context "HTTP Requests " do
+    it "Job Commands will provide a valid http request object" do
+      expect(commands.any?(&:request)).to be true
+    end
+
+    it "Performs Http Post Requests" do
+      test_url = "http://jsonplaceholder.typicode.com/users"
+      stub_request(:post, test_url).
+          to_return(status: 200, body: "{\"message\":\"me\"}", headers: {})
+
+      cmd = SknUtils::CommandJSONPost.call(full_url: test_url, payload: {"one" => 1})
+
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_job do
+        SknUtils::JobWrapper.call(cmd, SknUtils::HttpProcessor)
+      end
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be true
+      expect(result.values.size).to eq(1)
+      expect(result.values[0]).to be_a(SknSuccess)
+      expect(result.values[0].value).to be_a(Hash)
+      expect(result.values[0].value["message"]).to eq("me")
+    end
+
+    it "Performs Http Form Post Requests" do
+      test_url = "http://jsonplaceholder.typicode.com/users"
+      stub_request(:post, test_url).
+          to_return(status: 200, body: "message=me", headers: {})
+
+      cmd = SknUtils::CommandFORMPost.call(full_url: test_url, payload: {"one" => 1})
+
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_job do
+        SknUtils::JobWrapper.call(cmd, SknUtils::HttpProcessor)
+      end
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be true
+      expect(result.values.size).to eq(1)
+      expect(result.values[0]).to be_a(SknSuccess)
+      expect(result.values[0].value).to be_a(String)
+      expect(result.values[0].value).to eq("message=me")
+    end
+
+    it "Performs Http Get Requests" do
+      test_url = "http://jsonplaceholder.typicode.com/users"
+      stub_request(:get, test_url).
+          to_return(status: 200, body: "{\"message\":\"me\"}", headers: {})
+
+      cmd = SknUtils::CommandJSONGet.call(full_url: test_url)
+
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_job do
+        SknUtils::JobWrapper.call(cmd, SknUtils::HttpProcessor)
+      end
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be true
+      expect(result.values.size).to eq(1)
+      expect(result.values[0]).to be_a(SknSuccess)
+      expect(result.values[0].value).to be_a(Hash)
+      expect(result.values[0].value["message"]).to eq("me")
+    end
+
+    it "Performs Http Put Requests" do
+      test_url = "http://jsonplaceholder.typicode.com/users"
+      stub_request(:put, test_url).
+          to_return(status: 200, body: "{\"message\":\"me\"}", headers: {})
+
+      cmd = SknUtils::CommandJSONPut.call(full_url: test_url, payload: {"one" => 1})
+
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_job do
+        SknUtils::JobWrapper.call(cmd, SknUtils::HttpProcessor)
+      end
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be true
+      expect(result.values.size).to eq(1)
+      expect(result.values[0]).to be_a(SknSuccess)
+      expect(result.values[0].value).to be_a(Hash)
+      expect(result.values[0].value["message"]).to eq("me")
+    end
+
+    it "Performs Http Form Delete Requests" do
+      test_url = "http://jsonplaceholder.typicode.com/users"
+      stub_request(:delete, test_url).
+          to_return(status: 200, body: "message=me", headers: {})
+
+      cmd = SknUtils::CommandFORMDelete.call(full_url: test_url, payload: {"one" => 1})
+
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_job do
+        SknUtils::JobWrapper.call(cmd, SknUtils::HttpProcessor)
+      end
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be true
+      expect(result.values.size).to eq(1)
+      expect(result.values[0]).to be_a(SknSuccess)
+      expect(result.values[0].value).to be_a(String)
+      expect(result.values[0].value).to eq("message=me")
+    end
+  end
+
+  context "Asynchronous" do
+    it "Runs Jobs" do
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_jobs(commands, test_proc)
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be true
+      expect(result.values.size).to eq(commands.size)
+      expect(result.values[0]).to be_a(SknSuccess)
+    end
+    it "Runs Jobs and handles inline failures" do
+      provider = SknUtils::ConcurrentJobs.call
+
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[0], test_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[1], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[2], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[3], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[4], test_proc)
+      end
+
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be false
+      expect(result.values.size).to eq(commands.size)
+      expect(result.values[1]).to be_a(SknFailure)
+      expect(result.values[1].message).to eq("Failure")
+    end
+    it "Runs Jobs and handles catastrophic failures" do
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_job do
+        SknUtils::JobWrapper.call(command[0], test_proc)
+      end
+      provider.register_job do  # notice `command` vs `commands`
+        SknUtils::JobWrapper.call(command[1], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(command[2], catastrophic_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[3], catastrophic_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[4], test_proc)
+      end
+
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be false
+      expect(result.values.size).to eq(commands.size)
+      expect(result.values[3].value).to eq("NameError")
+      expect(result.values[3]).to be_a(SknFailure)
+      expect(result.values[3]).to be_a(SknFailure)
+      expect(result.values[0]).to be nil
+    end
+  end
+
+  context "Synchronous" do
+    it "Runs Jobs" do
+      provider = SknUtils::ConcurrentJobs.call(async: false)
+      provider.register_jobs(commands, test_proc)
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be true
+      expect(result.values.size).to eq(commands.size)
+      expect(result.values[0]).to be_a(SknSuccess)
+    end
+    it "Runs Jobs and handles inline failures" do
+      provider = SknUtils::ConcurrentJobs.call
+
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[0], test_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[1], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[2], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[3], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[4], test_proc)
+      end
+
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be false
+      expect(result.values.size).to eq(commands.size)
+      expect(result.values[1]).to be_a(SknFailure)
+      expect(result.values[1].message).to eq("Failure")
+    end
+    it "Runs Jobs and handles catastrophic failures" do
+      provider = SknUtils::ConcurrentJobs.call
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[0], test_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[1], inline_failure_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[2], catastrophic_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[3], catastrophic_proc)
+      end
+      provider.register_job do
+        SknUtils::JobWrapper.call(commands[4], test_proc)
+      end
+
+      result = provider.render_jobs
+
+      expect(result).to be_a(SknUtils::Result)
+      expect(result.success?).to be false
+      expect(result.values.size).to eq(commands.size)
+      expect(result.values[3].value).to eq("NameError")
+      expect(result.values[2]).to be_a(SknFailure)
+      expect(result.values[1]).to be_a(SknFailure)
+      expect(result.values[0]).to be_a(SknSuccess)
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -15,6 +15,8 @@ end
 require 'skn_utils'
 require 'rspec'
 
+require 'webmock/rspec'
+
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 RSpec.configure do |config|
   Kernel.srand config.seed
@@ -30,6 +32,8 @@ RSpec.configure do |config|
   # config.disable_monkey_patching!  # -- breaks rspec runtime
   config.warnings = true
 
+  config.include WebMock::API
+
   if config.files_to_run.one?
     config.formatter = :documentation
   else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skn_utils
 version: !ruby/object:Gem::Version
-  version: 5.4.1
+  version: 5.5.0
 platform: ruby
 authors:
 - James Scott Jr
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-02 00:00:00.000000000 Z
+date: 2019-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: deep_merge
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-coolline
+  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: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -136,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
 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
@@ -156,6 +184,10 @@ files:
 - Rakefile
 - _config.yml
 - bin/bench_nested_result.rb
+- bin/concurrent_test_block
+- bin/concurrent_test_grouped
+- bin/concurrent_test_procs
+- bin/concurrent_test_wrapped
 - bin/configs/settings.yml
 - bin/configs/settings/development.yml
 - bin/configs/settings/production.yml
@@ -172,11 +204,14 @@ files:
 - lib/skn_settings.rb
 - lib/skn_success.rb
 - lib/skn_utils.rb
+- lib/skn_utils/concurrent_jobs.rb
 - lib/skn_utils/configurable.rb
 - lib/skn_utils/configuration.rb
 - lib/skn_utils/core_extensions.rb
 - lib/skn_utils/dotted_hash.rb
 - lib/skn_utils/env_string_handler.rb
+- lib/skn_utils/http_processor.rb
+- lib/skn_utils/job_commands.rb
 - lib/skn_utils/nested_result.rb
 - lib/skn_utils/notifier_base.rb
 - lib/skn_utils/null_object.rb
@@ -196,6 +231,7 @@ files:
 - spec/lib/skn_settings_spec.rb
 - spec/lib/skn_utils/as_human_size_spec.rb
 - spec/lib/skn_utils/catch_exceptions_spec.rb
+- spec/lib/skn_utils/concurrent_jobs_spec.rb
 - spec/lib/skn_utils/configurable_spec.rb
 - spec/lib/skn_utils/container_spec.rb
 - spec/lib/skn_utils/nested_result_spec.rb
@@ -246,6 +282,7 @@ test_files:
 - spec/lib/skn_settings_spec.rb
 - spec/lib/skn_utils/as_human_size_spec.rb
 - spec/lib/skn_utils/catch_exceptions_spec.rb
+- spec/lib/skn_utils/concurrent_jobs_spec.rb
 - spec/lib/skn_utils/configurable_spec.rb
 - spec/lib/skn_utils/container_spec.rb
 - spec/lib/skn_utils/nested_result_spec.rb