js_regex 3.13.0 → 3.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 054de046ea7e8e7244c80e8c8385270ffd821f0fdd690b8a15a79ea1c1d2a6f4
-  data.tar.gz: d6d3dbd4d191e16008bfd586ff22a10a8240275ac328c0a080af910d99b650a1
+  metadata.gz: 81da8ab5dab32613d0486bb8b1d0c9926b1cd5dcf5cbf1dae7f7c7b86b695718
+  data.tar.gz: ad87e55f4c1834b237d8f18318fae065625e1e94f7645158ec4a7450967e5b69
 SHA512:
-  metadata.gz: 93e7c0a574cadfb867c598a9adbcbd9b18585204912865e589691246ce879bec7b7d48a02872c599447db3f2feeda80236d08b1030aecd1d6bf0568792ac859a
-  data.tar.gz: e766f2ce0305ed0e6b10372d58f07fb0137e51a4a62a607b1f0272ac4b431c820fdb9ca2b8d2ce18de30d4bd33ca6cd8c49846d5c8efa79c081324342b990e87
+  metadata.gz: 5b6e9d0eea5aa5656d3eaae3dd0ad769a21ef8a32d7304237afbe965266e8a8e8229c256a9110ce1573b2faf52ef112f354fcf84af61183b1f5aeb79035869f5
+  data.tar.gz: e546194d186650cc46aed54b73d92e6320251cb2954e213859fe3e5d4e06e04f502f8e0b5fe7a331db12578b59678484e184485ce4397dd61391677fe4766cd2

data/lib/js_regex/conversion.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   #
   # This class acts as a facade, passing a Regexp to the Converters.

data/lib/js_regex/converter/anchor_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/assertion_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'group_converter'
 

data/lib/js_regex/converter/backreference_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -19,20 +21,41 @@ class JsRegex
       end
 
       def convert_name_ref
-        if context.es_2018_or_higher?
-          # ES 2018+ supports named backrefs, but only the angled-bracket syntax
-          Node.new("\\k<#{expression.name}>", reference: new_position, type: :backref)
+        # Check if this is a multiplexed named group reference
+        if expression.referenced_expressions.count > 1
+          convert_multiplexed_name_ref
         else
+          # Always use numeric backrefs since we convert all named groups to numbered
+          # (see comment in GroupConverter)
           convert_to_plain_num_ref
         end
       end
 
       def convert_to_plain_num_ref
         position = new_position
+
+        # Check if this backreference refers to a group that was recursively called
+        original_group = target_position
+        if (recursive_position = context.get_recursive_group_position(original_group))
+          # Use the position of the group created by the recursive call
+          position = recursive_position
+        end
+
         text = "\\#{position}#{'(?:)' if expression.x?}"
         Node.new(text, reference: position, type: :backref)
       end
 
+      def convert_multiplexed_name_ref
+        # Create alternation of all groups with the same name
+        positions = expression.referenced_expressions.map do |ref_exp|
+          context.new_capturing_group_position(ref_exp.number)
+        end
+
+        # Build alternation like (?:\1|\2)
+        alternation = positions.map { |pos| "\\#{pos}" }.join('|')
+        Node.new("(?:#{alternation})")
+      end
+
       def new_position
         context.new_capturing_group_position(target_position)
       end
@@ -48,6 +71,10 @@ class JsRegex
         end
 
         context.count_recursion(expression)
+
+        # Track groups before the wrapper group is added
+        groups_before_wrapper = context.capturing_group_count
+
         context.increment_local_capturing_group_count
         target_copy = expression.referenced_expression.unquantified_clone
         # avoid "Duplicate capture group name" error in JS
@@ -55,9 +82,38 @@ class JsRegex
         context.start_subexp_recursion
         result = convert_expression(target_copy)
         context.end_subexp_recursion
