boson 0.2.3 → 0.2.4

data/lib/boson/scientist.rb

@@ -34,9 +34,10 @@ module Boson
     # Handles all Scientist errors.
     class Error < StandardError; end
 
-    attr_accessor :global_options, :rendered
+    attr_accessor :global_options, :rendered, :render
     @no_option_commands ||= []
     @option_commands ||= {}
+    @object_methods = {}
 
     # Redefines an object's method with a Command of the same name.
     def redefine_command(obj, command)
@@ -45,6 +46,8 @@ module Boson
       [command.name, command.alias].compact.each {|e|
         obj.instance_eval("class<<self;self;end").send(:define_method, e, cmd_block)
       }
+    rescue Error
+      $stderr.puts "Error: #{$!.message}"
     end
 
     # A wrapper around redefine_command that doesn't depend on a Command object. Rather you
@@ -72,12 +75,23 @@ module Boson
 
     # The actual method which redefines a command's original method
     def redefine_command_block(obj, command)
+      object_methods(obj)[command.name] ||= begin
+        obj.method(command.name)
+      rescue NameError
+        raise Error, "No method exists to redefine command '#{command.name}'."
+      end
       lambda {|*args|
-        Boson::Scientist.translate_and_render(obj, command, args) {|args| super(*args) }
+        Scientist.translate_and_render(obj, command, args) {|args|
+          Scientist.object_methods(obj)[command.name].call(*args)
+        }
       }
     end
 
     #:stopdoc:
+    def object_methods(obj)
+      @object_methods[obj] ||= {}
+    end
+
     def option_command(cmd=@command)
       @option_commands[cmd] ||= OptionCommand.new(cmd)
     end
@@ -144,7 +158,7 @@ module Boson
     end
 
     def render_or_raw(result)
-      if (@rendered = render?)
+      if (@rendered = can_render?)
         if @global_options.key?(:class) || @global_options.key?(:method)
           result = Pipe.scientist_process(result, @global_options, :config=>@command.config, :args=>@args, :options=>@current_options)
         end
@@ -156,7 +170,11 @@ module Boson
       raise Error, $!.message, $!.backtrace
     end
 
-    def render?
+    def can_render?
+      render.nil? ? command_renders? : render
+    end
+
+    def command_renders?
       (!!@command.render_options ^ @global_options[:render]) && !Pipe.any_no_render_pipes?(@global_options)
     end
     #:startdoc:

data/lib/boson/util.rb

@@ -35,7 +35,7 @@ module Boson
     # Valid options and possible returned keys are :methods, :object_methods, :modules, :gems.
     def detect(options={}, &block)
       options = {:methods=>true, :object_methods=>true}.merge!(options)
-      original_gems = Gem.loaded_specs.keys if Object.const_defined? :Gem
+      original_gems = Object.const_defined?(:Gem) ? Gem.loaded_specs.keys : []
       original_object_methods = Object.instance_methods
       original_instance_methods = class << Boson.main_object; instance_methods end
       original_modules = modules if options[:modules]
