Class: Dentaku::TokenMatcher

Inherits:
Object
  • Object
show all
Defined in:
lib/dentaku/token_matcher.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(categories = nil, values = nil, children = []) ⇒ TokenMatcher

Returns a new instance of TokenMatcher.



7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/dentaku/token_matcher.rb', line 7

def initialize(categories = nil, values = nil, children = [])
  # store categories and values as hash to optimize key lookup, h/t @jan-mangs
  @categories = [categories].compact.flatten.each_with_object({}) { |c, h| h[c] = 1 }
  @values     = [values].compact.flatten.each_with_object({}) { |v, h| h[v] = 1 }
  @children   = children.compact
  @invert     = false

  @min = 1
  @max = 1
  @range = (@min..@max)
end

Instance Attribute Details

#categories ⇒ Object (readonly)

Returns the value of attribute categories.



5
6
7
 
# File 'lib/dentaku/token_matcher.rb', line 5

def categories
  @categories
end

#children ⇒ Object (readonly)

Returns the value of attribute children.



5
6
7
 
# File 'lib/dentaku/token_matcher.rb', line 5

def children
  @children
end

#values ⇒ Object (readonly)

Returns the value of attribute values.



5
6
7
 
# File 'lib/dentaku/token_matcher.rb', line 5

def values
  @values
end

Class Method Details

.addsub ⇒ Object 



104
 
# File 'lib/dentaku/token_matcher.rb', line 104

def self.addsub;         new(:operator, [:add, :subtract]);    end

.anchored_minus ⇒ Object 



106
 
# File 'lib/dentaku/token_matcher.rb', line 106

def self.anchored_minus; new(:operator, :subtract).caret;      end

.arguments ⇒ Object 



122
 
# File 'lib/dentaku/token_matcher.rb', line 122

def self.arguments;      (value | comma).plus;                 end

.close ⇒ Object 



117
 
# File 'lib/dentaku/token_matcher.rb', line 117

def self.close;          new(:grouping, :close);               end

.combinator ⇒ Object 



110
 
# File 'lib/dentaku/token_matcher.rb', line 110

def self.combinator;     new(:combinator);                     end

.comma ⇒ Object 



118
 
# File 'lib/dentaku/token_matcher.rb', line 118

def self.comma;          new(:grouping, :comma);               end

.comp_gt ⇒ Object 



113
 
# File 'lib/dentaku/token_matcher.rb', line 113

def self.comp_gt;        new(:comparator, [:gt, :ge]);         end

.comp_lt ⇒ Object 



114
 
# File 'lib/dentaku/token_matcher.rb', line 114

def self.comp_lt;        new(:comparator, [:lt, :le]);         end

.comparator ⇒ Object 



112
 
# File 'lib/dentaku/token_matcher.rb', line 112

def self.comparator;     new(:comparator);                     end

.datetime ⇒ Object 



96
 
# File 'lib/dentaku/token_matcher.rb', line 96

def self.datetime;       new(:datetime);                       end

.if ⇒ Object 



124
 
# File 'lib/dentaku/token_matcher.rb', line 124

def self.if;             new(:function, :if);                  end

.logical ⇒ Object 



99
 
# File 'lib/dentaku/token_matcher.rb', line 99

def self.logical;        new(:logical);                        end

.method_missing(name, *args, &block) ⇒ Object 



130
131
132
 
# File 'lib/dentaku/token_matcher.rb', line 130

def self.method_missing(name, *args, &block)
  new(:function, name)
end

.mod ⇒ Object 



109
 
# File 'lib/dentaku/token_matcher.rb', line 109

def self.mod;            new(:operator, :mod);                 end

.muldiv ⇒ Object 



107
 
# File 'lib/dentaku/token_matcher.rb', line 107

def self.muldiv;         new(:operator, [:multiply, :divide]); end

.non_close_plus ⇒ Object 



121
 
# File 'lib/dentaku/token_matcher.rb', line 121

def self.non_close_plus; new(:grouping, :close).invert.plus;   end

.non_group ⇒ Object 



119
 
# File 'lib/dentaku/token_matcher.rb', line 119

def self.non_group;      new(:grouping).invert;                end

.non_group_star ⇒ Object 



