js_regex 3.1.1 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 6a237a19bfb30858c132e91050d86935f9de2408
-  data.tar.gz: d4ea7a0226b9a0189d8f8d5fe026f530a43c0318
+SHA256:
+  metadata.gz: 48540644a806114addad63fb0f3ff9ba7ad00a084b3b281b9132d2eddbe610ff
+  data.tar.gz: 775fd5d3f54c8b3c32b145414707c0b69c5c783cbd5270d9bc8d5e1564a6fec7
 SHA512:
-  metadata.gz: 3a7ee4f9e2fb0c9438462662a946c3451de9fc9f4ea699015f2e89eb7b78b3c7d0bae5e30f862feb42f091e191bed08f04cfa866e034c8a4efc7d0b003ba09e7
-  data.tar.gz: a8f3d501b3a593c1e18bfa3117841eab4e9e4dd3ed76e0b4d5c9fabf4a791efef9306d059701548acc2b13468fe7805e860aef244792911d992e07d78d7a2e29
+  metadata.gz: 97810021249f6b512ebae5898f6ffe51ae95269f1e47909fb7b95fbe1e8aa6ba9696e4c7966bac27cbc7c1bd36668729aeb5d0ab4c243e85a88bb70fd6cbb203
+  data.tar.gz: 5681e9d950c14f7260596b46a382a9829c0be4326bd898acbdcf5a257936c0f543018b5c7b1435582d8ba976a680d3b08ac0189e85d82b49e621e5f8918b93a9

data/lib/js_regex.rb

@@ -28,6 +28,6 @@ class JsRegex
   end
 
   def to_s
-    "/#{source}/#{options}"
+    "/#{source.empty? ? '(?:)' : source}/#{options}"
   end
 end

data/lib/js_regex/converter.rb

@@ -38,7 +38,11 @@ class JsRegex
       # 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
+      attr_writer :surrogate_pair_limit
+
+      def in_surrogate_pair_limit?(&pair_count)
+        @surrogate_pair_limit.nil? || @surrogate_pair_limit >= pair_count.call
+      end
     end
     self.surrogate_pair_limit = 300
   end

data/lib/js_regex/converter/assertion_converter.rb

@@ -16,7 +16,7 @@ class JsRegex
       def convert_data
         case subtype
         when :lookahead, :nlookahead
-          build_group(capturing: false)
+          build_group(head: pass_through, capturing: false)
         when :nlookbehind
           warn_of_unsupported_feature('negative lookbehind assertion')
         else # :lookbehind, ...

data/lib/js_regex/converter/backreference_converter.rb

@@ -12,57 +12,28 @@ class JsRegex
 
       def convert_data
         case subtype
-        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 mark_name_call
-        when :number_call         then mark_number_call
-        when :number_rel_call     then mark_number_rel_call
+        when :name_ref, :number, :number_ref, :number_rel_ref then convert_ref
+        when :name_call, :number_call, :number_rel_call       then convert_call
         else # name_recursion_ref, number_recursion_ref, ...
           warn_of_unsupported_feature
         end
       end
 
-      def convert_name_ref
-        convert_ref(context.named_group_positions.fetch(expression.name))
-      end
-
-      def convert_number_ref
-        convert_ref(context.new_capturing_group_position(expression.number))
-      end
-
-      def convert_number_rel_ref
-        convert_ref(context.new_capturing_group_position(absolute_position))
-      end
-
-      def convert_ref(position)
+      def convert_ref
+        position = context.new_capturing_group_position(target_position)
         Node.new('\\', Node.new(position.to_s, type: :backref_num))
       end
 
-      def absolute_position
-        expression.number + context.original_capturing_group_count + 1
+      def target_position
+        expression.referenced_expression.number
       end
 
-      def mark_name_call
-        mark_call(expression.name)
-      end
-
-      def mark_number_call
-        if expression.number.equal?(0)
+      def convert_call
+        if expression.respond_to?(:number) && expression.number.equal?(0)
           return warn_of_unsupported_feature('whole-pattern recursion')
         end
-        mark_call(expression.number)
-      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 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)
+        convert_expression(expression.referenced_expression.unquantified_clone)
       end
     end
   end

data/lib/js_regex/converter/base.rb

