boson 0.2.3 → 0.2.4

data/test/comment_inspector_test.rb

@@ -1,100 +1,98 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Boson
-  class ScraperTest < Test::Unit::TestCase
-    before(:all) { eval "module Optional; def self.bling; {:a=>'bling'}; end; end" }
-    context "description" do
-      before(:each) { 
-        @lines = ["module Foo", "  # some comments yay", "  def foo", "  end", "end"]
-      }
-      def description(options={})
-        CommentInspector.scrape(@lines.join("\n"), options[:line] || 3, Optional)[:desc]
-      end
-
-      test "directly above method returns desc" do
-        description.should == "some comments yay"
-      end
-
-      test "with explicit @desc returns desc" do
-        @lines[1] = '#@desc   some comments yay'
-        description.should == "some comments yay"
-      end
-
-      test "of multiple lines returns desc" do
-        @lines.delete_at(1)
-        @lines.insert(1, '#@options :b=>1', '#@desc here be', '# comments')
-        description(:line=>5).should == "here be comments"
-      end
-
-      test "that is empty returns nil" do
-        @lines[1] = ""
-        description.should == nil
-      end
-
-      test "that is empty with options keyword returns nil" do
-        @lines[1] = '#@options {:a=>1}'
-        description.should == nil
-      end
-
-      test "not directly above returns nil" do
-        @lines.insert(2, "   ")
-        description(:line=>4).should == nil
-      end
+describe "CommentInspector" do
+  before_all { eval "module ::Optional; def self.bling; {:a=>'bling'}; end; end" }
+  describe "scrapes description" do
+    before { 
+      @lines = ["module Foo", "  # some comments yay", "  def foo", "  end", "end"]
+    }
+    def description(options={})
+      CommentInspector.scrape(@lines.join("\n"), options[:line] || 3, Optional)[:desc]
     end
 
-    context "options" do
-      before(:each) {
-        @lines = ["module Foo", '  #@options {:a=>true}', "  def foo", "  end", "end"]
-      }
-      def options(opts={})
-        @lines[1] = opts[:value] if opts[:value]
-        args = [@lines.join("\n"), 3, Optional]
-        CommentInspector.scrape(*args)[:options]
-      end
-
-      test "that are basic return options" do
-        options.should == {:a=>true}
-      end
-
-      test "that are hash-like returns hashified options" do
-        options(:value=>'#@options :a => 2').should == {:a=>2}
-      end
-
-      test "that are whitespaced return options" do
-        options(:value=>"\t"+ '#    @options {:a=>1}').should == {:a=>1}
-      end
-
-      test "that have a local value return options" do
-        options(:value=>'#@options bling').should == {:a=>'bling'}
-      end
-
-      test "that are multi-line return options" do
-        @lines.delete_at(1)
-        @lines.insert(1, '#@options {:a =>', " # 1}", "# some comments")
-        CommentInspector.scrape(@lines.join("\n"), 5, Optional)[:options].should == {:a=>1}
-      end
-
-      test "with failed eval return nil" do
-        options(:value=>'#@options !--').should == nil
-      end
-
-      test "that are empty return nil" do
-        options(:value=>"# nada").should == nil
-      end
+    it "directly above method returns desc" do
+      description.should == "some comments yay"
     end
 
-    test "scrape all comment types with implicit desc" do
-      @lines = ["module Foo", '# @config :a=>true', '# @render_options :b=>1', '  # @options {:a=>true}',
-        '#blah', "  def foo", "  end", "end"]
-      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1}, :config=>{:a=>true}}
-      CommentInspector.scrape(@lines.join("\n"), 6, Optional).should == expected
+    it "with explicit @desc returns desc" do
+      @lines[1] = '#@desc   some comments yay'
+      description.should == "some comments yay"
     end
 
-    test "scrape all comment types with explicit desc" do
-      @lines = ["module Foo",  '#@desc blah', '# @render_options :b=>1,', '# :c=>2',
-        '  # @options {:a=>true}', '  # @config :a=>true', "  def foo", "  end", "end"]
-      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1, :c=>2}, :config=>{:a=>true}}
-      CommentInspector.scrape(@lines.join("\n"), 7, Optional).should == expected
+    it "of multiple lines returns desc" do
+      @lines.delete_at(1)
+      @lines.insert(1, '#@options :b=>1', '#@desc here be', '# comments')
+      description(:line=>5).should == "here be comments"
     end
