bond 0.1.4 → 0.2.0

data/test/mission_test.rb

@@ -1,65 +1,51 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Bond::MissionTest < Test::Unit::TestCase
-  before(:all) {|e| Bond.debrief(:readline_plugin=>valid_readline_plugin) }
-
-  context "mission" do
-    before(:each) {|e| Bond.agent.reset }
-    test "completes" do
+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| [] }
-      tabtab('some bling f').should == %w{fg}
-    end
-
-    test "with method completes" do
-      complete(:on=>/bling/) {|e| [] }
-      complete(:method=>'cool') {|e| %w{ab cd ef gd} }
-      tabtab('cool c').should == %w{cd}
-    end
-
-    test "with method and quoted argument completes" do
-      complete(:on=>/bling/) {|e| [] }
-      complete(:method=>'cool') {|e| %w{ab cd ef ad} }
-      tabtab('cool "a').should == %w{ab ad}
+      tab('some bling f').should == %w{fg}
     end
 
-    test "with string method completes exact matches" do
-      complete(:method=>'cool?') {|e| [] }
-      complete(:method=>'cool') {|e| %w{ab cd ef gd} }
-      tabtab('cool c').should == %w{cd}
+    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
 
-    test "with regex method completes multiple methods" do
-      complete(:method=>/cool|ls/) {|e| %w{ab cd ef ad}}
-      tabtab("cool a").should == %w{ab ad}
-      tabtab("ls c").should == %w{cd}
+    it "with non-string completions completes" do
+      complete(:on=>/.*/) { [:one,:two,:three] }
+      tab('ok ').should == %w{one two three}
     end
 
-    test "with regexp condition completes" do
-      complete(:on=>/\s*'([^']+)$/, :search=>false) {|e| %w{coco for puffs}.grep(/#{e.matched[1]}/) }
-      tabtab("require 'ff").should == ['puffs']
+    it "with non-array completions completes" do
+      complete(:on=>/blah/) { 'blah' }
+      tab('blah ').should == ['blah']
     end
 
-    test "with non-string completions completes" do
-      complete(:on=>/.*/) { [:one,:two,:three] }
-      tabtab('ok ').should == %w{one two three}
+    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
 
-    test "with symbol action completes" do
-      eval %[module ::Bond::Actions; def blah(input); %w{one two three}; end; end]
-      complete(:method=>'blah', :action=>:blah)
-      tabtab('blah ').should == %w{one two three}
+    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
 
-    test "with invalid action prints error" do
-      complete(:on=>/bling/) {|e| raise "whoops" }
-      capture_stderr { tabtab('bling') }.should =~ /bling.*whoops/m
+    it "always passes Input to action block" do
+      complete(:on=>/man/) {|e| e.should.be.is_a(Input); [] }
+      tab('man ')
     end
   end
 
-  test "default_mission set to a valid mission if irb doesn't exist" do
-    Object.expects(:const_defined?).with(:IRB).returns(false)
-    mission = Bond::Missions::DefaultMission.new
-    mission.action.respond_to?(:call).should == true
+  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

@@ -1,63 +1,59 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Bond::ObjectMissionTest < Test::Unit::TestCase
-  before(:all) {|e| Bond.debrief(:readline_plugin=>valid_readline_plugin) }
-  before(:each) {|e| Bond.agent.reset }
-  context "object mission" do
-    test "with default action completes" do
+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}}
-      tabtab("'man'.u").should == [".upcase!", ".unpack", ".untaint", ".upcase", ".upto"]
+      tab("'man'.up").sort.should == [".upcase", ".upcase!", ".upto"]
     end
 
-    test "with regex condition completes" do
-      complete(:object=>/Str/) {|e| e.object.class.superclass.instance_methods(true) }
+    it "with regex condition completes" do
+      complete(:object=>'Str.*') {|e| e.object.class.superclass.instance_methods(true) }
       complete(:on=>/man/) { %w{upper upster upful}}
-      tabtab("'man'.u").should == [".untaint"]
+      tab("'man'.unta").should == [".untaint"]
     end
 
-    test "with explicit action completes" do
+    it "with explicit action completes" do
       complete(:object=>"String") {|e| e.object.class.superclass.instance_methods(true) }
       complete(:on=>/man/) { %w{upper upster upful}}
