js_regex 3.8.0 → 3.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8971658980813740deb03ece3c5af5bfdfd7412f0630fc4a3f172e4c06b11c52
-  data.tar.gz: bdafa3639a230b1ec1ac4661828050d99339eb18ec1768fa2a6f1b5e69d95f1b
+  metadata.gz: 054de046ea7e8e7244c80e8c8385270ffd821f0fdd690b8a15a79ea1c1d2a6f4
+  data.tar.gz: d6d3dbd4d191e16008bfd586ff22a10a8240275ac328c0a080af910d99b650a1
 SHA512:
-  metadata.gz: 13abdf7b41485194f05cce79751ca60e8b1f9fc864b17f58294650df9f9e485a889b9571d847bf564aa12b709fd572c53f27a5a2900e3dc8bfa765f522b58e62
-  data.tar.gz: 31941c0d7a4842fdea84d5f649f3df30c54e8da24e6dbf722cff3e48661ae89646117f66f33ee419c0fc0e393b11f284cb565751b4f77aa5eb0bbbc8d38d903d
+  metadata.gz: 93e7c0a574cadfb867c598a9adbcbd9b18585204912865e589691246ce879bec7b7d48a02872c599447db3f2feeda80236d08b1030aecd1d6bf0568792ac859a
+  data.tar.gz: e766f2ce0305ed0e6b10372d58f07fb0137e51a4a62a607b1f0272ac4b431c820fdb9ca2b8d2ce18de30d4bd33ca6cd8c49846d5c8efa79c081324342b990e87

data/lib/js_regex/conversion.rb

@@ -13,20 +13,21 @@ class JsRegex
     require_relative 'target'
 
     class << self
-      def of(input, options: nil, target: Target::ES2009)
+      def of(input, options: nil, target: Target::ES2009, fail_fast: false)
         target                       = Target.cast(target)
-        source, warnings, extra_opts = convert_source(input, target)
+        source, warnings, extra_opts = convert_source(input, target, fail_fast)
         options_string               = convert_options(input, options, extra_opts)
         [source, options_string, warnings, target]
       end
 
       private
 
-      def convert_source(input, target)
+      def convert_source(input, target, fail_fast)
         tree = Regexp::Parser.parse(input)
         context = Converter::Context.new(
           case_insensitive_root: tree.i?,
           target:                target,
+          fail_fast:             fail_fast,
         )
         converted_tree = Converter.convert(tree, context)
         final_tree = SecondPass.call(converted_tree)
@@ -36,7 +37,7 @@ class JsRegex
       end
 
       def convert_options(input, custom_options, required_options)
-        options = custom_options.to_s.scan(/[gimsuy]/) + required_options
+        options = custom_options.to_s.scan(/[dgimsuvy]/) + required_options
         if input.is_a?(Regexp) && (input.options & Regexp::IGNORECASE).nonzero?
           options << 'i'
         end

data/lib/js_regex/converter/anchor_converter.rb

@@ -10,8 +10,10 @@ class JsRegex
 
       def convert_data
         case subtype
-        when :bol, :bos then '^'
-        when :eol, :eos then '$'
+        when :bol then convert_bol
+        when :bos then '^'
+        when :eol then '(?=$|\n)'
+        when :eos then '$'
         when :eos_ob_eol then '(?=\n?$)'
         when :word_boundary then convert_boundary
         when :nonword_boundary then convert_nonboundary
@@ -20,6 +22,15 @@ class JsRegex
         end
       end
 
+      def convert_bol
+        if context.es_2018_or_higher?
+          '(?<=^|\n(?!$))'
+        else
+          # TODO: warn in v4.0.0, or drop ES2009 & ES2015 support
+          '^'
+        end
+      end
+
       def convert_boundary
         if context.es_2018_or_higher? && context.enable_u_option
           BOUNDARY_EXPANSION

data/lib/js_regex/converter/backreference_converter.rb

@@ -29,7 +29,8 @@ class JsRegex
 
       def convert_to_plain_num_ref
         position = new_position
