bond 0.4.2-java

data/lib/bond/missions/anywhere_mission.rb

@@ -0,0 +1,15 @@
+# A mission which completes anywhere i.e. even after non word break characters
+# such as '[' or '}'.  With options :prefix and :anywhere, this mission matches
+# on the following regexp condition /:prefix?(:anywhere)$/ and passes the first
+# capture group to the mission action.
+class Bond::AnywhereMission < Bond::Mission
+  def initialize(options={}) #@private
+    options[:on] = Regexp.new("#{options[:prefix]}(#{options[:anywhere]})$")
+    super
+  end
+
+  def after_match(input) #@private
+    @completion_prefix = input.to_s.sub(/#{Regexp.escape(@matched[1])}$/, '')
+    create_input @matched[1]
+  end
+end

data/lib/bond/missions/default_mission.rb

@@ -0,0 +1,21 @@
+# This is the mission called when none of the others match.
+class Bond::DefaultMission < Bond::Mission
+  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"
+  ]
+
+
+  # Default action which generates methods, private methods, reserved words, local variables and constants.
+  def self.completions(input=nil)
+    Bond::Mission.current_eval("methods | private_methods | local_variables | " +
+                               "self.class.constants | instance_variables") | ReservedWords
+  end
+
+  def initialize(options={}) #@private
+    options[:action] ||= self.class.method(:completions)
+    super
+  end
+  def default_on; end #@private
+end

data/lib/bond/missions/method_mission.rb

