bond 0.4.2-java

data/lib/bond/agent.rb

@@ -0,0 +1,108 @@
+module Bond
+  # Every time a completion is attempted, the Agent searches its missions for
+  # the first one that matches the user input.  Using either the found mission
+  # or Agent.default_mission, the Agent executes the mission's action.
+  class Agent
+    # The array of missions that will be searched when a completion occurs.
+    attr_reader :missions
+    # An agent's best friend a.k.a. the readline plugin.
+    attr_reader :weapon
+
+    def initialize(options={}) #@private
+      setup_readline(options[:readline])
+      @default_mission_action = options[:default_mission] if options[:default_mission]
+      Mission.eval_binding = options[:eval_binding] if options[:eval_binding]
+      Search.default_search = options[:default_search] || :normal
+      @missions = []
+    end
+
+    # Creates a mission.
+    def complete(options={}, &block)
+      if (mission = create_mission(options, &block)).is_a?(Mission)
+        mission.place.is_a?(Integer) ? @missions.insert(mission.place - 1, mission).compact! : @missions << mission
+        sort_last_missions
+      end
+      mission
+    end
+
+    # Creates a mission and replaces the mission it matches if possible.
+    def recomplete(options={}, &block)
+      if (mission = create_mission(options, &block)).is_a?(Mission)
+        if (existing_mission = @missions.find {|e| e.name == mission.name })
+          @missions[@missions.index(existing_mission)] = mission
+          sort_last_missions
+        else
+          return "No existing mission found to recomplete."
+        end
+      end
+      mission
+    end
+
+    # This is where the action starts when a completion is initiated. Optional
+    # line_buffer overrides line buffer from readline plugin.
+    def call(input, line_buffer=nil)
+      mission_input = line_buffer || @weapon.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.new(input))
+    rescue FailedMissionError => e
+      completion_error(e.message, "Completion Info: #{e.mission.match_message}")
+    rescue
+      completion_error "Failed internally with '#{$!.message}'.",
+        "Please report this issue with debug on: Bond.config[:debug] = true."
+    end
+
+    # Given a hypothetical user input, reports back what mission it would have
+    # found and executed.
+    def spy(input)
+      if (mission = find_mission(input))
+        puts mission.match_message, "Possible completions: #{mission.execute.inspect}",
+          "Matches for #{mission.condition.inspect} are #{mission.matched.to_a.inspect}"
+      else
+        puts "Doesn't match a completion."
+      end
+    rescue FailedMissionError => e
+      puts e.mission.match_message, e.message,
+        "Matches for #{e.mission.condition.inspect} are #{e.mission.matched.to_a.inspect}"
+    end
+
+    def find_mission(input) #@private
+      @missions.find {|mission| mission.matches?(input) }
+    end
+
+    # Default mission used by agent. An instance of DefaultMission.
+    def default_mission
+      @default_mission ||= DefaultMission.new(:action => @default_mission_action)
+    end
+
+    # Resets an agent's missions
+    def reset
+      @missions = []
+    end
+
+    protected
+    def setup_readline(plugin)
+      @weapon = plugin
+      @weapon.setup(self)
+    rescue
+      $stderr.puts "Bond Error: Failed #{plugin.to_s[/[^:]+$/]} setup with '#{$!.message}'"
+    end
+
+    def create_mission(options, &block)
+      Mission.create options.merge!(:action => options[:action] || block)
+    rescue InvalidMissionError
+      "Invalid #{$!.message} for completion with options: #{options.inspect}"
+    rescue
+      "Unexpected error while creating completion with options #{options.inspect} and message:\n#{$!}"
+    end
+
+    def sort_last_missions
+      @missions.replace @missions.partition {|e| e.place != :last }.flatten
+    end
+
+    def completion_error(desc, message)
+      arr = ["Bond Error: #{desc}", message]
+      arr << "Stack Trace: #{$!.backtrace.inspect}" if Bond.config[:debug]
+      arr
+    end
+  end
+end

data/lib/bond/completion.rb

@@ -0,0 +1,16 @@
+# any object's methods
+complete :object=>"Object"
+# method arguments
+complete :all_methods=>true
+complete :all_operator_methods=>true
+# classes and constants
+complete(:name=>:constants, :anywhere=>'([A-Z][^. \(]*)::([^: .]*)') {|e|
+  receiver = e.matched[2]
+  candidates = eval("#{receiver}.constants | #{receiver}.methods") || []
+  normal_search(e.matched[3], candidates).map {|e| "#{receiver}::#{e}" }
+}
+# absolute constants
+complete(:prefix=>'::', :anywhere=>'[A-Z][^:\.\(]*') {|e| Object.constants }
+complete(:anywhere=>':[^:\s.]*') {|e|  Symbol.all_symbols.map {|f| ":#{f}" } rescue [] }
+complete(:anywhere=>'\$[^\s.]*') {|e| global_variables }
+complete(:name=>:quoted_files, :on=>/[\s(]["']([^'"]*)$/, :search=>false, :place=>:last) {|e| files(e.matched[1]) }

