Module: Bond

Extended by:
Included in:
Defined in:

Defined Under Namespace

Modules: M, Rc, Search Classes: Agent, AnywhereMission, DefaultMission, FailedMissionError, Input, InvalidMissionError, Jruby, MethodMission, Mission, ObjectMission, OperatorMethodMission, Rawline, Readline, Ruby

Constant Summary collapse


Instance Method Summary collapse

Instance Method Details


An Agent who saves all Bond.complete missions and executes the correct one when a completion is called.

# File 'lib/bond.rb', line 123

def agent; M.agent; end

#complete(options = {}, &block) ⇒ Object

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.


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)


  • options (Hash) (defaults to: {})

    When using :method(s) or :object, some hash keys may have different behavior. See Bond.complete sections of MethodMission and ObjectMission respectively.

Options Hash (options):

  • :on (Regexp)

    Matches the full line of input to create a Mission object.

  • :method (String)

    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.

  • :methods (Array<String>)

    Instance or class method(s) in the format of :method. Creates MethodMission objects.

  • :class (String)

    Optionally used with :method or :methods to represent module/class. Must end in ‘#’ or ‘.’ to indicate instance/class method. Suggested for use with :methods.

  • :object (String)

    Module or class of an object whose methods are completed. Creates ObjectMission object.

  • :anywhere (String)

    String representing a regular expression to match a mission. Creates AnywhereMission object.

  • :prefix (String)

    Optional string to prefix :anywhere.

  • :search (Symbol, false)

    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.

  • :action (String, Symbol)

    Rc method name that takes an Input and returns possible completions. See MethodMission for specific behavior with :method(s).

  • :place (Integer, :last)

    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.

  • :name (Symbol, String)

    Unique id for a mission which can be passed by Bond.recomplete to identify and replace the mission.

# File 'lib/bond.rb', line 61

def complete(options={}, &block); M.complete(options, &block); end


Returns Global config.


  • (Hash)

    Global config

# File 'lib/bond.rb', line 77

def config; M.config; end


Lists all methods that have argument completion.

# File 'lib/bond.rb', line 126

def list_methods; MethodMission.all_methods; end

#load_gems(*gems) ⇒ Object

Loads completions for gems that ship with them under lib/bond/completions/, relative to the gem’s base directory.

# File 'lib/bond.rb', line 120

def load_gems(*gems); M.load_gems(*gems); end

#recomplete(options = {}, &block) ⇒ Object

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.


Bond.recomplete(:on => /man/, :name => :count) { %w{4 5 6}}

# File 'lib/bond.rb', line 67

def recomplete(options={}, &block); M.recomplete(options, &block); end

#restart(options = {}, &block) ⇒ Object

Restarts completions with given options, ensuring to delete current completions. Takes same options as Bond#start.

# File 'lib/bond.rb', line 114

def restart(options={}, &block); M.restart(options, &block); end

#spy(*args) ⇒ Object

Reports what completion mission matches for a given input. Helpful for debugging missions.


>> Bond.spy "shoot oct"
Matches completion mission for method matching "shoot".
Possible completions: ["octopussy"]

# File 'lib/bond.rb', line 74

def spy(*args); M.spy(*args); end

#start(options = {}, &block) ⇒ Object

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.


Bond.start :gems => %w{hirb}
Bond.start(:default_search => :ignore_case) do
  complete(:method => "Object#respond_to?") {|e| e.object.methods }


  • options (Hash) (defaults to: {})

    Sets global keys in #config, some which specify what completions to load.

Options Hash (options):

  • :gems (Array<String>)

    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.

  • :readline (Module, Symbol) — default: 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.

  • :default_mission (Proc) — default: DefaultMission

    Sets default completion to use when no missions match. See Bond::Agent#default_mission.

  • :default_search (Symbol) — default: :underscore

    Name of a *_search method in Rc to use as the default search in completions. See #complete‘s :search option for valid values.

  • :eval_binding (Binding, Proc) — default: 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.

  • :debug (Boolean) — default: false

    Shows the stacktrace when autocompletion fails and raises exceptions in Rc.eval.

  • :eval_debug (Boolean) — default: false

    Raises eval errors occuring when finding a matching completion. Useful to debug an incorrect completion

  • :bare (Boolean) — default: false

    Doesn’t load default ruby completions and completions in ~/.bond*. Useful for non-ruby completions

# File 'lib/bond.rb', line 110

def start(options={}, &block); M.start(options, &block); end


Indicates if Bond has already started


  • (Boolean)

# File 'lib/bond.rb', line 117

def started?; M.started?; end