Class: Rouge::RegexLexer Abstract

Inherits:
Lexer
  • Object
show all
Defined in:
lib/rouge/regex_lexer.rb

Overview

This class is abstract.

A stateful lexer that uses sets of regular expressions to tokenize a string. Most lexers are instances of RegexLexer.

Defined Under Namespace

Classes: Rule, State, StateDSL

Constant Summary collapse

MAX_NULL_SCANS =

The number of successive scans permitted without consuming the input stream. If this is exceeded, the match fails.

5

Constants included from Token::Tokens

Token::Tokens::Num, Token::Tokens::Str

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Lexer

aliases, all, analyze_text, assert_utf8!, #debug, default_options, demo, demo_file, desc, filenames, find, find_fancy, guess, guess_by_filename, guess_by_mimetype, guess_by_source, guesses, #initialize, #lex, lex, mimetypes, #option, #options, tag, #tag

Methods included from Token::Tokens

token

Constructor Details

This class inherits a constructor from Rouge::Lexer

Class Method Details

.append(state, &b) ⇒ Object


184
185
186
187
188
# File 'lib/rouge/regex_lexer.rb', line 184

def self.append(state, &b)
  name = name.to_s
  dsl = state_definitions[name] or raise "no such state #{name.inspect}"
  replace_state(name, dsl.appended(&b))
end

.get_state(name) ⇒ Object


191
192
193
194
195
196
197
198
# File 'lib/rouge/regex_lexer.rb', line 191

def self.get_state(name)
  return name if name.is_a? State

  states[name.to_sym] ||= begin
    defn = state_definitions[name.to_s] or raise "unknown state: #{name.inspect}"
    defn.to_state(self)
  end
end

.prepend(name, &b) ⇒ Object


178
179
180
181
182
# File 'lib/rouge/regex_lexer.rb', line 178

def self.prepend(name, &b)
  name = name.to_s
  dsl = state_definitions[name] or raise "no such state #{name.inspect}"
  replace_state(name, dsl.prepended(&b))
end

.replace_state(name, new_defn) ⇒ Object


151
152
153
154
# File 'lib/rouge/regex_lexer.rb', line 151

def self.replace_state(name, new_defn)
  states[name] = nil
  state_definitions[name] = new_defn
end

.start(&b) ⇒ Object

Specify an action to be run every fresh lex.

Examples:

start { puts "I'm lexing a new string!" }

167
168
169
# File 'lib/rouge/regex_lexer.rb', line 167

def self.start(&b)
  start_procs << b
end

.start_procsObject

The routines to run at the beginning of a fresh lex.

See Also:


158
159
160
# File 'lib/rouge/regex_lexer.rb', line 158

def self.start_procs
  @start_procs ||= InheritableList.new(superclass.start_procs)
end

.state(name, &b) ⇒ Object

Define a new state for this lexer with the given name. The block will be evaluated in the context of a StateDSL.


173
174
175
176
# File 'lib/rouge/regex_lexer.rb', line 173

def self.state(name, &b)
  name = name.to_s
  state_definitions[name] = StateDSL.new(name, &b)
end

.state_definitionsObject


146
147
148
# File 'lib/rouge/regex_lexer.rb', line 146

def self.state_definitions
  @state_definitions ||= InheritableHash.new(superclass.state_definitions)
end

.statesObject

The states hash for this lexer.

See Also:


142
143
144
# File 'lib/rouge/regex_lexer.rb', line 142

def self.states
  @states ||= {}
end

Instance Method Details

#delegate(lexer, text = nil) ⇒ Object

Delegate the lex to another lexer. The #lex method will be called with `:continue` set to true, so that #reset! will not be called. In this way, a single lexer can be repeatedly delegated to while maintaining its own internal state stack.

