boson 0.0.1

data/test/bin_runner_test.rb

@@ -0,0 +1,136 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+require 'boson/runners/bin_runner'
+
+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
+
+      test "invalid option value prints error" do
+        capture_stderr { start("-l") }.should =~ /Error:/
+      end
+
+      test "help option but no arguments prints usage" do
+        capture_stdout { start '-h' }.should =~ /^boson/
+      end
+
+      test "help option and command prints help" do
+        capture_stdout { start('-h', 'commands') } =~ /^commands/
+      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
+
+      test "repl option starts repl" do
+        ReplRunner.expects(:start)
+        Util.expects(:which).returns("/usr/bin/irb")
+        Kernel.expects(:load).with("/usr/bin/irb")
+        start("--repl")
+      end
+
+      test "repl option but no repl found prints error" do
+        ReplRunner.expects(:start)
+        Util.expects(:which).returns(nil)
+        capture_stderr { start("--repl") } =~ /Repl not found/
+      end
+
+      test "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
+
+      test "command and too many arguments prints error" do
+        capture_stdout { start('commands','1','2','3') }.should =~ /Wrong number/
+      end
+
+      test "undiscovered command prints error" do
+         BinRunner.expects(:load_command_by_index).returns(false)
+        capture_stderr { start('blah') }.should =~ /Error.*blah/
+      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
+
+      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
+
+      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
+    end
+
+    context "load_command_by_index" do
+      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)
+        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/
+      end
+
+      test "with core command updates index and doesn't print index message" do
+        Index.expects(:write)
+        Boson.main_object.expects(:send).with('libraries')
+        capture_stdout { start 'libraries'}.should_not =~ /index/i
+      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.expects(:update).never
+        capture_stderr { start("sweet") }.should =~ /sweet/
+      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.expects(:update).returns(true)
+        capture_stderr { start("sweet") }.should =~ /sweet/
+      end
+    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']]
+    end
+  end
+end

data/test/commands_test.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class CommandsTest < Test::Unit::TestCase
+    before(:all) {
+      reset_boson
+      @higgs = Boson.main_object
+      ancestors = class <<Boson.main_object; self end.ancestors
+      # allows running just this test file
+      Manager.load Runner.default_libraries unless ancestors.include?(Boson::Commands::Core)
+    }
+
+    def render_expects(&block)
+      View.expects(:render).with(&block)
+    end
+
+    context "libraries" do
+      before(:all) {
+        Boson.libraries << Boson::Library.new(:name=>'blah')
+        Boson.libraries << Boson::Library.new(:name=>'another', :module=>"Cool")
+      }
+
+      test "lists all when given no argument" do
+        render_expects {|*args| args[0].size == 2}
+        @higgs.libraries
+      end
+
+      test "searches with a given search field" do
+        render_expects {|*args| args[0] == [Boson.library('another')]}
+        @higgs.libraries('Cool', :query_fields=>[:module])
+      end
+    end
+
+    context "commands" do
+      before(:all) {
+        Boson.commands << Command.create('some', Library.new(:name=>'thing'))
+        Boson.commands << Command.create('and', Library.new(:name=>'this'))
+      }
+
+      test "lists all when given no argument" do
+        render_expects {|*args| args[0].size == 2}
+        @higgs.commands
+      end
+
+      test "searches with a given search field" do
+        render_expects {|*args| args[0] == [Command.find('and')]}
+        @higgs.commands('this', :query_fields=>[:lib])
+      end
+    end
+  end
+end

data/test/comment_inspector_test.rb

@@ -0,0 +1,99 @@
+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
+    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
+    end
+
+    test "scrape all comment types with implicit desc" do
+      @lines = ["module Foo", '# @render_options :b=>1', '  # @options {:a=>true}', '#blah', "  def foo", "  end", "end"]
+      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1}}
+      CommentInspector.scrape(@lines.join("\n"), 5, Optional).should == expected
+    end
+
+    test "scrape all comment types with explicit desc" do
+      @lines = ["module Foo",  '#@desc blah', '# @render_options :b=>1,', '# :c=>2',
+        '  # @options {:a=>true}', "  def foo", "  end", "end"]
+      expected = {:desc=>"blah", :options=>{:a=>true}, :render_options=>{:b=>1, :c=>2}}
+      CommentInspector.scrape(@lines.join("\n"), 6, Optional).should == expected
+    end
+  end
+end

data/test/file_library_test.rb

