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/input.rb,
lib/bond/agent.rb,
lib/bond/search.rb,
lib/bond/rawline.rb,
lib/bond/mission.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

VERSION = 
'0.2.2'

Instance Method Summary (collapse)

Instance Method Details

- (Object) agent

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



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

def agent; M.agent end

- (Object) complete(options = {}, &block)

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:

  • (Hash) options (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):

  • (Regexp) :on N/A —

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

  • (String) :method N/A —

    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.

  • (Array<String>) :methods N/A —

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

  • (String) :class N/A —

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

  • (String) :object N/A —

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

  • (String) :anywhere N/A —

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

  • (String) :prefix N/A —

    Optional string to prefix :anywhere.

  • (Symbol, false) :search N/A —

    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.

  • (String, Symbol) :action N/A —

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

  • (Integer, :last) :place N/A —

    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.

  • (Symbol, String) :name N/A —

    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

- (Hash) config

Global config

Returns:

  • (Hash) —

    Global config 



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

def config; M.config end

- (Object) list_methods

Lists all methods that have argument completion. 



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

def list_methods; MethodMission.all_methods end

- (Object) load_gems(*gems)

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



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

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

- (Object) load_yard_gems(*gems)

Generates and loads completions for yardoc documented gems.

Parameters:

  • *gems —

    Gem(s) with optional options hash at the end

Options Hash (*gems):

  • (Boolean) :verbose — default: false —

    Displays additional information when building yardoc.

  • (Boolean) :reload — default: false —

    Rebuilds yard databases. Use when gems have changed versions. 



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

def load_yard_gems(*gems) Yard.load_yard_gems(*gems) end

- (Object) recomplete(options = {}, &block)

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

- (Object) spy(*args)

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

- (Object) start(options = {}, &block)

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:

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

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

Options Hash (options):

  • (Array<String>) :gems N/A —

    Gems which have their completions loaded from @gem_source/lib/bond/completions/*.rb.

  • (Array<String>) :yard_gems N/A —

    Gems using yard documentation to generate completions. See Yard.

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

    Specifies a Bond plugin to interface with a Readline-like library. Available plugins are Bond::Readline and Bond::Rawline.

  • (Proc) :default_mission — default: DefaultMission —

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

  • (Symbol) :default_search — 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.

  • (Binding) :eval_binding — default: TOPLEVEL_BINDING —

    Binding to use when evaluating objects in ObjectMission and MethodMission. When in irb, defaults to irb’s current binding.

  • (Boolean) :debug — default: false —

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

  • (Boolean) :eval_debug — default: false —

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



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

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