-      tabtab("'man'.u").should == [".untaint"]
+      tab("'man'.unta").should == [".untaint"]
     end
 
-    test "completes without including word break characters" do
+    it "completes without including word break characters" do
       complete(:object=>"Hash")
-      matches = tabtab("{}.f")
-      assert matches.size > 0
+      matches = tab("{}.f")
+      matches.size.should.be > 0
       matches.all? {|e| !e.include?('{')}.should == true
     end
 
-    test "completes nil, false and range objects" do
+    it "completes with additional text after completion point" do
       complete(:object=>"Object")
-      assert tabtab("nil.f").size > 0
-      assert tabtab("false.f").size > 0
-      assert tabtab("(1..10).f").size > 0
+      tab(':man.f blah', ':man.f').include?(':man.freeze').should == true
     end
 
-    test "completes hashes and arrays with spaces" do
-      complete(:object=>"Object")
-      assert tabtab("[1, 2].f").size > 0
-      assert tabtab("{:a =>1}.f").size > 0
+    it "doesn't evaluate anything before the completion object" do
+      complete(:object=>'Object')
+      tab('raise :man.i').size.should > 0
     end
 
-    test "ignores invalid invalid ruby" do
+    it "ignores invalid ruby" do
       complete(:object=>"String")
-      tabtab("blah.upt").should == []
+      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
-    test "doesn't evaluate irb binding on definition" do
+    it "doesn't evaluate irb binding on definition" do
       Object.expects(:const_defined?).never
       complete(:object=>"String")
     end
-
-    test "sets binding to toplevel binding when not in irb" do
-      Object.expects(:const_defined?).with(:IRB).returns(false)
-      mission = Bond::Mission.create(:object=>'Symbol')
-      mission.class.expects(:eval).with(anything, ::TOPLEVEL_BINDING)
-      mission.matches?(':ok.')
-    end
   end
 end

data/test/operator_method_mission_test.rb

