bosonson 0.304.1

data/lib/boson/namespace.rb

@@ -0,0 +1,31 @@
+module Boson
+  # Used in all things namespace.
+  class Namespace
+    # Hash of created namespace names to namespace objects
+    def self.namespaces
+      @namespaces ||= {}
+    end
+
+    # Creates a namespace given its name and the library it belongs to.
+    def self.create(name, library)
+      namespaces[name.to_s] = new(name, library)
+      Commands::Namespace.send(:define_method, name) { Boson::Namespace.namespaces[name.to_s] }
+    end
+
+    def initialize(name, library)
+      raise ArgumentError unless library.module
+      @name, @library = name.to_s, library
+      class <<self; self end.send :include, @library.module
+    end
+
+    def method_missing(method, *args, &block)
+      Boson.can_invoke?(method) ? Boson.invoke(method, *args, &block) : super
+    end
+
+    #:startdoc:
+    # List of subcommands for the namespace.
+    def boson_commands
+      @library.module.instance_methods.map {|e| e.to_s }
+    end
+  end
+end

data/lib/boson/option_command.rb

@@ -0,0 +1,222 @@
+require 'shellwords'
+module Boson
+  # A class used by Scientist to wrap around Command objects. It's main purpose is to parse
+  # a command's global options (basic, render and pipe types) and local options.
+  # As the names imply, global options are available to all commands while local options are specific to a command.
+  # When passing options to commands, global ones _must_ be passed first, then local ones.
+  # Also, options _must_ all be passed either before or after arguments.
+  # For more about pipe and render options see Pipe and View respectively.
+  #
+  # === Basic Global Options
+  # Any command with options comes with basic global options. For example '-hv' on an option command
+  # prints a help summarizing global and local options. Another basic global option is --pretend. This
+  # option displays what global options have been parsed and the actual arguments to be passed to a
+  # command if executed. For example:
+  #
+  #   # Define this command in a library
+  #   options :level=>:numeric, :verbose=>:boolean
+  #   def foo(*args)
+  #     args
+  #   end
+  #
+  #   irb>> foo 'testin -p -l=1'
+  #   Arguments: ["testin", {:level=>1}]
+  #   Global options: {:pretend=>true}
+  #
+  # If a global option conflicts with a local option, the local option takes precedence. You can get around
+  # this by passing global options after a '-'. For example, if the global option -f (--fields) conflicts with
+  # a local -f (--force):
+  #   foo 'arg1 -v -f - -f=f1,f2'
+  #   # is the same as
+  #   foo 'arg1 -v --fields=f1,f2 -f'
+  #
+  # === Toggling Views With the Basic Global Option --render
+  # One of the more important global options is --render. This option toggles the rendering of a command's
+  # output done with View and Hirb[http://github.com/cldwalker/hirb].
+  #
+  # Here's a simple example of toggling Hirb's table view:
+  #   # Defined in a library file:
+  #   #@options {}
+  #   def list(options={})
+  #     [1,2,3]
+  #   end
+  #
+  #   Using it in irb:
+  #   >> list
+  #   => [1,2,3]
+  #   >> list '-r'  # or list --render
+  #   +-------+
+  #   | value |
+  #   +-------+
+  #   | 1     |
+  #   | 2     |
+  #   | 3     |
+  #   +-------+
+  #   3 rows in set
+  #   => true
+  class OptionCommand
+    # ArgumentError specific to @command's arguments
+    class CommandArgumentError < ::ArgumentError; end
+
+    BASIC_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."},
+      :usage_options=>{:type=>:string, :desc=>"Render options to pass to usage/help"},
+      :pretend=>{:type=>:boolean, :desc=>"Display what a command would execute without executing it"},
+      :delete_options=>{:type=>:array, :desc=>'Deletes global options starting with given strings' }
+    } #:nodoc:
+
+    RENDER_OPTIONS = {
+      :fields=>{:type=>:array, :desc=>"Displays fields in the order given"},
+      :class=>{:type=>:string, :desc=>"Hirb helper class which renders"},
+      :max_width=>{:type=>:numeric, :desc=>"Max width of a table"},
+      :vertical=>{:type=>:boolean, :desc=>"Display a vertical table"},
+    } #:nodoc:
+
+    PIPE_OPTIONS = {
+      :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"},
+      :pipes=>{:alias=>'P', :type=>:array, :desc=>"Pipe to commands sequentially"}
+    } #:nodoc:
+
+    class <<self
+      #:stopdoc:
+      def default_option_parser
+        @default_option_parser ||= OptionParser.new default_pipe_options.
+          merge(default_render_options.merge(BASIC_OPTIONS))
+      end
+
+      def default_pipe_options
+        @default_pipe_options ||= PIPE_OPTIONS.merge Pipe.pipe_options
+      end
+
+      def default_render_options
+        @default_render_options ||= RENDER_OPTIONS.merge Boson.repo.config[:render_options] || {}
+      end
+
+      def delete_non_render_options(opt)
+        opt.delete_if {|k,v| BASIC_OPTIONS.keys.include?(k) }
+      end
+      #:startdoc:
+    end
+
+    attr_accessor :command
+    def initialize(cmd)
+      @command = cmd
+    end
+
+    # Parses arguments and returns global options, local options and leftover arguments.
+    def parse(args)
+      if args.size == 1 && args[0].is_a?(String)
+        global_opt, 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)
+        temp_args = Runner.in_shell? ? args : Shellwords.shellwords(args.pop)
+        global_opt, parsed_options, new_args = parse_options temp_args
+        Runner.in_shell? ? args = new_args : args += new_args
+      # add default options
+      elsif @command.options.nil? || @command.options.empty? || (!@command.has_splat_args? &&
+        args.size <= (@command.arg_size - 1).abs) || (@command.has_splat_args? && !args[-1].is_a?(Hash))
+          global_opt, parsed_options = parse_options([])[0,2]
+      # merge default options with given hash of options
+      elsif (@command.has_splat_args? || (args.size == @command.arg_size)) && args[-1].is_a?(Hash)
+        global_opt, parsed_options = parse_options([])[0,2]
+        parsed_options.merge!(args.pop)
+      end
+      [global_opt || {}, parsed_options, args]
+    end
+
+    #:stopdoc:
+    def parse_options(args)
+      parsed_options = @command.option_parser.parse(args, :delete_invalid_opts=>true)
+      trailing, unparseable = split_trailing
+      global_options = parse_global_options @command.option_parser.leading_non_opts + trailing
+      new_args = option_parser.non_opts.dup + unparseable
+      [global_options, parsed_options, new_args]
+    rescue OptionParser::Error
+      global_options = parse_global_options @command.option_parser.leading_non_opts + split_trailing[0]
+      global_options[:help] ? [global_options, nil, []] : raise
+    end
+
+    def split_trailing
+      trailing = @command.option_parser.trailing_non_opts
+      if trailing[0] == '--'
+        trailing.shift
+        [ [], trailing ]
+      else
+        trailing.shift if trailing[0] == '-'
+        [ trailing, [] ]
+      end
+    end
+
+    def parse_global_options(args)
+      option_parser.parse args
+    end
+
+    def option_parser
+      @option_parser ||= @command.render_options ? OptionParser.new(all_global_options) :
+        self.class.default_option_parser
+    end
+
+    def all_global_options
+      OptionParser.make_mergeable! @command.render_options
+      render_opts = Util.recursive_hash_merge(@command.render_options, Util.deep_copy(self.class.default_render_options))
+      merged_opts = Util.recursive_hash_merge Util.deep_copy(self.class.default_pipe_options), render_opts
+      opts = Util.recursive_hash_merge merged_opts, Util.deep_copy(BASIC_OPTIONS)
+      set_global_option_defaults opts
+    end
+
+    def set_global_option_defaults(opts)
+      if !opts[:fields].key?(:values)
+        if opts[:fields][:default]
+          opts[:fields][:values] = opts[:fields][:default]
+        else
+          if opts[:change_fields] && (changed = opts[:change_fields][:default])
+            opts[:fields][:values] = changed.is_a?(Array) ? changed : changed.values
+          end
+          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
+
+    def modify_args(args)
+      if @command.default_option && @command.arg_size <= 1 && !@command.has_splat_args? &&
+        !args[0].is_a?(Hash) && args[0].to_s[/./] != '-' && !args.join.empty?
+        args[0] = "--#{@command.default_option}=#{args[0]}"
+      end
+    end
+
+    def check_argument_size(args)
+      if args.size != @command.arg_size && !@command.has_splat_args?
+        command_size, args_size = args.size > @command.arg_size ? [@command.arg_size, args.size] :
+          [@command.arg_size - 1, args.size - 1]
+        raise CommandArgumentError, "wrong number of arguments (#{args_size} for #{command_size})"
+      end
+    end
+
+    def add_default_args(args, obj)
+      if @command.args && args.size < @command.args.size - 1
+        # leave off last arg since its an option
+        @command.args.slice(0..-2).each_with_index {|arr,i|
+          next if args.size >= i + 1 # only fill in once args run out
+          break if arr.size != 2 # a default arg value must exist
+          begin
+            args[i] = @command.file_parsed_args? ? obj.instance_eval(arr[1]) : arr[1]
+          rescue Exception
+            raise Scientist::Error, "Unable to set default argument at position #{i+1}.\nReason: #{$!.message}"
+          end
+        }
+      end
+    end
+    #:startdoc:
+  end
+end

data/lib/boson/option_parser.rb

@@ -0,0 +1,475 @@
+module Boson
+  # Simple Hash with indifferent fetching and storing using symbol or string keys. Other actions such as
+  # merging should assume symbolic keys. Used by OptionParser.
+  class IndifferentAccessHash < ::Hash
+    #:stopdoc:
+    def initialize(hash={})
+      super()
+      hash.each {|k,v| self[k] = v }
+    end
+
+    def [](key)
+      super convert_key(key)
+    end
+
+    def []=(key, value)
+      super convert_key(key), value
+    end
+
+    def values_at(*indices)
+      indices.collect { |key| self[convert_key(key)] }
+    end
+
+    protected
+    def convert_key(key)
+      key.kind_of?(String) ? key.to_sym : key
+    end
+    #:startdoc:
+  end
+
+  # This class concisely defines commandline options that when parsed produce a Hash of option keys and values.
+  # Additional points:
+  # * Setting option values should follow conventions in *nix environments. See examples below.
+  # * By default, there are 5 option types, each which produce different objects for option values.
+  # * The default option types can produce objects for one or more of the following Ruby classes:
+  #   String, Integer, Float, Array, Hash, FalseClass, TrueClass.
+  # * Users can define their own option types which create objects for _any_ Ruby class. See Options.
+  # * Each option type can have attributes to enable more features (see OptionParser.new).
+  # * When options are parsed by parse(), an IndifferentAccessHash hash is returned.
+  # * Options are also called switches, parameters, flags etc.
+  # * Option parsing stops when it comes across a '--'.
+  #
+  # Default option types:
+  # [*:boolean*] This option has no passed value. To toogle a boolean, prepend with '--no-'.
+  #              Multiple booleans can be joined together.
+  #                '--debug'    -> {:debug=>true}
+  #                '--no-debug' -> {:debug=>false}
+  #                '--no-d'     -> {:debug=>false}
+  #                '-d -f -t' same as '-dft'
+  # [*:string*] Sets values by separating name from value with space or '='.
+  #               '--color red' -> {:color=>'red'}
+  #               '--color=red' -> {:color=>'red'}
+  #               '--color "gotta love spaces"' -> {:color=>'gotta love spaces'}
+  # [*:numeric*] Sets values as :string does or by appending number right after aliased name. Shortened form
+  #              can be appended to joined booleans.
+  #                '-n3'  -> {:num=>3}
+  #                '-dn3' -> {:debug=>true, :num=>3}
+  # [*:array*] Sets values as :string does. Multiple values are split by a configurable character
+  #            Default is ',' (see OptionParser.new). Passing '*' refers to all known :values.
+  #             '--fields 1,2,3' -> {:fields=>['1','2','3']}
+  #             '--fields *'     -> {:fields=>['1','2','3']}
+  # [*:hash*] Sets values as :string does. Key-value pairs are split by ':' and pairs are split by
+  #           a configurable character (default ','). Multiple keys can be joined to one value. Passing '*'
+  #           as a key refers to all known :keys.
+  #             '--fields a:b,c:d' -> {:fields=>{'a'=>'b', 'c'=>'d'} }
+  #             '--fields a,b:d'   -> {:fields=>{'a'=>'d', 'b'=>'d'} }
+  #             '--fields *:d'     -> {:fields=>{'a'=>'d', 'b'=>'d', 'c'=>'d'} }
+  #
+  # This is a modified version of Yehuda Katz's Thor::Options class which is a modified version
+  # of Daniel Berger's Getopt::Long class (licensed under Ruby's license).
+  class OptionParser
+    # Raised for all OptionParser errors
+    class Error < StandardError; end
+
+    NUMERIC     = /(\d*\.\d+|\d+)/
+    LONG_RE     = /^(--\w+[-\w+]*)$/
+    SHORT_RE    = /^(-[a-zA-Z])$/i
+    EQ_RE       = /^(--\w+[-\w+]*|-[a-zA-Z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-zA-Z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-zA-Z])#{NUMERIC}$/i
+    STOP_STRINGS = %w{-- -}
+    
+    attr_reader :leading_non_opts, :trailing_non_opts, :opt_aliases
+
+    # Given options to pass to OptionParser.new, this method parses ARGV and returns the remaining arguments
+    # and a hash of parsed options. This is useful for scripts outside of Boson.
+    def self.parse(options, args=ARGV)
+      @opt_parser ||= new(options)
+      parsed_options = @opt_parser.parse(args)
+      [@opt_parser.non_opts, parsed_options]
+    end
+
+    # Usage string summarizing options defined in parse
+    def self.usage
+      @opt_parser.to_s
+    end
+
+    def self.make_mergeable!(opts) #:nodoc:
+      opts.each {|k,v|
+        if !v.is_a?(Hash) && !v.is_a?(Symbol)
+          opts[k] = {:default=>v}
+        end
+      }
+    end
+
+    # Array of arguments left after defined options have been parsed out by parse.
+    def non_opts
+      leading_non_opts + trailing_non_opts
+    end
+
+    # Takes a hash of options. Each option, a key-value pair, must provide the option's
+    # name and type. Names longer than one character are accessed with '--' while
+    # one character names are accessed with '-'. Names can be symbols, strings
+    # or even dasherized strings:
+    #
+    #    Boson::OptionParser.new :debug=>:boolean, 'level'=>:numeric,
+    #      '--fields'=>:array
+    #
+    # Options can have default values and implicit types simply by changing the
+    # option type for the default value:
+    #
+    #    Boson::OptionParser.new :debug=>true, 'level'=>3.1, :fields=>%w{f1 f2}
+    #
+    # By default every option name longer than one character is given an alias,
+    # the first character from its name. For example, the --fields option
+    # has -f as its alias. You can override the default alias by providing your own
+    # option aliases as an array in the option's key.
+    #
+    #    Boson::OptionParser.new [:debug, :damnit, :D]=>true
+    #
+    # Note that aliases are accessed the same way as option names. For the above,
+    # --debug, --damnit and -D all refer to the same option.
+    #
+    # Options can have additional attributes by passing a hash to the option value instead of
+    # a type or default:
+    # 
+    #    Boson::OptionParser.new :fields=>{:type=>:array, :values=>%w{f1 f2 f3},
+    #     :enum=>false}
+    #
+    # These attributes are available when an option is parsed via current_attributes().
+    # Here are the available option attributes for the default option types:
+    #
+    # [*:type*] This or :default is required. Available types are :string, :boolean, :array, :numeric, :hash.
+    # [*:default*] This or :type is required. This is the default value an option has when not passed.
+    # [*:bool_default*] This is the value an option has when passed as a boolean. However, by enabling this
+    #                   an option can only have explicit values with '=' i.e. '--index=alias' and no '--index alias'.
+    #                   If this value is a string, it is parsed as any option value would be. Otherwise, the value is
+    #                   passed directly without parsing.
+    # [*:required*] Boolean indicating if option is required. Option parses raises error if value not given.
+    #               Default is false.
+    # [*:alias*] Alternative way to define option aliases with an option name or an array of them. Useful in yaml files.
+    #            Setting to false will prevent creating an automatic alias.
+    # [*:values*] An array of values an option can have. Available for :array and :string options. Values here
+    #             can be aliased by typing a unique string it starts with or underscore aliasing (see Util.underscore_search).
+    #             For example, for values foo, odd and obnoxiously_long, f refers to foo, od to odd and o_l to obnoxiously_long.
+    # [*:enum*] Boolean indicating if an option enforces values in :values or :keys. Default is true. For
+    #           :array, :hash and :string options.
+    # [*:split*] For :array and :hash options. A string or regular expression on which an array value splits
+    #            to produce an array of values. Default is ','.
+    # [*:keys*] :hash option only. An array of values a hash option's keys can have. Keys can be aliased just like :values.
+    # [*:default_keys*] For :hash option only. Default keys to assume when only a value is given. Multiple keys can be joined
+    #                   by the :split character. Defaults to first key of :keys if :keys given.
+    # [*:regexp*] For :array option with a :values attribute. Boolean indicating that each option value does a regular
+    #             expression search of :values. If there are values that match, they replace the original option value. If none,
+    #             then the original option value is used.
+    def initialize(opts)
+      @defaults = {}
+      @opt_aliases = {}
+      @leading_non_opts, @trailing_non_opts = [], []
+
+      # build hash of dashed options to option types
+      # type can be a hash of opt attributes, a default value or a type symbol
+      @opt_types = opts.inject({}) do |mem, (name, type)|
+        name, *aliases = name if name.is_a?(Array)
+        name = name.to_s
+        # we need both nice and dasherized form of option name
+        if name.index('-') == 0
+          nice_name = undasherize name
+        else
+          nice_name = name
+          name = dasherize name
+        end
+        # store for later
+        @opt_aliases[nice_name] = aliases || []
+
+        if type.is_a?(Hash)
+          @option_attributes ||= {}
+          @option_attributes[nice_name] = type
+          @opt_aliases[nice_name] = Array(type[:alias]) if type.key?(:alias)
+          @defaults[nice_name] = type[:default] if type[:default]
+          @option_attributes[nice_name][:enum] = true if (type.key?(:values) || type.key?(:keys)) &&
+            !type.key?(:enum)
+          @option_attributes[nice_name][:default_keys] ||= type[:keys][0] if type.key?(:keys)
+          type = type[:type] || (!type[:default].nil? ? determine_option_type(type[:default]) : :boolean)
+        end
+
+        # set defaults
+        case type
+        when TrueClass                     then  @defaults[nice_name] = true
+        when FalseClass                    then  @defaults[nice_name] = false
+        else @defaults[nice_name] = type unless type.is_a?(Symbol)
+        end
+        mem[name] = !type.nil? ? determine_option_type(type) : type
+        mem
+      end
+
+      # generate hash of dashed aliases to dashed options
+      @opt_aliases = @opt_aliases.sort.inject({}) {|h, (nice_name, aliases)|
+        name = dasherize nice_name
+        # allow for aliases as symbols
+        aliases.map! {|e| e.to_s.index('-') == 0 || e == false ? e : dasherize(e.to_s) }
+        if aliases.empty? and nice_name.length > 1
+          opt_alias = nice_name[0,1]
+          opt_alias = h.key?("-"+opt_alias) ? "-"+opt_alias.capitalize : "-"+opt_alias
+          h[opt_alias] ||= name unless @opt_types.key?(opt_alias)
+        else
+          aliases.each {|e| h[e] = name if !@opt_types.key?(e) && e != false }
+        end
+        h
+      }
+    end
+
+    # Parses an array of arguments for defined options to return an IndifferentAccessHash. Once the parser
+    # recognizes a valid option, it continues to parse until an non option argument is detected.
+    # Flags that can be passed to the parser:
+    # * :opts_before_args: When true options must come before arguments. Default is false.
+    # * :delete_invalid_opts: When true deletes any invalid options left after parsing. Will stop deleting if
+    #   it comes across - or --. Default is false.
+    def parse(args, flags={})
+      @args = args
+      # start with defaults
+      hash = IndifferentAccessHash.new @defaults
+      
+      @leading_non_opts = []
+      unless flags[:opts_before_args]
+        @leading_non_opts << shift until current_is_option? || @args.empty? || STOP_STRINGS.include?(peek)
+      end
+
+      while current_is_option?
+        case @original_current_option = shift
+        when SHORT_SQ_RE
+          unshift $1.split('').map { |f| "-#{f}" }
+          next
+        when EQ_RE, SHORT_NUM
+          unshift $2
+          option = $1
+        when LONG_RE, SHORT_RE
+          option = $1
+        end
+
+        dashed_option = normalize_option(option)
+        @current_option = undasherize(dashed_option)
+        type = option_type(dashed_option)
+        validate_option_value(type)
+        value = create_option_value(type)
+        # set on different line since current_option may change
+        hash[@current_option.to_sym] = value
+      end
+
+      @trailing_non_opts = @args
+      check_required! hash
+      delete_invalid_opts if flags[:delete_invalid_opts]
+      hash
+    end
+
+    # Helper method to generate usage. Takes a dashed option and a string value indicating
+    # an option value's format.
+    def default_usage(opt, val)
+      opt + "=" + (@defaults[undasherize(opt)] || val).to_s
+    end
+
+    # Generates one-line usage of all options.
+    def formatted_usage
+      return "" if @opt_types.empty?
+      @opt_types.map do |opt, type|
+        val = respond_to?("usage_for_#{type}", true) ? send("usage_for_#{type}", opt) : "#{opt}=:#{type}"
+        "[" + val + "]"
+      end.join(" ")
+    end
+
+    alias :to_s :formatted_usage
+
+    # More verbose option help in the form of a table.
+    def print_usage_table(render_options={})
+      user_fields = render_options.delete(:fields)
+      fields = get_usage_fields user_fields
+      (fields << :default).uniq! if render_options.delete(:local) || user_fields == '*'
+      opts = all_options_with_fields fields
+      fields.delete(:default) if fields.include?(:default) && opts.all? {|e| e[:default].nil? }
+      render_options = default_render_options.merge(:fields=>fields).merge(render_options)
+      View.render opts, render_options
+    end
+
+    def all_options_with_fields(fields) #:nodoc:
+      aliases = @opt_aliases.invert
+      @opt_types.keys.sort.inject([]) {|t,e|
+        nice_name = undasherize(e)
+        h = {:name=>e, :type=>@opt_types[e], :alias=>aliases[e] || '' }
+        h[:default] = @defaults[nice_name] if fields.include?(:default)
+        (fields - h.keys).each {|f|
+          h[f] = (option_attributes[nice_name] || {})[f]
+        }
+        t << h
+      }
+    end
+
+    def default_render_options #:nodoc:
+      {:header_filter=>:capitalize, :description=>false, :filter_any=>true,
+        :filter_classes=>{Array=>[:join, ',']}, :hide_empty=>true}
+    end
+
+    # Hash of option names mapped to hash of its external attributes
+    def option_attributes
+      @option_attributes || {}
+    end
+
+    def get_usage_fields(fields) #:nodoc:
+      fields || ([:name, :alias, :type] + [:desc, :values, :keys].select {|e|
+        option_attributes.values.any? {|f| f.key?(e) } }).uniq
+    end
+
+    # Hash of option attributes for the currently parsed option. _Any_ hash keys
+    # passed to an option are available here. This means that an option type can have any
+    # user-defined attributes available during option parsing and object creation.
+    def current_attributes
+      @option_attributes && @option_attributes[@current_option] || {}
+    end
+
+    # Removes dashes from a dashed option i.e. '--date' -> 'date' and '-d' -> 'd'.
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
+
+    # Adds dashes to an option name i.e. 'date' -> '--date' and 'd' -> '-d'.
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str
+    end
+
+    # List of option types
+    def types
+      @opt_types.values
+    end
+
+    # List of option names
+    def names
+      @opt_types.keys.map {|e| undasherize e }
+    end
+
+    # List of option aliases
+    def aliases
+      @opt_aliases.keys.map {|e| undasherize e }
+    end
+
+    def option_type(opt)
+      if opt =~ /^--no-(\w+)$/
+        @opt_types[opt] || @opt_types[dasherize($1)] || @opt_types[original_no_opt($1)]
+      else
+        @opt_types[opt]
+      end
+    end
+
+    private
+    def determine_option_type(value)
+      return value if value.is_a?(Symbol)
+      case value
+      when TrueClass, FalseClass   then :boolean
+      when Numeric                 then :numeric
+      else Util.underscore(value.class.to_s).to_sym
+      end
+    end
+
+    def value_shift
+      return shift if !current_attributes.key?(:bool_default)
+      return shift if @original_current_option =~ EQ_RE
+      current_attributes[:bool_default]
+    end
+
+    def create_option_value(type)
+      if current_attributes.key?(:bool_default) && (@original_current_option !~ EQ_RE) &&
+        !(bool_default = current_attributes[:bool_default]).is_a?(String)
+          bool_default
+      else
+        respond_to?("create_#{type}", true) ? send("create_#{type}", type != :boolean ? value_shift : nil) :
+          raise(Error, "Option '#{@current_option}' is invalid option type #{type.inspect}.")
+      end
+    end
+
+    def auto_alias_value(values, possible_value)
+      if Boson.repo.config[:option_underscore_search]
+        self.class.send(:define_method, :auto_alias_value) {|values, possible_value|
+          Util.underscore_search(possible_value, values, true) || possible_value
+        }.call(values, possible_value)
+      else
+        self.class.send(:define_method, :auto_alias_value) {|values, possible_value|
+          values.find {|v| v.to_s =~ /^#{possible_value}/ } || possible_value
+        }.call(values, possible_value)
+      end
+    end
+
+    def validate_enum_values(values, possible_values)
+      if current_attributes[:enum]
+        Array(possible_values).each {|e|
+          raise(Error, "invalid value '#{e}' for option '#{@current_option}'") if !values.include?(e)
+        }
+      end
+    end
+
+    def validate_option_value(type)
+      return if current_attributes.key?(:bool_default)
+      if type != :boolean && peek.nil?
+        raise Error, "no value provided for option '#{@current_option}'"
+      end
+      send("validate_#{type}", peek) if respond_to?("validate_#{type}", true)
+    end
+
+    def delete_invalid_opts
+      @trailing_non_opts.delete_if {|e|
+        break if STOP_STRINGS.include? e
+        invalid = e.to_s[/^-/]
+        $stderr.puts "Deleted invalid option '#{e}'" if invalid
+        invalid
+      }
+    end
+
+    def peek
+      @args.first
+    end
+
+    def shift
+      @args.shift
+    end
+
+    def unshift(arg)
+      unless arg.kind_of?(Array)
+        @args.unshift(arg)
+      else
+        @args = arg + @args
+      end
+    end
+    
+    def valid?(arg)
+      if arg.to_s =~ /^--no-(\w+)$/
+        @opt_types.key?(arg) or (@opt_types[dasherize($1)] == :boolean) or
+          (@opt_types[original_no_opt($1)] == :boolean)
+      else
+        @opt_types.key?(arg) or @opt_aliases.key?(arg)
+      end
+    end
+
+    def current_is_option?
+      case peek
+      when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+        valid?($1)
+      when SHORT_SQ_RE
+        $1.split('').any? { |f| valid?("-#{f}") }
+      end
+    end
+    
+    def normalize_option(opt)
+      @opt_aliases.key?(opt) ? @opt_aliases[opt] : opt
+    end
+    
+    def original_no_opt(opt)
+      @opt_aliases[dasherize(opt)]
+    end
+
+    def check_required!(hash)
+      for name, type in @opt_types
+        @current_option = undasherize(name)
+        if current_attributes[:required] && !hash.key?(@current_option.to_sym)
+          raise Error, "no value provided for required option '#{@current_option}'"
+        end
+      end
+    end
+  end
+end