js_regex 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4f8f83148f3bcfeb5262259d0893fe92db40e59f64627c4430deee7eaee194c2
-  data.tar.gz: 9cf144827bd01a075552cf12bfd16152c417e82eab064f1fa6a65133381d95ac
+  metadata.gz: 7219e7e794aa7b4df64655f362d448122fd07f901686ead1706626e925919976
+  data.tar.gz: 97924f576ecabd32288c9a4827edf5538b21d807813afb8c7ee2cfc639136b2d
 SHA512:
-  metadata.gz: bf9b4ff58756d2f12be785a803fda5e75aeffd556cdd49860e7474caf963957414b11e9fd1f3d35c6aee90375f3f23dc4435033ee1d3ba086534fdd7cf8d7caf
-  data.tar.gz: b6d4e6dd07949b8fa3394e4868214d1a1977ee3fe65713c7eb000cdffc50e1d485be9af2f7fcffcc1893c883eb36cd4bd5c4c687b2aebabd62f2454820f57db5
+  metadata.gz: 0de5c05e55115fa6bc400551e6cd6eeaf9370b65bcf64262bebb6aaee7612ed4d0e6d67c10eeae794ae28af83839e1765f4cbc2b5ab0274e117ff8c20a4b30be
+  data.tar.gz: b71ef3b13a3969b65c332b1ecb42e164fa6acf7e317872eda254a485647378870749c74f04486d520d8b854ac39c5d9a1e90d6f84f898ebbda8ffd4f7bb339df

data/lib/js_regex/conversion.rb

@@ -9,6 +9,8 @@ class JsRegex
   class Conversion
     require 'regexp_parser'
     require_relative 'converter'
+    require_relative 'node'
+    require_relative 'second_pass'
 
     class << self
       def of(ruby_regex, options: nil)
@@ -20,11 +22,11 @@ class JsRegex
       private
 
       def convert_source(ruby_regex)
-        context = Converter::Context.new(ruby_regex)
-        [
-          Converter::RootConverter.new.convert(context.ast, context),
-          context.warnings
-        ]
+        tree = Regexp::Parser.parse(ruby_regex)
+        context = Converter::Context.new(case_insensitive_root: tree.i?)
+        converted_tree = Converter.convert(tree, context)
+        final_tree = SecondPass.call(converted_tree)
+        [final_tree.to_s, context.warnings]
       end
 
       def convert_options(ruby_regex, custom_options)

data/lib/js_regex/converter/backreference_converter.rb

@@ -15,60 +15,54 @@ class JsRegex
         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
+        when :name_call           then mark_name_call
+        when :number_call         then mark_number_call
+        when :number_rel_call     then mark_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)}"
+        convert_ref(context.named_group_positions.fetch(expression.name))
       end
 
       def convert_number_ref
-        "\\#{context.new_capturing_group_position(expression.number)}"
+        convert_ref(context.new_capturing_group_position(expression.number))
       end
 
       def convert_number_rel_ref
-        "\\#{context.new_capturing_group_position(absolute_position)}"
+        convert_ref(context.new_capturing_group_position(absolute_position))
+      end
+
+      def convert_ref(position)
+        Node.new('\\', Node.new(position.to_s, type: :backref_num))
       end
 
       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
+      def mark_name_call
+        mark_call(expression.name)
       end
 
