Module: Bond

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

Defined Under Namespace

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

Constant Summary collapse

VERSION = 
'0.3.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.



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

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.



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

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

#config ⇒ Hash

Returns Global config.

Returns:

  • (Hash) —

    Global config



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

def config; M.config; end

#list_methods ⇒ Object

Lists all methods that have argument completion.



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

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.



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

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

#load_yard_gems(*gems) ⇒ Object

Generates and loads completions for yardoc documented gems.

Parameters:

  • *gems —

    Gem(s) with optional options hash at the end



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

def load_yard_gems(*gems); Yard.load_yard_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}}



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

def recomplete(options={}, &block); M.recomplete(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"]



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

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, completions from :yard_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.

  • :yard_gems (Array<String>) —

    Gems using yard documentation to generate completions. See Yard.

  • :readline_plugin (Module) — default: Bond::Readline —

    Specifies a Bond plugin to interface with a Readline-like library. Available plugins are Bond::Readline 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.



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

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