-        # wrap in group if it is a full-pattern recursion
+
+        # Track all groups created during this recursive call
+        # This handles both the directly called group and any nested groups within it
+        # Get all group numbers from the referenced expression
+        original_groups = collect_group_numbers(expression.referenced_expression)
+
+        # The first new group number is groups_before_wrapper + 1
+        # (the wrapper group from increment_local_capturing_group_count doesn't appear in output)
+        first_new_group = groups_before_wrapper + 1
+
+        # Map each original group to its corresponding new group
+        # For example, if we recursively called group 1 which contains group 2,
+        # and this created groups 3 and 4, then:
+        # - group 1 -> group 3
+        # - group 2 -> group 4
+        original_groups.each_with_index do |old_group_num, index|
+          new_group_num = first_new_group + index
+          context.track_recursive_group_call(old_group_num, new_group_num)
+        end
+
+        # wrap in passive group if it is a full-pattern recursion
         expression.reference == 0 ? Node.new('(?:', result, ')') : result
       end
+
+      def collect_group_numbers(exp)
+        return [] if exp.terminal?
+
+        numbers = []
+        numbers << exp.number if exp.capturing?
+        exp.each_expression { |sub| numbers += collect_group_numbers(sub) }
+        numbers
+      end
     end
   end
 end

data/lib/js_regex/converter/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Converter
     #
@@ -44,7 +46,9 @@ class JsRegex
       end
 
       def convert_subexpressions
-        Node.new(*expression.map { |subexp| convert_expression(subexp) })
+        # mark alternation and conditional branches for processing in second pass
+        type = expression.is?(:sequence) ? :branch : :plain
+        Node.new(*expression.map { |subexp| convert_expression(subexp) }, type: type)
       end
 
       def convert_expression(expression)
@@ -78,10 +82,15 @@ class JsRegex
       def wrap_in_backrefed_lookahead(content)
         number = context.capturing_group_count + 1
         backref_node = Node.new("\\#{number}", reference: number, type: :backref)
+        backrefed_group = Node.new('(', *content, ')', reference: number, type: :captured_group)
         context.increment_local_capturing_group_count
         # The surrounding group is added so that quantifiers apply to the whole.
         # Without it, `(?:)` would need to be appended as literal digits may follow.
-        Node.new('(?:(?=(', *content, '))', backref_node, ')')
+        Node.new('(?:(?=', backrefed_group, ')', backref_node, ')')
+      end
+
+      def unmatchable_substitution
+        '(?!)'
       end
     end
   end

data/lib/js_regex/converter/conditional_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Converter
     #
@@ -18,8 +20,10 @@ class JsRegex
         self.capturing_group_count = 0
         self.fail_fast = fail_fast
         self.recursions_per_expression = {}
+        self.recursion_stack = []
         self.required_options_hash = {}
         self.warnings = []
+        self.recursive_group_map = {}
 
         self.case_insensitive_root = case_insensitive_root
         self.target = target
@@ -71,11 +75,12 @@ class JsRegex
       end
 
       def recursions(exp)
-        recursions_per_expression[recursion_id(exp)] || 0
+        # Count recursions in the current stack path only
+        recursion_stack.count { |e| recursion_id(e) == recursion_id(exp) }
       end
 
       def count_recursion(exp)
-        recursions_per_expression[recursion_id(exp)] = recursions(exp) + 1
+        recursion_stack.push(exp)
       end
 
       def recursion_id(exp)
@@ -84,10 +89,18 @@ class JsRegex
 
       def start_subexp_recursion
         self.in_subexp_recursion = true
+        self.recursion_start_group_count = capturing_group_count
       end
 
       def end_subexp_recursion
         self.in_subexp_recursion = false
+        # Pop the last recursion from stack when exiting
+        recursion_stack.pop if recursion_stack.any?
+      end
+
+      # Get the number of groups at the start of the current recursion
+      def recursion_start_group_count
+        self.recursion_start_group_count || 0
       end
 
       # takes and returns 1-indexed group positions.
@@ -104,11 +117,23 @@ class JsRegex
         capturing_group_count - total_added_capturing_groups
       end
 