Parameters:

  • lexer (#lex)

    The lexer or lexer class to delegate to

  • text (String) (defaults to: nil)

    The text to delegate. This defaults to the last matched string.


351
352
353
354
355
356
357
358
359
# File 'lib/rouge/regex_lexer.rb', line 351

def delegate(lexer, text=nil)
  puts "    delegating to #{lexer.inspect}" if @debug
  text ||= @current_stream[0]

  lexer.lex(text, :continue => true) do |tok, val|
    puts "    delegated token: #{tok.inspect}, #{val.inspect}" if @debug
    yield_token(tok, val)
  end
end

#get_state(state_name) ⇒ Object


201
202
203
# File 'lib/rouge/regex_lexer.rb', line 201

def get_state(state_name)
  self.class.get_state(state_name)
end

#goto(state_name) ⇒ Object

replace the head of the stack with the given state


395
396
397
398
399
400
# File 'lib/rouge/regex_lexer.rb', line 395

def goto(state_name)
  raise 'empty stack!' if stack.empty?

  puts "    going to state #{state_name} " if @debug
  stack[-1] = get_state(state_name)
end

#group(tok) ⇒ Object

Deprecated.

Yield a token with the next matched group. Subsequent calls to this method will yield subsequent groups.


330
331
332
# File 'lib/rouge/regex_lexer.rb', line 330

def group(tok)
  raise "RegexLexer#group is deprecated: use #groups instead"
end

#groups(*tokens) ⇒ Object

Yield tokens corresponding to the matched groups of the current match.


336
337
338
339
340
# File 'lib/rouge/regex_lexer.rb', line 336

def groups(*tokens)
  tokens.each_with_index do |tok, i|
    yield_token(tok, @current_stream[i+1])
  end
end

#in_state?(state_name) ⇒ Boolean

Check if `state_name` is in the state stack.

Returns:

  • (Boolean)

410
411
412
413
414
415
# File 'lib/rouge/regex_lexer.rb', line 410

def in_state?(state_name)
  state_name = state_name.to_s
  stack.any? do |state|
    state.name == state_name.to_s
  end
end

#pop!(times = 1) ⇒ Object

Pop the state stack. If a number is passed in, it will be popped that number of times.


384
385
386
387
388
389
390
391
392
# File 'lib/rouge/regex_lexer.rb', line 384

def pop!(times=1)
  raise 'empty stack!' if stack.empty?

  puts "    popping stack: #{times}" if @debug

  stack.pop(times)

  nil
end

#push(state_name = nil, &b) ⇒ Object

Push a state onto the stack. If no state name is given and you've passed a block, a state will be dynamically created using the StateDSL.


368
369
370
371
372
373
374
375
376
377
378
379
380
# File 'lib/rouge/regex_lexer.rb', line 368

def push(state_name=nil, &b)
  push_state = if state_name
    get_state(state_name)
  elsif block_given?
    StateDSL.new(b.inspect, &b).to_state(self.class)
  else
    # use the top of the stack by default
    self.state
  end

  puts "    pushing #{push_state.name}" if @debug
  stack.push(push_state)
end

#recurse(text = nil) ⇒ Object


361
362
363
# File 'lib/rouge/regex_lexer.rb', line 361

def recurse(text=nil)
  delegate(self.class, text)
end

#reset!Object

reset this lexer to its initial state. This runs all of the start_procs.


222
223
224
225
226
227
228
229
# File 'lib/rouge/regex_lexer.rb', line 222

def reset!
  @stack = nil
  @current_stream = nil

  self.class.start_procs.each do |pr|
    instance_eval(&pr)
  end
end

#reset_stackObject

reset the stack back to `[:root]`.


403
404
405
406
407
# File 'lib/rouge/regex_lexer.rb', line 403

def reset_stack
  puts '    resetting stack' if @debug
  stack.clear
  stack.push get_state(:root)
end

#stackObject

The state stack. This is initially the single state `[:root]`. It is an error for this stack to be empty.

See Also:


208
209
210
# File 'lib/rouge/regex_lexer.rb', line 208

def stack
  @stack ||= [get_state(:root)]
end

#stateObject

The current state - i.e. one on top of the state stack.

NB: if the state stack is empty, this will throw an error rather than returning nil.


216
217
218
# File 'lib/rouge/regex_lexer.rb', line 216

def state
  stack.last or raise 'empty stack!'
end

#state?(state_name) ⇒ Boolean

Check if `state_name` is the state on top of the state stack.

Returns:

  • (Boolean)

418
419
420
# File 'lib/rouge/regex_lexer.rb', line 418

def state?(state_name)
  state_name.to_s == state.name
end

#step(state, stream) ⇒ Object

Runs one step of the lex. Rules in the current state are tried until one matches, at which point its callback is called.

Returns:

  • true if a rule was tried successfully

  • false otherwise.


276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
# File 'lib/rouge/regex_lexer.rb', line 276

def step(state, stream)
  state.rules.each do |rule|
    if rule.is_a?(State)
      puts "  entering mixin #{rule.name}" if @debug
      return true if step(rule, stream)
      puts "  exiting  mixin #{rule.name}" if @debug
    else
      puts "  trying #{rule.inspect}" if @debug

      # XXX HACK XXX
      # StringScanner's implementation of ^ is b0rken.
      # see http://bugs.ruby-lang.org/issues/7092
      # TODO: this doesn't cover cases like /(a|^b)/, but it's
      # the most common, for now...
      next if rule.beginning_of_line && !stream.beginning_of_line?

      if size = stream.skip(rule.re)
        puts "    got #{stream[0].inspect}" if @debug

        instance_exec(stream, &rule.callback)

        if size.zero?
          @null_steps += 1
          if @null_steps > MAX_NULL_SCANS
            puts "    too many scans without consuming the string!" if @debug
            return false
          end
        else
          @null_steps = 0
        end

        return true
      end
    end
  end

  false
end

#stream_tokens(str, &b) ⇒ Object

This implements the lexer protocol, by yielding [token, value] pairs.

The process for lexing works as follows, until the stream is empty:

  1. We look at the state on top of the stack (which by default is `[:root]`).

  2. Each rule in that state is tried until one is successful. If one is found, that rule's callback is evaluated - which may yield tokens and manipulate the state stack. Otherwise, one character is consumed with an `'Error'` token, and we continue at (1.)


243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
# File 'lib/rouge/regex_lexer.rb', line 243

def stream_tokens(str, &b)
  stream = StringScanner.new(str)

  @current_stream = stream
  @output_stream  = b
  @states         = self.class.states
  @null_steps     = 0

  until stream.eos?
    if @debug
      puts "lexer: #{self.class.tag}"
      puts "stack: #{stack.map(&:name).inspect}"
      puts "stream: #{stream.peek(20).inspect}"
    end

    success = step(state, stream)

    if !success
      puts "    no match, yielding Error" if @debug
      b.call(Token::Tokens::Error, stream.getch)
    end
  end
end

#token(tok, val = @current_stream[0]) ⇒ Object

Yield a token.

Parameters:

  • tok

    the token type

  • val (defaults to: @current_stream[0])

    (optional) the string value to yield. If absent, this defaults to the entire last match.


322
323
324
# File 'lib/rouge/regex_lexer.rb', line 322

def token(tok, val=@current_stream[0])
  yield_token(tok, val)
end