Class: Rouge::RegexLexer::StateDSL

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

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(rules) ⇒ StateDSL

Returns a new instance of StateDSL.



63
64
65
 
# File 'lib/rouge/regex_lexer.rb', line 63

def initialize(rules)
  @rules = rules
end

Instance Attribute Details

#rules ⇒ Object (readonly)

Returns the value of attribute rules.



62
63
64
 
# File 'lib/rouge/regex_lexer.rb', line 62

def rules
  @rules
end

Instance Method Details

#mixin(lexer_name) ⇒ Object

Mix in the rules from another state into this state. The rules from the mixed-in state will be tried in order before moving on to the rest of the rules in this state.



102
103
104
 
# File 'lib/rouge/regex_lexer.rb', line 102

def mixin(lexer_name)
  rules << lexer_name.to_s
end

#rule(re, token, next_state = nil) ⇒ Object #rule(re, &callback) ⇒ Object

Define a new rule for this state.

Parameters:

  • re (Regexp) —

    a regular expression for this rule to test.

  • tok (String) (defaults to: nil) —

    the token type to yield if ‘re` matches.

  • next_state (#to_s) (defaults to: nil) —

    (optional) a state to push onto the stack if ‘re` matches. If `next_state` is `:pop!`, the state stack will be popped instead.

  • callback (Proc) —

    a block that will be evaluated in the context of the lexer if ‘re` matches. This block has access to a number of lexer methods, including Rouge::RegexLexer#push, Rouge::RegexLexer#pop!, Rouge::RegexLexer#token, and Rouge::RegexLexer#delegate. The first argument can be used to access the match groups.



86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/rouge/regex_lexer.rb', line 86

def rule(re, tok=nil, next_state=nil, &callback)
  callback ||= case next_state
  when :pop!
    proc { token tok; pop! }
  when Symbol
    proc { token tok; push next_state }
  else
    proc { token tok }
  end

  rules << Rule.new(re, callback)
end