js_regex 3.2.0 → 3.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 48540644a806114addad63fb0f3ff9ba7ad00a084b3b281b9132d2eddbe610ff
-  data.tar.gz: 775fd5d3f54c8b3c32b145414707c0b69c5c783cbd5270d9bc8d5e1564a6fec7
+  metadata.gz: 0f418197d1c8fea37bd549b701049f1130bfca486c5a11ba25e56d7d0cf990f8
+  data.tar.gz: 8679277fb51aca528933f4727cd0e70f1e1204c78acaf4e20da48d6b790ea7be
 SHA512:
-  metadata.gz: 97810021249f6b512ebae5898f6ffe51ae95269f1e47909fb7b95fbe1e8aa6ba9696e4c7966bac27cbc7c1bd36668729aeb5d0ab4c243e85a88bb70fd6cbb203
-  data.tar.gz: 5681e9d950c14f7260596b46a382a9829c0be4326bd898acbdcf5a257936c0f543018b5c7b1435582d8ba976a680d3b08ac0189e85d82b49e621e5f8918b93a9
+  metadata.gz: ddeadbe690e2928c068d8c2962d80e88c50f5fef46304e46fa98e8dc215c6c57c7790e9ef7ba8b1f640e71c3ca834b7233449c9b7d68466ac76581de73c7ffe3
+  data.tar.gz: 9c10d4e6a529ec54385ed55b34e4a910d354d7665f0831bc65b65bc20f176f4e46f9aa90cff2b36ea8f1306dfa65f7e42f4a93516ab228f206e74db7d708b779

data/lib/js_regex/converter/group_converter.rb

@@ -34,9 +34,6 @@ class JsRegex
       end
 
       def build_options_group
-        unless (encoding_options = data.scan(/[adu]/)).empty?
-          warn_of_unsupported_feature("encoding options #{encoding_options}")
-        end
         if subtype.equal?(:options_switch)
           # can be ignored since #options on subsequent Expressions are correct
           drop_without_warning

data/lib/js_regex/converter/literal_converter.rb

@@ -13,18 +13,22 @@ class JsRegex
 
         def convert_data(data)
           if data =~ ASTRAL_PLANE_CODEPOINT_PATTERN
-            data.each_char.each_with_object(Node.new) do |chr, node|
-              if chr =~ ASTRAL_PLANE_CODEPOINT_PATTERN
-                node << surrogate_pair_for(chr)
-              else
-                node << convert_bmp_data(chr)
-              end
-            end
+            convert_astral_data(data)
           else
             convert_bmp_data(data)
           end
         end
 
