Class: Bond::Mission

Inherits:

Object

• Object
• Bond::Mission

show all

Defined in:

lib/bond/mission.rb

Overview

Constant Summary

OPERATORS =

All known operator methods

%w{% & * ** + - / < << <= <=> == === =~ > >= >> [] []= ^ | ~ ! != !~}

OBJECTS =

Regular expressions which describe common objects for MethodMission and ObjectMission

%w<\([^\)]*\) '[^']*' "[^"]*" \/[^\/]*\/> +
%w<(?:%q|%r|%Q|%w|%s|%)?\[[^\]]*\] (?:proc|lambda|%q|%r|%Q|%w|%s|%)?\s*\{[^\}]*\}>

Instance Attribute Summary (collapse)

• - (Object) action readonly

  Generates array of possible completions and searches them if search is disabled.

• - (Object) matched readonly

  A MatchData object generated from matching the user input with the condition.

• - (Object) on readonly

  Regexp condition.

• - (Object) place readonly

  See #complete’s :place.

Class Method Summary (collapse)

• + (Object) create(options)

  Handles creation of proper Mission class depending on the options passed.

• + (Object) current_eval(string, ebinding = eval_binding)

  Calls eval with either the irb’s current workspace binding or TOPLEVEL_BINDING.

Instance Method Summary (collapse)

• - (Object) after_match(input)

  Stuff a mission needs to do after matching successfully, in preparation for Mission.execute.

• - (Object) call_action(input)

  Calls the action to generate an array of possible completions.

• - (Object) call_search(search, input, list)

  Searches possible completions from the action which match the input.

• - (Object) condition

  A regexp representing the condition under which a mission matches the input.

• - (Object) do_match(input)

  Method which must return non-nil for a mission to match.

• - (Object) execute(input = @input)

  Called when a mission has been chosen to autocomplete.

• - (Mission) initialize(options) constructor

  Takes same options as #complete.

• - (Object) match_message

  A message used to explains under what conditions a mission matched the user input.

• - (Boolean) matches?(input)

  Returns a boolean indicating if a mission matches the given Input and should be executed for completion.

• - (Object) name

  The name or generated unique_id for a mission.

54
55
56
57
58
59
60
61

# File 'lib/bond/mission.rb', line 54

def initialize(options)
  raise InvalidMissionError, ":action" unless (options[:action] || respond_to?(:default_action))
  raise InvalidMissionError, ":on" unless (options[:on] && options[:on].is_a?(Regexp)) || respond_to?(:default_on)
  @action, @on = options[:action], options[:on]
  @place = options[:place] if options[:place]
  @name = options[:name] if options[:name]
  @search = options.has_key?(:search) ? options[:search] : Search.default_search
end

46
47
48

# File 'lib/bond/mission.rb', line 46

def action
  @action
end

50
51
52

# File 'lib/bond/mission.rb', line 50

def matched
  @matched
end

52
53
54

# File 'lib/bond/mission.rb', line 52

def on
  @on
end

48
49
50

# File 'lib/bond/mission.rb', line 48

def place
  @place
end

18
19
20
21
22
23
24
25
26

# File 'lib/bond/mission.rb', line 18

def create(options)
  if options[:method] || options[:methods] then MethodMission.create(options)
  elsif options[:object]                   then ObjectMission.new(options)
  elsif options[:anywhere]                 then AnywhereMission.new(options)
  elsif options[:all_methods]              then MethodMission.new(options)
  elsif options[:all_operator_methods]     then OperatorMethodMission.new(options)
  else                                          new(options)
  end
end

29
30
31

# File 'lib/bond/mission.rb', line 29

def current_eval(string, ebinding=eval_binding)
  eval(string, ebinding)
end

125
126
127

# File 'lib/bond/mission.rb', line 125

def after_match(input)
  create_input(input[/\S+$/])
end

94
95
96
97
98
99
100
101

# File 'lib/bond/mission.rb', line 94

def call_action(input)
  @action.respond_to?(:call) ? @action.call(input) : Rc.send(@action, input)
rescue StandardError, SyntaxError
  message = $!.is_a?(NoMethodError) && !@action.respond_to?(:call) &&
    !Rc.respond_to?(@action) ? "Completion action '#{@action}' doesn't exist." :
    "Failed during completion action with '#{$!.message}'."
  raise FailedMissionError.new(self), message
end

84
85
86
87
88
89
90
91

# File 'lib/bond/mission.rb', line 84

def call_search(search, input, list)
  Rc.send("#{search}_search", input || '', list)
rescue
  message = $!.is_a?(NoMethodError) && !Rc.respond_to?("#{search}_search") ?
    "Completion search '#{search}' doesn't exist." :
    "Failed during completion search with '#{$!.message}'."
  raise FailedMissionError.new(self), message
end

110
111
112

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

def condition
  self.class.const_defined?(:CONDITION) ? Regexp.new(self.class.const_get(:CONDITION)) : @on
end

120
121
122

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

def do_match(input)
  @matched = input.match(@on)
end

71
72
73
74
75
76
77
78
79
80
81

# File 'lib/bond/mission.rb', line 71

def execute(input=@input)
  completions = Array(call_action(input)).map {|e| e.to_s }
  completions = call_search(@search, input, completions) if @search
  if @completion_prefix
    # Everything up to last break char stays on the line.
    # Must ensure only chars after break are prefixed
    @completion_prefix = @completion_prefix[/([^#{Readline::DefaultBreakCharacters}]+)$/,1] || ''
    completions = completions.map {|e| @completion_prefix + e }
  end
  completions
end

105
106
107

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

def match_message
  "Matches completion with condition #{condition.inspect}."
end

64
65
66
67
68

# File 'lib/bond/mission.rb', line 64

def matches?(input)
  @matched = @input = @completion_prefix = @eval_binding = nil
  (match = do_match(input)) && after_match(@line = input)
  !!match
end

115
116
117

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

def name
  @name ? @name.to_s : unique_id
end