boson 0.1.0 → 0.2.0

data/lib/boson/util.rb

@@ -24,12 +24,6 @@ module Boson
       any_const_get(camelize(string))
     end
 
-    def symbolize_keys(hash)
-      hash.inject({}) {|options, (key, value)|
-        options[key.to_sym] = value; options
-      }
-    end
-
     # Returns a constant like const_get() no matter what namespace it's nested in.
     # Returns nil if the constant is not found.
     def any_const_get(name)
@@ -80,16 +74,13 @@ module Boson
       all_modules
     end
 
-    # Returns array of _all_ common instance methods between two modules/classes.
-    def common_instance_methods(module1, module2)
-      (module1.instance_methods + module1.private_instance_methods) & (module2.instance_methods + module2.private_instance_methods)
-    end
-
-    # Creates a module under a given base module and possible name. If the module already exists, it attempts
-    # to create one with a number appended to the name.
+    # Creates a module under a given base module and possible name. If the module already exists or conflicts
+    # per top_level_class_conflict, it attempts to create one with a number appended to the name.
     def create_module(base_module, name)
       desired_class = camelize(name)
-      if (suffix = ([""] + (1..10).to_a).find {|e| !base_module.const_defined?(desired_class+e)})
+      possible_suffixes = [''] + %w{1 2 3 4 5 6 7 8 9 10}
+      if (suffix = possible_suffixes.find {|e| !base_module.const_defined?(desired_class+e) &&
+        !top_level_class_conflict(base_module, "#{base_module}::#{desired_class}#{e}") })
         base_module.const_set(desired_class+suffix, Module.new)
       end
     end
@@ -108,5 +99,20 @@ module Boson
     def recursive_hash_merge(hash1, hash2)
       hash1.merge(hash2) {|k,o,n| (o.is_a?(Hash)) ? recursive_hash_merge(o,n) : n}
     end
