boson 0.2.2 → 0.2.3

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT LICENSE
 
-Copyright (c) 2009 Gabriel Horner
+Copyright (c) 2010 Gabriel Horner
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -18,8 +18,8 @@ Note: To read a linkable version of this README, {see here}[http://tagaholic.me/
   * can have any number of local and global options (Boson::OptionCommand). Options are defined with Boson::OptionParser.
   * can have any view associated to it (via Hirb) without adding view code to the command's method.
     These views can be toggled on and manipulated via global render options (Boson::View and Boson::OptionCommand).
-  * can pipe their return value into multiple commands with pipe options. Default pipe options give the ability
-    to search and sort an array of any objects (Boson::Pipe).
+  * can pipe their return value into custom pipe options (Boson::Pipe).
+  * has default pipe options to search and sort an array of any objects (Boson::Pipes).
 * Option parser (Boson::OptionParser)
   * provides option types that map to objects i.e. :array type creates Array objects.
   * come with 5 default option types: boolean, array, string, hash and numeric.

data/Rakefile

@@ -25,14 +25,14 @@ begin
     s.authors = ["Gabriel Horner"]
     s.has_rdoc = true
     s.rubyforge_project = 'tagaholic'
-    s.add_dependency 'hirb', '>= 0.2.8'
+    s.add_dependency 'hirb', '>= 0.2.10'
     s.add_dependency 'alias', '>= 0.2.1'
     s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
     s.files = FileList["Rakefile", "VERSION.yml", "README.rdoc", "LICENSE.txt", "{bin,lib,test}/**/*"]
   end
 
 rescue LoadError
-  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install jeweler"
 end
 
 Rake::TestTask.new do |t|

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
 :minor: 2
-:patch: 2
+:patch: 3
 :build: 
 :major: 0

data/lib/boson.rb

@@ -5,7 +5,7 @@ $:.unshift File.dirname(__FILE__) unless $:.include? File.expand_path(File.dirna
 # order of library subclasses matters
 %w{module file gem require local_file}.each {|e| require "boson/libraries/#{e}_library" }
 (%w{namespace view command util commands option_parser options} +
-  %w{index repo_index scientist option_command pipe}).each {|e| require "boson/#{e}" }
+  %w{index repo_index scientist option_command pipe pipes}).each {|e| require "boson/#{e}" }
 
 # This module stores the libraries, commands, repos and main object used throughout Boson.
 #

data/lib/boson/command.rb

@@ -72,7 +72,7 @@ module Boson
           @args = [['*args']]
         end
       end
-      @config = (hash.delete(:config) || {}).merge(hash)
+      @config = Util.recursive_hash_merge hash, hash.delete(:config) || {}
     end
 
     # Library object a command belongs to.
@@ -96,6 +96,11 @@ module Boson
       @option_parser ||= OptionParser.new(@options || {})
     end
 
+    # Option parser for command as defined by @render_options.
+    def render_option_parser
+      option_command? ? Boson::Scientist.option_command(self).option_parser : nil
+    end
+
     # Help string for options if a command has it.
     def option_help
       @options ? option_parser.to_s : ''
@@ -120,6 +125,11 @@ module Boson
     end
 
     #:stopdoc:
+    # until @config is consistent in index + actual loading
+    def config
+      @config ||= {}
+    end
+
     def file_string_and_method_for_args(lib)
       if !lib.is_a?(ModuleLibrary) && (klass_method = (lib.class_commands || {})[@name])
         if RUBY_VERSION >= '1.9'
@@ -135,7 +145,7 @@ module Boson
     end
 
     def has_splat_args?
-      !!(@args && @args[-1] && @args[-1][0][/^\*/])
+      !!(args && @args[-1] && @args[-1][0][/^\*/])
     end
 
     def make_option_command(lib=library)

data/lib/boson/commands/core.rb

@@ -8,13 +8,16 @@ module Boson::Commands::Core #:nodoc:
     commands = {
       'render'=>{:desc=>"Render any object using Hirb"},
       'menu'=>{:desc=>"Provide a menu to multi-select elements from a given array"},
-      'usage'=>{:desc=>"Print a command's usage", :options=>{[:verbose, :V]=>:boolean}},
+      'usage'=>{:desc=>"Print a command's usage", :options=>{
+        :verbose=>{:desc=>"Display global options", :type=>:boolean},
+        :render_options=>{:desc=>"Render options for option tables", :default=>{},
+          :keys=>[:vertical, :fields, :hide_empty]} } },
       'commands'=>{
         :desc=>"List or search commands. Query must come before any options.", :default_option=>'query',
         :options=>{ :index=>{:type=>:boolean, :desc=>"Searches index"},
           :local=>{:type=>:boolean, :desc=>"Local commands only" } },
         :render_options=>{
-          :headers=>{:default=>{:desc=>'description'}},
+          [:headers,:H]=>{:default=>{:desc=>'description'}},
           :query=>{:keys=>command_attributes, :default_keys=>'full_name'},
           :fields=>{:default=>[:full_name, :lib, :alias, :usage, :desc], :values=>command_attributes, :enum=>false},
           :filters=>{:default=>{:render_options=>:inspect, :options=>:inspect, :args=>:inspect, :config=>:inspect}}
@@ -53,20 +56,22 @@ module Boson::Commands::Core #:nodoc:
     Boson::View.render(object, options)
   end
 
-  def menu(output, options={}, &block)
-    Hirb::Console.format_output(output, options.merge(:class=>"Hirb::Menu"), &block)
+  def menu(arr, options={}, &block)
+    Hirb::Console.format_output(arr, options.merge(:class=>"Hirb::Menu"), &block)
   end
 
   def usage(command, options={})
-    msg = (cmd = Boson::Command.find(command)) ? "#{command} #{cmd.usage}" : "Command '#{cmd}' not found"
+    msg = (cmd = Boson::Command.find(command)) ? "#{command} #{cmd.usage}" : "Command '#{command}' not found"
     puts msg
-    if cmd && options[:verbose]
-      if cmd.options && !cmd.options.empty?
-        puts "\nLOCAL OPTIONS"
-        cmd.option_parser.print_usage_table
-      end
+    return if options[:one_line] || !cmd
+
+    if cmd.options && !cmd.options.empty?
+      puts "\nLOCAL OPTIONS"
+      cmd.option_parser.print_usage_table options[:render_options].dup.merge(:local=>true)
+    end
+    if options[:verbose]
       puts "\nGLOBAL OPTIONS"
-      Boson::Scientist.option_command(cmd).option_parser.print_usage_table
+      cmd.render_option_parser.print_usage_table options[:render_options].dup
     end
   end
 end

data/lib/boson/commands/web_core.rb

@@ -1,52 +1,59 @@
-module Boson::Commands::WebCore #:nodoc:
+module Boson::Commands::WebCore
   extend self
 
-  def config
+  def config #:nodoc:
     descriptions = {
       :install=>"Installs a library by url. Library should then be loaded with load_library.",
-      :browser=>"Opens urls in a browser on a Mac", :get=>"Gets the body of a url", :post=>'Posts to url' }
+      :browser=>"Opens urls in a browser on a Mac", :get=>"Gets the body of a url", :post=>'Posts to url',
+      :build_url=>"Builds a url, escaping the given params"
+    }
     commands = descriptions.inject({}) {|h,(k,v)| h[k.to_s] = {:desc=>v}; h}
     commands['install'][:options] = {:name=>{:type=>:string, :desc=>"Library name to save to"},
       :force=>{:type=>:boolean, :desc=>'Overwrites an existing library'},
+      :default=>{:type=>:boolean, :desc=>'Adds library as a default library to main config file'},
       :module_wrap=>{:type=>:boolean, :desc=>"Wraps a module around install using library name"},
       :method_wrap=>{:type=>:boolean, :desc=>"Wraps a method and module around installed library using library name"}}
+    commands['install'][:args] = [['url'],['options', {}]]
     {:library_file=>File.expand_path(__FILE__), :commands=>commands, :namespace=>false}
   end
 
-  def get(url, options={})
-    %w{uri net/http}.each {|e| require e }
-    if options[:success_only]
-      url = URI.parse(url)
-      res = Net::HTTP.start(url.host, url.port) {|http| http.get(url.request_uri) }
-      res.code == '200' ? res.body : nil
-    else
-      Net::HTTP.get(URI.parse(url))
+  # Requires libraries only once before defining method with given block
+  def self.def_which_requires(meth, *libs, &block)
+    define_method(meth) do |*args|
+      libs.each {|e| require e }
+      define_method(meth, block).call(*args)
     end
-  rescue
-    raise "Error opening #{url}"
   end
 
-  def post(url, options={})
-    %w{uri net/http}.each {|e| require e }
+  def_which_requires(:get, 'uri', 'net/http') do |url, options|
+    options ||= {}
+    url = build_url(url, options[:params]) if options[:params]
+    Get.new(url).request(options)
+  end
+
+  def_which_requires(:build_url, 'cgi') do |url, params|
+    url + (url[/\?/] ? '&' : "?") + params.map {|k,v|
+      v = v.is_a?(Array) ? v.join(' ') : v.to_s
+      "#{k}=#{CGI.escape(v)}"
+    }.join("&")
+  end
+
+  def_which_requires(:post, 'uri', 'net/http') do |url, options|
     Net::HTTP.post_form(URI.parse(url), options)
   end
 
-  def install(url, options={})
+  def install(url, options={}) #:nodoc:
     options[:name] ||= strip_name_from_url(url)
     return puts("Please give a library name for this url.") if options[:name].empty?
-    filename = File.join Boson.repo.commands_dir, "#{options[:name]}.rb"
+    filename = File.join ::Boson.repo.commands_dir, "#{options[:name]}.rb"
     return puts("Library name #{options[:name]} already exists. Try a different name.") if File.exists?(filename) && !options[:force]
-    File.open(filename, 'w') {|f| f.write get(url) }
 
-    if options[:method_wrap] || options[:module_wrap]
-      file_string = File.read(filename)
-      file_string = "def #{options[:name]}\n#{file_string}\nend" if options[:method_wrap]
-      unless (mod_name = Boson::Util.camelize(options[:name]))
-        return puts("Can't wrap install with name #{options[:name]}")
-      end
-      file_string = "module #{mod_name}\n#{file_string}\nend"
-      File.open(filename, 'w') {|f| f.write file_string }
-    end
+    file_string = get(url)
+    file_string = "# Originally from #{url}\n"+file_string
+    file_string = wrap_install(file_string, options) if options[:method_wrap] || options[:module_wrap]
+
+    File.open(filename, 'w') {|f| f.write file_string }
+    Boson.repo.update_config {|c| (c[:defaults] ||= []) << options[:name] } if options[:default]
     puts "Saved to #{filename}."
   end
 
@@ -56,7 +63,80 @@ module Boson::Commands::WebCore #:nodoc:
   end
 
   private
+  def wrap_install(file_string, options)
+    indent = "  "
+    unless (mod_name = ::Boson::Util.camelize(options[:name]))
+      return puts("Can't wrap install with name #{options[:name]}")
+    end
+
+    file_string.gsub!(/(^)/,'\1'+indent)
+    file_string = "def #{options[:name]}\n#{file_string}\nend".gsub(/(^)/,'\1'+indent) if options[:method_wrap]
+    "module #{mod_name}\n#{file_string}\nend"
+  end
+
   def strip_name_from_url(url)
     url[/\/([^\/.]+)(\.[a-z]+)?$/, 1].to_s.gsub('-', '_').gsub(/[^a-zA-Z_]/, '')
   end
+
+  # Used by the get command to make get requests and optionally parse json and yaml.
+  # Ruby 1.8.x is dependent on json gem for parsing json.
+  # See Get.request for options a request can take.
+  class Get
+    FORMAT_HEADERS = {
+      :json=>%w{application/json text/json application/javascript text/javascript},
+      :yaml=>%w{application/x-yaml text/yaml}
+    } #:nodoc:
+
+    def initialize(url, options={})
+      @url, @options = url, options
+    end
+
+    # Returns the response body string or a parsed data structure. Returns nil if request fails. By default expects response
+    # to be 200.
+    # ==== Options:
+    # [:any_response] Returns body string for any response code. Default is false.
+    # [:parse] Parse the body into either json or yaml. Expects a valid format or if true autodetects one.
+    #          Default is false.
+    # [:raise_error] Raises any original errors when parsing or fetching url instead of handling errors silently.
+    def request(options={})
+      @options.merge! options
+      body = get_body
+      body && @options[:parse] ? parse_body(body) : body
+    end
+
+    private
+    # Returns body string if successful or nil if not.
+    def get_body
+      uri = URI.parse(@url)
+      @response = Net::HTTP.get_response uri
+      (@options[:any_response] || @response.code == '200') ? @response.body : nil
+    rescue
+      @options[:raise_error] ? raise : puts("Error: GET '#{@url}' -> #{$!.class}: #{$!.message}")
+    end
+
+    # Returns nil if dependencies or parsing fails
+    def parse_body(body)
+      format = determine_format(@options[:parse])
+      case format
+      when :json
+        unless ::Boson::Util.safe_require 'json'
+          return puts("Install the json gem to parse json: sudo gem install json")
+        end
+        JSON.parse body
+      when :yaml
+        YAML::load body
+      else
+        puts "Can't parse this format."
+      end
+    rescue
+      @options[:raise_error] ? raise : puts("Error while parsing #{format} response of '#{@url}': #{$!.class}")
+    end
+
+    def determine_format(format)
+      return format.to_sym if %w{json yaml}.include?(format.to_s)
+      return :json if FORMAT_HEADERS[:json].include?(@response.content_type)
+      return :yaml if FORMAT_HEADERS[:yaml].include?(@response.content_type)
+      nil
+    end
+  end
 end

data/lib/boson/inspector.rb

@@ -68,9 +68,8 @@ module Boson
 
     #:stopdoc:
     def add_method_scraped_data
-      (MethodInspector::METHODS + [:method_args]).each do |e|
-        key = command_key(e)
-        (@store[e] || []).each do |cmd, val|
+      (MethodInspector::METHODS + [:args]).each do |key|
+        (@store[key] || []).each do |cmd, val|
           @commands_hash[cmd] ||= {}
           add_scraped_data_to_config(key, val, cmd)
         end
@@ -94,15 +93,10 @@ module Boson
         scraped = CommentInspector.scrape(FileLibrary.read_library_file(file), lineno, MethodInspector.current_module)
         @commands_hash[cmd] ||= {}
         MethodInspector::METHODS.each do |e|
-          add_scraped_data_to_config(command_key(e), scraped[e], cmd)
+          add_scraped_data_to_config(e, scraped[e], cmd)
         end
       end
     end
-
-    # translates from inspector attribute name to command attribute name
-    def command_key(key)
-      {:method_args=>:args}[key] || key
-    end
     #:startdoc:
   end
 end

data/lib/boson/inspectors/method_inspector.rb

@@ -37,13 +37,13 @@ module Boson
 
     # Scrapes a method's arguments using ArgumentInspector.
     def scrape_arguments(meth)
-      store[:method_args] ||= {}
+      store[:args] ||= {}
 
       o = Object.new
       o.extend(@current_module)
       # private methods return nil
       if (val = ArgumentInspector.scrape_with_eval(meth, @current_module, o))
-        store[:method_args][meth.to_s] = val
+        store[:args][meth.to_s] = val
       end
     end
 

data/lib/boson/libraries/file_library.rb

@@ -18,8 +18,8 @@ module Boson
   #   end
   #
   # Once loaded, this library can be run from the commandline or irb:
-  #  bash> boson take_over world
-  #  irb>> take_over 'world'
+  #  $ boson take_over world
+  #  >> take_over 'world'
   #
   # If the library is namespaced, the command would be run as brain.take_over.
   #
@@ -33,8 +33,8 @@ module Boson
   #   end
   #
   # From the commandline and irb this runs as:
-  #   bash> boson take_over world -e initiate_brainiac
-  #   irb>> take_over 'world -e initiate_brainiac'
+  #   $ boson take_over world -e initiate_brainiac
+  #   >> take_over 'world -e initiate_brainiac'
   #
   # Since Boson aims to make your libraries just standard ruby, we can achieve the above
   # by making options a commented method attribute:
@@ -53,11 +53,11 @@ module Boson
   # * See Inspector for other method attributes, like config and render_options, that can be placed above a method.
   #
   # Once a command has a defined option, a command can also recognize a slew of global options:
-  #   irb>> take_over '-h'
+  #   >> take_over '-h'
   #   take_over [destination] [--execute=STRING]
   #
   #   # prints much more verbose help
-  #   irb>> take_over '-hv'
+  #   >> take_over '-hv'
   #
   # For more about these global options see OptionCommand and View.
   class FileLibrary < Library

data/lib/boson/manager.rb

@@ -44,7 +44,7 @@ module Boson
         FileLibrary.reset_file_cache(library.to_s)
         failed_libraries << library
         $stderr.puts "Unable to #{load_method} library #{library}. Reason: #{e.message}"
-      rescue Exception=>e
+      rescue StandardError=>e
         FileLibrary.reset_file_cache(library.to_s)
         failed_libraries << library
         message = "Unable to #{load_method} library #{library}. Reason: #{$!}"

data/lib/boson/option_command.rb

@@ -1,9 +1,10 @@
 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 options, render options, pipe options) and local options.
+  # 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
@@ -61,6 +62,7 @@ module Boson
       :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:
@@ -76,6 +78,7 @@ module Boson
       :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

data/lib/boson/option_parser.rb

@@ -77,6 +77,7 @@ module Boson
     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
 
@@ -148,9 +149,9 @@ module Boson
     #               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. For example, for values foo, odd, optional,
-    #             f refers to foo, o to odd and op to optional.
+    # [*: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
@@ -196,8 +197,7 @@ module Boson
         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)
+        else @defaults[nice_name] = type unless type.is_a?(Symbol)
         end
         mem[name] = !type.nil? ? determine_option_type(type) : type
         mem
@@ -207,7 +207,7 @@ module Boson
       @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 ? dasherize(e.to_s) : e }
+        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
@@ -232,7 +232,7 @@ module Boson
       
       @leading_non_opts = []
       unless flags[:opts_before_args]
-        @leading_non_opts << shift until current_is_option? || @args.empty? || peek == '--'
+        @leading_non_opts << shift until current_is_option? || @args.empty? || STOP_STRINGS.include?(peek)
       end
 
       while current_is_option?
@@ -281,20 +281,41 @@ module Boson
 
     # 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
-      additional = [:desc, :values].select {|e| (@option_attributes || {}).values.any? {|f| f.key?(e) } }
-      additional_opts = {:desc=>[:desc], :values=>[:values, :keys]}
-      opts = @opt_types.keys.sort.inject([]) {|t,e|
-        h = {:name=>e, :aliases=>aliases[e], :type=>@opt_types[e]}
-        additional.each {|f|
-          h[f] = additional_opts[f].map {|g| (@option_attributes[undasherize(e)] || {})[g]}.flatten.compact
+      @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
       }
-      render_options = {:headers=>{:name=>"Option", :aliases=>"Alias", :desc=>'Description', :values=>'Values/Keys', :type=>'Type'},
-        :fields=>[:name, :aliases, :type] + additional, :description=>false, :filters=>{:values=>lambda {|e| (e || []).join(',')} }
-      }.merge(render_options)
-      View.render opts, render_options
+    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
@@ -343,8 +364,7 @@ module Boson
       case value
       when TrueClass, FalseClass   then :boolean
       when Numeric                 then :numeric
-      else
-        Util.underscore(value.class.to_s).to_sym
+      else Util.underscore(value.class.to_s).to_sym
       end
     end
 
@@ -365,7 +385,15 @@ module Boson
     end
 
     def auto_alias_value(values, possible_value)
-      values.find {|v| v.to_s =~ /^#{possible_value}/ } || 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)
@@ -386,7 +414,7 @@ module Boson
 
     def delete_invalid_opts
       @trailing_non_opts.delete_if {|e|
-        break if %w{- --}.include? e
+        break if STOP_STRINGS.include? e
         invalid = e.to_s[/^-/]
         $stderr.puts "Deleted invalid option '#{e}'" if invalid
         invalid