Class: Regexp::Expression::Subexpression
- Includes:
- Enumerable
- Defined in:
- lib/regexp_parser/expression/subexpression.rb,
lib/regexp_parser/expression/methods/traverse.rb,
lib/regexp_parser/expression/methods/strfregexp.rb
Direct Known Subclasses
CharacterSet, CharacterSet::Range, Conditional::Expression, Group::Base, Root, Sequence, SequenceOperation
Instance Attribute Summary collapse
-
#expressions ⇒ Object
Returns the value of attribute expressions.
Attributes inherited from Base
#conditional_level, #level, #nesting_level, #options, #quantifier, #set_level, #text, #token, #ts, #type
Instance Method Summary collapse
- #<<(exp) ⇒ Object
- #dig(*indices) ⇒ Object
-
#each_expression(include_self = false, &block) ⇒ Object
Iterates over the expressions of this expression as an array, passing the expression and its index within its parent to the given block.
-
#flat_map(include_self = false, &block) ⇒ Object
Returns a new array with the results of calling the given block once for every expression.
-
#initialize(token, options = {}) ⇒ Subexpression
constructor
A new instance of Subexpression.
-
#initialize_clone(other) ⇒ Object
Override base method to clone the expressions as well.
- #strfregexp_tree(format = '%a', include_self = true, separator = "\n") ⇒ Object (also: #strfre_tree)
- #te ⇒ Object
- #to_h ⇒ Object
- #to_s(format = :full) ⇒ Object
-
#traverse(include_self = false, &block) ⇒ Object
(also: #walk)
Traverses the subexpression (depth-first, pre-order) and calls the given block for each expression with three arguments; the traversal event, the expression, and the index of the expression within its parent.
Methods inherited from Base
#ascii_classes?, #attributes, #case_insensitive?, #coded_offset, #default_classes?, #free_spacing?, #full_length, #greedy?, #is?, #match, #matches?, #multiline?, #offset, #one_of?, #possessive?, #quantified?, #quantifier_affix, #quantify, #quantity, #reluctant?, #strfregexp, #terminal?, #to_re, #type?, #unicode_classes?
Constructor Details
#initialize(token, options = {}) ⇒ Subexpression
Returns a new instance of Subexpression.
8 9 10 11 12 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 8 def initialize(token, = {}) super self.expressions = [] end |
Instance Attribute Details
#expressions ⇒ Object
Returns the value of attribute expressions.
6 7 8 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 6 def expressions @expressions end |
Instance Method Details
#<<(exp) ⇒ Object
20 21 22 23 24 25 26 27 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 20 def <<(exp) if exp.is_a?(WhiteSpace) && last && last.is_a?(WhiteSpace) last.merge(exp) else exp.nesting_level = nesting_level + 1 expressions << exp end end |
#dig(*indices) ⇒ Object
37 38 39 40 41 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 37 def dig(*indices) exp = self indices.each { |idx| exp = exp.nil? || exp.terminal? ? nil : exp[idx] } exp end |
#each_expression(include_self = false, &block) ⇒ Object
Iterates over the expressions of this expression as an array, passing the expression and its index within its parent to the given block.
39 40 41 42 43 |
# File 'lib/regexp_parser/expression/methods/traverse.rb', line 39 def each_expression(include_self = false, &block) traverse(include_self) do |event, exp, index| yield(exp, index) unless event == :exit end end |
#flat_map(include_self = false, &block) ⇒ Object
Returns a new array with the results of calling the given block once for every expression. If a block is not given, returns an array with each expression and its level index as an array.
48 49 50 51 52 53 54 55 56 57 58 59 60 |
# File 'lib/regexp_parser/expression/methods/traverse.rb', line 48 def flat_map(include_self = false, &block) result = [] each_expression(include_self) do |exp, index| if block_given? result << yield(exp, index) else result << [exp, index] end end result end |
#initialize_clone(other) ⇒ Object
Override base method to clone the expressions as well.
15 16 17 18 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 15 def initialize_clone(other) other.expressions = expressions.map(&:clone) super end |
#strfregexp_tree(format = '%a', include_self = true, separator = "\n") ⇒ Object Also known as: strfre_tree
103 104 105 106 107 108 109 110 111 |
# File 'lib/regexp_parser/expression/methods/strfregexp.rb', line 103 def strfregexp_tree(format = '%a', include_self = true, separator = "\n") output = include_self ? [self.strfregexp(format)] : [] output += flat_map do |exp, index| exp.strfregexp(format, (include_self ? 1 : 0), index) end output.join(separator) end |
#te ⇒ Object
43 44 45 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 43 def te ts + to_s.length end |
#to_h ⇒ Object
54 55 56 57 58 59 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 54 def to_h attributes.merge({ text: to_s(:base), expressions: expressions.map(&:to_h) }) end |
#to_s(format = :full) ⇒ Object
47 48 49 50 51 52 |
# File 'lib/regexp_parser/expression/subexpression.rb', line 47 def to_s(format = :full) # Note: the format does not get passed down to subexpressions. # Note: cant use #text accessor, b/c it is overriden as def text; to_s end # in Expression::Sequence, causing infinite recursion. Clean-up needed. "#{@text}#{expressions.join}#{quantifier_affix(format)}" end |
#traverse(include_self = false, &block) ⇒ Object Also known as: walk
Traverses the subexpression (depth-first, pre-order) and calls the given block for each expression with three arguments; the traversal event, the expression, and the index of the expression within its parent.
The event argument is passed as follows:
-
For subexpressions, :enter upon entering the subexpression, and :exit upon exiting it.
-
For terminal expressions, :visit is called once.
Returns self.
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
# File 'lib/regexp_parser/expression/methods/traverse.rb', line 16 def traverse(include_self = false, &block) raise 'traverse requires a block' unless block_given? block.call(:enter, self, 0) if include_self each_with_index do |exp, index| if exp.terminal? block.call(:visit, exp, index) else block.call(:enter, exp, index) exp.traverse(&block) block.call(:exit, exp, index) end end block.call(:exit, self, 0) if include_self self end |