-      def convert_number_call
-        if expression.number == 0
+      def mark_number_call
+        if expression.number.equal?(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
+        mark_call(expression.number)
       end
 
-      def convert_number_rel_call
-        replace_with_group do |group|
-          [:capture, :options].include?(group.token) &&
-            group.number.equal?(absolute_position)
-        end
+      def mark_number_rel_call
+        is_forward_referring = data.include?('+') # e.g. \g<+2>
+        mark_call(absolute_position - (is_forward_referring ? 1 : 0))
       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
-        ''
+      def mark_call(reference)
+        # increment group count as calls will be substituted with groups
+        context.increment_local_capturing_group_count
+        Node.new(reference: reference, type: :subexp_call)
       end
     end
   end

data/lib/js_regex/converter/base.rb

@@ -3,15 +3,18 @@
 class JsRegex
   module Converter
     #
-    # Template class. Implement #convert_data in subclasses.
+    # Template class. Implement #convert_data in subclasses and return
+    # instance of String or Node from it.
     #
     class Base
+      # returns instance of Node with #quantifier attached.
       def convert(expression, context)
         self.context    = context
         self.expression = expression
 
-        source = convert_data
-        apply_quantifier(source)
+        node = convert_data
+        node = Node.new(node) if node.instance_of?(String)
+        apply_quantifier(node)
       end
 
       private
@@ -27,41 +30,49 @@ class JsRegex
       end
       alias pass_through data
 
-      def apply_quantifier(source)
-        return source if source.empty? || !(quantifier = expression.quantifier)
+      def apply_quantifier(node)
+        return node if node.dropped? || (qtf = expression.quantifier).nil?
 
-        if quantifier.mode.equal?(:possessive)
-          context.wrap_in_backrefed_lookahead(source + quantifier.text[0..-2])
+        if qtf.possessive?
+          node.update(quantifier: qtf.text[0..-2])
+          return wrap_in_backrefed_lookahead([node])
         else
-          source + quantifier
+          node.update(quantifier: qtf)
         end
-      end
 
-      def convert_subexpressions
-        convert_expressions(subexpressions)
+        node
       end
 
-      def convert_expressions(expressions)
-        expressions.map { |exp| Converter.for(exp).convert(exp, context) }.join
+      def convert_subexpressions
+        Node.new(*expression.expressions.map { |exp| convert_expression(exp) })
       end
 
-      def subexpressions
-        expression.expressions
+      def convert_expression(expression)
+        Converter.convert(expression, context)
       end
 
       def warn_of_unsupported_feature(description = nil)
         description ||= "#{subtype} #{expression.type}".tr('_', ' ')
         full_desc = "#{description} '#{expression}'"
         warn("Dropped unsupported #{full_desc} at index #{expression.ts}")
-        ''
+        drop
       end
 
       def warn(text)
         context.warnings << text
       end
 
-      def drop_without_warning
-        ''
+      def drop
+        Node.new(type: :dropped)
+      end
+      alias drop_without_warning drop
+
+      def wrap_in_backrefed_lookahead(content)
+        backref_num = context.capturing_group_count + 1
+        backref_num_node = Node.new(backref_num.to_s, type: :backref_num)
+        context.increment_local_capturing_group_count
+        # an empty passive group (?:) is appended as literal digits may follow
+        Node.new('(?=(', *content, '))\\', backref_num_node, '(?:)')
       end
     end
   end

data/lib/js_regex/converter/conditional_converter.rb

@@ -11,12 +11,20 @@ class JsRegex
       private
 
       def convert_data
-        warn_of_unsupported_feature('conditional')
-        branches = subexpressions.drop(1).each_with_object([]) do |branch, arr|
-          converted_branch = convert_expressions(branch)
-          arr << converted_branch unless converted_branch.eql?('')
+        case subtype
+        when :open      then mark_conditional
+        when :condition then drop_without_warning
+        else                 warn_of_unsupported_feature
         end
-        "(?:#{branches.join('|')})"
+      end
+
+      def mark_conditional
+        reference = expression.reference
+        node = Node.new('(?:', reference: reference, type: :conditional)
+        expression.branches.each do |branch|
+          node << Node.new('(?:', convert_expression(branch), ')')
+        end
+        node << ')'
       end
     end
   end

data/lib/js_regex/converter/context.rb

@@ -8,20 +8,19 @@ class JsRegex
     # The Converters themselves are stateless.
     #
     class Context
-      attr_reader :ast,
+      attr_reader :capturing_group_count,
                   :case_insensitive_root,
                   :in_atomic_group,
                   :named_group_positions,
                   :warnings
 
-      def initialize(ruby_regex)
+      def initialize(case_insensitive_root: false)
         self.added_capturing_groups_after_group = Hash.new(0)
         self.capturing_group_count = 0
         self.named_group_positions = {}
         self.warnings = []
 
-        self.ast = Regexp::Parser.parse(ruby_regex)
-        self.case_insensitive_root = ast.case_insensitive?
+        self.case_insensitive_root = case_insensitive_root
       end
 
       # group context
@@ -38,13 +37,9 @@ class JsRegex
         self.in_atomic_group = false
       end
 
-      def wrap_in_backrefed_lookahead(content)
-        new_backref_num = capturing_group_count + 1
-        # an empty passive group (?:) is appended as literal digits may follow
-        result = "(?=(#{content}))\\#{new_backref_num}(?:)"
+      def increment_local_capturing_group_count
         added_capturing_groups_after_group[original_capturing_group_count] += 1
         capture_group
-        result
       end
 
       # takes and returns 1-indexed group positions.
@@ -67,10 +62,9 @@ class JsRegex
 
       private
 
-      attr_accessor :added_capturing_groups_after_group,
-                    :capturing_group_count
+      attr_accessor :added_capturing_groups_after_group
 
-      attr_writer :ast,
+      attr_writer :capturing_group_count,
                   :case_insensitive_root,
                   :in_atomic_group,
                   :named_group_positions,

data/lib/js_regex/converter/escape_converter.rb

@@ -55,9 +55,9 @@ class JsRegex
       end
 
       def convert_codepoint_list
-        expression.chars.map do |char|
-          LiteralConverter.convert_data(Regexp.escape(char))
-        end.join
+        expression.chars.each_with_object(Node.new) do |char, node|
+          node << LiteralConverter.convert_data(Regexp.escape(char))
+        end
       end
 
       def unicode_escape_codepoint

data/lib/js_regex/converter/group_converter.rb

@@ -28,7 +28,7 @@ class JsRegex
           build_unsupported_group('nested atomic group')
         else
           context.start_atomic_group
-          result = context.wrap_in_backrefed_lookahead(convert_subexpressions)
+          result = wrap_in_backrefed_lookahead(convert_subexpressions)
           context.end_atomic_group
           result
         end
@@ -37,15 +37,19 @@ class JsRegex
       def build_named_group
         # remember position, then drop name part without warning
         context.store_named_group_position(expression.name)
-        build_group(head: '(')
+        build_group(head: '(', reference: expression.name)
       end
 
       def build_options_group
         unless (encoding_options = data.scan(/[adu]/)).empty?
           warn_of_unsupported_feature("encoding options #{encoding_options}")
         end
-        switch_only = subtype.equal?(:options_switch)
-        switch_only ? drop_without_warning : build_group(head: '(')
+        if subtype.equal?(:options_switch)
+          # can be ignored since #options on subsequent Expressions are correct
+          drop_without_warning
+        else
+          build_passive_group
+        end
       end
 
       def build_passive_group
@@ -58,9 +62,19 @@ class JsRegex
       end
 
       def build_group(opts = {})
-        context.capture_group unless opts[:capturing].equal?(false)
         head = opts[:head] || pass_through
-        "#{head}#{convert_subexpressions})"
+        if opts[:capturing].equal?(false)
+          return Node.new(*group_with_head(head))
+        end
+
+        context.capture_group
+
+        ref = opts[:reference] || expression.number
+        Node.new(*group_with_head(head), reference: ref, type: :captured_group)
+      end
+
+      def group_with_head(head)
+        [head, *convert_subexpressions, ')']
       end
     end
   end

data/lib/js_regex/converter/literal_converter.rb

@@ -9,18 +9,28 @@ class JsRegex
     #
     class LiteralConverter < JsRegex::Converter::Base
       class << self
-        ASTRAL_PLANE_CODEPOINT_PATTERN = /\A[\u{10000}-\u{FFFFF}]\z/
+        ASTRAL_PLANE_CODEPOINT_PATTERN = /[\u{10000}-\u{FFFFF}]/
 
         def convert_data(data)
           if data =~ ASTRAL_PLANE_CODEPOINT_PATTERN
-            surrogate_pair_for(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
           else
-            ensure_json_compatibility(
-              ensure_forward_slashes_are_escaped(data)
-            )
+            convert_bmp_data(data)
           end
         end
 
+        def convert_bmp_data(data)
+          ensure_json_compatibility(
+            ensure_forward_slashes_are_escaped(data)
+          )
+        end
+
         private
 
         def surrogate_pair_for(astral_char)
@@ -56,7 +66,10 @@ class JsRegex
 
       def handle_locally_case_insensitive_literal(literal)
         return literal unless literal =~ HAS_CASE_PATTERN
-        "[#{literal}#{literal.swapcase}]"
+
+        literal.each_char.each_with_object(Node.new) do |chr, node|
+          node << (chr =~ HAS_CASE_PATTERN ? "[#{chr}#{chr.swapcase}]" : chr)
+        end
       end
     end
   end

data/lib/js_regex/converter/meta_converter.rb

@@ -13,7 +13,7 @@ class JsRegex
       def convert_data
         case subtype
         when :alternation
-          convert_alternation
+          convert_alternatives
         when :dot
           expression.multiline? ? '(?:.|\n)' : '.'
         else
@@ -21,12 +21,15 @@ class JsRegex
         end
       end
 
-      def convert_alternation
-        branches = subexpressions.each_with_object([]) do |branch, arr|
-          converted_branch = convert_expressions(branch.expressions)
-          arr << converted_branch unless converted_branch.eql?('')
+      def convert_alternatives
+        kept_any = false
+
+        convert_subexpressions.map do |node|
+          dropped = !node.children.empty? && node.children.all?(&:dropped?)
+          node.children.unshift('|') if kept_any.equal?(true) && !dropped
+          kept_any = true unless dropped
+          node
         end
-        branches.join('|')
       end
     end
   end

data/lib/js_regex/converter/property_converter.rb

@@ -8,20 +8,19 @@ class JsRegex
     #
     # Template class implementation.
     #
+    # Uses the `character_set` and `regexp_property_values` gems to get the
+    # codepoints matched by the property and build a set string from them.
+    #
     class PropertyConverter < JsRegex::Converter::Base
       private
 
       def convert_data
-        convert_property
-      end
-
-      def convert_property(negated = nil)
         content = CharacterSet.of_property(subtype)
         if expression.case_insensitive? && !context.case_insensitive_root
           content = content.case_insensitive
         end
 
-        if negated
+        if expression.negative?
           if content.astral_part.empty?
             return "[^#{content.to_s(format: :js)}]"
           else
@@ -35,10 +34,10 @@ class JsRegex
         end
 
         bmp_part = content.bmp_part
-        return '' if bmp_part.empty?
+        return drop if bmp_part.empty?
 
         string = bmp_part.to_s(format: :js)
-        negated ? "[^#{string}]" : "[#{string}]"
+        expression.negative? ? "[^#{string}]" : "[#{string}]"
       end
     end
   end

data/lib/js_regex/converter/set_converter.rb

@@ -10,6 +10,11 @@ class JsRegex
     #
     # Template class implementation.
     #
+    # Unlike other converters, this one does not recurse on subexpressions,
+    # since many are unsupported by JavaScript. If it detects incompatible
+    # children, it uses the `character_set` gem to establish the codepoints
+    # matched by the whole set and build a completely new set string.
+    #
     class SetConverter < JsRegex::Converter::Base
       private
 
@@ -32,7 +37,7 @@ class JsRegex
         else
           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)
+          bmp_part.empty? ? drop : bmp_part.to_s(format: :js, in_brackets: true)
         end
       end
 
@@ -42,7 +47,7 @@ class JsRegex
           return false
         end
 
-        # check for subexpressions that need conversion
+        # check for children needing conversion (#each_expression is recursive)
         expression.each_expression do |node|
           case node.type
           when :literal

data/lib/js_regex/converter/{root_converter.rb → subexpression_converter.rb}

@@ -7,7 +7,7 @@ class JsRegex
     #
     # Template class implementation.
     #
-    class RootConverter < JsRegex::Converter::Base
+    class SubexpressionConverter < JsRegex::Converter::Base
       private
 
       def convert_data

data/lib/js_regex/converter/type_converter.rb

@@ -19,7 +19,7 @@ class JsRegex
 
       HEX_EXPANSION       = '[0-9A-Fa-f]'
       NONHEX_EXPANSION    = '[^0-9A-Fa-f]'
-      LINEBREAK_EXPANSION = '(\r\n|\r|\n)'
+      LINEBREAK_EXPANSION = '(?:\r\n|\r|\n)'
 
       private
 

data/lib/js_regex/converter.rb

@@ -12,27 +12,32 @@ class JsRegex
       backref:     BackreferenceConverter,
       conditional: ConditionalConverter,
       escape:      EscapeConverter,
+      expression:  SubexpressionConverter,
       free_space:  FreespaceConverter,
       group:       GroupConverter,
       literal:     LiteralConverter,
       meta:        MetaConverter,
-      nonproperty: NonpropertyConverter,
+      nonproperty: PropertyConverter,
       property:    PropertyConverter,
       set:         SetConverter,
       type:        TypeConverter
     ).freeze
 
