class Regexp::Expression::Base

def ascii_classes?
  options[:a] == true
end

def attributes
  {
    type:              type,
    token:             token,
    text:              to_s(:base),
    starts_at:         ts,
    length:            full_length,
    level:             level,
    set_level:         set_level,
    conditional_level: conditional_level,
    options:           options,
    quantifier:        quantified? ? quantifier.to_h : nil,
  }
end

def case_insensitive?
  options[:i] == true
end

def coded_offset
  '@%d+%d' % offset
end

def default_classes?
  options[:d] == true
end

def free_spacing?
  options[:x] == true
end

def full_length
  to_s.length
end

def greedy?
  quantified? and quantifier.greedy?
end

def initialize(token, options = {})
  self.type              = token.type
  self.token             = token.token
  self.text              = token.text
  self.ts                = token.ts
  self.level             = token.level
  self.set_level         = token.set_level
  self.conditional_level = token.conditional_level
  self.nesting_level     = 0
  self.quantifier        = nil
  self.options           = options
end

def initialize_clone(orig)
  self.text       = (orig.text       ? orig.text.dup         : nil)
  self.options    = (orig.options    ? orig.options.dup      : nil)
  self.quantifier = (orig.quantifier ? orig.quantifier.clone : nil)
  super
end

def is?(test_token, test_type = nil)
  return true if test_token === :*
  token == test_token and (test_type ? type?(test_type) : true)
end

def match(string, offset = 0)
  Regexp.new(to_s).match(string, offset)
end

def match?(string)
  !!match(string)
end

def multiline?
  options[:m] == true
end

def offset
  [starts_at, full_length]
end

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

def possessive?
  quantified? and quantifier.possessive?
end

def quantified?
  !quantifier.nil?
end

def quantifier_affix(expression_format)
  quantifier.to_s if quantified? && expression_format != :base
end

def quantify(token, text, min = nil, max = nil, mode = :greedy)
  self.quantifier = Quantifier.new(token, text, min, max, mode)
end

def quantity
  return [nil,nil] unless quantified?
  [quantifier.min, quantifier.max]
end

def reluctant?
  quantified? and quantifier.reluctant?
end

def repetitions
  return 1..1 unless quantified?
  min = quantifier.min
  max = quantifier.max < 0 ? Float::INFINITY : quantifier.max
  range = min..max
  # fix Range#minmax on old Rubies - https://bugs.ruby-lang.org/issues/15807
  if RUBY_VERSION.to_f < 2.7
    range.define_singleton_method(:minmax) { [min, max] }
  end
  range
end

def strfregexp(format = '%a', indent_offset = 0, index = nil)
  have_index    = index ? true : false
  part = {}
  print_level = nesting_level > 0 ? nesting_level - 1 : nil
  # Order is important! Fields that use other fields in their
  # definition must appear before the fields they use.
  part_keys = %w{a m b o i l x s e S y k c q Q z Z t ~t T >}
  part.keys.each {|k| part[k] = "<?#{k}?>"}
  part['>'] = print_level ? ('  ' * (print_level + indent_offset)) : ''
  part['l'] = print_level ? "#{'%d' % print_level}" : 'root'
  part['x'] = "#{'%d' % index}" if have_index
  part['s'] = starts_at
  part['S'] = full_length
  part['e'] = starts_at + full_length
  part['o'] = coded_offset
  part['k'] = token
  part['y'] = type
  part['i'] = '%y:%k'
  part['c'] = self.class.name
  if quantified?
    if quantifier.max == -1
      part['q'] = "{#{quantifier.min}, or-more}"
    else
      part['q'] = "{#{quantifier.min}, #{quantifier.max}}"
    end
    part['Q'] = quantifier.text
    part['z'] = quantifier.min
    part['Z'] = quantifier.max
  else
    part['q'] = '{1}'
    part['Q'] = ''
    part['z'] = '1'
    part['Z'] = '1'
  end
  part['t'] = to_s(:base)
  part['~t'] = terminal? ? to_s : "#{type}:#{token}"
  part['T'] = to_s(:full)
  part['b'] = '%o %i'
  part['m'] = '%b %q'
  part['a'] = '%m %t'
  out = format.dup
  part_keys.each do |k|
    out.gsub!(/%#{k}/, part[k].to_s)
  end
  out
end

def terminal?
  !respond_to?(:expressions)
end

def to_re(format = :full)
  ::Regexp.new(to_s(format))
end

def to_s(format = :full)
  "#{text}#{quantifier_affix(format)}"
end

def type?(test_type)
  test_types = Array(test_type).map(&:to_sym)
  test_types.include?(:*) || test_types.include?(type)
end

def unicode_classes?
  options[:u] == true
end

def unquantified_clone
  clone.tap { |exp| exp.quantifier = nil }
end