regexp_parser 2.8.1 → 2.11.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1426faee272654c45e3da8e262e94cfdbcf134dbad7804aed8cd945334c07be
-  data.tar.gz: 37eec721839fe2ebfc25c9d614756289b59ee766f5e7e60ecf4839b554bbb93e
+  metadata.gz: ba0845a7ebcd158dc60281b731adb0d597b71028a734209a9cf6e850986c03b4
+  data.tar.gz: '078369f6bdbf716aff8f435a318e3f1a8e83593951ee7b21c94bbcd597213d54'
 SHA512:
-  metadata.gz: abed9d7f387634b5e16eb19cbfd5d9aab03288dd4d284b1c52688f958714479783275c5418ee623607ced96b301124ab82dff546e7e4146c7c5ec7feae3e089d
-  data.tar.gz: 62c0757df1c73df52fcf71ef8de666ab9a51a4a8145e71321424ab0ff8408cb2b707cf154dae64ebbcc5a9c8a12ee377a3eadab7549432a9d0e6ee0e65afddd1
+  metadata.gz: e4539f7196c10d233aca76dc0da3fc8ae8df48b11afd3cc8c7548eedf5893a1202ba06f5fa841444b8afc7d4b0178b6cfb2f16db5e4d05401c64ba26fb05d1de
+  data.tar.gz: 801716036ad9a094641094077a8f1695d82cda38020369fb7385a9a7c34d7df0fc90c1629865072d22921fdcfa02a11f70c504220be2bd8df699a10d6d787647

data/Gemfile

@@ -1,15 +1,17 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
 
 group :development, :test do
-  gem 'leto', '~> 2.0'
-  gem 'rake', '~> 13.0'
-  gem 'regexp_property_values', '~> 1.4'
+  gem 'leto', '~> 2.1'
+  gem 'rake', '~> 13.1'
+  gem 'regexp_property_values', '~> 1.5'
   gem 'rspec', '~> 3.10'
   if RUBY_VERSION.to_f >= 2.7
     gem 'benchmark-ips', '~> 2.1'
     gem 'gouteur', '~> 1.1'
-    gem 'rubocop', '~> 1.7'
+    gem 'rubocop', '>= 1.80.2'
   end
 end

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010, 2012-2023,  Ammar Ali
+Copyright (c) 2010, 2012-2025,  Ammar Ali
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'bundler'
 require 'rubygems'
 require 'rubygems/package_task'
@@ -14,10 +16,10 @@ RSpec::Core::RakeTask.new(:spec)
 task :default => [:'test:full']
 
 namespace :test do
-  task full: [:'ragel:rb', :spec]
+  task full: [:ragel, :spec]
 end
 
 # Add ragel task as a prerequisite for building the gem to ensure that the
 # latest scanner code is generated and included in the build.
-desc "Runs ragel:rb before building the gem"
-task :build => ['ragel:rb']
+desc "Runs ragel before building the gem"
+task build: :ragel

data/lib/regexp_parser/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Regexp::Parser
   # base class for all gem-specific errors
   class Error < StandardError; end

data/lib/regexp_parser/expression/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class Base
     include Regexp::Expression::Shared

data/lib/regexp_parser/expression/classes/alternation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   # A sequence of expressions, used by Alternation as one of its alternatives.
   class Alternative < Regexp::Expression::Sequence; end

data/lib/regexp_parser/expression/classes/anchor.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Anchor
     class Base < Regexp::Expression::Base; end

data/lib/regexp_parser/expression/classes/backreference.rb

@@ -1,25 +1,8 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Backreference
-    class Base < Regexp::Expression::Base
-      attr_accessor :referenced_expression
-
-      def initialize_copy(orig)
-        exp_id = [self.class, self.starts_at]
-
-        # prevent infinite recursion for recursive subexp calls
-        copied = @@copied ||= {}
-        self.referenced_expression =
-          if copied[exp_id]
-            orig.referenced_expression
-          else
-            copied[exp_id] = true
-            orig.referenced_expression.dup
-          end
-        copied.clear
-
-        super
-      end
-    end
+    class Base < Regexp::Expression::Base; end
 
     class Number < Backreference::Base
       attr_reader :number

data/lib/regexp_parser/expression/classes/character_set/intersection.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class CharacterSet < Regexp::Expression::Subexpression
     class IntersectedSequence < Regexp::Expression::Sequence; end

data/lib/regexp_parser/expression/classes/character_set/range.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class CharacterSet < Regexp::Expression::Subexpression
     class Range < Regexp::Expression::Subexpression

data/lib/regexp_parser/expression/classes/character_set.rb

