bond 0.4.2-java

data/.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+require 'rubygems' unless Object.const_defined?(:Gem)
+require File.dirname(__FILE__) + "/lib/bond/version"
+
+Gem::Specification.new do |s|
+  s.name        = "bond"
+  s.version     = Bond::VERSION
+  s.platform    = ENV['GEM_PLATFORM'] if ENV['GEM_PLATFORM']
+  s.authors     = ["Gabriel Horner"]
+  s.email       = "gabriel.horner@gmail.com"
+  s.homepage    = "http://tagaholic.me/bond/"
+  s.summary = "Mission: Easy custom autocompletion for arguments, methods and beyond. Accomplished for irb and any other readline-like console environments."
+  s.description = "Bond is on a mission to improve autocompletion in ruby, especially for irb/ripl. Aside from doing everything irb's can do and fixing its quirks, Bond can autocomplete argument(s) to methods, uniquely completing per module, per method and per argument. Bond brings ruby autocompletion closer to bash/zsh as it provides a configuration system and a DSL for creating custom completions and completion rules. With this configuration system, users can customize their autocompletions and share it with others. Bond can also load completions that ship with gems.  Bond is able to offer more than irb's completion since it uses the full line of input when completing as opposed to irb's last-word approach."
+  s.required_rubygems_version = ">= 1.3.6"
+  s.has_rdoc = 'yard'
+  s.rdoc_options = ['--title', "Bond #{Bond::VERSION} Documentation"]
+  s.add_development_dependency 'bacon', '>= 1.1.0'
+  s.add_development_dependency 'mocha', '>= 0.9.8'
+  s.add_development_dependency 'mocha-on-bacon'
+  s.add_development_dependency 'bacon-bits'
+  s.files = Dir.glob(%w[{lib,test}/**/*.rb bin/* [A-Z]*.{txt,rdoc} **/deps.rip]) + %w{Rakefile .gemspec .travis.yml}
+  if ENV['GEM_PLATFORM'] != 'java'
+    s.files += Dir.glob("ext/**/*.{rb,c}")
+    s.extensions = ["ext/readline_line_buffer/extconf.rb"]
+  end
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+  s.license = 'MIT'
+end

data/.travis.yml

