Module: Regexp::Expression::Shared
- Included in:
- Base, Quantifier
- Defined in:
- lib/regexp_parser/expression/shared.rb,
lib/regexp_parser/expression/methods/tests.rb,
lib/regexp_parser/expression/methods/construct.rb
Defined Under Namespace
Modules: ClassMethods
Class Method Summary collapse
Instance Method Summary collapse
-
#==(other) ⇒ Object
(also: #===, #eql?)
Deep-compare two expressions for equality.
- #base_length ⇒ Object
- #coded_offset ⇒ Object
- #full_length ⇒ Object
- #initialize_copy(orig) ⇒ Object
-
#is?(test_token, test_type = nil) ⇒ Boolean
Test if this expression has the given test_token, and optionally a given test_type.
- #nesting_level=(lvl) ⇒ Object
- #offset ⇒ Object
-
#one_of?(scope, top = true) ⇒ Boolean
Test if this expression matches an entry in the given scope spec.
- #parts ⇒ Object
- #quantified? ⇒ Boolean
- #quantifier_affix(expression_format) ⇒ Object
- #starts_at ⇒ Object
- #terminal? ⇒ Boolean
- #to_s(format = :full) ⇒ Object (also: #to_str)
- #token_class ⇒ Object
-
#type?(test_type) ⇒ Boolean
Test if this expression has the given test_type, which can be either a symbol or an array of symbols to check against the expression’s type.
Class Method Details
.included(mod) ⇒ Object
5 6 7 8 9 10 11 12 13 14 15 |
# File 'lib/regexp_parser/expression/shared.rb', line 5 def self.included(mod) mod.class_eval do extend Shared::ClassMethods attr_accessor :type, :token, :text, :ts, :te, :level, :set_level, :conditional_level, :options, :quantifier attr_reader :nesting_level end end |
Instance Method Details
#==(other) ⇒ Object Also known as: ===, eql?
Deep-compare two expressions for equality.
98 99 100 101 102 |
# File 'lib/regexp_parser/expression/methods/tests.rb', line 98 def ==(other) other.class == self.class && other.to_s == to_s && other. == end |
#base_length ⇒ Object
42 43 44 |
# File 'lib/regexp_parser/expression/shared.rb', line 42 def base_length to_s(:base).length end |
#coded_offset ⇒ Object
71 72 73 |
# File 'lib/regexp_parser/expression/shared.rb', line 71 def coded_offset '@%d+%d' % offset end |
#full_length ⇒ Object
46 47 48 |
# File 'lib/regexp_parser/expression/shared.rb', line 46 def full_length to_s.length end |
#initialize_copy(orig) ⇒ Object
31 32 33 34 35 36 |
# File 'lib/regexp_parser/expression/shared.rb', line 31 def initialize_copy(orig) self.text = orig.text.dup if orig.text self. = orig..dup if orig. self.quantifier = orig.quantifier.clone if orig.quantifier super end |
#is?(test_token, test_type = nil) ⇒ Boolean
Test if this expression has the given test_token, and optionally a given test_type.
# Any expressions
exp.is? :* # always returns true
# is it a :capture
exp.is? :capture
# is it a :character and a :set
exp.is? :character, :set
# is it a :meta :dot
exp.is? :dot, :meta
# is it a :meta or :escape :dot
exp.is? :dot, [:meta, :escape]
36 37 38 39 |
# File 'lib/regexp_parser/expression/methods/tests.rb', line 36 def is?(test_token, test_type = nil) return true if test_token === :* token == test_token and (test_type ? type?(test_type) : true) end |
#nesting_level=(lvl) ⇒ Object
79 80 81 82 83 |
# File 'lib/regexp_parser/expression/shared.rb', line 79 def nesting_level=(lvl) @nesting_level = lvl quantifier && quantifier.nesting_level = lvl terminal? || each { |subexp| subexp.nesting_level = lvl + 1 } end |
#offset ⇒ Object
67 68 69 |
# File 'lib/regexp_parser/expression/shared.rb', line 67 def offset [starts_at, full_length] end |
#one_of?(scope, top = true) ⇒ Boolean
Test if this expression matches an entry in the given scope spec.
A scope spec can be one of:
. An array: Interpreted as a set of tokens, tested for inclusion
of the expression's token.
. A hash: Where the key is interpreted as the expression type
and the value is either a symbol or an array. In this
case, when the scope is a hash, one_of? calls itself to
evaluate the key's value.
. A symbol: matches the expression's token or type, depending on
the level of the call. If one_of? is called directly with
a symbol then it will always be checked against the
type of the expression. If it's being called for a value
from a hash, it will be checked against the token of the
expression.
# any expression
exp.one_of?(:*) # always true
# like exp.type?(:group)
exp.one_of?(:group)
# any expression of type meta
exp.one_of?(:meta => :*)
# meta dots and alternations
exp.one_of?(:meta => [:dot, :alternation])
# meta dots and any set tokens
exp.one_of?({meta: [:dot], set: :*})
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
# File 'lib/regexp_parser/expression/methods/tests.rb', line 75 def one_of?(scope, top = true) case scope when Array scope.include?(:*) || scope.include?(token) when Hash if scope.has_key?(:*) test_type = scope.has_key?(type) ? type : :* one_of?(scope[test_type], false) else scope.has_key?(type) && one_of?(scope[type], false) end when Symbol scope.equal?(:*) || (top ? type?(scope) : is?(scope)) else raise ArgumentError, "Array, Hash, or Symbol expected, #{scope.class.name} given" end end |
#parts ⇒ Object
55 56 57 |
# File 'lib/regexp_parser/expression/shared.rb', line 55 def parts [text.dup] end |
#quantified? ⇒ Boolean
63 64 65 |
# File 'lib/regexp_parser/expression/shared.rb', line 63 def quantified? !quantifier.nil? end |
#quantifier_affix(expression_format) ⇒ Object
59 60 61 |
# File 'lib/regexp_parser/expression/shared.rb', line 59 def quantifier_affix(expression_format) quantifier.to_s if quantified? && expression_format != :base end |
#starts_at ⇒ Object
38 39 40 |
# File 'lib/regexp_parser/expression/shared.rb', line 38 def starts_at ts end |
#terminal? ⇒ Boolean
75 76 77 |
# File 'lib/regexp_parser/expression/shared.rb', line 75 def terminal? !respond_to?(:expressions) end |
#to_s(format = :full) ⇒ Object Also known as: to_str
50 51 52 |
# File 'lib/regexp_parser/expression/shared.rb', line 50 def to_s(format = :full) "#{parts.join}#{quantifier_affix(format)}" end |
#token_class ⇒ Object
39 40 41 |
# File 'lib/regexp_parser/expression/methods/construct.rb', line 39 def token_class self.class.token_class end |
#type?(test_type) ⇒ Boolean
Test if this expression has the given test_type, which can be either a symbol or an array of symbols to check against the expression’s type.
# is it a :group expression
exp.type? :group
# is it a :set, or :meta
exp.type? [:set, :meta]
13 14 15 16 |
# File 'lib/regexp_parser/expression/methods/tests.rb', line 13 def type?(test_type) test_types = Array(test_type).map(&:to_sym) test_types.include?(:*) || test_types.include?(type) end |