@@ -1,10 +1,9 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class CharacterSet < Regexp::Expression::Subexpression
     attr_accessor :closed, :negative
-
-    alias :negative? :negative
-    alias :negated?  :negative
-    alias :closed?   :closed
+    alias :closed? :closed
 
     def initialize(token, options = {})
       self.negative = false

data/lib/regexp_parser/expression/classes/character_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module CharacterType
     class Base < Regexp::Expression::Base; end

data/lib/regexp_parser/expression/classes/conditional.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Conditional
     class TooManyBranches < Regexp::Parser::Error
@@ -7,26 +9,17 @@ module Regexp::Expression
     end
 
     class Condition < Regexp::Expression::Base
-      attr_accessor :referenced_expression
-
       # Name or number of the referenced capturing group that determines state.
       # Returns a String if reference is by name, Integer if by number.
       def reference
         ref = text.tr("'<>()", "")
         ref =~ /\D/ ? ref : Integer(ref)
       end
-
-      def initialize_copy(orig)
-        self.referenced_expression = orig.referenced_expression.dup
-        super
-      end
     end
 
     class Branch < Regexp::Expression::Sequence; end
 
     class Expression < Regexp::Expression::Subexpression
-      attr_accessor :referenced_expression
-
       def <<(exp)
         expressions.last << exp
       end
@@ -54,11 +47,6 @@ module Regexp::Expression
       def reference
         condition.reference
       end
-
-      def initialize_copy(orig)
-        self.referenced_expression = orig.referenced_expression.dup
-        super
-      end
     end
   end
 end

data/lib/regexp_parser/expression/classes/escape_sequence.rb

@@ -1,100 +1,31 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module EscapeSequence
-    class Base < Regexp::Expression::Base
-      def codepoint
-        char.ord
-      end
-
-      if ''.respond_to?(:undump)
-        def char
-          %("#{text}").undump
-        end
-      else
-        # poor man's unescape without using eval
-        require 'yaml'
-        def char
-          YAML.load(%Q(---\n"#{text}"\n))
-        end
-      end
-    end
-
-    class Literal < EscapeSequence::Base
-      def char
-        text[1..-1]
-      end
-    end
-
-    class AsciiEscape   < EscapeSequence::Base; end
-    class Backspace     < EscapeSequence::Base; end
-    class Bell          < EscapeSequence::Base; end
-    class FormFeed      < EscapeSequence::Base; end
-    class Newline       < EscapeSequence::Base; end
-    class Return        < EscapeSequence::Base; end
-    class Tab           < EscapeSequence::Base; end
-    class VerticalTab   < EscapeSequence::Base; end
-
-    class Hex           < EscapeSequence::Base; end
-    class Codepoint     < EscapeSequence::Base; end
-
-    class CodepointList < EscapeSequence::Base
-      def char
-        raise NoMethodError, 'CodepointList responds only to #chars'
-      end
-
-      def codepoint
-        raise NoMethodError, 'CodepointList responds only to #codepoints'
-      end
-
-      def chars
-        codepoints.map { |cp| cp.chr('utf-8') }
-      end
-
-      def codepoints
-        text.scan(/\h+/).map(&:hex)
-      end
-    end
-
-    class Octal < EscapeSequence::Base
-      def char
-        text[1..-1].to_i(8).chr('utf-8')
-      end
-    end
-
-    class AbstractMetaControlSequence < EscapeSequence::Base
-      def char
-        codepoint.chr('utf-8')
-      end
-
-      private
-
-      def control_sequence_to_s(control_sequence)
-        five_lsb = control_sequence.unpack('B*').first[-5..-1]
-        ["000#{five_lsb}"].pack('B*')
-      end
-
-      def meta_char_to_codepoint(meta_char)
-        byte_value = meta_char.ord
-        byte_value < 128 ? byte_value + 128 : byte_value
-      end
-    end
-
-    class Control < AbstractMetaControlSequence
-      def codepoint
-        control_sequence_to_s(text).ord
-      end
-    end
-
-    class Meta < AbstractMetaControlSequence
-      def codepoint
-        meta_char_to_codepoint(text[-1])
-      end
-    end
-
-    class MetaControl < AbstractMetaControlSequence
-      def codepoint
-        meta_char_to_codepoint(control_sequence_to_s(text))
-      end
-    end
+    Base        = Class.new(Regexp::Expression::Base)
+
+    AsciiEscape = Class.new(Base) # \e
+    Backspace   = Class.new(Base) # \b
+    Bell        = Class.new(Base) # \a
+    FormFeed    = Class.new(Base) # \f
+    Newline     = Class.new(Base) # \n
+    Return      = Class.new(Base) # \r
+    Tab         = Class.new(Base) # \t
+    VerticalTab = Class.new(Base) # \v
+
+    Literal     = Class.new(Base) # e.g. \j, \@, \😀 (ineffectual escapes)
+
+    Octal       = Class.new(Base) # e.g. \012
+    Hex         = Class.new(Base) # e.g. \x0A
+    Codepoint   = Class.new(Base) # e.g. \u000A
+
+    CodepointList = Class.new(Base) # e.g. \u{A B}
+    UTF8Hex       = Class.new(Base) # e.g. \xE2\x82\xAC
+
+    AbstractMetaControlSequence = Class.new(Base)
+    Control                     = Class.new(AbstractMetaControlSequence) # e.g. \cB
+    Meta                        = Class.new(AbstractMetaControlSequence) # e.g. \M-Z
+    MetaControl                 = Class.new(AbstractMetaControlSequence) # e.g. \M-\cX
   end
 
   # alias for symmetry between Token::* and Expression::*

