boson 0.2.3 → 0.2.4

data/test/manager_test.rb

@@ -1,102 +1,100 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Boson
-  class ManagerTest < Test::Unit::TestCase
-    context "after_load" do
-      def load_library(hash)
-        new_attributes = {:name=>hash.delete(:name), :commands=>[], :created_dependencies=>[], :loaded=>true}
-        [: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
+describe "Manager" do
+  describe "after_load" do
+    def load_library(hash)
+      new_attributes = {:name=>hash[:name], :commands=>[], :created_dependencies=>[], :loaded=>true}
+      [:module, :commands].each {|e| new_attributes[e] = hash.delete(e) if hash[e] }
+      Manager.expects(:rescue_load_action).returns(Library.new(new_attributes))
+      Manager.load([hash[:name]])
+    end
 
-      before(:each) { reset_boson }
+    before { reset_boson }
 
-      test "loads basic library" do
-        load_library :name=>'blah'
-        library_loaded? 'blah'
-      end
+    it "loads basic library" do
+      load_library :name=>'blah'
+      library_loaded? 'blah'
+    end
 
-      test "loads library with commands" do
-        load_library :name=>'blah', :commands=>['frylock','meatwad']
-        library_loaded? 'blah'
-        command_exists?('frylock')
-        command_exists?('meatwad')
-      end
+    it "loads library with commands" do
+      load_library :name=>'blah', :commands=>['frylock','meatwad']
+      library_loaded? 'blah'
+      command_exists?('frylock')
+      command_exists?('meatwad')
+    end
 
-      context "command aliases" do
-        before(:each) { eval %[module ::Aquateen; def frylock; end; end] }
-        after(:each) { Object.send(:remove_const, "Aquateen") }
+    describe "command aliases" do
+      before { eval %[module ::Aquateen; def frylock; end; end] }
+      after { Object.send(:remove_const, "Aquateen") }
 
-        test "created with command specific config" do
-          with_config(:command_aliases=>{'frylock'=>'fr'}) do
-            Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
-            load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
-            library_loaded? 'aquateen'
-          end
+      it "created with command specific config" do
+        with_config(:command_aliases=>{'frylock'=>'fr'}) do
+          Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+          load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+          library_loaded? 'aquateen'
         end
+      end
 
-        test "created with config command_aliases" do
-          with_config(:command_aliases=>{"frylock"=>"fr"}) do
-            Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
-            load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
-            library_loaded? 'aquateen'
-          end
+      it "created with config command_aliases" do
+        with_config(:command_aliases=>{"frylock"=>"fr"}) do
+          Manager.expects(:create_instance_aliases).with({"Aquateen"=>{"frylock"=>"fr"}})
+          load_library :name=>'aquateen', :commands=>['frylock'], :module=>Aquateen
+          library_loaded? 'aquateen'
         end
+      end
 
-        test "not created and warns for commands with no module" do
-          with_config(:command_aliases=>{'frylock'=>'fr'}) do
-            capture_stderr {
-              load_library(:name=>'aquateen', :commands=>['frylock'])
-            }.should =~ /No aliases/
-            library_loaded? 'aquateen'
-            Aquateen.method_defined?(:fr).should == false
-          end
+      it "not created and warns for commands with no module" do
+        with_config(:command_aliases=>{'frylock'=>'fr'}) do
+          capture_stderr {
+            load_library(:name=>'aquateen', :commands=>['frylock'])
+          }.should =~ /No aliases/
+          library_loaded? 'aquateen'
+          Aquateen.method_defined?(:fr).should == false
         end
       end
+    end
 
-      test "merges with existing created library" do
-        create_library('blah')
-        load_library :name=>'blah'
-        library_loaded? 'blah'
-        Boson.libraries.size.should == 1
-      end
+    it "merges with existing created library" do
+      create_library('blah')
+      load_library :name=>'blah'
+      library_loaded? 'blah'
+      Boson.libraries.size.should == 1
     end
+  end
 
-    context "option commands without args" do
-      before(:all) {
-        reset_boson
-        @library = Library.new(:name=>'blah', :commands=>['foo', 'bar'])
-        Boson.libraries << @library
-        @foo = Command.new(:name=>'foo', :lib=>'blah', :options=>{:fool=>:string}, :args=>'*')
-        Boson.commands << @foo
-        Boson.commands << Command.new(:name=>'bar', :lib=>'blah', :options=>{:bah=>:string})
-      }
+  describe "option commands without args" do
+    before_all {
+      reset_boson
+      @library = Library.new(:name=>'blah', :commands=>['foo', 'bar'])
+      Boson.libraries << @library
+      @foo = Command.new(:name=>'foo', :lib=>'blah', :options=>{:fool=>:string}, :args=>'*')
+      Boson.commands << @foo
+      Boson.commands << Command.new(:name=>'bar', :lib=>'blah', :options=>{:bah=>:string})
+    }
 
-      test "are deleted" do
-        Scientist.expects(:redefine_command).with(anything, @foo)
-        Manager.redefine_commands(@library, @library.commands)
-      end
+    it "are deleted" do
+      Scientist.expects(:redefine_command).with(anything, @foo)
+      Manager.redefine_commands(@library, @library.commands)
+    end
 
-      test "are deleted and printed when verbose" do
-        Scientist.expects(:redefine_command).with(anything, @foo)
-        @library.instance_eval("@options = {:verbose=>true}")
-        capture_stdout { Manager.redefine_commands(@library, @library.commands) } =~ /options.*blah/
-      end
+    it "are deleted and printed when verbose" do
+      Scientist.expects(:redefine_command).with(anything, @foo)
+      @library.instance_eval("@options = {:verbose=>true}")
+      capture_stdout { Manager.redefine_commands(@library, @library.commands) } =~ /options.*blah/
     end
+  end
 
-    context "loaded" do
-      before(:each) { reset_libraries }
+  describe "loaded" do
+    before { reset_libraries }
 
-      test "returns false when library isn't loaded" do
-        create_library('blah')
-        Manager.loaded?('blah').should be(false)
-      end
+    it "returns false when library isn't loaded" do
+      create_library('blah')
+      Manager.loaded?('blah').should == false
+    end
 
-      test "returns true when library is loaded" do
-        create_library('blah', :loaded=>true)
-        Manager.loaded?('blah').should be(true)
-      end
+    it "returns true when library is loaded" do
+      create_library('blah', :loaded=>true)
+      Manager.loaded?('blah').should == true
     end
   end
-end
+end

data/test/method_inspector_test.rb

@@ -1,69 +1,67 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Boson
-  class MethodInspectorTest < Test::Unit::TestCase
-    test "non commands module can't set anything" do
-      eval "module Blah; end"
-      MethodInspector.current_module = Blah
+describe "MethodInspector" do
+  it "non commands module can't set anything" do
+    eval "module Blah; end"
+    MethodInspector.current_module = Blah
+    Inspector.enable
+    Blah.module_eval("desc 'test'; def test; end; options :a=>1; def test2; end")
+    Inspector.disable
+    MethodInspector.store[:desc].empty?.should == true
+    MethodInspector.store[:options].empty?.should == true
+  end
+
+  describe "commands module with" do
+    def parse(string)
       Inspector.enable
-      Blah.module_eval("desc 'test'; def test; end; options :a=>1; def test2; end")
+      ::Boson::Commands::Zzz.module_eval(string)
       Inspector.disable
-      MethodInspector.store[:desc].empty?.should == true
-      MethodInspector.store[:options].empty?.should == true
+      MethodInspector.store
     end
 
-    context "commands module with" do
-      def parse(string)
-        Inspector.enable
-        ::Boson::Commands::Zzz.module_eval(string)
-        Inspector.disable
-        MethodInspector.store
-      end
-
-      before(:all) { eval "module ::Boson::Commands::Zzz; end" }
-      before(:each) { MethodInspector.mod_store.delete(::Boson::Commands::Zzz) }
+    before_all { eval "module ::Boson::Commands::Zzz; end" }
+    before { 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"
-        parsed[:desc].should == {"m1"=>"test", "m2"=>"more"}
-      end
+    it "desc sets descriptions" do
+      parsed = parse "desc 'test'; def m1; end; desc 'one'; desc 'more'; def m2; end"
+      parsed[:desc].should == {"m1"=>"test", "m2"=>"more"}
+    end
 
-      test "options sets options" do
-        parse("options :z=>'b'; def zee; end")[:options].should == {"zee"=>{:z=>'b'}}
-      end
+    it "options sets options" do
+      parse("options :z=>'b'; def zee; end")[:options].should == {"zee"=>{:z=>'b'}}
+    end
 
-      test "render_options sets render_options" do
-        parse("render_options :z=>true; def zee; end")[:render_options].should == {"zee"=>{:z=>true}}
-      end
+    it "render_options sets render_options" do
+      parse("render_options :z=>true; def zee; end")[:render_options].should == {"zee"=>{:z=>true}}
+    end
 
-      test "config sets config" do
-        parse("config :z=>true; def zee; end")[:config].should == {"zee"=>{:z=>true}}
-      end
+    it "config sets config" do
+      parse("config :z=>true; def zee; end")[:config].should == {"zee"=>{:z=>true}}
+    end
 
-      test "not all method attributes set causes method_locations to be set" do
-        MethodInspector.stubs(:find_method_locations).returns(["/some/path", 10])
-        parsed = parse "desc 'yo'; def yo; end; options :yep=>1; def yep; end; " +
-          "render_options :a=>1; config :a=>1; desc 'z'; options :a=>1; def az; end"
-        parsed[:method_locations].key?('yo').should == true
-        parsed[:method_locations].key?('yep').should == true
-        parsed[:method_locations].key?('az').should == false
-      end
+    it "not all method attributes set causes method_locations to be set" do
+      MethodInspector.stubs(:find_method_locations).returns(["/some/path", 10])
+      parsed = parse "desc 'yo'; def yo; end; options :yep=>1; def yep; end; " +
+        "render_options :a=>1; config :a=>1; desc 'z'; options :a=>1; def az; end"
+      parsed[:method_locations].key?('yo').should == true
+      parsed[:method_locations].key?('yep').should == true
+      parsed[:method_locations].key?('az').should == false
+    end
 
-      test "no find_method_locations doesn't set method_locations" do
-        MethodInspector.stubs(:find_method_locations).returns(nil)
-        parse("def bluh; end")[:method_locations].key?('bluh').should == false
-      end
+    it "no find_method_locations doesn't set method_locations" do
+      MethodInspector.stubs(:find_method_locations).returns(nil)
+      parse("def bluh; end")[:method_locations].key?('bluh').should == false
+    end
 
-      test "options calls scrape_with_eval" do
-        ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
-        parse("desc 'desc'; options :some=>:opts; def doy(arg1); end")[:args]['doy'].should == [['arg1']]
-      end
+    it "options calls scrape_with_eval" do
+      ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
+      parse("desc 'desc'; options :some=>:opts; def doy(arg1); end")[:args]['doy'].should == [['arg1']]
+    end
 
-      test "options in file calls scrape_with_eval" do
-        MethodInspector.expects(:inspector_in_file?).returns(true)
-        ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
-        parse("desc 'desc'; def doz(arg1); end")[:args]['doz'].should == [['arg1']]
-      end
+    it "options in file calls scrape_with_eval" do
+      MethodInspector.expects(:inspector_in_file?).returns(true)
+      ArgumentInspector.expects(:scrape_with_eval).returns([['arg1']])
+      parse("desc 'desc'; def doz(arg1); end")[:args]['doz'].should == [['arg1']]
     end
   end
-end
+end

data/test/option_parser_test.rb

@@ -1,11 +1,19 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Boson
-  class OptionParserTest < Test::Unit::TestCase
-  include OptionTestHelper
+describe "OptionParser" do
+  def create(opts)
+    @opt = OptionParser.new(opts)
+  end
+
+  def opt; @opt; end
+  
+  def parse(*args)
+    @non_opts = []
+    opt.parse(args.flatten)
+  end
 
-  context "IndifferentAccessHash" do
-    before(:each) {
+  describe "IndifferentAccessHash" do
+    before {
       @hash = IndifferentAccessHash.new 'foo' => 'bar', 'baz' => 'bee'
     }
     it "can access values indifferently" do
@@ -31,7 +39,7 @@ module Boson
     end
   end
 
-  context "naming" do
+  describe "naming" do
     it "automatically aliases long options with their first letter" do
       create "--foo" => true
       parse("-f")["foo"].should == true
@@ -122,7 +130,7 @@ module Boson
     
   end
 
-  context "option values can be set with" do
+  describe "option values can be set with" do
     it "a opt=<value> assignment" do
       create :foo => :string
       parse("--foo=12")["foo"].should == "12"
@@ -153,51 +161,51 @@ module Boson
     end
   end
 
-  context "parse" do
+  describe "parse" do
     it "extracts non-option arguments" do
       create "--foo" => :string, "--bar" => true
       parse("foo", "bar", "--baz", "--foo", "12", "--bar", "-T", "bang").should == {
         :foo => "12", :bar => true
       }
-      @opt.leading_non_opts.should == ["foo", "bar", "--baz"]
-      @opt.trailing_non_opts.should == ["-T", "bang"]
-      @opt.non_opts.should == ["foo", "bar", "--baz", "-T", "bang"]
+      opt.leading_non_opts.should == ["foo", "bar", "--baz"]
+      opt.trailing_non_opts.should == ["-T", "bang"]
+      opt.non_opts.should == ["foo", "bar", "--baz", "-T", "bang"]
     end
 
     it "stopped by --" do
       create :foo=>:boolean, :dude=>:boolean
       parse("foo", "bar", "--", "-f").should == {}
-      @opt.leading_non_opts.should == %w{foo bar}
-      @opt.trailing_non_opts.should == %w{-- -f}
+      opt.leading_non_opts.should == %w{foo bar}
+      opt.trailing_non_opts.should == %w{-- -f}
     end
 
-    context "with parse flag" do
+    describe "with parse flag" do
       it ":delete_invalid_opts deletes and warns of invalid options" do
         create(:foo=>:boolean)
         capture_stderr {
-          @opt.parse(%w{-f -d ok}, :delete_invalid_opts=>true)
+          opt.parse(%w{-f -d ok}, :delete_invalid_opts=>true)
         }.should =~ /Deleted invalid option '-d'/
-        @opt.non_opts.should == ['ok']
+        opt.non_opts.should == ['ok']
       end
 
       it ":delete_invalid_opts deletes until - or --" do
         create(:foo=>:boolean, :bar=>:boolean)
         %w{- --}.each do |stop_char|
           capture_stderr {
-            @opt.parse(%w{ok -b -d} << stop_char << '-f', :delete_invalid_opts=>true)
+            opt.parse(%w{ok -b -d} << stop_char << '-f', :delete_invalid_opts=>true)
           }.should =~ /'-d'/
-          @opt.non_opts.should == %w{ok -d} << stop_char << '-f'
+          opt.non_opts.should == %w{ok -d} << stop_char << '-f'
         end
       end
 
       it ":opts_before_args only allows options before args" do
         create(:foo=>:boolean)
-        @opt.parse(%w{ok -f}, :opts_before_args=>true).should == {}
-        @opt.parse(%w{-f ok}, :opts_before_args=>true).should == {:foo=>true}
+        opt.parse(%w{ok -f}, :opts_before_args=>true).should == {}
+        opt.parse(%w{-f ok}, :opts_before_args=>true).should == {:foo=>true}
       end
     end
 
-    context "with no arguments" do
+    describe "with no arguments" do
       it "and no options returns an empty hash" do
         create({})
         parse.should == {}
@@ -210,7 +218,7 @@ module Boson
     end
   end
 
-  context "option hashes" do
+  describe "option hashes" do
     it "make hash keys available as symbols as well" do
       create "--foo" => :string
       parse("--foo", "12")[:foo].should == "12"
@@ -224,8 +232,8 @@ module Boson
     end
   end
 
-  context ":required option attribute" do
-    before(:all) {
+  describe ":required option attribute" do
+    before_all {
       create "--foo" => {:type=>:string, :required=>true}, :bar => {:type=>:hash, :required=>true}
     }
 
@@ -242,8 +250,8 @@ module Boson
     end
   end
 
-  context ":bool_default option attribute" do
-    before(:all) {
+  describe ":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}
     }
@@ -270,10 +278,10 @@ module Boson
     end
   end
 
-  context "option with attributes" do
+  describe "option with attributes" do
     it "can get type from :type" do
       create :foo=>{:type=>:numeric}
-      parse("-f", '3')[:foo] == 3
+      parse("-f", '3')[:foo].should == 3
     end
 
     it "can get type and default from :default" do
@@ -289,10 +297,10 @@ module Boson
   end
   
   def usage
-    @opt.formatted_usage.split(" ").sort
+    opt.formatted_usage.split(" ").sort
   end
 
-  context "#formatted_usage" do
+  describe "#formatted_usage" do
     it "outputs string args with sample values" do
       create "--repo" => :string, "--branch" => "bugfix", "-n" => 6
       usage.should == %w([--branch=bugfix] [--repo=REPO] [-n=6])
@@ -314,47 +322,46 @@ module Boson
     end
   end
 
-  context "user defined option class" do
-    before(:all) {
+  describe "user defined option class" do
+    before_all {
       ::FooBoo = Struct.new(:name)
-      module ::Boson::Options::FooBoo
+      module 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
+      ::OptionParser.send :include, 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
+    it "created from symbol" do
       (obj = parse('-a', 'whoop')[:a]).class.should == ::FooBoo
       obj.name.should == 'whoop'
     end
 
-    test "created from default" do
+    it "created from default" do
       (obj = parse[:b]).class.should == ::FooBoo
       obj.name.should == 'blah'
     end
 
-    test "created from type attribute" do
+    it "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)
+    it "has its validation called" do
+      opt.expects(:validate_foo_boo)
       parse("-a", 'blah')
     end
 
-    test "has default usage" do
+    it "has default usage" do
       usage[0].should == "[-a=:foo_boo]"
     end
 
-    test "when nonexistant raises error" do
+    it "when nonexistant raises error" do
       assert_error(OptionParser::Error, "invalid.*:blah_blah") { parse("-c", 'ok') }
     end
   end
-end
 end