+
+    # From Rubygems, determine a user's home.
+    def find_home
+      ['HOME', 'USERPROFILE'].each {|e| return ENV[e] if ENV[e] }
+      return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+      File.expand_path("~")
+    rescue
+      File::ALT_SEPARATOR ? "C:/" : "/"
+    end
+
+    # Returns name of top level class that conflicts if it exists. For example, for base module Boson::Commands,
+    # Boson::Commands::Alias conflicts with Alias if Alias exists.
+    def top_level_class_conflict(base_module, conflicting_module)
+      (conflicting_module =~ /^#{base_module}.*::([^:]+)/) && Object.const_defined?($1) && $1
+    end
   end
 end

data/lib/boson/view.rb

@@ -11,33 +11,88 @@ module Boson
 
     # Renders any object via Hirb. Options are passed directly to
     # {Hirb::Console.render_output}[http://tagaholic.me/hirb/doc/classes/Hirb/Console.html#M000011].
-    def render(object, options={})
+    def render(object, options={}, return_obj=false)
       if silent_object?(object)
         puts(object.inspect) unless options[:silence_booleans]
       else
-        render_object(object, options)
+        render_object(object, options, return_obj)
       end
     end
 
+    # Searches and sorts an array of objects or hashes using options :query, :sort and :reverse_sort.
+    # The :query option is a hash of fields mapped to their search terms. Searches are OR-ed.
+    def search_and_sort(object, options)
+      if object.is_a?(Array)
+        object = search_object(object, options[:query]) if options[:query]
+        object = sort_object(object, options[:sort], options[:reverse_sort]) if object.size > 0 && options[:sort]
+      end
+      object
+    end
+
+    #:stopdoc:
+    def toggle_pager
+      Hirb::View.toggle_pager
+    end
+
     def silent_object?(obj)
       [nil,false,true].include?(obj)
     end
 
-    def render_object(object, options={}) #:nodoc:
+    def render_object(object, options={}, return_obj=false)
       options[:class] ||= :auto_table
-      if object.is_a?(Array) && object.size > 0 && (sort = options.delete(:sort))
-        begin
-          sort_lambda = object[0].is_a?(Hash) ? (object[0][sort].respond_to?(:<=>) ?
-            lambda {|e| e[sort] } : lambda {|e| e[sort].to_s }) :
-            (object[0].send(sort).respond_to?(:<=>) ? lambda {|e| e.send(sort)} :
-            lambda {|e| e.send(sort).to_s })
-          object = object.sort_by &sort_lambda
-          object = object.reverse if options[:reverse_sort]
-        rescue NoMethodError, ArgumentError
-          $stderr.puts "Sort failed with nonexistant method '#{sort}'"
+      render_result = Hirb::Console.render_output(object, options)
+      return_obj ? object : render_result
+    end
+
+    def search_object(object, query_hash)
+      if object[0].is_a?(Hash)
+        TableCallbacks.search_callback(object, :query=>query_hash)
+      else
+        query_hash.map {|field,query| object.select {|e| e.send(field).to_s =~ /#{query}/i } }.flatten.uniq
+      end
+    rescue NoMethodError
+      $stderr.puts "Query failed with nonexistant method '#{$!.message[/`(.*)'/,1]}'"
+    end
+
+    def sort_object(object, sort, reverse_sort=false)
+      if object[0].is_a?(Hash)
+        TableCallbacks.sort_callback(object, :sort=>sort, :reverse_sort=>reverse_sort)
+      else
+        sort_lambda = object.all? {|e| e.send(sort).respond_to?(:<=>) } ? lambda {|e| e.send(sort) || ''} :
+          lambda {|e| e.send(sort).to_s }
+        object = object.sort_by &sort_lambda
+        object = object.reverse if reverse_sort
+        object
+      end
+    rescue NoMethodError, ArgumentError
+      $stderr.puts "Sort failed with nonexistant method '#{sort}'"
+    end
+    #:startdoc:
+
+    # Callbacks used by Hirb::Helpers::Table to search and sort arrays of hashes.
+    module TableCallbacks
+      extend self
+      # Case-insensitive searches an array of hashes using the option :query. Numerical string keys
+      # in :query are converted to actual numbers to interface with Hirb. See View.search_and_sort for more
+      # about :query.
+      def search_callback(obj, options)
+        !options[:query] ? obj : begin
+          options[:query].map {|field,query|
+            field = field.to_i if field.to_s[/^\d+$/]
+            obj.select {|e| e[field].to_s =~ /#{query}/i }
+          }.flatten.uniq
         end
       end
-      Hirb::Console.render_output(object, options)
+
+      # Sorts an array of hashes using :sort option and reverses the sort with :reverse_sort option.
+      def sort_callback(obj, options)
+        sort =  options[:sort].to_s[/^\d+$/] ? options[:sort].to_i : options[:sort]
+        sort_lambda = (obj.all? {|e| e[sort].respond_to?(:<=>) } ? lambda {|e| e[sort] } : lambda {|e| e[sort].to_s })
+        obj = obj.sort_by &sort_lambda
+        obj = obj.reverse if options[:reverse_sort]
+        obj
+      end
     end
   end
-end
+end
+Hirb::Helpers::Table.send :include, Boson::View::TableCallbacks

data/test/bin_runner_test.rb

@@ -55,8 +55,8 @@ module Boson
       end
 
       test "global option takes value with whitespace" do
-        View.expects(:render).with(anything, {:sort => :lib, :fields => [:name, :lib]})
-        start('commands', '-g', 'f=name,lib s=lib')
+        View.expects(:render).with(anything, {:vertical=>true, :fields => [:name, :lib]}, anything)
+        start('commands', '-g', 'f=name,lib vertical')
       end
 
       test "execute option errors are caught" do
@@ -69,7 +69,11 @@ module Boson
 
       test "failed subcommand prints error and not command not found" do
         BinRunner.expects(:execute_command).raises("bling")
-        capture_stderr { start("commands.blah") }.should =~ /Error: bling/
+        capture_stderr { start("commands.to_s") }.should =~ /Error: bling/
+      end
+
+      test "nonexistant subcommand prints command not found" do
+        capture_stderr { start("to_s.bling") }.should =~ /'to_s.bling' not found/
       end
 
       test "undiscovered command prints error" do
@@ -102,19 +106,31 @@ module Boson
     end
 
     context "load_command_by_index" do
+      def index(options={})
+        Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0] == options[:load]
+          }.at_least(1).returns(!options[:fails])
+          Index.expects(:write)
+      end
+
       test "with index option, no existing index and core command updates index and prints index message" do
-        Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0] == Runner.all_libraries }.at_least(1)
-        Index.expects(:exists?).returns(false)
-        Index.expects(:write)
+        index :load=>Runner.all_libraries
+        Index.stubs(:exists?).returns(false)
         capture_stdout { start("--index", "libraries") }.should =~ /Generating index/
       end
 
       test "with index option, existing index and core command updates incremental index" do
