boson 0.4.0 → 1.0.0

data/test/command_test.rb

@@ -2,21 +2,17 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 
 describe "Command" do
   describe ".find" do
-    before_all {
+    before do
       reset_boson
-      Boson.libraries << Library.new(:name=>'bling', :namespace=>true)
-      @namespace_command = Command.new(:name=>'blah', :lib=>'bling', :namespace=>'bling')
-      @top_level_command = Command.new(:name=>'blah', :lib=>'bling')
-      Boson.commands << @namespace_command
-      Boson.commands << @top_level_command
-    }
+      @top_level_command = create_command(:name=>'blah', :lib=>'bling')
+    end
 
     it 'finds correct command when a subcommand of the same name exists' do
       Command.find('blah').should == @top_level_command
     end
 
-    it 'finds correct command when a top level command of the same name exists' do
-      Command.find('bling.blah').should == @namespace_command
+    it 'finds nothing given nil' do
+      Command.find(nil).should == nil
     end
   end
 end

data/test/deps.rip

@@ -1,5 +1,5 @@
-mocha =0.9.8
+mocha ~>0.10.4
 bacon >=1.1.0
 mocha-on-bacon >=0
 bacon-bits >=0
-rake >=0
+bahia >=0.4.0

data/test/loader_test.rb

@@ -1,235 +1,37 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 describe "Loader" do
-  def load_namespace_library
-    Manager.load([Boson::Commands::Namespace])
-  end
-
-  before { Gem.stubs(:loaded_specs).returns({}) } if RUBY_VERSION >= '1.9.2' && defined? Gem
-  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
-
-    # 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
-
-    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
-
-    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
-
-    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
-
   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
 
-    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"
+    it "prints error for method conflicts with main_object method" do
+      runner = create_runner :require
+      manager_load runner
+      stderr.should =~ /Unable to load library Blarg.*conflict.*commands: require/
     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')
+    it "prints error for method conflicts between libraries" do
+      create_runner :whoops
+      create_runner :whoops, library: :Blorg
+      Manager.load Blarg
+      manager_load Blorg
+      stderr.should =~ /^Unable to load library Blorg.*conflict.*commands: whoops/
     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/
+    it "sets loaded to true after loading a library" do
+      Manager.load create_runner
+      library('blarg').loaded.should == true
     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
-
-    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
-
-    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
-
-    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
-
-    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
-
-    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('chwhat', :file_string=>"module Chwhat; def chwhat; end; end")
-        }.should =~ /Unable to load library chwhat.*conflict.*chwhat/
-      end
-    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
-
-    describe "module library" do
-      def mock_library(*args); 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
-
-      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
-
-      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
-
-    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
-
-      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
-
-      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 =~ /Library blah did not/
-      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/
+        runner = create_runner do
+          def blah; end
+          alias :b :blah
         end
+        Manager.load runner
+        library('blarg').commands.should == ['blah']
       end
     end
   end
-
-  describe "library with namespace" do
-    before_all { reset_main_object }
-    before { reset_boson }
-
-    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
-
-    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
-
-    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

data/test/manager_test.rb

@@ -1,114 +1,104 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
 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
+  def manager
+    Manager.instance
+  end
+
+  before do
+    reset_boson
+    Manager.instance = nil
+  end
 
-    before { reset_boson }
+  describe ".load" do
+    def load_library(hash={})
+      meths = hash.delete(:commands) || []
+      manager_load create_runner(*(meths + [{library: :Blah}])), hash
+    end
 
     it "loads basic library" do
-      load_library :name=>'blah'
+      load_library
       library_loaded? 'blah'
     end
 
-    it "loads library with commands" do
-      load_library :name=>'blah', :commands=>['frylock','meatwad']
+    it "loads basic library with verbose" do
+      capture_stdout {
+          load_library verbose: true
+      }.chomp.should == 'Loaded library blah'
       library_loaded? 'blah'
-      command_exists?('frylock')
-      command_exists?('meatwad')
     end
 