data/lib/regexp_parser/expression/classes/free_space.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class FreeSpace < Regexp::Expression::Base
     def quantify(*_args)

data/lib/regexp_parser/expression/classes/group.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Group
     class Base < Regexp::Expression::Subexpression

data/lib/regexp_parser/expression/classes/keep.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Keep
-    # TOOD: in regexp_parser v3.0.0 this should possibly be a Subexpression
+    # TODO: in regexp_parser v3.0.0 this should possibly be a Subexpression
     #       that contains all expressions to its left.
     class Mark < Regexp::Expression::Base; end
   end

data/lib/regexp_parser/expression/classes/literal.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class Literal < Regexp::Expression::Base; end
 end

data/lib/regexp_parser/expression/classes/posix_class.rb

@@ -1,9 +1,7 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class PosixClass < Regexp::Expression::Base
-    def negative?
-      type == :nonposixclass
-    end
-
     def name
       text[/\w+/]
     end

data/lib/regexp_parser/expression/classes/root.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class Root < Regexp::Expression::Subexpression
     def self.build(options = {})

data/lib/regexp_parser/expression/classes/unicode_property.rb

@@ -1,10 +1,8 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module UnicodeProperty
     class Base < Regexp::Expression::Base
-      def negative?
-        type == :nonproperty
-      end
-
       def name
         text[/\A\\[pP]\{([^}]+)\}\z/, 1]
       end
@@ -109,11 +107,12 @@ module Regexp::Expression
       class Unassigned  < Codepoint::Base; end
     end
 
-    class Age     < UnicodeProperty::Base; end
-    class Derived < UnicodeProperty::Base; end
-    class Emoji   < UnicodeProperty::Base; end
-    class Script  < UnicodeProperty::Base; end
-    class Block   < UnicodeProperty::Base; end
+    class Age        < UnicodeProperty::Base; end
+    class Block      < UnicodeProperty::Base; end
+    class Derived    < UnicodeProperty::Base; end
+    class Emoji      < UnicodeProperty::Base; end
+    class Enumerated < UnicodeProperty::Base; end
+    class Script     < UnicodeProperty::Base; end
   end
 
   # alias for symmetry between token symbol and Expression class name

data/lib/regexp_parser/expression/methods/construct.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Shared
     module ClassMethods

data/lib/regexp_parser/expression/methods/escape_sequence_char.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+Regexp::Expression::EscapeSequence::Base.class_eval do
+  def char
+    codepoint.chr('utf-8')
+  end
+end