data/lib/bond/completions/activerecord.rb

@@ -0,0 +1,12 @@
+attribute_imethods = %w{attribute_for_inspect column_for_attribute decrement} +
+  %w{increment update_attribute toggle update_attributes []}
+complete(:methods=>attribute_imethods, :class=>"ActiveRecord::Base#") {|e| e.object.attribute_names }
+
+attribute_cmethods = %w{attr_accessible attr_protected attr_readonly create create! decrement_counter} +
+  %w{destroy_all exists? increment_counter new serialize update update_all update_counters where}
+complete(:methods=>attribute_cmethods, :class=>'ActiveRecord::Base.') {|e| e.object.column_names }
+
+complete(:method=>"ActiveRecord::Base.establish_connection") { %w{adapter host username password database} }
+complete(:methods=>%w{find all first last}, :class=>'ActiveRecord::Base.') {
+  %w{conditions order group having limit offset joins include select from readonly lock}
+}

data/lib/bond/completions/array.rb

@@ -0,0 +1 @@
+complete(:methods=>%w{delete index rindex include?}, :class=>"Array#") {|e| e.object }

data/lib/bond/completions/bond.rb

@@ -0,0 +1,6 @@
+complete(:methods=>%w{Bond.complete Bond.recomplete}) {
+  ["on", "method", "methods", "class", "object", "anywhere", "prefix", "search", "action", "place", "name"]
+}
+complete(:methods=>['Bond.start', 'Bond.restart']) {
+  %w{gems readline default_mission default_search eval_binding debug eval_debug bare}
+}

data/lib/bond/completions/hash.rb

@@ -0,0 +1,3 @@
+complete(:methods=>%w{delete fetch store, [] has_key? key? include? member? values_at},
+  :class=>"Hash#") {|e| e.object.keys }
+complete(:methods=>%w{index value? has_value?}, :class=>"Hash#") {|e| e.object.values }

data/lib/bond/completions/kernel.rb

