bond 0.4.2-java

data/lib/bond/version.rb

@@ -0,0 +1,3 @@
+module Bond
+  VERSION = '0.4.2'
+end

data/test/agent_test.rb

@@ -0,0 +1,235 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Agent" do
+  describe "#call" do
+    before { Bond.agent.reset }
+
+    it "chooses default mission if no missions match" do
+      complete(:on=>/bling/) {|e| [] }
+      Bond.agent.default_mission.expects(:execute).with {|e| e.is_a?(Input) }
+      tab 'blah'
+    end
+
+    it "for internal Bond error completes error" do
+      complete(:on=>/bling/) {|e| [] }
+      Bond.agent.expects(:find_mission).raises('wtf')
+      errors = tab('bling')
+      errors[0].should =~ /Bond Error: Failed internally.*'wtf'/
+      errors[1].should =~ /Please/
+    end
+
+    it "allows the readline buffer to be provided as an argument" do
+      Bond.agent.weapon.stubs(:line_buffer).raises(Exception)
+      should.not.raise { Bond.agent.call('bl', 'bl foo') }
+    end
+
+    def complete_error(msg)
+      lambda {|e|
+        e[0].should =~ msg
+        e[1].should =~ /Completion Info: Matches.*blah/
+      }
+    end
+
+    it "for completion action raising error completes error" do
+      Bond.config[:debug] = false
+      complete(:on=>/blah/) { raise 'blah' }
+      errors = tab('blah')
+      errors.size.should == 2
+      errors.should complete_error(/Bond Error: Failed.*action.*'blah'/)
+      Bond.config[:debug] = true
+    end
+
+    it "for completion action raising error with debug completes error and stacktrace" do
+      complete(:on=>/blah/) { raise 'blah' }
+      errors = tab('blah')
+      errors.size.should == 3
+      errors.should complete_error(/Bond Error: Failed.*action.*'blah'/)
+      errors[2].should =~ /Stack Trace:/
+    end
+
+    it "for completion action raising NoMethodError completes error" do
+      complete(:on=>/blah/) { raise NoMethodError }
+      tab('blah').should complete_error(/Bond Error: Failed.*action.*'NoMethodError'/)
+    end
+
+    it 'for completion action failing with Rc.eval completes empty' do
+      Bond.config[:debug] = false
+      complete(:on=>/blah/) { Rc.eval '{[}'}
+      tab('blah').should == []
+      Bond.config[:debug] = true
+    end
+
+    it 'for completion action failing with Rc.eval and debug completes error' do
+      complete(:on=>/blah/) { Rc.eval('{[}') || [] }
+      tab('blah').should complete_error(/Bond Error: Failed.*action.*(syntax|expect)/m)
+    end
+
+    it "for completion action raising SyntaxError in eval completes error" do
+      complete(:on=>/blah/) { eval '{[}'}
+      tab('blah').should complete_error(/Bond Error: Failed.*action.*(eval)/)
+    end
+
+    it "for completion action that doesn't exist completes error" do
+      complete(:on=>/blah/, :action=>:huh)
+      tab('blah').should complete_error(/Bond Error:.*action 'huh' doesn't exist/)
+    end
+
+    it "for completion search raising error completes error" do
+      Rc.module_eval "def blah_search(*args); raise 'blah'; end"
+      complete(:on=>/blah/, :search=>:blah) { [1] }
+      tab('blah').should complete_error(/Bond Error: Failed.*search.*'blah'/)
+    end
+
+    it "for completion search that doesn't exist completes error" do
+      complete(:on=>/blah/, :search=>:huh) { [] }
+      tab('blah').should complete_error(/Bond Error:.*search 'huh' doesn't exist/)
+    end
+  end
+
+  describe "complete" do
+    before {|e| Bond.agent.reset }
+    def complete_prints_error(msg, *args, &block)
+      capture_stderr { complete(*args, &block) }.should =~ msg
+    end
+
+    it "with no :action prints error" do
+      complete_prints_error /Invalid :action/, :on=>/blah/
+    end
+
+    it "with no :on prints error" do
+      complete_prints_error(/Invalid :on/) { [] }
+    end
+
+    it "with invalid :on prints error" do
+      complete_prints_error(/Invalid :on/, :on=>'blah') { [] }
+    end
+
+    it "with internal failure prints error" do
+      Mission.expects(:create).raises(RuntimeError, 'blah')
+      complete_prints_error(/Unexpected error.*blah/, :on=>/blah/) { [] }
+    end
+
+    it "with invalid :anywhere and :prefix prints no error" do
+      complete_prints_error(/^$/, :prefix=>nil, :anywhere=>:blah) {}
+    end
+
+    it "with invalid :object prints no error" do
+      complete_prints_error(/^$/, :object=>:Mod) {}
+    end
+
+    it "with invalid :method prints error" do
+      complete_prints_error(/Invalid.*:method\(s\)/, :method=>true) {}
+    end
+
+    it "with invalid array :method prints error" do
+      complete_prints_error(/Invalid array :method/, :method=>%w{one two}) {}
+    end
+
+    it "with invalid :methods prints error" do
+      complete_prints_error(/Invalid.*:method\(s\)/, :methods=>[:blah]) {}
+    end
+
+    it "with invalid :action for method completion prints error" do
+      complete_prints_error(/Invalid string :action/, :method=>"blah", :action=>"Kernel#wtf") {}
+    end
+
+    it "with invalid :class prints no error" do
+      complete_prints_error(/^$/, :method=>'ok', :class=>/wtf/) {}
+    end
+
+    it "places missions last when declared last" do
+      complete(:object=>"Symbol", :place=>:last)
+      complete(:on=>/man/, :place=>:last) { }
+      complete(:on=>/man\s*(.*)/) {|e| [e.matched[1]] }
+      Bond.agent.missions.map {|e| e.class}.should == [Mission, ObjectMission, Mission]
+      tab('man ok').should == ['ok']
+    end
+
+    it "places mission correctly for a place number" do
+      complete(:object=>"Symbol")
+      complete(:on=>/man/) {}
+      complete(:on=>/man\s*(.*)/, :place=>1) {|e| [e.matched[1]] }
+      tab('man ok')
+      Bond.agent.missions.map {|e| e.class}.should == [Mission, ObjectMission, Mission]
+      tab('man ok').should == ['ok']
+    end
+  end
+
+  describe "recomplete" do
+    before {|e| Bond.agent.reset }
+
+    it "recompletes a mission" do
+      complete(:on=>/man/) { %w{1 2 3}}
+      Bond.recomplete(:on=>/man/) { %w{4 5 6}}
+      tab('man ').should == %w{4 5 6}
+    end
+
+    it "recompletes a mission with :name" do
+      complete(:on=>/man/, :name=>:count) { %w{1 2 3}}
+      Bond.recomplete(:on=>/man/, :name=>:count) { %w{4 5 6}}
+      tab('man ').should == %w{4 5 6}
+    end
+
+    it "recompletes a method mission" do
+      complete(:all_methods=>true)
+      MethodMission.reset
+      complete(:method=>'blah') { %w{1 2 3}}
+      Bond.recomplete(:method=>'blah') { %w{4 5 6}}
+      tab('blah ').should == %w{4 5 6}
+    end
+
+    it "completes a method mission if mission not found" do
+      complete(:all_methods=>true)
+      MethodMission.reset
+      Bond.recomplete(:method=>'blah') { %w{4 5 6}}
+      tab('blah ').should == %w{4 5 6}
+    end
+
+    it "recompletes an object mission" do
+      complete(:object=>'String') { %w{1 2 3}}
+      Bond.recomplete(:object=>'String') { %w{4 5 6}}
+      tab('"blah".').should == %w{.4 .5 .6}
+    end
+
+    it "recompletes anywhere mission" do
+      complete(:anywhere=>'dude.*') { %w{duder dudest} }
+      Bond.recomplete(:anywhere=>'dude.*') { %w{duderific dudeacious} }
+      tab('dude').should == %w{duderific dudeacious}
+    end
+
+    it "prints error if no existing mission" do
+      complete(:object=>'String') { %w{1 2 3}}
+      capture_stderr { Bond.recomplete(:object=>'Array') { %w{4 5 6}}}.should =~ /No existing mission/
+      tab('[].').should == []
+    end
+
+    it "prints error if invalid condition given" do
+      capture_stderr { Bond.recomplete}.should =~ /Invalid :action/
+    end
+  end
+
+  describe "spy" do
+    before_all {
+      reset
+      complete(:on=>/end$/) { [] };
+      complete(:all_methods=>true); complete(:method=>'the') { %w{spy who loved me} }
+      complete(:object=>"Symbol")
+    }
+
+    it "detects basic mission" do
+      capture_stdout { Bond.spy('the end')}.should =~ /end/
+    end
+
+    it "detects object mission" do
+      capture_stdout { Bond.spy(':dude.i')}.should =~ /object.*Symbol.*dude\.id/m
+    end
+
+    it "detects method mission" do
+      capture_stdout { Bond.spy('the ')}.should =~ /method.*the.*Kernel.*loved/m
+    end
+
+    it "detects no mission" do
+      capture_stdout { Bond.spy('blah')}.should =~ /Doesn't match/
+    end
+  end
+end

data/test/anywhere_mission_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "anywhere mission" do
+  before { Bond.agent.reset }
+
+  describe "normally" do
+    before { complete(:anywhere=>':[^:\s.]*') {|e| %w{:ab :bd :ae} } }
+
+    it "completes at beginning" do
+      tab(":a").should == %w{:ab :ae}
+    end
+
+    it "completes in middle of string" do
+      tab("hash[:a").should == %w{hash[:ab hash[:ae}
+    end
+
+    it "completes after word break chars" do
+      tab("{:ab=>1}[:a").should == ["1}[:ab", "1}[:ae"]
+      tab("nil;:a").should == %w{:ab :ae}
+    end
+  end
+
+  it 'with special chars and custom search completes' do
+    complete(:anywhere=>'\$[^\s.]*', :search=>false) {|e|
+      global_variables.grep(/^#{Regexp.escape(e.matched[1])}/)
+    }
+    tab("$LO").sort.should == ["$LOADED_FEATURES", "$LOAD_PATH"]
+  end
+
+  it 'with :prefix completes' do
+    complete(:prefix=>'_', :anywhere=>':[^:\s.]*') { %w{:ab :bd :ae} }
+    tab("_:a").should == %w{_:ab _:ae}
+  end
+end

data/test/bond_test.rb

@@ -0,0 +1,141 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Bond" do
+  describe "start" do
+    def start(options={}, &block)
+      Bond.start({:readline=>valid_readline}.merge(options), &block)
+    end
+
+    before { M.instance_eval("@started = @agent = @config = nil"); M.expects(:load_completions) }
+    it "prints error if readline doesn't have all required methods" do
+      capture_stderr {
+        start :readline=>Module.new{ def self.setup(arg); end }
+      }.should =~ /Invalid/
+    end
+
+    it "prints error if readline symbol is invalid" do
+      capture_stderr {
+        start :readline => :blah
+      }.should =~ /Invalid.*'blah'/
+    end
+
+    it "prints no error if valid readline" do
+      capture_stderr { start }.should == ''
+    end
+
+    it 'prints no error if valid readline symbol' do
+      capture_stderr { start :readline => :ruby }.should == ''
+      Bond.config[:readline].should == Bond::Ruby
+    end
+
+    it "sets default mission" do
+      start :default_mission=>lambda {|e| %w{1 2 3}}
+      tab('1').should == ['1']
+    end
+
+    it "sets default search" do
+      start :default_search=>:anywhere
+      complete(:on=>/blah/) { %w{all_quiet on_the western_front}}
+      tab('blah qu').should == ["all_quiet"]
+    end
+
+    it "defines completion in block" do
+      start { complete(:on=>/blah/) { %w{all_quiet on_the western_front}} }
+      tab('blah all').should == ["all_quiet"]
+    end
+
+    it "sets proc eval_binding" do
+      bdg = binding
+      start :eval_binding => lambda { bdg }
+      Mission.expects(:eval).with(anything, bdg).returns([])
+      tab("'blah'.").should == []
+    end
+
+    it "status can be checked with started?" do
+      Bond.started?.should == false
+      start
+      Bond.started?.should == true
+    end
+
+    after_all { reset }
+  end
+
+  describe "start with :gems" do
+    before {
+      File.stubs(:exists?).returns(true)
+      M.stubs(:load_file)
+    }
+
+    it "attempts to load gem" do
+      M.stubs(:load_dir)
+      M.expects(:gem).twice
+      start(:gems=>%w{one two})
+    end
+
+    it "rescues nonexistent gem" do
+      M.stubs(:load_dir)
+      M.expects(:gem).raises(LoadError)
+      should.not.raise { start(:gems=>%w{blah}) }
+    end
+
+    it "rescues nonexistent method 'gem'" do
+      M.stubs(:load_dir)
+      M.expects(:gem).raises(NoMethodError)
+      should.not.raise { start(:gems=>%w{blah}) }
+    end
+
+    it "prints error if gem completion not found" do
+      M.stubs(:load_dir)
+      M.expects(:find_gem_file).returns(nil)
+      capture_stderr { start(:gems=>%w{invalid}) }.should =~ /No completions.*'invalid'/
+    end
+
+    it "loads gem completion file" do
+      M.expects(:load_dir)
+      M.expects(:load_dir).with(File.join($:[0], 'awesome', '..', 'bond'))
+      M.expects(:load_dir)
+      M.expects(:gem)
+      start(:gems=>%w{awesome})
+    end
+    after_all { reset }
+  end
+
+  it "prints error if Readline setup fails" do
+    Bond::Readline.expects(:setup).raises('WTF')
+    capture_stderr { Bond.start(:readline=>Bond::Readline) }.should =~ /Error.*Failed Readline.*'WTF'/
+    M.debrief :readline=>valid_readline
+  end
+
+  it "start prints error for failed completion file" do
+    Rc.stubs(:module_eval).raises('wtf')
+    capture_stderr { Bond.start }.should =~ /Bond Error: Completion file.*with:\nwtf/
+  end
+
+  it "reset clears existing missions" do
+    complete(:on=>/blah/) {[]}
+    Bond.agent.missions.size.should.not == 0
+    reset
+    Bond.agent.missions.size.should == 0
+  end
+
+  describe "restart" do
+    def start(options={}, &block)
+      Bond.start({:readline=>valid_readline}.merge(options), &block)
+    end
+
+    it "deletes previous config" do
+      start :blah=>''
+      Bond.config[:blah].should.not == nil
+      Bond.restart({:readline=>valid_readline})
+      Bond.config[:blah].should == nil
+    end
+
+    it "deletes previous method completions" do
+      start
+      complete(:method=>'blah') { [] }
+      MethodMission.actions['blah'].should.not == nil
+      Bond.restart({:readline=>valid_readline})
+      MethodMission.actions['blah'].should == nil
+    end
+  end
+end

data/test/completion_test.rb

@@ -0,0 +1,148 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Completion" do
+  before_all {
+    reset
+    M.load_file File.dirname(__FILE__) + '/../lib/bond/completion.rb'
+    M.load_dir File.dirname(__FILE__) + '/../lib/bond'
+  }
+
+  it "completes global variables anywhere" do
+    tab("blah $LOA").should.satisfy {|e|
+      e.size > 0 && e.all? {|e| e=~ /^\$LOA/} }
+    tab("h[$LOADED").should == ["h[$LOADED_FEATURES"]
+  end
+
+  it "completes absolute constants anywhere" do
+    tab("blah ::Has").should == ["::Hash"]
+    tab("h[::Has").should == ["h[::Hash"]
+  end
+
+  it "completes invalid constants safely" do
+    capture_stdout {
+      tab("Bond::MethodMission ").should == []
+    }.should == ''
+  end
+
+  it "completes nested classes greater than 2 levels" do
+    eval %[module ::Foo; module Bar; module Baz; end; end; end]
+    tab("Foo::Bar::B").should == %w{Foo::Bar::Baz}
+  end
+
+  it "completes nested classes anywhere" do
+    tab("module Blah; include Bond::Sea").should == ["Bond::Search"]
+  end
+
+  it "completes symbols anywhere" do
+    Symbol.expects(:all_symbols).twice.returns([:mah])
+    tab("blah :m").size.should.be > 0
+    tab("blah[:m").should == ["blah[:mah"]
+  end
+
+  it "completes method arguments with parenthesis" do
+    tab("%w{ab bc cd}.delete(").should == %w{ab bc cd}
+  end
+
+  it "completes method arguments when object contains method names" do
+    tab("%w{find ab cd}.delete ").should == %w{find ab cd}
+  end
+
+  it "completes hash coming from a method" do
+    tab('Bond.config[:r').should == ["Bond.config[:readline"]
+  end
+
+  it "methods don't swallow up default completion" do
+    Bond.agent.find_mission("some_method(:verbose=>true) { Arr").should == nil
+  end
+
+  describe "completes object methods" do
+    def be_methods_from(klass, regex, obj=klass.new)
+      lambda {|e|
+        meths = e.map {|f| f.sub(/^#{Regexp.quote(regex)}/, '') }
+        meths.size.should.be > 0
+        (meths - obj.methods.map {|e| e.to_s} - Mission::OPERATORS).size.should == 0
+      }
+    end
+
+    shared "objects" do
+      it "non whitespace object" do
+        tab(':man.').should be_methods_from(Symbol, ':man.', :man)
+      end
+
+      it "nil" do
+        tab("nil.t").should be_methods_from(NilClass, 'nil.', nil)
+      end
+
+      it "false" do
+        tab("false.f").should be_methods_from(FalseClass, 'false.', false)
+      end
+
+      it "strings" do
+        tab("'man oh'.s").should be_methods_from(String, '.')
+        tab('"man oh".s').should be_methods_from(String, '.')
+      end
+
+      it "array" do
+        tab("[1, 2].f").should be_methods_from(Array, '2].')
+      end
+
+      it "hash" do
+        tab("{:a =>1}.f").should be_methods_from(Hash, '1}.')
+      end
+
+      it "regexp" do
+        tab("/man oh/.c").should be_methods_from(Regexp, 'oh/.', /man oh/)
+      end
+
+      it "proc" do
+        tab('lambda { }.c').should be_methods_from(Proc, '}.', lambda{})
+        tab('proc { }.c').should be_methods_from(Proc, '}.', lambda{})
+      end
+
+      it "range" do
+        tab("(1 .. 10).m").should be_methods_from(Range, '10).', (1..10))
+      end
+
+      it "object between ()" do
+        tab("(2 * 2).").should be_methods_from(Fixnum, '2).', 2)
+        tab("String.new('man oh').s").should be_methods_from(String, ').')
+      end
+
+      it "object quoted by {}" do
+        tab("%r{man oh}.c").should be_methods_from(Regexp, 'oh}.', /man oh/)
+        tab("%q{man oh}.s").should be_methods_from(String, 'oh}.')
+        tab("%Q{man oh}.s").should be_methods_from(String, 'oh}.')
+        tab("%w{man oh}.f").should be_methods_from(Array, 'oh}.')
+        tab("%s{man oh}.t").should be_methods_from(Symbol, 'oh}.', :man)
+        tab("%{man oh}.t").should be_methods_from(String, 'oh}.')
+      end
+
+      it "object quoted by []" do
+        tab("%r[man oh].c").should be_methods_from(Regexp, 'oh].', /man oh/)
+        tab("%q[man oh].s").should be_methods_from(String, 'oh].')
+        tab("%Q[man oh].s").should be_methods_from(String, 'oh].')
+        tab("%w[man oh].f").should be_methods_from(Array, 'oh].')
+        tab("%s[man oh].t").should be_methods_from(Symbol, 'oh].', :man)
+        tab("%[man oh].t").should be_methods_from(String, 'oh].')
+      end
+    end
+
+    describe "for" do
+      behaves_like "objects"
+    end
+
+    describe "after valid ruby for" do
+      def tab(str)
+        super("nil; "+str)
+      end
+      behaves_like "objects"
+    end
+
+    describe "after invalid ruby for" do
+      def tab(str)
+        super("blah "+str)
+      end
+      behaves_like "objects"
+    end
+  end
+end