+
+    it "that is empty returns nil" do
+      @lines[1] = ""
+      description.should == nil
+    end
+
+    it "that is empty with options keyword returns nil" do
+      @lines[1] = '#@options {:a=>1}'
+      description.should == nil
+    end
+
+    it "not directly above returns nil" do
+      @lines.insert(2, "   ")
+      description(:line=>4).should == nil
+    end
+  end
+
+  describe "scrapes options" do
+    before {
+      @lines = ["module Foo", '  #@options {:a=>true}', "  def foo", "  end", "end"]
+    }
+    def options(opts={})
+      @lines[1] = opts[:value] if opts[:value]
+      args = [@lines.join("\n"), 3, Optional]
+      CommentInspector.scrape(*args)[:options]
+    end
+
+    it "that are basic return options" do
+      options.should == {:a=>true}
+    end
+
+    it "that are hash-like returns hashified options" do
+      options(:value=>'#@options :a => 2').should == {:a=>2}
+    end
+
+    it "that are whitespaced return options" do
+      options(:value=>"\t"+ '#    @options {:a=>1}').should == {:a=>1}
+    end
+
+    it "that have a local value return options" do
+      options(:value=>'#@options bling').should == {:a=>'bling'}
+    end
+
+    it "that are multi-line return options" do
+      @lines.delete_at(1)
+      @lines.insert(1, '#@options {:a =>', " # 1}", "# some comments")
+      CommentInspector.scrape(@lines.join("\n"), 5, Optional)[:options].should == {:a=>1}
+    end
+
+    it "with failed eval return nil" do
+      options(:value=>'#@options !--').should == nil
+    end
+
+    it "that are empty return nil" do
+      options(:value=>"# nada").should == nil
+    end
+  end
+
+  it "scrapes all comment types with implicit desc" do
+    @lines = ["module Foo", '# @config :a=>true', '# @render_options :b=>1', '  # @options {:a=>true}',
+      '#blah', "  def foo", "  end", "end"]
+    expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1}, :config=>{:a=>true}}
+    CommentInspector.scrape(@lines.join("\n"), 6, Optional).should == expected
+  end
+
+  it "scrapes all comment types with explicit desc" do
+    @lines = ["module Foo",  '#@desc blah', '# @render_options :b=>1,', '# :c=>2',
+      '  # @options {:a=>true}', '  # @config :a=>true', "  def foo", "  end", "end"]
+    expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1, :c=>2}, :config=>{:a=>true}}
+    CommentInspector.scrape(@lines.join("\n"), 7, Optional).should == expected
   end
 end

data/test/file_library_test.rb

@@ -1,44 +1,42 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Boson
-  class FileLibraryTest < Test::Unit::TestCase
-    context "file library" do
-      before(:each) { reset; FileLibrary.reset_file_cache }
+describe "file library" do
+  before { reset; FileLibrary.reset_file_cache }
+  before { Gem.stubs(:loaded_specs).returns({}) } if RUBY_VERSION >= '1.9.2'
 
-      test "loads" do
-        load :blah, :file_string=>"module Blah; def blah; end; end"
-        library_has_module('blah', 'Boson::Commands::Blah')
-        command_exists?('blah')
-      end
+  it "loads" do
+    load :blah, :file_string=>"module Blah; def blah; end; end"
+    library_has_module('blah', 'Boson::Commands::Blah')
+    command_exists?('blah')
+  end
 