+      # Track that a group was created by a recursive call
+      def track_recursive_group_call(original_group_num, new_group_num)
+        recursive_group_map[original_group_num] = new_group_num
+      end
+
+      # Get the group number created by a recursive call
+      def get_recursive_group_position(original_group_num)
+        recursive_group_map[original_group_num]
+      end
+
       private
 
       attr_accessor :added_capturing_groups_after_group,
                     :recursions_per_expression,
+                    :recursion_stack,
                     :required_options_hash,
+                    :recursive_group_map,
                     :target
 
       attr_writer :capturing_group_count,
@@ -116,6 +141,7 @@ class JsRegex
                   :fail_fast,
                   :in_atomic_group,
                   :in_subexp_recursion,
+                  :recursion_start_group_count,
                   :warnings
 
       def total_added_capturing_groups

data/lib/js_regex/converter/escape_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'literal_converter'
 
@@ -38,7 +40,7 @@ class JsRegex
         case subtype
         when :codepoint_list
           convert_codepoint_list
-        when :control, :meta_sequence
+        when :control, :meta_sequence, :utf8_hex
           unicode_escape_codepoint
         when :literal
           LiteralConverter.convert_data(expression.char, context)

data/lib/js_regex/converter/freespace_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/group_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -22,12 +24,10 @@ class JsRegex
       end
 
       def build_named_group
-        if context.es_2018_or_higher?
-          # ES 2018+ supports named groups, but only the angled-bracket syntax
-          build_group(head: "(?<#{expression.name}>")
-        else
-          build_group
-        end
+        # Always convert named groups to numbered groups. ES2018+ supports named
+        # groups, but can not handle repeated names in multiplexing or conditional
+        # expansion scenarios.
+        build_group
       end
 
       def emulate_atomic_group
@@ -69,10 +69,6 @@ class JsRegex
         expression.empty?
       end
 
-      def unmatchable_substitution
-        '(?!)'
-      end
-
       def build_absence_group
         head = "(?:(?:.|\\n){,#{expression.inner_match_length.min - 1}}|(?:(?!"
         tail = ')(?:.|\n))*)'

data/lib/js_regex/converter/keep_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/literal_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -6,8 +8,8 @@ class JsRegex
     # Template class implementation.
     #
     class LiteralConverter < JsRegex::Converter::Base
-      ASTRAL_PLANE_CODEPOINT_PATTERN = /[\u{10000}-\u{10FFFF}]/
-      LITERAL_REQUIRING_ESCAPE_PATTERN = /[\/\f\n\r\t\v]/
+      ASTRAL_PLANE_CODEPOINT_PATTERN = /[\u{10000}-\u{10FFFF}]/.freeze
+      LITERAL_REQUIRING_ESCAPE_PATTERN = /[\/\f\n\r\t\v]/.freeze
 
       class << self
         def convert_data(data, context)
@@ -59,7 +61,7 @@ class JsRegex
         result
       end
 
-      HAS_CASE_PATTERN = /[\p{lower}\p{upper}]/
+      HAS_CASE_PATTERN = /[\p{lower}\p{upper}]/.freeze
 
       def handle_locally_case_insensitive_literal(literal)
         literal =~ HAS_CASE_PATTERN ? case_insensitivize(literal) : literal

data/lib/js_regex/converter/meta_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/property_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require 'character_set'
 

data/lib/js_regex/converter/set_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 require_relative 'escape_converter'
 require_relative 'type_converter'
@@ -76,7 +78,7 @@ class JsRegex
       end
 
       SET_LITERALS_REQUIRING_ESCAPE_PATTERN = Regexp.union(%w<( ) [ ] { } / - |>)
-      SET_SPECIFIC_ESCAPES_PATTERN = /[\^\-]/
+      SET_SPECIFIC_ESCAPES_PATTERN = /[\^\-]/.freeze
       CONVERTIBLE_ESCAPE_TOKENS = %i[control meta_sequence bell escape octal] +
         EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS
 

