bond 0.1.4 → 0.2.0

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").should == ["$LOAD_PATH", "$LOADED_FEATURES"]
+  end
+
+  it 'with :prefix completes' do
+    complete(:prefix=>'_', :anywhere=>':[^:\s.]*') { %w{:ab :bd :ae} }
+    tab("_:a").should == %w{_:ab _:ae}
+  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/bond_test.rb

@@ -1,40 +1,55 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class BondTest < Test::Unit::TestCase
-  context "debrief" do
-    before(:each) {|e| Bond.instance_eval("@agent = @config = nil")}
-    test "prints error if readline_plugin is not a module" do
-      capture_stderr { Bond.debrief :readline_plugin=>false }.should =~ /Invalid/
+describe "Bond" do
+  describe "start" do
+    before { M.instance_eval("@agent = @config = nil"); M.expects(:load_completions) }
+    it "prints error if readline_plugin is not a module" do
+      capture_stderr { Bond.start :readline_plugin=>false }.should =~ /Invalid/
     end
     
-    test "prints error if readline_plugin doesn't have all required methods" do
-      capture_stderr {Bond.debrief :readline_plugin=>Module.new{ def setup; end } }.should =~ /Invalid/
+    it "prints error if readline_plugin doesn't have all required methods" do
+      capture_stderr {Bond.start :readline_plugin=>Module.new{ def setup(arg); end } }.should =~ /Invalid/
     end
 
-    test "prints no error if valid readline_plugin" do
-      capture_stderr {Bond.debrief :readline_plugin=>valid_readline_plugin }.should == ''
+    it "prints no error if valid readline_plugin" do
+      capture_stderr {Bond.start :readline_plugin=>valid_readline_plugin }.should == ''
     end
 
-    test "sets default mission" do
-      default_mission = lambda { %w{1 2 3}}
-      Bond.reset
-      Bond.debrief :default_mission=>default_mission, :readline_plugin=>valid_readline_plugin
-      tabtab('1').should == ['1']
+    it "sets default mission" do
+      Bond.start :default_mission=>lambda {|e| %w{1 2 3}}, :readline_plugin=>valid_readline_plugin
+      tab('1').should == ['1']
     end
 
-    test "sets default search" do
-      Bond.reset
-      Bond.debrief :default_search=>:underscore
-      complete(:method=>'blah') { %w{all_quiet on_the western_front}}
-      tabtab('blah a-q').should == ["all_quiet"]
-      Bond.reset
+    it "sets default search" do
+      Bond.start :default_search=>:anywhere, :readline_plugin=>valid_readline_plugin
+      complete(:on=>/blah/) { %w{all_quiet on_the western_front}}
+      tab('blah qu').should == ["all_quiet"]
     end
+
+    it "defines completion in block" do
+      Bond.start do
+        complete(:on=>/blah/) { %w{all_quiet on_the western_front}}
+      end
+      tab('blah all').should == ["all_quiet"]
+    end
+    after_all { M.debrief :readline_plugin=>valid_readline_plugin; M.reset }
+  end
+
+  it "prints error if Readline setup fails" do
+    Bond::Readline.expects(:setup).raises('WTF')
+    capture_stderr { Bond.start(:readline_plugin=>Bond::Readline) }.should =~ /Error.*Failed Readline.*'WTF'/
+    M.debrief :readline_plugin=>valid_readline_plugin
+  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
 
-  test "reset clears existing missions" do
+  it "reset clears existing missions" do
     complete(:on=>/blah/) {[]}
-    Bond.agent.missions.size.should_not == 0
-    Bond.reset
+    Bond.agent.missions.size.should.not == 0
+    M.reset
     Bond.agent.missions.size.should == 0
   end
 end

data/test/completion_test.rb

@@ -1,38 +1,140 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Bond::CompletionTest < Test::Unit::TestCase
-  before(:all) { Bond.reset; Bond.debrief(:readline_plugin=>valid_readline_plugin); require 'bond/completion' }
+describe "Completion" do
+  before_all {
+    M.reset
+    M.load_file File.dirname(__FILE__) + '/../lib/bond/completion.rb'
+    M.load_dir File.dirname(__FILE__) + '/../lib/bond'
+  }
 
-  test "completes object methods anywhere" do
-    matches = tabtab("blah :man.")
-    assert matches.size > 0
-    assert matches.all? {|e| e=~ /^:man/}
+  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
 
-  test "completes global variables anywhere" do
-    matches = tabtab("blah $-")
-    assert matches.size > 0
-    assert matches.all? {|e| e=~ /^\$-/}
+  it "completes absolute constants anywhere" do
+    tab("blah ::Arr").should == ["::Array"]
+    tab("h[::Arr").should == ["h[::Array"]
   end
 
-  test "completes absolute constants anywhere" do
-    tabtab("blah ::Arr").should == ["::Array"]
+  it "completes invalid constants safely" do
+    capture_stdout {
+      tab("Bond::MethodMission ").should == []
+    }.should == ''
   end
 
-  test "completes nested classes anywhere" do
-    tabtab("blah IRB::In").should == ["IRB::InputCompletor"]
+  it "completes nested classes anywhere" do
+    mock_irb
+    tab("blah IRB::In").should == ["IRB::InputCompletor"]
   end
 
-  test "completes symbols anywhere" do
-    Symbol.expects(:all_symbols).returns([:mah])
-    assert tabtab("blah :m").size > 0
+  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
 
-  test "completes string methods anywhere" do
-    tabtab("blah 'man'.f").include?('.freeze').should == true
+  it "completes method arguments with parenthesis" do
+    tab("%w{ab bc cd}.delete(").should == %w{ab bc cd}
   end
 
-  test "methods don't swallow up default completion" do
-    Bond.agent.find_mission("Bond.complete(:method=>'blah') { Arr").should == nil
+  it "completes hash coming from a method" do
+    tab('Bond.config[:r').should == ["Bond.config[:readline_plugin"]
+  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

data/test/completions_test.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+describe "completions for" do
+  before_all {
+    M.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").should == %w{Errno::ETIMEDOUT Errno::ETIME}
+    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
+      tab("[].instance_of? Arr").should == ['Array']
+    end
+
+    it "#is_a?" do
+      tab("Module.is_a? Mod").should == ['Module']
+    end
+
+    it "#send" do
+      tab("Object.send :super").should == [':superclass']
+    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/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