@@ -0,0 +1,15 @@
+complete(:methods=>%w{Kernel#raise Kernel#fail}) { objects_of(Class).select {|e| e < StandardError } }
+complete(:methods=>%w{Kernel#system Kernel#exec}) {|e|
+  ENV['PATH'].split(File::PATH_SEPARATOR).uniq.map {|e|
+    File.directory?(e) ? Dir.entries(e) : []
+  }.flatten.uniq - ['.', '..']
+}
+complete(:method=>"Kernel#require", :search=>:files) {
+  paths = $:.map {|e| Dir["#{e}/**/*.{rb,bundle,dll,so}"].map {|f| f.sub(e+'/', '') } }.flatten
+  if Object.const_defined?(:Gem)
+    paths += Gem.path.map {|e| Dir["#{e}/gems/*/lib/*.{rb,bundle,dll,so}"].
+      map {|f| f.sub(/^.*\//,'') } }.flatten
+  end
+  paths.uniq
+}
+complete(:methods=>%w{Kernel#trace_var Kernel#untrace_var}) { global_variables.map {|e| ":#{e}"} }

data/lib/bond/completions/module.rb

@@ -0,0 +1,10 @@
+complete(:methods=>%w{const_get const_set const_defined? remove_const}, :class=>"Module#") {|e| e.object.constants }
+complete(:methods=>%w{class_variable_defined? class_variable_get class_variable_set remove_class_variable},
+  :class=>"Module#") {|e| e.object.class_variables }
+complete(:methods=>%w{instance_method method_defined? module_function remove_method undef_method},
+  :class=>"Module#") {|e| e.object.instance_methods }
+complete(:method=>"Module#public") {|e| e.object.private_instance_methods + e.object.protected_instance_methods }
+complete(:method=>"Module#private") {|e| e.object.instance_methods + e.object.protected_instance_methods }
+complete(:method=>"Module#protected") {|e| e.object.instance_methods + e.object.private_instance_methods }
+complete(:methods=>%w{< <= <=> > >= include? include}, :class=>"Module#", :search=>:modules) { objects_of(Module) }
+complete(:method=>'Module#alias_method') {|e| e.argument > 1 ? e.object.instance_methods : [] }

data/lib/bond/completions/object.rb

@@ -0,0 +1,21 @@
+instance_meths = %w{instance_variable_get instance_variable_set remove_instance_variable instance_variable_defined?}
+complete(:methods=>instance_meths, :class=>"Object#") {|e| e.object.instance_variables }
+complete(:method=>"Object#instance_of?", :search=>:modules) { objects_of(Class) }
+complete(:methods=>%w{is_a? kind_a? extend}, :class=>"Object#", :search=>:modules) { objects_of(Module) }
+complete(:methods=>%w{Object#method Object#respond_to?}) {|e| e.object.methods }
+complete(:method=>"Object#[]") {|e| e.object.keys rescue [] }
+complete(:method=>"Object#send") {|e|
+  if e.argument > 1
+    if (meth = eval(e.arguments[0])) && meth.to_s != 'send' &&
+      (action = MethodMission.find(e.object, meth.to_s))
+      e.argument -= 1
+      e.arguments.shift
+      action[0].call(e)
+    end
+  else
+    send_methods(e.object)
+  end
+}
+def send_methods(obj)
+  (obj.methods + obj.private_methods(false)).map {|e| e.to_s } - Mission::OPERATORS
+end

data/lib/bond/completions/struct.rb

@@ -0,0 +1 @@
+complete(:method=>"Struct#[]") {|e| e.object.members }

data/lib/bond/input.rb

@@ -0,0 +1,28 @@
+module Bond
+  # A string representing the last word the user has typed. This string is passed to a mission
+  # action to generate possible completions. This string contains a number of attributes from the
+  # matching mission, useful in generating completions.
+  class Input < String
+    # Actual object a user has just typed. Used by MethodMission and ObjectMission.
+    attr_accessor :object
+    # MatchData object from the matching mission (Mission#matched).
+    attr_reader :matched
+    # Current argument number and array of argument strings. Used by MethodMission.
+    attr_accessor :argument, :arguments
+    # The full line the user has typed.
+    attr_reader :line
+    def initialize(str, options={}) #@private
+      super(str || '')
+      @matched = options[:matched]
+      @line = options[:line]
+      @object = options[:object] if options[:object]
+      @argument = options[:argument] if options[:argument]
+      @arguments = options[:arguments] if options[:arguments]
+    end
+
+    def inspect #@private
+      "#<Bond::Input #{self.to_s.inspect} @matched=#{@matched.to_a.inspect} @line=#{@line.inspect} "+
+      "@argument=#{@argument.inspect} @arguments=#{@arguments.inspect} @object=#{@object.inspect}>"
+    end
+  end
+end

data/lib/bond/m.rb

@@ -0,0 +1,146 @@
+module Bond
+  # Takes international quagmires (a user's completion setup) and passes them on
+  # as missions to an Agent.
+  module M
+    extend self
+
+    # See {Bond#complete}
+    def complete(options={}, &block)
+      if (result = agent.complete(options, &block)).is_a?(String)
+        $stderr.puts "Bond Error: "+result
+        false
+      else
+        true
+      end
+    end
+
+    # See {Bond#recomplete}
+    def recomplete(options={}, &block)
+      if (result = agent.recomplete(options, &block)).is_a?(String)
+        $stderr.puts "Bond Error: "+result
+        false
+      else
+        true
+      end
+    end
+
+    # See {Bond#agent}
+    def agent
+      @agent ||= Agent.new(config)
+    end
+
+    # See {Bond#config}
+    def config
+      @config ||= {:debug => false, :default_search => :underscore}
+    end
+
+    # Resets M's missions and config
+    def reset
+      MethodMission.reset
+      @config = @agent = nil
+    end
+
+    # See {Bond#spy}
+    def spy(input)
+      agent.spy(input)
+    end
+
+    # Validates and sets values in M.config.
+    def debrief(options={})
+      config.merge! options
+      config[:readline] ||= default_readline
+      if !config[:readline].is_a?(Module) &&
+        Bond.const_defined?(config[:readline].to_s.capitalize)
+        config[:readline] = Bond.const_get(config[:readline].to_s.capitalize)
+      end
+      unless %w{setup line_buffer}.all? {|e| config[:readline].respond_to?(e) }
+        $stderr.puts "Bond Error: Invalid readline plugin '#{config[:readline]}'."
+      end
+    end
+
+    # See {Bond#restart}
+    def restart(options={}, &block)
+      reset
+      start(options, &block)
+    end
+
+    # See {Bond#start}
+    def start(options={}, &block)
+      debrief options
+      @started = true
+      load_completions
+      Rc.module_eval(&block) if block
+      true
+    end
+
+    # See {Bond#started?}
+    def started?
+      !!@started
+    end
+
+    # Finds the full path to a gem's file relative it's load path directory.
+    # Returns nil if not found.
+    def find_gem_file(rubygem, file)
+      begin gem(rubygem); rescue Exception; end
+      (dir = $:.find {|e| File.exists?(File.join(e, file)) }) && File.join(dir, file)
+    end
+
+    # Loads a completion file in Rc namespace.
+    def load_file(file)
+      Rc.module_eval File.read(file)
+    rescue Exception => e
+      $stderr.puts "Bond Error: Completion file '#{file}' failed to load with:", e.message
+    end
+
+    # Loads completion files in given directory.
+    def load_dir(base_dir)
+      if File.exists?(dir = File.join(base_dir, 'completions'))
+        Dir[dir + '/*.rb'].each {|file| load_file(file) }
+        true
+      end
+    end
+
+    # Loads completions from gems
+    def load_gems(*gems)
+      gems.select {|e| load_gem_completion(e) }
+    end
+
+    # Find a user's home in a cross-platform way
+    def home
+      ['HOME', 'USERPROFILE'].each {|e| return ENV[e] if ENV[e] }
+      return "#{ENV['HOMEDRIVE']}#{ENV['HOMEPATH']}" if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+      File.expand_path("~")
+    rescue
+      File::ALT_SEPARATOR ? "C:/" : "/"
+    end
+
+    protected
+    def default_readline
+      RUBY_PLATFORM[/mswin|mingw|bccwin|wince/i] ? Ruby :
+        RUBY_PLATFORM[/java/i] ? Jruby : Bond::Readline
+    end
+
+    def load_gem_completion(rubygem)
+      (dir = find_gem_file(rubygem, File.join(rubygem, '..', 'bond'))) ? load_dir(dir) :
+        rubygem[/\/|-/] ? load_plugin_file(rubygem) :
+        $stderr.puts("Bond Error: No completions found for gem '#{rubygem}'.")
+    end
+
+    def load_plugin_file(rubygem)
+      namespace, file = rubygem.split(/\/|-/, 2)
+      file += '.rb' unless file[/\.rb$/]
+      if (dir = $:.find {|e| File.exists?(File.join(e, namespace, 'completions', file)) })
+        load_file File.join(dir, namespace, 'completions', file)
+        true
+      end
+    end
+
+    def load_completions
+      load_file File.join(File.dirname(__FILE__), 'completion.rb') unless config[:bare]
+      load_dir File.dirname(__FILE__) unless config[:bare]
+      load_gems *config[:gems] if config[:gems]
+      load_file(File.join(home,'.bondrc')) if File.exists?(File.join(home, '.bondrc')) && !config[:bare]
+      load_dir File.join(home, '.bond') unless config[:bare]
+    end
+  end
+end

data/lib/bond/mission.rb

@@ -0,0 +1,151 @@
+module Bond
+  # Occurs when a mission is incorrectly defined.
+  class InvalidMissionError < StandardError; end
+  # Occurs when a mission fails.
+  class FailedMissionError < StandardError
+    # Mission that failed
+    attr_reader :mission
+    def initialize(mission); @mission = mission; end #@private
+  end
+
+  # Represents a completion rule, given a condition (:on) on which to match and an action
+  # (block or :action) with which to generate possible completions.
+  class Mission
+    class<<self
+      # eval binding used across missions
+      attr_accessor :eval_binding
+      # Handles creation of proper Mission class depending on the options passed.
+      def create(options)
+        if options[:method] || options[:methods] then MethodMission.create(options)
+        elsif options[:object]                   then ObjectMission.new(options)
+        elsif options[:anywhere]                 then AnywhereMission.new(options)
+        elsif options[:all_methods]              then MethodMission.new(options)
+        elsif options[:all_operator_methods]     then OperatorMethodMission.new(options)
+        else                                          new(options)
+        end
+      end
+
+      # Calls eval with either the irb's current workspace binding or TOPLEVEL_BINDING.
+      def current_eval(string, ebinding=Mission.eval_binding)
+        ebinding = ebinding.call if ebinding.is_a?(Proc)
+        eval(string, ebinding)
+      end
+
+      def eval_binding #@private
+        @eval_binding || IRB.CurrentContext.workspace.binding rescue ::TOPLEVEL_BINDING
+      end
+    end
+
+    # All known operator methods
+    OPERATORS = %w{% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ | ~ ! != !~}
+    # Regular expressions which describe common objects for MethodMission and ObjectMission
+    OBJECTS = %w<\([^\)]*\) '[^']*' "[^"]*" \/[^\/]*\/> +
+      %w<(?:%q|%r|%Q|%w|%s|%)?\[[^\]]*\] (?:proc|lambda|%q|%r|%Q|%w|%s|%)?\s*\{[^\}]*\}>
+
+    # Generates array of possible completions and searches them if search is disabled. Any values
+    # that aren't strings are automatically converted with to_s.
+    attr_reader :action
+    # See {Bond#complete}'s :place.
+    attr_reader :place
+    # A MatchData object generated from matching the user input with the condition.
+    attr_reader :matched
+    # Regexp condition
+    attr_reader :on
+    # Takes same options as {Bond#complete}.
+    def initialize(options)
+      raise InvalidMissionError, ":action" unless (options[:action] || respond_to?(:default_action))
+      raise InvalidMissionError, ":on" unless (options[:on] && options[:on].is_a?(Regexp)) || respond_to?(:default_on)
+      @action, @on = options[:action], options[:on]
+      @place = options[:place] if options[:place]
+      @name = options[:name] if options[:name]
+      @search = options.has_key?(:search) ? options[:search] : Search.default_search
+    end
+
+    # Returns a boolean indicating if a mission matches the given Input and should be executed for completion.
+    def matches?(input)
+      @matched = @input = @completion_prefix = nil
+      (match = do_match(input)) && after_match(@line = input)
+      !!match
+    end
+
+    # Called when a mission has been chosen to autocomplete.
+    def execute(input=@input)
+      completions = Array(call_action(input)).map {|e| e.to_s }
+      completions = call_search(@search, input, completions) if @search
+      if @completion_prefix
+        # Everything up to last break char stays on the line.
+        # Must ensure only chars after break are prefixed
+        @completion_prefix = @completion_prefix[/([^#{Readline::DefaultBreakCharacters}]+)$/,1] || ''
+        completions = completions.map {|e| @completion_prefix + e }
+      end
+      completions
+    end
+
+    # Searches possible completions from the action which match the input.
+    def call_search(search, input, list)
+      Rc.send("#{search}_search", input || '', list)
+    rescue
+      message = $!.is_a?(NoMethodError) && !Rc.respond_to?("#{search}_search") ?
+        "Completion search '#{search}' doesn't exist." :
+        "Failed during completion search with '#{$!.message}'."
+      raise FailedMissionError.new(self), message
+    end
+
+    # Calls the action to generate an array of possible completions.
+    def call_action(input)
+      @action.respond_to?(:call) ? @action.call(input) : Rc.send(@action, input)
+    rescue StandardError, SyntaxError
+      message = $!.is_a?(NoMethodError) && !@action.respond_to?(:call) &&
+        !Rc.respond_to?(@action) ? "Completion action '#{@action}' doesn't exist." :
+        "Failed during completion action '#{name}' with '#{$!.message}'."
+      raise FailedMissionError.new(self), message
+    end
+
+    # A message used to explains under what conditions a mission matched the user input.
+    # Useful for spying and debugging.
+    def match_message
+      "Matches completion with condition #{condition.inspect}."
+    end
+
+    # A regexp representing the condition under which a mission matches the input.
+    def condition
+      self.class.const_defined?(:CONDITION) ? Regexp.new(self.class.const_get(:CONDITION)) : @on
+    end
+
+    # The name or generated unique_id for a mission. Mostly for use with Bond.recomplete.
+    def name
+      @name ? @name.to_s : unique_id
+    end
+
+    # Method which must return non-nil for a mission to match.
+    def do_match(input)
+      @matched = input.match(@on)
+    end
+
+    # Stuff a mission needs to do after matching successfully, in preparation for Mission.execute.
+    def after_match(input)
+      create_input(input[/\S+$/])
+    end
+
+    private
+    def condition_with_objects
+      self.class.const_get(:CONDITION).sub('OBJECTS', self.class.const_get(:OBJECTS).join('|'))
+    end
+
+    def eval_object(obj)
+      @evaled_object = self.class.current_eval(obj)
+      true
+    rescue Exception
+      raise FailedMissionError.new(self), "Match failed during eval of '#{obj}'." if Bond.config[:eval_debug]
+      false
+    end
+
+    def unique_id
+      @on.inspect
+    end
+
+    def create_input(input, options={})
+      @input = Input.new(input, options.merge(:line => @line, :matched => @matched))
+    end
+  end
+end