js_regex 2.2.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97bbd3590a59d72ec30e671104a4cde9485d4579acfbc8516f0e5b65395ea63d
-  data.tar.gz: 6a78449fd51fa3c2cd7db2e09e9e00aef24fe2ce79ca7a5076239a65ce6ec90d
+  metadata.gz: 4f8f83148f3bcfeb5262259d0893fe92db40e59f64627c4430deee7eaee194c2
+  data.tar.gz: 9cf144827bd01a075552cf12bfd16152c417e82eab064f1fa6a65133381d95ac
 SHA512:
-  metadata.gz: 1617eff1117554660bbbc2840fc3632e62246e31ec170a8df7ea5acb7277f525129e546cebf3c210f7819eb54be3415cb834b291db60fd98cf5cf7c1f459616e
-  data.tar.gz: e41ec6d2af6543a14395fee5682b2a6423ab22e737b8dc9c79dc1844051d13b6df626590e0ecf7984b813bb0e1dcc563e0a02fbc7cbb2785f4de452ba35051c1
+  metadata.gz: bf9b4ff58756d2f12be785a803fda5e75aeffd556cdd49860e7474caf963957414b11e9fd1f3d35c6aee90375f3f23dc4435033ee1d3ba086534fdd7cf8d7caf
+  data.tar.gz: b6d4e6dd07949b8fa3394e4868214d1a1977ee3fe65713c7eb000cdffc50e1d485be9af2f7fcffcc1893c883eb36cd4bd5c4c687b2aebabd62f2454820f57db5

data/lib/js_regex.rb

@@ -15,8 +15,8 @@ class JsRegex
 
   attr_reader :source, :options, :warnings
 
-  def initialize(ruby_regex)
-    @source, @options, @warnings = Conversion.of(ruby_regex)
+  def initialize(ruby_regex, options: nil)
+    @source, @options, @warnings = Conversion.of(ruby_regex, options: options)
   end
 
   def to_h

data/lib/js_regex/conversion.rb

@@ -11,26 +11,26 @@ class JsRegex
     require_relative 'converter'
 
     class << self
-      def of(ruby_regex)
+      def of(ruby_regex, options: nil)
         source, warnings = convert_source(ruby_regex)
-        options          = convert_options(ruby_regex)
-        [source, options, warnings]
+        options_string   = convert_options(ruby_regex, options)
+        [source, options_string, warnings]
       end
 
       private
 
       def convert_source(ruby_regex)
-        context         = Converter::Context.new(ruby_regex)
-        expression_tree = Regexp::Parser.parse(ruby_regex)
+        context = Converter::Context.new(ruby_regex)
         [
-          Converter::RootConverter.new.convert(expression_tree, context),
+          Converter::RootConverter.new.convert(context.ast, context),
           context.warnings
         ]
       end
 
-      def convert_options(ruby_regex)
-        ignore_case = (ruby_regex.options & Regexp::IGNORECASE).nonzero?
-        ignore_case ? 'gi' : 'g'
+      def convert_options(ruby_regex, custom_options)
+        options = custom_options.to_s.scan(/[gimuy]/)
+        options << 'i' if (ruby_regex.options & Regexp::IGNORECASE).nonzero?
+        options.uniq.sort.join
       end
     end
   end

data/lib/js_regex/converter.rb

@@ -25,5 +25,16 @@ class JsRegex
     def self.for(expression)
       MAP[expression.type].new
     end
+
+    # Limit the number of generated surrogate pairs, else the output might
+    # get to large for certain applications. The chosen number is somewhat
+    # arbitrary. 100 pairs make for about 1 KB, uncompressed. The median char
+    # count of all properties supported by Ruby is 92. 75% are below 300 chars.
+    #
+    # Set this to nil if you need full unicode matches and size doesn't matter.
+    class << self
+      attr_accessor :surrogate_pair_limit
+    end
+    self.surrogate_pair_limit = 300
   end
 end

data/lib/js_regex/converter/backreference_converter.rb

@@ -12,29 +12,63 @@ class JsRegex
 
       def convert_data
         case subtype