120
 
# File 'lib/dentaku/token_matcher.rb', line 120

def self.non_group_star; new(:grouping).invert.star;           end

.not ⇒ Object 



128
 
# File 'lib/dentaku/token_matcher.rb', line 128

def self.not;            new(:function, :not);                 end

.numeric ⇒ Object 



97
 
# File 'lib/dentaku/token_matcher.rb', line 97

def self.numeric;        new(:numeric);                        end

.open ⇒ Object 



116
 
# File 'lib/dentaku/token_matcher.rb', line 116

def self.open;           new(:grouping, :open);                end

.pow ⇒ Object 



108
 
# File 'lib/dentaku/token_matcher.rb', line 108

def self.pow;            new(:operator, :pow);                 end

.respond_to_missing?(name, include_priv) ⇒ Boolean

Returns:

  • (Boolean) 


134
135
136
 
# File 'lib/dentaku/token_matcher.rb', line 134

def self.respond_to_missing?(name, include_priv)
  true
end

.round ⇒ Object 



125
 
# File 'lib/dentaku/token_matcher.rb', line 125

def self.round;          new(:function, :round);               end

.rounddown ⇒ Object 



127
 
# File 'lib/dentaku/token_matcher.rb', line 127

def self.rounddown;      new(:function, :rounddown);           end

.roundup ⇒ Object 



126
 
# File 'lib/dentaku/token_matcher.rb', line 126

def self.roundup;        new(:function, :roundup);             end

.string ⇒ Object 



98
 
# File 'lib/dentaku/token_matcher.rb', line 98

def self.string;         new(:string);                         end

.subtract ⇒ Object 



105
 
# File 'lib/dentaku/token_matcher.rb', line 105

def self.subtract;       new(:operator, :subtract);            end

.value ⇒ Object 



100
101
102
 
# File 'lib/dentaku/token_matcher.rb', line 100

def self.value
  new(:datetime) | new(:numeric) | new(:string) | new(:logical)
end

Instance Method Details

#==(token) ⇒ Object 



28
29
30
 
# File 'lib/dentaku/token_matcher.rb', line 28

def ==(token)
  leaf_matcher? ? matches_token?(token) : any_child_matches_token?(token)
end

#caret ⇒ Object 



47
48
49
50
 
# File 'lib/dentaku/token_matcher.rb', line 47

def caret
  @caret = true
  self
end

#caret? ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
 
# File 'lib/dentaku/token_matcher.rb', line 52

def caret?
  @caret
end

#invert ⇒ Object 



23
24
25
26
 
# File 'lib/dentaku/token_matcher.rb', line 23

def invert
  @invert = ! @invert
  self
end

#leaf_matcher? ⇒ Boolean

Returns:

  • (Boolean) 


69
70
71
 
# File 'lib/dentaku/token_matcher.rb', line 69

def leaf_matcher?
  children.empty?
end

#leaf_matchers ⇒ Object 



73
74
75
 
# File 'lib/dentaku/token_matcher.rb', line 73

def leaf_matchers
  leaf_matcher? ? [self] : children
end

#match(token_stream, offset = 0) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/dentaku/token_matcher.rb', line 32

def match(token_stream, offset = 0)
  matched_tokens = []
  matched = false

  while self == token_stream[matched_tokens.length + offset] && matched_tokens.length < @max
    matched_tokens << token_stream[matched_tokens.length + offset]
  end

  if @range.cover?(matched_tokens.length)
    matched = true
  end

  [matched, matched_tokens]
end

#plus ⇒ Object 



63
64
65
66
67
 
# File 'lib/dentaku/token_matcher.rb', line 63

def plus
  @max = Float::INFINITY
  @range = (@min..@max)
  self
end

#star ⇒ Object 



56
57
58
59
60
61
 
# File 'lib/dentaku/token_matcher.rb', line 56

def star
  @min = 0
  @max = Float::INFINITY
  @range = (@min..@max)
  self
end

#|(other_matcher) ⇒ Object 



19
20
21
 
# File 'lib/dentaku/token_matcher.rb', line 19

def |(other_matcher)
  self.class.new(:nomatch, :nomatch, leaf_matchers + other_matcher.leaf_matchers)
end