simple_command_dispatcher 3.0.4 → 4.1.0

data/lib/simple_command_dispatcher.rb

@@ -1,135 +1,84 @@
 # frozen_string_literal: true
 
-require 'simple_command_dispatcher/version'
-require 'simple_command_dispatcher/klass_transform'
-require 'simple_command'
+require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/string/inflections'
-require 'simple_command_dispatcher/configure'
-
-module Kernel
-  def eigenclass
-    class << self
-      self
-    end
-  end
-end
+require 'core_ext/kernel'
+require 'simple_command_dispatcher/commands/command_callable'
+require 'simple_command_dispatcher/configuration'
+require 'simple_command_dispatcher/errors'
+require 'simple_command_dispatcher/services/command_service'
+require 'simple_command_dispatcher/version'
 
-module SimpleCommand
-  # Provides a way to call SimpleCommands or your own custom commands in a more dymanic manner.
-  #
-  # For information about the simple_command gem, visit {https://rubygems.org/gems/simple_command}
+module SimpleCommandDispatcher
+  # Provides a way to call your custom commands dynamically.
   #
-  module Dispatcher
-    class << self
-      include SimpleCommand::KlassTransform
+  class << self
+    # Calls a *Command* given the command name, the namespace (modules) the command belongs to
+    # and the (request) parameters to pass to the command.
+    #
+    # @param command [Symbol, String] the name of the Command to call.
+    #
+    # @param command_namespace [Hash, Array] the ruby modules that qualify the Command 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 Command
+    #    to call (e.g. 'Api::AppName::V1::MySimpleCommand' = Api::AppName::V1::MySimpleCommand.call(*request_params)).
+    #
+    # @param request_params [Hash, Array, Object] the parameters to pass to the call method of the Command. This
+    #    parameter is simply passed through to the call method of the Command. Hash parameters are passed as
+    #    keyword arguments, Array parameters are passed as positional arguments, and other objects are passed
+    #    as a single argument.
+    #
+    # @return [Object] the Object returned as a result of calling the Command#call method.
+    #
+    # @example
+    #
+    #  # Below call equates to the following:
+    #  # Api::Carz4Rent::V1::Authenticate.call({ email: 'sam@gmail.com', password: 'AskM3!' })
+    #  SimpleCommandDispatcher.call(command: :Authenticate,
+    #     command_namespace: { api: :Api, app_name: :Carz4Rent, api_version: :V1 },
+    #     request_params: { email: 'sam@gmail.com', password: 'AskM3!' } ) # => Command result
+    #
+    #  # Below equates to the following: Api::Carz4Rent::V2::Authenticate.call('sam@gmail.com', 'AskM3!')
+    #  SimpleCommandDispatcher.call(command: :Authenticate,
+    #     command_namespace: ['Api', 'Carz4Rent', 'V2'],
+    #     request_params: ['sam@gmail.com', 'AskM3!']) # => Command result
+    #
+    #  # Below equates to the following:
+    #  # Api::Auth::JazzMeUp::V1::Authenticate.call('jazz_me@gmail.com', 'JazzM3!')
+    #  SimpleCommandDispatcher.call(command: :Authenticate,
+    #     command_namespace: ['Api::Auth::JazzMeUp', :V1],
+    #     request_params: ['jazz_me@gmail.com', 'JazzM3!']) # => Command result
+    #
+    def call(command:, command_namespace: {}, request_params: nil)
+      # Create a constantized class from our command and command_namespace...
+      constantized_class_object = Services::CommandService.new(command:, command_namespace:).to_class
+      validate_command!(constantized_class_object)
 
-      # Calls a *SimpleCommand* or *Command* 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 or Command 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 [Array<Symbol>] the parameters to pass to the call method of the SimpleCommand.
-      #    This parameter is simplypassed through to the call method of the SimpleCommand/Command.
-      #
-      # @return [SimpleCommand, Object] the SimpleCommand or Object returned as a result of calling the
-      #    SimpleCommand#call method or the Command#call method respectfully.
-      #
-      # @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...
-        command_class_constant = to_constantized_class(command, command_modules, options)
+      # We know we have a valid command class object if we get here. All we need to do is call the .call
+      # class method, pass the request_params arguments depending on the request_params data type, and
+      # return the results.
 
-        # If we're NOT allowing custom commands, make sure we're dealing with a a command class
-        # that prepends the SimpleCommand module.
-        if !SimpleCommand::Dispatcher.configuration.allow_custom_commands && !simple_command?(command_class_constant)
-          raise ArgumentError,
-            "Class \"#{command_class_constant}\" " \
-            'must prepend module SimpleCommand if Configuration#allow_custom_commands is true.'
-        end
-
-        if valid_command?(command_class_constant)
-          # 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.
-          run_command(command_class_constant, command_parameters)
-        else
-          raise NameError, "Class \"#{command_class_constant}\" does not respond_to? method ::call."
-        end
-      end
-
-      private
+      call_command(constantized_class_object:, request_params:)
+    end
 