-    it "prints error for library with SyntaxError" do
-      Manager.expects(:loader_create).raises(SyntaxError)
-      capture_stderr {
-        Manager.load 'blah'
-      }.should =~ /Unable to load library blah. Reason: SyntaxError/
+    it "loads library with commands" do
+      load_library :commands=>['frylock','meatwad']
+      library_loaded? 'blah'
+      library_has_command 'blah', 'frylock'
+      library_has_command 'blah', 'meatwad'
     end
 
-    it "prints error for library with LoadError" do
-      Manager.expects(:loader_create).raises(LoadError)
-      capture_stderr {
-        Manager.load 'blah'
-      }.should =~ /Unable to load library blah. Reason: LoadError/
+    it "prints error if library does not load" do
+      RunnerLibrary.any_instance.expects(:load).returns false
+      load_library
+      stderr.should == "Library blah did not load successfully."
     end
 
-    describe "command aliases" do
-      before { eval %[module ::Aquateen; def frylock; end; end] }
-      after { Object.send(:remove_const, "Aquateen") }
-
-      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
+    [SyntaxError, StandardError, LoaderError].each do |klass|
+      it "prints error if library fails with #{klass}" do
+        RunnerLibrary.expects(:new).raises(klass)
+        load_library
+        stderr.should == "Unable to load library Blah. Reason: #{klass}"
+        manager.failed_libraries.should == [Blah]
       end
+    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
+    [SyntaxError, StandardError].each do |klass|
+      it "with verbose prints verbose error if library fails with #{klass}" do
+        RunnerLibrary.expects(:new).raises(klass)
+        load_library verbose: true
+        stderr.should =~ /^Unable to load library Blah. Reason: #{klass}\n\s*\//
+        manager.failed_libraries.should == [Blah]
       end
+    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
+    it "prints error if no library is found" do
+      manager_load 'dude'
+      stderr.should ==
+        'Unable to load library dude. Reason: Library dude not found.'
+    end
+
+    it "prints error for library that's already loaded" do
+      runner = create_runner
+      Manager.load runner
+      manager_load runner, verbose: true
+      stderr.should == "Library blarg already exists."
     end
 
     it "merges with existing created library" do
-      create_library('blah')
-      load_library :name=>'blah'
+      create_library(name: 'blah')
+      load_library
       library_loaded? 'blah'
       Boson.libraries.size.should == 1
     end
   end
 
-  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})
-    }
-
-    it "are deleted" do
-      Scientist.expects(:redefine_command).with(anything, @foo)
-      Manager.redefine_commands(@library, @library.commands)
+  describe ".redefine_commands" do
+    before do
+      @library = create_library(:name=>'blah', :commands=>['foo', 'bar'])
+      @foo = create_command(name: 'foo', lib: 'blah', options: {fool: :string},
+        args: '*')
+      create_command(name: 'bar', lib: 'blah', options: {bah: :string})
     end
 
-    it "are deleted and printed when verbose" do
+    it "only redefines commands with args" do
       Scientist.expects(:redefine_command).with(anything, @foo)
-      @library.instance_eval("@options = {:verbose=>true}")
-      capture_stdout { Manager.redefine_commands(@library, @library.commands) } =~ /options.*blah/
+      manager.redefine_commands(@library, @library.commands)
     end
-  end
-
-  describe ".loaded?" do
-    before { reset_libraries }
 
-    it "returns false when library isn't loaded" do
-      create_library('blah')
-      Manager.loaded?('blah').should == false
-    end
-
-    it "returns true when library is loaded" do
-      create_library('blah', :loaded=>true)
-      Manager.loaded?('blah').should == true
+    it "with verbose only redefines commands with args and prints rejected" do
+      Manager.instance.verbose = true
+      Scientist.expects(:redefine_command).with(anything, @foo)
+      capture_stdout {
+        manager.redefine_commands(@library, @library.commands)
+      }.should =~ /cannot have options.*bar/
     end
   end
-end
+end