-      test "in a subdirectory loads" do
-        load 'site/delicious', :file_string=>"module Delicious; def blah; end; end"
-        library_has_module('site/delicious', "Boson::Commands::Site::Delicious")
-        command_exists?('blah')
-      end
+  it "in a subdirectory loads" do
+    load 'site/delicious', :file_string=>"module Delicious; def blah; end; end"
+    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
+  it "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
+  it "loads by basename" do
+    Dir.stubs(:[]).returns([RUBY_VERSION < '1.9.2' ? './test/commands/site/github.rb' :
+      File.expand_path('./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
 
-      test "loads a plugin library by creating its module" do
-        load(:blah, :file_string=>"def blah; end")
-        library_has_module('blah', "Boson::Commands::Blah")
-        command_exists?('blah', false)
-      end
+  it "loads a plugin library by creating its module" do
+    load(:blah, :file_string=>"def blah; end")
+    library_has_module('blah', "Boson::Commands::Blah")
+    command_exists?('blah', false)
+  end
 
-      test "prints error for file library with multiple modules" do
-        capture_stderr { load(:blah, :file_string=>"module Doo; end; module Daa; end") }.should =~ /Can't.*config/
-      end
-    end
+  it "prints error for file library with multiple modules" do
+    capture_stderr { load(:blah, :file_string=>"module Doo; end; module Daa; end") }.should =~ /Can't.*config/
   end
 end

data/test/loader_test.rb

@@ -1,236 +1,235 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Boson
-  class LoaderTest < Test::Unit::TestCase
-
-    def load_namespace_library
-      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
+describe "Loader" do
+  def load_namespace_library
+    Manager.load([Boson::Commands::Namespace])
+  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'=>{:desc=>'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').desc.should == 'bling'
-          library('blah').command_object('blang').alias.should == 'ba'
-        end
+  before { Gem.stubs(:loaded_specs).returns({}) } if RUBY_VERSION >= '1.9.2'
+  describe "config" do
+    before { reset }
+    it "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
 
-      test "non-hash from inspector overridden by user's config" do
-        with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:desc=>'already'}}}}) do
-          load :blah, :file_string=>"module Blah; #from file\ndef bling; end; end"
-          library('blah').command_object('bling').desc.should == 'already'
-        end
+    # if this test fails, other exists? using methods fail
+    it "from callback recursively merges with user's config" do
+      with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:desc=>'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').desc.should == 'bling'
+        library('blah').command_object('blang').alias.should == 'ba'
       end
+    end
 
-      test "from inspector attribute config sets command's config" do
-        load :blah, :file_string=>"module Blah; config :alias=>'ok'\n; def bling; end; end"
-        library('blah').command_object('bling').alias.should == 'ok'
+    it "non-hash from inspector overridden by user's config" do
+      with_config(:libraries=>{'blah'=>{:commands=>{'bling'=>{:desc=>'already'}}}}) do
+        load :blah, :file_string=>"module Blah; #from file\ndef bling; end; end"
+        library('blah').command_object('bling').desc.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
+    it "from inspector attribute config sets command's config" do
+      load :blah, :file_string=>"module Blah; config :alias=>'ok'\n; def bling; end; end"
+      library('blah').command_object('bling').alias.should == 'ok'
     end
 
-    context "load" do
-      before(:each) { reset }
-      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/
+    it "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
 
-      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
+  describe "load" do
+    before { reset }
+    it "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 "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
+    it "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 and returns false for existing library" do
-        libs = create_library('blah', :loaded=>true)
-        Manager.stubs(:loader_create).returns(libs[0])
-        capture_stderr { load('blah', :no_mock=>true, :verbose=>true).should == false }.should =~ /already exists/
-      end
+    it "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 "loads and strips aliases from a library's commands" do
-        with_config(:command_aliases=>{"blah"=>'b'}) do
-          load :blah, :file_string=>"module Blah; def blah; end; alias_method(:b, :blah); end"
-          library_loaded?('blah')
-          library('blah').commands.should == ['blah']
-        end
-      end
+    it "prints error and returns false for existing library" do
+      libs = create_library('blah', :loaded=>true)
+      Manager.stubs(:loader_create).returns(libs[0])
+      capture_stderr { load('blah', :no_mock=>true, :verbose=>true).should == false }.should =~ /already exists/
+    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
+    it "loads and strips aliases from a library's commands" do
+      with_config(:command_aliases=>{"blah"=>'b'}) do
+        load :blah, :file_string=>"module Blah; def blah; end; alias_method(:b, :blah); end"
+        library_loaded?('blah')
+        library('blah').commands.should == ['blah']
       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")