-      # Returns true or false depending on whether or not the class constant has a public
-      # class method named ::call defined. Commands that do not have a public class method
-      # named ::call, are considered invalid.
-      #
-      # @param klass_constant [String] a class constant that will be validated to see whether or not the
-      #    class is a valid command.
-      #
-      # @return [Boolean] true if klass_constant has a public class method named ::call defined,
-      #    false otherwise.
-      #
-      # @!visibility public
-      def valid_command?(klass_constant)
-        klass_constant.eigenclass.public_method_defined?(:call)
-      end
+    private
 
-      # 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.
-      #
-      # @!visibility public
-      def simple_command?(klass_constant)
-        klass_constant.eigenclass.included_modules.include? SimpleCommand::ClassMethods
+    def call_command(constantized_class_object:, request_params:)
+      if request_params.is_a?(Hash)
+        constantized_class_object.call(**request_params)
+      elsif request_params.is_a?(Array)
+        constantized_class_object.call(*request_params)
+      elsif request_params.present?
+        constantized_class_object.call(request_params)
+      else
+        constantized_class_object.call
       end
+    end
 
-      # Runs the command given the parameters and returns the result.
-      #
-      # @param klass_constant [String] a class constant that will be called.
-      # @param parameters [Array] an array of parameters to pass to the command that will be called.
-      #
-      # @return [Object] returns the object (if any) that results from calling the command.
-      #
-      # @!visibility public
-      def run_command(klass_constant, parameters)
-        klass_constant.call(*parameters)
-        # rescue NameError
-        #   raise NameError.new("Class \"#{klass_constant}\" does not respond_to? method ::call.")
+    def validate_command!(constantized_class_object)
+      unless constantized_class_object.eigenclass.public_method_defined?(:call)
+        raise Errors::RequiredClassMethodMissingError, constantized_class_object
       end
     end
   end

data/simple_command_dispatcher.gemspec

@@ -6,16 +6,15 @@ require 'simple_command_dispatcher/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'simple_command_dispatcher'
-  spec.version       = SimpleCommand::Dispatcher::VERSION
+  spec.version       = SimpleCommandDispatcher::VERSION
   spec.authors       = ['Gene M. Angelo, Jr.']
   spec.email         = ['public.gma@gmail.com']
 
-  spec.summary       = 'Provides a way to dispatch simple_command (ruby gem) commands or your own custom commands (service objects) in a more dynamic manner
-                          within your service API. Ideal for rails-api.'
-  spec.description   = 'Within a services API (rails-api for instance), you may have a need to execute different simple_commands or your own custom commands (service objects)
-                          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 execute either command with one line of code dynamically.'.gsub(/\s+/, ' ')
+  spec.summary       = 'Dynamic command execution for Rails applications using convention over configuration - automatically maps request routes to command classes.'
+  spec.description   = 'A lightweight Ruby gem that enables Rails applications to dynamically execute command objects using convention over configuration. ' \
+                       'Automatically transforms request paths into Ruby class constants, allowing controllers to dispatch commands based on routes and parameters. ' \
+                       'Features the optional CommandCallable module for standardized command interfaces with built-in success/failure tracking and error handling. ' \
+                       'Perfect for clean, maintainable Rails APIs with RESTful route-to-command mapping. Only depends on ActiveSupport for reliable camelization.'
   spec.homepage      = 'https://github.com/gangelo/simple_command_dispatcher'
   spec.license       = 'MIT'
 
@@ -35,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version = Gem::Requirement.new('>= 3.0.1', '< 4.0')
-  spec.add_runtime_dependency 'activesupport', '>= 7.0.8', '< 8.0'
-  spec.add_runtime_dependency 'simple_command', '~> 1.0', '>= 1.0.1'
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.3', '< 4.0')
+
+  spec.add_runtime_dependency 'activesupport', '>= 7.0.8', '< 9.0'
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: simple_command_dispatcher
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 4.1.0
 platform: ruby
 authors:
 - Gene M. Angelo, Jr.
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-03 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -19,7 +18,7 @@ dependencies:
         version: 7.0.8
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,33 +28,14 @@ dependencies:
         version: 7.0.8
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8.0'
-- !ruby/object:Gem::Dependency
-  name: simple_command
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.1
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.0.1
-description: 'Within a services API (rails-api for instance), you may have a need
-  to execute different simple_commands or your own custom commands (service objects)
-  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 execute either command with one line of code dynamically.'
+        version: '9.0'
+description: A lightweight Ruby gem that enables Rails applications to dynamically
+  execute command objects using convention over configuration. Automatically transforms
+  request paths into Ruby class constants, allowing controllers to dispatch commands
+  based on routes and parameters. Features the optional CommandCallable module for
+  standardized command interfaces with built-in success/failure tracking and error
+  handling. Perfect for clean, maintainable Rails APIs with RESTful route-to-command
+  mapping. Only depends on ActiveSupport for reliable camelization.
 email:
 - public.gma@gmail.com
 executables: []
