rubycom 0.3.0 → 0.3.2

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDQwZWY1MzUyMTk1MGQ1OTc2YTEzYzNhOWRlNTZjZTkzMjU3MzliNw==
+    NzljMjJkOTA5OGI4NTlmNTNjMjQ0NDdkMzQ1NzY5YjYxMGRkMmQxNw==
   data.tar.gz: !binary |-
-    OWVkOTI4MjY3ODhlODM1M2FhMTAxZTc2YjQxYTVkN2JmZDg2ZGE1Yg==
+    MTY3NjdiMTkyOTBhM2UyNjZiNjc4ODE5YzQ0MDJiNzQzNmNlOGJiOQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    Nzc5NWUyZTczZWMzZjUxM2UwMmEyNGQxYTZlZTEyYmI1MmViYmUwZDE0NmRm
-    ZTYzM2Y0N2Q1MjhkOThjZTdiN2Q5OWIyODEyMmVkMjdiMjQ3OTc0ZWQ2MTcx
-    NzUwZTAzMzZjOWMwN2FlZjk1NjUzMTFlM2EzZTdkZTk3NjI5ZGQ=
+    NDRmZWFhNTRhMWFmMTBjZjY1ZjE3N2JhODFjNThiMDc3MDk3YjQzMzc3NWM4
+    OWQwNWE3NzA3ZjgzMDdlODAzZjQzZmY3NWFjNDdhYjMxNDU5YzE2ZjkyM2Jl
+    OWU4ODYzMWFlZWY0NzYzOGQ5YzQwYWZlM2VmMDlmMzcxYzdmZTk=
   data.tar.gz: !binary |-
-    YzVlZTBiODM0MzU0MmQzNTg1YWI1NDg0MTE0ZGRhOWMyMDA2M2Y5NTIxZTY1
-    NTFmM2Y3NDM5MDU5ZmRhYmI2Y2FlMDc1YjdiNzA3OWIzYWVlNGYxNTRhMjU3
-    MzZjYzNjMmQ2NzUwZmIxNDM2MzcxODU4OGUzMWYyZGNmOGVjNGY=
+    Njg1YWIxMzI5ODA1NGViMTA1NGMyMjYxOGViNDI0NTZjOWQyY2U1OTE3Mzgx
+    YmQ0NGNhOGVkNTg0OGE2OWNjMTBkNWI2YWE5ZjJkNjZjYWY0YzlmN2Q2ZWVm
+    ZTRmMTVlMDdhMDUxY2NjYzg4NjA1NjMwZWNkZmQyNzUxNzUxZGE=

data/lib/rubycom.rb

@@ -18,15 +18,25 @@ module Rubycom
   #
   # @param [Module] base the module which invoked 'include Rubycom'
   def self.included(base)
-    raise CLIError, 'base must be a module' if base.class != Module
     base_file_path = caller.first.gsub(/:\d+:.+/, '')
-    if base_file_path == $0
+    if base.class == Module && (base_file_path == $0 || self.is_executed_by_gem?(base_file_path))
       base.module_eval {
         Rubycom.run(base, ARGV)
       }
     end
   end
 
+  # Determines whether the including module was executed by a gem binary
+  #
+  # @param [String] base_file_path the path to the including module's source file
+  def self.is_executed_by_gem?(base_file_path)
+    Gem.loaded_specs.map{|k,s|
+      {k => {name: "#{s.name}-#{s.version}", executables: s.executables}}
+    }.reduce(&:merge).map{|k,s|
+      base_file_path.include?(s[:name]) && s[:executables].include?(File.basename(base_file_path))
+    }.flatten.reduce(&:|)
+  end
+
   # Looks up the command specified in the first arg and executes with the rest of the args
   #
   # @param [Module] base the module which invoked 'include Rubycom'
@@ -112,10 +122,11 @@ module Rubycom
     end
   end
 
-  # Calls the given Method#name on the given Module after parsing the given Array of arguments
+  # Handles the method call according to the given arguments. If the specified command is a Module then a recursive search
+  # is performed until a Method is found in the specified arguments.
   #
   # @param [Module] base the module which invoked 'include Rubycom'
-  # @param [String] command the name of the Method to call
+  # @param [String] command the name of the command to call, may be a Module name or a Method
   # @param [Array] arguments a String Array representing the arguments for the given command
   def self.run_command(base, command, arguments=[])
     arguments = [] if arguments.nil?
@@ -125,17 +136,7 @@ module Rubycom
       if base.included_modules.map { |mod| mod.name.to_sym }.include?(command.to_sym)
         self.run_command(eval(command), arguments[0], arguments[1..-1])
       else
-        method = base.public_method(command.to_sym)
-        raise CLIError, "No public method found for symbol: #{command.to_sym}" if method.nil?
-        param_defs = Arguments.get_param_definitions(method)
-        args = Arguments.parse_arguments(param_defs, arguments)
-        flatten = false
-        params = method.parameters.map { |arr| flatten = true if arr[0]==:rest; args[arr[1]] }
-        if flatten
-          rest_arr = params.delete_at(-1)
-          rest_arr.each { |arg| params << arg }
-        end
-        (arguments.nil? || arguments.empty?) ? method.call : method.call(*params)
+        self.call_method(base, command, arguments)
       end
     rescue CLIError => e
       $stderr.puts e
@@ -143,6 +144,30 @@ module Rubycom
     end
   end
 
+  # Calls the given command on the given Module after parsing the given Array of arguments
+  #
+  # @param [Module] base the module wherein the specified command is defined
+  # @param [String] command the name of the Method to call
+  # @param [Array] arguments a String Array representing the arguments for the given command
+  # @return the result of the specified Method call
+  def self.call_method(base, command, arguments=[])
+    method = base.public_method(command.to_sym)
+    raise CLIError, "No public method found for symbol: #{command.to_sym}" if method.nil?
+    param_defs = Arguments.get_param_definitions(method)
+    args = Arguments.resolve(param_defs, arguments)
+    flatten = false
+    params = method.parameters.map { |arr| flatten = true if arr[0]==:rest; args[arr[1]] }
+    if flatten
+      rest_arr = params.delete_at(-1)
+      if rest_arr.respond_to?(:each)
+        rest_arr.each { |arg| params << arg }
+      else
+        params << rest_arr
+      end
+    end
+    (arguments.nil? || arguments.empty?) ? method.call : method.call(*params)
+  end
+
   # Inserts a tab completion into the current user's .bash_profile with a command entry to register the function for
   # the current running ruby file
   #

data/lib/rubycom/arguments.rb

@@ -13,41 +13,61 @@ module Rubycom
     #                                              }
     # @param [Array] arguments an Array of Strings representing the arguments to be parsed
     # @return [Hash] a Hash mapping the defined parameters to their matching argument values
-    def self.parse_arguments(parameters={}, arguments=[])
+    def self.resolve(parameters={}, arguments=[])
       raise CLIError, 'parameters may not be nil' if parameters.nil?
       raise CLIError, 'arguments may not be nil' if arguments.nil?
-      sorted_args = arguments.map { |arg|
-        self.parse_arg(arg)
-      }.group_by { |hsh|
-        hsh.keys.first
-      }.map { |key, arr|
-        (key == :rubycom_non_opt_arg) ? Hash[key, arr.map { |hsh| hsh.values }.flatten(1)] : Hash[key, arr.map { |hsh| hsh.values.first }.reduce(&:merge)]
-      }.reduce(&:merge) || {}
+      parsed_args = self.parse_args(arguments)
 
-      sorted_arg_count = sorted_args.map { |key, val| val }.flatten(1).length
+      args = parsed_args[:rubycom_non_opt_arg] || []
+      options = parsed_args.select{|key,_| key != :rubycom_non_opt_arg } || {}
+      parsed_arg_count = args.length + options.length
       types = parameters.values.group_by { |hsh| hsh[:type] }.map { |type, defs_arr| Hash[type, defs_arr.length] }.reduce(&:merge) || {}
-      raise CLIError, "Wrong number of arguments. Expected at least #{types[:req]}, received #{sorted_arg_count}" if sorted_arg_count < (types[:req]||0)
-      raise CLIError, "Wrong number of arguments. Expected at most #{(types[:req]||0) + (types[:opt]||0)}, received #{sorted_arg_count}" if types[:rest].nil? && (sorted_arg_count > ((types[:req]||0) + (types[:opt]||0)))
+      raise CLIError, "Wrong number of arguments. Expected at least #{types[:req]}, received #{parsed_arg_count}" if parsed_arg_count < (types[:req]||0)
+      raise CLIError, "Wrong number of arguments. Expected at most #{(types[:req]||0) + (types[:opt]||0)}, received #{parsed_arg_count}" if types[:rest].nil? && (parsed_arg_count > ((types[:req]||0) + (types[:opt]||0)))
+
+      self.merge_params(parameters, parsed_args)
+    end
 
+    # Matches the given parameters to the given pre-parsed arguments
+    #
+    # @param [Hash] parameters a Hash representing the parameters to match.
+    #         Entries should match :param_name => { type: :req||:opt||:rest,
+    #                                               def:(source_definition),
+    #                                               default:(default_value || :nil_rubycom_required_param)
+    #                                              }
+    # @param [Hash] parsed_args a Hash of parsed arguments where the keys are either the name of the optional argument
+    #         the value to designated for or :rubycom_non_opt_arg if the argument was not sent for a specified optional parameter
+    # @return [Hash] a Hash mapping the defined parameters to their matching argument values
+    def self.merge_params(parameters={}, parsed_args={})
       parameters.map { |param_sym, def_hash|
         if def_hash[:type] == :req
-          raise CLIError, "No argument available for #{param_sym}" if sorted_args[:rubycom_non_opt_arg].nil? || sorted_args[:rubycom_non_opt_arg].length == 0
-          Hash[param_sym, sorted_args[:rubycom_non_opt_arg].shift]
+          raise CLIError, "No argument available for #{param_sym}" if parsed_args[:rubycom_non_opt_arg].nil? || parsed_args[:rubycom_non_opt_arg].length == 0
+          Hash[param_sym, parsed_args[:rubycom_non_opt_arg].shift]
         elsif def_hash[:type] == :opt
-          if sorted_args[param_sym].nil?
-            arg = (sorted_args[:rubycom_non_opt_arg].nil? || sorted_args[:rubycom_non_opt_arg].empty?) ? parameters[param_sym][:default] : sorted_args[:rubycom_non_opt_arg].shift
+          if parsed_args[param_sym].nil?
+            arg = (parsed_args[:rubycom_non_opt_arg].nil? || parsed_args[:rubycom_non_opt_arg].empty?) ? parameters[param_sym][:default] : parsed_args[:rubycom_non_opt_arg].shift
           else
-            arg = sorted_args[param_sym]
+            arg = parsed_args[param_sym]
           end
           Hash[param_sym, arg]
         elsif def_hash[:type] == :rest
-          ret = Hash[param_sym, ((!sorted_args[param_sym].nil?) ? sorted_args[param_sym] : sorted_args[:rubycom_non_opt_arg])]
-          sorted_args[:rubycom_non_opt_arg] = []
+          ret = Hash[param_sym, ((!parsed_args[param_sym].nil?) ? parsed_args[param_sym] : parsed_args[:rubycom_non_opt_arg])]
+          parsed_args[:rubycom_non_opt_arg] = []
           ret
         end
       }.reduce(&:merge)
     end
 
+    def self.parse_args(arguments)
+      arguments.map { |arg|
+        self.parse_arg(arg)
+      }.group_by { |hsh|
+        hsh.keys.first
+      }.map { |key, arr|
+        (key == :rubycom_non_opt_arg) ? Hash[key, arr.map { |hsh| hsh.values }.flatten(1)] : Hash[key, arr.map { |hsh| hsh.values.first }.reduce(&:merge)]
+      }.reduce(&:merge) || {}
+    end
+
     # Uses YAML.load to parse the given String
     #
     # @param [String] arg a String representing the argument to be parsed
@@ -60,12 +80,23 @@ module Rubycom
         k, v = arg.partition(/^(-|--)\w+[=|\s]{1}/).select { |part|
           !part.empty?
         }.each_with_index.map { |part, index|
-          index == 0 ? part.chomp('=').gsub(/^--/, '').gsub(/^-/, '').strip.to_sym : (YAML.load(part) rescue "#{part}")
+          if index == 0
+            part.chomp('=').gsub(/^--/, '').gsub(/^-/, '').strip.to_sym
+          else
+            if part.start_with?("#") || part.start_with?("!")
+              "#{part}"
+            else
+              (YAML.load(part) rescue "#{part}")
+            end
+          end
         }
         Hash[k, v]
       else
         begin
-          parsed_arg = YAML.load("#{arg}")
+          parsed_arg = "#{arg}"
+          unless arg.start_with?("#") || arg.start_with?("!")
+            parsed_arg = YAML.load("#{arg}")
+          end
         rescue Exception
           parsed_arg = "#{arg}"
         end

data/lib/rubycom/documentation.rb

@@ -31,17 +31,7 @@ module Rubycom
       raise CLIError, "Can not get usage for #{command_name} with base: #{base||"nil"}" if base.nil? || !base.respond_to?(:included_modules)
       return 'No command specified.' if command_name.nil? || command_name.length == 0
       if base.included_modules.map { |mod| mod.name.to_sym }.include?(command_name.to_sym)
-        begin
-          mod_const = Kernel.const_get(command_name.to_sym)
-          desc = File.read(mod_const.public_method(mod_const.singleton_methods().first).source_location.first).split(//).reduce("") { |str, c|
-            unless str.gsub("\n", '').gsub(/\s+/, '').include?("module#{mod_const}")
-              str << c
-            end
-            str
-          }.split("\n").select { |line| line.strip.match(/^#/) && !line.strip.match(/^#!/) }.map { |line| line.strip.gsub(/^#+/, '') }.join("\n")
-        rescue
-          desc = ""
-        end
+        desc = self.get_module_doc(command_name)
       else
         raise CLIError, "Invalid command for #{base}, #{command_name}" unless base.public_methods.include?(command_name.to_sym)
         desc = self.get_doc(base.public_method(command_name.to_sym))[:desc].join("\n") rescue ""
@@ -128,6 +118,24 @@ module Rubycom
       }.join
     end
 
+    # Retrieves the given module's documentation from it's source code
+    #
+    # @param [String] base_name
+    # @return [String] the documentation text from the top of the specified module
+    def self.get_module_doc(base_name)
+      begin
+        mod_const = Kernel.const_get(base_name.to_sym)
+        File.read(mod_const.public_method(mod_const.singleton_methods().first).source_location.first).split(//).reduce("") { |str, c|
+          unless str.gsub("\n", '').gsub(/\s+/, '').include?("module#{mod_const}")
+            str << c
+          end
+          str
+        }.split("\n").select { |line| line.strip.match(/^#/) && !line.strip.match(/^#!/) }.map { |line| line.strip.gsub(/^#+/, '') }.join("\n")
+      rescue
+        ""
+      end
+    end
+
     # Retrieves the given method's documentation from it's source code
     #
     # @param [Method] method the Method who's documentation should be retrieved

data/lib/rubycom/version.rb

@@ -1,3 +1,3 @@
 module Rubycom
-  VERSION = "0.3.0"
+  VERSION = "0.3.2"
 end

data/test/rubycom/arguments_test.rb

@@ -145,4 +145,145 @@ class ArgumentsTest < Test::Unit::TestCase
     assert_equal(expected, result)
   end
 
+  def test_parse_args_no_params
+    test_method = UtilTestModule.public_method(:test_command)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = []
+    expected = nil
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_one_param
+    test_method = UtilTestModule.public_method(:test_command_with_arg)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["abc"]
+    expected = {:test_arg=>"abc"}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_one_param_array
+    test_method = UtilTestModule.public_method(:test_command_with_arg)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["[a,b,c,1,2,3]"]
+    expected = {:test_arg=>['a','b','c',1,2,3]}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_one_param_hash
+    test_method = UtilTestModule.public_method(:test_command_with_arg)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["{abc: 123}"]
+    expected = {:test_arg=>{"abc"=>123}}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_too_many_args
+    test_method = UtilTestModule.public_method(:test_command)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["123"]
+    expected = nil
+    result = nil
+    assert_raise Rubycom::CLIError do
+      result = Rubycom::Arguments.resolve(params, arguments)
+    end
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_too_few_args
+    test_method = UtilTestModule.public_method(:test_command_with_arg)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = []
+    expected = nil
+    result = nil
+    assert_raise Rubycom::CLIError do
+      result = Rubycom::Arguments.resolve(params, arguments)
+    end
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_with_options
+    test_method = UtilTestModule.public_method(:test_command_with_options)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = [";asd"]
+    expected = {:test_arg=>";asd", :test_option=>"option_default"}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_with_options_filled
+    test_method = UtilTestModule.public_method(:test_command_with_options)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["[1,2,3]","--test_option=abc"]
+    expected = {:test_arg=>[1, 2, 3], :test_option=>"abc"}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_all_options
+    test_method = UtilTestModule.public_method(:test_command_all_options)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = []
+    expected = {:test_arg=>"test_arg_default", :test_option=>"test_option_default"}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_all_opts_args_entered
+    test_method = UtilTestModule.public_method(:test_command_all_options)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["[1,2,3]","abc"]
+    expected = {:test_arg=>[1, 2, 3], :test_option=>"abc"}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_all_opts_filled
+    test_method = UtilTestModule.public_method(:test_command_all_options)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["-test_arg='123asd'","--test_option=[b,c,d]"]
+    expected = {:test_arg=>"123asd", :test_option=>["b","c","d"]}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_arr_option
+    test_method = UtilTestModule.public_method(:test_command_arg_arr)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["--test_arr=['123','abc']"]
+    expected = {:test_arr=>["123","abc"]}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_options_arr
+    test_method = UtilTestModule.public_method(:test_command_options_arr)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = [",a2","1","2","3","a","b","c"]
+    expected = {:test_option=>",a2", :test_options=>[1, 2, 3, "a", "b", "c"]}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_options_arr_with_arr
+    test_method = UtilTestModule.public_method(:test_command_options_arr)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = [",a2","[1,2,3,a,b,c]"]
+    expected = {:test_option=>",a2", :test_options=>[[1, 2, 3, "a", "b", "c"]]}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
+  def test_parse_args_hash
+    test_method = UtilTestModule.public_method(:test_command_arg_hash)
+    params = Rubycom::Arguments.get_param_definitions(test_method)
+    arguments = ["{testing: 'arg1', 123: 'abc', abc: 123}"]
+    expected = {:test_hash=>{"testing"=>"arg1", 123=>"abc", "abc"=>123}}
+    result = Rubycom::Arguments.resolve(params, arguments)
+    assert_equal(expected, result)
+  end
+
 end

data/test/rubycom/rubycom_test.rb

@@ -281,28 +281,22 @@ class RubycomTest < Test::Unit::TestCase
   end
 
   def test_run_options_arr
-    tst_out = ''
-
-    def tst_out.write(data)
-      self << data
-    end
-
-    o_stdout, $stdout = $stdout, tst_out
-    o_stderr, $stderr = $stderr, tst_out
-
-    base = UtilTestModule
-    args = ["test_command_options_arr", "test_option1", "test_option2", 1.0, false]
-    result = Rubycom.run(base, args)
+    mod = "util_test_module.rb"
+    command = "test_command_options_arr"
+    args = "test_option1 test_option2 1.0 false"
+    expected = 'Output is test_option=test_option1,test_option_arr=["test_option2", 1.0, false]'+"\n\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
 
-    e_test_arg = 'test_option1'
-    e_test_options = ["test_option2", 1.0, false]
-    expected = nil
-    expected_out = "Output is test_option=#{e_test_arg},test_option_arr=#{e_test_options}\n"
+  def test_run_multi_args
+    mod = "util_test_composite.rb"
+    sub_mod = "UtilTestModule"
+    command = "test_command_with_args"
+    args = "a b"
+    expected = 'test_arg=a,another_test_arg=b'+"\n\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{sub_mod} #{command} #{args})
     assert_equal(expected, result)
-    assert_equal(expected_out.gsub(/\n|\r|\s/, ''), tst_out.gsub(/\n|\r|\s/, ''))
-  ensure
-    $stdout = o_stdout
-    $stderr = o_stderr
   end
 
   def test_run_missing_required_arg
@@ -369,6 +363,15 @@ class RubycomTest < Test::Unit::TestCase
     assert_equal(expected, result)
   end
 
+  def test_full_run_args_for_opts
+    mod = "util_test_module.rb"
+    command = "test_command_mixed_options"
+    args = "testing_arg test2 testing_option test_hsh_arg true some other args"
+    expected = "test_arg=testing_arg test_arr=test2 test_opt=testing_option test_hsh=test_hsh_arg test_bool=true test_rest=[\"some\", \"other\", \"args\"]"+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
   def test_full_run_mixed_args_solid_arr
     mod = "util_test_module.rb"
     command = "test_command_mixed_options"
@@ -414,6 +417,24 @@ class RubycomTest < Test::Unit::TestCase
     assert_equal(expected, result)
   end
 
+  def test_full_run_sharp_arg
+    mod = "util_test_module.rb"
+    command = "test_command_mixed_options"
+    args = '#' + " \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" -test_bool=true some other args"
+    expected = 'test_arg=# test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
+  def test_full_run_bang_arg
+    mod = "util_test_module.rb"
+    command = "test_command_mixed_options"
+    args = "! \"[test1, test2]\" -test_opt='testing_option' \"{a: 'test_hsh_arg'}\" -test_bool=true some other args"
+    expected = 'test_arg=! test_arr=["test1", "test2"] test_opt=testing_option test_hsh={"a"=>"test_hsh_arg"} test_bool=true test_rest=["some", "other", "args"]'+"\n"
+    result = %x(ruby #{File.expand_path(File.dirname(__FILE__))}/#{mod} #{command} #{args})
+    assert_equal(expected, result)
+  end
+
   def test_tab_complete_nil_arg
     mod = UtilTestComposite
     args = nil

data/test/rubycom/util_test_module.rb

@@ -53,7 +53,7 @@ module UtilTestModule
 
   # A test_command with an options array
   # @param [String] test_option an optional test argument
-  # @param [String] test_options an optional array of arguments
+  # @param [Array] test_options an optional array of arguments
   def self.test_command_options_arr (
       test_option="test_option_default",
           *test_options

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubycom
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Danny Purcell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-29 00:00:00.000000000 Z
+date: 2013-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler