Module: BEL::Completion

Defined in:
lib/bel/completion.rb,
lib/bel/completion_rule.rb

Overview

Completion defines an API for completing BEL Expressions.

Defined Under Namespace

Modules: Rule Classes: MatchFunctionRule, MatchNamespacePrefixRule, MatchNamespaceValueRule

Constant Summary collapse

SORTED_NAMESPACES = 
BEL::Namespace::NAMESPACE_LATEST.keys.sort.map(&:to_s)
EMPTY_MATCH = 
[]

Class Method Summary collapse

Class Method Details

.complete(bel_expression, specification, search, namespaces, position = nil) ⇒ Array<Completion>

Provides completions on BEL expressions.

If bel_expression is nil then its assumed to be the empty string otherwise the to_s method is called. An empty bel_expression will return all BEL functions as possible completions.

A Resource::Search plugin must be provided that provides completions for namespaces and namespace values.

A Resource::Namespaces API must be provided to resolve namespace properties given a URI.

If position is nil then its assumed to be the last index of bel_expression otherwise the to_i method is called.

If position is negative or greater than the length of bel_expression an IndexError is raised.

complete on provide namespace value completions



35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/bel/completion.rb', line 35

def self.complete(bel_expression, specification, search, namespaces, position = nil)
  #raise ArgumentError.new(
  #  "search should be a BEL::Resource::Search plugin implementation"
  #) unless search
  #raise ArgumentError.new(
  #  "namespaces should be a BEL::Resource::Namespaces object"
  #) unless namespaces

  bel_expression = (bel_expression || '').to_s
  position = (position || bel_expression.length).to_i
  if position < 0 or position > bel_expression.length
    msg = %Q{position #{position}, bel_expression "#{bel_expression}"}
    fail IndexError, msg
  end

  token_list = LibBEL::tokenize_term(bel_expression)
  active_token, active_index = token_list.token_at(position)

  # no active token indicates the position is out of
  # range of all tokens in the list.
  return [] unless active_token

  tokens = token_list.to_a
  options = {
    :search => search
  }
  BEL::Completion::run_rules(
    tokens, active_index, active_token,
    :specification => specification,
    :search        => search,
    :namespaces    => namespaces
  )
end

.rules ⇒ Object

Retrieve all completion rules.



20
21
22
23
24
25
 
# File 'lib/bel/completion_rule.rb', line 20

def self.rules
  constants.map do |const|
    obj = const_get(const)
    obj.new if obj.include?(Rule)
  end.compact
end

.run_rules(tokens, active_index, active_token, options = {}) ⇒ Object

Run all defined rules.



10
11
12
13
14
15
16
17
 
# File 'lib/bel/completion_rule.rb', line 10

def self.run_rules(tokens, active_index, active_token, options = {})
  self.rules.reduce([]) { |completion_results, rule|
    completion_results.concat(
      rule.apply(tokens, active_token, active_index, options)
    )
    completion_results
  }
end