@@ -80,19 +60,25 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
-- lib/core_extensions/string.rb
+- lib/core_ext/kernel.rb
 - lib/simple_command_dispatcher.rb
+- lib/simple_command_dispatcher/commands/command_callable.rb
+- lib/simple_command_dispatcher/commands/errors.rb
+- lib/simple_command_dispatcher/commands/utils.rb
 - lib/simple_command_dispatcher/configuration.rb
-- lib/simple_command_dispatcher/configure.rb
-- lib/simple_command_dispatcher/klass_transform.rb
+- lib/simple_command_dispatcher/errors.rb
+- lib/simple_command_dispatcher/errors/invalid_class_constant_error.rb
+- lib/simple_command_dispatcher/errors/required_class_method_missing_error.rb
+- lib/simple_command_dispatcher/helpers/camelize.rb
+- lib/simple_command_dispatcher/helpers/trim_all.rb
+- lib/simple_command_dispatcher/services/command_namespace_service.rb
+- lib/simple_command_dispatcher/services/command_service.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
@@ -100,7 +86,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.0.1
+      version: '3.3'
   - - "<"
     - !ruby/object:Gem::Version
       version: '4.0'
@@ -110,10 +96,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
-signing_key:
+rubygems_version: 3.6.8
 specification_version: 4
-summary: Provides a way to dispatch simple_command (ruby gem) commands or your own
-  custom commands (service objects) in a more dynamic manner within your service API.
-  Ideal for rails-api.
+summary: Dynamic command execution for Rails applications using convention over configuration
+  - automatically maps request routes to command classes.
 test_files: []

data/lib/core_extensions/string.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-class String
-  # Returns a copy of string with all spaces removed.
-  #
-  # @return [String] with all spaces trimmed which includes all leading, trailing and embedded spaces.
-  def trim_all
-    gsub(/\s+/, '')
-  end
-end

data/lib/simple_command_dispatcher/configure.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'configuration'
-
-module SimpleCommand
-  module Dispatcher
-    class << self
-      attr_writer :configuration
-    end
-
-    # Returns the application configuration object.
-    #
-    # @return [Configuration] the application Configuration object.
-    def self.configuration
-      @configuration ||= Configuration.new
-    end
-
-    def self.configure
-      yield(configuration)
-    end
-  end
-end

data/lib/simple_command_dispatcher/klass_transform.rb

@@ -1,251 +0,0 @@
-# rubocop:disable Style/OptionHash
-# frozen_string_literal: true
-
-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 StandardError
-        raise NameError, "\"#{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 = {}) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
-      klass_modules = validate_klass_modules(klass_modules)
-
-      options = ensure_options(options)
-
-      klass_modules_string = ''
-      unless klass_modules.empty?
-        case klass_modules
-        when String
-          klass_modules_string = klass_modules
-        when Array
-          klass_modules_string = klass_modules.join('::').to_s
-        when Hash
-          klass_modules_string = ''
-          klass_modules.to_a.each_with_index.map do |value, index|
-            klass_modules_string = index.zero? ? value[1].to_s : "#{klass_modules_string}::#{value[1]}"
-          end
-        else
-          raise ArgumentError, '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)
-      klass = klass.titleize if options[:class_titleize]
-      klass = camelize(klass) if options[:class_camelize]
-      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)
-      raise ArgumentError, 'Token is not a String' unless token.instance_of? String
-
-      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)
-
-      options[:class_camelize] = options[:module_camelize] = true if options[:camelize]
-
-      options[:class_titleize] = options[:module_titleize] = true if options[:titleize]
-
-      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)
-      unless klass.is_a?(Symbol) || klass.is_a?(String)
-        raise ArgumentError,
-          'Class is not a String or Symbol. Class must equal the class name of the ' \
-          'SimpleCommand or Command to call in the form of a String or Symbol.'
-      end
-
-      klass = klass.to_s.strip
-
-      raise ArgumentError, 'Class is empty?' if klass.empty?
-
-      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, 'Class modules is not a String, Hash or Array.'
-      end
-
-      klass_modules
-    end
-  end
-end
-
-# rubocop:enable Style/OptionHash