-        Node.new("\\#{position}", reference: position, type: :backref)
+        text = "\\#{position}#{'(?:)' if expression.x?}"
+        Node.new(text, reference: position, type: :backref)
       end
 
       def new_position
@@ -41,14 +42,21 @@ class JsRegex
       end
 
       def convert_call
-        if expression.respond_to?(:number) && expression.number.equal?(0)
-          return warn_of_unsupported_feature('whole-pattern recursion')
+        if context.recursions(expression) >= 5
+          warn_of("Recursion for '#{expression}' curtailed at 5 levels")
+          return drop
         end
+
+        context.count_recursion(expression)
         context.increment_local_capturing_group_count
         target_copy = expression.referenced_expression.unquantified_clone
         # avoid "Duplicate capture group name" error in JS
         target_copy.token = :capture if target_copy.is?(:named, :group)
-        convert_expression(target_copy)
+        context.start_subexp_recursion
+        result = convert_expression(target_copy)
+        context.end_subexp_recursion
+        # wrap in group if it is a full-pattern recursion
+        expression.reference == 0 ? Node.new('(?:', result, ')') : result
       end
     end
   end

data/lib/js_regex/converter/base.rb

@@ -63,7 +63,11 @@ class JsRegex
       end
 
       def warn_of(text)
-        context.warnings << text
+        if context.fail_fast
+          raise ConversionError, text.sub(/^Dropped /, '')
+        else
+          context.warnings << text
+        end
       end
 
       def drop
@@ -75,8 +79,9 @@ class JsRegex
         number = context.capturing_group_count + 1
         backref_node = Node.new("\\#{number}", reference: number, type: :backref)
         context.increment_local_capturing_group_count
-        # an empty passive group (?:) is appended as literal digits may follow
-        Node.new('(?=(', *content, '))', backref_node, '(?:)')
+        # 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, ')')
       end
     end
   end

data/lib/js_regex/converter/context.rb

@@ -8,14 +8,18 @@ class JsRegex
     class Context
       attr_reader :capturing_group_count,
                   :case_insensitive_root,
+                  :fail_fast,
                   :in_atomic_group,
+                  :in_subexp_recursion,
                   :warnings
 
-      def initialize(case_insensitive_root: false, target: nil)
+      def initialize(case_insensitive_root: false, fail_fast: false, target: nil)
         self.added_capturing_groups_after_group = Hash.new(0)
         self.capturing_group_count = 0
-        self.warnings = []
+        self.fail_fast = fail_fast
+        self.recursions_per_expression = {}
         self.required_options_hash = {}
+        self.warnings = []
 
         self.case_insensitive_root = case_insensitive_root
         self.target = target
@@ -39,6 +43,10 @@ class JsRegex
         required_options_hash['u'] = true
       end
 
+      def u?
+        required_options_hash['u']
+      end
+
       def required_options
         required_options_hash.keys
       end
@@ -62,6 +70,26 @@ class JsRegex
         capture_group
       end
 
+      def recursions(exp)
+        recursions_per_expression[recursion_id(exp)] || 0
+      end
+
+      def count_recursion(exp)
+        recursions_per_expression[recursion_id(exp)] = recursions(exp) + 1
+      end
+
+      def recursion_id(exp)
+        [exp.class, exp.starts_at]
+      end
+
+      def start_subexp_recursion
+        self.in_subexp_recursion = true
+      end
+
+      def end_subexp_recursion
+        self.in_subexp_recursion = false
+      end
+
       # takes and returns 1-indexed group positions.
       # new is different from old if capturing groups were added in between.
       def new_capturing_group_position(old_position)
@@ -79,12 +107,15 @@ class JsRegex
       private
 
       attr_accessor :added_capturing_groups_after_group,
+                    :recursions_per_expression,
                     :required_options_hash,
                     :target
 
       attr_writer :capturing_group_count,
                   :case_insensitive_root,
+                  :fail_fast,
                   :in_atomic_group,
+                  :in_subexp_recursion,
                   :warnings
 
       def total_added_capturing_groups

data/lib/js_regex/converter/escape_converter.rb

@@ -42,10 +42,10 @@ class JsRegex
           unicode_escape_codepoint
         when :literal
           LiteralConverter.convert_data(expression.char, context)