-        when :number, :number_ref
-          convert_number_ref
-        when :number_rel_ref
-          convert_number_rel_ref
-        when :name_ref
-          convert_name_ref
-        else
+        when :name_ref            then convert_name_ref
+        when :number, :number_ref then convert_number_ref
+        when :number_rel_ref      then convert_number_rel_ref
+        when :name_call           then convert_name_call
+        when :number_call         then convert_number_call
+        when :number_rel_call     then convert_number_rel_call
+        else # name_recursion_ref, number_recursion_ref, ...
           warn_of_unsupported_feature
         end
       end
 
+      def convert_name_ref
+        "\\#{context.named_group_positions.fetch(expression.name)}"
+      end
+
       def convert_number_ref
-        "\\#{context.new_capturing_group_position(Integer(expression.number))}"
+        "\\#{context.new_capturing_group_position(expression.number)}"
       end
 
       def convert_number_rel_ref
-        absolute_position = Integer(expression.number) +
-                            context.original_capturing_group_count + 1
         "\\#{context.new_capturing_group_position(absolute_position)}"
       end
 
-      def convert_name_ref
-        "\\#{context.named_group_positions.fetch(expression.name)}"
+      def absolute_position
+        expression.number + context.original_capturing_group_count + 1
+      end
+
+      def convert_name_call
+        replace_with_group do |group|
+          group.token == :named && group.name == expression.name
+        end
+      end
+
+      def convert_number_call
+        if expression.number == 0
+          return warn_of_unsupported_feature('whole-pattern recursion')
+        end
+        replace_with_group do |group|
+          [:capture, :options].include?(group.token) &&
+            group.number.equal?(expression.number)
+        end
+      end
+
+      def convert_number_rel_call
+        replace_with_group do |group|
+          [:capture, :options].include?(group.token) &&
+            group.number.equal?(absolute_position)
+        end
+      end
+
+      def replace_with_group
+        context.ast.each_expression do |subexp|
+          if subexp.type == :group && yield(subexp)
+            return Converter.for(subexp).convert(subexp, context)
+          end
+        end
+        ''
       end
     end
   end

data/lib/js_regex/converter/context.rb

@@ -8,12 +8,10 @@ class JsRegex
     # The Converters themselves are stateless.
     #
     class Context
-      attr_reader :buffered_set_extractions,
-                  :buffered_set_members,
+      attr_reader :ast,
                   :case_insensitive_root,
                   :in_atomic_group,
                   :named_group_positions,
-                  :negative_base_set,
                   :warnings
 
       def initialize(ruby_regex)
@@ -22,20 +20,8 @@ class JsRegex
         self.named_group_positions = {}
         self.warnings = []
 
-        self.case_insensitive_root =
-          !(ruby_regex.options & Regexp::IGNORECASE).equal?(0)
-      end
-
-      # set context
-
-      def negate_base_set
-        self.negative_base_set = true
-      end
-
-      def reset_set_context
-        self.buffered_set_extractions = []
-        self.buffered_set_members = []
-        self.negative_base_set = false
+        self.ast = Regexp::Parser.parse(ruby_regex)
+        self.case_insensitive_root = ast.case_insensitive?
       end
 
       # group context
@@ -75,10 +61,6 @@ class JsRegex
         capturing_group_count - total_added_capturing_groups
       end
 
-      def total_added_capturing_groups
-        added_capturing_groups_after_group.values.inject(0, &:+)
-      end
-
       def store_named_group_position(name)
         named_group_positions[name] = capturing_group_count + 1
       end
@@ -88,13 +70,15 @@ class JsRegex
       attr_accessor :added_capturing_groups_after_group,
                     :capturing_group_count
 
-      attr_writer :buffered_set_extractions,
-                  :buffered_set_members,
+      attr_writer :ast,
                   :case_insensitive_root,
                   :in_atomic_group,
                   :named_group_positions,
-                  :negative_base_set,
                   :warnings
+
+      def total_added_capturing_groups
+        added_capturing_groups_after_group.values.inject(0, &:+)
+      end
     end
   end
 end

