bond 0.4.2-java

data/test/completions_test.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "completions for" do
+  before_all {
+    reset
+    complete(:all_methods=>true)
+    complete(:all_operator_methods=>true)
+    M.load_file File.dirname(__FILE__) + '/../lib/bond/completion.rb'
+    M.load_dir File.dirname(__FILE__) + '/../lib/bond'
+  }
+
+  it "Array#delete" do
+    tab("[12,23,34,15].delete 1").should == %w{12 15}
+  end
+
+  describe "Hash" do
+    before { @hash = %q{{:ab=>1,:bc=>1,:cd=>3,:ae=>2}} }
+
+    it "#delete" do
+      tab("#{@hash}.delete :a").sort.should == %w{:ab :ae}
+    end
+
+    it "#index" do
+      tab("#{@hash}.index 2").should == %w{2}
+    end
+
+    it "#[]" do
+      tab("#{@hash}['a").sort.should == %w{ab ae}
+    end
+  end
+
+  describe "Kernel" do
+    it "#raise" do
+      tab("raise Errno::ETIME").sort.should == %w{Errno::ETIME Errno::ETIMEDOUT}
+    end
+
+    it "#require" do
+      mock_libs = ['net/http.rb', 'net/http/get.rb', 'abbrev.rb'].map {|e| $:[0] + "/#{e}" }
+      Dir.stubs(:[]).returns(mock_libs)
+      tab("require 'net/htt").should == %w{net/http.rb net/http/}
+    end
+  end
+
+  describe "Object" do
+    it "#instance_of?" do
+      expectations = ['Hash']
+      expectations = ["Hash", "Hash::"] if RbConfig::CONFIG["RUBY_SO_NAME"].to_s[/rubinius/i]
+      tab("[].instance_of? Has").should == expectations
+    end
+
+    it "#is_a?" do
+      tab("Module.is_a? Mod").should == ['Module']
+    end
+
+    it "#send" do
+      tab("Object.send :ne").should == [':new']
+    end
+
+    it "#send and additional arguments" do
+      tab('Bond.send :const_get, Ag').should == ['Agent']
+    end
+
+    it "#send and invalid first argument" do
+      tab('Bond.send :blah, ').should == []
+    end
+
+    it "#instance_variable_get" do
+      tab("Bond::M.instance_variable_get '@a").should == ['@agent']
+    end
+
+    it "#method" do
+      tab("Bond::M.method :ho").should == [':home']
+    end
+
+    it "#[]" do
+      ::ENV['ZZZ'] = ::ENV['ZZY'] = 'blah'
+      tab("ENV['ZZ").should == %w{ZZY ZZZ}
+    end
+  end
+
+  describe "Module" do
+    it "#const_get" do
+      tab("Bond.const_get M").sort.should == ['M', 'MethodMission', 'Mission']
+    end
+
+    it "#instance_methods" do
+      tab("Bond::Agent.instance_method :ca").should == [':call']
+    end
+
+    it "#>" do
+      tab("Object > Mod").should == %w{Module}
+    end
+
+    it "#> and :files search" do
+      tab("Object > Bon").should == %w{Bond Bond::}
+    end
+  end
+end

data/test/deps.rip

@@ -0,0 +1,4 @@
+bacon >=1.1.0
+mocha >=0.9.8
+mocha-on-bacon >=0
+bacon-bits >=0

data/test/m_test.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "M" do
+  describe "#load_gems" do
+    before { $: << '/dir' }
+    after { $:.pop }
+
+    def mock_file_exists(file)
+      File.expects(:exists?).at_least(1).returns(false).with {|e| e != file }
+      File.expects(:exists?).times(1).returns(true).with {|e| e == file }
+    end
+
+    it "loads gem" do
+      M.expects(:gem)
+      mock_file_exists '/dir/boom/../bond'
+      M.expects(:load_dir).with('/dir/boom/../bond').returns(true)
+      Bond.load_gems('boom').should == ['boom']
+    end
+
+    it "loads plugin gem in gem format" do
+      M.expects(:find_gem_file).returns(false)
+      mock_file_exists '/dir/boom/completions/what.rb'
+      M.expects(:load_file).with('/dir/boom/completions/what.rb')
+      Bond.load_gems('boom-what').should == ['boom-what']
+    end
+
+    it "loads plugin gem in file format" do
+      M.expects(:find_gem_file).returns(false)
+      mock_file_exists '/dir/boom/completions/what.rb'
+      M.expects(:load_file).with('/dir/boom/completions/what.rb')
+      Bond.load_gems('boom/what.rb').should == ['boom/what.rb']
+    end
+  end
+end