+        when :bell, :escape, :hex, :octal
+          hex_escape_codepoint
         when *ESCAPES_SHARED_BY_RUBY_AND_JS
           pass_through
-        when :bell, :escape, :octal
-          hex_escape_codepoint
         else
           warn_of_unsupported_feature
         end

data/lib/js_regex/converter/group_converter.rb

@@ -84,7 +84,7 @@ class JsRegex
         tail = opts[:tail] || ')'
         return Node.new(*wrap(head, tail)) if opts[:capturing].equal?(false)
 
-        context.capture_group
+        context.capture_group unless context.in_subexp_recursion
         ref = expression.number
         Node.new(*wrap(head, tail), reference: ref, type: :captured_group)
       end

data/lib/js_regex/converter/literal_converter.rb

@@ -6,11 +6,12 @@ class JsRegex
     # Template class implementation.
     #
     class LiteralConverter < JsRegex::Converter::Base
-      class << self
-        ASTRAL_PLANE_CODEPOINT_PATTERN = /[\u{10000}-\u{10FFFF}]/
+      ASTRAL_PLANE_CODEPOINT_PATTERN = /[\u{10000}-\u{10FFFF}]/
+      LITERAL_REQUIRING_ESCAPE_PATTERN = /[\/\f\n\r\t\v]/
 
+      class << self
         def convert_data(data, context)
-          if data =~ ASTRAL_PLANE_CODEPOINT_PATTERN
+          if !context.u? && data =~ ASTRAL_PLANE_CODEPOINT_PATTERN
             if context.enable_u_option
               escape_incompatible_bmp_literals(data)
             else
@@ -23,7 +24,7 @@ class JsRegex
 
         def convert_astral_data(data)
           data.each_char.each_with_object(Node.new) do |char, node|
-            if char =~ ASTRAL_PLANE_CODEPOINT_PATTERN
+            if char.ord > 0xFFFF
               node << surrogate_substitution_for(char)
             else
               node << escape_incompatible_bmp_literals(char)
@@ -31,8 +32,12 @@ class JsRegex
           end
         end
 
+        ESCAPES = Hash.new { |h, k| raise KeyError, "#{h}[#{k.inspect}]" }
+          .merge("\f\n\r\t\v".chars.to_h { |c| [c, Regexp.escape(c)] })
+          .merge('/' => '\\/')
+
         def escape_incompatible_bmp_literals(data)
-          data.gsub('/', '\\/').gsub(/[\f\n\r\t]/) { |lit| Regexp.escape(lit) }
+          data.gsub(LITERAL_REQUIRING_ESCAPE_PATTERN, ESCAPES)
         end
 
         private

data/lib/js_regex/converter/set_converter.rb

@@ -17,54 +17,92 @@ class JsRegex
       private
 
       def convert_data
-        return pass_through_with_escaping if directly_compatible?
+        simple_conversion || full_recalculation
+      end
 
-        content = CharacterSet.of_expression(expression)
-        if expression.case_insensitive? && !context.case_insensitive_root
-          content = content.case_insensitive
-        elsif !expression.case_insensitive? && context.case_insensitive_root
-          warn_of_unsupported_feature('nested case-sensitive set')
-        end
+      def simple_conversion
+        return false if casefolding_needed?
 
-        if context.es_2015_or_higher?
-          context.enable_u_option if content.astral_part?
-          content.to_s(format: 'es6', in_brackets: true)
-        else
-          content.to_s_with_surrogate_ranges
+        result = "[#{'^' if expression.negative?}".dup
+
+        expression.expressions.each do |subexp|
+          return false unless (child_res = simple_convert_child(subexp))
+
+          result << child_res.to_s
         end
-      end
 
-      def directly_compatible?
-        all_children_directly_compatible? && !casefolding_needed?
+        result << ']'
       end
 
-      def all_children_directly_compatible?
-        # note that #each_expression is recursive
-        expression.each_expression.all? { |ch| child_directly_compatible?(ch) }
+      def casefolding_needed?
+        expression.case_insensitive? ^ context.case_insensitive_root
       end
 