-        Index.expects(:changed_libraries).returns(['changed'])
-        Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0] == ['changed'] }.at_least(1)
-        Index.expects(:exists?).returns(true)
-        Index.expects(:write)
-        capture_stdout { start("--index", "libraries")}.should =~ /Indexing.*changed/
+        index :load=>['changed']
+        Index.stubs(:exists?).returns(true)
+        capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
+      end
+
+      test "with index option, failed indexing prints error" do
+        index :load=>['changed'], :fails=>true
+        Index.stubs(:exists?).returns(true)
+        Manager.stubs(:failed_libraries).returns(['changed'])
+        capture_stderr {
+          capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
+        }.should =~ /Error:.*failed.*changed/
       end
 
       test "with core command updates index and doesn't print index message" do

data/test/file_library_test.rb

@@ -13,7 +13,20 @@ module Boson
 
       test "in a subdirectory loads" do
         load 'site/delicious', :file_string=>"module Delicious; def blah; end; end"
-        library_has_module('site/delicious', "Boson::Commands::Delicious")
+        library_has_module('site/delicious', "Boson::Commands::Site::Delicious")
+        command_exists?('blah')
+      end
+
+      test "in a sub subdirectory loads" do
+        load 'web/site/delicious', :file_string=>"module Delicious; def blah; end; end"
+        library_has_module('web/site/delicious', "Boson::Commands::Web::Site::Delicious")
+        command_exists?('blah')
+      end
+
+      test "loads by basename" do
+        Dir.stubs(:[]).returns(['./test/commands/site/github.rb'])
+        load 'github', :file_string=>"module Github; def blah; end; end", :exists=>false
+        library_has_module('site/github', "Boson::Commands::Site::Github")
         command_exists?('blah')
       end
 

data/test/index_test.rb

@@ -9,7 +9,8 @@ module Boson
       before(:each) { reset_boson; Index.instance_eval "@libraries = @commands = nil" }
 
       def transfers(options={})
-        Index.instance_variable_set "@libraries", [Library.new(:name=>'blah'), Library.new(:name=>'bling')]
+        Index.instance_variable_set "@libraries", [Library.new(:name=>'blah', :commands=>['blurb']),
+          Library.new(:name=>'bling')]
         Index.instance_variable_set "@commands", [Command.new(:name=>'blurb', :lib=>'blah')]
         Index.read_and_transfer options[:ignored] || []
         Boson.libraries.map {|e| e.name}.should == options[:libraries]

data/test/loader_test.rb

@@ -7,20 +7,62 @@ module Boson
       Manager.load([Boson::Commands::Namespace])
     end
 
+    context "config" do
+      before(:each) { reset }
+      test "from callback overridden by user's config" do
+        with_config(:libraries=>{'blih'=>{:namespace=>false}}) do
+          load :blih, :file_string=>"module Blah; def self.config; {:namespace=>'bling'}; end; end"
+          library('blih').namespace.should == false
+        end
+      end
+
+      # if this test fails, other exists? using methods fail
+      test "from callback recursively merges with user's config" do
+        with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:description=>'bling', :options=>{:num=>3}}}}}) do
+          File.stubs(:exists?).returns(true)
+          load :blah, :file_string=> "module Blah; def self.config; {:commands=>{'blang'=>{:alias=>'ba'}, " +
+            "'bling'=>{:options=>{:verbose=>:boolean}}}}; end; end"
+          library('blah').command_object('bling').options.should == {:verbose=>:boolean, :num=>3}
+          library('blah').command_object('bling').description.should == 'bling'
+          library('blah').command_object('blang').alias.should == 'ba'
+        end
+      end
+
+      test "non-hash from inspector overridden by user's config" do
+        with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:description=>'already'}}}}) do
+          load :blah, :file_string=>"module Blah; #from file\ndef bling; end; end"
+          library('blah').command_object('bling').description.should == 'already'
+        end
+      end
+
+      test "hash from inspector recursively merged with user's config" do
+        with_config(:libraries=>{'blah'=>{:commands=>{'blung'=>{:args=>[], :render_options=>{:sort=>'this'}}}}}) do
+          CommentInspector.expects(:scrape).returns({:render_options=>{:fields=>['this']}})
+          load :blah, :file_string=>"module Blah; def blung; end; end"
+          library('blah').command_object('blung').render_options.should == {:fields=>["this"], :sort=>"this"}
+        end
+      end
+    end
+
     context "load" do
       before(:each) { reset }