@@ -0,0 +1,197 @@
+module Bond
+  # A mission which completes arguments for any module/class method that isn't an operator method.
+  # To create this mission or OperatorMethodMission, :method or :methods must be passed to Bond.complete.
+  # A completion for a given module/class effects any object that has it as an ancestor. If an object
+  # has two ancestors that have completions for the same method, the ancestor closer to the object is
+  # picked. For example, if Array#collect and Enumerable#collect have completions, argument completion on
+  # '[].collect ' would use Array#collect.
+  #
+  # ==== Bond.complete Options:
+  # [:action] If a string, value is assumed to be a :method and that method's action is copied.
+  #           Otherwise defaults to normal :action behavior.
+  # [:search] If :action is a :method string, defaults to copying its search.
+  #           Otherwise defaults to normal :search behavior.
+  # [:name, :place] These options aren't supported by a MethodMission/OperatorMethodMission completion.
+  # ==== Examples:
+  #   Bond.complete(:methods => %w{delete index rindex}, :class => "Array#") {|e| e.object }
+  #   Bond.complete(:method => "Hash#index") {|e| e.object.values }
+  #
+  # ==== Argument Format
+  # All method arguments can autocomplete as symbols or strings and the first argument can be prefixed
+  # with '(':
+  #   >> Bond.complete(:method => 'example') { %w{some example eh} }
+  #   => true
+  #   >> example '[TAB]
+  #   eh    example    some
+  #   >> example :[TAB]
+  #   :eh   :example   :some
+  #
+  #  >> example("[TAB]
+  #   eh    example    some
+  #
+  # ==== Multiple Arguments
+  # Every time a comma appears after a method, Bond starts a new completion. This allows a method to
+  # complete multiple arguments as well as complete keys for a hash. *Each* argument can be have a unique
+  # set of completions since a completion action is aware of what argument it is currently completing:
+  #   >> Bond.complete(:method => 'FileUtils.chown') {|e|
+  #        e.argument > 3 ? %w{noop verbose} : %w{root admin me} }
+  #   => true
+  #   >> FileUtils.chown 'r[TAB]
+  #   >> FileUtils.chown 'root'
+  #   >> FileUtils.chown 'root', 'a[TAB]
+  #   >> FileUtils.chown 'root', 'admin'
+  #   >> FileUtils.chown 'root', 'admin', 'some_file', :v[TAB]
+  #   >> FileUtils.chown 'root', 'admin', 'some_file', :verbose
+  #   >> FileUtils.chown 'root', 'admin', 'some_file', :verbose => true
+  #
+  # ==== Developer Notes
+  # Unlike other missions, creating these missions with Bond.complete doesn't add more completion rules
+  # for an Agent to look through. Instead, all :method(s) completions are handled by one MethodMission
+  # object which looks them up with its own hashes. In the same way, all operator methods are
+  # handled by one OperatorMethodMission object.
+  class MethodMission < Bond::Mission
+  class<<self
+    # Hash of instance method completions which maps methods to hashes of modules to arrays ([action, search])
+    attr_accessor :actions
+    # Same as :actions but for class methods
+    attr_accessor :class_actions
+    # Stores last search result from MethodMission.find
+    attr_accessor :last_find
+    # Stores class from last search in MethodMission.find
+    attr_accessor :last_class
+
+    # Creates a method action given the same options as Bond.complete
+    def create(options)
+      if options[:action].is_a?(String)
+        klass, klass_meth = split_method(options[:action])
+        if (arr = (current_actions(options[:action])[klass_meth] || {})[klass])
+          options[:action], options[:search] = [arr[0], options[:search] || arr[1]]
+        else
+          raise InvalidMissionError, "string :action"
+        end
+      end
+
+      raise InvalidMissionError, "array :method" if options[:method].is_a?(Array)
+      meths = options[:methods] || Array(options[:method])
+      raise InvalidMissionError, "non-string :method(s)" unless meths.all? {|e| e.is_a?(String) }
+      if options[:class].is_a?(String)
+        options[:class] << '#' unless options[:class][/[#.]$/]
+        meths.map! {|e| options[:class] + e }
+      end
+
+      meths.each {|meth|
+        klass, klass_meth = split_method(meth)
+        (current_actions(meth)[klass_meth] ||= {})[klass] = [options[:action], options[:search]].compact
+      }
+      nil
+    end
+
+    # Resets all instance and class method actions.
+    def reset
+      @actions = {}
+      @class_actions = {}
+    end
+
+    # Lists method names
+    def action_methods
+      (actions.keys + class_actions.keys).uniq
+    end
+
+    # Lists full method names, prefixed with class/module
+    def all_methods
+      (class_actions.map {|m,h| h.map {|k,v| "#{k}.#{m}" } } +
+        actions.map {|m,h| h.map {|k,v| "#{k}##{m}" } }).flatten.sort
+    end
+
+    # Returns the first completion by looking up the object's ancestors and finding the closest
+    # one that has a completion definition for the given method. Completion is returned
+    # as an array containing action proc and optional search to go with it.
+    def find(obj, meth)
+      last_find = find_with(obj, meth, :<=, @class_actions) if obj.is_a?(Module)
+      last_find = find_with(obj, meth, :is_a?, @actions) unless last_find
+      @last_class = last_find.is_a?(Array) ? last_find[0] : nil
+      @last_find = last_find ? last_find[1] : last_find
+    end
+
+    # Returns a constant like Module#const_get no matter what namespace it's nested in.
+    # Returns nil if the constant is not found.
+    def any_const_get(name)
+      return name if name.is_a?(Module)
+      klass = Object
+      name.split('::').each {|e| klass = klass.const_get(e) }
+      klass
+    rescue
+       nil
+    end
+
+    protected
+    def current_actions(meth)
+      meth.include?('.') ? @class_actions : @actions
+    end
+
+    def split_method(meth)
+      meth = "Kernel##{meth}" if !meth.to_s[/[.#]/]
+      meth.split(/[.#]/,2)
+    end
+
+    def find_with(obj, meth, find_meth, actions)
+      (actions[meth] || {}).select {|k,v| get_class(k) }.
+        sort {|a,b| get_class(a[0]) <=> get_class(b[0]) || -1 }.
+        find {|k,v| obj.send(find_meth, get_class(k)) }
+    end
+
+    def get_class(klass)
+      (@klasses ||= {})[klass] ||= any_const_get(klass)
+    end
+  end
+
+  self.reset
+  OBJECTS = Mission::OBJECTS + %w{\S*?}
+  CONDITION = %q{(OBJECTS)\.?(METHODS)(?:\s+|\()(['":])?(.*)$}
+
+  def match_message #@private
+    "Matches completion for method '#{@meth}' in '#{MethodMission.last_class}'."
+  end
+
+  protected
+  def do_match(input)
+    (@on = default_on) && super && eval_object(@matched[1] ? @matched[1] : 'self') &&
+      MethodMission.find(@evaled_object, @meth = matched_method)
+  end
+
+  def default_on
+    Regexp.new condition_with_objects.sub('METHODS',Regexp.union(*current_methods).to_s)
+  end
+
+  def current_methods
+    self.class.action_methods - OPERATORS
+  end
+
+  def default_action
+    MethodMission.last_find[0]
+  end
+
+  def matched_method
+    @matched[2]
+  end
+
+  def set_action_and_search
+    @action = default_action
+    @search = MethodMission.last_find[1] || Search.default_search
+  end
+
+  def after_match(input)
+    set_action_and_search
+    @completion_prefix, typed = @matched[3], @matched[-1]
+    input_options = {:object => @evaled_object, :argument => 1+typed.count(','),
+      :arguments => (@completion_prefix.to_s+typed).split(/\s*,\s*/) }
+    if typed.to_s.include?(',') && (match = typed.match(/(.*?\s*)([^,]*)$/))
+      typed = match[2]
+      typed.sub!(/^(['":])/,'')
+      @completion_prefix = typed.empty? ? '' : "#{@matched[3]}#{match[1]}#{$1}"
+    end
+    create_input typed, input_options
+  end
+
+  end
+end

data/lib/bond/missions/object_mission.rb

@@ -0,0 +1,44 @@
+# 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:
+# [: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
+  OBJECTS = %w<\S+> + Bond::Mission::OBJECTS
+  CONDITION = '(OBJECTS)\.(\w*(?:\?|!)?)$'
+  def initialize(options={}) #@private
+    @object_condition = /^#{options[:object]}$/
+    options[:on] ||= Regexp.new condition_with_objects
+    super
+  end
+
+  def match_message #@private
+    "Matches completion for object with ancestor matching #{@object_condition.inspect}."
+  end
+
+  protected
+  def unique_id
+    "#{@object_condition.inspect}+#{@on.inspect}"
+  end
+
+  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 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
+end

data/lib/bond/missions/operator_method_mission.rb

@@ -0,0 +1,27 @@
+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*(['":])?(.*)$}
+
+    protected
+    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
+  end
+end

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

@@ -0,0 +1,38 @@
+# This is the default readline plugin for Bond. A valid plugin must be an object
+# that responds to methods setup and line_buffer as described below.
+class Bond::Readline
+  DefaultBreakCharacters = " \t\n\"\\'`><=;|&{("
+
+  # Loads the readline-like library and sets the completion_proc to the given agent.
+  def self.setup(agent)
+    readline_setup
+
+    # Reinforcing irb defaults
+    Readline.completion_append_character = nil
+    if Readline.respond_to?("basic_word_break_characters=")
+      Readline.basic_word_break_characters = DefaultBreakCharacters
+    end
+
+    Readline.completion_proc = agent
+  end
+
+  def self.readline_setup
+    require 'readline'
+    load_extension unless Readline.respond_to?(:line_buffer)
+    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
+
+  def self.load_extension
+    require 'readline_line_buffer'
+  rescue LoadError
+    $stderr.puts "Bond Error: Failed to load readline_line_buffer. Ensure that it exists and was built correctly."
+  end
+
+  # Returns full line of what the user has typed.
+  def self.line_buffer
+    Readline.line_buffer
+  end
+end

data/lib/bond/readlines/jruby.rb

@@ -0,0 +1,13 @@
+# Readline for Jruby
+class Bond::Jruby < Bond::Readline
+  def self.readline_setup
+    require 'readline'
+    require 'jruby'
+    class << Readline
+      ReadlineExt = org.jruby.ext.Readline
+      def line_buffer
+        ReadlineExt.s_get_line_buffer(JRuby.runtime.current_context, JRuby.reference(self))
+      end
+    end
+  end
+end

data/lib/bond/readlines/rawline.rb

@@ -0,0 +1,15 @@
+# A pure ruby readline which requires {rawline}[http://github.com/h3rald/rawline].
+class Bond::Rawline < Bond::Readline
+  def self.setup(agent)
+    require 'rawline'
+    Rawline.completion_append_character = nil
+    Rawline.basic_word_break_characters= " \t\n\"\\'`><;|&{("
+    Rawline.completion_proc = agent
+  rescue LoadError
+    abort "Bond Error: rawline gem is required for this readline plugin -> gem install rawline"
+  end
+
+  def self.line_buffer
+    Rawline.editor.line.text
+  end
+end

data/lib/bond/readlines/ruby.rb

@@ -0,0 +1,9 @@
+# A pure ruby readline which requires {rb-readline}[https://github.com/luislavena/rb-readline].
+class Bond::Ruby < Bond::Readline
+  def self.readline_setup
+    require 'rb-readline'
+  rescue LoadError
+    abort "Bond Error: rb-readline gem is required for this readline plugin" +
+      " -> gem install rb-readline"
+  end
+end

data/lib/bond/search.rb

@@ -0,0 +1,74 @@
+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 normal_search(input, list)
+      list.grep(/^#{Regexp.escape(input)}/)
+    end
+
+    # Searches completions anywhere in the string.
+    def anywhere_search(input, list)
+      list.grep(/#{Regexp.escape(input)}/)
+    end
+
+    # Searches completions from the beginning and ignores case.
+    def ignore_case_search(input, list)
+      list.grep(/^#{Regexp.escape(input)}/i)
+    end
+
+    # 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[/_([^_]+)$/]
+        regex = input.split('_').map {|e| Regexp.escape(e) }.join("([^_]+)?_")
+        list.select {|e| e =~ /^#{regex}/ }
+      else
+        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