-      def child_directly_compatible?(exp)
+      def simple_convert_child(exp)
         case exp.type
         when :literal
-          # surrogate pair substitution needed on ES2009 if astral
-          exp.text.ord <= 0xFFFF || context.enable_u_option
+          simple_convert_literal_child(exp)
         when :set
-          # conversion needed for nested sets, intersections
-          exp.token.equal?(:range)
+          # full conversion is needed for nested sets and intersections
+          exp.token.equal?(:range) && exp.expressions.map do |op|
+            simple_convert_child(op) or return false
+          end.join('-')
         when :type
-          TypeConverter.directly_compatible?(exp)
+          TypeConverter.directly_compatible?(exp, context) &&
+            exp.text
         when :escape
-          EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS.include?(exp.token)
+          return exp.text if SET_SPECIFIC_ESCAPES_PATTERN.match?(exp.text)
+
+          case exp.token
+          when *CONVERTIBLE_ESCAPE_TOKENS
+            EscapeConverter.new.convert(exp, context)
+          when :literal
+            exp.char.ord <= 0xFFFF &&
+              LiteralConverter.escape_incompatible_bmp_literals(exp.char)
+          end
         end
       end
 
-      def casefolding_needed?
-        expression.case_insensitive? ^ context.case_insensitive_root
+      def simple_convert_literal_child(exp)
+        if !context.u? &&
+           exp.text =~ LiteralConverter::ASTRAL_PLANE_CODEPOINT_PATTERN &&
+           !context.enable_u_option
+          false
+        elsif SET_LITERALS_REQUIRING_ESCAPE_PATTERN.match?(exp.text)
+          "\\#{exp.text}"
+        else
+          LiteralConverter.escape_incompatible_bmp_literals(exp.text)
+        end
+      end
+
+      SET_LITERALS_REQUIRING_ESCAPE_PATTERN = Regexp.union(%w<( ) [ ] { } / - |>)
+      SET_SPECIFIC_ESCAPES_PATTERN = /[\^\-]/
+      CONVERTIBLE_ESCAPE_TOKENS = %i[control meta_sequence bell escape octal] +
+        EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS
+
+      def full_recalculation
+        # Fetch codepoints as if the set was case-sensitive, then re-add
+        # case-insensitivity if needed.
+        # This way we preserve the casing of the original set in cases where the
+        # whole regexp is case-insensitive, e.g. /[ABc]/i => /[ABc]/i.
+        content = original_case_character_set
+        if expression.case_insensitive? && !context.case_insensitive_root
+          content = content.case_insensitive
+        elsif !expression.case_insensitive? && context.case_insensitive_root
+          warn_of_unsupported_feature('nested case-sensitive set')
+        end
+        if context.es_2015_or_higher?
+          context.enable_u_option if content.astral_part?
+          content.to_s(format: 'es6', in_brackets: true)
+        else
+          content.to_s_with_surrogate_ranges
+        end
       end
 
-      def pass_through_with_escaping
-        string = expression.to_s(:base)
-        LiteralConverter.escape_incompatible_bmp_literals(string)
+      def original_case_character_set
+        neutral_set = expression.dup
+        neutral_set.each_expression(true) { |exp| exp.options[:i] = false }
+        CharacterSet.of_expression(neutral_set)
       end
     end
   end

data/lib/js_regex/converter/type_converter.rb

@@ -6,13 +6,16 @@ class JsRegex
     # Template class implementation.
     #
     class TypeConverter < JsRegex::Converter::Base
-      HEX_EXPANSION           = '[0-9A-Fa-f]'
-      NONHEX_EXPANSION        = '[^0-9A-Fa-f]'
-      ES2018_HEX_EXPANSION    = '\p{AHex}'
-      ES2018_NONHEX_EXPANSION = '\P{AHex}'
-      LINEBREAK_EXPANSION     = '(?:\r\n|[\n\v\f\r\u0085\u2028\u2029])'
+      HEX_EXPANSION              = '[0-9A-Fa-f]'
+      NONHEX_EXPANSION           = '[^0-9A-Fa-f]'
+      I_MODE_HEX_EXPANSION       = '[0-9A-F]'
+      I_MODE_NONHEX_EXPANSION    = '[^0-9A-F]'
+      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])'
 