-        with_config(:libraries=>{"water"=>{:dependencies=>"oaks"}}) do
-          load 'water', :no_mock=>true
-          library_has_module('water', "Boson::Commands::Water")
-          library_has_module('oaks', "Boson::Commands::Oaks")
-          command_exists?('water')
-          command_exists?('oaks')
-        end
+    it "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 "prints error for library with invalid dependencies" do
-        GemLibrary.stubs(:is_a_gem?).returns(true) #mock all as gem libs
-        Util.stubs(:safe_require).returns(true)
-        with_config(:libraries=>{"water"=>{:dependencies=>"fire"}, "fire"=>{:dependencies=>"man"}}) do
-          capture_stderr { 
-            load('water', :no_mock=>true)
-          }.should == "Unable to load library fire. Reason: Can't load dependency man\nUnable to load"+
-          " library water. Reason: Can't load dependency fire\n"
-        end
+    it "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")
+      with_config(:libraries=>{"water"=>{:dependencies=>"oaks"}}) do
+        load 'water', :no_mock=>true
+        library_has_module('water', "Boson::Commands::Water")
+        library_has_module('oaks', "Boson::Commands::Oaks")
+        command_exists?('water')
+        command_exists?('oaks')
       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
+    it "prints error for library with invalid dependencies" do
+      GemLibrary.stubs(:is_a_gem?).returns(true) #mock all as gem libs
+      Util.stubs(:safe_require).returns(true)
+      with_config(:libraries=>{"water"=>{:dependencies=>"fire"}, "fire"=>{:dependencies=>"man"}}) do
+        capture_stderr { 
+          load('water', :no_mock=>true)
+        }.should == "Unable to load library fire. Reason: Can't load dependency man\nUnable to load"+
+        " library water. Reason: Can't load dependency fire\n"
       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")
-          capture_stderr {
-            load('chwhat', :file_string=>"module Chwhat; def chwhat; end; end")
-          }.should =~ /Unable to load library chwhat.*conflict.*chwhat/
-        end
+    it "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 "namespaces a library that has a method conflict" do
+    it "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")
         capture_stderr {
-          load('chwhat2', :file_string=>"module Chwhat2; def chwhat; end; end")
-        }.should =~ /conflict.*chwhat.*chwhat2/
-        library_has_command('namespace', 'chwhat2')
-        library_has_command('chwhat2', 'chwhat')
+          load('chwhat', :file_string=>"module Chwhat; def chwhat; end; end")
+        }.should =~ /Unable to load library chwhat.*conflict.*chwhat/
       end
+    end
 
-      context "module library" do
-        def mock_library(*args); end
+    it "namespaces a library that has a method conflict" do
+      load('blah', :file_string=>"module Blah; def chwhat; end; end")
+      capture_stderr {
+        load('chwhat2', :file_string=>"module Chwhat2; def chwhat; end; end")
+      }.should =~ /conflict.*chwhat.*chwhat2/
+      library_has_command('namespace', 'chwhat2')
+      library_has_command('chwhat2', 'chwhat')
+    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_command('harvey', 'bird')
-          library_has_command('harvey', 'eagle')
-        end
+    describe "module library" do
+      def mock_library(*args); 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
+      it "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_command('harvey', 'bird')
+        library_has_command('harvey', 'eagle')
+      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
+      it "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
 
-      context "gem library" do
-        def mock_library(lib, options={})
-          options[:file_string] ||= ''
-          File.stubs(:exists?).returns(false)
-          GemLibrary.expects(:is_a_gem?).returns(true)
-          Util.expects(:safe_require).with { eval options.delete(:file_string) || ''; true}.returns(true)
-        end
+      it "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
 
-        test "loads" do
-          with_config(:libraries=>{"dude"=>{:module=>'Dude'}}) do
-            load "dude", :file_string=>"module ::Dude; def blah; end; end"
-            library_has_module('dude', "Dude")
-            command_exists?("blah")
-          end
-        end
+    describe "gem library" do
+      def mock_library(lib, options={})
+        options[:file_string] ||= ''
+        File.stubs(:exists?).returns(false)
+        GemLibrary.expects(:is_a_gem?).returns(true)
+        Util.expects(:safe_require).with { eval options.delete(:file_string) || ''; true}.returns(true)
+      end
 