data/lib/regexp_parser/expression/methods/escape_sequence_codepoint.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Regexp::Expression::EscapeSequence
+  AsciiEscape.class_eval { def codepoint; 0x1B end }
+  Backspace.class_eval   { def codepoint; 0x8  end }
+  Bell.class_eval        { def codepoint; 0x7  end }
+  FormFeed.class_eval    { def codepoint; 0xC  end }
+  Newline.class_eval     { def codepoint; 0xA  end }
+  Return.class_eval      { def codepoint; 0xD  end }
+  Tab.class_eval         { def codepoint; 0x9  end }
+  VerticalTab.class_eval { def codepoint; 0xB  end }
+
+  Literal.class_eval     { def codepoint; text[1].ord end }
+
+  Octal.class_eval       { def codepoint; text[/\d+/].to_i(8) end }
+
+  Hex.class_eval         { def codepoint; text[/\h+/].hex end }
+  Codepoint.class_eval   { def codepoint; text[/\h+/].hex end }
+
+  UTF8Hex.class_eval do
+    def codepoint
+      text.scan(/\h+/).map(&:hex).pack('C*').force_encoding('utf-8').ord
+    end
+  end
+
+  CodepointList.class_eval do
+    # Maybe this should be a unique top-level expression class?
+    def char
+      raise NoMethodError, 'CodepointList responds only to #chars'
+    end
+
+    def codepoint
+      raise NoMethodError, 'CodepointList responds only to #codepoints'
+    end
+
+    def chars
+      codepoints.map { |cp| cp.chr('utf-8') }
+    end
+
+    def codepoints
+      text.scan(/\h+/).map(&:hex)
+    end
+  end
+
+  AbstractMetaControlSequence.class_eval do
+    private
+
+    def control_sequence_to_s(control_sequence)
+      five_lsb = control_sequence.unpack('B*').first[-5..-1]
+      ["000#{five_lsb}"].pack('B*')
+    end
+
+    def meta_char_to_codepoint(meta_char)
+      byte_value = meta_char.ord
+      byte_value < 128 ? byte_value + 128 : byte_value
+    end
+  end
+
+  Control.class_eval do
+    def codepoint
+      control_sequence_to_s(text).ord
+    end
+  end
+
+  Meta.class_eval do
+    def codepoint
+      meta_char_to_codepoint(text[-1])
+    end
+  end
+
+  MetaControl.class_eval do
+    def codepoint
+      meta_char_to_codepoint(control_sequence_to_s(text))
+    end
+  end
+end

data/lib/regexp_parser/expression/methods/human_name.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Shared
     # default implementation, e.g. "atomic group", "hex escape", "word type", ..

data/lib/regexp_parser/expression/methods/match.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class Base
     def match?(string)

data/lib/regexp_parser/expression/methods/match_length.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Regexp::MatchLength
   include Enumerable
 

data/lib/regexp_parser/expression/methods/negative.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  module Shared
+    def negative?
+      false
+    end
+
+    # not an alias so as to respect overrides of #negative?
+    def negated?
+      negative?
+    end
+  end
+
+  Anchor::NonWordBoundary.class_eval       { def negative?; true                          end }
+  Assertion::NegativeLookahead.class_eval  { def negative?; true                          end }
+  Assertion::NegativeLookbehind.class_eval { def negative?; true                          end }
+  CharacterSet.class_eval                  { def negative?; negative                      end }
+  CharacterType::Base.class_eval           { def negative?; token.to_s.start_with?('non') end }
+  PosixClass.class_eval                    { def negative?; type == :nonposixclass        end }
+  UnicodeProperty::Base.class_eval         { def negative?; type == :nonproperty          end }
+end

data/lib/regexp_parser/expression/methods/options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class Base
     def multiline?

data/lib/regexp_parser/expression/methods/parts.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Shared
     # default implementation

data/lib/regexp_parser/expression/methods/printing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Shared
     def inspect

data/lib/regexp_parser/expression/methods/referenced_expressions.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Regexp::Expression
+  module ReferencedExpressions
+    attr_accessor :referenced_expressions
+
+    def referenced_expression
+      referenced_expressions && referenced_expressions.first
+    end
+
+    def initialize_copy(orig)
+      exp_id = [self.class, self.starts_at]
+
+      # prevent infinite recursion for recursive subexp calls
+      copied = self.class.instance_eval { @copied_ref_exps ||= {} }
+      self.referenced_expressions =
+        if copied[exp_id]
+          orig.referenced_expressions
+        else
+          copied[exp_id] = true
+          orig.referenced_expressions && orig.referenced_expressions.map(&:dup)
+        end
+      copied.clear
+
+      super
+    end
+  end
+
+  Base.include ReferencedExpressions
+end

data/lib/regexp_parser/expression/methods/strfregexp.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class Base
 

data/lib/regexp_parser/expression/methods/tests.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   module Shared
 

data/lib/regexp_parser/expression/methods/traverse.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   class Subexpression < Regexp::Expression::Base
 

data/lib/regexp_parser/expression/quantifier.rb

@@ -1,3 +1,5 @@
+# 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,
@@ -6,7 +8,7 @@ module Regexp::Expression
   class Quantifier
     include Regexp::Expression::Shared
 
-    MODES = %i[greedy possessive reluctant]
+    MODES = %i[greedy possessive reluctant].freeze
 
     def initialize(*args)
       deprecated_old_init(*args) and return if args.count == 4 || args.count == 5

data/lib/regexp_parser/expression/sequence.rb

@@ -1,3 +1,5 @@
+# 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

data/lib/regexp_parser/expression/sequence_operation.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Regexp::Expression
   # abstract class
   class SequenceOperation < Regexp::Expression::Subexpression