simple_command_dispatcher 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 978601fab3ba1ceb4f717b3b4d1d6fb13ea649f0
+  data.tar.gz: ceae85997bb18d8479845f89bf324c4d15fd4eb6
+SHA512:
+  metadata.gz: 7df1d6310235fbe4ea04e82f95f7a00d40e5790ddaf8f6a4a1722cb59b642b2ba6b209231b4497ed81edfc0da9d214bb62e6bbf307b9ff415f2bfea53f7e01b6
+  data.tar.gz: 4272706508300aa3a2e7d0760c717e5621d4db0c73cab6736eb0a5f197c192c0b4696371bc307e8882ee52d6645691036c848a8ae761c52691bb2e9004ad8b97

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.13.6

data/CHANGELOG.mb

@@ -0,0 +1,32 @@
+### Unreleased
+* Upcoming features
+  * whitelist for allowable namespaces
+
+### 1.1.1
+* Documentation updates
+  * Add example code in README.md to include clarification on command namespacing, and how to autoload command classes to avoid NameError exceptions when SimpleCommand::Dispatcher.call(...) is call due to uninitialized command constants.
+
+### 1.1.0
+* Bug fix lib/core_extensions/string.rb not included in SimpleCommand::Dispatcher, causing exception.
+
+### 1.0.0
+* Limit support to ruby >= 2.2.2
+
+### 0.2.0
+* Yanked
+
+### 0.1.3
+* Documentation updates
+* Add `SimpleCommand::KlassTransform` rake task sandbox to test the below listed `SimpleCommand::KlassTransform` members; run the rake tasks for usage; these rake tasks are simply a playground to see how simple_command_dispatcher transforms parameters into output when calling SimpleCommand::Dispatcher.call(...):
+  * `SimpleCommand::KlassTransform#to_class_string`
+    * $ rake to_class_string 
+  * `SimpleCommand::KlassTransform#to_modules_string`
+    * $ rake to_modules_string 
+  * `SimpleCommand::KlassTransform#to_constantized_class_string`
+    * $ rake to_constantized_class_string 
+
+### 0.1.2
+* Documentation updates
+
+### 0.1.1
+* Documentation updates

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at web.gma@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in simple_command_dispatcher.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 gangelo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,210 @@
+[![GitHub version](https://badge.fury.io/gh/gangelo%2Fsimple_command_dispatcher.svg)](https://badge.fury.io/gh/gangelo%2Fsimple_command_dispatcher)
+[![Gem Version](https://badge.fury.io/rb/simple_command_dispatcher.svg)](https://badge.fury.io/rb/simple_command_dispatcher)
+
+# Q. simple_command_dispatcher - what is it?
+# A. It's a Ruby gem!
+
+## Overview
+__simple_command_dispatcher__ (SCD) allows you to execute __simple_command__ commands in a more dynamic way. If you are not familiar with the _simple_command_ gem, check it out [here][simple-command]. SCD was written specifically with the [rails-api][rails-api] in mind; however, you can use SDC wherever you use simple_command commands. 
+
+## Example
+The below example is from a `rails-api` API that uses token-based authentication and services two mobile applications, identified as *__my_app1__* and *__my_app2__*, in this example.
+
+This example assumes the following:
+
+* `application_controller` is a base class, inherited by all other controllers. The `#authenticate_request` method is called for every request in order to make sure the request is authorized (`before_action :authenticate_request`).
+* `request.headers` will contain the authorization token to authorize all requests (`request.headers["Authorization"]`)
+* This application uses the following folder structure to manage its _simple_command_ commands:
+
+![N|Solid](https://cldup.com/1UeyWzOLic.png)
+
+Command classes (and the modules they reside under) are named *__according to their file name and respective location within the above folder structure__*; for example, the command class defined in the `/api/my_app1/v1/authenticate_request.rb` file would be defined in this manner:
+
+```ruby 
+# /api/my_app1/v1/authenticate_request.rb
+
+module Api 
+   module MyApp1 
+      module V1 
+         class AuthenticateRequest 
+         end 
+     end 
+   end 
+end
+```
+   
+Likewise, the command class defined in the `/api/my_app2/v2/update_user.rb` file would be defined in this manner, and so on:
+
+```ruby 
+# /api/my_app2/v2/update_user.rb
+
+module Api 
+   module MyApp2 
+      module V2 
+         class UpdateUser 
+         end 
+     end 
+   end 
+end
+```
+
+The __routes used in this example__, conform to the following format: `"/api/[app_name]/[app_version]/[controller]"` where `[app_name]` = the _application name_,`[app_version]` = the _application version_, and `[controller]` = the _controller_; therefore, running `$ rake routes` for this example would output the following sample route information:
+
+
+| Prefix        | Verb | URI Pattern | Controller#Action |
+|-------------:|:-------------|:------------------|:------------------|
+| api_my_app1_v1_user_authenticate | POST  | /api/my_app1/v1/user/authenticate(.:format) | api/my_app1/v1/authentication#create |
+| api_my_app1_v2_user_authenticate | POST  | /api/my_app1/v2/user/authenticate(.:format) | api/my_app1/v2/authentication#create |
+| api_my_app2_v1_user_authenticate | POST  | /api/my_app2/v1/user/authenticate(.:format) | api/my_app2/v1/authentication#create |
+| api_my_app2_v2_user              | PATCH | /api/my_app2/v2/users/:id(.:format)         | api/my_app2/v2/users#update |
+|                                  | PUT   | /api/my_app2/v2/users/:id(.:format)         | api/my_app2/v2/users#update |
+
+
+### Request Authentication Code Snippet
+
+```ruby
+# /config/initializers/simple_command_dispatcher.rb
+
+# See: http://pothibo.com/2013/07/namespace-stuff-in-your-app-folder/
+
+=begin
+# Uncomment this code if you want to namespace your commands in the following manner, for example:
+#
+#   class Api::MyApp1::V1::AuthenticateRequest; end
+#
+# As opposed to this: 
+# 
+#   module Api
+#      module MyApp1
+#         module V1
+#            class AuthenticateRequest
+#            end
+#         end
+#     end
+#   end
+#
+module Helpers
+   def self.ensure_namespace(namespace, scope = "::")
+      namespace_parts = namespace.split("::")
+
+      namespace_chain = ""
+
+      namespace_parts.each { | part |
+         namespace_chain = (namespace_chain.empty?) ? part : "#{namespace_chain}::#{part}"
+         eval("module #{scope}#{namespace_chain}; end")
+      }
+   end
+end
+
+Helpers.ensure_namespace("Api::MyApp1::V1")
+Helpers.ensure_namespace("Api::MyApp1::V2")
+Helpers.ensure_namespace("Api::MyApp2::V1")
+Helpers.ensure_namespace("Api::MyApp2::V2")
+=end
+
+# simple_command_dispatcher creates commands dynamically; therefore we need
+# to make sure the namespaces and command classes are loaded before we construct and
+# call them. The below code traverses the 'app/api' and all subfolders, and
+# autoloads them so that we do not get any NameError exceptions due to
+# uninitialized constants.
+Rails.application.config.to_prepare do
+   path = Rails.root + "app/api"
+   ActiveSupport::Dependencies.autoload_paths -= [path.to_s]
+
+   reloader = ActiveSupport::FileUpdateChecker.new [], path.to_s => [:rb] do
+      ActiveSupport::DescendantsTracker.clear
+      ActiveSupport::Dependencies.clear
+
+      Dir[path + "**/*.rb"].each do |file|
+         ActiveSupport.require_or_load file
+      end
+   end
+
+   Rails.application.reloaders << reloader
+   ActionDispatch::Reloader.to_prepare { reloader.execute_if_updated }
+   reloader.execute
+end
+```
+
+```ruby 
+# /app/controllers/application_controller.rb
+
+require 'simple_command_dispatcher'
+
+class ApplicationController < ActionController::API
+   before_action :authenticate_request
+   attr_reader :current_user
+
+   protected
+
+   def get_command_path
+      # request.env['PATH_INFO'] could return any number of paths. The important
+      # thing (in the case of our example), is that we get the portion of the 
+      # path that uniquely identifies the SimpleCommand we need to call; this 
+      # would include the application, the API version and the SimpleCommand
+      # name itself.
+      command_path = request.env['PATH_INFO'] # => "/api/[app name]/v1/[action]”
+      command_path = command_path.split('/').slice(0,4).join('/') # => "/api/[app name]/v1/"
+   end
+
+   private
+   
+   def authenticate_request
+      # The parameters and options we are passing to the dispatcher, wind up equating
+      # to the following: Api::MyApp1::V1::AuthenticateRequest.call(request.headers).
+      # Explaination: @param command_modules (e.g. path, "/api/my_app1/v1/"), in concert with @param 
+      # options { camelize: true }, is transformed into "Api::MyApp1::V1" and prepended to the 
+      # @param command, which becomes "Api::MyApp1::V1::AuthenticateRequest." This string is then
+      # simply constantized; #call is then executed, passing the @param command_parameters
+      # (e.g. request.headers, which contains ["Authorization"], out authorization token).
+      # Consequently, the correlation between our routes and command class module structure 
+      # was no coincidence.
+      command = SimpleCommand::Dispatcher.call(:AuthenticateRequest, get_command_path, { camelize: true}, request.headers)
+      if command.success?
+         @current_user = command.result
+      else
+         render json: { error: 'Not Authorized' }, status: 401
+      end
+    end
+end
+```
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'simple_command_dispatcher'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_command_dispatcher
+
+## Usage
+
+See the example above.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gangelo/simple_command_dispatcher. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+   [simple-command]: <https://rubygems.org/gems/simple_command>
+   [rails-api]: <https://rubygems.org/gems/rails-api>
+

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require 'yard'
+
+# Rspec
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+
+
+# Yard
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb']   
+  t.options = ['--no-cache', '--protected', '--private']
+  t.stats_options = ['--list-undoc']
+end
+
+# Load our custom rake tasks.
+Gem.find_files("tasks/**/*.rake").each { | path | import path }

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "simple_command_dispatcher"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/core_extensions/string.rb

@@ -0,0 +1,5 @@
+class String
+   def trim_all
+      self.gsub(/\s+/, "")
+   end
+end

data/lib/simple_command_dispatcher.rb

@@ -0,0 +1,93 @@
+require "simple_command_dispatcher/version"
+require "simple_command_dispatcher/klass_transform"
+require "simple_command"
+require "active_support/core_ext/string/inflections"
+
+module Kernel
+  def eigenclass
+    class << self
+      self
+    end
+  end
+end
+
+module SimpleCommand
+   
+   # Provides a way to call SimpleCommand commands in a more dymanic manner.
+   #
+   # For information about the simple_command gem, visit https://rubygems.org/gems/simple_command
+   #
+   module Dispatcher
+      
+      class << self
+         include SimpleCommand::KlassTransform
+
+         public
+
+         # Calls a *SimpleCommand* given the command name, the modules the command belongs to and the parameters to pass to the command.
+         #
+         # @param command [Symbol, String] the name of the SimpleCommand to call.
+         #
+         # @param command_modules [Hash, Array] the ruby modules that qualify the SimpleCommand to call. When passing a Hash, the Hash 
+         #    keys serve as documentation only. For example, ['Api', 'AppName', 'V1'] and { :api :Api, app_name: :AppName, api_version: :V1 }
+         #    will both produce 'Api::AppName::V1', this string will be prepended to the command to form the SimpleCommand to call
+         #    (e.g. 'Api::AppName::V1::MySimpleCommand' = Api::AppName::V1::MySimpleCommand.call(*command_parameters)).
+         #
+         # @param [Hash] options the options that determine how command and command_module are transformed.
+         # @option options [Boolean] :camelize (false) determines whether or not both class and module names should be camelized.
+         # @option options [Boolean] :titleize (false) determines whether or not both class and module names should be titleized.
+         # @option options [Boolean] :class_titleize (false) determines whether or not class names should be titleized.
+         # @option options [Boolean] :class_camelized (false) determines whether or not class names should be camelized.
+         # @option options [Boolean] :module_titleize (false) determines whether or not module names should be titleized.
+         # @option options [Boolean] :module_camelized (false) determines whether or not module names should be camelized.
+         #
+         # @param command_parameters [*] the parameters to pass to the call method of the SimpleCommand. This parameter is simply
+         #    passed through to the call method of the SimpleCommand.
+         #
+         # @return [SimpleCommand] the SimpleCommand returned as a result from calling the SimpleCommand#call method.
+         #
+         # @example
+         #     
+         #  # Below call equates to the following: Api::Carz4Rent::V1::Authenticate.call({ email: 'sam@gmail.com', password: 'AskM3!' })
+         #  SimpleCommand::Dispatcher.call(:Authenticate, { api: :Api, app_name: :Carz4Rent, api_version: :V1 }, 
+         #                              { email: 'sam@gmail.com', password: 'AskM3!' } ) # => SimpleCommand result
+         #
+         #  # Below equates to the following: Api::Carz4Rent::V2::Authenticate.call('sam@gmail.com', 'AskM3!')   
+         #  SimpleCommand::Dispatcher.call(:Authenticate, ['Api', 'Carz4Rent', 'V2'], 'sam@gmail.com', 'AskM3!') # => SimpleCommand result 
+         #
+         #  # Below equates to the following: Api::Auth::JazzMeUp::V1::Authenticate.call('jazz_me@gmail.com', 'JazzM3!')  
+         #  SimpleCommand::Dispatcher.call(:Authenticate, ['Api::Auth::JazzMeUp', :V1], 'jazz_me@gmail.com', 'JazzM3!') # => SimpleCommand result
+         #
+         def call(command = "", command_modules = {}, options = {}, *command_parameters)
+
+            # Create a constantized class from our command and command_modules...
+            simple_command_class_constant = to_constantized_class(command, command_modules, options)
+
+            # Calling is_simple_command? returns true if the class pointed to by
+            # simple_command_class_constant is a valid SimpleCommand class; that is, 
+            # if it prepends module SimpleCommand::ClassMethods.
+            if !is_simple_command?(simple_command_class_constant) 
+               raise ArgumentError.new('Class does not prepend module SimpleCommand.')
+            end
+
+            # We know we have a valid SimpleCommand; all we need to do is call #call,
+            # pass the command_parameter variable arguments to the call, and return the results.
+            simple_command_class_constant.call(*command_parameters)
+         end
+
+         private
+
+         # @!visibility public
+         #
+         # Returns true or false depending on whether or not the class constant prepends module SimpleCommand::ClassMethods.
+         #
+         # @param klass_constant [String] a class constant that will be validated to see whether or not the class prepends module SimpleCommand::ClassMethods.
+         #
+         # @return [Boolean] true if klass_constant prepends Module SimpleCommand::ClassMethods, false otherwise.
+         #
+         def is_simple_command?(klass_constant)
+            klass_constant.eigenclass.included_modules.include? SimpleCommand::ClassMethods
+         end
+      end
+   end
+end

data/lib/simple_command_dispatcher/klass_transform.rb

@@ -0,0 +1,240 @@
+require_relative '../core_extensions/string'
+
+module SimpleCommand
+
+   # Handles class and module transformations.
+   module KlassTransform
+
+      # Returns a constantized class (as a Class constant), given the klass and klass_modules.
+      #
+      # @param klass [Symbol or String] the class name.
+      # @param klass_modules [Hash, Array or String] the modules klass belongs to.
+      # @param options [Hash] the options that determine how klass_modules is transformed.
+      # @option options [Boolean] :camelize (false) determines whether or not both klass and klass_modules should be camelized.
+      # @option options [Boolean] :titleize (false) determines whether or not both klass and klass_modules should be titleized.
+      # @option options [Boolean] :class_titleize (false) determines whether or not klass names should be titleized.
+      # @option options [Boolean] :class_camelized (false) determines whether or not klass names should be camelized.
+      # @option options [Boolean] :module_titleize (false) determines whether or not klass_modules names should be titleized.
+      # @option options [Boolean] :module_camelized (false) determines whether or not klass_modules names should be camelized.
+      #
+      # @return [Class] the class constant. Can be used to call ClassConstant.constantize.
+      #
+      # @raise [NameError] if the constantized class string cannot be constantized; that is, if it is not
+      #   a valid class constant.
+      #
+      # @example
+      #
+      #   to_constantized_class("Authenticate", "Api") # => Api::Authenticate
+      #   to_constantized_class(:Authenticate, [:Api, :AppName, :V1]) # => Api::AppName::V1::Authenticate
+      #   to_constantized_class(:Authenticate, { :api :Api, app_name: :AppName, api_version: :V2 }) # => Api::AppName::V2::Authenticate
+      #   to_constantized_class("authenticate", { :api :api, app_name: :app_name, api_version: :v1 }, { class_titleize: true, module_titleize: true }) # => Api::AppName::V1::Authenticate
+      #
+      def to_constantized_class(klass, klass_modules = [], options = {})
+         constantized_class_string = to_constantized_class_string(klass, klass_modules, options)
+
+         begin
+            constantized_class_string.constantize
+         rescue
+             raise NameError.new("\"#{constantized_class_string}\" is not a valid class constant.")
+         end
+      end
+
+      # Returns a fully-qualified constantized class (as a string), given the klass and klass_modules.
+      #
+      # @param [Symbol or String] klass the class name.
+      # @param [Hash, Array or String] klass_modules the modules klass belongs to.
+      # @param [Hash] options the options that determine how klass_modules is transformed.
+      # @option options [Boolean] :class_titleize (false) Determines whether or not klass should be titleized.
+      # @option options [Boolean] :module_titleize (false) Determines whether or not klass_modules should be titleized.
+      #
+      # @return [String] the fully qualified class, which includes module(s) and class name.
+      #
+      # @example
+      #
+      #   to_constantized_class_string("Authenticate", "Api") # => "Api::Authenticate"
+      #   to_constantized_class_string(:Authenticate, [:Api, :AppName, :V1]) # => "Api::AppName::V1::Authenticate"
+      #   to_constantized_class_string(:Authenticate, { :api :Api, app_name: :AppName, api_version: :V2 }) # => "Api::AppName::V2::Authenticate"
+      #   to_constantized_class_string("authenticate", { :api :api, app_name: :app_name, api_version: :v1 }, { class_titleize: true, module_titleize: true }) # => "Api::AppName::V1::Authenticate"
+      #
+      def to_constantized_class_string(klass, klass_modules = [], options = {})
+         options = ensure_options(options)
+         klass_modules = to_modules_string(klass_modules, options)
+         klass_string = to_class_string(klass, options)
+         "#{klass_modules}#{klass_string}"
+      end
+
+      # Returns a string of modules that can be subsequently prepended to a class, to create a constantized class.
+      #
+      # @param [Hash, Array or String] klass_modules the modules a class belongs to.
+      # @param [Hash] options the options that determine how klass_modules is transformed.
+      # @option options [Boolean] :module_titleize (false) Determines whether or not klass_modules should be titleized.
+      #
+      # @return [String] a string of modules that can be subsequently prepended to a class, to create a constantized class.
+      #
+      # @raise [ArgumentError] if the klass_modules is not of type String, Hash or Array.
+      #
+      # @example
+      #
+      #   to_modules_string("Api") # => "Api::"
+      #   to_modules_string([:Api, :AppName, :V1]) # => "Api::AppName::V1::"
+      #   to_modules_string({ :api :Api, app_name: :AppName, api_version: :V1 }) # => "Api::AppName::V1::"
+      #   to_modules_string({ :api :api, app_name: :app_name, api_version: :v1 }, { module_titleize: true }) # => "Api::AppName::V1::"
+      #
+      def to_modules_string(klass_modules = [], options = {})
+         klass_modules = validate_klass_modules(klass_modules)
+
+         options = ensure_options(options)
+
+         klass_modules_string = ''
+         if !klass_modules.empty?
+            case klass_modules
+               when String
+                  klass_modules_string = klass_modules
+               when Array
+                  klass_modules_string = "#{klass_modules.join('::')}"
+               when Hash
+                  klass_modules_string = ''
+                  klass_modules.to_a.each_with_index.map { | value, index | 
+                     klass_modules_string = index == 0 ? value[1].to_s : "#{klass_modules_string}::#{value[1]}"
+                  }
+               else
+                  raise ArgumentError.new('Class modules is not a String, Hash or Array.')
+            end
+            klass_modules_string = klass_modules_string.split('::').map(&:titleize).join('::') if options[:module_titleize]
+            klass_modules_string = camelize(klass_modules_string) if options[:module_camelize]
+            klass_modules_string = klass_modules_string.trim_all
+            klass_modules_string = "#{klass_modules_string}::" unless klass_modules_string.empty?
+         end
+
+         klass_modules_string
+      end
+
+      # Returns the klass as a string after transformations have been applied.
+      #
+      # @param [Symbol or String] klass the class name to be transformed.
+      # @param [Hash] options the options that determine how klass will be transformed.
+      # @option options [Boolean] :class_titleize (false) Determines whether or not klass should be titleized.
+      #
+      # @return [String] the transformed class as a string.
+      #
+      # @example
+      #
+      #   to_class_string("MyClass") # => "MyClass"
+      #   to_class_string("myClass", { class_titleize: true }) # => "MyClass"
+      #   to_class_string(:MyClass) # => "MyClass"
+      #   to_class_string(:myClass, { class_titleize: true }) # => "MyClass"
+      #
+      def to_class_string(klass, options = {})
+         klass = validate_klass(klass, options)
+         if options[:class_titleize]
+            klass = klass.titleize
+         end
+         if options[:class_camelize]
+            klass = camelize(klass)
+         end
+         klass
+      end
+
+      # Transforms a route into a module string
+      #
+      # @return [String] the camelized token.
+      #
+      # @example
+      #
+      #   camelize("/api/app/auth/v1") # => "Api::App::Auth::V1"
+      #   camelize("/api/app_name/auth/v1") # => "Api::AppName::Auth::V1"
+      #
+      def camelize(token)
+         if !token.instance_of? String
+            raise ArgumentError.new('Token is not a String')
+         end
+         token = token.titlecase.camelize.sub(/^[:]*/,"").trim_all unless token.empty?
+      end
+
+      private
+
+      # @!visibility public
+      #
+      # Ensures options are initialized and valid before accessing them.
+      #
+      # @param [Hash] options the options that determine how processing and transformations will be handled.
+      # @option options [Boolean] :camelize (false) determines whether or not both class and module names should be camelized.
+      # @option options [Boolean] :titleize (false) determines whether or not both class and module names should be titleized.
+      # @option options [Boolean] :class_titleize (false) determines whether or not class names should be titleized.
+      # @option options [Boolean] :module_titleize (false) determines whether or not module names should be titleized.
+      # @option options [Boolean] :class_camelized (false) determines whether or not class names should be camelized.
+      # @option options [Boolean] :module_camelized (false) determines whether or not module names should be camelized.
+      # 
+      # @return [Hash] the initialized, validated options.
+      #
+      def ensure_options(options)
+         options = {} unless options.instance_of? Hash
+         options = { camelize: false, titleize: false, class_titleize: false, module_titleize: false, class_camelize: false, module_camelize: false}.merge(options)
+
+         if options[:camelize]
+            options[:class_camelize] = options[:module_camelize] = true
+         end
+
+         if options[:titleize]
+            options[:class_titleize] = options[:module_titleize] = true
+         end
+
+         options
+      end
+
+      # @!visibility public
+      #
+      # Validates klass and returns klass as a string after all blanks have been removed using klass.gsub(/\s+/, "").
+      #
+      # @param [Symbol or String] klass the class name to be validated. klass cannot be empty?
+      #
+      # @return [String] the validated class as a string with blanks removed.
+      #
+      # @raise [ArgumentError] if the klass is empty? or not of type String or Symbol.
+      #
+      # @example
+      #
+      #   validate_klass(" My Class ") # => "MyClass"
+      #   validate_klass(:MyClass) # => "MyClass"
+      #
+      def validate_klass(klass, options)
+         if !(klass.is_a?(Symbol) || klass.is_a?(String))
+            raise ArgumentError.new('Class is not a String or Symbol. Class must equal the name of the SimpleCommand to call in the form of a String or Symbol.')
+         end
+
+         klass = klass.to_s.strip
+
+         if klass.empty?
+            raise ArgumentError.new('Class is empty?')
+         end
+
+         klass
+      end
+
+      # @!visibility public
+      #
+      # Validates and returns klass_modules.
+      #
+      # @param [Symbol, Array or String] klass_modules the module(s) to be validated.
+      #
+      # @return [Symbol, Array or String] the validated module(s).
+      #
+      # @raise [ArgumentError] if the klass_modules is not of type String, Hash or Array.
+      #
+      # @example
+      #
+      #   validate_modules(" Module ") # => " Module "
+      #   validate_modules(:Module) # => "Module"
+      #   validate_module("ModuleA::ModuleB") # => "ModuleA::ModuleB"
+      #
+      def validate_klass_modules(klass_modules)
+         return {} if klass_modules.nil? || (klass_modules.respond_to?(:empty?) && klass_modules.empty?)
+
+         if !klass_modules.instance_of?(String) && !klass_modules.instance_of?(Hash) && !klass_modules.instance_of?(Array)
+            raise ArgumentError.new('Class modules is not a String, Hash or Array.')
+         end
+
+         klass_modules
+      end
+   end
+end

data/lib/simple_command_dispatcher/version.rb

@@ -0,0 +1,5 @@
+module SimpleCommand
+	module Dispatcher
+  		VERSION = "1.1.1"
+  	end
+end

data/lib/tasks/simple_command_dispatcher_sandbox.rake

@@ -0,0 +1,232 @@
+require 'rake'
+# Tasks to play with certain klass_transform module members
+
+
+desc 'Test to_class_string'
+task :to_class_string do
+   require "colorize"
+   require "simple_command_dispatcher"
+
+   class Test
+      prepend SimpleCommand::KlassTransform
+   end
+  
+   puts "Testing SimpleCommand::KlassTransform#to_class_String...\n".cyan
+   puts "Enter a blank line to exit.".cyan
+    loop do
+      puts "\nUsage: \"-c [class], -o [options]\" where class = String or Symbol and options = Hash".cyan
+      puts "\n\t Examples:"
+      print "\n\t\t-c \"my_class\" -o { class_camelize: true }".cyan
+      print "\n\t\t-c :MyClass -o { class_camelize: false }".cyan
+
+      print "\n=> "
+
+      input = STDIN.gets.chomp
+      break if input.empty?
+
+      input = clean_input(input)
+
+      klass = get_option_class(input)
+      if klass.nil? || klass.empty?
+         print "=> Error: Class not a String or Symbol\n".red
+         next
+      elsif !klass.is_a?(String) && ! klass.is_a?(Symbol)
+         print "=> Error: Class not a String or Symbol\n".red
+         next
+      end
+
+      options_hash = get_options_hash(input)
+
+      options_hash = { class_camelize: true }.merge(options_hash || {})
+
+      puts "\nCalling to_class_string with the following parameters: class: #{klass.class}, options: #{options_hash.class}".cyan
+
+      print "\nSuccess: => #to_class_String(#{klass}, #{options_hash}) => #{Test.new.to_class_string(klass, options_hash)}\n".green
+    end
+
+    print
+    print 'Done'.yellow
+    print
+end
+
+
+desc 'Test to_modules_string'
+task :to_modules_string do
+   require "colorize"
+   require "simple_command_dispatcher"
+
+   class Test
+      prepend SimpleCommand::KlassTransform
+   end
+  
+   puts "Testing SimpleCommand::KlassTransform#to_modules_string...\n".cyan
+   puts "Enter a blank line to exit.".cyan
+    loop do 
+      puts "\nUsage: \"-m [modules], -o [options]\" where modules = Hash, Array or String and options = Hash".cyan
+      puts "\n\t Examples:"
+      print "\n\t\t-m \"Module1::Module2::Module3\" -o { modules_camelize: false }".cyan
+      print "\n\t\t-m [:module1, :module2, :module3] -o { modules_camelize: true }".cyan
+      print "\n\t\t-m {api: :api, app: :crazy_buttons, version: :v1} -o { modules_camelize: true }".cyan
+
+      print "\n=> "
+
+      input = STDIN.gets.chomp
+      break if input.empty?
+
+      input = clean_input(input)
+
+      modules = get_option_modules(input)
+      p modules.class
+      if modules.nil? || modules.empty?
+         print "=> Error: Modules not a Hash, Array or String\n".red
+         next
+      elsif !modules.is_a?(Hash) && !modules.is_a?(Array) && !modules.is_a?(String)
+         print "=> Error: Modules not a Hash, Array or String\n".red
+         next
+      end
+
+      options_hash = get_options_hash(input)
+      options_hash = { module_camelize: true }.merge(options_hash || {})
+
+      puts "\nCalling to_modules_string with the following parameters: modules: #{modules}, type: #{modules.class}, options: #{options_hash}, type: #{options_hash.class}...".cyan
+
+      puts "\nSuccess: => #to_modules_string(#{modules}, #{options_hash}) => #{Test.new.to_modules_string(modules, options_hash)}\n".green
+    end
+
+    print
+    print 'Done'.yellow
+    print
+
+end
+
+
+#
+#
+#
+
+desc 'Test to_constantized_class_string'
+task :to_constantized_class_string do
+   require "colorize"
+   require "simple_command_dispatcher"
+
+   class Test
+      prepend SimpleCommand::KlassTransform
+   end
+  
+   puts "Testing SimpleCommand::KlassTransform#to_constantized_class_string...\n".cyan
+   puts "Enter a blank line to exit.".cyan
+    loop do 
+      puts "\nUsage: \"-c [class] -m [modules], -o [options]\" where class = Symbol or String, modules = Hash, Array or String and options = Hash".cyan
+      puts "\n\t Examples:"
+      print "\n\t\t-c :MyClass -m \"Module1::Module2::Module3\" -o { modules_camelize: false }".cyan
+      print "\n\t\t-c \"my_class\" -m [:module1, :module2, :module3] -o { modules_camelize: true }".cyan
+      print "\n\t\t-c :myClass -m {api: :api, app: :crazy_buttons, version: :v1} -o { modules_camelize: true }".cyan
+
+      print "\n=> "
+
+      input = STDIN.gets.chomp
+      break if input.empty?
+
+      input = clean_input(input)
+
+      klass = get_option_class(input)
+      if klass.nil? || klass.empty?
+         print "=> Error: Class not a String or Symbol\n".red
+         next
+      elsif !klass.is_a?(String) && ! klass.is_a?(Symbol)
+         print "=> Error: Class not a String or Symbol\n".red
+         next
+      end
+
+      modules = get_option_modules(input)
+      if modules.nil? || modules.empty?
+         print "=> Error: Modules not a Hash, Array or String\n".red
+         next
+      elsif !modules.is_a?(Hash) && !modules.is_a?(Array) && !modules.is_a?(String)
+         print "=> Error: Modules not a Hash, Array or String\n".red
+         next
+      end
+
+      options_hash = get_options_hash(input)
+      options_hash = { class_camelize: true, module_camelize: true }.merge(options_hash || {})
+
+      puts "\nCalling to_constantized_class_string with the following parameters: class: #{klass}, type: #{klass.class}, modules: #{modules}, type: #{modules.class}, options: #{options_hash}, type: #{options_hash.class}...".cyan
+
+      puts "\nSuccess: => #to_constantized_class_string(#{klass}, #{modules}, #{options_hash}) => #{Test.new.to_constantized_class_string(klass, modules, options_hash)}\n".green
+    end
+
+    print
+    print 'Done'.yellow
+    print
+end
+
+
+#
+# Helper methods
+# 
+
+def clean_input(input)
+   # Place a space before every dash that is not separated by a space.
+   input = input.gsub(/-c/, " -c ").gsub(/-m/, " -m ").gsub(/-o/, " -o ")
+   input = input.gsub(/"/, " \" ").gsub(/\s+/, " ").strip
+
+   puts "=> keyboard input after clean_input => #{input}".magenta
+
+   input
+end
+
+def get_option_class(options)
+   if options.nil? || options.empty?
+      return ""
+   end
+   options_options = options[/-c\s*([:"].+?(["\s-]||$?))($|\s+|-)/m,1]
+
+   return "" if options_options.nil?
+
+   options_options = options_options.gsub(/("|')+/, "")
+   klass = options_options.strip.gsub(/\s+/, " ")
+
+   puts "=> class after get_option_class => #{klass}".magenta
+
+   klass
+end
+
+def get_options_hash(options)
+   if options.nil? || options.empty?
+      return {}
+   end
+   options_options = options[/-o\s*([{].+?([}\s-]$?))($|\s+|-)/m,1]
+
+   return {} if options_options.nil?
+
+   puts "=> options after get_options_hash => #{options_options}".magenta
+
+   begin
+      eval(options_options)
+   rescue
+      {}
+   end
+end
+
+def get_option_modules(modules)
+   if modules.nil? || modules.empty?
+      return ""
+   end
+
+   extracted_modules = modules[/-m\s*([\[{"].+?(["}\]\s-]$?))($|\s+|-)/m,1]
+
+   return "" if extracted_modules.nil?
+
+   extracted_modules = extracted_modules.strip.gsub(/\s+/, " ")
+
+   puts "=> modules after get_option_modules => #{extracted_modules}".magenta
+
+   begin
+      eval(extracted_modules)
+   rescue
+      ""
+   end
+end
+
+
+

data/simple_command_dispatcher.gemspec

@@ -0,0 +1,48 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simple_command_dispatcher/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "simple_command_dispatcher"
+  spec.version       = SimpleCommand::Dispatcher::VERSION
+  spec.authors       = ["Gene M. Angelo, Jr."]
+  spec.email         = ["public.gma@gmail.com"]
+
+  spec.summary       = %q{Provides a way to dispatch simple_command ruby gem SimpleCommands (service objects) in a more dynamic manner within your service API. Ideal for rails-api.}
+  spec.description   = %q{Within a services API (rails-api for instance), you may have a need to execute different SimpleCommands
+                          based on one or more factors: multiple application, API version, user type, user credentials, etc. For example, 
+                          your service API may need to execute either Api::Auth::V1::AuthenticateCommand.call(...) or Api::Auth::V2::AuthenticateCommand.call(...)
+                          based on the API version. simple_command_dispatcher allows you to make one call to execute both command dynamically.}.gsub(/\s+/,' ')
+  spec.homepage      = "https://github.com/gangelo/simple_command_dispatcher"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  #if spec.respond_to?(:metadata)
+  #  spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  #else
+  #  raise "RubyGems 2.0 or newer is required to protect against " \
+  #    "public gem pushes."
+  #end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "rdoc"
+  spec.add_development_dependency "colorize"
+
+  spec.required_ruby_version = '>= 2.2.2'
+  spec.add_runtime_dependency 'activesupport', '~> 5.0', '>= 5.0.0.1'
+
+  spec.add_runtime_dependency 'simple_command', '>= 0.0.9'
+end

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: simple_command_dispatcher
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Gene M. Angelo, Jr.
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: rdoc
+  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: colorize
+  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: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0.1
+- !ruby/object:Gem::Dependency
+  name: simple_command
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+description: 'Within a services API (rails-api for instance), you may have a need
+  to execute different SimpleCommands based on one or more factors: multiple application,
+  API version, user type, user credentials, etc. For example, your service API may
+  need to execute either Api::Auth::V1::AuthenticateCommand.call(...) or Api::Auth::V2::AuthenticateCommand.call(...)
+  based on the API version. simple_command_dispatcher allows you to make one call
+  to execute both command dynamically.'
+email:
+- public.gma@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.mb
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/core_extensions/string.rb
+- lib/simple_command_dispatcher.rb
+- lib/simple_command_dispatcher/klass_transform.rb
+- lib/simple_command_dispatcher/version.rb
+- lib/tasks/simple_command_dispatcher_sandbox.rake
+- simple_command_dispatcher.gemspec
+homepage: https://github.com/gangelo/simple_command_dispatcher
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.7
+signing_key: 
+specification_version: 4
+summary: Provides a way to dispatch simple_command ruby gem SimpleCommands (service
+  objects) in a more dynamic manner within your service API. Ideal for rails-api.
+test_files: []