@@ -0,0 +1,50 @@
+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 }
+
+      test "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::Delicious")
+        command_exists?('blah')
+      end
+
+      test "prints error for file library with no module" do
+        capture_stderr { load(:blah, :file_string=>"def blah; end") }.should =~ /Can't.*at least/
+      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
+
+      test "with same module reloads" do
+        load(:blah, :file_string=>"module Blah; def blah; end; end")
+        File.stubs(:exists?).returns(true)
+        File.stubs(:read).returns("module Blah; def bling; end; end")
+        Manager.reload('blah').should == true
+        command_exists?('bling')
+        library('blah').commands.size.should == 2
+      end
+
+      test "with different module reloads" do
+        load(:blah, :file_string=>"module Blah; def blah; end; end")
+        File.stubs(:exists?).returns(true)
+        File.stubs(:read).returns("module Bling; def bling; end; end")
+        Manager.reload('blah').should == true
+        library_has_module('blah', "Boson::Commands::Bling")
+        command_exists?('bling')
+        command_exists?('blah', false)
+        library('blah').commands.size.should == 1
+      end
+      
+    end
+  end
+end

data/test/index_test.rb

@@ -0,0 +1,117 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+module Boson
+  class IndexTest < Test::Unit::TestCase
+    # since we're defining our own @commands, @libraries, @lib_hashes
+    before(:all) { Index.instance_variable_set "@read", true }
+
+    context "read_and_transfer" do
+      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 "@commands", [Command.new(:name=>'blurb', :lib=>'blah')]
+        Index.read_and_transfer options[:ignored] || []
+        Boson.libraries.map {|e| e.name}.should == options[:libraries]
+        Boson.commands.map {|e| e.name}.should == options[:commands]
+      end
+
+      test "transfers libraries with no libraries to ignore" do
+        transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}, :ignored=>[]
+      end
+
+      test "transfers libraries and commands except for ignored libraries and its commands" do
+        transfers :libraries=>%w{bling}, :commands=>[], :ignored=>%w{blah}
+      end
+
+      test "doesn't replace existing libraries" do
+        lib = Library.new(:name=>'blah')
+        cmd = Command.new(:name=>'blurb', :lib=>'blah')
+        Boson.libraries << lib
+        Boson.commands << cmd
+        transfers :libraries=>%w{blah bling}, :commands=>%w{blurb}
+        Boson.libraries.include?(lib).should == true
+        Boson.commands.include?(cmd).should == true
+      end
+    end
+
+    context "find_library" do
+      before(:all) {
+        reset_boson
+        commands = [Command.new(:name=>'blurb', :lib=>'blah', :alias=>'bb'), 
+          Command.new(:name=>'sub', :lib=>'bling', :alias=>'s')
+        ]
+        Index.instance_variable_set "@commands", commands
+        Index.instance_variable_set "@libraries", [Library.new(:name=>'blah'), Library.new(:name=>'bling', :namespace=>'bling')]
+      }
+
+      test "finds command aliased or not" do
+        Index.find_library('blurb').should == 'blah'
+        Index.find_library('bb').should == 'blah'
+      end
+
+      test "doesn't find command" do
+        Index.find_library('blah').should == nil
+      end
+
+      test "finds a subcommand aliased or not" do
+        Index.find_library('bling.sub').should == 'bling'
+        # Index.find_library('bl.s').should == 'bling'
+      end
+
+      test "finds namespace command aliased or not without a subcommand" do
+        Index.find_library('bling').should == 'bling'
+        # Index.find_library('bl').should == 'bling'
+      end
+
+      test "doesn't find a subcommand" do
+        Index.find_library('d.d').should == nil
+      end
+    end
+
+    context "changed_libraries" do
+      before(:all) { Index.instance_eval "@lib_hashes = nil" }
+
+      def changed(string, all_libs=['file1'])
+        Runner.expects(:all_libraries).returns(all_libs)
+        Index.instance_variable_set "@lib_hashes", {"file1"=>Digest::MD5.hexdigest("state1")}
+        File.stubs(:exists?).returns(true)
+        File.expects(:read).returns(string)
+        Index.changed_libraries
+      end
+
+      test "detects changed libraries" do
+        changed("state2").should == %w{file1}
+      end
+
+      test "detects new libraries" do
+        changed("state1", ['file2']).should == %w{file2}
+      end
+
+      test "detects no changed libraries" do
+        changed("state1").should == []
+      end
+    end
+
+    context "write" do
+      before(:all) {
+        reset_boson
+        Boson.commands << Command.new(:name=>'blah', :lib=>'blah', :args=>[['arg1', {}], ['arg2', self.class]])
+        Boson.libraries << Library.new(:name=>'blah', :module=>self.class)
+        Index.expects(:latest_hashes)
+        libraries = commands = []
+        Index.expects(:save_marshal_index).with {|str| libraries, commands, hashes = Marshal.load(str) ; true}
+        Index.write
+        @index = {:libraries=>libraries, :commands=>commands}
+      }
+
+      test "saves library module constants as strings" do
+        @index[:libraries][0].module.class.should == String
+      end
+
+      test "save commands with arg values as strings" do
+        @index[:commands][0].args.each {|e| e[1].class.should == String}
+      end
+    end
+  end
+end