zayef 0.1.1 → 0.2.0.1

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression/methods/tests.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  module Shared
+
+    # 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]
+    #
+    def type?(test_type)
+      test_types = Array(test_type).map(&:to_sym)
+      test_types.include?(:*) || test_types.include?(type)
+    end
+
+    # 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]
+    #
+    def is?(test_token, test_type = nil)
+      return true if test_token === :*
+      token == test_token and (test_type ? type?(test_type) : true)
+    end
+
+    # 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: :*})
+    #
+    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
+
+    # Deep-compare two expressions for equality.
+    #
+    # When changing the conditions, please make sure to update
+    # #pretty_print_instance_variables so that it includes all relevant values.
+    def ==(other)
+      self.class   == other.class &&
+        text       == other.text &&
+        quantifier == other.quantifier &&
+        options    == other.options &&
+        (terminal? || expressions == other.expressions)
+    end
+    alias :=== :==
+    alias :eql? :==
+
+    def optional?
+      quantified? && quantifier.min == 0
+    end
+
+    def quantified?
+      !quantifier.nil?
+    end
+  end
+
+  Shared.class_eval                     { def terminal?; self.class.terminal? end }
+  Shared::ClassMethods.class_eval       { def terminal?; true  end }
+  Subexpression.instance_eval           { def terminal?; false end }
+
+  Shared.class_eval                     { def capturing?; self.class.capturing? end }
+  Shared::ClassMethods.class_eval       { def capturing?; false end }
+  Group::Capture.instance_eval          { def capturing?; true  end }
+
+  Shared.class_eval                     { def comment?; self.class.comment? end }
+  Shared::ClassMethods.class_eval       { def comment?; false end }
+  Comment.instance_eval                 { def comment?; true  end }
+  Group::Comment.instance_eval          { def comment?; true  end }
+
+  Shared.class_eval                     { def decorative?; self.class.decorative? end }
+  Shared::ClassMethods.class_eval       { def decorative?; false end }
+  FreeSpace.instance_eval               { def decorative?; true  end }
+  Group::Comment.instance_eval          { def decorative?; true  end }
+
+  Shared.class_eval                     { def referential?; self.class.referential? end }
+  Shared::ClassMethods.class_eval       { def referential?; false end }
+  Backreference::Base.instance_eval     { def referential?; true  end }
+  Conditional::Condition.instance_eval  { def referential?; true  end }
+  Conditional::Expression.instance_eval { def referential?; true  end }
+end

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression/methods/traverse.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  class Subexpression < Regexp::Expression::Base
+
+    # Traverses the expression, passing each recursive child to the
+    # given block.
+    # If the block takes two arguments, the indices of the children within
+    # their parents are also passed to it.
+    def each_expression(include_self = false, &block)
+      return enum_for(__method__, include_self) unless block
+
+      if block.arity == 1
+        block.call(self) if include_self
+        each_expression_without_index(&block)
+      else
+        block.call(self, 0) if include_self
+        each_expression_with_index(&block)
+      end
+    end
+
+    # 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.
+    def traverse(include_self = false, &block)
+      return enum_for(__method__, include_self) 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
+    alias :walk :traverse
+
+    # 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.
+    def flat_map(include_self = false, &block)
+      case block && block.arity
+      when nil then each_expression(include_self).to_a
+      when 2   then each_expression(include_self).map(&block)
+      else          each_expression(include_self).map { |exp| block.call(exp) }
+      end
+    end
+
+    protected
+
+    def each_expression_with_index(&block)
+      each_with_index do |exp, index|
+        block.call(exp, index)
+        exp.each_expression_with_index(&block) unless exp.terminal?
+      end
+    end
+
+    def each_expression_without_index(&block)
+      each do |exp|
+        block.call(exp)
+        exp.each_expression_without_index(&block) unless exp.terminal?
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression/quantifier.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  # TODO: in v3.0.0, maybe put Shared back into Base, and inherit from Base and
+  # call super in #initialize, but raise in #quantifier= and #quantify,
+  # or introduce an Expression::Quantifiable intermediate class.
+  # Or actually allow chaining as a more concise but tricky solution than PR#69.
+  class Quantifier
+    include Regexp::Expression::Shared
+
+    MODES = %i[greedy possessive reluctant].freeze
+
+    def initialize(*args)
+      deprecated_old_init(*args) and return if args.count == 4 || args.count == 5
+
+      init_from_token_and_options(*args)
+      # TODO: remove in v3.0.0, stop removing parts of #token (?)
+      self.token = token.to_s.sub(/_(greedy|possessive|reluctant)/, '').to_sym
+    end
+
+    def to_h
+      {
+        token: token,
+        text:  text,
+        mode:  mode,
+        min:   min,
+        max:   max,
+      }
+    end
+
+    MODES.each do |mode|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{mode}?
+          mode.equal?(:#{mode})
+        end
+      RUBY
+    end
+    alias :lazy? :reluctant?
+
+    def min
+      derived_data[:min]
+    end
+
+    def max
+      derived_data[:max]
+    end
+
+    def mode
+      derived_data[:mode]
+    end
+
+    private
+
+    def deprecated_old_init(token, text, _min, _max, _mode = :greedy)
+      warn "Calling `Expression::Base#quantify` or `#{self.class}.new` with 4+ arguments "\
+           "is deprecated.\nIt will no longer be supported in regexp_parser v3.0.0.\n"\
+           "Please pass a Regexp::Token instead, e.g. replace `token, text, min, max, mode` "\
+           "with `::Regexp::Token.new(:quantifier, token, text)`. min, max, and mode "\
+           "will be derived automatically.\n"\
+           "Or do `exp.quantifier = #{self.class}.construct(token: token, text: str)`.\n"\
+           "This is consistent with how Expression::Base instances are created. "
+      @token = token
+      @text  = text
+    end
+
+    def derived_data
+      @derived_data ||= begin
+        min, max =
+          case text[0]
+          when '?'; [0, 1]
+          when '*'; [0, -1]
+          when '+'; [1, -1]
+          else
+            int_min = text[/\{(\d*)/, 1]
+            int_max = text[/,?(\d*)\}/, 1]
+            [int_min.to_i, (int_max.empty? ? -1 : int_max.to_i)]
+          end
+
+        mod = text[/.([?+])/, 1]
+        mode = (mod == '?' && :reluctant) || (mod == '+' && :possessive) || :greedy
+
+        { min: min, max: max, mode: mode }
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression/sequence.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  # A sequence of expressions. Differs from a Subexpressions by how it handles
+  # quantifiers, as it applies them to its last element instead of itself as
+  # a whole subexpression.
+  #
+  # Used as the base class for the Alternation alternatives, Conditional
+  # branches, and CharacterSet::Intersection intersected sequences.
+  class Sequence < Regexp::Expression::Subexpression
+    class << self
+      def add_to(exp, params = {}, active_opts = {})
+        sequence = construct(
+          level:             exp.level,
+          set_level:         exp.set_level,
+          conditional_level: params[:conditional_level] || exp.conditional_level,
+          ts:                params[:ts],
+        )
+        sequence.options = active_opts
+        exp.expressions << sequence
+        sequence
+      end
+    end
+
+    def ts
+      (head = expressions.first) ? head.ts : @ts
+    end
+
+    def quantify(token, *args)
+      extract_quantifier_target(token.text).quantify(token, *args)
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression/sequence_operation.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  # abstract class
+  class SequenceOperation < Regexp::Expression::Subexpression
+    alias :sequences :expressions
+    alias :operands :expressions
+    alias :operator :text
+
+    def ts
+      (head = expressions.first) ? head.ts : @ts
+    end
+
+    def <<(exp)
+      expressions.last << exp
+    end
+
+    def add_sequence(active_opts = {}, params = { ts: 0 })
+      self.class::OPERAND.add_to(self, params, active_opts)
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression/shared.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  module Shared
+    module ClassMethods; end # filled in ./methods/*.rb
+
+    def self.included(mod)
+      mod.class_eval do
+        extend Shared::ClassMethods
+
+        attr_accessor :type, :token, :text, :ts, :te,
+                      :level, :set_level, :conditional_level,
+                      :options, :parent,
+                      :custom_to_s_handling, :pre_quantifier_decorations
+
+        attr_reader   :nesting_level, :quantifier
+      end
+    end
+
+    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
+    private :init_from_token_and_options
+
+    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
+      self.parent     = nil # updated by Subexpression#initialize_copy
+      if orig.pre_quantifier_decorations
+        self.pre_quantifier_decorations = orig.pre_quantifier_decorations.map(&:dup)
+      end
+      super
+    end
+
+    def starts_at
+      ts
+    end
+
+    def ends_at(include_quantifier = true)
+      ts + (include_quantifier ? full_length : base_length)
+    end
+
+    def base_length
+      to_s(:base).length
+    end
+
+    def full_length
+      to_s(:original).length
+    end
+
+    # #to_s reproduces the original source, as an unparser would.
+    #
+    # It takes an optional format argument.
+    #
+    # Example:
+    #
+    # lit = Regexp::Parser.parse(/a +/x)[0]
+    #
+    # lit.to_s            # => 'a+'  # default; with quantifier
+    # lit.to_s(:full)     # => 'a+'  # default; with quantifier
+    # lit.to_s(:base)     # => 'a'   # without quantifier
+    # lit.to_s(:original) # => 'a +' # with quantifier AND intermittent decorations
+    #
+    def to_s(format = :full)
+      base = ''.dup
+      parts.each do |part|
+        if part.instance_of?(String)
+          base << part
+        elsif !part.custom_to_s_handling
+          base << part.to_s(:original)
+        end
+      end
+      "#{base}#{pre_quantifier_decoration(format)}#{quantifier_affix(format)}"
+    end
+    alias :to_str :to_s
+
+    def pre_quantifier_decoration(expression_format = :original)
+      pre_quantifier_decorations.to_a.join if expression_format == :original
+    end
+
+    def quantifier_affix(expression_format = :full)
+      quantifier.to_s if quantified? && expression_format != :base
+    end
+
+    def offset
+      [starts_at, full_length]
+    end
+
+    def coded_offset
+      '@%d+%d' % offset
+    end
+
+    def nesting_level=(lvl)
+      @nesting_level = lvl
+      quantifier && quantifier.nesting_level = lvl
+      terminal? || each { |subexp| subexp.nesting_level = lvl + 1 }
+    end
+
+    def quantifier=(qtf)
+      @quantifier = qtf
+      @repetitions = nil # clear memoized value
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression/subexpression.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  class Subexpression < Regexp::Expression::Base
+    include Enumerable
+
+    attr_accessor :expressions
+
+    def initialize(token, options = {})
+      self.expressions = []
+      super
+    end
+
+    # Override base method to clone the expressions as well.
+    def initialize_copy(orig)
+      self.expressions = orig.expressions.map do |exp|
+        exp.clone.tap { |copy| copy.parent = self }
+      end
+      super
+    end
+
+    def <<(exp)
+      exp.parent = self
+      expressions << exp
+    end
+
+    %w[[] at each empty? fetch index join last length values_at].each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(*args, &block)
+          expressions.#{method}(*args, &block)
+        end
+      RUBY
+    end
+
+    def dig(*indices)
+      exp = self
+      indices.each { |idx| exp = exp.nil? || exp.terminal? ? nil : exp[idx] }
+      exp
+    end
+
+    def te
+      ts + base_length
+    end
+
+    def to_h
+      attributes.merge(
+        text:        to_s(:base),
+        expressions: expressions.map(&:to_h)
+      )
+    end
+
+    def extract_quantifier_target(quantifier_description)
+      pre_quantifier_decorations = []
+      target = expressions.reverse.find do |exp|
+        if exp.decorative?
+          exp.custom_to_s_handling = true
+          pre_quantifier_decorations << exp.text
+          next
+        end
+        exp
+      end
+      target or raise Regexp::Parser::ParserError,
+        "No valid target found for '#{quantifier_description}' quantifier"
+
+      target.pre_quantifier_decorations = pre_quantifier_decorations
+      target
+    end
+  end
+end

data/vendor/bundle/ruby/3.0.0/gems/regexp_parser-2.11.3/lib/regexp_parser/expression.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+
+require_relative 'expression/shared'
+require_relative 'expression/base'
+require_relative 'expression/quantifier'
+require_relative 'expression/subexpression'
+require_relative 'expression/sequence'
+require_relative 'expression/sequence_operation'
+
+require_relative 'expression/classes/alternation'
+require_relative 'expression/classes/anchor'
+require_relative 'expression/classes/backreference'
+require_relative 'expression/classes/character_set'
+require_relative 'expression/classes/character_set/intersection'
+require_relative 'expression/classes/character_set/range'
+require_relative 'expression/classes/character_type'
+require_relative 'expression/classes/conditional'
+require_relative 'expression/classes/escape_sequence'
+require_relative 'expression/classes/free_space'
+require_relative 'expression/classes/group'
+require_relative 'expression/classes/keep'
+require_relative 'expression/classes/literal'
+require_relative 'expression/classes/posix_class'
+require_relative 'expression/classes/root'
+require_relative 'expression/classes/unicode_property'
+
+require_relative 'expression/methods/construct'
+require_relative 'expression/methods/escape_sequence_char'
+require_relative 'expression/methods/escape_sequence_codepoint'
+require_relative 'expression/methods/human_name'
+require_relative 'expression/methods/match'
+require_relative 'expression/methods/match_length'
+require_relative 'expression/methods/negative'
+require_relative 'expression/methods/options'
+require_relative 'expression/methods/parts'
+require_relative 'expression/methods/printing'
+require_relative 'expression/methods/referenced_expressions'
+require_relative 'expression/methods/strfregexp'
+require_relative 'expression/methods/tests'
+require_relative 'expression/methods/traverse'