data/lib/js_regex/converter/subexpression_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter/type_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex
@@ -10,10 +12,37 @@ class JsRegex
       NONHEX_EXPANSION           = '[^0-9A-Fa-f]'
       I_MODE_HEX_EXPANSION       = '[0-9A-F]'
       I_MODE_NONHEX_EXPANSION    = '[^0-9A-F]'
+      LINEBREAK_EXPANSION        = '(?:\r\n|[\n\v\f\r\u0085\u2028\u2029])'
       ES2018_HEX_EXPANSION       = '\p{AHex}'
       ES2018_NONHEX_EXPANSION    = '\P{AHex}'
-      ES2018_XGRAPHEME_EXPANSION = '[\P{M}\P{Lm}](?:(?:[\u035C\u0361]\P{M}\p{M}*)|\u200d|\p{M}|\p{Lm}|\p{Emoji_Modifier})*'
-      LINEBREAK_EXPANSION        = '(?:\r\n|[\n\v\f\r\u0085\u2028\u2029])'
+      # partially taken from https://unicode.org/reports/tr51/#EBNF_and_Regex
+      ES2018_XGRAPHEME_EXPANSION = <<-'REGEXP'.gsub(/\s+/, '')
+        (?:
+          \r\n
+        |
+          \p{RI}\p{RI}
+        |
+          \p{Emoji}
+          (?:
+            \p{EMod}
+          |
+            \uFE0F\u20E3?
+          |
+            [\u{E0020}-\u{E007E}]+\u{E007F}
+          )?
+          (?:
+            \u200D
+            (?:
+              \p{RI}\p{RI}
+            |
+              \p{Emoji}(?:\p{EMod}|\uFE0F\u20E3?|[\u{E0020}-\u{E007E}]+\u{E007F})?
+            )
+          )*
+        |
+          [\P{M}\P{Lm}](?:\u200d|\p{M}|\p{Lm}|\p{Emoji_Modifier})*
+        )
+      REGEXP
+
 
       def self.directly_compatible?(expression, _context = nil)
         case expression.token

data/lib/js_regex/converter/unsupported_token_converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'base'
 
 class JsRegex

data/lib/js_regex/converter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Converter
     Dir[File.join(__dir__, 'converter', '*.rb')].sort.each do |file|

data/lib/js_regex/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   # This is mixed into errors, e.g. those thrown by the parser,
   # allowing to `rescue JsRegex::Error`.

data/lib/js_regex/node.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   #
   # Converter#convert result. Represents a branch or leaf node with an optional