data/test/method_mission_test.rb

@@ -0,0 +1,246 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "method mission" do
+  before_all { MethodMission.reset }
+  before { Bond.agent.reset; Bond.complete(:all_methods=>true) }
+
+  describe "method" do
+    before { complete(:method=>'Array#index') {|e| %w{ab cd ef ad} } }
+
+    it "completes" do
+      tab('[].index c').should == %w{cd}
+    end
+
+    it "completes quoted argument" do
+      tab('[].index "a').should == %w{ab ad}
+    end
+
+    it "completes parenthetical argument" do
+      tab('[].index("a').should == %w{ab ad}
+    end
+
+    it "completes symbolic argument" do
+      tab('[].index :a').should == %w{:ab :ad}
+    end
+
+    it "needs space to complete argument" do
+      tab('[].indexa').should == []
+      tab('[].index a').should == %w{ab ad}
+    end
+
+    it "completes all arguments with only space as argument" do
+      tab('[].index ').should == %w{ab cd ef ad}
+    end
+
+    it "completes with a chain of objects" do
+      tab('{}.to_a.index a').should == %w{ab ad}
+    end
+
+    it "completes after valid ruby" do
+      tab('nil; [].index a').should == %w{ab ad}
+    end
+
+    it "completes after invalid ruby" do
+      tab('blah [].index a').should == %w{ab ad}
+    end
+
+    describe "completes for whitespaced object that is" do
+      def complete_and_tab(klass, example)
+        complete(:method=>"#{klass}#to_s") { %w{ab cd ef ad} }
+        tab(example + '.to_s a').should == %w{ab ad}
+      end
+
+      it "a string" do
+        complete_and_tab(String, "'man oh'")
+      end
+
+      it "an array" do
+        complete_and_tab(Array, "[1, 2, 3]")
+      end
+
+      it "a hash" do
+        complete_and_tab(Hash, "{:a => 1}")
+      end
+
+      it "a regexp" do
+        complete_and_tab(Regexp, "/man oh/")
+      end
+
+      it "a proc" do
+        complete_and_tab(Proc, "lambda { }")
+        complete_and_tab(Proc, "proc { }")
+      end
+
+      it "a range" do
+        complete_and_tab(Range, "(1.. 10)")
+      end
+
+      it "wrapped ()" do
+        complete_and_tab(Fixnum, "(2 * 2)")
+      end
+
+      it "quoted by {}" do
+        complete_and_tab(String, "%q{man oh}")
+      end
+
+      it "quoted by []" do
+        complete_and_tab(String, "%q[man oh]")
+      end
+    end
+  end
+
+  describe "any instance method" do
+    before { complete(:method=>'Array#index', :search=>:anywhere) {|e| %w{ab cd ef ad} } }
+
+    it "completes for objects of a subclass" do
+      class ::MyArray < Array; end
+      tab('MyArray.new.index a').should == %w{ab ad}
+    end
+
+    it "completes for objects of a subclass using its own definition" do
+      class ::MyArray < Array; end
+      complete(:method=>'MyArray#index') {|e| %w{aa ab bc} }
+      tab('MyArray.new.index a').should == %w{aa ab}
+    end
+
+    it "ignores invalid ruby" do
+      tab("[{].index a").should == []
+    end
+
+    it "with string :action copies its action" do
+      complete(:method=>"Array#fetch", :action=>"Array#index")
+      tab('[].fetch a').should == %w{ab ad}
+    end
+
+    it "with string :action copies its search" do
+      complete(:method=>"Array#fetch", :action=>"Array#index")
+      tab('[].fetch d').should == %w{cd ad}
+    end
+
+    it "with string :action and :search doesn't copy its search" do
+      complete(:method=>"Array#fetch", :action=>"Array#index", :search=>:normal)
+      tab('[].fetch d').should == []
+    end
+
+    it "with symbol :action references Rc method" do
+      Rc.module_eval %[def _fetch(input); %w{ab cd ef ad}; end ]
+      complete(:method=>"Array#fetch", :action=>:_fetch)
+      tab('[].fetch a').should == %w{ab ad}
+    end
+  end
+
+  describe "any class method" do
+    before { complete(:method=>'Date.parse') {|e| %w{12/01 03/01 01/01} } }
+
+    it "completes" do
+      tab('Date.parse 0').should == ["03/01", "01/01"]
+    end
+
+    it "completes for a subclass using inherited definition" do
+      class ::MyDate < Date; end
+      tab('MyDate.parse 0').should == ["03/01", "01/01"]
+    end
+
+    it "completes for a subclass using its own definition" do
+      class ::MyDate < Date; end
+      complete(:method=>'MyDate.parse') {|e| %w{12 03 01} }
+      tab('MyDate.parse 0').should == %w{03 01}
+    end
+
+    it "with string :action copies existing action" do
+      complete(:method=>"Date.blah", :action=>"Date.parse")
+      tab('Date.blah 0').should == ["03/01", "01/01"]
+    end
+
+    it "doesn't conflict with instance method completion" do
+      complete(:method=>'Date#parse') {|e| %w{01 02 23}}
+      tab('Date.today.parse 0').should == %w{01 02}
+    end
+  end
+
+  describe "multi argument method" do
+    before { complete(:method=>'Array#index') {|e| %w{ab cd ef ad e,e} } }
+
+    it "completes second argument" do
+      tab('[].index ab, a').should == %w{ab ad}
+    end
+
+    it "completes second argument as a symbol" do
+      tab('[].index ab, :a').should == %w{:ab :ad}
+    end
+
+    it "completes second argument as a string" do
+      tab('[].index \'ab\' , "a').should == %w{ab ad}
+    end
+
+    it "completes third argument" do
+      tab('[].index ab, zz, c').should == %w{cd}
+    end
+
+    it "completes all arguments after comma" do
+      tab('[].index ab,').should == %w{ab cd ef ad e,e}
+      tab('[].index ab, ').should == %w{ab cd ef ad e,e}
+    end
+
+    it "completes based on argument number" do
+      complete(:method=>'blah') {|e| e.argument == 2 ? %w{ab ad} : %w{ab ae} }
+      tab('blah a').should == %w{ab ae}
+      tab('blah zz, a').should == %w{ab ad}
+    end
+
+    it "can't handle a completion with a comma as a completion" do
+      tab('[].index e,').should == %w{ab cd ef ad e,e}
+    end
+  end
+
+  describe "top-level method" do
+    before { complete(:method=>'cool') {|e| %w{ab cd ef ad} } }
+
+    it "completes" do
+      complete(:method=>'cool?') {|e| [] }
+      tab('cool c').should == %w{cd}
+    end
+
+    it "completes after valid ruby" do
+      tab('nil; cool a').should == %w{ab ad}
+    end
+  end
+
+  it "with :methods completes for multiple instance methods" do
+    complete(:methods=>%w{cool ls}) {|e| %w{ab cd ef ad}}
+    tab("cool a").should == %w{ab ad}
+    tab("ls c").should == %w{cd}
+  end
+
+  it "with :methods completes for instance and class methods" do
+    complete(:methods=>%w{String#include? String.new}) {|e| %w{ab cd ef ad}}
+    tab("'blah'.include? a").should == %w{ab ad}
+    tab("String.new a").should == %w{ab ad}
+  end
+
+  it "with :search completes" do
+    complete(:method=>"blah", :search=>:anywhere) { %w{abc bcd cde} }
+    tab('blah bc').should == ['abc', 'bcd']
+  end
+
+  describe "with :class" do
+    it "completes for instance methods" do
+      complete(:method=>"blong", :class=>"Array#") { %w{ab cd ef ad} }
+      tab('[].blong a').should == %w{ab ad}
+      complete(:methods=>["bling"], :class=>"Array#") { %w{ab cd ef ad} }
+      tab('[].bling a').should == %w{ab ad}
+    end
+
+    it "that is ambiguous defaults to instance methods" do
+      complete(:method=>"blong", :class=>"Array") { %w{ab cd ef ad} }
+      tab('[].blong a').should == %w{ab ad}
+    end
+
+    it "completes for class methods" do
+      complete(:method=>"blong", :class=>"Array.") { %w{ab cd ef ad} }
+      tab('Array.blong a').should == %w{ab ad}
+      complete(:methods=>["bling"], :class=>"Array.") { %w{ab cd ef ad} }
+      tab('Array.bling a').should == %w{ab ad}
+    end
+  end
+end

data/test/mission_test.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "Mission" do
+  describe "mission" do
+    before { Bond.agent.reset }
+    it "completes" do
+      complete(:on=>/bling/) {|e| %w{ab cd fg hi}}
+      complete(:method=>'cool') {|e| [] }
+      tab('some bling f').should == %w{fg}
+    end
+
+    it "with regexp condition completes" do
+      complete(:on=>/\s*'([^']+)$/, :search=>false) {|e| %w{coco for puffs}.grep(/#{e.matched[1]}/) }
+      tab("require 'ff").should == ['puffs']
+    end
+
+    it "with non-string completions completes" do
+      complete(:on=>/.*/) { [:one,:two,:three] }
+      tab('ok ').should == %w{one two three}
+    end
+
+    it "with non-array completions completes" do
+      complete(:on=>/blah/) { 'blah' }
+      tab('blah ').should == ['blah']
+    end
+
+    it "with symbol action completes" do
+      Rc.module_eval %[def blah(input); %w{one two three}; end]
+      complete(:on=>/blah/, :action=>:blah)
+      tab('blah ').should == %w{one two three}
+    end
+
+    it "with string action completes" do
+      Rc.module_eval %[def blah(input); %w{one two three}; end]
+      complete(:on=>/blah/, :action=>'blah')
+      tab('blah ').should == %w{one two three}
+    end
+
+    it "always passes Input to action block" do
+      complete(:on=>/man/) {|e| e.should.be.is_a(Input); [] }
+      tab('man ')
+    end
+  end
+
+  it "sets binding to toplevel binding when not in irb" do
+    Mission.eval_binding = nil
+    mock_irb
+    ::IRB.CurrentContext.expects(:workspace).raises
+    Mission.eval_binding.should == ::TOPLEVEL_BINDING
+  end
+end

data/test/object_mission_test.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "ObjectMission" do
+  before { Bond.agent.reset }
+  describe "object mission" do
+    it "with default action completes" do
+      complete(:object=>"String")
+      complete(:on=>/man/) { %w{upper upster upful}}
+      tab("'man'.up").sort.should == [".upcase", ".upcase!", ".upto"]
+    end
+
+    it "with regex condition completes" do
+      complete(:object=>'Str.*') {|e| e.object.class.superclass.instance_methods(true) }
+      complete(:on=>/man/) { %w{upper upster upful}}
+      tab("'man'.unta").should == [".untaint"]
+    end
+
+    it "with explicit action completes" do
+      complete(:object=>"String") {|e| e.object.class.superclass.instance_methods(true) }
+      complete(:on=>/man/) { %w{upper upster upful}}
+      tab("'man'.unta").should == [".untaint"]
+    end
+
+    it "completes without including word break characters" do
+      complete(:object=>"Hash")
+      matches = tab("{}.f")
+      matches.size.should.be > 0
+      matches.all? {|e| !e.include?('{')}.should == true
+    end
+
+    it "completes with additional text after completion point" do
+      complete(:object=>"Object")
+      tab(':man.f blah', ':man.f').include?(':man.freeze').should == true
+    end
+
+    it "doesn't evaluate anything before the completion object" do
+      complete(:object=>'Object')
+      tab('raise :man.i').size.should > 0
+    end
+
+    it "ignores invalid ruby" do
+      complete(:object=>"String")
+      tab("blah.upt").should == []
+    end
+
+    it "ignores object that doesn't have a valid class" do
+      complete :on=>/(.*)./, :object=>'Object'
+      capture_stdout {
+        tab("obj = Object.new; def obj.class; end; obj.").should == []
+      }.should == ''
+    end
+
+    # needed to ensure Bond works in irbrc
+    it "doesn't evaluate irb binding on definition" do
+      Object.expects(:const_defined?).never
+      complete(:object=>"String")
+    end
+  end
+end