-      test "calls included hook" do
+      test "calls included callback" do
         capture_stdout {
           load :blah, :file_string=>"module Blah; def self.included(mod); puts 'included blah'; end; def blah; end; end"
         }.should =~ /included blah/
       end
 
-      test "calls methods in config init_methods" do
-        with_config(:libraries=>{"blah"=>{:init_methods=>['blah']}}) do
-          capture_stdout {
-            load :blah, :file_string=>"module Blah; def blah; puts 'yo'; end; end"
-          }.should == "yo\n"
-        end
+      test "calls after_included callback" do
+        capture_stdout {
+          load :blah, :file_string=>"module Blah; def self.after_included; puts 'yo'; end; end"
+        }.should == "yo\n"
+      end
+
+      test "prints error if library module conflicts with top level constant/module" do
+        capture_stderr {
+          load :blah, :file_string=>"module Object; def self.blah; end; end"
+        }.should =~ /conflict.*'Object'/
+        library_loaded?('blah')
       end
 
       test "prints error and returns false for existing library" do
@@ -37,6 +79,14 @@ module Boson
         end
       end
 
+      test "loads a library and creates its class commands" do
+        with_config(:libraries=>{"blah"=>{:class_commands=>{"bling"=>"Blah.bling", "Blah"=>['hmm']}}}) do
+          load :blah, :file_string=>"module Blah; def self.bling; end; def self.hmm; end; end"
+          command_exists? 'bling'
+          command_exists? 'hmm'
+        end
+      end
+
       test "loads a library with dependencies" do
         File.stubs(:exists?).returns(true)
         File.stubs(:read).returns("module Water; def water; end; end", "module Oaks; def oaks; end; end")
@@ -60,6 +110,14 @@ module Boson
         end
       end
 
+      test "prints error for method conflicts with main_object method" do
+        with_config(:error_method_conflicts=>true) do
+          capture_stderr {
+            load('blah', :file_string=>"module Blah; def require; end; end")
+          }.should =~ /Unable to load library blah.*conflict.*require/
+        end
+      end
+
       test "prints error for method conflicts with config error_method_conflicts" do
         with_config(:error_method_conflicts=>true) do
           load('blah', :file_string=>"module Blah; def chwhat; end; end")
@@ -81,11 +139,25 @@ module Boson
       context "module library" do
         def mock_library(*args); end
 
-        test "loads a module library" do
-          eval %[module ::Harvey; def bird; end; end]
+        test "loads a module library and all its class methods by default" do
+          eval %[module ::Harvey; def self.bird; end; def self.eagle; end; end]
           load ::Harvey, :no_mock=>true
-          library_has_module('harvey', "Harvey")
-          command_exists?('bird')
+          library_has_command('harvey', 'bird')
+          library_has_command('harvey', 'eagle')
+        end
+
+        test "loads a module library with specified commands" do
+          eval %[module ::Peanut; def self.bird; end; def self.eagle; end; end]
+          load ::Peanut, :no_mock=>true, :commands=>%w{bird}
+          library('peanut').commands.size.should == 1
+          library_has_command('peanut', 'bird')
+        end
+
+        test "loads a module library as a class" do
+          eval %[class ::Mentok; def self.bird; end; def self.eagle; end; end]
+          load ::Mentok, :no_mock=>true, :commands=>%w{bird}
+          library('mentok').commands.size.should == 1
+          library_has_command('mentok', 'bird')
         end
       end
 
@@ -145,17 +217,8 @@ module Boson
         end
       end
 
-      test "loads with config except" do
-        with_config(:libraries=>{'blong'=>{:namespace=>true, :except=>['wrong']}}) do
-          load 'blong', :file_string=>"module Blong; def bling; end; def wrong; end; end"
-          library_has_command('blong', 'bling')
-          library_has_command('blong', 'wrong', false)
-          library('blong').commands.size.should == 1
-        end
-      end
-
       test "prints error if namespace conflicts with existing commands" do
