bond 0.1.4 → 0.2.0

data/lib/bond/missions/object_mission.rb

@@ -1,49 +1,46 @@
-# Represents a completion mission specified by :object in Bond.complete. Unlike other missions, this
-# one needs to both match the mission condition and have the current object being completed have
-# an ancestor specified by :object.
-class Bond::Missions::ObjectMission < Bond::Mission
+# A mission which completes an object's methods. For this mission to match,
+# the condition must match and the current object must have an ancestor that matches :object.
+# Note: To access to the current object being completed on within an action, use the input's
+# object attribute.
+#
+# ==== Bond.complete Options:
+# [*:object*] String representing a module/class of object whose methods are completed.
+# [*:action*] If an action is not specified, the default action is to complete an object's
+#             non-operator methods.
+#
+# ===== Example:
+#   Bond.complete(:object=>ActiveRecord::Base) {|input| input.object.class.instance_methods(false) }
+class Bond::ObjectMission < Bond::Mission
   #:stopdoc:
-  attr_reader :object_condition
-
+  OBJECTS = %w<\S+> + Bond::Mission::OBJECTS
+  CONDITION = '(OBJECTS)\.(\w*(?:\?|!)?)$'
   def initialize(options={})
-    @object_condition = options.delete(:object)
-    @object_condition = /^#{Regexp.escape(@object_condition.to_s)}$/ unless @object_condition.is_a?(Regexp)
-    options[:on] ||= /(\S+|[^.]+)\.([^.\s]*)$/
-    @eval_binding = options[:eval_binding]
+    @object_condition = /^#{options[:object]}$/
+    options[:on] ||= Regexp.new condition_with_objects
     super
   end
 
   def unique_id
-    "#{@object_condition.inspect}+#{@condition.inspect}"
+    "#{@object_condition.inspect}+#{@on.inspect}"
   end
 
-  def handle_valid_match(input)
-    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
+  def do_match(input)
+    super && eval_object(@matched[1]) && @evaled_object.class.respond_to?(:ancestors) &&
+      @evaled_object.class.ancestors.any? {|e| e.to_s =~ @object_condition }
   end
 
-  def eval_object(match)
-    @matched = match
-    @evaled_object = self.class.current_eval(match[1], @eval_binding)
+  def after_match(input)
+    @completion_prefix = @matched[1] + "."
+    @action ||= lambda {|e| default_action(e.object) }
+    create_input @matched[2], :object=>@evaled_object
   end
 
   def default_action(obj)
     obj.methods.map {|e| e.to_s} - OPERATORS
   end
+
+  def match_message
+    "Matches completion for object with ancestor matching #{@object_condition.inspect}."
+  end
   #:startdoc:
 end

data/lib/bond/missions/operator_method_mission.rb