@@ -103,6 +103,14 @@ module Boson
       (conflicting_module =~ /^#{base_module}.*::([^:]+)/) && Object.const_defined?($1) && $1
     end
 
+    # Splits array into array of arrays with given element
+    def split_array_by(arr, divider)
+      arr.inject([[]]) {|results, element|
+        (divider == element) ? (results << []) : (results.last << element)
+        results
+      }
+    end
+
     # Regular expression search of a list with underscore anchoring of words.
     # For example 'some_dang_long_word' can be specified as 's_d_l_w'.
     def underscore_search(input, list, first_match=false)

data/lib/boson/version.rb

@@ -0,0 +1,3 @@
+module Boson
+  VERSION = '0.2.4'
+end

data/test/argument_inspector_test.rb

@@ -1,66 +1,62 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module Boson
-  class ArgumentInspectorTest < Test::Unit::TestCase
-    context "scrape_with_text" do
-      def args_from(file_string)
-        ArgumentInspector.scrape_with_text(file_string, "blah")
-      end
-
-      test "parses arguments of class method" do
-        args_from("    def YAML.blah( filepath )\n").should == [['filepath']]
-      end
+describe "scrape_with_text" do
+  def args_from(file_string)
+    ArgumentInspector.scrape_with_text(file_string, "blah")
+  end
 
-      test "parses arguments with no spacing" do
-        args_from("def bong; end\ndef blah(arg1,arg2='val2')\nend").should == [["arg1"], ['arg2', "'val2'"]]
-      end
+  it "parses arguments of class method" do
+    args_from("    def YAML.blah( filepath )\n").should == [['filepath']]
+  end
 
-      test "parses arguments with spacing" do
-        args_from("\t def blah(  arg1=val1, arg2 = val2)").should == [["arg1","val1"], ["arg2", "val2"]]
-      end
+  it "parses arguments with no spacing" do
+    args_from("def bong; end\ndef blah(arg1,arg2='val2')\nend").should == [["arg1"], ['arg2', "'val2'"]]
+  end
 
-      test "parses arguments without parenthesis" do
-        args_from(" def blah arg1, arg2, arg3={}").should == [['arg1'], ['arg2'], ['arg3','{}']]
-      end
-    end
+  it "parses arguments with spacing" do
+    args_from("\t def blah(  arg1=val1, arg2 = val2)").should == [["arg1","val1"], ["arg2", "val2"]]
+  end
 
-    context "scrape_with_eval" do
-      def args_from(string)
-        # methods need options to have their args parsed with ArgumentInspector
-        string.gsub!(/(def blah)/, 'options :a=>1; \1')
-        Inspector.enable
-        ::Boson::Commands::Aaa.module_eval(string)
-        Inspector.disable
-        MethodInspector.store[:args]['blah']
-      end
+  it "parses arguments without parenthesis" do
+    args_from(" def blah arg1, arg2, arg3={}").should == [['arg1'], ['arg2'], ['arg3','{}']]
+  end
+end
+
+describe "scrape_with_eval" do
+  def args_from(string)
+    # methods need options to have their args parsed with ArgumentInspector
+    string.gsub!(/(def blah)/, 'options :a=>1; \1')
+    Inspector.enable
+    ::Boson::Commands::Aaa.module_eval(string)
+    Inspector.disable
+    MethodInspector.store[:args]['blah']
+  end
 
-      before(:all) { eval "module ::Boson::Commands::Aaa; end"; }
-      before(:each) { MethodInspector.mod_store[::Boson::Commands::Aaa] = {} }
+  before_all { eval "module ::Boson::Commands::Aaa; end"; }
+  before { MethodInspector.mod_store[::Boson::Commands::Aaa] = {} }
 
-      test "determines arguments with literal defaults" do
-        args_from("def blah(arg1,arg2='val2'); end").should == [['arg1'], ['arg2','val2']]
-      end
+  it "determines arguments with literal defaults" do
+    args_from("def blah(arg1,arg2='val2'); end").should == [['arg1'], ['arg2','val2']]
+  end
 
-      test "determines splat arguments" do
-        args_from("def blah(arg1, *args); end").should == [['arg1'], ["*args"]]
-      end
+  it "determines splat arguments" do
+    args_from("def blah(arg1, *args); end").should == [['arg1'], ["*args"]]
+  end
 
-      test "determines arguments with local values before a method" do
-        body = "AWESOME='awesome'; def sweet; 'ok'; end; def blah(arg1=AWESOME, arg2=sweet); end"
-        args_from(body).should == [['arg1', 'awesome'], ['arg2', 'ok']]
-      end
+  it "determines arguments with local values before a method" do
+    body = "AWESOME='awesome'; def sweet; 'ok'; end; def blah(arg1=AWESOME, arg2=sweet); end"
+    args_from(body).should == [['arg1', 'awesome'], ['arg2', 'ok']]
+  end
 
-      test "doesn't get arguments with local values after a method" do
-        args_from("def blah(arg1=nope) end; def nope; 'nope'; end").should == nil
-      end
+  it "doesn't get arguments with local values after a method" do
+    args_from("def blah(arg1=nope) end; def nope; 'nope'; end").should == nil
+  end
 
-      test "doesn't determine arguments of a private method" do
-        args_from("private; def blah(arg1,arg2); end").should == nil
-      end
+  it "doesn't determine arguments of a private method" do
+    args_from("private; def blah(arg1,arg2); end").should == nil
+  end
 
-      test "doesn't determine arguments if an error occurs" do
-        args_from("def blah(arg1,arg2=raise); end").should == nil
-      end
-    end
+  it "doesn't determine arguments if an error occurs" do
+    args_from("def blah(arg1,arg2=raise); end").should == nil
   end
 end

data/test/bacon_extensions.rb

@@ -0,0 +1,26 @@
+module BaconExtensions
+  def self.included(mod)
+    mod.module_eval do
+      # nested context methods automatically inherit methods from parent contexts
+      def describe(*args, &block)
+        context = Bacon::Context.new(args.join(' '), &block)
+        (parent_context = self).methods(false).each {|e|
+          class<<context; self end.send(:define_method, e) {|*args| parent_context.send(e, *args)}
+        }
+        @before.each { |b| context.before(&b) }
+        @after.each { |b| context.after(&b) }
+        context.run
+      end
+    end
+  end
+
+  def xit(*args); end
+  def xdescribe(*args); end
+  def before_all; yield; end
+  def after_all; yield; end
+  def assert(description, &block)
+    it(description) do
+      block.call.should == true
+    end
+  end
+end

data/test/bin_runner_test.rb

@@ -1,203 +1,203 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 require 'boson/runners/bin_runner'
+BinRunner = Boson::BinRunner
 
-module Boson
-  class BinRunnerTest < Test::Unit::TestCase
-    def start(*args)
-      Hirb.stubs(:enable)
-      BinRunner.start(args)
-    end
-
-    before(:each) {|e|
-      Boson::BinRunner.instance_variables.each {|e| Boson::BinRunner.instance_variable_set(e, nil)}
-    }
-    context "at commandline" do
-      before(:all) { reset }
-
-      test "no arguments prints usage" do
-        capture_stdout { start }.should =~ /^boson/
-      end
+describe "BinRunner" do
+  def start(*args)
+    Hirb.stubs(:enable)
+    BinRunner.start(args)
+  end
 
-      test "invalid option value prints error" do
-        capture_stderr { start("-l") }.should =~ /Error:/
-      end
+  before {|e|
+    BinRunner.instance_variables.each {|e| BinRunner.instance_variable_set(e, nil)}
+  }
+  describe "at commandline" do
+    before_all { reset }
 
-      test "help option but no arguments prints usage" do
-        capture_stdout { start '-h' }.should =~ /^boson/
-      end
+    it "no arguments prints usage" do
+      capture_stdout { start }.should =~ /^boson/
+    end
 
-      test "help option and command prints help" do
-        capture_stdout { start('-h', 'commands') } =~ /^commands/
-      end
+    it "invalid option value prints error" do
+      capture_stderr { start("-l") }.should =~ /Error:/
+    end
 
-      test "load option loads libraries" do
-        Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0][0] == 'blah'}.times(2)
-        BinRunner.stubs(:execute_command)
-        start('-l', 'blah', 'libraries')
-      end
+    it "help option but no arguments prints usage" do
+      capture_stdout { start '-h' }.should =~ /^boson/
+    end
 
