simple_command_dispatcher 1.2.2 → 1.2.5

data/lib/simple_command_dispatcher.rb

@@ -1,9 +1,9 @@
-require "simple_command_dispatcher/version"
-require "simple_command_dispatcher/klass_transform"
-require "simple_command"
-require "active_support/core_ext/string/inflections"
+# frozen_string_literal: true
 
-require 'simple_command_dispatcher/configuration'
+require 'simple_command_dispatcher/version'
+require 'simple_command_dispatcher/klass_transform'
+require 'simple_command'
+require 'active_support/core_ext/string/inflections'
 require 'simple_command_dispatcher/configure'
 
 module Kernel
@@ -15,116 +15,107 @@ module Kernel
 end
 
 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 Dispatcher
-      
-      class << self
-         include SimpleCommand::KlassTransform
-
-         public
-
-         # 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 simply
-         #    passed 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)
+  # 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 Dispatcher
+    class << self
+      include SimpleCommand::KlassTransform
 
-            # Create a constantized class from our command and command_modules...
-            command_class_constant = to_constantized_class(command, command_modules, options)
+      # 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 simply
+      #    passed 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)
 
-            # 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  
-               # Calling is_simple_command? returns true if the class pointed to by
-               # command_class_constant is a valid SimpleCommand class; that is, 
-               # if it prepends module SimpleCommand::ClassMethods.
-               if !is_simple_command?(command_class_constant) 
-                  raise ArgumentError.new("Class \"#{command_class_constant}\" must prepend module SimpleCommand if Configuration#allow_custom_commands is true.")
-               end
-            end
+        # 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 && !is_simple_command?(command_class_constant)
+          raise ArgumentError,
+            "Class \"#{command_class_constant}\" must prepend module SimpleCommand if Configuration#allow_custom_commands is true."
+        end
 
-            if is_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.new("Class \"#{command_class_constant}\" does not respond_to? method ::call.")
-            end
-         end
+        if is_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
+      private
 
-         # 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 is_valid_command(klass_constant)
-            klass_constant.eigenclass.public_method_defined?(:call)
-         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 is_valid_command(klass_constant)
+        klass_constant.eigenclass.public_method_defined?(:call)
+      end
 
-         # 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 is_simple_command?(klass_constant)
-            klass_constant.eigenclass.included_modules.include? SimpleCommand::ClassMethods
-         end
+      # 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 is_simple_command?(klass_constant)
+        klass_constant.eigenclass.included_modules.include? SimpleCommand::ClassMethods
+      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.")
-         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.")
       end
-   end
+    end
+  end
 end

data/lib/tasks/simple_command_dispatcher_sandbox.rake

@@ -1,232 +1,222 @@
+# frozen_string_literal: true
+
 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
+  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 = get_options_hash(input)
 
-      options_hash = { class_camelize: true }.merge(options_hash || {})
+    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
+    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 "\nSuccess: => #to_class_String(#{klass}, #{options_hash}) => #{Test.new.to_class_string(klass,
+                                                                                                   options_hash)}\n".green
+  end
 
-    print
-    print 'Done'.yellow
-    print
+  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
+  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
 
-    print
-    print 'Done'.yellow
-    print
+    options_hash = get_options_hash(input)
+    options_hash = { module_camelize: true }.merge(options_hash || {})
 
-end
+    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
+  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
 
-    print
-    print 'Done'.yellow
-    print
-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
+  # 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
+  puts "=> keyboard input after clean_input => #{input}".magenta
 
-   input
+  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.nil? || options.empty?
+
+  options_options = options[/-c\s*([:"].+?(["\s-]||$?))($|\s+|-)/m, 1]
 
-   return "" if options_options.nil?
+  return '' if options_options.nil?
 
-   options_options = options_options.gsub(/("|')+/, "")
-   klass = options_options.strip.gsub(/\s+/, " ")
+  options_options = options_options.gsub(/("|')+/, '')
+  klass = options_options.strip.gsub(/\s+/, ' ')
 
-   puts "=> class after get_option_class => #{klass}".magenta
+  puts "=> class after get_option_class => #{klass}".magenta
 
-   klass
+  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.nil? || options.empty?
+
+  options_options = options[/-o\s*([{].+?([}\s-]$?))($|\s+|-)/m, 1]
 
-   return {} if options_options.nil?
+  return {} if options_options.nil?
 
-   puts "=> options after get_options_hash => #{options_options}".magenta
+  puts "=> options after get_options_hash => #{options_options}".magenta
 
-   begin
-      eval(options_options)
-   rescue
-      {}
-   end
+  begin
+    eval(options_options)
+  rescue StandardError
+    {}
+  end
 end
 
 def get_option_modules(modules)
-   if modules.nil? || modules.empty?
-      return ""
-   end
+  return '' if modules.nil? || modules.empty?
 
-   extracted_modules = modules[/-m\s*([\[{"].+?(["}\]\s-]$?))($|\s+|-)/m,1]
+  extracted_modules = modules[/-m\s*([\[{"].+?(["}\]\s-]$?))($|\s+|-)/m, 1]
 
-   return "" if extracted_modules.nil?
+  return '' if extracted_modules.nil?
 
-   extracted_modules = extracted_modules.strip.gsub(/\s+/, " ")
+  extracted_modules = extracted_modules.strip.gsub(/\s+/, ' ')
 
-   puts "=> modules after get_option_modules => #{extracted_modules}".magenta
+  puts "=> modules after get_option_modules => #{extracted_modules}".magenta
 
-   begin
-      eval(extracted_modules)
-   rescue
-      ""
-   end
+  begin
+    eval(extracted_modules)
+  rescue StandardError
+    ''
+  end
 end
-
-
-