module Regexp::Expression::Shared
Public Class Methods
included(mod)
click to toggle source
# 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
Public Instance Methods
==(other)
click to toggle source
Deep-compare two expressions for equality.
# File lib/regexp_parser/expression/methods/tests.rb, line 98 def ==(other) other.class == self.class && other.to_s == to_s && other.options == options end
base_length()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 42 def base_length to_s(:base).length end
coded_offset()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 71 def coded_offset '@%d+%d' % offset end
full_length()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 46 def full_length to_s.length end
initialize_copy(orig)
click to toggle source
Calls superclass method
# File lib/regexp_parser/expression/shared.rb, line 31 def initialize_copy(orig) self.text = orig.text.dup if orig.text self.options = orig.options.dup if orig.options self.quantifier = orig.quantifier.clone if orig.quantifier super end
is?(test_token, test_type = nil)
click to toggle source
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]
# 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)
click to toggle source
# 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()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 67 def offset [starts_at, full_length] end
one_of?(scope, top = true)
click to toggle source
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: :*})
# 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()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 55 def parts [text.dup] end
quantified?()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 63 def quantified? !quantifier.nil? end
quantifier_affix(expression_format)
click to toggle source
# 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()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 38 def starts_at ts end
terminal?()
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 75 def terminal? !respond_to?(:expressions) end
to_s(format = :full)
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 50 def to_s(format = :full) "#{parts.join}#{quantifier_affix(format)}" end
Also aliased as: to_str
token_class()
click to toggle source
# File lib/regexp_parser/expression/methods/construct.rb, line 39 def token_class self.class.token_class end
type?(test_type)
click to toggle source
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]
# 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
Private Instance Methods
init_from_token_and_options(token, options = {})
click to toggle source
# File lib/regexp_parser/expression/shared.rb, line 17 def init_from_token_and_options(token, options = {}) self.type = token.type self.token = token.token self.text = token.text self.ts = token.ts self.te = token.te self.level = token.level self.set_level = token.set_level self.conditional_level = token.conditional_level self.nesting_level = 0 self.options = options || {} end