-    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
+      def convert(exp, context = nil)
+        self.for(exp).convert(exp, context || Context.new)
+      end
+
+      def 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.
       attr_accessor :surrogate_pair_limit
     end
     self.surrogate_pair_limit = 300

data/lib/js_regex/node.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class JsRegex
+  #
+  # Converter#convert result. Represents a branch or leaf node with an optional
+  # quantifier as well as type and reference annotations for SecondPass.
+  #
+  class Node
+    attr_reader :children, :quantifier, :reference, :type
+
+    TYPES = %i[
+      backref_num
+      captured_group
+      conditional
+      dropped
+      plain
+      subexp_call
+    ]
+
+    def initialize(*children, quantifier: nil, reference: nil, type: :plain)
+      raise ArgumentError, "bad type #{type}" unless TYPES.include?(type)
+      self.children = children
+      self.quantifier = quantifier
+      self.reference = reference
+      self.type = type
+    end
+
+    def initialize_copy(orig)
+      super
+      self.children = orig.children.map(&:clone)
+      self.quantifier = orig.quantifier && orig.quantifier.clone
+    end
+
+    def map(&block)
+      clone.tap { |node| node.children.replace(children.map(&block)) }
+    end
+
+    def <<(node)
+      children << node
+      self
+    end
+
+    def dropped?
+      # keep everything else, including empty or depleted capturing groups
+      # so as not to not mess with reference numbers (e.g. backrefs)
+      type.equal?(:dropped)
+    end
+
+    def to_s
+      case type
+      when :dropped
+        ''
+      when :backref_num, :captured_group, :plain
+        children.join << quantifier.to_s
+      else
+        raise TypeError, "#{type} must be substituted before stringification"
+      end
+    end
+
+    def update(attrs)
+      self.children   = attrs[:children]   if attrs.key?(:children)
+      self.quantifier = attrs[:quantifier] if attrs.key?(:quantifier)
+      self.type       = attrs[:type]       if attrs.key?(:type)
+    end
+
+    private
+
+    attr_writer :children, :reference, :quantifier, :type
+  end
+end

data/lib/js_regex/second_pass.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+class JsRegex
+  #
+  # After conversion of a full Regexp::Expression tree, this class
+  # checks for Node instances that need further processing.
+  #
+  # E.g. subexpression calls (such as \g<1>) can be look-ahead,
+  # so the full Regexp must have been processed first, and only then can
+  # they be substituted with the conversion result of their targeted group.
+  #
+  module SecondPass
+    module_function
+
+    def call(tree)
+      substitute_subexp_calls(tree)
+      alternate_conditional_permutations(tree)
+      tree
+    end
+
+    def substitute_subexp_calls(tree)
+      crawl(tree) do |node|
+        if node.type == :subexp_call
+          called_group = find_group_by_reference(node.reference, in_node: tree)
+          node.update(children: called_group.children, type: :captured_group)
+        end
+      end
+    end
+
+    def crawl(node, &block)
+      return if node.instance_of?(String)
+      yield(node)
+      node.children.each { |child| crawl(child, &block) }
+    end
+
+    def alternate_conditional_permutations(tree)
+      permutations = conditional_tree_permutations(tree)
+      return tree if permutations.empty?
+
+      alternatives = permutations.map.with_index do |variant, i|
+        Node.new((i.zero? ? '(?:' : '|(?:'), variant, ')')
+      end
+      tree.update(children: alternatives)
+    end
+
+    def find_group_by_reference(ref, in_node: nil)
+      crawl(in_node) do |node|
+        return node if node.type == :captured_group && node.reference == ref
+      end
+      Node.new('()')
+    end
+
+    def conditional_tree_permutations(tree)
+      all_conditions = conditions(tree)
+      return [] if all_conditions.empty?
+
+      captured_groups_per_branch = captured_group_count(tree)
+
+      condition_permutations(all_conditions).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
+        end
+      end
+    end
+
+    def conditions(tree)
+      conditions = []
+      crawl(tree) do |node|
+        conditions << node.reference if node.type.equal?(:conditional)
+      end
+      conditions
+    end
+
+    def captured_group_count(tree)
+      count = 0
+      crawl(tree) { |node| count += 1 if node.type.equal?(:captured_group)}
+      count
+    end
+
+    def condition_permutations(conditions)
+      return [] if conditions.empty?
+
+      condition_permutations = (0..(conditions.length)).inject([]) do |arr, n|
+        arr += conditions.combination(n).to_a
+      end
+    end
+
+    def min_quantify(node)
+      return if (qtf = node.quantifier).nil? || qtf.min > 0
+
+      if qtf.max.equal?(1) # any zero_or_one quantifier (?, ??, ?+)
+        node.update(quantifier: nil)
+      else
+        node.update(quantifier: "{1,#{qtf.max}}#{'?' if qtf.reluctant?}")
+      end
+    end
+
+    def null_quantify(node)
+      node.update(quantifier: '{0}')
+    end
+  end
+end

data/lib/js_regex/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js_regex
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-04 00:00:00.000000000 Z
+date: 2018-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: character_set
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: regexp_property_values
   requirement: !ruby/object:Gem::Requirement
@@ -144,12 +144,13 @@ files:
 - lib/js_regex/converter/group_converter.rb
 - lib/js_regex/converter/literal_converter.rb
 - lib/js_regex/converter/meta_converter.rb
-- lib/js_regex/converter/nonproperty_converter.rb
 - lib/js_regex/converter/property_converter.rb
-- lib/js_regex/converter/root_converter.rb
 - lib/js_regex/converter/set_converter.rb
+- lib/js_regex/converter/subexpression_converter.rb
 - lib/js_regex/converter/type_converter.rb
 - lib/js_regex/converter/unsupported_token_converter.rb
+- lib/js_regex/node.rb
+- lib/js_regex/second_pass.rb
 - lib/js_regex/version.rb
 homepage: https://github.com/janosch-x/js_regex
 licenses:

data/lib/js_regex/converter/nonproperty_converter.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-require_relative 'property_converter'
-
-class JsRegex
-  module Converter
-    #
-    # Template class implementation.
-    #
-    # Note the inheritance from PropertyConverter.
-    #
-    class NonpropertyConverter < JsRegex::Converter::PropertyConverter
-      private
-
-      def convert_data
-        convert_property(true)
-      end
-    end
-  end
-end