-      test "console option starts irb" do
-        ConsoleRunner.expects(:start)
-        Util.expects(:which).returns("/usr/bin/irb")
-        Kernel.expects(:load).with("/usr/bin/irb")
-        start("--console")
-      end
+    it "help option and command prints help" do
+      capture_stdout { start('-h', 'commands') }.should =~ /^commands/
+    end
 
-      test "console option but no irb found prints error" do
-        ConsoleRunner.expects(:start)
-        Util.expects(:which).returns(nil)
-        capture_stderr { start("--console") }.should =~ /Console not found/
-      end
+    it "load option loads libraries" do
+      Manager.expects(:load).with {|*args| args[0][0].is_a?(Module) ? true : args[0][0] == 'blah'}.times(2)
+      BinRunner.stubs(:execute_command)
+      start('-l', 'blah', 'libraries')
+    end
 
-      test "execute option executes string" do
-        BinRunner.expects(:define_autoloader)
-        capture_stdout { start("-e", "p 1 + 1") }.should == "2\n"
-      end
+    # it "console option starts irb" do
+    #   ConsoleRunner.expects(:start)
+    #   Util.expects(:which).returns("/usr/bin/irb")
+    #   Kernel.expects(:load).with("/usr/bin/irb")
+    #   start("--console")
+    # end
+
+    it "console option but no irb found prints error" do
+      ConsoleRunner.expects(:start)
+      Util.expects(:which).returns(nil)
+      capture_stderr { start("--console") }.should =~ /Console not found/
+    end
 
-      test "global option takes value with whitespace" do
-        View.expects(:render).with {|*args| args[1][:fields] = %w{f1 f2} }
-        start('commands', '-f', 'f1, f2')
-      end
+    it "execute option executes string" do
+      BinRunner.expects(:define_autoloader)
+      capture_stdout { start("-e", "p 1 + 1") }.should == "2\n"
+    end
 
-      test "execute option errors are caught" do
-        capture_stderr { start("-e", "raise 'blah'") }.should =~ /^Error:/
-      end
+    it "global option takes value with whitespace" do
+      View.expects(:render).with {|*args| args[1][:fields] = %w{f1 f2} }
+      start('commands', '-f', 'f1, f2')
+    end
 