+        def convert_astral_data(data)
+          data.each_char.each_with_object(Node.new) do |chr, node|
+            if chr =~ ASTRAL_PLANE_CODEPOINT_PATTERN
+              node << surrogate_pair_for(chr)
+            else
+              node << convert_bmp_data(chr)
+            end
+          end
+        end
+
         def convert_bmp_data(data)
           ensure_json_compatibility(
             ensure_forward_slashes_are_escaped(data)

data/lib/js_regex/converter/meta_converter.rb

@@ -22,15 +22,20 @@ class JsRegex
       end
 
       def convert_alternatives
-        kept_any = nil
+        kept_any_previous_branch = nil
 
         convert_subexpressions.transform do |node|
-          dropped = !node.children.empty? && node.children.all?(&:dropped?)
-          node.children.unshift('|') if kept_any && !dropped
-          kept_any = true unless dropped
+          unless dropped_branch?(node)
+            node.children.unshift('|') if kept_any_previous_branch
+            kept_any_previous_branch = true
+          end
           node
         end
       end
+
+      def dropped_branch?(branch_node)
+        branch_node.children.any? && branch_node.children.all?(&:dropped?)
+      end
     end
   end
 end

data/lib/js_regex/converter/property_converter.rb

@@ -15,10 +15,7 @@ class JsRegex
       private
 
       def convert_data
-        content = CharacterSet.of_property(subtype)
-        if expression.case_insensitive? && !context.case_insensitive_root
-          content = content.case_insensitive
-        end
+        content = character_set_of_property
 
         if expression.negative?
           if content.astral_part?
@@ -30,6 +27,19 @@ class JsRegex
           warn_of_unsupported_feature('large astral plane match of property')
         end
 
+        limit_to_bmp_part(content)
+      end
+
+      def character_set_of_property
+        character_set = CharacterSet.of_property(subtype)
+        if expression.case_insensitive? && !context.case_insensitive_root
+          character_set.case_insensitive
+        else
+          character_set
+        end
+      end
+
+      def limit_to_bmp_part(content)
         bmp_part = content.bmp_part
         return drop if bmp_part.empty?
 

data/lib/js_regex/converter/set_converter.rb

@@ -19,10 +19,7 @@ class JsRegex
       private
 
       def convert_data
-        if directly_compatible?
-          return expression.to_s(:base)
-                           .gsub(%r{\\?([\f\n\r\t])}) { Regexp.escape($1) }
-        end
+        return pass_through_with_escaping if directly_compatible?
 
         content = CharacterSet.of_expression(expression)
         if expression.case_insensitive? && !context.case_insensitive_root
@@ -34,35 +31,48 @@ class JsRegex
         if Converter.in_surrogate_pair_limit? { content.astral_part.size }
           content.to_s_with_surrogate_alternation
         else
-          warn_of_unsupported_feature('large astral plane match of set')
-          bmp_part = content.bmp_part
-          bmp_part.empty? ? drop : bmp_part.to_s(in_brackets: true)
+          limit_to_bmp_part_with_warning(content)
         end
       end
 
       def directly_compatible?
-        if expression.case_insensitive? ^ context.case_insensitive_root
-          # casefolding needed
-          return
-        end
+        all_children_directly_compatible? && !casefolding_needed?
+      end
 
-        # check for children needing conversion (#each_expression is recursive)
+      def all_children_directly_compatible?
+        # note that #each_expression is recursive
         expression.each_expression do |exp|
-          case exp.type
-          when :literal
-            # surrogate pair substitution needed if astral
-            next if exp.text.ord <= 0xFFFF
-          when :set
-            # conversion needed for nested sets, intersections
-            next if exp.token.equal?(:range)
-          when :type
-            next if TypeConverter::TYPES_SHARED_BY_RUBY_AND_JS.include?(exp.token)
-          when :escape
-            next if EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS.include?(exp.token)
-          end
-          return
+          return unless child_directly_compatible?(exp)
+        end
+      end
+
+      def child_directly_compatible?(exp)
+        case exp.type
+        when :literal
+          # surrogate pair substitution needed if astral
+          exp.text.ord <= 0xFFFF
+        when :set
+          # conversion needed for nested sets, intersections
+          exp.token.equal?(:range)
+        when :type
+          TypeConverter.directly_compatible?(exp)
+        when :escape
+          EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS.include?(exp.token)
         end
-        true
+      end
+
+      def casefolding_needed?
+        expression.case_insensitive? ^ context.case_insensitive_root
+      end
+
+      def pass_through_with_escaping
+        expression.to_s(:base).gsub(%r{\\?([\f\n\r\t])}) { Regexp.escape($1) }
+      end
+
+      def limit_to_bmp_part_with_warning(content)
+        warn_of_unsupported_feature('large astral plane match of set')
+        bmp_part = content.bmp_part
+        bmp_part.empty? ? drop : bmp_part.to_s(in_brackets: true)
       end
     end
   end

data/lib/js_regex/converter/type_converter.rb

@@ -8,19 +8,19 @@ class JsRegex
     # Template class implementation.
     #
     class TypeConverter < JsRegex::Converter::Base
-      TYPES_SHARED_BY_RUBY_AND_JS = %i[
-        digit
-        nondigit
-        word
-        nonword
-        space
-        nonspace
-      ].freeze
-
       HEX_EXPANSION       = '[0-9A-Fa-f]'
       NONHEX_EXPANSION    = '[^0-9A-Fa-f]'
       LINEBREAK_EXPANSION = '(?:\r\n|[\n\v\f\r\u0085\u2028\u2029])'
 
+      def self.directly_compatible?(expression)
+        case expression.token
+        when :space, :nonspace
+          !expression.ascii_classes?
+        when :digit, :nondigit, :word, :nonword
+          !expression.unicode_classes?
+        end
+      end
+
       private
 
       def convert_data
@@ -28,12 +28,30 @@ class JsRegex
         when :hex then HEX_EXPANSION
         when :nonhex then NONHEX_EXPANSION
         when :linebreak then LINEBREAK_EXPANSION
-        when *TYPES_SHARED_BY_RUBY_AND_JS
-          pass_through
+        when :digit, :space, :word
+          return pass_through if self.class.directly_compatible?(expression)
+          set_substitution
+        when :nondigit, :nonspace, :nonword
+          return pass_through if self.class.directly_compatible?(expression)
+          negative_set_substitution
         else
           warn_of_unsupported_feature
         end
       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.
+        "[^#{character_set.inversion.bmp_part}]"
+      end
+
+      def set_substitution
+        character_set.bmp_part.to_s(in_brackets: true)
+      end
+
+      def character_set
+        CharacterSet.of_expression(expression)
+      end
     end
   end
 end

data/lib/js_regex/second_pass.rb

@@ -25,32 +25,16 @@ class JsRegex
       end
 
       def conditional_tree_permutations(tree)
-        all_conditions = conditions(tree)
-        return [] if all_conditions.empty?
+        all_conds = conditions(tree)
+        return [] if all_conds.empty?
 
-        captured_groups_per_branch = captured_group_count(tree)
+        caps_per_branch = captured_group_count(tree)
 
-        condition_permutations(all_conditions).map.with_index do |truthy_conds, i|
+        condition_permutations(all_conds).map.with_index do |truthy_conds, i|
           tree_permutation = tree.clone
           # find referenced groups and conditionals and make one-sided
           crawl(tree_permutation) do |node|
-            truthy = truthy_conds.include?(node.reference)
-
-            if node.type.equal?(:captured_group) &&
-              all_conditions.include?(node.reference)
-              truthy ? min_quantify(node) : null_quantify(node)
-            elsif node.type.equal?(:conditional)
-              branches = node.children[1...-1]
-              if branches.count == 1
-                truthy || null_quantify(branches.first)
-              else
-                null_quantify(truthy ? branches.last : branches.first)
-              end
-              node.update(type: :plain)
-            elsif node.type.equal?(:backref_num)
-              new_num = node.children[0].to_i + captured_groups_per_branch * i
-              node.update(children: [new_num.to_s])
-            end
+            build_permutation(node, all_conds, truthy_conds, caps_per_branch, i)
           end
         end
       end
@@ -81,8 +65,40 @@ class JsRegex
         end
       end
 
+      def build_permutation(node, all_conds, truthy_conds, caps_per_branch, i)
+        truthy = truthy_conds.include?(node.reference)
+
+        if node.type.equal?(:captured_group) &&
+          all_conds.include?(node.reference)
+          adapt_referenced_group_to_permutation(node, truthy)
+        elsif node.type.equal?(:conditional)
+          adapt_conditional_to_permutation(node, truthy)
+        elsif node.type.equal?(:backref_num)
+          adapt_backref_to_permutation(node, caps_per_branch, i)
+        end
+      end
+
+      def adapt_referenced_group_to_permutation(group_node, truthy)
+        truthy ? min_quantify(group_node) : null_quantify(group_node)
+      end
+
+      def adapt_conditional_to_permutation(conditional_node, truthy)
+        branches = conditional_node.children[1...-1]
+        if branches.count == 1
+          truthy || null_quantify(branches.first)
+        else
+          null_quantify(truthy ? branches.last : branches.first)
+        end
+        conditional_node.update(type: :plain)
+      end
+
+      def adapt_backref_to_permutation(backref_node, caps_per_branch, i)
+        new_num = backref_node.children[0].to_i + caps_per_branch * i
+        backref_node.update(children: [new_num.to_s])
+      end
+
       def min_quantify(node)
-        return if (qtf = node.quantifier).nil? || qtf.min > 0
+        return if guarantees_at_least_one_match?(qtf = node.quantifier)
 
         if qtf.max.equal?(1) # any zero_or_one quantifier (?, ??, ?+)
           node.update(quantifier: nil)
@@ -91,6 +107,10 @@ class JsRegex
         end
       end
 
+      def guarantees_at_least_one_match?(quantifier)
+        quantifier.nil? || quantifier.min > 0
+      end
+
       def null_quantify(node)
         node.update(quantifier: '{0}')
       end

data/lib/js_regex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class JsRegex
-  VERSION = '3.2.0'
+  VERSION = '3.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js_regex
 version: !ruby/object:Gem::Version
-  version: 3.2.0
+  version: 3.3.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-18 00:00:00.000000000 Z
+date: 2019-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: character_set
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: regexp_parser
   requirement: !ruby/object:Gem::Requirement
@@ -122,20 +122,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.12'
-- !ruby/object:Gem::Dependency
-  name: mutant-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
 description: JsRegex converts Ruby's native regular expressions for JavaScript, taking
   care of various incompatibilities and returning warnings for unsolvable differences.
 email: