boson 0.1.0 → 0.2.0

data/lib/boson/options.rb

@@ -0,0 +1,127 @@
+module Boson
+  # This module contains the methods used to define the default option types.
+  #
+  # === Creating Your Own Option Type
+  # Defining your own option type simply requires one method (create_@type) to parse the option value and create
+  # the desired object. To create an option type :date, you could create the following create_date method:
+  #   # Drop this in your ~/.irbrc after require 'boson'
+  #   module Boson::Options::Date
+  #     def create_date(value)
+  #       # value_shift should be mm/dd
+  #       Date.parse(value + "/#{Date.today.year}")
+  #     end
+  #   end
+  #   Boson::OptionParser.send :include, Boson::Options::Date
+  #
+  # In a FileLibrary, we could then use this new option:
+  #   module Calendar
+  #     #@options :day=>:date
+  #     def appointments(options={})
+  #       # ...
+  #     end
+  #   end
+  #   # >> appointments '-d 10/10'   -> {:day=>#<Date: 4910229/2,0,2299161> }
+  # As you can see, a date object is created from the :date option's value and passed into appointments().
+  #
+  # Some additional tips on the create_* method:
+  # * The argument passed to the method is the option value from the user.
+  # * To access the current option name use @current_option.
+  # * To access the hash of attributes the current option has use OptionParser.current_attributes. See
+  #   OptionParser.new for more about option attributes.
+  #
+  # There are two optional methods per option type: validate_@type and usage_for_@type i.e. validate_date and usage_for_date.
+  # Like create_@type, validate_@type takes the option's value. If the value validation fails, raise an
+  # OptionParser::Error with a proper message. All user-defined option types automatically validate for an option value's existence.
+  # The usage_for_* method takes an option's name (i.e. --day) and returns a usage string to be wrapped in '[ ]'. If no usage is defined
+  # the default would look like '[--day=:date]'. Consider using the OptionParser.default_usage helper method for your usage.
+  module Options
+    #:stopdoc:
+    # Parse/create methods
+    def create_string(value)
+      if (values = current_attributes[:values]) && (values = values.sort_by {|e| e.to_s})
+        (val = auto_alias_value(values, value)) && value = val
+      end
+      value
+    end
+
+    def create_boolean(value)
+      if (!@opt_types.key?(dasherize(@current_option)) && @current_option =~ /^no-(\w+)$/)
+        opt = (opt = original_no_opt($1)) ? undasherize(opt) : $1
+        (@current_option.replace(opt) && false)
+      else
+        true
+      end
+    end
+
+    def create_numeric(value)
+      value.index('.') ? value.to_f : value.to_i
+    end
+
+    def create_array(value)
+      splitter = current_attributes[:split] || ','
+      array = value.split(splitter)
+      if (values = current_attributes[:values]) && (values = values.sort_by {|e| e.to_s })
+        array.each {|e| array.delete(e) && array += values if e == '*'}
+        array.each_with_index {|e,i|
+          (value = auto_alias_value(values, e)) && array[i] = value
+        }
+      end
+      array
+    end
+
+    def create_hash(value)
+      splitter = current_attributes[:split] || ','
+      (keys = current_attributes[:keys]) && keys = keys.sort_by {|e| e.to_s }
+      if !value.include?(':') && current_attributes[:default_keys]
+        value = current_attributes[:default_keys].to_s + ":#{value}"
+      end
+      # Creates array pairs, grouping array of keys with a value
+      aoa = Hash[*value.split(/(?::)([^#{Regexp.quote(splitter)}]+)#{Regexp.quote(splitter)}?/)].to_a
+      aoa.each_with_index {|(k,v),i| aoa[i][0] = keys.join(splitter) if k == '*' } if keys
+      hash = aoa.inject({}) {|t,(k,v)| k.split(splitter).each {|e| t[e] = v }; t }
+      keys ? hash.each {|k,v|
+              (new_key = auto_alias_value(keys, k)) && hash[new_key] = hash.delete(k)
+             } : hash
+    end
+
+    # Validation methods
+    def validate_string(value)
+      raise OptionParser::Error, "cannot pass '#{value}' as an argument to option '#{@current_option}'" if valid?(value)
+    end
+
+    def validate_numeric(value)
+      unless value =~ OptionParser::NUMERIC and $& == value
+        raise OptionParser::Error, "expected numeric value for option '#{@current_option}'; got #{value.inspect}"
+      end
+    end
+
+    def validate_hash(value)
+      if !value.include?(':') && !current_attributes[:default_keys]
+        raise(OptionParser::Error, "invalid key:value pair for option '#{@current_option}'")
+      end
+    end
+
+    # Usage methods
+    def usage_for_boolean(opt)
+      opt
+    end
+
+    def usage_for_string(opt)
+      default_usage(opt, undasherize(opt).upcase)
+    end
+
+    def usage_for_numeric(opt)
+      default_usage opt, "N"
+    end
+
+    def usage_for_array(opt)
+      default_usage opt, "A,B,C"
+    end
+
+    def usage_for_hash(opt)
+      default_usage opt, "A:B,C:D"
+    end
+    #:startdoc:
+  end
+end
+Boson::OptionParser.send :include, Boson::Options

data/lib/boson/repo.rb

@@ -15,7 +15,16 @@ module Boson
 
     # Points to the config/ subdirectory and is automatically created when called. Used for config files.
     def config_dir
-      @config_dir ||= FileUtils.mkdir_p("#{dir}/config") && "#{dir}/config"
+      @config_dir ||= FileUtils.mkdir_p(config_dir_path) && config_dir_path
+    end
+
+    def config_dir_path
+      "#{dir}/config"
+    end
+
+    # Path name of main config file. If passed true, parent directory of file is created.
+    def config_file(create_dir=false)
+      File.join((create_dir ? config_dir : config_dir_path), 'boson.yml')
     end
 
     # Points to the commands/ subdirectory and is automatically created when called. Used for command libraries.
@@ -25,6 +34,7 @@ module Boson
 
     # A hash read from the YAML config file at config/boson.yml.
     # {See here}[http://github.com/cldwalker/irbfiles/blob/master/boson/config/boson.yml] for an example config file.
+    # Top level config keys, library attributes and config attributes need to be symbols.
     # ==== Valid config keys:
     # [:libraries] Hash of libraries mapping their name to attribute hashes. See Library.new for configurable attributes.
     #               Example:
@@ -35,8 +45,10 @@ module Boson
     #                    key of a library entry in :libraries.
     #                     Example:
     #                      :command_aliases=>{'libraries'=>'lib', 'commands'=>'com'}
-    # [:console_defaults] Array of libraries to load at start up when used in irb. Default is to load all library files and libraries defined
-    #             in the config.
+    # [:defaults] Array of libraries to load at start up for commandline and irb. This is useful for extending boson i.e. adding your
+    #             own option types. Default is no libraries.
+    # [:console_defaults] Array of libraries to load at start up when used in irb. Default is to load all library files and libraries
+    #                     defined in the config.
     # [:bin_defaults] Array of libraries to load at start up when used from the commandline. Default is no libraries.
     # [:add_load_path] Boolean specifying whether to add a load path pointing to the lib subdirectory/. This is useful in sharing
     #                  classes between libraries without resorting to packaging them as gems. Defaults to false if the lib
@@ -45,11 +57,18 @@ module Boson
     #                           the global namespace. When set to false, Boson automatically puts the library in its own namespace.
     #                           When set to true, the library fails to load explicitly. Default is false.
     # [:console] Console to load when using --console from commandline. Default is irb.
-    # [:auto_namespace] Boolean which automatically namespaces all user-defined libraries. Default is false.
+    # [:auto_namespace] Boolean which automatically namespaces all user-defined libraries. Be aware this can break libraries which
+    #                   depend on commands from other libraries. Default is false.
     def config(reload=false)
       if reload || @config.nil?
-        default = {:libraries=>{}, :command_aliases=>{}, :console_defaults=>[]}
-        @config = default.merge(YAML::load_file(config_dir + '/boson.yml')) rescue default
+        begin
+          @config = {:libraries=>{}, :command_aliases=>{}, :console_defaults=>[]}
+          @config.merge!(YAML::load_file(config_file(true))) if File.exists?(config_file)
+        rescue ArgumentError
+          message = $!.message !~ /syntax error on line (\d+)/ ? "Error"+$!.message :
+            "Error: Syntax error in line #{$1} of config file '#{config_file}'"
+          Kernel.abort message
+        end
       end
       @config
     end

data/lib/boson/runner.rb

@@ -11,13 +11,13 @@ module Boson
 
       # Libraries that come with Boson
       def default_libraries
-        [Boson::Commands::Core, Boson::Commands::WebCore]
+        [Boson::Commands::Core, Boson::Commands::WebCore] + (Boson.repo.config[:defaults] || [])
       end
 
       # Libraries detected in repositories
       def detected_libraries
         Boson.repos.map {|repo| Dir[File.join(repo.commands_dir, '**/*.rb')].
-          map {|e| e.gsub(/.*commands\//,'').gsub('.rb','') } }.flatten
+          map {|e| e.gsub(/^#{repo.commands_dir}\/|\.rb$/, '')} }.flatten
       end
 
       # Libraries specified in config files and detected_libraries

data/lib/boson/runners/bin_runner.rb

@@ -1,29 +1,38 @@
 module Boson
-  # Runs Boson from the commandline. Usage for the boson shell command looks like this:
+  # This class handles the boson executable (boson command execution from the commandline). Any changes
+  # to your commands are immediately available from the commandline except for changes to the main config file.
+  # For those changes to take effect you need to explicitly load and index the libraries with --index.
+  # See Index to understand how Boson can immediately detect the latest commands.
+  #
+  # Usage for the boson shell command looks like this:
   #   boson [GLOBAL OPTIONS] [COMMAND] [ARGS] [COMMAND OPTIONS]
   #
   # The boson executable comes with these global options:
   # [:help]  Gives a basic help of global options. When a command is given the help shifts to a command's help.
   # [:verbose] Using this along with :help option shows more help. Also gives verbosity to other actions i.e. loading.
-  # [:index] Updates index. This should be called in the unusual case that Boson doesn't detect new commands
-  #          and libraries.
   # [:execute] Like ruby -e, this executes a string of ruby code. However, this has the advantage that all
   #            commands are available as normal methods, automatically loading as needed. This is a good
   #            way to call commands that take non-string arguments.
   # [:console] This drops Boson into irb after having loaded default commands and any explict libraries with
-  #                :load option. This is a good way to start irb with only certain libraries loaded.
+  #            :load option. This is a good way to start irb with only certain libraries loaded.
   # [:load] Explicitly loads a list of libraries separated by commas. Most useful when used with :console option.
   #         Can also be used to explicitly load libraries that aren't being detected automatically.
+  # [:index] Updates index for given libraries allowing you to use them. This is useful if Boson's autodetection of
+  #          changed libraries isn't picking up your changes. Since this option has a :bool_default attribute, arguments
+  #          passed to this option need to be passed with '=' i.e. '--index=my_lib'.
   # [:render] Pretty formats the results of commands without options. Handy for commands that return arrays.
+  # [:pager_toggle] Toggles Hirb's pager in case you'd like to pipe to another command.
   class BinRunner < Runner
     GLOBAL_OPTIONS =  {
       :verbose=>{:type=>:boolean, :desc=>"Verbose description of loading libraries or help"},
-      :index=>{:type=>:boolean, :desc=>"Updates index for libraries and commands"},
+      :index=>{:type=>:array, :desc=>"Libraries to index. Libraries must be passed with '='.",
+        :bool_default=>nil, :values=>all_libraries, :enum=>false},
       :execute=>{:type=>:string, :desc=>"Executes given arguments as a one line script"},
       :console=>{:type=>:boolean, :desc=>"Drops into irb with default and explicit libraries loaded"},
       :help=>{:type=>:boolean, :desc=>"Displays this help message or a command's help if given a command"},
       :load=>{:type=>:array, :values=>all_libraries, :enum=>false, :desc=>"A comma delimited array of libraries to load"},
-      :render=>{:type=>:boolean, :desc=>"Renders a Hirb view from result of command without options"}
+      :render=>{:type=>:boolean, :desc=>"Renders a Hirb view from result of command without options"},
+      :pager_toggle=>{:type=>:boolean, :desc=>"Toggles Hirb's pager"}
     } #:nodoc:
 
     class <<self
@@ -34,6 +43,7 @@ module Boson
         return print_usage if args.empty? || (@command.nil? && !@options[:console] && !@options[:execute])
         return ConsoleRunner.bin_start(@options[:console], @options[:load]) if @options[:console]
         init
+        View.toggle_pager if @options[:pager_toggle]
 
         if @options[:help]
           Boson.invoke(:usage, @command, :verbose=>@options[:verbose])
@@ -43,14 +53,16 @@ module Boson
           execute_command
         end
       rescue Exception
-        print_error_message (@command && !Boson.can_invoke?(@command[/\w+/])) ?
+        is_invalid_command = lambda {|command| !Boson.can_invoke?(command[/\w+/]) ||
+          (Boson.can_invoke?(command[/\w+/]) && command.include?('.') && $!.is_a?(NoMethodError)) }
+        print_error_message @command && is_invalid_command.call(@command) ?
           "Error: Command '#{@command}' not found" : "Error: #{$!.message}"
       end
 
       # Loads the given command.
       def init
         super
-        Index.update(:verbose=>true) if @options[:index]
+        Index.update(:verbose=>true, :libraries=>@options[:index]) if @options.key?(:index)
         if @options[:load]
           Manager.load @options[:load], load_options
         elsif @options[:execute]
@@ -62,13 +74,13 @@ module Boson
 
       #:stopdoc:
       def print_error_message(message)
-        message += "\nActual error: #{$!}\n" + $!.backtrace.inspect if @options && @options[:verbose]
+        message += "\nOriginal error: #{$!}\n" + $!.backtrace.slice(0,10).map {|e| "  " + e }.join("\n") if @options && @options[:verbose]
         $stderr.puts message
       end
 
       def load_command_by_index
-        Index.update(:verbose=>@options[:verbose]) if !@options[:index] && Boson.can_invoke?(@command) && !@options[:help]
-        if !Boson.can_invoke?(@command) && ((lib = Index.find_library(@command)) ||
+        Index.update(:verbose=>@options[:verbose]) if !@options.key?(:index) && Boson.can_invoke?(@command) && !@options[:help]
+        if !Boson.can_invoke?(@command, false) && ((lib = Index.find_library(@command)) ||
           (Index.update(:verbose=>@options[:verbose]) && (lib = Index.find_library(@command))))
           Manager.load lib, load_options
         end
@@ -79,9 +91,7 @@ module Boson
       end
 
       def execute_command
-        command, subcommand = @command.include?('.') ? @command.split('.', 2) : [@command, nil]
-        dispatcher = subcommand ? Boson.invoke(command) : Boson.main_object
-        render_output dispatcher.send(subcommand || command, *@args)
+        render_output Boson.full_invoke(@command, @args)
       rescue ArgumentError
         # for the rare case it's raise outside of boson
         raise unless $!.backtrace.first.include?('boson/')
@@ -112,7 +122,7 @@ module Boson
         if @options[:verbose]
           Manager.load [Boson::Commands::Core]
           puts "\n\nDEFAULT COMMANDS"
-          Boson.invoke :commands, "", :fields=>["name", "usage", "description"], :description=>false
+          Boson.invoke :commands, :fields=>["name", "usage", "description"], :description=>false
         end
       end
       #:startdoc:

data/lib/boson/scientist.rb

@@ -1,9 +1,12 @@
 require 'shellwords'
 module Boson
-  # Scientist redefines the methods of commands that have options and/or take global options. This redefinition
-  # allows a command to receive its arguments normally or as a commandline app does. For a command's
-  # method to be redefined correctly, its last argument _must_ expect a hash.
+  # Scientist redefines _any_ object's methods to act like shell commands while still receiving ruby arguments normally.
+  # It also let's your method have an optional view generated from a method's return value.
+  # Boson::Scientist.create_option_command redefines an object's method with a Boson::Command while
+  # Boson::Scientist.commandify redefines with just a hash. For an object's method to be redefined correctly,
+  # its last argument _must_ expect a hash.
   #
+  # === Examples
   # Take for example this basic method/command with an options definition:
   #   options :level=>:numeric, :verbose=>:boolean
   #   def foo(arg='', options={})
@@ -72,25 +75,26 @@ module Boson
     class Error < StandardError; end
     class EscapeGlobalOption < StandardError; end
 
-    attr_reader :global_options, :rendered
+    attr_reader :global_options, :rendered, :option_parsers, :command_options
     @no_option_commands ||= []
     GLOBAL_OPTIONS = {
       :help=>{:type=>:boolean, :desc=>"Display a command's help"},
       :render=>{:type=>:boolean, :desc=>"Toggle a command's default rendering behavior"},
       :verbose=>{:type=>:boolean, :desc=>"Increase verbosity for help, errors, etc."},
       :global=>{:type=>:string, :desc=>"Pass a string of global options without the dashes"},
-      :pretend=>{:type=>:boolean, :desc=>"Display what a command would execute without executing it"}
+      :pretend=>{:type=>:boolean, :desc=>"Display what a command would execute without executing it"},
     } #:nodoc:
     RENDER_OPTIONS = {
       :fields=>{:type=>:array, :desc=>"Displays fields in the order given"},
-      :sort=>{:type=>:string, :desc=>"Sort by given field"},
       :class=>{:type=>:string, :desc=>"Hirb helper class which renders"},
-      :reverse_sort=>{:type=>:boolean, :desc=>"Reverse a given sort"},
       :max_width=>{:type=>:numeric, :desc=>"Max width of a table"},
-      :vertical=>{:type=>:boolean, :desc=>"Display a vertical table"}
+      :vertical=>{:type=>:boolean, :desc=>"Display a vertical table"},
+      :sort=>{:type=>:string, :desc=>"Sort by given field"},
+      :reverse_sort=>{:type=>:boolean, :desc=>"Reverse a given sort"},
+      :query=>{:type=>:hash, :desc=>"Queries fields given field:search pairs"},
     } #:nodoc:
 
-    # Redefines a command's method for the given object.
+    # Redefines an object's method with a Command of the same name.
     def create_option_command(obj, command)
       cmd_block = create_option_command_block(obj, command)
       @no_option_commands << command if command.options.nil?
@@ -99,6 +103,29 @@ module Boson
       }
     end
 
+    # A wrapper around create_option_command that doesn't depend on a Command object. Rather you
+    # simply pass a hash of command attributes (see Command.new) or command methods and let OpenStruct mock a command.
+    # The only required attribute is :name, though to get any real use you should define :options and
+    # :arg_size (default is '*'). Example:
+    #   >> def checkit(*args); args; end
+    #   => nil
+    #   >> Boson::Scientist.commandify(self, :name=>'checkit', :options=>{:verbose=>:boolean, :num=>:numeric})
+    #   => ['checkit']
+    #   # regular ruby method
+    #   >> checkit 'one', 'two', :num=>13, :verbose=>true
+    #   => ["one", "two", {:num=>13, :verbose=>true}]
+    #   # commandline ruby method
+    #   >> checkit 'one two -v -n=13'
+    #   => ["one", "two", {:num=>13, :verbose=>true}]
+    def commandify(obj, hash)
+      raise ArgumentError, ":name required" unless hash[:name]
+      hash[:arg_size] ||= '*'
+      hash[:has_splat_args?] = true if hash[:arg_size] == '*'
+      fake_cmd = OpenStruct.new(hash)
+      fake_cmd.option_parser ||= OptionParser.new(fake_cmd.options || {})
+      create_option_command(obj, fake_cmd)
+    end
+
     # The actual method which replaces a command's original method
     def create_option_command_block(obj, command)
       lambda {|*args|
@@ -123,8 +150,13 @@ module Boson
 
     def translate_args(obj, command, args)
       @obj, @command, @args = obj, command, args
+      # prepends default option
+      if @command.default_option && @command.arg_size == 1 && !@command.has_splat_args? && @args[0].to_s[/./] != '-'
+        @args[0] = "--#{@command.default_option}=#{@args[0]}" unless @args.join.empty? || @args[0].is_a?(Hash)
+      end
       @command.options ||= {}
-      if parsed_options = command_options
+
+      if parsed_options = parse_command_options
         add_default_args(@args)
         return @args if @no_option_commands.include?(@command)
         @args << parsed_options
@@ -143,65 +175,103 @@ module Boson
     end
 
     def render_or_raw(result)
-      (@rendered = render?) ? View.render(result, global_render_options) : result
+      if (@rendered = render?)
+        result = run_pipe_commands(result)
+        render_global_opts = @global_options.dup.delete_if {|k,v| default_global_options.keys.include?(k) }
+        View.render(result, render_global_opts, false)
+      else
+        result = View.search_and_sort(result, @global_options) if !(@global_options.keys & [:sort, :reverse_sort, :query]).empty?
+        run_pipe_commands(result)
+      end
     rescue Exception
       message = @global_options[:verbose] ? "#{$!}\n#{$!.backtrace.inspect}" : $!.message
       raise Error, message
     end
 
+    def pipe_options
+      @pipe_options ||= Hash[*default_global_options.select {|k,v| v[:pipe] }.flatten]
+    end
+
+    def run_pipe_commands(result)
+      (global_options.keys & pipe_options.keys).each {|e|
+        command = pipe_options[e][:pipe] != true ? pipe_options[e][:pipe] : e
+        pipe_result = pipe_options[e][:type] == :boolean ? Boson.invoke(command, result) :
+          Boson.invoke(command, result, global_options[e])
+        result = pipe_result if pipe_options[e][:filter]
+      }
+      result
+    end
+
+    # choose current parser
     def option_parser
       @command.render_options ? command_option_parser : default_option_parser
     end
 
+    # current command parser
     def command_option_parser
-      (@option_parsers ||= {})[@command] ||= OptionParser.new render_options.merge(GLOBAL_OPTIONS)
+      (@option_parsers ||= {})[@command] ||= OptionParser.new current_command_options
     end
 
+    # set cmd and use its parser
     def render_option_parser(cmd)
       @command = cmd
       option_parser
     end
 
     def default_option_parser
-      @default_option_parser ||= OptionParser.new RENDER_OPTIONS.merge(GLOBAL_OPTIONS)
+      @default_option_parser ||= OptionParser.new default_render_options.merge(default_global_options)
+    end
+
+    def default_global_options
+      @default_global_options ||= GLOBAL_OPTIONS.merge Boson.repo.config[:global_options] || {}
     end
 
-    def render_options
-      @command.render_options ? command_render_options : RENDER_OPTIONS
+    def default_render_options
+      @default_render_options ||= RENDER_OPTIONS.merge Boson.repo.config[:render_options] || {}
     end
 
-    def command_render_options
-      (@command_render_options ||= {})[@command] ||= begin
+    def current_command_options
+      (@command_options ||= {})[@command] ||= begin
         @command.render_options.each {|k,v|
-          if !v.is_a?(Hash) && !v.is_a?(Symbol) && RENDER_OPTIONS.keys.include?(k)
+          if !v.is_a?(Hash) && !v.is_a?(Symbol)
             @command.render_options[k] = {:default=>v}
           end
         }
-        opts = Util.recursive_hash_merge(@command.render_options, Util.deep_copy(RENDER_OPTIONS))
-        opts[:sort][:values] ||= opts[:fields][:values] if opts[:fields][:values]
+        render_opts = Util.recursive_hash_merge(@command.render_options, Util.deep_copy(default_render_options))
+        opts = Util.recursive_hash_merge render_opts, Util.deep_copy(default_global_options)
+        if !opts[:fields].key?(:values)
+          if opts[:fields][:default]
+            opts[:fields][:values] = opts[:fields][:default]
+          else
+            opts[:fields][:values] = opts[:change_fields][:default].values if opts[:change_fields] && opts[:change_fields][:default]
+            opts[:fields][:values] ||= opts[:headers][:default].keys if opts[:headers] && opts[:headers][:default]
+          end
+          opts[:fields][:enum] = false if opts[:fields][:values] && !opts[:fields].key?(:enum)
+        end
+        if opts[:fields][:values]
+          opts[:sort][:values] ||= opts[:fields][:values]
+          opts[:query][:keys] ||= opts[:fields][:values]
+          opts[:query][:default_keys] ||= "*"
+        end
         opts
       end
     end
 
-    def global_render_options
-      @global_options.dup.delete_if {|k,v| !render_options.keys.include?(k) }
-    end
-
     def render?
       (@command.render_options && !@global_options[:render]) || (!@command.render_options && @global_options[:render])
     end
 
-    def command_options
+    def parse_command_options
       if @args.size == 1 && @args[0].is_a?(String)
         parsed_options, @args = parse_options Shellwords.shellwords(@args[0])
       # last string argument interpreted as args + options
       elsif @args.size > 1 && @args[-1].is_a?(String)
-        args = caller.grep(/bin_runner.rb:/).empty? ? Shellwords.shellwords(@args.pop) : @args
+        args = Boson.const_defined?(:BinRunner) ? @args : Shellwords.shellwords(@args.pop)
         parsed_options, new_args = parse_options args
         @args += new_args
       # add default options
-      elsif (!@command.has_splat_args? && @args.size <= @command.arg_size - 1) ||
-        (@command.has_splat_args? && !@args[-1].is_a?(Hash))
+      elsif @command.options.empty? || (!@command.has_splat_args? &&
+        @args.size <= (@command.arg_size - 1).abs) || (@command.has_splat_args? && !@args[-1].is_a?(Hash))
           parsed_options = parse_options([])[0]
       # merge default options with given hash of options
       elsif (@command.has_splat_args? || (@args.size == @command.arg_size)) && @args[-1].is_a?(Hash)