-        eval "module Conflict; def bleng; end; end"
+        eval "module Conflict; def self.bleng; end; end"
         load Conflict, :no_mock=>true
         with_config(:libraries=>{'bleng'=>{:namespace=>true}}) do
           capture_stderr {

data/test/manager_test.rb

@@ -5,7 +5,7 @@ module Boson
     context "after_load" do
       def load_library(hash)
         new_attributes = {:name=>hash.delete(:name), :commands=>[], :created_dependencies=>[], :loaded=>true}
-        [:module, :except, :commands].each {|e| new_attributes[e] = hash.delete(e) if hash[e] }
+        [:module, :commands].each {|e| new_attributes[e] = hash.delete(e) if hash[e] }
         Manager.expects(:load_once).returns(Library.new(new_attributes))
         Manager.load([hash[:name]])
       end
@@ -24,14 +24,6 @@ module Boson
         command_exists?('meatwad')
       end
 
-      test "loads library with commands and except option" do
-        Boson.main_object.instance_eval("class<<self;self;end").expects(:undef_method).with('frylock')
-        load_library :name=>'blah', :commands=>['frylock','meatwad'], :except=>['frylock']
-        library_loaded? 'blah'
-        command_exists?('frylock', false)
-        command_exists?('meatwad')
-      end
-
       context "command aliases" do
         before(:each) { eval %[module ::Aquateen; def frylock; end; end] }
         after(:each) { Object.send(:remove_const, "Aquateen") }

data/test/method_inspector_test.rb

@@ -1,7 +1,7 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 module Boson
-  class InspectorTest < Test::Unit::TestCase
+  class MethodInspectorTest < Test::Unit::TestCase
     test "non commands module can't set anything" do
       eval "module Blah; end"
       MethodInspector.current_module = Blah
@@ -21,7 +21,7 @@ module Boson
       end
 
       before(:all) { eval "module ::Boson::Commands::Zzz; end" }
-      before(:each) { MethodInspector.mod_store[::Boson::Commands::Zzz] = {} }
+      before(:each) { MethodInspector.mod_store.delete(::Boson::Commands::Zzz) }
 
       test "desc sets descriptions" do
         parsed = parse "desc 'test'; def m1; end; desc 'one'; desc 'more'; def m2; end"

data/test/option_parser_test.rb

@@ -90,7 +90,7 @@ module Boson
     end
     
     it "allows humanized opt name" do
-      create 'foo' => :string, :bar => :required
+      create 'foo' => :string, :bar => :string
       parse("-f", "1", "-b", "2").should == {:foo => "1", :bar => "2"}
     end
 
@@ -113,6 +113,7 @@ module Boson
     it "accepts --[no-]opt variant for booleans, setting false for value" do
       create "--foo" => :boolean
       parse("--no-foo")["foo"].should == false
+      parse("--no-f")["foo"].should == false
       parse("--foo")["foo"].should == true
     end
     
@@ -125,7 +126,7 @@ module Boson
 
   context "option values can be set with" do
     it "a opt=<value> assignment" do
-      create "--foo" => :required
+      create :foo => :string
       parse("--foo=12")["foo"].should == "12"
       parse("-f=12")["foo"].should == "12"
       parse("--foo=bar=baz")["foo"].should == "bar=baz"
@@ -133,8 +134,8 @@ module Boson
     end
   
     it "a -nXY assignment" do
-      create "--num" => :required
-      parse("-n12")["num"].should == "12"
+      create "--num" => :numeric
+      parse("-n12")["num"].should == 12
     end
   
     it "conjoined short options" do
@@ -146,17 +147,17 @@ module Boson
     end
   
     it "conjoined short options with argument" do
-      create "--foo" => true, "--bar" => true, "--app" => :required
+      create "--foo" => true, "--bar" => true, "--app" => :numeric
       opts = parse "-fba", "12"
       opts["foo"].should == true
       opts["bar"].should == true
-      opts["app"].should == "12"
+      opts["app"].should == 12
     end
   end
 
   context "parse" do
     it "extracts non-option arguments" do
-      create "--foo" => :required, "--bar" => true
+      create "--foo" => :string, "--bar" => true
       parse("foo", "bar", "--baz", "--foo", "12", "--bar", "-T", "bang").should == {
         :foo => "12", :bar => true
       }
@@ -208,14 +209,55 @@ module Boson
     end
   end
 
-  it ":required type raises an error if it isn't given" do
-    create "--foo" => :required, "--bar" => :string
-    assert_error(OptionParser::Error, 'no value.*required.*foo') { parse("--bar", "str") }
+  context ":required option attribute" do
+    before(:all) {
+      create "--foo" => {:type=>:string, :required=>true}, :bar => {:type=>:hash, :required=>true}
+    }
+
+    it "raises an error if string option isn't given" do
+      assert_error(OptionParser::Error, 'no value.*required.*foo') { parse("--bar", "str:ok") }
+    end
+
+    it "raises an error if non-string option isn't given" do
+      assert_error(OptionParser::Error, 'no value.*required.*bar') { parse("--foo", "yup") }
+    end
+
+    it "raises no error when given arguments" do
+      parse("--foo", "yup", "--bar","ok:dude").should == {:foo=>'yup', :bar=>{'ok'=>'dude'}}
+    end
   end
-  
+
+  context ":bool_default option attribute" do
+    before(:all) {
+      create :foo=>{:type=>:string, :bool_default=>'whoop'}, :bar=>{:type=>:array, :bool_default=>'1'},
+        :verbose=>:boolean, :yep=>{:type=>:string, :bool_default=>true}
+    }
+
+    it "sets default boolean" do
+      parse('--foo', '--bar', '1')[:foo].should == 'whoop'
+      parse('--foo', 'ok', 'dokay')[:foo].should == 'whoop'
+    end
+
+    it "sets options normally" do
+      parse('--foo=boo', '--bar=har').should == {:foo=>'boo', :bar=>['har']}
+    end
+
+    it "sets default boolean for array" do
+      parse("--bar", '--foo', '2')[:bar].should == ['1']
+    end
+
+    it "sets default boolean for non-string value" do
+      parse('--yep', '--foo=2')[:yep].should == true
+    end
+
+    it "default booleans can be joined with boolean options" do
+      parse('-fbv').should == {:verbose=>true, :bar=>['1'], :foo=>'whoop'}
+    end
+  end
+
   context ":string type" do
     before :each do
-      create "--foo" => :string, "--bar" => :string
+      create "--foo" => :string, "--bar" => :string, :blah=>{:type=>:string, :default=>:huh}
     end
 
     it "doesn't set nonexistant options" do
@@ -238,6 +280,10 @@ module Boson
     it "overwrites earlier values with later values" do
       parse("--foo", "12", "--foo", "13")[:foo].should == "13"
     end
+
+    it "can have symbolic default value" do
+      parse('--blah','ok')[:blah].should == 'ok'
+    end
   end
   
   context ":string type with :values attribute" do
@@ -298,8 +344,8 @@ module Boson
 
   context ":array type" do
     before(:all) {
-      create :a=>:array, :b=>[1,2,3], :c=>{:type=>:array, :values=>%w{foo fa bar zebra}},
-        :d=>{:type=>:array, :split=>" "}
+      create :a=>:array, :b=>[1,2,3], :c=>{:type=>:array, :values=>%w{foo fa bar zebra}, :enum=>false},
+        :d=>{:type=>:array, :split=>" ", :values=>[:ab, :bc, :cd], :enum=>false}
     }
 
     it "supports array defaults" do
@@ -318,9 +364,71 @@ module Boson
       parse("-c","f,b")[:c].should == %w{fa bar}
     end
 
-    it "allows a configurable splitter" do
+    it "auto aliases symbolic :values" do
+      parse("-d","a c")[:d].should == [:ab,:cd]
+    end
+
+    it "supports a configurable splitter" do
       parse("-d", "yogi berra")[:d].should == %w{yogi berra}
     end
+
+    it "aliases * to all values" do
+      parse("-c", '*')[:c].sort.should == %w{bar fa foo zebra}
+      parse("-c", '*,ok')[:c].sort.should == %w{bar fa foo ok zebra}
+    end
+  end
+
+  context ":hash type" do
+    before(:all) {
+      create :a=>:hash, :b=>{:default=>{:a=>'b'}}, :c=>{:type=>:hash, :keys=>%w{one two three}},
+        :e=>{:type=>:hash, :keys=>[:one, :two, :three], :default_keys=>:three},
+        :d=>{:type=>:hash, :split=>" "}
+    }
+
+    it "converts comma delimited pairs to hash" do
+      parse("-a", "f:3,g:4")[:a].should == {'f'=>'3', 'g'=>'4'}
+    end
+
+    it "supports hash defaults" do
+      parse[:b].should == {:a=>'b'}
+    end
+
+    it "raises error when option has no value" do
+      assert_error(OptionParser::Error, "no value.*'a'") { parse("-a") }
+    end
+
+    it "raises error if invalid key-value pair given for unknown keys" do
+      assert_error(OptionParser::Error, "invalid.*pair.*'a'") { parse("-a", 'b') }
+    end
+
+    it "auto aliases :keys attribute" do
+      parse("-c","t:3,o:1")[:c].should == {'three'=>'3', 'one'=>'1'}
+    end
+
+    it "adds in explicit default keys with value only argument" do
+      parse('-e', 'whoop')[:e].should == {:three=>'whoop'}
+    end
+
+    it "adds in default keys from known :keys with value only argument" do
+      parse("-c","okay")[:c].should == {'one'=>'okay'}
+    end
+
+    it "auto aliases symbolic :keys" do
+      parse("-e","t:3,o:1")[:e].should == {:three=>'3', :one=>'1'}
+    end
+
+    it "supports a configurable splitter" do
+      parse("-d","a:ab b:bc")[:d].should == {'a'=>'ab', 'b'=>'bc'}
+    end
+
+    it "supports grouping keys" do
+      parse("-c", "t,tw:foo,o:bar")[:c].should == {'three'=>'foo','two'=>'foo', 'one'=>'bar'}
+    end
+
+    it "aliases * to all keys" do
+      parse("-c", "*:foo")[:c].should == {'three'=>'foo', 'two'=>'foo', 'one'=>'foo'}
+      parse('-a', '*:foo')[:a].should == {'*'=>'foo'}
+    end
   end
 
   context "option with attributes" do
@@ -341,11 +449,11 @@ module Boson
     end
   end
   
+  def usage
+    @opt.formatted_usage.split(" ").sort
+  end
+
   context "#formatted_usage" do
-    def usage
-      @opt.formatted_usage.split(" ").sort
-    end
-    
     it "outputs string args with sample values" do
       create "--repo" => :string, "--branch" => "bugfix", "-n" => 6
       usage.should == %w([--branch=bugfix] [--repo=REPO] [-n=6])
@@ -360,6 +468,54 @@ module Boson
       create "--libs" => :array
       usage.should == ["[--libs=A,B,C]"]
     end
+
+    it "outputs hash args with sample value" do
+      create '--paths' => :hash
+      usage.should == ["[--paths=A:B,C:D]"]
+    end
+  end
+
+  context "user defined option class" do
+    before(:all) {
+      ::FooBoo = Struct.new(:name)
+      module ::Boson::Options::FooBoo
+        def create_foo_boo(value)
+          ::FooBoo.new(value)
+        end
+        def validate_foo_boo(value); end
+      end
+      ::Boson::OptionParser.send :include, ::Boson::Options::FooBoo
+      create :a=>:foo_boo, :b=>::FooBoo.new('blah'), :c=>:blah_blah,
+        :d=>{:type=>:foo_boo, :type=>::FooBoo.new('bling')}
+    }
+
+    test "created from symbol" do
+      (obj = parse('-a', 'whoop')[:a]).class.should == ::FooBoo
+      obj.name.should == 'whoop'
+    end
+
+    test "created from default" do
+      (obj = parse[:b]).class.should == ::FooBoo
+      obj.name.should == 'blah'
+    end
+
+    test "created from type attribute" do
+      (obj = parse('-d', 'whoop')[:d]).class.should == ::FooBoo
+      obj.name.should == 'whoop'
+    end
+
+    test "has its validation called" do
+      @opt.expects(:validate_foo_boo)
+      parse("-a", 'blah')
+    end
+
+    test "has default usage" do
+      usage[0].should == "[-a=:foo_boo]"
+    end
+
+    test "when nonexistant raises error" do
+      assert_error(OptionParser::Error, "invalid.*:blah_blah") { parse("-c", 'ok') }
+    end
   end
 end
-end
+end