Class: Regexp::Syntax::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/regexp_parser/syntax.rb

Overview

A lookup map of supported types and tokens in a given syntax

Direct Known Subclasses

Any, Ruby::V186

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Base

Returns a new instance of Base.



112
113
114
115
116
117
 
# File 'lib/regexp_parser/syntax.rb', line 112

def initialize
  @implements = {}

  implements Token::Literal::Type,   Token::Literal::All
  implements Token::FreeSpace::Type, Token::FreeSpace::All
end

Instance Method Details

#excludes(type, tokens) ⇒ Object

removes



132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'lib/regexp_parser/syntax.rb', line 132

def excludes(type, tokens)
  if tokens
    tokens = [tokens] unless tokens.is_a?(Array)
  end

  if @implements[type]
    if tokens
      @implements[type] = @implements[type] - tokens
      @implements[type] = nil if @implements[type].empty?
    else
      @implements[type] = nil
    end
  end
end

#implementation ⇒ Object 



119
120
121
 
# File 'lib/regexp_parser/syntax.rb', line 119

def implementation
  @implements
end

#implements(type, tokens) ⇒ Object 



123
124
125
126
127
128
129
 
# File 'lib/regexp_parser/syntax.rb', line 123

def implements(type, tokens)
  if @implements[type]
    @implements[type] = (@implements[type] + tokens).uniq
  else
    @implements[type] = tokens
  end
end

#implements!(type, token) ⇒ Object Also known as: check!

Raises:



153
154
155
156
 
# File 'lib/regexp_parser/syntax.rb', line 153

def implements!(type, token)
  raise NotImplementedError.new(self, type, token) unless
    implements?(type, token)
end

#implements?(type, token) ⇒ Boolean Also known as: check?

Returns:

  • (Boolean) 


147
148
149
150
 
# File 'lib/regexp_parser/syntax.rb', line 147

def implements?(type, token)
  return true if @implements[type] and @implements[type].include?(token)
  false
end

#normalize(type, token) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
 
# File 'lib/regexp_parser/syntax.rb', line 159

def normalize(type, token)
  case type
  when :group
    normalize_group(type, token)
  when :backref
    normalize_backref(type, token)
  else
    [type, token]
  end
end

#normalize_backref(type, token) ⇒ Object 



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/regexp_parser/syntax.rb', line 179

def normalize_backref(type, token)
  case token
  when :name_ref_ab, :name_ref_sq
    [:backref, :name_ref]
  when :name_call_ab, :name_call_sq
    [:backref, :name_call]
  when :name_nest_ref_ab, :name_nest_ref_sq
    [:backref, :name_nest_ref]
  when :number_ref_ab, :number_ref_sq
    [:backref, :number_ref]
  when :number_call_ab, :number_call_sq
    [:backref, :number_call]
  when :number_rel_ref_ab, :number_rel_ref_sq
    [:backref, :number_rel_ref]
  when :number_rel_call_ab, :number_rel_call_sq
    [:backref, :number_rel_call]
  when :number_nest_ref_ab, :number_nest_ref_sq
    [:backref, :number_nest_ref]
  else
    [type, token]
  end
end

#normalize_group(type, token) ⇒ Object 



170
171
172
173
174
175
176
177
 
# File 'lib/regexp_parser/syntax.rb', line 170

def normalize_group(type, token)
  case token
  when :named_ab, :named_sq
    [:group, :named]
  else
    [type, token]
  end
end