-      def self.directly_compatible?(expression)
+      def self.directly_compatible?(expression, _context = nil)
         case expression.token
         when :space, :nonspace
           !expression.ascii_classes?
@@ -27,7 +30,8 @@ class JsRegex
         case subtype
         when :hex then hex_expansion
         when :nonhex then nonhex_expansion
-        when :linebreak then LINEBREAK_EXPANSION
+        when :linebreak then linebreak_expansion
+        when :xgrapheme then xgrapheme
         when :digit, :space, :word
           return pass_through if self.class.directly_compatible?(expression)
           set_substitution
@@ -42,6 +46,8 @@ class JsRegex
       def hex_expansion
         if context.es_2018_or_higher? && context.enable_u_option
           ES2018_HEX_EXPANSION
+        elsif context.case_insensitive_root
+          I_MODE_HEX_EXPANSION
         else
           HEX_EXPANSION
         end
@@ -50,11 +56,17 @@ class JsRegex
       def nonhex_expansion
         if context.es_2018_or_higher? && context.enable_u_option
           ES2018_NONHEX_EXPANSION
+        elsif context.case_insensitive_root
+          I_MODE_NONHEX_EXPANSION
         else
           NONHEX_EXPANSION
         end
       end
 
+      def linebreak_expansion
+        wrap_in_backrefed_lookahead(LINEBREAK_EXPANSION)
+      end
+
       def negative_set_substitution
         # ::of_expression returns an inverted set for negative expressions,
         # so we need to un-invert before wrapping in [^ and ]. Kinda lame.
@@ -68,6 +80,14 @@ class JsRegex
       def character_set
         CharacterSet.of_expression(expression)
       end
+
+      def xgrapheme
+        if context.es_2018_or_higher? && context.enable_u_option
+          wrap_in_backrefed_lookahead(ES2018_XGRAPHEME_EXPANSION)
+        else
+          warn_of_unsupported_feature
+        end
+      end
     end
   end
 end

data/lib/js_regex/target.rb

@@ -8,7 +8,7 @@ class JsRegex
     def self.cast(arg)
       return ES2009 if arg.nil?
 
-      normalized_arg = arg.to_s.upcase
+      normalized_arg = arg.to_s.upcase.sub(/^(ECMASCRIPT|ES|JAVASCRIPT|JS)? ?/, 'ES')
       return normalized_arg if SUPPORTED.include?(normalized_arg)
 
       raise ArgumentError.new(

data/lib/js_regex/version.rb

@@ -1,3 +1,3 @@
 class JsRegex
-  VERSION = '3.8.0'
+  VERSION = '3.13.0'
 end

data/lib/js_regex.rb

@@ -30,14 +30,17 @@ class JsRegex
     "/#{source.empty? ? '(?:)' : source}/#{options}"
   end
 
+  # @raise JsRegex::ConversionError
   def self.new!(ruby_regex, **kwargs)
-    js_regex = new(ruby_regex, **kwargs)
-    if js_regex.warnings.any?
-      raise StandardError.new(
-        "Could not fully convert the given regex #{ruby_regex.inspect}:\n" +
-        js_regex.warnings.join("\n")
-      ).extend(JsRegex::Error)
-    end
-    js_regex
+    new(ruby_regex, fail_fast: true, **kwargs)
   end
+
+  def self.compatible?(ruby_regex, **kwargs)
+    new!(ruby_regex, **kwargs)
+    true
+  rescue ConversionError
+    false
+  end
+
+  ConversionError = Class.new(StandardError).send(:include, JsRegex::Error)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js_regex
 version: !ruby/object:Gem::Version
-  version: 3.8.0
+  version: 3.13.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-25 00:00:00.000000000 Z
+date: 2025-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: character_set
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.10'
 - !ruby/object:Gem::Dependency
   name: regexp_property_values
   requirement: !ruby/object:Gem::Requirement
@@ -105,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.0.dev
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: Converts Ruby regexes to JavaScript regexes.