bond 0.1.1 → 0.1.3

data/CHANGELOG.rdoc

@@ -1,3 +1,14 @@
+== 0.1.3
+* Fixing deployment mistake
+
+== 0.1.2
+* Added bond/completion which is a drop-in enhancement of irb/completion
+* Added ability to define predefined actions in Bond::Actions
+* Fixed underscore search bug
+* Fixed word breaking completion bug
+* Fixed irb's completion inconsistencies
+* Added ability to specify :default_search for Bond.debrief
+* Added placement of completions with :place for Bond.complete
 == 0.1.1
 * Added Bond.spy to debug completions
 * Fixed object completion failing in irbrc

data/README.rdoc

@@ -15,6 +15,15 @@ Install the gem with:
 
 == Usage
 
+To start of with, you may want to replace irb's completion (irb/completion) with Bond's enhanced version
+in your irbrc :
+
+  require 'bond'
+  require 'bond/completion'
+
+This should give you more consistent method completion on any objects, file completion of strings
+and argument completion of Kernel#require, Kernel#system and the backtick (`).
+
 === Argument Completion for Methods
 
     bash> irb -rirb/completion -rubygems
@@ -179,12 +188,8 @@ which Bond uses to read Readline's full buffer. Thanks also goes out to Takao Ko
 commiting}[http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/ext/readline/readline.c?view=diff&r1=24018&r2=24019]
 this Readline enhancement to ruby.
 
-== Bugs
-The underscore search intermittently doesn't complete when it should and deletes the last
-character typed.
+== Links
+* http://tagaholic.me/2009/07/16/bond-from-irb-with-completion-love.html
 
 == Todo
-* Allow Bond to easily get its completion missions from a module.
-* Provide a set of Bond completions which can serve as a drop-in replacement for irb/completion.
-* Argument autocompletion by object class.
-* Make replacement of existing completions not require doing a Bond.reset.
+* Allow usage of prefined Bond::Actions in action procs.

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 1
-:patch: 1
+:patch: 3

data/lib/bond.rb

@@ -4,6 +4,7 @@ require 'bond/readline'
 require 'bond/rawline'
 require 'bond/agent'
 require 'bond/search'
+require 'bond/actions'
 require 'bond/mission'
 require 'bond/missions/default_mission'
 require 'bond/missions/method_mission'
@@ -16,8 +17,8 @@ require 'bond/missions/object_mission'
 # * Bond can work outside of irb and readline when debriefed with Bond.debrief. This should be called before any Bond.complete calls.
 # * Bond doesn't take over completion until an explicit Bond.complete is called.
 # * Order of completion missions matters. The order they're defined in is the order Bond searches
-#   when looking for a matching completion. This means that you should probably declare general
-#   completions at the end.
+#   when looking for a matching completion. This means that more specific completions like method and object completions should come
+#   before more general ones. You can tweak completion placement by passing :place to Bond.complete.
 # * If no completion missions match, then Bond falls back on a default mission. If using irb and irb/completion
 #   this falls back on irb's completion. Otherwise an empty completion list is returned.
 module Bond
@@ -41,11 +42,15 @@ module Bond
   #           traditional searching i.e. looking at the beginning of a string for possible matches. If false, search is turned off and
   #           assumed to be done in the action block. Possible symbols are :anywhere, :ignore_case and :underscore. See Bond::Search for
   #           more info about them. A proc is given two arguments: the input string and an array of possible completions.
+  # [:place] Given a symbol or number, controls where this completion is placed in relation to existing ones. If a number, the
+  #          completion is placed at that number. If the symbol :last, the completion is placed at the end regardless of completions
+  #          defined after it. Use this symbol as a way of anchoring completions you want to remain at the end. Multiple declarations
+  #          of :last are kept last in the order they are defined.
   #
   # ==== Examples:
   #  Bond.complete(:method=>'shoot') {|input| %w{to kill} }
   #  Bond.complete(:on=>/^((([a-z][^:.\(]*)+):)+/, :search=>false) {|input| Object.constants.grep(/#{input.matched[1]}/) }
-  #  Bond.complete(:object=>ActiveRecord::Base, :search=>:underscore)
+  #  Bond.complete(:object=>ActiveRecord::Base, :search=>:underscore, :place=>:last)
   #  Bond.complete(:object=>ActiveRecord::Base) {|input| input.object.class.instance_methods(false) }
   #  Bond.complete(:method=>'you', :search=>proc {|input, list| list.grep(/#{input}/i)} ) {|input| %w{Only Live Twice} }
   def complete(options={}, &block)
@@ -54,6 +59,9 @@ module Bond
   rescue InvalidMissionError
     $stderr.puts "Invalid mission given. Mission needs an action and a condition."
     false