data/lib/js_regex/converter/escape_converter.rb

@@ -9,85 +9,63 @@ class JsRegex
     # Template class implementation.
     #
     class EscapeConverter < JsRegex::Converter::Base
-      private
-
-      ESCAPES_SHARED_BY_RUBY_AND_JS = [
-        :backslash,
-        :bol,
-        :carriage,
-        :codepoint,
-        :dot,
-        :eol,
-        :form_feed,
-        :group_close,
-        :group_open,
-        :hex,
-        :interval_close,
-        :interval_open,
-        :newline,
-        :octal,
-        :one_or_more,
-        :set_close,
-        :set_open,
-        :tab,
-        :vertical_tab,
-        :zero_or_more,
-        :zero_or_one
+      ESCAPES_SHARED_BY_RUBY_AND_JS = %i[
+        alternation
+        backslash
+        backspace
+        bol
+        carriage
+        codepoint
+        dot
+        eol
+        form_feed
+        group_close
+        group_open
+        hex
+        interval_close
+        interval_open
+        newline
+        octal
+        one_or_more
+        set_close
+        set_open
+        tab
+        vertical_tab
+        zero_or_more
+        zero_or_one
       ].freeze
 
+      private
+
       def convert_data
         case subtype
         when :codepoint_list
           convert_codepoint_list
-        when :control
-          convert_control_sequence
+        when :control, :meta_sequence
+          unicode_escape_codepoint
         when :literal
           LiteralConverter.convert_data(data)
-        when :meta_sequence
-          convert_meta_sequence
         when *ESCAPES_SHARED_BY_RUBY_AND_JS
           pass_through
+        when :bell, :escape
+          hex_escape_codepoint
         else
-          # Bell, Escape, HexWide, ...
           warn_of_unsupported_feature
         end
       end
 
       def convert_codepoint_list
-        elements = data.scan(/\h+/).map do |codepoint|
-          literal = Regexp.escape([codepoint.hex].pack('U'))
-          LiteralConverter.convert_data(literal)
-        end
-        elements.join
-      end
-
-      def convert_control_sequence
-        convert_meta_control_sequence ||
-          unicode_escape_for(control_sequence_to_s(data))
-      end
-
-      def convert_meta_sequence
-        convert_meta_control_sequence ||
-          unicode_escape_for(meta_char_to_char_code(data[-1]))
-      end
-
-      def convert_meta_control_sequence
-        return unless expression.class.to_s.include?('MetaControl')
-        unicode_escape_for(meta_char_to_char_code(control_sequence_to_s(data)))
-      end
-
-      def unicode_escape_for(char)
-        "\\u#{char.ord.to_s(16).upcase.rjust(4, '0')}"
+        expression.chars.map do |char|
+          LiteralConverter.convert_data(Regexp.escape(char))
+        end.join
       end
 
-      def control_sequence_to_s(control_sequence)
-        five_lsb = control_sequence.unpack('B*').first[-5..-1]
-        ["000#{five_lsb}"].pack('B*')
+      def unicode_escape_codepoint
+        "\\u#{expression.codepoint.to_s(16).upcase.rjust(4, '0')}"
       end
 
-      def meta_char_to_char_code(meta_char)
-        byte_value = meta_char.ord
-        byte_value < 128 ? byte_value + 128 : byte_value
+      def hex_escape_codepoint
+        "\\x#{expression.codepoint.to_s(16).upcase.rjust(2, '0')}"
       end
     end
   end

data/lib/js_regex/converter/group_converter.rb

@@ -16,7 +16,7 @@ class JsRegex
         when :capture then build_group
         when :comment then drop_without_warning
         when :named then build_named_group
-        when :options then build_options_group
+        when :options, :options_switch then build_options_group
         when :passive then build_passive_group
         when :absence then warn_of_unsupported_feature
         else build_unsupported_group
@@ -44,8 +44,7 @@ class JsRegex
         unless (encoding_options = data.scan(/[adu]/)).empty?
           warn_of_unsupported_feature("encoding options #{encoding_options}")
         end
-        # TODO: replace this check in Regexp::Parser v1
-        switch_only = !data.include?(':')
+        switch_only = subtype.equal?(:options_switch)
         switch_only ? drop_without_warning : build_group(head: '(')
       end
 

data/lib/js_regex/converter/property_converter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'base'
-require_relative File.join('..', 'property_map')
+require 'character_set'
 
 class JsRegex
   module Converter
@@ -9,24 +9,6 @@ class JsRegex
     # Template class implementation.
     #
     class PropertyConverter < JsRegex::Converter::Base
-      class << self
-        def property_replacement(property_name, negated = nil)
-          replacement = PROPERTY_MAP[property_name.downcase.to_sym]
-          negated ? negated_property_replacement(replacement) : replacement
-        end
-
-        private
-
-        def negated_property_replacement(property_string)
-          return nil unless property_string
-          if property_string.start_with?('[^')
-            property_string.sub('[^', '[')
-          else
-            property_string.sub('[', '[^')
-          end
-        end
-      end
-
       private
 
       def convert_data
@@ -34,8 +16,29 @@ class JsRegex
       end
 
       def convert_property(negated = nil)
-        replace = self.class.property_replacement(subtype, negated)
-        replace || warn_of_unsupported_feature
+        content = CharacterSet.of_property(subtype)
+        if expression.case_insensitive? && !context.case_insensitive_root
+          content = content.case_insensitive
+        end
+
+        if negated
+          if content.astral_part.empty?
+            return "[^#{content.to_s(format: :js)}]"
+          else
+            warn_of_unsupported_feature('astral plane negation by property')
+          end
+        elsif Converter.surrogate_pair_limit.nil? ||
+              Converter.surrogate_pair_limit >= content.astral_part.size
+          return content.to_s_with_surrogate_alternation
+        else
+          warn_of_unsupported_feature('large astral plane match of property')
+        end
+
+        bmp_part = content.bmp_part
+        return '' if bmp_part.empty?
+
+        string = bmp_part.to_s(format: :js)
+        negated ? "[^#{string}]" : "[#{string}]"
       end
     end
   end

data/lib/js_regex/converter/set_converter.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 require_relative 'base'
-require_relative 'literal_converter'
-require_relative 'property_converter'
+require_relative 'escape_converter'
+require_relative 'type_converter'
+require 'character_set'
 
 class JsRegex
   module Converter
@@ -13,143 +14,51 @@ class JsRegex
       private
 
       def convert_data
-        if expression.set_level.equal?(0) # reached end of set expression
-          context.reset_set_context
-          context.negate_base_set if negative_set?
-          process_members
-          finalize_set
-        elsif negative_set?
-          warn_of_unsupported_feature('nested negative set data')
-        else # positive subset
-          process_members
+        if directly_compatible?
+          return expression.to_s(:base)
+                           .gsub(%r{\\?([\f\n\r\t])}) { Regexp.escape($1) }
         end
-      end
-
-      def negative_set?
-        expression.negative?
-      end
-
-      def process_members
-        expression.each { |member| process_member(member) }
-      end
 
-      ASTRAL_PLANE_PATTERN = /[\u{10000}-\u{FFFFF}]/
-      PROPERTY_PATTERN     = /\A(?:\[:|\\([pP])\{)(\^?)([^:\}]+)/
-
-      def process_member(member)
-        return convert_subset(member) unless member.instance_of?(String)
-
-        utf8_data = member.dup.force_encoding('UTF-8')
-        case utf8_data
-        when ASTRAL_PLANE_PATTERN
-          warn_of_unsupported_feature('astral plane set member')
-        when '\\h'
-          handle_hex_type
-        when '\\H'
-          handle_nonhex_type
-        when '&&'
-          warn_of_unsupported_feature('set intersection')
-        when PROPERTY_PATTERN
-          handle_property($1, $2, $3)
-        else
-          handle_literal(utf8_data)
+        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
-      end
-
-      HEX_RANGES = 'A-Fa-f0-9'
-      NONHEX_SET = '[^A-Fa-f0-9]'
 
-      def handle_hex_type
-        buffer_set_member(HEX_RANGES)
-      end
-
-      def handle_nonhex_type
-        if context.negative_base_set
-          warn_of_unsupported_feature('nonhex type in negative set')
+        if Converter.surrogate_pair_limit.nil? ||
+           Converter.surrogate_pair_limit >= content.astral_part.size
+          content.to_s_with_surrogate_alternation
         else
-          buffer_set_extraction(NONHEX_SET)
+          warn_of_unsupported_feature('large astral plane match of set')
+          bmp_part = content.bmp_part
+          bmp_part.empty? ? '' : bmp_part.to_s(format: :js, in_brackets: true)
         end
       end
 
-      def handle_property(sign, caret, name)
-        if context.negative_base_set
-          return warn_of_unsupported_feature('property in negative set')
+      def directly_compatible?
+        if expression.case_insensitive? && !context.case_insensitive_root
+          # casefolding needed
+          return false
         end
-        std = standardize_property_name(name)
-        negated = sign.eql?('P') ^ caret.eql?('^')
-        if (replacement = PropertyConverter.property_replacement(std, negated))
-          buffer_set_extraction(replacement)
-        else
-          warn_of_unsupported_feature('property')
-        end
-      end
-
-      def handle_literal(utf8_data)
-        conversion = LiteralConverter.convert_data(utf8_data)
-        if context.case_insensitive_root && !expression.case_insensitive?
-          warn_of_unsupported_feature('nested case-sensitive set member')
-        elsif !context.case_insensitive_root && expression.case_insensitive?
-          return handle_locally_case_insensitive_literal(conversion)
-        end
-        buffer_set_member(conversion)
-      end
-
-      DESCENDING_CASE_RANGE_PATTERN = /\p{upper}-\p{lower}/
 
-      def handle_locally_case_insensitive_literal(literal)
-        buffer_set_member(
-          if literal =~ DESCENDING_CASE_RANGE_PATTERN
-            warn_of_unsupported_feature(
-              'nested case-insensitive range going from upper to lower case'
-            )
-            literal
-          else
-            [literal, literal.swapcase].uniq
+        # check for subexpressions that need conversion
+        expression.each_expression do |node|
+          case node.type
+          when :literal
+            # surrogate pair substitution needed if astral
+            next if node.text.force_encoding('utf-8').ord <= 0xFFFF
+          when :set
+            # conversion needed for nested sets, intersections
+            next if node.token.equal?(:range)
+          when :type
+            next if TypeConverter::TYPES_SHARED_BY_RUBY_AND_JS.include?(node.token)
+          when :escape
+            next if EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS.include?(node.token)
           end
-        )
-      end
-
-      def standardize_property_name(name)
-        Regexp::Parser.parse("\\p{#{name}}").expressions.first.token
-      end
-
-      def buffer_set_member(data)
-        context.buffered_set_members << data
-      end
-
-      def buffer_set_extraction(data)
-        context.buffered_set_extractions << data
-      end
-
-      def convert_subset(subset)
-        SetConverter.new.convert(subset, context)
-      end
-
-      def finalize_set
-        buffered_members     = context.buffered_set_members
-        buffered_extractions = context.buffered_set_extractions
-        if buffered_members.empty?
-          finalize_depleted_set(buffered_extractions)
-        else
-          finalize_nondepleted_set(buffered_members, buffered_extractions)
-        end
-      end
-
-      def finalize_depleted_set(buffered_extractions)
-        case buffered_extractions.count
-        when 0 then ''
-        when 1 then buffered_extractions.first
-        else "(?:#{buffered_extractions.join('|')})"
-        end
-      end
-
-      def finalize_nondepleted_set(buffered_members, buffered_extractions)
-        set = "[#{'^' if negative_set?}#{buffered_members.join}]"
-        if buffered_extractions.empty?
-          set
-        else
-          "(?:#{set}|#{buffered_extractions.join('|')})"
+          return false
         end
+        true
       end
     end
   end