@@ -35,7 +35,7 @@ class JsRegex
 
         if qtf.possessive?
           node.update(quantifier: qtf.text[0..-2])
-          return wrap_in_backrefed_lookahead([node])
+          return wrap_in_backrefed_lookahead(node)
         else
           node.update(quantifier: qtf)
         end
@@ -44,7 +44,7 @@ class JsRegex
       end
 
       def convert_subexpressions
-        Node.new(*expression.expressions.map { |exp| convert_expression(exp) })
+        Node.new(*expression.map { |subexp| convert_expression(subexp) })
       end
 
       def convert_expression(expression)

data/lib/js_regex/converter/conditional_converter.rb

@@ -12,14 +12,13 @@ class JsRegex
 
       def convert_data
         case subtype
-        when :open      then mark_conditional
-        when :condition then drop_without_warning
-        else                 warn_of_unsupported_feature
+        when :open then mark_conditional
+        else warn_of_unsupported_feature
         end
       end
 
       def mark_conditional
-        reference = expression.reference
+        reference = expression.referenced_expression.number
         node = Node.new('(?:', reference: reference, type: :conditional)
         expression.branches.each do |branch|
           node << Node.new('(?:', convert_expression(branch), ')')

data/lib/js_regex/converter/context.rb

@@ -11,13 +11,11 @@ class JsRegex
       attr_reader :capturing_group_count,
                   :case_insensitive_root,
                   :in_atomic_group,
-                  :named_group_positions,
                   :warnings
 
       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.case_insensitive_root = case_insensitive_root
@@ -56,10 +54,6 @@ class JsRegex
         capturing_group_count - total_added_capturing_groups
       end
 
-      def store_named_group_position(name)
-        named_group_positions[name] = capturing_group_count + 1
-      end
-
       private
 
       attr_accessor :added_capturing_groups_after_group
@@ -67,7 +61,6 @@ class JsRegex
       attr_writer :capturing_group_count,
                   :case_insensitive_root,
                   :in_atomic_group,
-                  :named_group_positions,
                   :warnings
 
       def total_added_capturing_groups

data/lib/js_regex/converter/group_converter.rb

@@ -12,13 +12,12 @@ class JsRegex
 
       def convert_data
         case subtype
+        when :capture, :named then build_group
         when :atomic then emulate_atomic_group
-        when :capture then build_group
         when :comment then drop_without_warning
-        when :named then build_named_group
         when :options, :options_switch then build_options_group
         when :passive then build_passive_group
-        when :absence then warn_of_unsupported_feature
+        when :absence then build_absence_group_if_simple
         else build_unsupported_group
         end
       end
@@ -34,12 +33,6 @@ class JsRegex
         end
       end
 
-      def build_named_group
-        # remember position, then drop name part without warning
-        context.store_named_group_position(expression.name)
-        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}")
@@ -56,25 +49,47 @@ class JsRegex
         build_group(head: '(?:', capturing: false)
       end
 
+      def build_absence_group_if_simple
+        if unmatchable_absence_group?
+          unmatchable_substitution
+        elsif expression.inner_match_length.fixed?
+          build_absence_group
+        else
+          warn_of_unsupported_feature('variable-length absence group content')
+        end
+      end
+
+      def unmatchable_absence_group?
+        expression.empty?
+      end
+
+      def unmatchable_substitution
+        '(?!)'
+      end
+
+      def build_absence_group
+        head = "(?:(?:.|\\n){,#{expression.inner_match_length.min - 1}}|(?:(?!"
+        tail = ')(?:.|\n))*)'
+        build_group(head: head, tail: tail, capturing: false)
+      end
+
       def build_unsupported_group(description = nil)
         warn_of_unsupported_feature(description)
         build_passive_group
       end
 
       def build_group(opts = {})
-        head = opts[:head] || pass_through
-        if opts[:capturing].equal?(false)
-          return Node.new(*group_with_head(head))
-        end
+        head = opts[:head] || '('
+        tail = opts[:tail] || ')'
+        return Node.new(*wrap(head, tail)) if opts[:capturing].equal?(false)
 
         context.capture_group
-
-        ref = opts[:reference] || expression.number
-        Node.new(*group_with_head(head), reference: ref, type: :captured_group)
+        ref = expression.number
+        Node.new(*wrap(head, tail), reference: ref, type: :captured_group)
       end
 
-      def group_with_head(head)
-        [head, *convert_subexpressions, ')']
+      def wrap(head, tail)
+        [head, convert_subexpressions, tail]
       end
     end
   end

data/lib/js_regex/converter/literal_converter.rb

@@ -65,8 +65,10 @@ class JsRegex
       HAS_CASE_PATTERN = /[\p{lower}\p{upper}]/
 
       def handle_locally_case_insensitive_literal(literal)
-        return literal unless literal =~ HAS_CASE_PATTERN
+        literal =~ HAS_CASE_PATTERN ? case_insensitivize(literal) : literal
+      end
 
+      def case_insensitivize(literal)
         literal.each_char.each_with_object(Node.new) do |chr, node|
           node << (chr =~ HAS_CASE_PATTERN ? "[#{chr}#{chr.swapcase}]" : chr)
         end

data/lib/js_regex/converter/meta_converter.rb

@@ -22,11 +22,11 @@ class JsRegex
       end
 
       def convert_alternatives
-        kept_any = false
+        kept_any = nil
 
-        convert_subexpressions.map do |node|
+        convert_subexpressions.transform do |node|
           dropped = !node.children.empty? && node.children.all?(&:dropped?)
-          node.children.unshift('|') if kept_any.equal?(true) && !dropped
+          node.children.unshift('|') if kept_any && !dropped
           kept_any = true unless dropped
           node
         end

data/lib/js_regex/converter/property_converter.rb

@@ -21,13 +21,10 @@ class JsRegex
         end
 
         if expression.negative?
-          if content.astral_part.empty?
-            return "[^#{content.to_s(format: :js)}]"
-          else
+          if content.astral_part?
             warn_of_unsupported_feature('astral plane negation by property')
           end
-        elsif Converter.surrogate_pair_limit.nil? ||
-              Converter.surrogate_pair_limit >= content.astral_part.size
+        elsif Converter.in_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')
@@ -36,8 +33,7 @@ class JsRegex
         bmp_part = content.bmp_part
         return drop if bmp_part.empty?
 
-        string = bmp_part.to_s(format: :js)
-        expression.negative? ? "[^#{string}]" : "[#{string}]"
+        "[#{'^' if expression.negative?}#{bmp_part}]"
       end
     end
   end

data/lib/js_regex/converter/set_converter.rb

@@ -31,37 +31,36 @@ class JsRegex
           warn_of_unsupported_feature('nested case-sensitive set')
         end
 
-        if Converter.surrogate_pair_limit.nil? ||
-           Converter.surrogate_pair_limit >= content.astral_part.size
+        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(format: :js, in_brackets: true)
+          bmp_part.empty? ? drop : bmp_part.to_s(in_brackets: true)
         end
       end
 
       def directly_compatible?
-        if expression.case_insensitive? && !context.case_insensitive_root
+        if expression.case_insensitive? ^ context.case_insensitive_root
           # casefolding needed
-          return false
+          return
         end
 
         # check for children needing conversion (#each_expression is recursive)
-        expression.each_expression do |node|
-          case node.type
+        expression.each_expression do |exp|
+          case exp.type
           when :literal
             # surrogate pair substitution needed if astral
-            next if node.text.force_encoding('utf-8').ord <= 0xFFFF
+            next if exp.text.ord <= 0xFFFF
           when :set
             # conversion needed for nested sets, intersections
-            next if node.token.equal?(:range)
+            next if exp.token.equal?(:range)
           when :type
-            next if TypeConverter::TYPES_SHARED_BY_RUBY_AND_JS.include?(node.token)
+            next if TypeConverter::TYPES_SHARED_BY_RUBY_AND_JS.include?(exp.token)
           when :escape
-            next if EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS.include?(node.token)
+            next if EscapeConverter::ESCAPES_SHARED_BY_RUBY_AND_JS.include?(exp.token)
           end
-          return false
+          return
         end
         true
       end

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|[\n\v\f\r\u0085\u2028\u2029])'
 
       private
 

data/lib/js_regex/node.rb