@@ -0,0 +1,8 @@
+before_install: bundle init --gemspec=.gemspec
+script: bacon -q -Ilib -I. test/*_test.rb
+rvm:
+- 1.8.7
+- 1.9.2
+- 1.9.3
+- rbx
+- jruby

data/CHANGELOG.rdoc

@@ -0,0 +1,91 @@
+== 0.4.2
+* Start also releasing java version of gem
+* Put tests on travis
+* Fix tests for jruby
+
+== 0.4.1
+* Fix install on jruby 1.6
+
+== 0.4.0
+* Improve extconf.rb: support --without-readline, fail hard, detect windows
+* Add rb-readline support for windows and non-readline users
+* Rename :readline_plugin option to :readline
+* Allow :readline option to take a symbol
+
+== 0.3.5
+* Move yard-related functionality to bond-yard gem
+  
+== 0.3.4
+* Add gem plugin completion
+* Add jruby support thanks to @headius
+* Add bare option to Bond.start
+
+== 0.3.3
+* Add Bond.restart
+
+== 0.3.2
+* Add Bond.started?
+
+== 0.3.1
+* Fix install for non-readline platforms
+* Fix install for rubinius
+
+== 0.3.0
+* Fixes for tests to pass in rubinius and 1.9.2.
+* Add support for a proc :eval_binding.
+* Add instance variables to default completion.
+* Add DefaultMission.completions to make default completions reusable
+* Remove unused Mission#eval_binding.
+
+== 0.2.2
+* Moved documentation to yard.
+* Better extconf.rb thanks to @timcharper
+* Better error when failing to require extension.
+
+== 0.2.1
+* Added Bond.load_yard_gems which generates argument completions from yard documentation.
+* Added Bond.load_gems which loads completions from gem's directory.
+* Added compatibility within emacs' inf-ruby mode (thanks to @pd).
+* Added :eval_debug to Bond.config for debugging completions.
+* Doesn't build or load c extension for ruby 1.9.2.
+* Fixed argument completion of object containing method names bug.
+* Fixed nested constants completion bug.
+* Updated completions for Kernel#system, Module#public, Module#protected and Module#private.
+
+== 0.2.0
+* Added comprehensive argument completion per module, method and argument.
+* Added 60+ default method argument completions.
+* Added configuration system and DSL.
+* Added user-friendly completion error handling.
+* Improved Bond.spy.
+* Fixed several 1.9 bugs.
+* Replaced require 'bond/completion' with Bond.start.
+* Changed underscore_search to use '_' instead of '-'.
+* Removed Bond.debrief and Bond.reset.
+* Switched to bacon for tests.
+
+== 0.1.4
+* Added Bond.recomplete to make redefinition of completion missions easy.
+* Added flag to readline extension building so that installing bond doesn't fail for
+  users without readline.
+* bond/completion allows require to autocomplete gems and within gems.
+
+== 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
+* Allow regex characters in completions
+
+== 0.1.0
+* Intial release. Whoop!

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2010 Gabriel Horner
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,242 @@
+== Description
+
+Bond is on a mission to improve autocompletion in ruby, especially for irb/ripl. Aside from doing
+everything irb's can do and fixing its quirks, Bond can autocomplete argument(s) to methods,
+uniquely completing per module, per method and per argument. Bond brings ruby autocompletion closer
+to bash/zsh as it provides a configuration system and a DSL for creating custom completions and
+completion rules. With this configuration system, users can customize their autocompletions and
+share it with others. Bond can also load completions that ship with gems.  Bond is able to offer
+more than irb's completion since it uses the full line of input when completing as opposed to irb's
+last-word approach.
+
+== Install
+
+To use bond with {Readline}[http://cnswww.cns.cwru.edu/php/chet/readline/rltop.html] (version >=
+5.6 recommended) or JLine for JRuby users, install the gem with:
+
+    gem install bond
+
+To use bond with {a pure ruby readline}[https://github.com/luislavena/rb-readline] i.e. Windows
+users or users without Readline:
+
+    gem install bond rb-readline -- --without-readline
+
+To use bond without readline support (and presumably use your own readline plugin):
+
+    gem install bond -- --without-readline
+
+== Setup
+
+If you're using {ripl}[https://github.com/cldwalker/ripl] instead of irb, bond is already setup.
+
+To start off, replace irb's completion (require 'irb/completion') with Bond's enhanced version in your irbrc:
+
+  require 'bond'
+  Bond.start
+  # For users using a pure ruby readline
+  Bond.start :readline => :ruby
+
+This setup gives you more consistent method completion on any object, customizable completions
+and argument completion of some 80+ methods including Hash#[], Kernel#system, Kernel#require and some Rails methods.
+
+== Method Argument Completion
+
+By default, Bond autocompletes arguments for a number of core methods:
+
+  $ ripl
+  # require completes gems and anything in $LOAD_PATH
+  >> require 'rb[TAB]
+  rbconfig.rb          rbconfig/
+  >> require 'rbconfig
+  >> require 'rbconfig.rb'
+
+  # hash methods can complete their keys
+  >> CONFIG::CONFIG[TAB]
+  >> CONFIG::CONFIG['m[TAB]
+  >> CONFIG::CONFIG['mandir'
+  >> CONFIG::CONFIG['mandir']
+
+  >> ENV['CO[TAB]
+  COLUMNS       COMMAND_MODE
+  >> ENV['COL[TAB]
+  >> ENV['COLUMNS'
+  >> ENV['COLUMNS']
+
+  # array methods can complete their elements
+  >> %w{ab bc cd de}.delete '[TAB]
+  ab  bc  cd  de
+  >> %w{ab  bc  cd  de}.delete 'a[TAB]
+  >> %w{ab  bc  cd  de}.delete 'ab'
+
+  # system can complete shell commands
+  >> system 'ec[TAB]
+  >> system 'echo
+  >> system 'echo'
+
+Bond also comes with some basic Rails completions, mostly for attributes/columns of models:
+
+  $ script/console
+  >> Url.column_names
+  => ["id", "name", "description", "created_at", "updated_at"]
+  >> Url.create :n[TAB]
+  >> Url.create :name
+  ...
+  >> Url.first.update_attribute :d[TAB]
+  >> Url.first.update_attribute :description
+  ...
+
+To see more methods whose arguments can be completed:
+  >> puts Bond.list_methods
+  ActiveRecord::Base#[]
+  ActiveRecord::Base#attribute_for_inspect
+  ...
+
+== Multiple Arguments
+Every time a comma appears after a method, Bond starts a new completion. This allows a method to
+complete multiple arguments. *Each* argument can be have a unique set of completions since a completion action
+is aware of what argument it is currently completing. Take for example the completion for Object#send:
+
+  >> Bond.send :me[TAB]
+  >> Bond.send :method
+  >> Bond.send :method, [TAB]
+  agent       complete    config      recomplete  spy         start
+  >> Bond.send :method, :a[TAB]
+  >> Bond.send :method, :agent
+  => #<Method: Module#agent>
+
+Notice the arguments were completed differently: the first completing for Bond.send and the second for Bond.method. The second
+argument was only able to complete because there's a completion for Module#method. Using Object#send it's possible to
+use completions defined for private methods i.e. Module#remove_const:
+  >> Bond.send :remove_const, :A[TAB]
+  :Agent            :AnywhereMission
+  >> Bond.send :remove_const, :Ag[TAB]
+  >> Bond.send :remove_const, :Agent
+
+Since Bond uses a comma to delimit completions, methods whose last argument is a hash can have their hash keys
+autocompleted. Revisiting the above Rails example:
+  >> Url.create :n[TAB]
+  >> Url.create :name
+  >> Url.create :name=>'example.com', :d[TAB]
+  >> Url.create :name=>'example.com', :description
+  ...
+  >> Url.first.update_attributes :d[TAB]
+  >> Url.first.update_attributes :description
+  >> Url.first.update_attributes :description=>'zzz', :u[TAB]
+  >> Url.first.update_attributes :description=>'zzz', :updated_at
+  ...
+
+== Creating Completions
+Bond's completion resembles bash/zsh's. When Bond.start is called, Bond looks up completion files in multiple places:
+~/.bondrc and ~/.bond/completions/*.rb. Here's how bash and bond completion definitions compare in their config files:
+  # Bash
+  complete -W "one two three" example
+  complete -F _example example
+
+  # Bond
+  complete(:method=>'example') { %w{one two three} }
+  complete(:method=>'example', :action=>'_example')
+
+To read up on the wealth of completion types one can make, see the docs for Bond.complete.
+
+=== Creating Argument Completions for Methods
+While the above method completion was a static list, most completions will dynamically generate completions based on the method's
+receiver (object). Let's look at such an example with Hash#[] :
+  complete(:method=>"Hash#[]") {|e| e.object.keys }
+
+As you can see, the currently typed object is available as the :object attribute of the block's argument, a Bond::Input object.
+This object can offer other useful attributes describing what the user has typed. For example, the :argument attribute holds the
+current argument number being completed. Here's a completion that uses this attribute to complete differently for the first argument
+and remaining arguments:
+   complete(:method=>'example') {|e| e.argument > 1 ? %w{verbose force noop} : %w{one two three} }
+
+=== Creating Other Completions
+First you should know Bond works: A user creates completion missions with Bond.start and its config files (which are just
+Bond.complete calls). When a user autocompletes, Bond.agent looks up missions in the *order* they were defined and completes
+with the first one that matches. The exception to this ordering are :method completions.
+
+To create a completion, Bond.complete needs a regexp to match the user input and an action to generate completions when
+it matches. If the completion isn't working, use Bond.spy to see which completion is executing. If a completion needs to be placed
+before existing completions, use the :place option.
+
+== Irb's Incorrect Completions
+
+There are a number of incorrect completions irb gives for object methods. Bond fixes all of the ones described below.
+
+Irb completes anything surrounded with '{}' the same:
+
+  $ irb
+  >> proc {}.c[TAB]
+  }.call     }.class    }.clear    }.clone    }.collect
+  >> %w{ab bc}.c[TAB]
+  }.call     }.class    }.clear    }.clone    }.collect
+  >> %r{ab bc}.c[TAB]
+  }.call     }.class    }.clear    }.clone    }.collect
+  >> {}.c[TAB]
+  }.call     }.class    }.clear    }.clone    }.collect
+  >> {}.call
+  NoMethodError: undefined method `call' for {}:Hash
+          from (irb):1
+
+There are a number of cases where irb gives a default completion because it doesn't know what else to do.
+  # The default completion
+  >> self.[TAB]
+  Display all 496 possibilities? (y or n)
+
+  # And all of these cases are apparently the same:
+  >> nil.[TAB]
+  Display all 496 possibilities? (y or n)
+  >> false.[TAB]
+  Display all 496 possibilities? (y or n)
+  >> true.[TAB]
+  Display all 496 possibilities? (y or n)
+  # Regular expressions with spaces
+  >> /man oh man/.[TAB]
+  Display all 496 possibilities? (y or n)
+  # Grouped expressions
+ >> (3 + 4).[TAB]
+ Display all 496 possibilities? (y or n)
+
+ # Nested hashes and arrays
+ >> {:a=>{:a=>1}}.[TAB]
+ Display all 496 possibilities? (y or n)
+ >> [[1,2], [3,4]].[TAB]
+ Display all 496 possibilities? (y or n)
+
+ # Any object produced from a method call
+ >> 'awesome'.to_sym.[TAB]
+ Display all 496 possibilities? (y or n)
+ >> :dude.to_s.[TAB]
+ Display all 496 possibilities? (y or n)
+ 
+Ranges don't get much love
+  >> (2..4).[TAB]
+  # Nothing happens
+
+== Limitations
+If on a Mac and using Editline as a Readline replacement (Readline::VERSION =~ /editline/i), Bond will probably not work consistently. I strongly recommend switching to the official Readline. If using rvm, {this post}[http://niwos.com/2010/03/19/rvm-on-osx-snow-leopard-readline-errors/]
+has good instructions for reinstalling ruby with the official Readline.
+
+== Credits
+* Csaba Hank for {providing the C extension}[http://www.creo.hu/~csaba/ruby/irb-enhancements/doc/files/README.html] which Bond uses to read Readline's full buffer.
+* Takao Kouji for {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 1.9.2.
+* pd for compatibility with emacs' inf-ruby mode.
+* timcharper for improving extconf.rb.
+* headius for jruby support
+* tobias for a java version of the gem
+
+== Bugs/Issues
+Please report them {on github}[http://github.com/cldwalker/bond/issues].
+
+== Contributing
+{See here}[http://tagaholic.me/contributing.html]
+
+== Links
+* http://tagaholic.me/2010/05/07/screencast-of-argument-autocompletion-for-methods-in-irb.html
+* http://tagaholic.me/2009/07/16/bond-from-irb-with-completion-love.html
+* http://tagaholic.me/2009/07/22/better-irb-completion-with-bond.html
+* http://tagaholic.me/2009/07/23/mini-irb-and-mini-script-console.html
+
+== Todo
+* Make completion actions more synonymous with argument types.
+* Cache expensive completion actions.
+* Ensure completions work when there is additional, unrelated text to the right of a completion.

data/Rakefile

@@ -0,0 +1,47 @@
+require 'rake'
+require 'fileutils'
+
+def gemspec
+  @gemspec ||= eval(File.read('.gemspec'), binding, '.gemspec')
+end
+
+def gem_file
+  "#{gemspec.name}-#{gemspec.version}#{ENV['GEM_PLATFORM'] == 'java' ? '-java' : ''}.gem"
+end
+
+desc "Build the gem"
+task :gem=>:gemspec do
+  sh "gem build .gemspec"
+  FileUtils.mkdir_p 'pkg'
+  FileUtils.mv gem_file, 'pkg'
+end
+
+desc "Build gems for the default and java platforms"
+task :all_gems => :gem do
+  ENV['GEM_PLATFORM'] = 'java'
+  @gemspec = nil
+  Rake::Task["gem"].reenable
+  Rake::Task["gem"].invoke
+end
+
+desc "Install the gem locally"
+task :install => :gem do
+  sh %{gem install pkg/#{gem_file}}
+end
+
+desc "Generate the gemspec"
+task :generate do
+  puts gemspec.to_ruby
+end
+
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc 'Run tests'
+task :test do |t|
+  sh 'bacon -q -Ilib -I. test/*_test.rb'
+end
+
+task :default => :test

data/lib/bond.rb

@@ -0,0 +1,127 @@
+require 'bond/m'
+require 'bond/version'
+require 'bond/readline'
+require 'bond/readlines/rawline'
+require 'bond/readlines/ruby'
+require 'bond/readlines/jruby'
+require 'bond/agent'
+require 'bond/search'
+require 'bond/input'
+require 'bond/rc'
+require 'bond/mission'
+require 'bond/missions/default_mission'
+require 'bond/missions/method_mission'
+require 'bond/missions/object_mission'
+require 'bond/missions/anywhere_mission'
+require 'bond/missions/operator_method_mission'
+
+module Bond
+  extend self
+
+  # Creates a completion rule (Mission). A valid Mission consists of a condition and an action. A
+  # condition is specified with one of the following options: :on, :object, :anywhere or :method(s). Each
+  # of these options creates a different Mission class. An action is either the method's block or :action.
+  # An action takes what the user has typed (Input) and returns an array of possible completions. Bond
+  # searches these completions and returns matching completions. This searching behavior can be configured
+  # or turned off per mission with :search. If turned off, the action must also handle searching.
+  #
+  # ==== 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, :place => :last)
+  #  Bond.complete(:method => 'you', :search => proc {|input, list| list.grep(/#{input}/i)} ) {|input| %w{Only Live Twice} }
+  #  Bond.complete(:method => 'system', :action => :shell_commands)
+  #
+  # @param [Hash] options When using :method(s) or :object, some hash keys may have different behavior. See
+  #   Bond.complete sections of {MethodMission} and {ObjectMission} respectively.
+  # @option options [Regexp] :on Matches the full line of input to create a {Mission} object.
+  # @option options [String] :method An instance (Class#method) or class method (Class.method). Creates
+  #   {MethodMission} object. A method's class can be set by :class or detected automatically if '#' or '.' is
+  #   present. If no class is detected, 'Kernel#' is assumed.
+  # @option options [Array<String>] :methods Instance or class method(s) in the format of :method. Creates
+  #   {MethodMission} objects.
+  # @option options [String] :class Optionally used with :method or :methods to represent module/class.
+  #   Must end in '#' or '.' to indicate instance/class method. Suggested for use with :methods.
+  # @option options [String] :object Module or class of an object whose methods are completed. Creates
+  #   {ObjectMission} object.
+  # @option options [String] :anywhere String representing a regular expression to match a mission. Creates
+  #   {AnywhereMission} object.
+  # @option options [String] :prefix Optional string to prefix :anywhere.
+  # @option options [Symbol,false] :search Determines how completions are searched. Defaults to
+  #   Search.default_search. If false, search is turned off and assumed to be done in the action.
+  #   Possible symbols are :anywhere, :ignore_case, :underscore, :normal, :files and :modules.
+  #   See {Search} for more info.
+  # @option options [String,Symbol] :action Rc method name that takes an Input and returns possible completions.
+  #   See {MethodMission} for specific behavior with :method(s).
+  # @option options [Integer,:last] :place Indicates where a mission is inserted amongst existing
+  #   missions. If the symbol :last, places the mission at the end regardless of missions defined
+  #   after it. Multiple declarations of :last are kept last in the order they are defined.
+  # @option options [Symbol,String] :name Unique id for a mission which can be passed by
+  #   Bond.recomplete to identify and replace the mission.
+  def complete(options={}, &block); M.complete(options, &block); end
+
+  # Redefines an existing completion mission to have a different action. The condition can only be varied if :name is
+  # used to identify and replace a mission. Takes same options as {#complete}.
+  # ==== Example:
+  #   Bond.recomplete(:on => /man/, :name => :count) { %w{4 5 6}}
+  def recomplete(options={}, &block); M.recomplete(options, &block); end
+
+  # Reports what completion mission matches for a given input. Helpful for debugging missions.
+  # ==== Example:
+  #   >> Bond.spy "shoot oct"
+  #   Matches completion mission for method matching "shoot".
+  #   Possible completions: ["octopussy"]
+  def spy(*args); M.spy(*args); end
+
+  # @return [Hash] Global config
+  def config; M.config; end
+
+  # Starts Bond with a default set of completions that replace and improve irb's completion. Loads completions
+  # in this order: lib/bond/completion.rb, lib/bond/completions/*.rb and the following optional completions:
+  # completions from :gems, ~/.bondrc, ~/.bond/completions/*.rb and from block. See
+  # {Rc} for the DSL to use in completion files and in the block.
+  #
+  # ==== Examples:
+  #   Bond.start :gems => %w{hirb}
+  #   Bond.start(:default_search => :ignore_case) do
+  #     complete(:method => "Object#respond_to?") {|e| e.object.methods }
+  #   end
+  #
+  # @param [Hash] options Sets global keys in {#config}, some which specify what completions to load.
+  # @option options [Array<String>] :gems Gems which have their completions loaded from
+  #   @gem_source/lib/bond/completions/*.rb. If gem is a plugin gem i.e. ripl-plugin, completion will be loaded
+  #   from @gem_source/lib/ripl/completions/plugin.rb.
+  # @option options [Module, Symbol] :readline (Bond::Readline) Specifies a Bond readline plugin.
+  #   A symbol points to a capitalized Bond constant i.e. :ruby -> Bond::Ruby.
+  #   Available plugins are Bond::Readline, Bond::Ruby, Bond::Jruby and Bond::Rawline.
+  # @option options [Proc] :default_mission (DefaultMission) Sets default completion to use when no missions match.
+  #  See {Agent#default_mission}.
+  # @option options [Symbol] :default_search (:underscore) Name of a *_search method in Rc to use as the default
+  #   search in completions. See {#complete}'s :search option for valid values.
+  # @option options [Binding, Proc] :eval_binding (TOPLEVEL_BINDING) Binding to use when evaluating objects in
+  #   ObjectMission and MethodMission. When in irb, defaults to irb's current binding. When proc,
+  #   binding is evaluated each time by calling proc.
+  # @option options [Boolean] :debug (false) Shows the stacktrace when autocompletion fails and raises exceptions
+  #   in Rc.eval.
+  # @option options [Boolean] :eval_debug (false) Raises eval errors occuring when finding a matching completion.
+  #   Useful to debug an incorrect completion
+  # @option options [Boolean] :bare (false) Doesn't load default ruby completions and completions in
+  #   ~/.bond*. Useful for non-ruby completions
+  def start(options={}, &block); M.start(options, &block); end
+
+  # Restarts completions with given options, ensuring to delete current completions.
+  # Takes same options as Bond#start.
+  def restart(options={}, &block); M.restart(options, &block); end
+
+  # Indicates if Bond has already started
+  def started?; M.started?; end
+
+  # Loads completions for gems that ship with them under lib/bond/completions/, relative to the gem's base directory.
+  def load_gems(*gems); M.load_gems(*gems); end
+
+  # An Agent who saves all Bond.complete missions and executes the correct one when a completion is called.
+  def agent; M.agent; end
+
+  # Lists all methods that have argument completion.
+  def list_methods; MethodMission.all_methods; end
+end