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
Also aliased as: ===, eql?
===(other)
Alias for: ==
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
eql?(other)
Alias for: ==
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
to_str(format = :full)
Alias for: to_s
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