@@ -14,25 +14,21 @@ class JsRegex
       conditional
       dropped
       plain
-      subexp_call
-    ]
+    ].freeze
 
-    def initialize(*children, quantifier: nil, reference: nil, type: :plain)
-      raise ArgumentError, "bad type #{type}" unless TYPES.include?(type)
+    def initialize(*children, reference: nil, type: :plain)
       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
+    def initialize_copy(*)
+      self.children = children.map(&:clone)
     end
 
-    def map(&block)
-      clone.tap { |node| node.children.replace(children.map(&block)) }
+    def transform(&block)
+      children.map!(&block)
+      self
     end
 
     def <<(node)
@@ -58,9 +54,9 @@ class JsRegex
     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)
+      self.children   = attrs.fetch(:children)   if attrs.key?(:children)
+      self.quantifier = attrs.fetch(:quantifier) if attrs.key?(:quantifier)
+      self.type       = attrs.fetch(:type)       if attrs.key?(:type)
     end
 
     private

data/lib/js_regex/second_pass.rb

@@ -2,119 +2,98 @@
 
 class JsRegex
   #
-  # After conversion of a full Regexp::Expression tree, this class
+  # After conversion of a full Regexp::Expression tree, this
   # 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
+    class << self
+      def call(tree)
+        alternate_conditional_permutations(tree)
+        tree
       end
-    end
 
-    def crawl(node, &block)
-      return if node.instance_of?(String)
-      yield(node)
-      node.children.each { |child| crawl(child, &block) }
-    end
+      private
 
-    def alternate_conditional_permutations(tree)
-      permutations = conditional_tree_permutations(tree)
-      return tree if permutations.empty?
+      def alternate_conditional_permutations(tree)
+        permutations = conditional_tree_permutations(tree)
+        return 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
+        alternatives = permutations.map.with_index do |variant, i|
+          Node.new((i.zero? ? '(?:' : '|(?:'), variant, ')')
+        end
+        tree.update(children: alternatives)
       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)
+      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
-            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)
+      def crawl(node, &block)
+        return if node.instance_of?(String)
+        yield(node)
+        node.children.each { |child| crawl(child, &block) }
       end
-      conditions
-    end
 
-    def captured_group_count(tree)
-      count = 0
-      crawl(tree) { |node| count += 1 if node.type.equal?(:captured_group)}
-      count
-    end
+      def conditions(tree)
+        conditions = []
+        crawl(tree) do |node|
+          conditions << node.reference if node.type.equal?(:conditional)
+        end
+        conditions
+      end
 
-    def condition_permutations(conditions)
-      return [] if conditions.empty?
+      def captured_group_count(tree)
+        count = 0
+        crawl(tree) { |node| count += 1 if node.type.equal?(:captured_group) }
+        count
+      end
 
-      condition_permutations = (0..(conditions.length)).inject([]) do |arr, n|
-        arr += conditions.combination(n).to_a
+      def condition_permutations(conditions)
+        (0..(conditions.length)).inject([]) do |arr, n|
+          arr += conditions.combination(n).to_a
+        end
       end
-    end
 
-    def min_quantify(node)
-      return if (qtf = node.quantifier).nil? || qtf.min > 0
+      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?}")
+        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
-    end
 
-    def null_quantify(node)
-      node.update(quantifier: '{0}')
+      def null_quantify(node)
+        node.update(quantifier: '{0}')
+      end
     end
   end
 end

data/lib/js_regex/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: js_regex
 version: !ruby/object:Gem::Version
-  version: 3.1.1
+  version: 3.2.0
 platform: ruby
 authors:
 - Janosch Müller
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-24 00:00:00.000000000 Z
+date: 2019-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: character_set
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: regexp_parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: regexp_property_values
   requirement: !ruby/object:Gem::Requirement
@@ -122,6 +122,20 @@ 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:
@@ -152,7 +166,7 @@ files:
 - lib/js_regex/node.rb
 - lib/js_regex/second_pass.rb
 - lib/js_regex/version.rb
-homepage: https://github.com/janosch-x/js_regex
+homepage: https://github.com/jaynetics/js_regex
 licenses:
 - MIT
 metadata: {}
@@ -171,8 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Converts Ruby regexes to JavaScript regexes.