+  rescue InvalidMissionActionError
+    $stderr.puts "Invalid mission action given. Make sure action responds to :call or refers to a predefined action that does."
+    false
   rescue
     $stderr.puts "Mission setup failed with:", $!
     false
@@ -71,9 +79,13 @@ module Bond
   #                    Defaults to Bond::Readline. Note that a plugin doesn't imply use with irb. Irb is joined to the hip with Readline.
   # [:default_mission] A proc to be used as the default completion proc when no completions match or one fails. When in irb with completion
   #                    enabled, uses irb completion. Otherwise defaults to a proc with an empty completion list.
+  # [:default_search] A symbol or proc to be used as the default search in completions. See Bond.complete's :search option for valid symbols.
   # [:eval_binding] Specifies a binding to be used with Bond::Missions::ObjectMission. When in irb, defaults to irb's main binding. Otherwise
   #                 defaults to TOPLEVEL_BINDING.
   # [:debug]  Boolean to print unexpected errors when autocompletion fails. Default is false.
+  #
+  # ==== Example:
+  #   Bond.debrief :default_search=>:underscore, :default_mission=>:default
   def debrief(options={})
     config.merge! options
     plugin_methods = %w{setup line_buffer}
@@ -85,6 +97,10 @@ module Bond
 
   # Reports what completion mission and possible completions would happen for a given input. Helpful for debugging
   # your completion missions.
+  # ==== Example:
+  #   >> Bond.spy "shoot oct"
+  #   Matches completion mission for method matching "shoot".
+  #   Possible completions: ["octopussy"]
   def spy(input)
     agent.spy(input)
   end

data/lib/bond/actions.rb

@@ -0,0 +1,65 @@
+module Bond
+  # Namespace for mission actions.
+  module Actions
+    ReservedWords = [
+      "BEGIN", "END", "alias", "and", "begin", "break", "case", "class", "def", "defined", "do", "else", "elsif", "end", "ensure",
+      "false", "for", "if", "in", "module", "next", "nil", "not", "or", "redo", "rescue", "retry", "return", "self", "super",
+      "then", "true", "undef", "unless", "until", "when", "while", "yield"
+    ]
+
+    # Helper function for evaluating strings in the current console binding.
+    def current_eval(string)
+      Missions::ObjectMission.current_eval(string)
+    rescue Exception
+      nil
+    end
+
+    # Completes backtick and Kernel#system with shell commands available in ENV['PATH']
+    def shell_commands(input)
+      ENV['PATH'].split(File::PATH_SEPARATOR).uniq.map {|e| Dir.entries(e) }.flatten.uniq - ['.', '..']
+    end
+
+    # Default completion for non-irb console and bond/completion
+    def default(input)
+      current_eval("methods | private_methods | local_variables | self.class.constants") | ReservedWords
+    end
+
+    # File completion
+    def files(input)
+      (::Readline::FILENAME_COMPLETION_PROC.call(input) || []).map {|f|
+        f =~ /^~/ ?  File.expand_path(f) : f
+      }
+    end
+
+    def quoted_files(input) #:nodoc:
+      files(input.matched[1])
+    end
+
+    def constants(input) #:nodoc:
+      receiver = input.matched[1]
+      candidates = current_eval("#{receiver}.constants | #{receiver}.methods")
+      candidates.grep(/^#{Regexp.escape(input.matched[4])}/).map {|e| receiver + "::" + e}
+    end
+
+    # Completes Kernel#require
+    def method_require(input)
+      fs = ::File::SEPARATOR
+      extensions_regex = /((\.(so|dll|rb|bundle))|#{fs})$/i
+      input =~ /^(\.{0,2}#{fs}|~)/ and return files(input).select {|f| f =~ extensions_regex or File.directory? f }
+      dir_entries = proc {|dir| Dir.entries(dir).delete_if {|e| %w{. ..}.include?(e) }.map {|f|
+         File.directory?(File.join(dir,f)) ? f+fs : f } }
+      input_regex = /^#{Regexp.escape(input)}/
+
+      $:.select {|e| File.directory?(e)}.inject([]) do |t,dir|
+        if input[/.$/] == fs && File.directory?(File.join(dir,input))
+          matches = dir_entries.call(File.join(dir,input)).select {|e| e =~ extensions_regex }.map {|e| input + e }
+        else
+          entries = input.include?(fs) && File.directory?(File.join(dir,File.dirname(input))) ?
+           dir_entries.call(File.join(dir,File.dirname(input))).map {|e| File.join(File.dirname(input), e) } : dir_entries.call(dir)
+          matches = entries.select {|e| e=~ extensions_regex && e =~ input_regex }
+        end
+        t += matches
+      end
+    end
+  end
+end

data/lib/bond/agent.rb

@@ -9,18 +9,27 @@ module Bond
       extend(options[:readline_plugin])
       @default_mission_action = options[:default_mission] if options[:default_mission]
       @eval_binding = options[:eval_binding] if options[:eval_binding]
+      Mission.default_search = options[:default_search] if options[:default_search]
       setup
       @missions = []
     end
 
     def complete(options={}, &block) #:nodoc:
-      @missions << Mission.create(options.merge(:action=>block, :eval_binding=>@eval_binding))
+      options[:action] ||= block
+      mission = Mission.create(options.merge(:eval_binding=>@eval_binding))
+      mission.place.is_a?(Integer) ? @missions.insert(mission.place - 1, mission).compact! : @missions << mission
+      @missions.replace @missions.partition {|e| e.place != :last }.flatten
+    end
+
+    def reset #:nodoc:
+      @missions = []
     end
 
     # This is where the action starts when a completion is initiated.
     def call(input)
-      # Use line_buffer instead of input since it's more info
-      (mission = find_mission(line_buffer)) ? mission.execute : default_mission.execute(input)
+      mission_input = line_buffer
+      mission_input = $1 if mission_input !~ /#{Regexp.escape(input)}$/ && mission_input =~ /^(.*#{Regexp.escape(input)})/
+      (mission = find_mission(mission_input)) ? mission.execute : default_mission.execute(input)
     rescue FailedExecutionError
       $stderr.puts "", $!.message
     rescue

data/lib/bond/completion.rb

@@ -0,0 +1,28 @@
+# You shouldn't place Bond.complete statements before requiring this file
+# unless you're also reproducing this Bond.debrief
+Bond.debrief(:default_search=>:underscore) unless Bond.config[:default_search]
+Bond.debrief(:default_mission=>:default) unless Bond.config[:default_mission]
+Bond.complete(:method=>/system|`/, :action=>:shell_commands)
+Bond.complete(:method=>'require', :action=>:method_require, :search=>false)
+
+# irb/completion reproduced without the completion quirks
+# Completes classes and constants
+Bond.complete(:on=>/(((::)?[A-Z][^:.\(]*)+)::?([^:.]*)$/, :action=>:constants, :search=>false)
+# Completes absolute constants
+Bond.complete(:on=>/::([A-Z][^:\.\(]*)$/, :search=>false) {|e|
+  Object.constants.grep(/^#{Regexp.escape(e.matched[1])}/).collect{|f| "::" + f}
+}
+# Completes symbols
+Bond.complete(:on=>/(:[^:\s.]*)$/) {|e|
+  Symbol.respond_to?(:all_symbols) ? Symbol.all_symbols.map {|f| ":#{f}" } : []
+}
+# Completes global variables
+Bond.complete(:on=>/(\$[^\s.]*)$/, :search=>false) {|e|
+  global_variables.grep(/^#{Regexp.escape(e.matched[1])}/)
+}
+# Completes files
+Bond.complete(:on=>/\s+["']([^'"]*)$/, :search=>false, :action=>:quoted_files, :place=>:last)
+# Completes any object's methods
+Bond.complete(:object=>"Object", :place=>:last)
+# Completes method completion anywhere in the line
+Bond.complete(:on=>/([^.\s]+)\.([^.\s]*)$/, :object=>"Object", :place=>:last)

data/lib/bond/mission.rb

@@ -1,6 +1,8 @@
 module Bond
   # Occurs when a mission is incorrectly defined.
   class InvalidMissionError < StandardError; end
+  # Occurs when a mission action is incorrectly defined.
+  class InvalidMissionActionError < StandardError; end
   # Occurs when a mission or search action fails.
   class FailedExecutionError < StandardError; end
   # Namespace for subclasses of Bond::Mission.
@@ -10,18 +12,40 @@ module Bond
   class Mission
     include Search
 
-    # Handles creation of proper Mission class depending on the options passed.
-    def self.create(options)
-      if options[:method]
-        Missions::MethodMission.new(options)
-      elsif options[:object]
-        Missions::ObjectMission.new(options)
-      else
-        new(options)
+    class<<self
+      # default search used across missions
+      attr_accessor :default_search
+      # Handles creation of proper Mission class depending on the options passed.
+      def create(options)
+        if options[:method]
+          Missions::MethodMission.new(options)
+        elsif options[:object]
+          Missions::ObjectMission.new(options)
+        else
+          new(options)
+        end
       end
+      #:stopdoc:
+      def action_object
+        @action_object ||= Object.new.extend(Actions)
+      end
+
+      def current_eval(string, eval_binding=nil)
+        eval_binding ||= default_eval_binding
+        eval(string, eval_binding)
+      end
+
+      def default_eval_binding
+        Object.const_defined?(:IRB) ? IRB.CurrentContext.workspace.binding : ::TOPLEVEL_BINDING
+      end
+
+      def default_search
+        @default_search ||= :default
+      end
+      #:startdoc:
     end
 
-    attr_reader :action, :condition
+    attr_reader :action, :condition, :place
     OPERATORS = ["%", "&", "*", "**", "+",  "-",  "/", "<", "<<", "<=", "<=>", "==", "===", "=~", ">", ">=", ">>", "[]", "[]=", "^"]
 
     # Options are almost the same as those explained at Bond.complete. The only difference is that the action is passed
@@ -30,14 +54,18 @@ module Bond
       raise InvalidMissionError unless (options[:action] || respond_to?(:default_action)) &&
         (options[:on] || is_a?(Missions::DefaultMission))
       raise InvalidMissionError if options[:on] && !options[:on].is_a?(Regexp)
-      @action = options[:action]
+      @action = options[:action].is_a?(Symbol) && self.class.action_object.respond_to?(options[:action]) ?
+        self.class.action_object.method(options[:action]) : options[:action]
+      raise InvalidMissionActionError if @action && !@action.respond_to?(:call)
       @condition = options[:on]
-      @search = options.has_key?(:search) ? options[:search] : method(:default_search)
-      @search = method("#{options[:search]}_search") if respond_to?("#{options[:search]}_search")
+      @place = options[:place]
+      @search = options.has_key?(:search) ? options[:search] : Mission.default_search
+      @search = method("#{@search}_search") unless @search.is_a?(Proc) || @search == false
     end
 
     # Returns a boolean indicating if a mission matches the given input.
     def matches?(input)
+      @matched = @input = @list_prefix = nil
       if (match = handle_valid_match(input))
         @input.instance_variable_set("@matched", @matched)
         @input.instance_eval("def self.matched; @matched ; end")
@@ -46,14 +74,15 @@ module Bond
     end
 
     # Called when a mission has been chosen to autocomplete.
-    def execute(*args)
-      if args.empty?
-        list = (@action.call(@input) || []).map {|e| e.to_s }
-        list = @search ? @search.call(@input || '', list) : list
-        @list_prefix ? list.map {|e| @list_prefix + e } : list
-      else
-        @action.call(*args)
+    def execute(input=@input)
+      completions = @action.call(input)
+      completions = (completions || []).map {|e| e.to_s }
+      completions =  @search.call(input || '', completions) if @search
+      if @completion_prefix
+        @completion_prefix = @completion_prefix.split(Regexp.union(*Readline::DefaultBreakCharacters.split('')))[-1]
+        completions = completions.map {|e| @completion_prefix + e }
       end
+      completions
     rescue
       error_message = "Mission action failed to execute properly. Check your mission action with pattern #{@condition.inspect}.\n" +
         "Failed with error: #{$!.message}"

data/lib/bond/missions/default_mission.rb

@@ -6,6 +6,6 @@ class Bond::Missions::DefaultMission < Bond::Mission
   end
 
   def default_action #:nodoc:
-    Object.const_defined?(:IRB) && IRB.const_defined?(:InputCompletor) ? IRB::InputCompletor::CompletionProc : lambda {|e| [] }
+    Object.const_defined?(:IRB) && IRB.const_defined?(:InputCompletor) ? IRB::InputCompletor::CompletionProc : :default
   end
 end

data/lib/bond/missions/method_mission.rb

@@ -3,7 +3,7 @@ class Bond::Missions::MethodMission < Bond::Mission
   attr_reader :method_condition
   def initialize(options={}) #:nodoc:
     @method_condition = options.delete(:method)
-    @method_condition = Regexp.quote(@method_condition.to_s) unless @method_condition.is_a?(Regexp)
+    @method_condition = Regexp.escape(@method_condition.to_s) unless @method_condition.is_a?(Regexp)
     options[:on] = /^\s*(#{@method_condition})\s*['"]?(.*)$/
     super
   end

data/lib/bond/missions/object_mission.rb

@@ -7,41 +7,39 @@ class Bond::Missions::ObjectMission < Bond::Mission
 
   def initialize(options={})
     @object_condition = options.delete(:object)
-    @object_condition = /^#{Regexp.quote(@object_condition.to_s)}$/ unless @object_condition.is_a?(Regexp)
-    options[:on] = /^((\.?[^.]+)+)\.([^.]*)$/
+    @object_condition = /^#{Regexp.escape(@object_condition.to_s)}$/ unless @object_condition.is_a?(Regexp)
+    options[:on] ||= /(\S+|[^.]+)\.([^.\s]*)$/
     @eval_binding = options[:eval_binding]
     super
   end
 
   def handle_valid_match(input)
-    match = super
-    if match && eval_object(match) && (match = @evaled_object.class.ancestors.any? {|e| e.to_s =~ @object_condition })
-      @list_prefix = @matched[1] + "."
-      @input = @matched[3]
-      @input.instance_variable_set("@object", @evaled_object)
-      @input.instance_eval("def self.object; @object ; end")
-      @action ||= lambda {|e| default_action(e.object) }
-    else
-      match = false
+    if (match = super)
+      begin
+        eval_object(match)
+      rescue Exception
+        return false
+      end
+      if (match = @evaled_object.class.ancestors.any? {|e| e.to_s =~ @object_condition })
+        @completion_prefix = @matched[1] + "."
+        @input = @matched[2]
+        @input.instance_variable_set("@object", @evaled_object)
+        @input.instance_eval("def self.object; @object ; end")
+        @action ||= lambda {|e| default_action(e.object) }
+      else
+        match = false
+      end
     end
     match
   end
 
   def eval_object(match)
     @matched = match
-    @evaled_object = begin eval("#{match[1]}", eval_binding); rescue Exception; nil end
+    @evaled_object = self.class.current_eval(match[1], @eval_binding)
   end
 
   def default_action(obj)
     obj.methods.map {|e| e.to_s} - OPERATORS
   end
-
-  def eval_binding
-    @eval_binding ||= default_eval_binding
-  end
-
-  def default_eval_binding
-    Object.const_defined?(:IRB) ? IRB.CurrentContext.workspace.binding : ::TOPLEVEL_BINDING
-  end
   #:startdoc:
 end

data/lib/bond/search.rb

@@ -21,10 +21,15 @@ module Bond
     # at the beginning of an underscored word. For example, to choose the first completion between 'so_long' and 'so_larger',
     # type 's-lo'.
     def underscore_search(input, list)
-      split_input = input.split("-").join("")
-      list.select {|c|
-        c.split("_").map {|g| g[0,1] }.join("") =~ /^#{Regexp.escape(split_input)}/ || c =~ /^#{Regexp.escape(input)}/
-      }
+      if input.include?("-")
+        index = 0
+        input.split('-').inject(list) {|new_list,e|
+          new_list = new_list.select {|f| f.split(/_+/)[index] =~ /^#{Regexp.escape(e)}/ };
+          index +=1; new_list
+        }
+      else
+        default_search(input, list)
+      end
     end
   end
 end

data/test/agent_test.rb

@@ -3,51 +3,49 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 class Bond::AgentTest < Test::Unit::TestCase
   before(:all) {|e| Bond.debrief(:readline_plugin=>valid_readline_plugin) }
 
-  context "InvalidAgent" do
-    test "prints error if no action given for mission" do
-      capture_stderr { Bond.complete :on=>/blah/ }.should =~ /Invalid mission/
-    end
-
-    test "prints error if no condition given" do
-      capture_stderr { Bond.complete {|e| []} }.should =~ /Invalid mission/
-    end
-  
-    test "prints error if invalid condition given" do
-      capture_stderr { Bond.complete(:on=>'blah') {|e| []} }.should =~ /Invalid mission/
-    end
-    
-    test "prints error if setting mission fails unpredictably" do
-      Bond.agent.expects(:complete).raises(ArgumentError)
-      capture_stderr { Bond.complete(:on=>/blah/) {|e| [] } }.should =~ /Mission setup failed/
-    end
-  end
-
   context "Agent" do
-    before(:each) {|e| Bond.agent.instance_eval("@missions = []") }
+    before(:each) {|e| Bond.agent.reset }
 
     test "chooses default mission if no missions match" do
-      Bond.complete(:on=>/bling/) {|e| [] }
+      complete(:on=>/bling/) {|e| [] }
       Bond.agent.default_mission.expects(:execute)
-      complete 'blah'
+      tabtab 'blah'
     end
 
     test "chooses default mission if internal processing fails" do
-      Bond.complete(:on=>/bling/) {|e| [] }
+      complete(:on=>/bling/) {|e| [] }
       Bond.agent.expects(:find_mission).raises
       Bond.agent.default_mission.expects(:execute)
-      complete('bling')
+      tabtab('bling')
+    end
+
+    test "completes in middle of line" do
+      complete(:object=>"Object")
+      tabtab(':man.f blah', ':man.f').include?(':man.freeze').should == true
+    end
+
+    test "places missions last when declared last" do
+      complete(:object=>"Symbol", :place=>:last)
+      complete(:method=>"man", :place=>:last) { }
+      complete(:on=>/man\s*(.*)/) {|e| e.matched[1] }
+      Bond.agent.missions.map {|e| e.class}.should == [Bond::Mission, Bond::Missions::ObjectMission, Bond::Missions::MethodMission]
+      tabtab('man ok').should == ['ok']
     end
 
-    test "prints error if action generates failure" do
-      Bond.complete(:on=>/bling/) {|e| raise "whoops" }
-      capture_stderr { complete('bling') }.should =~ /bling.*whoops/m
+    test "places mission correctly for a place number" do
+      complete(:object=>"Symbol")
+      complete(:method=>"man") {}
+      complete(:on=>/man\s*(.*)/, :place=>1) {|e| e.matched[1] }
+      tabtab('man ok')
+      Bond.agent.missions.map {|e| e.class}.should == [Bond::Mission, Bond::Missions::ObjectMission, Bond::Missions::MethodMission]
+      tabtab('man ok').should == ['ok']
     end
   end
 
   context "spy" do
     before(:all) {
-      Bond.reset; Bond.complete(:on=>/end$/) { [] }; Bond.complete(:method=>'the') { %w{spy who loved me} }
-      Bond.complete(:object=>"Symbol")
+      Bond.reset; complete(:on=>/end$/) { [] }; complete(:method=>'the') { %w{spy who loved me} }
+      complete(:object=>"Symbol")
     }
 
     test "detects basic mission" do

data/test/bond_test.rb

@@ -11,19 +11,51 @@ class BondTest < Test::Unit::TestCase
       capture_stderr {Bond.debrief :readline_plugin=>Module.new{ def setup; end } }.should =~ /Invalid/
     end
 
-    test "no error if valid readline_plugin" do
+    test "prints no error if valid readline_plugin" do
       capture_stderr {Bond.debrief :readline_plugin=>valid_readline_plugin }.should == ''
     end
 
     test "sets default mission" do
-      default_mission = lambda {}
+      default_mission = lambda { %w{1 2 3}}
+      Bond.reset
       Bond.debrief :default_mission=>default_mission, :readline_plugin=>valid_readline_plugin
-      Bond.agent.default_mission.action.should == default_mission
+      tabtab('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
+    end
+  end
+
+  context "complete" do
+    test "prints error if no action given" do
+      capture_stderr { complete :on=>/blah/ }.should =~ /Invalid mission/
+    end
+
+    test "prints error if no condition given" do
+      capture_stderr { complete {|e| []} }.should =~ /Invalid mission/
+    end
+
+    test "prints error if invalid condition given" do
+      capture_stderr { complete(:on=>'blah') {|e| []} }.should =~ /Invalid mission/
+    end
+
+    test "prints error if invalid symbol action given" do
+      capture_stderr { complete(:on=>/blah/, :action=>:bling) }.should =~ /Invalid mission action/
+    end
+
+    test "prints error if setting mission fails unpredictably" do
+      Bond.agent.expects(:complete).raises(ArgumentError)
+      capture_stderr { complete(:on=>/blah/) {|e| [] } }.should =~ /Mission setup failed/
     end
   end
 
   test "reset clears existing missions" do
-    Bond.complete(:on=>/blah/) {[]}
+    complete(:on=>/blah/) {[]}
     Bond.agent.missions.size.should_not == 0
     Bond.reset
     Bond.agent.missions.size.should == 0

data/test/completion_test.rb

@@ -0,0 +1,38 @@
+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' }
+
+  test "completes object methods anywhere" do
+    matches = tabtab("blah :man.")
+    assert matches.size > 0
+    assert matches.all? {|e| e=~ /^:man/}
+  end
+
+  test "completes global variables anywhere" do
+    matches = tabtab("blah $-")
+    assert matches.size > 0
+    assert matches.all? {|e| e=~ /^\$-/}
+  end
+
+  test "completes absolute constants anywhere" do
+    tabtab("blah ::Arr").should == ["::Array"]
+  end
+
+  test "completes nested classes anywhere" do
+    tabtab("blah IRB::In").should == ["IRB::InputCompletor"]
+  end
+
+  test "completes symbols anywhere" do
+    Symbol.expects(:all_symbols).returns([:mah])
+    assert tabtab("blah :m").size > 0
+  end
+
+  test "completes string methods anywhere" do
+    tabtab("blah 'man'.f").include?('.freeze').should == true
+  end
+
+  test "methods don't swallow up default completion" do
+    Bond.agent.find_mission("Bond.complete(:method=>'blah') { Arr").should == nil
+  end
+end

data/test/mission_test.rb

@@ -4,45 +4,56 @@ class Bond::MissionTest < Test::Unit::TestCase
   before(:all) {|e| Bond.debrief(:readline_plugin=>valid_readline_plugin) }
 
   context "mission" do
-    before(:each) {|e| Bond.agent.instance_eval("@missions = []") }
+    before(:each) {|e| Bond.agent.reset }
     test "completes" do
-      Bond.complete(:on=>/bling/) {|e| %w{ab cd fg hi}}
-      Bond.complete(:method=>'cool') {|e| [] }
-      complete('some bling f').should == %w{fg}
+      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
-      Bond.complete(:on=>/bling/) {|e| [] }
-      Bond.complete(:method=>'cool') {|e| %w{ab cd ef gd} }
-      complete('cool c').should == %w{cd}
+      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
-      Bond.complete(:on=>/bling/) {|e| [] }
-      Bond.complete(:method=>'cool') {|e| %w{ab cd ef ad} }
-      complete('cool "a').should == %w{ab ad}
+      complete(:on=>/bling/) {|e| [] }
+      complete(:method=>'cool') {|e| %w{ab cd ef ad} }
+      tabtab('cool "a').should == %w{ab ad}
     end
 
     test "with string method completes exact matches" do
-      Bond.complete(:method=>'cool?') {|e| [] }
-      Bond.complete(:method=>'cool') {|e| %w{ab cd ef gd} }
-      complete('cool c').should == %w{cd}
+      complete(:method=>'cool?') {|e| [] }
+      complete(:method=>'cool') {|e| %w{ab cd ef gd} }
+      tabtab('cool c').should == %w{cd}
     end
 
     test "with regex method completes multiple methods" do
-      Bond.complete(:method=>/cool|ls/) {|e| %w{ab cd ef ad}}
-      complete("cool a").should == %w{ab ad}
-      complete("ls c").should == %w{cd}
+      complete(:method=>/cool|ls/) {|e| %w{ab cd ef ad}}
+      tabtab("cool a").should == %w{ab ad}
+      tabtab("ls c").should == %w{cd}
     end
 
     test "with regexp condition completes" do
-      Bond.complete(:on=>/\s*'([^']+)$/, :search=>false) {|e| %w{coco for puffs}.grep(/#{e.matched[1]}/) }
-      complete("require 'ff").should == ['puffs']
+      complete(:on=>/\s*'([^']+)$/, :search=>false) {|e| %w{coco for puffs}.grep(/#{e.matched[1]}/) }
+      tabtab("require 'ff").should == ['puffs']
     end
 
     test "with non-string completions completes" do
-      Bond.complete(:on=>/.*/) { [:one,:two,:three] }
-      complete('ok ').should == %w{one two three}
+      complete(:on=>/.*/) { [:one,:two,:three] }
+      tabtab('ok ').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}
+    end
+
+    test "with invalid action prints error" do
+      complete(:on=>/bling/) {|e| raise "whoops" }
+      capture_stderr { tabtab('bling') }.should =~ /bling.*whoops/m
     end
   end
 

data/test/object_mission_test.rb

@@ -2,42 +2,62 @@ 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.instance_eval("@missions = []") }
+  before(:each) {|e| Bond.agent.reset }
   context "object mission" do
     test "with default action completes" do
-      Bond.complete(:object=>"String")
-      Bond.complete(:on=>/man/) { %w{upper upster upful}}
-      complete("'man'.u").should == ["'man'.upcase!", "'man'.unpack", "'man'.untaint", "'man'.upcase", "'man'.upto"]
+      complete(:object=>"String")
+      complete(:on=>/man/) { %w{upper upster upful}}
+      tabtab("'man'.u").should == [".upcase!", ".unpack", ".untaint", ".upcase", ".upto"]
     end
 
     test "with regex condition completes" do
-      Bond.complete(:object=>/Str/) {|e| e.object.class.superclass.instance_methods(true) }
-      Bond.complete(:on=>/man/) { %w{upper upster upful}}
-      complete("'man'.u").should == ["'man'.untaint"]
+      complete(:object=>/Str/) {|e| e.object.class.superclass.instance_methods(true) }
+      complete(:on=>/man/) { %w{upper upster upful}}
+      tabtab("'man'.u").should == [".untaint"]
     end
 
     test "with explicit action completes" do
-      Bond.complete(:object=>"String") {|e| e.object.class.superclass.instance_methods(true) }
-      Bond.complete(:on=>/man/) { %w{upper upster upful}}
-      complete("'man'.u").should == ["'man'.untaint"]
+      complete(:object=>"String") {|e| e.object.class.superclass.instance_methods(true) }
+      complete(:on=>/man/) { %w{upper upster upful}}
+      tabtab("'man'.u").should == [".untaint"]
+    end
+
+    test "completes without including word break characters" do
+      complete(:object=>"Hash")
+      matches = tabtab("{}.f")
+      assert matches.size > 0
+      matches.all? {|e| !e.include?('{')}.should == true
+    end
+
+    test "completes nil, false and range objects" do
+      complete(:object=>"Object")
+      assert tabtab("nil.f").size > 0
+      assert tabtab("false.f").size > 0
+      assert tabtab("(1..10).f").size > 0
+    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
     end
 
     test "ignores invalid invalid ruby" do
-      Bond.complete(:object=>"String")
-      complete("blah.upt").should == []
+      complete(:object=>"String")
+      tabtab("blah.upt").should == []
     end
 
     # needed to ensure Bond works in irbrc
     test "doesn't evaluate irb binding on definition" do
       Object.expects(:const_defined?).never
-      Bond.complete(:object=>"String")
+      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.')
-      mission.eval_binding.should == ::TOPLEVEL_BINDING
     end
   end
 end

data/test/search_test.rb

@@ -2,41 +2,54 @@ 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.instance_eval("@missions = []") }
+  before(:each) {|e| Bond.agent.reset }
 
   context "mission with search" do
     test "false completes" do
-      Bond.complete(:on=>/cool '(.*)/, :search=>false) {|e| %w{coco for puffs}.grep(/#{e.matched[1]}/) }
-      complete("cool 'ff").should == ['puffs']
+      complete(:on=>/cool '(.*)/, :search=>false) {|e| %w{coco for puffs}.grep(/#{e.matched[1]}/) }
+      tabtab("cool 'ff").should == ['puffs']
     end
     
     test "proc completes" do
-      Bond.complete(:method=>'blah', :search=>proc {|input, list| list.grep(/#{input}/)}) {|e| %w{coco for puffs} }
-      complete("blah 'ff").should == ['puffs']
+      complete(:method=>'blah', :search=>proc {|input, list| list.grep(/#{input}/)}) {|e| %w{coco for puffs} }
+      tabtab("blah 'ff").should == ['puffs']
     end
 
     test ":anywhere completes" do
-      Bond.complete(:method=>'blah', :search=>:anywhere) {|e| %w{coco for puffs} }
-      complete("blah 'ff").should == ['puffs']
+      complete(:method=>'blah', :search=>:anywhere) {|e| %w{coco for puffs} }
+      tabtab("blah 'ff").should == ['puffs']
     end
 
     test ":ignore_case completes" do
-      Bond.complete(:method=>'blah', :search=>:ignore_case) {|e| %w{Coco For PufFs} }
-      complete("blah 'pu").should == ['PufFs']
+      complete(:method=>'blah', :search=>:ignore_case) {|e| %w{Coco For PufFs} }
+      tabtab("blah 'pu").should == ['PufFs']
     end
 
     test ":underscore completes" do
-      Bond.complete(:on=>/blah/, :search=>:underscore) {|e| %w{and_one big_two can_three} }
-      complete("blah and").should == ['and_one']
-      complete("blah b-t").should == ['big_two']
+      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']
     end
   end
 
+  test "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?"]
+  end
+
+  test "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}
+  end
+
   test "search handles completions with regex characters" do
     completions = ['[doh]', '.*a', '?ok']
-    Bond.complete(:on=>/blah/) { completions }
-    complete('blah .').should == ['.*a']
-    complete('blah [').should == ['[doh]']
-    complete('blah ?').should == ['?ok']
+    complete(:on=>/blah/) { completions }
+    tabtab('blah .').should == ['.*a']
+    tabtab('blah [').should == ['[doh]']
+    tabtab('blah ?').should == ['?ok']
   end
 end

data/test/test_helper.rb

@@ -42,13 +42,16 @@ class Test::Unit::TestCase
     fake.string
   end
 
-  def complete(full_line, last_word=full_line)
+  def tabtab(full_line, last_word=full_line)
     Bond.agent.stubs(:line_buffer).returns(full_line)
     Bond.agent.call(last_word)
   end
 
+  def complete(*args, &block)
+    Bond.complete(*args, &block)
+  end
+
   def valid_readline_plugin
     Module.new{ def setup; end; def line_buffer; end }
   end
-end
-
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: bond
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors: 
 - Gabriel Horner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-17 00:00:00 -04:00
+date: 2009-07-22 00:00:00 -04:00
 default_executable: 
 dependencies: []
 
@@ -31,7 +31,9 @@ files:
 - ext/readline_line_buffer/extconf.rb
 - ext/readline_line_buffer/readline_line_buffer.c
 - lib/bond.rb
+- lib/bond/actions.rb
 - lib/bond/agent.rb
+- lib/bond/completion.rb
 - lib/bond/mission.rb
 - lib/bond/missions/default_mission.rb
 - lib/bond/missions/method_mission.rb
@@ -41,6 +43,7 @@ files:
 - lib/bond/search.rb
 - test/agent_test.rb
 - test/bond_test.rb
+- test/completion_test.rb
 - test/mission_test.rb
 - test/object_mission_test.rb
 - test/search_test.rb
@@ -76,6 +79,7 @@ summary: "Mission: Easy custom autocompletion for arguments, methods and beyond.
 test_files: 
 - test/agent_test.rb
 - test/bond_test.rb
+- test/completion_test.rb
 - test/mission_test.rb
 - test/object_mission_test.rb
 - test/search_test.rb