-      test "command and too many arguments prints error" do
-        capture_stdout { capture_stderr { start('commands','1','2','3') }.should =~ /'commands'.*incorrect/ }
-      end
+    it "execute option errors are caught" do
+      capture_stderr { start("-e", "raise 'blah'") }.should =~ /^Error:/
+    end
 
-      test "failed subcommand prints error and not command not found" do
-        BinRunner.expects(:execute_command).raises("bling")
-        capture_stderr { start("commands.to_s") }.should =~ /Error: bling/
-      end
+    it "option command and too many arguments prints error" do
+      capture_stdout {
+        capture_stderr { start('commands','1','2','3') }.should =~ /'commands'.*incorrect/
+      }
+    end
 
-      test "nonexistant subcommand prints command not found" do
-        capture_stderr { start("to_s.bling") }.should =~ /'to_s.bling' not found/
-      end
+    it "normal command and too many arguments prints error" do
+      capture_stdout {
+        capture_stderr { start('render') }.should =~ /'render'.*incorrect/
+      }
+    end
 
-      test "undiscovered command prints error" do
-         BinRunner.expects(:load_command_by_index).returns(false)
-        capture_stderr { start('blah') }.should =~ /Error.*not found/
-      end
+    it "failed subcommand prints error and not command not found" do
+      BinRunner.expects(:execute_command).raises("bling")
+      capture_stderr { start("commands.to_s") }.should =~ /Error: bling/
+    end
 
-      test "basic command executes" do
-        BinRunner.expects(:init).returns(true)
-        BinRunner.stubs(:render_output)
-        Boson.main_object.expects(:send).with('kick','it')
-        start 'kick','it'
-      end
+    it "nonexistant subcommand prints command not found" do
+      capture_stderr { start("to_s.bling") }.should =~ /'to_s.bling' not found/
+    end
 
-      test "sub command executes" do
-        obj = Object.new
-        Boson.main_object.extend Module.new { def phone; Struct.new(:home).new('done'); end }
-        BinRunner.expects(:init).returns(true)
-        BinRunner.expects(:render_output).with('done')
-        start 'phone.home'
-      end
+    it "undiscovered command prints error" do
+       BinRunner.expects(:autoload_command).returns(false)
+      capture_stderr { start('blah') }.should =~ /Error.*not found/
+    end
 
-      test "bin_defaults config loads by default" do
-        defaults = Boson::Runner.default_libraries + ['yo']
-        with_config(:bin_defaults=>['yo']) do
-          Manager.expects(:load).with {|*args| args[0] == defaults }
-          capture_stderr { start 'blah' }
-        end
-      end
+    it "basic command executes" do
+      BinRunner.expects(:init).returns(true)
+      BinRunner.stubs(:render_output)
+      Boson.main_object.expects(:send).with('kick','it')
+      start 'kick','it'
     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.indexes[0].expects(:write)
-      end
+    it "sub command executes" do
+      obj = Object.new
+      Boson.main_object.extend Module.new { def phone; Struct.new(:home).new('done'); end }
+      BinRunner.expects(:init).returns(true)
+      BinRunner.expects(:render_output).with('done')
+      start 'phone.home'
+    end
 
-      test "with index option, no existing index and core command updates index and prints index message" do
-        index :load=>Runner.all_libraries
-        Index.indexes[0].stubs(:exists?).returns(false)
-        capture_stdout { start("--index", "libraries") }.should =~ /Generating index/
+    it "bin_defaults config loads by default" do
+      defaults = Runner.default_libraries + ['yo']
+      with_config(:bin_defaults=>['yo']) do
+        Manager.expects(:load).with {|*args| args[0] == defaults }
+        capture_stderr { start 'blah' }
       end
+    end
+  end
 
-      test "with index option, existing index and core command updates incremental index" do
-        index :load=>['changed']
-        Index.indexes[0].stubs(:exists?).returns(true)
-        capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
-      end
+  describe "autoload_command" 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.indexes[0].expects(:write)
+    end
 
-      test "with index option, failed indexing prints error" do
-        index :load=>['changed'], :fails=>true
-        Index.indexes[0].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
+    it "with index option, no existing index and core command updates index and prints index message" do
+      index :load=>Runner.all_libraries
+      Index.indexes[0].stubs(:exists?).returns(false)
+      capture_stdout { start("--index", "libraries") }.should =~ /Generating index/
+    end
 