@@ -10,6 +12,7 @@ class JsRegex
 
     TYPES = %i[
       backref
+      branch
       captured_group
       conditional
       dropped
@@ -47,7 +50,7 @@ class JsRegex
       case type
       when :dropped
         ''
-      when :backref, :captured_group, :plain
+      when :backref, :branch, :captured_group, :plain
         children.join << quantifier.to_s
       else
         raise TypeError.new(
@@ -63,6 +66,10 @@ class JsRegex
       self
     end
 
+    def optional?
+      quantifier && quantifier.min == 0
+    end
+
     private
 
     TypeError = Class.new(::TypeError).extend(JsRegex::Error)

data/lib/js_regex/second_pass.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   #
   # After conversion of a full Regexp::Expression tree, this
@@ -8,6 +10,7 @@ class JsRegex
       def call(tree)
         substitute_root_level_keep_mark(tree)
         alternate_conditional_permutations(tree)
+        handle_non_participating_backrefs(tree)
         tree
       end
 
@@ -26,12 +29,49 @@ class JsRegex
         tree.update(children: [lookbehind, *post])
       end
 
+      def handle_non_participating_backrefs(tree)
+        level = 0
+        completed_group_numbers = {}
+        group_branches = {}
+        branch_stack = []
+
+        crawl(tree, true) do |node, event|
+          case [node.type, event]
+          when [:branch, :enter]
+            branch_stack.push(node)
+          when [:branch, :exit]
+            branch_stack.pop
+          when [:captured_group, :enter]
+            level += 1
+          when [:captured_group, :exit]
+            unless node.optional? # ignore optional groups
+              group_branches[node.reference] = branch_stack.last
+            end
+            number = level
+            number += 1 while completed_group_numbers[number]
+            completed_group_numbers[number] = true
+            level -= 1
+          when [:backref, :exit]
+            ref_branch = group_branches[node.reference]
+            current_branch = branch_stack.last
+
+            # make bad backrefs non-matchable
+            references_other_branch =
+              ref_branch && current_branch && ref_branch != current_branch
+            forward_reference = !completed_group_numbers[node.reference]
+            if references_other_branch || forward_reference
+              node.update(type: :plain, children: ['(?!)'])
+            end
+          end
+        end
+      end
+
       def alternate_conditional_permutations(tree)
         permutations = conditional_tree_permutations(tree)
         return if permutations.empty?
 
         alternatives = permutations.map.with_index do |variant, i|
-          Node.new((i.zero? ? '(?:' : '|(?:'), variant, ')')
+          Node.new((i.zero? ? '(?:' : '|(?:'), variant, ')', type: :branch)
         end
         tree.update(children: alternatives)
       end
@@ -48,13 +88,16 @@ class JsRegex
           crawl(tree_permutation) do |node|
             build_permutation(node, conds, truthy_conds, caps_per_branch, i)
           end
+          tree_permutation
         end
       end
 
-      def crawl(node, &block)
+      def crawl(node, trace = false, &block)
         return if node.instance_of?(String)
-        yield(node)
-        node.children.each { |child| crawl(child, &block) }
+
+        trace ? yield(node, :enter) : yield(node)
+        node.children.each { |child| crawl(child, trace, &block) }
+        trace && yield(node, :exit)
       end
 
       def conditions(tree)
@@ -90,11 +133,6 @@ class JsRegex
           # backref numbers need to be incremented for subsequent "branches"
           adapt_backref_to_permutation(node, caps_per_branch, i)
         when :captured_group
-          # Remove name, c.f. :backref handling.
-          node.update(children: [
-            node.children.first.sub(/\?<.*>/, ''),
-            *node.children[1..-1]
-          ])
           # if the group is referenced by any condition, modulate its quantity
           if conds.include?(node.reference)
             adapt_referenced_group_to_permutation(node, truthy)
@@ -124,8 +162,9 @@ class JsRegex
       end
 
       def min_quantify(node)
-        return if guarantees_at_least_one_match?(qtf = node.quantifier)
+        return unless node.optional?
 
+        qtf = node.quantifier
         if qtf.max.equal?(1) # any zero_or_one quantifier (?, ??, ?+)
           node.update(quantifier: nil)
         else
@@ -135,10 +174,6 @@ class JsRegex
         end
       end
 
-      def guarantees_at_least_one_match?(quantifier)
-        quantifier.nil? || quantifier.min > 0
-      end
-
       def null_quantify(node)
         null_quantifier = Regexp::Expression::Quantifier.construct(text: '{0}')
         node.update(quantifier: null_quantifier)

data/lib/js_regex/target.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
   module Target
     ES2009 = 'ES2009'

data/lib/js_regex/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class JsRegex
-  VERSION = '3.13.0'
+  VERSION = '3.14.0'
 end

data/lib/js_regex.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # JsRegex converts ::Regexp instances to JavaScript.
 #
 # Usage:

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: js_regex
 version: !ruby/object:Gem::Version
-  version: 3.13.0
+  version: 3.14.0
 platform: ruby
 authors:
 - Janosch Müller
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-27 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: character_set
@@ -30,14 +29,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '2.11'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.10'
+        version: '2.11'
 - !ruby/object:Gem::Dependency
   name: regexp_property_values
   requirement: !ruby/object:Gem::Requirement
@@ -90,7 +89,6 @@ homepage: https://github.com/jaynetics/js_regex
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -105,8 +103,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Converts Ruby regexes to JavaScript regexes.
 test_files: []