-        test "with kernel methods loads" do
-          load "dude", :file_string=>"module ::Kernel; def dude; end; end"
-          library_loaded? 'dude'
-          library('dude').module.should == nil
-          command_exists?("dude")
+      it "loads" do
+        with_config(:libraries=>{"dude"=>{:module=>'Dude'}}) do
+          load "dude", :file_string=>"module ::Dude; def blah; end; end"
+          library_has_module('dude', "Dude")
+          command_exists?("blah")
         end
+      end
 
-        test "prints error when nonexistent" do
-          capture_stderr { load('blah') }.should =~ /Unable.*load/
-        end
+      it "with kernel methods loads" do
+        load "dude", :file_string=>"module ::Kernel; def dude; end; end"
+        library_loaded? 'dude'
+        library('dude').module.should == nil
+        command_exists?("dude")
+      end
+
+      it "prints error when nonexistent" do
+        capture_stderr { load('blah') }.should =~ /Unable.*load/
+      end
 
-        test "with invalid module prints error" do
-          with_config(:libraries=>{"coolio"=>{:module=>"Cool"}}) do
-            capture_stderr {
-              load('coolio', :file_string=>"module ::Coolio; def coolio; end; end")
-            }.should =~ /Unable.*coolio.*No module/
-          end
+      it "with invalid module prints error" do
+        with_config(:libraries=>{"coolio"=>{:module=>"Cool"}}) do
+          capture_stderr {
+            load('coolio', :file_string=>"module ::Coolio; def coolio; end; end")
+          }.should =~ /Unable.*coolio.*No module/
         end
       end
     end
+  end
 
-    context "library with namespace" do
-      before(:all) { reset_main_object }
-      before(:each) { reset_boson }
+  describe "library with namespace" do
+    before_all { reset_main_object }
+    before { reset_boson }
 
-      test "loads and defaults to library name" do
-        with_config(:libraries=>{'blang'=>{:namespace=>true}}) do
-          load 'blang', :file_string=>"module Blang; def bling; end; end"
-          library_has_command('blang', 'bling')
-        end
+    it "loads and defaults to library name" do
+      with_config(:libraries=>{'blang'=>{:namespace=>true}}) do
+        load 'blang', :file_string=>"module Blang; def bling; end; end"
+        library_has_command('blang', 'bling')
       end
+    end
 
-      test "loads with config namespace" do
-        with_config(:libraries=>{'blung'=>{:namespace=>'dope'}}) do
-          load 'blung', :file_string=>"module Blung; def bling; end; end"
-          library_has_command('blung', 'bling')
-          library('blung').commands.size.should == 1
-        end
+    it "loads with config namespace" do
+      with_config(:libraries=>{'blung'=>{:namespace=>'dope'}}) do
+        load 'blung', :file_string=>"module Blung; def bling; end; end"
+        library_has_command('blung', 'bling')
+        library('blung').commands.size.should == 1
       end
+    end
 
-      test "prints error if namespace conflicts with existing commands" do
-        eval "module Conflict; def self.bleng; end; end"
-        load Conflict, :no_mock=>true
-        with_config(:libraries=>{'bleng'=>{:namespace=>true}}) do
-          capture_stderr {
-            load 'bleng', :file_string=>"module Bleng; def bling; end; end"
-          }.should =~ /conflict.*bleng/
-        end
+    it "prints error if namespace conflicts with existing commands" do
+      eval "module ::Conflict; def self.bleng; end; end"
+      load Conflict, :no_mock=>true
+      with_config(:libraries=>{'bleng'=>{:namespace=>true}}) do
+        capture_stderr {
+          load 'bleng', :file_string=>"module Bleng; def bling; end; end"
+        }.should =~ /conflict.*bleng/
       end
     end
   end
+  after_all { FileUtils.rm_r File.dirname(__FILE__)+'/commands/', :force=>true }
 end