-      test "with core command updates index and doesn't print index message" do
-        Index.indexes[0].expects(:write)
-        Boson.main_object.expects(:send).with('libraries')
-        capture_stdout { start 'libraries'}.should_not =~ /index/i
-      end
+    it "with index option, existing index and core command updates incremental index" do
+      index :load=>['changed']
+      Index.indexes[0].stubs(:exists?).returns(true)
+      capture_stdout { start("--index=changed", "libraries")}.should =~ /Indexing.*changed/
+    end
 
-      test "with non-core command finding library doesn't update index" do
-        Index.expects(:find_library).returns('sweet_lib')
-        Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
-        Index.indexes[0].expects(:update).never
-        capture_stderr { start("sweet") }.should =~ /sweet/
-      end
+    it "with index option, failed indexing prints error" do
+      index :load=>['changed'], :fails=>true
+      Index.indexes[0].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 non-core command not finding library, does update index" do
-        Index.expects(:find_library).returns(nil, 'sweet_lib').times(2)
-        Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
-        Index.indexes[0].expects(:update).returns(true)
-        capture_stderr { start("sweet") }.should =~ /sweet/
-      end
+    it "with core command updates index and doesn't print index message" do
+      Index.indexes[0].expects(:write)
+      Boson.main_object.expects(:send).with('libraries')
+      capture_stdout { start 'libraries'}.should.not =~ /index/i
     end
 
-    context "render_output" do
-      before(:each) { Scientist.rendered = false; BinRunner.instance_eval "@options = {}" }
+    it "with non-core command not finding library, does update index" do
+      Index.expects(:find_library).returns(nil, 'sweet_lib')
+      Manager.expects(:load).with {|*args| args[0].is_a?(String) ? args[0] == 'sweet_lib' : true}.at_least(1)
+      Index.indexes[0].expects(:update).returns(true)
+      capture_stderr { start("sweet") }.should =~ /sweet/
+    end
+  end
 
-      test "doesn't render when nil, false or true" do
-        View.expects(:render).never
-        [nil, false, true].each do |e|
-          BinRunner.render_output e
-        end
-      end
+  describe "render_output" do
+    before { Scientist.rendered = false; BinRunner.instance_eval "@options = {}" }
 
-      test "doesn't render when rendered with Scientist" do
-        Scientist.rendered = true
-        View.expects(:render).never
-        BinRunner.render_output 'blah'
+    it "doesn't render when nil, false or true" do
+      View.expects(:render).never
+      [nil, false, true].each do |e|
+        BinRunner.render_output e
       end
+    end
 
-      test "render with puts when non-string" do
-        View.expects(:render).with('dude', {:method => 'puts'})
-        BinRunner.render_output 'dude'
-      end
+    it "doesn't render when rendered with Scientist" do
+      Scientist.rendered = true
+      View.expects(:render).never
+      BinRunner.render_output 'blah'
+    end
 
-      test "renders with inspect when non-array and non-string" do
-        [{:a=>true}, :ok].each do |e|
-          View.expects(:puts).with(e.inspect)
-          BinRunner.render_output e
-        end
-      end
+    it "render with puts when non-string" do
+      View.expects(:render).with('dude', {:method => 'puts'})
+      BinRunner.render_output 'dude'
+    end
 
-      test "renders with inspect when Scientist rendering toggled off with :render" do
-        Scientist.global_options = {:render=>true}
-        View.expects(:puts).with([1,2].inspect)
-        BinRunner.render_output [1,2]
-        Scientist.global_options = nil
+    it "renders with inspect when non-array and non-string" do
+      [{:a=>true}, :ok].each do |e|
+        View.expects(:puts).with(e.inspect)
+        BinRunner.render_output e
       end
+    end
 
-      test "renders with hirb when array" do
-        View.expects(:render_object)
-        BinRunner.render_output [1,2,3]
-      end
+    it "renders with inspect when Scientist rendering toggled off with :render" do
+      Scientist.global_options = {:render=>true}
+      View.expects(:puts).with([1,2].inspect)
+      BinRunner.render_output [1,2]
+      Scientist.global_options = nil
     end
 
-    test "parse_args only translates options before command" do
-      BinRunner.parse_args(['-v', 'com', '-v']).should == ["com", {:verbose=>true}, ['-v']]
-      BinRunner.parse_args(['com', '-v']).should == ["com", {}, ['-v']]
+    it "renders with hirb when array" do
+      View.expects(:render_object)
+      BinRunner.render_output [1,2,3]
     end
   end
+
+  it "parse_args only translates options before command" do
+    BinRunner.parse_args(['-v', 'com', '-v']).should == ["com", {:verbose=>true}, ['-v']]
+    BinRunner.parse_args(['com', '-v']).should == ["com", {}, ['-v']]
+  end
 end