@@ -0,0 +1,66 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "operator method mission" do
+  before_all { MethodMission.reset }
+  before { Bond.agent.reset; Bond.complete(:all_operator_methods=>true) }
+
+  describe "operator" do
+    before { complete(:method=>"Hash#[]") { %w{ab cd ae} } }
+
+    it "completes" do
+      tab('{}[a').should == ["}[ab", "}[ae"]
+    end
+
+    it "completes quoted argument" do
+      tab('{:a=>1}["a').should == %w{ab ae}
+    end
+
+    it "completes symbolic argument" do
+      tab('{}[:a').should == ["}[:ab", "}[:ae"]
+    end
+
+    it "completes with no space between method and argument" do
+      tab('{}[a').should == ["}[ab", "}[ae"]
+    end
+
+    it "completes with space between method and argument" do
+      tab('{}[ a').should == ["ab", "ae"]
+    end
+
+    it "completes with operator characters in object" do
+      tab('{:a=> 1}[').should == ["1}[ab", "1}[cd", "1}[ae"]
+    end
+
+    it "completes all arguments with only space as argument" do
+      tab('{}[ ').should == ["ab", "cd", "ae"]
+    end
+
+    it "completes with a chain of objects" do
+      tab('Hash.new[a').should == %w{Hash.new[ab Hash.new[ae}
+    end
+
+    it "completes in middle of line" do
+      tab('nil; {}[a').should == ["}[ab", "}[ae"]
+    end
+
+    it "doesn't complete for multiple arguments" do
+      tab('{}[a,').should == []
+    end
+  end
+
+  it "operator with space between object and method completes" do
+    complete(:method=>"Array#*") { %w{ab cd ae} }
+    tab('[1,2] * a').should == %w{ab ae}
+    tab('[1,2] *a').should == %w{*ab *ae}
+  end
+
+  it "class operator completes" do
+    complete(:method=>"Hash.*") { %w{ab cd ae} }
+    tab('Hash * a').should == %w{ab ae}
+  end
+
+  it "with :search completes" do
+    complete(:method=>"Array#*", :search=>:anywhere) { %w{abc bcd cde} }
+    tab('[1, 2] * b').should == ['abc', 'bcd']
+  end
+end

data/test/search_test.rb

@@ -1,55 +1,132 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Bond::SearchTest < Test::Unit::TestCase
-  before(:all) {|e| Bond.debrief(:readline_plugin=>valid_readline_plugin) }
-  before(:each) {|e| Bond.agent.reset }
+describe "Search" do
+  before { Bond.agent.reset }
 
-  context "mission with search" do
-    test "false completes" do
+  describe "mission with search" do
+    it "false completes" do
       complete(:on=>/cool '(.*)/, :search=>false) {|e| %w{coco for puffs}.grep(/#{e.matched[1]}/) }
-      tabtab("cool 'ff").should == ['puffs']
+      tab("cool 'ff").should == ['puffs']
     end
     
-    test "proc completes" do
-      complete(:method=>'blah', :search=>proc {|input, list| list.grep(/#{input}/)}) {|e| %w{coco for puffs} }
-      tabtab("blah 'ff").should == ['puffs']
+    it "defined in Rc completes" do
+      Rc.module_eval %q{def coco_search(input, list); list.grep(/#{input}/); end }
+      complete(:on=>/blah/, :search=>:coco) {|e| %w{coco for puffs} }
+      tab("blah ff").should == ['puffs']
     end
 
-    test ":anywhere completes" do
-      complete(:method=>'blah', :search=>:anywhere) {|e| %w{coco for puffs} }
-      tabtab("blah 'ff").should == ['puffs']
+    it ":anywhere completes" do
+      complete(:on=>/blah/, :search=>:anywhere) {|e| %w{coco for puffs} }
+      tab("blah ff").should == ['puffs']
     end
 
-    test ":ignore_case completes" do
-      complete(:method=>'blah', :search=>:ignore_case) {|e| %w{Coco For PufFs} }
-      tabtab("blah 'pu").should == ['PufFs']
+    it ":ignore_case completes" do
+      complete(:on=>/blah/, :search=>:ignore_case) {|e| %w{Coco For PufFs} }
+      tab("blah pu").should == ['PufFs']
     end
 
-    test ":underscore completes" do
+    it ":underscore completes" do
       complete(:on=>/blah/, :search=>:underscore) {|e| %w{and_one big_two can_three} }
-      tabtab("blah and").should == ['and_one']
-      tabtab("blah b-t").should == ['big_two']
+      tab("blah and").should == ['and_one']
+      tab("blah b_t").should == ['big_two']
     end
   end
 
-  test "underscore search doesn't pick up strings starting with __" do
+  it "underscore search doesn't pick up strings starting with __" do
     completions = ["include?", "instance_variable_defined?", "__id__", "include_and_exclude?"]
-    complete(:method=>'blah', :search=>:underscore) { completions }
-    tabtab("blah i").should == ["include?", "instance_variable_defined?", "include_and_exclude?"]
+    complete(:on=>/blah/, :search=>:underscore) { completions }
+    tab("blah i").should == ["include?", "instance_variable_defined?", "include_and_exclude?"]
   end
 
-  test "underscore search can match first unique strings of each underscored word" do
+  it "underscore search can match first unique strings of each underscored word" do
     completions = %w{so_long so_larger so_louder}
-    complete(:method=>'blah', :search=>:underscore) { completions }
-    tabtab("blah s-lo").should == %w{so_long so_louder}
-    tabtab("blah s-lou").should == %w{so_louder}
+    complete(:on=>/blah/, :search=>:underscore) { completions }
+    tab("blah s_lo").should == %w{so_long so_louder}
+    tab("blah s_lou").should == %w{so_louder}
   end
 
-  test "search handles completions with regex characters" do
+  it "underscore search acts normal if ending in underscore" do
+    complete(:on=>/blah/, :search=>:underscore) {|e| %w{and_one big_two can_three ander_one} }
+    tab("blah and_").should == %w{and_one}
+  end
+
+  it "search handles completions with regex characters" do
     completions = ['[doh]', '.*a', '?ok']
     complete(:on=>/blah/) { completions }
-    tabtab('blah .').should == ['.*a']
-    tabtab('blah [').should == ['[doh]']
-    tabtab('blah ?').should == ['?ok']
+    tab('blah .').should == ['.*a']
+    tab('blah [').should == ['[doh]']
+    tab('blah ?').should == ['?ok']
+  end
+
+  it "default search uses default search" do
+    Search.default_search.should == :underscore
+    Rc.expects(:underscore_search).with('a', %w{ab cd})
+    Rc.send(:default_search, 'a', %w{ab cd})
+  end
+
+  describe "modules search" do
+    before {
+      complete(:on=>/blah/, :search=>:modules) { %w{A1 M1::Z M1::Y::X M2::X} }
+    }
+    it "completes all modules" do
+      tab('blah ').should == ["A1", "M1::", "M2::"]
+    end
+
+    it "completes single first level module" do
+      tab('blah A').should == %w{A1}
+    end
+
+    it "completes single first level module parent" do
+      tab('blah M2').should == %w{M2::}
+    end
+
+    it "completes all second level modules" do
+      tab('blah M1::').should == %w{M1::Z M1::Y::}
+    end
+
+    it "completes second level module parent" do
+      tab('blah M1::Y').should == %w{M1::Y::}
+    end
+
+    it "completes third level module" do
+      tab('blah M1::Y::').should == %w{M1::Y::X}
+    end
+  end
+
+  describe "files search" do
+    before {
+      complete(:on=>/rm/, :search=>:files) { %w{a1 d1/f2 d1/d2/f1 d2/f1 d2/f1/ /f1} }
+    }
+    it "completes all paths" do
+      tab('rm ').should == %w{a1 d1/ d2/ /}
+    end
+
+    it "completes single first level file" do
+      tab('rm a').should == %w{a1}
+    end
+
+    it "completes single first level directory" do
+      tab('rm d2').should == %w{d2/}
+    end
+
+    it "completes all second level paths" do
+      tab('rm d1/').should == %w{d1/f2 d1/d2/}
+    end
+
+    it "completes single second level directory" do
+      tab('rm d1/d2').should == %w{d1/d2/}
+    end
+
+    it "completes single third level file" do
+      tab('rm d1/d2/').should == %w{d1/d2/f1}
+    end
+
+    it "completes file and directory with same name" do
+      tab('rm d2/f').should == %w{d2/f1 d2/f1/}
+    end
+
+    it "completes file with full path" do
+      tab('rm /f').should == %w{/f1}
+    end
   end
 end

data/test/test_helper.rb

@@ -1,14 +1,12 @@
-require 'rubygems'
-require 'test/unit'
-require 'context' #gem install jeremymcanally-context -s http://gems.github.com
-require 'matchy' #gem install jeremymcanally-matchy -s http://gems.github.com
+require 'bacon'
+require File.dirname(__FILE__)+'/bacon_extensions'
 require 'mocha'
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'mocha-on-bacon'
 require 'bond'
 
-class Test::Unit::TestCase
-  before(:all) {
-    # Mock irb
+module TestHelpers
+  extend self
+  def mock_irb
     unless Object.const_defined?(:IRB)
       eval %[
         module ::IRB
@@ -18,7 +16,7 @@ class Test::Unit::TestCase
       ]
       ::IRB.CurrentContext = stub(:workspace=>stub(:binding=>binding))
     end
-  }
+  end
 
   def capture_stderr(&block)
     original_stderr = $stderr
@@ -42,8 +40,8 @@ class Test::Unit::TestCase
     fake.string
   end
 
-  def tabtab(full_line, last_word=full_line)
-    Bond.agent.stubs(:line_buffer).returns(full_line)
+  def tab(full_line, last_word=full_line)
+    Bond.agent.weapon.stubs(:line_buffer).returns(full_line)
     Bond.agent.call(last_word)
   end
 
@@ -52,6 +50,15 @@ class Test::Unit::TestCase
   end
 
   def valid_readline_plugin
-    Module.new{ def setup; end; def line_buffer; end }
+    Module.new{ def setup(arg); end; def line_buffer; end }
   end
-end
+end
+
+class Bacon::Context
+  include TestHelpers
+  include BaconExtensions
+end
+
+# Default settings
+Bond::M.debrief(:readline_plugin=>TestHelpers.valid_readline_plugin, :debug=>true)
+include Bond