js_regex 3.9.0 → 3.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4710feb6c1da4ea2665ec125ab16bf92c35117ee028b2c6986ec9ebe61cc5eea
-  data.tar.gz: 7152f08cbea846150bc370cb2aeb2d9a99f7e7c18b8b448e080845a54fbbe05d
+  metadata.gz: 6c55b0dded778c8851267d5d6d24c4a1afcbdb64e6d28ef3e48da5ba8acaf4d8
+  data.tar.gz: 71cf3ead5808405c0e32a2fa2dd63a8efa6f5f02df9ef707c12d4238087121a6
 SHA512:
-  metadata.gz: cee471265231e58c04d682a707184c5d8a468481eff5f2e0df498b7323fe75ee245b95e1d2ca69016fa83e9378faecaa95541e70af07711773bcd7cbe4bdae57
-  data.tar.gz: '0924f4a4f73f2786c8dcac578588f04fb3c6d86913ce6c8f1ac74169e8e226f6e4b993ee43a100e7e913ade4062cb18d6e53ac87573aeaabe3780c6f75beb0d0'
+  metadata.gz: d5cb89a802b4c90382146f6a49e2c0fbefa5aed7580d0698e8bd392e05ed172880a713dc619b484e9fa0f28689b1b03c35eb08f9efc6673895ca1a450985723e
+  data.tar.gz: c0c8fda9db5419e5d05b43036190d1fb3d9e44d32c7f57598f21cb6c16d444208dae18ed6cdeb871357188619113475f83deb70c4eef2babfc44a37c27cbbbb9

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)

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

data/lib/js_regex/converter/context.rb

@@ -8,15 +8,17 @@ class JsRegex
     class Context
       attr_reader :capturing_group_count,
                   :case_insensitive_root,
+                  :fail_fast,
                   :in_atomic_group,
                   :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.fail_fast = fail_fast
         self.recursions_per_expression = {}
-        self.warnings = []
         self.required_options_hash = {}
+        self.warnings = []
 
         self.case_insensitive_root = case_insensitive_root
         self.target = target
@@ -40,6 +42,10 @@ class JsRegex
         required_options_hash['u'] = true
       end
 
+      def u?
+        required_options_hash['u']
+      end
+
       def required_options
         required_options_hash.keys
       end
@@ -98,6 +104,7 @@ class JsRegex
 
       attr_writer :capturing_group_count,
                   :case_insensitive_root,
+                  :fail_fast,
                   :in_atomic_group,
                   :warnings
 

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,73 @@ 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
+          return false if !context.u? &&
+            exp.text =~ LiteralConverter::ASTRAL_PLANE_CODEPOINT_PATTERN &&
+            !context.enable_u_option
+
+          LiteralConverter.escape_incompatible_bmp_literals(exp.text)
         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
-      end
+      SET_SPECIFIC_ESCAPES_PATTERN = /[\^\-]/
+      CONVERTIBLE_ESCAPE_TOKENS = %i[control meta_sequence bell escape octal] +
+        EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS
 
-      def pass_through_with_escaping
-        string = expression.to_s(:base)
-        LiteralConverter.escape_incompatible_bmp_literals(string)
+      def full_recalculation
+        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
+        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
     end
   end

data/lib/js_regex/converter/type_converter.rb

@@ -13,7 +13,7 @@ class JsRegex
       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?

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.9.0'
+  VERSION = '3.11.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.9.0
+  version: 3.11.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-01-24 00:00:00.000000000 Z
+date: 2023-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: character_set