@@ -0,0 +1,26 @@
+module Bond
+  # A mission which completes arguments for any module/class method that is an operator i.e. '>' or '*'.
+  # Takes same Bond.complete options as MethodMission. The only operator method this mission doesn't
+  # complete is '[]='. The operator '[]' should cover the first argument completion of '[]=' anyways.
+  class OperatorMethodMission < MethodMission
+    OPERATORS = Mission::OPERATORS - ["[]", "[]="]
+    OBJECTS = Mission::OBJECTS + %w{\S+}
+    CONDITION = %q{(OBJECTS)\s*(METHODS)\s*(['":])?(.*)$}
+
+    #:stopdoc:
+    def current_methods
+      (OPERATORS & MethodMission.action_methods) + ['[']
+    end
+
+    def matched_method
+      {'['=>'[]'}[@matched[2]] || @matched[2]
+    end
+
+    def after_match(input)
+      set_action_and_search
+      @completion_prefix, typed = input.to_s.sub(/#{Regexp.quote(@matched[-1])}$/, ''), @matched[-1]
+      create_input typed, :object=>@evaled_object, :argument=>1
+    end
+    #:startdoc:
+  end
+end

data/lib/bond/rawline.rb

@@ -1,12 +1,12 @@
 module Bond
-  # A readline plugin for use with {Rawline}[http://github.com/h3rald/rawline/tree/master]. This plugin
+  # A readline plugin for use with {Rawline}[http://github.com/h3rald/rawline]. This plugin
   # should be used in conjunction with {a Rawline shell}[http://www.h3rald.com/articles/real-world-rawline-usage].
   module Rawline
-    def setup
+    def setup(agent)
       require 'rawline'
       ::Rawline.completion_append_character = nil
       ::Rawline.basic_word_break_characters= " \t\n\"\\'`><;|&{(" 
-      ::Rawline.completion_proc = self
+      ::Rawline.completion_proc = agent
     end
 
     def line_buffer

data/lib/bond/rc.rb

@@ -0,0 +1,48 @@
+module Bond
+  # Namespace in which completion files, ~/.bondrc and ~/.bond/completions/*.rb, are evaluated. Methods in this module
+  # and Search are the DSL in completion files and can be used within completion actions.
+  #
+  # === Example ~/.bondrc
+  #   # complete arguments for any object's :respond_to?
+  #   complete(:method=>"Object#respond_to?") {|e| e.object.methods }
+  #   # complete arguments for any module's :public
+  #   complete(:method=>"Module#public") {|e| e.object.instance_methods }
+  #
+  #   # Share generate_tags action across completions
+  #   complete(:method=>"edit_tags", :action=>:generate_tags)
+  #   complete(:method=>"delete_tags", :search=>false) {|e| generate_tags(e).grep(/#{e}/i) }
+  #
+  #   def generate_tags(input)
+  #    ...
+  #   end
+  module Rc
+    extend self, Search
+
+    # See Bond.complete
+    def complete(*args, &block); M.complete(*args, &block); end
+    # See Bond.recomplete
+    def recomplete(*args, &block); M.recomplete(*args, &block); end
+
+    # Action method with search which returns array of files that match current input.
+    def files(input)
+      (::Readline::FILENAME_COMPLETION_PROC.call(input) || []).map {|f|
+        f =~ /^~/ ?  File.expand_path(f) : f
+      }
+    end
+
+    # Helper method which returns objects of a given class.
+    def objects_of(klass)
+      object = []
+      ObjectSpace.each_object(klass) {|e| object.push(e) }
+      object
+    end
+
+    # Calls eval with Mission.current_eval, rescuing any exceptions to return nil.
+    # If Bond.config[:debug] is true, exceptions are raised again.
+    def eval(str)
+      Mission.current_eval(str)
+    rescue Exception
+      raise if Bond.config[:debug]
+    end
+  end
+end

data/lib/bond/readline.rb

@@ -1,12 +1,11 @@
-
 module Bond
-  # This is the default readline plugin for Bond. A valid plugin must define methods setup() and line_buffer(). setup()
-  # should load the readline-like library and set the completion_proc. line_buffer() should give access to the full line of what
-  # the user has typed.
+  # This is the default readline plugin for Bond. A valid plugin must be a module that defines methods setup
+  # and line_buffer as described below.
   module Readline
     DefaultBreakCharacters = " \t\n\"\\'`><=;|&{("
 
-    def setup
+    # Loads the readline-like library and sets the completion_proc to the given agent.
+    def setup(agent)
       require 'readline'
       begin
         require 'readline_line_buffer'
@@ -37,9 +36,13 @@ module Bond
         ::Readline.basic_word_break_characters = DefaultBreakCharacters
       end
 
-      ::Readline.completion_proc = self
+      ::Readline.completion_proc = agent
+      if (::Readline::VERSION rescue nil).to_s[/editline/i]
+        puts "Bond has detected EditLine and may not work with it. See the README's Limitations section."
+      end
     end
 
+    # Returns full line of what the user has typed.
     def line_buffer
       ::Readline.line_buffer
     end

data/lib/bond/search.rb

@@ -1,8 +1,24 @@
 module Bond
   # Contains search methods used to filter possible completions given what the user has typed for that completion.
+  # For a search method to be used by Bond.complete it must end in '_search' and take two arguments: the Input
+  # string and an array of possible completions.
+  #
+  # ==== Creating a search method
+  # Say you want to create a custom search which ignores completions containing '-'.
+  # In a completion file under Rc namespace, define this method:
+  #   def ignore_hyphen_search(input, list)
+  #     normal_search(input, list.select {|e| e !~ /-/ })
+  #   end
+  #
+  # Now you can pass this custom search to any complete() as :search=>:ignore_hyphen
   module Search
+    class<<self
+      # Default search used across missions, set by Bond.config[:default_search]
+      attr_accessor :default_search
+    end
+
     # Searches completions from the beginning of the string.
-    def default_search(input, list)
+    def normal_search(input, list)
       list.grep(/^#{Regexp.escape(input)}/)
     end
 
@@ -16,20 +32,43 @@ module Bond
       list.grep(/^#{Regexp.escape(input)}/i)
     end
 
-    # Searches completions from the beginning but also provides aliasing of underscored words.
-    # For example 'some_dang_long_word' can be specified as 's-d-l-w'. Aliases can be any unique string
-    # at the beginning of an underscored word. For example, to choose the first completion between 'so_long' and 'so_larger',
-    # type 's-lo'.
+    # A normal_search which also provides aliasing of underscored words.
+    # For example 'some_dang_long_word' can be specified as 's_d_l_w'. Aliases can be any unique string
+    # 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)
-      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
-        }
+      if input[/_(.+)$/]
+        regex = input.split('_').map {|e| Regexp.escape(e) }.join("([^_]+)?_")
+        list.select {|e| e =~ /^#{regex}/ }
       else
-        default_search(input, list)
+        normal_search(input, list)
       end
     end
+
+    # Default search across missions to be invoked by a search that wrap another search i.e. files_search.
+    def default_search(input, list)
+      send("#{Search.default_search}_search", input, list)
+    end
+
+    # Does default_search on the given paths but only returns ones that match the input's current
+    # directory depth, determined by '/'. For example if a user has typed 'irb/c', this search returns
+    # matching paths that are one directory deep i.e. 'irb/cmd/ irb/completion.rb irb/context.rb'.
+    def files_search(input, list)
+      incremental_filter(input, list, '/')
+    end
+
+    # Does the same as files_search but for modules. A module depth is delimited by '::'.
+    def modules_search(input, list)
+      incremental_filter(input, list, '::')
+    end
+
+    # Used by files_search and modules_search.
+    def incremental_filter(input, list, delim)
+      i = 0; input.gsub(delim) {|e| i+= 1 }
+      delim_chars = delim.split('').uniq.join('')
+      current_matches, future_matches = default_search(input, list).partition {|e|
+        e[/^[^#{delim_chars}]*(#{delim}[^#{delim_chars}]+){0,#{i}}$/] }
+      (current_matches + future_matches.map {|e| e[/^(([^#{delim_chars}]*#{delim}){0,#{i+1}})/, 1] }).uniq
+    end
   end
 end

data/lib/bond/version.rb

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

data/test/agent_test.rb

@@ -1,122 +1,225 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class Bond::AgentTest < Test::Unit::TestCase
-  before(:all) {|e| Bond.debrief(:readline_plugin=>valid_readline_plugin) }
+describe "Agent" do
+  describe "#call" do
+    before { Bond.agent.reset }
 
-  context "Agent" do
-    before(:each) {|e| Bond.agent.reset }
-
-    test "chooses default mission if no missions match" do
+    it "chooses default mission if no missions match" do
       complete(:on=>/bling/) {|e| [] }
-      Bond.agent.default_mission.expects(:execute)
-      tabtab 'blah'
+      Bond.agent.default_mission.expects(:execute).with {|e| e.is_a?(Input) }
+      tab 'blah'
     end
 
-    test "chooses default mission if internal processing fails" do
+    it "for internal Bond error completes error" do
       complete(:on=>/bling/) {|e| [] }
-      Bond.agent.expects(:find_mission).raises
-      Bond.agent.default_mission.expects(:execute)
-      tabtab('bling')
+      Bond.agent.expects(:find_mission).raises('wtf')
+      errors = tab('bling')
+      errors[0].should =~ /Bond Error: Failed internally.*'wtf'/
+      errors[1].should =~ /Please/
     end
 
-    test "completes in middle of line" do
-      complete(:object=>"Object")
-      tabtab(':man.f blah', ':man.f').include?(':man.freeze').should == true
+    def complete_error(msg)
+      lambda {|e|
+        e[0].should =~ msg
+        e[1].should =~ /Completion Info: Matches.*blah/
+      }
     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']
+    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
 
-    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']
+    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.*(eval)/)
+    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
 
-  context "complete" do
-    test "prints error if no action given" do
-      capture_stderr { complete :on=>/blah/ }.should =~ /Invalid mission/
+  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
 
-    test "prints error if no condition given" do
-      capture_stderr { complete {|e| []} }.should =~ /Invalid mission/
+    it "with invalid :on prints error" do
+      complete_prints_error(/Invalid :on/, :on=>'blah') { [] }
     end
 
-    test "prints error if invalid condition given" do
-      capture_stderr { complete(:on=>'blah') {|e| []} }.should =~ /Invalid mission/
+    it "with internal failure prints error" do
+      Mission.expects(:create).raises(RuntimeError, 'blah')
+      complete_prints_error(/Unexpected error.*blah/, :on=>/blah/) { [] }
     end
 
-    test "prints error if invalid symbol action given" do
-      capture_stderr { complete(:on=>/blah/, :action=>:bling) }.should =~ /Invalid mission action/
+    it "with invalid :anywhere and :prefix prints no error" do
+      complete_prints_error(/^$/, :prefix=>nil, :anywhere=>:blah) {}
     end
 
-    test "prints error if setting mission fails unpredictably" do
-      Bond::Mission.expects(:create).raises(RuntimeError)
-      capture_stderr { complete(:on=>/blah/) {|e| [] } }.should =~ /Mission setup failed/
+    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 :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
 
-  context "recomplete" do
-    before(:each) {|e| Bond.agent.reset }
+  describe "recomplete" do
+    before {|e| Bond.agent.reset }
 
-    test "recompletes a mission" do
-      Bond.complete(:on=>/man/) { %w{1 2 3}}
+    it "recompletes a mission" do
+      complete(:on=>/man/) { %w{1 2 3}}
       Bond.recomplete(:on=>/man/) { %w{4 5 6}}
-      tabtab('man ').should == %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
 
-    test "recompletes a method mission" do
-      Bond.complete(:method=>'blah') { %w{1 2 3}}
+    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}}
-      tabtab('blah ').should == %w{4 5 6}
+      tab('blah ').should == %w{4 5 6}
     end
 
-    test "recompletes an object mission" do
-      Bond.complete(:object=>'String') { %w{1 2 3}}
+    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}}
-      tabtab('"blah".').should == %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
 
-    test "prints error if no existing mission" do
-      Bond.complete(:object=>'String') { %w{1 2 3}}
+    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/
-      tabtab('[].').should == []
+      tab('[].').should == []
     end
 
-    test "prints error if invalid condition given" do
-      capture_stderr { Bond.recomplete}.should =~ /Invalid mission/
+    it "prints error if invalid condition given" do
+      capture_stderr { Bond.recomplete}.should =~ /Invalid :action/
     end
   end
 
-  context "spy" do
-    before(:all) {
-      Bond.reset; complete(:on=>/end$/) { [] }; complete(:method=>'the') { %w{spy who loved me} }
+  describe "spy" do
+    before_all {
+      M.reset; complete(:on=>/end$/) { [] };
+      complete(:all_methods=>true); complete(:method=>'the') { %w{spy who loved me} }
       complete(:object=>"Symbol")
     }
 
-    test "detects basic mission" do
+    it "detects basic mission" do
       capture_stdout { Bond.spy('the end')}.should =~ /end/
     end
 
-    test "detects object mission" do
+    it "detects object mission" do
       capture_stdout { Bond.spy(':dude.i')}.should =~ /object.*Symbol.*dude\.id/m
     end
 
-    test "detects method mission" do
-      capture_stdout { Bond.spy('the ')}.should =~ /method.*the.*loved/m
+    it "detects method mission" do
+      capture_stdout { Bond.spy('the ')}.should =~ /method.*the.*Kernel.*loved/m
     end
 
-    test "detects no mission" do
+    it "detects no mission" do
       capture_stdout { Bond.spy('blah')}.should =~ /Doesn't match/
     end
   end
-end
+end