Module: Bond

Extended by:
Bond
Included in:
Bond
Defined in:
lib/bond.rb,
lib/bond/m.rb,
lib/bond/rc.rb,
lib/bond/agent.rb,
lib/bond/input.rb,
lib/bond/search.rb,
lib/bond/mission.rb,
lib/bond/version.rb,
lib/bond/missions/method_mission.rb,
lib/bond/missions/operator_method_mission.rb

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

VERSION = 
'0.5.1'

Instance Method Summary collapse

Instance Method Details

#agent ⇒ Object

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



123
 
# 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.

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)

Parameters:

  • 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.



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

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

#config ⇒ Hash

Returns Global config.

Returns:

  • (Hash) —

    Global config



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

def config; M.config; end

#list_methods ⇒ Object

Lists all methods that have argument completion.



126
 
# 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.



120
 
# 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.

Example:

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



67
 
# 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.



114
 
# 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.

Example:

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



74
 
# 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.

Examples:

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

Parameters:

  • 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



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

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

#started? ⇒ Boolean

Indicates if Bond has already started

Returns:

  • (Boolean) 


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

def started?; M.started?; end