pcre2 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3af91ee4c80035897edf206316fbc0d3db890a04af6e8443ef6c2449f4d2c4ab
+  data.tar.gz: ac7380e81492952a72a5ccd7b20a704f673e11645eb32b258216db40b1fa6cad
+SHA512:
+  metadata.gz: 32f765faedfbaeb55e3b63572d13546d0afb7fb69f2a1cc102cf9f2c393c2a3e957be61a187cf5f7744c0e8f2d63655e281b932fecf26058c754c450aa1d8ef5
+  data.tar.gz: 590060108d1f0f68d945a9753372936cf1bc46b4efa4e53544e4b13fde0e7ecd49b0b7a4aae1f9858bc734b636b29e4fd0622ca60cb1648f838ee136e7cfb22a

data/.github/workflows/tests.yml

@@ -0,0 +1,21 @@
+# Setup Ruby, install gems, cache gems, and run test suite
+# - https://github.com/ruby/setup-ruby
+
+name: Tests
+on: [push, pull_request]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ '2.5', '2.6' ]
+    name: Ruby ${{ matrix.ruby }} tests
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        bundler-cache: true
+        ruby-version: ${{ matrix.ruby }}
+    - run: bundle install
+    - run: bundle exec rake -t

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+/Gemfile.lock

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in pcre2.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 David Verhasselt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,67 @@
+# PCRE2
+
+This library provides a Ruby interface for the PCRE2 library, which supports more advanced regular expression functionality than the built-in Ruby `Regexp`.
+
+## Installation
+
+Install the PCRE2 library:
+
+```bash
+brew install pcre2
+```
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pcre2'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install pcre2
+
+## Usage
+
+`PCRE2::Regexp` aims to act as much like Ruby's `Regexp` as possible. It has implemented a subset of the `Regexp` and `MatchData` APIs so it can be used as a drop-in replacement.
+
+```ruby
+regexp = PCRE2::Regexp.new("hello")
+subject = "well hello there!"
+matchdata = regexp.match(subject)
+
+matchdata.offset(0) # [5, 10] - start and end of the match
+matchdata[0] # => "hello"
+
+matchdata = regexp.match(subject, 11) # find next match
+```
+
+## Benchmark
+
+You can run the benchmark that compares `PCRE2::Regexp` with Ruby's built-in `Regexp` as follows:
+
+```bash
+bundle exec rake benchmark
+```
+
+## Resources
+
+- [PCRE2 Library](https://www.pcre.org/current/doc/html/)
+- [PCRE2 demo](https://www.pcre.org/current/doc/html/pcre2demo.html)
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/dv/pcre2.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+load "benchmark.rake"

data/benchmark.rake

@@ -0,0 +1,90 @@
+require "benchmark"
+require "pcre2"
+
+desc "Run a benchmark to compare PCRE2 vs Ruby's built-in Regexp"
+task :benchmark do
+  def benchmark!(pattern, string)
+    task = ->(re) {
+      pos = 0
+
+      while matchdata = re.match(string, pos)
+        pos = matchdata.offset(0)[1] + 1
+      end
+    }
+
+    GC.disable
+    Benchmark.bmbm do |benchmark|
+      ruby_re = Regexp.new(pattern)
+      pcre2_re = PCRE2::Regexp.new(pattern)
+      pcre2_re_jit = PCRE2::Regexp.new(pattern).tap(&:jit!)
+
+      benchmark.report("Ruby Regexp") do
+        100000.times { task.call(ruby_re) }
+      end
+
+      GC.start
+
+      benchmark.report("PCRE2 Regexp") do
+        100000.times { task.call(pcre2_re) }
+      end
+
+      GC.start
+
+      benchmark.report("PCRE2 Regexp - JIT enhanced") do
+        100000.times { task.call(pcre2_re_jit) }
+      end
+    end
+    GC.enable
+
+    puts
+    puts
+    puts
+  end
+
+  puts "Benchmark 1: Small pattern, big string"
+  puts
+
+  pattern = "hello"
+  string = "abab" * 1000
+  string += "hello"
+  string += "abab" * 1000
+
+  benchmark!(pattern, string)
+
+
+  puts "Benchmark 2: Big pattern, big string"
+  puts
+
+  pattern = "hello" * 50
+  string = "abab" * 1000
+  string += "hello"
+  string += "abab" * 1000
+  string += pattern
+  string += "abab" * 1000
+
+  benchmark!(pattern, string)
+
+
+  puts "Benchmark 3: Small pattern, small string"
+  puts
+
+  pattern = "hello"
+  string = "abababab" + "hello" + "abababab"
+
+  benchmark!(pattern, string)
+
+
+  puts "Benchmark 3: Multiple matches"
+  puts
+
+  pattern = "hello"
+  string = ""
+
+  20.times do
+    string += "abab" * 5
+    string += "hello"
+    string += "abab" * 5
+  end
+
+  benchmark!(pattern, string)
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pcre2"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/pcre2.rb

@@ -0,0 +1,11 @@
+require "pcre2/version"
+require "pcre2/lib"
+require "pcre2/lib/constants"
+
+require "pcre2/error"
+require "pcre2/regexp"
+require "pcre2/matchdata"
+
+module PCRE2
+  # Your code goes here...
+end

data/lib/pcre2/error.rb

@@ -0,0 +1,9 @@
+class PCRE2::Error < StandardError
+  def self.from_error_code(error_code, extra_message = nil)
+    message = "Error #{error_code}: "
+    message += PCRE2::Lib.get_error_message(error_code)
+    message += " - #{extra_message}" if extra_message
+
+    self.new(message)
+  end
+end

data/lib/pcre2/lib.rb

@@ -0,0 +1,168 @@
+require "ffi"
+
+module PCRE2::Lib
+  RETURN_CODE_NO_ERROR = 100
+
+  extend FFI::Library
+
+  ffi_lib 'pcre2-8'     # Able to do 16 or 32 too
+
+  PCRE2_SIZE    = typedef :size_t,   :PCRE2_SIZE
+  PCRE2_SPTR    = typedef :pointer,  :PCRE2_SPTR
+  PCRE2_UCHAR8  = typedef :uint8_t,  :PCRE2_UCHAR8
+  PCRE2_UCHAR16 = typedef :uint16_t, :PCRE2_UCHAR16
+  PCRE2_UCHAR32 = typedef :uint32_t, :PCRE2_UCHAR32
+
+  # For 8-bit PCRE
+  PCRE2_UCHAR   = typedef :PCRE2_UCHAR8, :PCRE2_UCHAR
+
+  # int pcre2_get_error_message(int errorcode, PCRE2_UCHAR *buffer, PCRE2_SIZE bufflen);
+  attach_function :pcre2_get_error_message_8, [ :int, :pointer, :PCRE2_SIZE ], :int
+
+  # pcre2_code *pcre2_compile(PCRE2_SPTR pattern, PCRE2_SIZE length, uint32_t options, int *errorcode, PCRE2_SIZE *erroroffset, pcre2_compile_context *ccontext);
+  attach_function :pcre2_compile_8, [ :PCRE2_SPTR, :PCRE2_SIZE, :uint32_t, :pointer, :pointer, :pointer ], :pointer
+  attach_function :pcre2_code_free_8, [ :pointer ], :void
+
+  # int pcre2_pattern_info(const pcre2_code *code, uint32_t what, void *where);
+  attach_function :pcre2_pattern_info_8, [ :pointer, :uint32_t, :pointer ], :int
+
+  # pcre2_match_data *pcre2_match_data_create_from_pattern( const pcre2_code *code, pcre2_general_context *gcontext);
+  attach_function :pcre2_match_data_create_from_pattern_8, [ :pointer, :pointer ], :pointer
+  attach_function :pcre2_match_data_free_8, [ :pointer ], :void
+
+  # int pcre2_match(const pcre2_code *code, PCRE2_SPTR subject, PCRE2_SIZE length, PCRE2_SIZE startoffset, uint32_t options, pcre2_match_data *match_data, pcre2_match_context *mcontext);
+  attach_function :pcre2_match_8, [ :pointer, :PCRE2_SPTR, :PCRE2_SIZE, :PCRE2_SIZE, :uint32_t, :pointer, :pointer ], :int
+
+  attach_function :pcre2_get_ovector_count_8, [ :pointer ], :uint32_t
+  attach_function :pcre2_get_ovector_pointer_8, [ :pointer ], :pointer
+
+  # int pcre2_jit_compile(pcre2_code *code, uint32_t options)
+  attach_function :pcre2_jit_compile_8, [ :pointer, :uint32_t ], :int
+
+
+  def self.get_error_message(error_code)
+    if error_code.kind_of?(FFI::MemoryPointer)
+      error_code = error_code.read_int
+    end
+
+    buffer = FFI::MemoryPointer.new(PCRE2_UCHAR, 120)
+    result = pcre2_get_error_message_8(error_code, buffer, buffer.size)
+
+    case result
+    when PCRE2::PCRE2_ERROR_BADDATA
+      "Error number #{error_code} unknown"
+    when PCRE2::PCRE2_ERROR_NOMEMORY
+      raise PCRE2::Error, "Buffer of #{buffer.size} is not large enough to contain message"
+    else
+      buffer.read_string
+    end
+  end
+
+  # Some utility functions to help make the above more palatable
+  def self.compile_pattern(pattern, options = [])
+    pattern_string_ptr = FFI::MemoryPointer.from_string(pattern)
+    error_code_ptr     = FFI::MemoryPointer.new(:int, 1)
+    error_offset_ptr   = FFI::MemoryPointer.new(PCRE2_SIZE, 1)
+    options            = options.flatten.inject(0) { |memo, option| memo | option }
+
+    pattern_ptr = PCRE2::Lib.pcre2_compile_8(pattern_string_ptr, pattern.size, options, error_code_ptr, error_offset_ptr, nil)
+
+    if pattern_ptr.null?
+      error_code = error_code_ptr.read_int
+      error_offset = error_offset_ptr.read(PCRE2_SIZE)
+
+      raise PCRE2::Error.from_error_code(error_code, "while compiling pattern #{pattern} @ #{error_offset}")
+    end
+
+    FFI::AutoPointer.new(pattern_ptr, PCRE2::Lib.method(:pcre2_code_free_8))
+  end
+
+  def self.create_match_data_for_pattern(pattern_ptr)
+    match_data_ptr = PCRE2::Lib.pcre2_match_data_create_from_pattern_8(pattern_ptr, nil)
+    FFI::AutoPointer.new(match_data_ptr, PCRE2::Lib.method(:pcre2_match_data_free_8))
+  end
+
+  def self.match(pattern_ptr, body, position: 0, match_data_ptr: nil)
+    position ||= 0
+    match_data_ptr ||= create_match_data_for_pattern(pattern_ptr)
+
+    body_ptr = FFI::MemoryPointer.from_string(body)
+
+    return_code =
+      PCRE2::Lib.pcre2_match_8(
+        pattern_ptr,
+        body_ptr,
+        body_ptr.size,
+        position,
+        0,
+        match_data_ptr,
+        nil
+      )
+
+    case return_code
+    when 0
+      raise PCRE2::Error, "Not enough memory in MatchData to store all captures"
+    when PCRE2::PCRE2_ERROR_NOMATCH
+      result_count = 0
+    else
+      if return_code < 0
+        raise PCRE2::Error.from_error_code(return_code)
+      else
+        result_count = return_code
+      end
+    end
+
+    [result_count, match_data_ptr]
+  end
+
+  def self.get_ovector_pairs(match_data_ptr, pair_count)
+    if pair_count.nil?
+      pair_count = PCRE2::Lib.pcre2_get_ovector_count_8(match_data_ptr)
+    end
+
+    ovector_ptr = PCRE2::Lib.pcre2_get_ovector_pointer_8(match_data_ptr)
+    type_size = FFI.type_size(:size_t)
+
+    pair_count.times.map do |i|
+      [
+        ovector_ptr.get(:size_t, i*2 * type_size),
+        ovector_ptr.get(:size_t, (i*2+1) * type_size)
+      ]
+    end
+  end
+
+  def self.named_captures(pattern_ptr)
+    named_captures_count = FFI::MemoryPointer.new(:uint32_t, 1)
+    name_entry_size      = FFI::MemoryPointer.new(:uint32_t, 1)
+    name_table_ptr       = FFI::MemoryPointer.new(:pointer, 1)
+
+    if PCRE2::Lib.pcre2_pattern_info_8(pattern_ptr, PCRE2::PCRE2_INFO_NAMECOUNT, named_captures_count) != 0
+      raise "Something went wrong"
+    end
+
+    if PCRE2::Lib.pcre2_pattern_info_8(pattern_ptr, PCRE2::PCRE2_INFO_NAMEENTRYSIZE, name_entry_size) != 0
+      raise "Something went wrong"
+    end
+
+    if PCRE2::Lib.pcre2_pattern_info_8(pattern_ptr, PCRE2::PCRE2_INFO_NAMETABLE, name_table_ptr) != 0
+      raise "Something went wrong"
+    end
+
+    named_captures_count = named_captures_count.read_uint32
+    name_entry_size      = name_entry_size.read_uint32
+    name_table_ptr       = name_table_ptr.read_pointer
+
+    names_and_positions =
+      named_captures_count.times.map do |i|
+        ovector_position = (name_table_ptr.get_int8(0) << 8) + name_table_ptr.get_int8(1)
+        match_name = (name_table_ptr+2).read_string_to_null
+
+        name_table_ptr += name_entry_size
+
+        [match_name, ovector_position]
+      end
+
+    # Convert an array of [name, position] into a Hash of name => [position (, position, ...)], with possible duplicate names
+    names_and_positions.each_with_object(Hash.new {[]} ) { |(name, position), hash| hash[name] <<= position }
+  end
+end

data/lib/pcre2/lib/constants.rb

@@ -0,0 +1,349 @@
+#
+# Use replace:
+#
+#   "#define ([^\W]+) \W* (.*)/"" -> "\1 = \2"
+#   "(0x[^u]+)u"                  -> "\1"
+#
+module PCRE2
+  # The following option bits can be passed to pcre2_compile(), pcre2_match(),
+  # or pcre2_dfa_match(). PCRE2_NO_UTF_CHECK affects only the function to which it
+  # is passed. Put these bits at the most significant end of the options word so
+  # others can be added next to them
+
+  PCRE2_ANCHORED                             = 0x80000000
+  PCRE2_NO_UTF_CHECK                         = 0x40000000
+  PCRE2_ENDANCHORED                          = 0x20000000
+
+  # The following option bits can be passed only to pcre2_compile(). However,
+  # they may affect compilation, JIT compilation, and/or interpretive execution.
+  # The following tags indicate which:
+  # C   alters what is compiled by pcre2_compile()
+  # J   alters what is compiled by pcre2_jit_compile()
+  # M   is inspected during pcre2_match() execution
+  # D   is inspected during pcre2_dfa_match() execution
+
+  PCRE2_ALLOW_EMPTY_CLASS                    = 0x00000001  # C
+  PCRE2_ALT_BSUX                             = 0x00000002  # C
+  PCRE2_AUTO_CALLOUT                         = 0x00000004  # C
+  PCRE2_CASELESS                             = 0x00000008  # C
+  PCRE2_DOLLAR_ENDONLY                       = 0x00000010  #   J M D
+  PCRE2_DOTALL                               = 0x00000020  # C
+  PCRE2_DUPNAMES                             = 0x00000040  # C
+  PCRE2_EXTENDED                             = 0x00000080  # C
+  PCRE2_FIRSTLINE                            = 0x00000100  #   J M D
+  PCRE2_MATCH_UNSET_BACKREF                  = 0x00000200  # C J M
+  PCRE2_MULTILINE                            = 0x00000400  # C
+  PCRE2_NEVER_UCP                            = 0x00000800  # C
+  PCRE2_NEVER_UTF                            = 0x00001000  # C
+  PCRE2_NO_AUTO_CAPTURE                      = 0x00002000  # C
+  PCRE2_NO_AUTO_POSSESS                      = 0x00004000  # C
+  PCRE2_NO_DOTSTAR_ANCHOR                    = 0x00008000  # C
+  PCRE2_NO_START_OPTIMIZE                    = 0x00010000  #   J M D
+  PCRE2_UCP                                  = 0x00020000  # C J M D
+  PCRE2_UNGREEDY                             = 0x00040000  # C
+  PCRE2_UTF                                  = 0x00080000  # C J M D
+  PCRE2_NEVER_BACKSLASH_C                    = 0x00100000  # C
+  PCRE2_ALT_CIRCUMFLEX                       = 0x00200000  #   J M D
+  PCRE2_ALT_VERBNAMES                        = 0x00400000  # C
+  PCRE2_USE_OFFSET_LIMIT                     = 0x00800000  #   J M D
+  PCRE2_EXTENDED_MORE                        = 0x01000000  # C
+  PCRE2_LITERAL                              = 0x02000000  # C
+
+  # An additional compile options word is available in the compile context.
+
+  PCRE2_EXTRA_ALLOW_SURROGATE_ESCAPES        = 0x00000001  # C
+  PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL          = 0x00000002  # C
+  PCRE2_EXTRA_MATCH_WORD                     = 0x00000004  # C
+  PCRE2_EXTRA_MATCH_LINE                     = 0x00000008  # C
+  PCRE2_EXTRA_ESCAPED_CR_IS_LF               = 0x00000010  # C
+  PCRE2_EXTRA_ALT_BSUX                       = 0x00000020  # C
+
+  # These are for pcre2_jit_compile().
+
+  PCRE2_JIT_COMPLETE                         = 0x00000001  # For full matching
+  PCRE2_JIT_PARTIAL_SOFT                     = 0x00000002
+  PCRE2_JIT_PARTIAL_HARD                     = 0x00000004
+  PCRE2_JIT_INVALID_UTF                      = 0x00000100
+
+  # These are for pcre2_match(), pcre2_dfa_match(), pcre2_jit_match(), and
+  # pcre2_substitute(). Some are allowed only for one of the functions, and in
+  # these cases it is noted below. Note that PCRE2_ANCHORED, PCRE2_ENDANCHORED and
+  # PCRE2_NO_UTF_CHECK can also be passed to these functions (though
+  # pcre2_jit_match() ignores the latter since it bypasses all sanity checks).
+
+  PCRE2_NOTBOL                               = 0x00000001
+  PCRE2_NOTEOL                               = 0x00000002
+  PCRE2_NOTEMPTY                             = 0x00000004  # ) These two must be kept
+  PCRE2_NOTEMPTY_ATSTART                     = 0x00000008  # ) adjacent to each other.
+  PCRE2_PARTIAL_SOFT                         = 0x00000010
+  PCRE2_PARTIAL_HARD                         = 0x00000020
+  PCRE2_DFA_RESTART                          = 0x00000040  # pcre2_dfa_match() only
+  PCRE2_DFA_SHORTEST                         = 0x00000080  # pcre2_dfa_match() only
+  PCRE2_SUBSTITUTE_GLOBAL                    = 0x00000100  # pcre2_substitute() only
+  PCRE2_SUBSTITUTE_EXTENDED                  = 0x00000200  # pcre2_substitute() only
+  PCRE2_SUBSTITUTE_UNSET_EMPTY               = 0x00000400  # pcre2_substitute() only
+  PCRE2_SUBSTITUTE_UNKNOWN_UNSET             = 0x00000800  # pcre2_substitute() only
+  PCRE2_SUBSTITUTE_OVERFLOW_LENGTH           = 0x00001000  # pcre2_substitute() only
+  PCRE2_NO_JIT                               = 0x00002000  # Not for pcre2_dfa_match()
+  PCRE2_COPY_MATCHED_SUBJECT                 = 0x00004000
+
+  # Options for pcre2_pattern_convert().
+
+  PCRE2_CONVERT_UTF                          = 0x00000001
+  PCRE2_CONVERT_NO_UTF_CHECK                 = 0x00000002
+  PCRE2_CONVERT_POSIX_BASIC                  = 0x00000004
+  PCRE2_CONVERT_POSIX_EXTENDED               = 0x00000008
+  PCRE2_CONVERT_GLOB                         = 0x00000010
+  PCRE2_CONVERT_GLOB_NO_WILD_SEPARATOR       = 0x00000030
+  PCRE2_CONVERT_GLOB_NO_STARSTAR             = 0x00000050
+
+  # Newline and \R settings, for use in compile contexts. The newline values
+  # must be kept in step with values set in config.h and both sets must all be
+  # greater than zero.
+
+  PCRE2_NEWLINE_CR                           = 1
+  PCRE2_NEWLINE_LF                           = 2
+  PCRE2_NEWLINE_CRLF                         = 3
+  PCRE2_NEWLINE_ANY                          = 4
+  PCRE2_NEWLINE_ANYCRLF                      = 5
+  PCRE2_NEWLINE_NUL                          = 6
+  PCRE2_BSR_UNICODE                          = 1
+  PCRE2_BSR_ANYCRLF                          = 2
+
+  # Error codes for pcre2_compile(). Some of these are also used by
+  # pcre2_pattern_convert().
+
+  PCRE2_ERROR_END_BACKSLASH                  = 101
+  PCRE2_ERROR_END_BACKSLASH_C                = 102
+  PCRE2_ERROR_UNKNOWN_ESCAPE                 = 103
+  PCRE2_ERROR_QUANTIFIER_OUT_OF_ORDER        = 104
+  PCRE2_ERROR_QUANTIFIER_TOO_BIG             = 105
+  PCRE2_ERROR_MISSING_SQUARE_BRACKET         = 106
+  PCRE2_ERROR_ESCAPE_INVALID_IN_CLASS        = 107
+  PCRE2_ERROR_CLASS_RANGE_ORDER              = 108
+  PCRE2_ERROR_QUANTIFIER_INVALID             = 109
+  PCRE2_ERROR_INTERNAL_UNEXPECTED_REPEAT     = 110
+  PCRE2_ERROR_INVALID_AFTER_PARENS_QUERY     = 111
+  PCRE2_ERROR_POSIX_CLASS_NOT_IN_CLASS       = 112
+  PCRE2_ERROR_POSIX_NO_SUPPORT_COLLATING     = 113
+  PCRE2_ERROR_MISSING_CLOSING_PARENTHESIS    = 114
+  PCRE2_ERROR_BAD_SUBPATTERN_REFERENCE       = 115
+  PCRE2_ERROR_NULL_PATTERN                   = 116
+  PCRE2_ERROR_BAD_OPTIONS                    = 117
+  PCRE2_ERROR_MISSING_COMMENT_CLOSING        = 118
+  PCRE2_ERROR_PARENTHESES_NEST_TOO_DEEP      = 119
+  PCRE2_ERROR_PATTERN_TOO_LARGE              = 120
+  PCRE2_ERROR_HEAP_FAILED                    = 121
+  PCRE2_ERROR_UNMATCHED_CLOSING_PARENTHESIS  = 122
+  PCRE2_ERROR_INTERNAL_CODE_OVERFLOW         = 123
+  PCRE2_ERROR_MISSING_CONDITION_CLOSING      = 124
+  PCRE2_ERROR_LOOKBEHIND_NOT_FIXED_LENGTH    = 125
+  PCRE2_ERROR_ZERO_RELATIVE_REFERENCE        = 126
+  PCRE2_ERROR_TOO_MANY_CONDITION_BRANCHES    = 127
+  PCRE2_ERROR_CONDITION_ASSERTION_EXPECTED   = 128
+  PCRE2_ERROR_BAD_RELATIVE_REFERENCE         = 129
+  PCRE2_ERROR_UNKNOWN_POSIX_CLASS            = 130
+  PCRE2_ERROR_INTERNAL_STUDY_ERROR           = 131
+  PCRE2_ERROR_UNICODE_NOT_SUPPORTED          = 132
+  PCRE2_ERROR_PARENTHESES_STACK_CHECK        = 133
+  PCRE2_ERROR_CODE_POINT_TOO_BIG             = 134
+  PCRE2_ERROR_LOOKBEHIND_TOO_COMPLICATED     = 135
+  PCRE2_ERROR_LOOKBEHIND_INVALID_BACKSLASH_C = 136
+  PCRE2_ERROR_UNSUPPORTED_ESCAPE_SEQUENCE    = 137
+  PCRE2_ERROR_CALLOUT_NUMBER_TOO_BIG         = 138
+  PCRE2_ERROR_MISSING_CALLOUT_CLOSING        = 139
+  PCRE2_ERROR_ESCAPE_INVALID_IN_VERB         = 140
+  PCRE2_ERROR_UNRECOGNIZED_AFTER_QUERY_P     = 141
+  PCRE2_ERROR_MISSING_NAME_TERMINATOR        = 142
+  PCRE2_ERROR_DUPLICATE_SUBPATTERN_NAME      = 143
+  PCRE2_ERROR_INVALID_SUBPATTERN_NAME        = 144
+  PCRE2_ERROR_UNICODE_PROPERTIES_UNAVAILABLE = 145
+  PCRE2_ERROR_MALFORMED_UNICODE_PROPERTY     = 146
+  PCRE2_ERROR_UNKNOWN_UNICODE_PROPERTY       = 147
+  PCRE2_ERROR_SUBPATTERN_NAME_TOO_LONG       = 148
+  PCRE2_ERROR_TOO_MANY_NAMED_SUBPATTERNS     = 149
+  PCRE2_ERROR_CLASS_INVALID_RANGE            = 150
+  PCRE2_ERROR_OCTAL_BYTE_TOO_BIG             = 151
+  PCRE2_ERROR_INTERNAL_OVERRAN_WORKSPACE     = 152
+  PCRE2_ERROR_INTERNAL_MISSING_SUBPATTERN    = 153
+  PCRE2_ERROR_DEFINE_TOO_MANY_BRANCHES       = 154
+  PCRE2_ERROR_BACKSLASH_O_MISSING_BRACE      = 155
+  PCRE2_ERROR_INTERNAL_UNKNOWN_NEWLINE       = 156
+  PCRE2_ERROR_BACKSLASH_G_SYNTAX             = 157
+  PCRE2_ERROR_PARENS_QUERY_R_MISSING_CLOSING = 158
+
+  # Error 159 is obsolete and should now never occur
+
+  PCRE2_ERROR_VERB_ARGUMENT_NOT_ALLOWED      = 159
+  PCRE2_ERROR_VERB_UNKNOWN                   = 160
+  PCRE2_ERROR_SUBPATTERN_NUMBER_TOO_BIG      = 161
+  PCRE2_ERROR_SUBPATTERN_NAME_EXPECTED       = 162
+  PCRE2_ERROR_INTERNAL_PARSED_OVERFLOW       = 163
+  PCRE2_ERROR_INVALID_OCTAL                  = 164
+  PCRE2_ERROR_SUBPATTERN_NAMES_MISMATCH      = 165
+  PCRE2_ERROR_MARK_MISSING_ARGUMENT          = 166
+  PCRE2_ERROR_INVALID_HEXADECIMAL            = 167
+  PCRE2_ERROR_BACKSLASH_C_SYNTAX             = 168
+  PCRE2_ERROR_BACKSLASH_K_SYNTAX             = 169
+  PCRE2_ERROR_INTERNAL_BAD_CODE_LOOKBEHINDS  = 170
+  PCRE2_ERROR_BACKSLASH_N_IN_CLASS           = 171
+  PCRE2_ERROR_CALLOUT_STRING_TOO_LONG        = 172
+  PCRE2_ERROR_UNICODE_DISALLOWED_CODE_POINT  = 173
+  PCRE2_ERROR_UTF_IS_DISABLED                = 174
+  PCRE2_ERROR_UCP_IS_DISABLED                = 175
+  PCRE2_ERROR_VERB_NAME_TOO_LONG             = 176
+  PCRE2_ERROR_BACKSLASH_U_CODE_POINT_TOO_BIG = 177
+  PCRE2_ERROR_MISSING_OCTAL_OR_HEX_DIGITS    = 178
+  PCRE2_ERROR_VERSION_CONDITION_SYNTAX       = 179
+  PCRE2_ERROR_INTERNAL_BAD_CODE_AUTO_POSSESS = 180
+  PCRE2_ERROR_CALLOUT_NO_STRING_DELIMITER    = 181
+  PCRE2_ERROR_CALLOUT_BAD_STRING_DELIMITER   = 182
+  PCRE2_ERROR_BACKSLASH_C_CALLER_DISABLED    = 183
+  PCRE2_ERROR_QUERY_BARJX_NEST_TOO_DEEP      = 184
+  PCRE2_ERROR_BACKSLASH_C_LIBRARY_DISABLED   = 185
+  PCRE2_ERROR_PATTERN_TOO_COMPLICATED        = 186
+  PCRE2_ERROR_LOOKBEHIND_TOO_LONG            = 187
+  PCRE2_ERROR_PATTERN_STRING_TOO_LONG        = 188
+  PCRE2_ERROR_INTERNAL_BAD_CODE              = 189
+  PCRE2_ERROR_INTERNAL_BAD_CODE_IN_SKIP      = 190
+  PCRE2_ERROR_NO_SURROGATES_IN_UTF16         = 191
+  PCRE2_ERROR_BAD_LITERAL_OPTIONS            = 192
+  PCRE2_ERROR_SUPPORTED_ONLY_IN_UNICODE      = 193
+  PCRE2_ERROR_INVALID_HYPHEN_IN_OPTIONS      = 194
+  PCRE2_ERROR_ALPHA_ASSERTION_UNKNOWN        = 195
+  PCRE2_ERROR_SCRIPT_RUN_NOT_AVAILABLE       = 196
+
+  # "Expected" matching error codes: no match and partial match.
+
+  PCRE2_ERROR_NOMATCH                        = (-1)
+  PCRE2_ERROR_PARTIAL                        = (-2)
+
+  # Error codes for UTF-8 validity checks
+
+  PCRE2_ERROR_UTF8_ERR1                      = (-3)
+  PCRE2_ERROR_UTF8_ERR2                      = (-4)
+  PCRE2_ERROR_UTF8_ERR3                      = (-5)
+  PCRE2_ERROR_UTF8_ERR4                      = (-6)
+  PCRE2_ERROR_UTF8_ERR5                      = (-7)
+  PCRE2_ERROR_UTF8_ERR6                      = (-8)
+  PCRE2_ERROR_UTF8_ERR7                      = (-9)
+  PCRE2_ERROR_UTF8_ERR8                      = (-10)
+  PCRE2_ERROR_UTF8_ERR9                      = (-11)
+  PCRE2_ERROR_UTF8_ERR10                     = (-12)
+  PCRE2_ERROR_UTF8_ERR11                     = (-13)
+  PCRE2_ERROR_UTF8_ERR12                     = (-14)
+  PCRE2_ERROR_UTF8_ERR13                     = (-15)
+  PCRE2_ERROR_UTF8_ERR14                     = (-16)
+  PCRE2_ERROR_UTF8_ERR15                     = (-17)
+  PCRE2_ERROR_UTF8_ERR16                     = (-18)
+  PCRE2_ERROR_UTF8_ERR17                     = (-19)
+  PCRE2_ERROR_UTF8_ERR18                     = (-20)
+  PCRE2_ERROR_UTF8_ERR19                     = (-21)
+  PCRE2_ERROR_UTF8_ERR20                     = (-22)
+  PCRE2_ERROR_UTF8_ERR21                     = (-23)
+
+  # Error codes for UTF-16 validity checks
+
+  PCRE2_ERROR_UTF16_ERR1                     = (-24)
+  PCRE2_ERROR_UTF16_ERR2                     = (-25)
+  PCRE2_ERROR_UTF16_ERR3                     = (-26)
+
+  # Error codes for UTF-32 validity checks
+
+  PCRE2_ERROR_UTF32_ERR1                     = (-27)
+  PCRE2_ERROR_UTF32_ERR2                     = (-28)
+
+  # Miscellaneous error codes for pcre2[_dfa]_match(), substring extraction
+  # functions, context functions, and serializing functions. They are in numerical
+  # order. Originally they were in alphabetical order too, but now that PCRE2 is
+  # released, the numbers must not be changed.
+
+  PCRE2_ERROR_BADDATA                        = (-29)
+  PCRE2_ERROR_MIXEDTABLES                    = (-30)  # Name was changed
+  PCRE2_ERROR_BADMAGIC                       = (-31)
+  PCRE2_ERROR_BADMODE                        = (-32)
+  PCRE2_ERROR_BADOFFSET                      = (-33)
+  PCRE2_ERROR_BADOPTION                      = (-34)
+  PCRE2_ERROR_BADREPLACEMENT                 = (-35)
+  PCRE2_ERROR_BADUTFOFFSET                   = (-36)
+  PCRE2_ERROR_CALLOUT                        = (-37)  # Never used by PCRE2 itself
+  PCRE2_ERROR_DFA_BADRESTART                 = (-38)
+  PCRE2_ERROR_DFA_RECURSE                    = (-39)
+  PCRE2_ERROR_DFA_UCOND                      = (-40)
+  PCRE2_ERROR_DFA_UFUNC                      = (-41)
+  PCRE2_ERROR_DFA_UITEM                      = (-42)
+  PCRE2_ERROR_DFA_WSSIZE                     = (-43)
+  PCRE2_ERROR_INTERNAL                       = (-44)
+  PCRE2_ERROR_JIT_BADOPTION                  = (-45)
+  PCRE2_ERROR_JIT_STACKLIMIT                 = (-46)
+  PCRE2_ERROR_MATCHLIMIT                     = (-47)
+  PCRE2_ERROR_NOMEMORY                       = (-48)
+  PCRE2_ERROR_NOSUBSTRING                    = (-49)
+  PCRE2_ERROR_NOUNIQUESUBSTRING              = (-50)
+  PCRE2_ERROR_NULL                           = (-51)
+  PCRE2_ERROR_RECURSELOOP                    = (-52)
+  PCRE2_ERROR_DEPTHLIMIT                     = (-53)
+  PCRE2_ERROR_RECURSIONLIMIT                 = (-53)  # Obsolete synonym
+  PCRE2_ERROR_UNAVAILABLE                    = (-54)
+  PCRE2_ERROR_UNSET                          = (-55)
+  PCRE2_ERROR_BADOFFSETLIMIT                 = (-56)
+  PCRE2_ERROR_BADREPESCAPE                   = (-57)
+  PCRE2_ERROR_REPMISSINGBRACE                = (-58)
+  PCRE2_ERROR_BADSUBSTITUTION                = (-59)
+  PCRE2_ERROR_BADSUBSPATTERN                 = (-60)
+  PCRE2_ERROR_TOOMANYREPLACE                 = (-61)
+  PCRE2_ERROR_BADSERIALIZEDDATA              = (-62)
+  PCRE2_ERROR_HEAPLIMIT                      = (-63)
+  PCRE2_ERROR_CONVERT_SYNTAX                 = (-64)
+  PCRE2_ERROR_INTERNAL_DUPMATCH              = (-65)
+
+  # Request types for pcre2_pattern_info()
+
+  PCRE2_INFO_ALLOPTIONS                      = 0
+  PCRE2_INFO_ARGOPTIONS                      = 1
+  PCRE2_INFO_BACKREFMAX                      = 2
+  PCRE2_INFO_BSR                             = 3
+  PCRE2_INFO_CAPTURECOUNT                    = 4
+  PCRE2_INFO_FIRSTCODEUNIT                   = 5
+  PCRE2_INFO_FIRSTCODETYPE                   = 6
+  PCRE2_INFO_FIRSTBITMAP                     = 7
+  PCRE2_INFO_HASCRORLF                       = 8
+  PCRE2_INFO_JCHANGED                        = 9
+  PCRE2_INFO_JITSIZE                         = 10
+  PCRE2_INFO_LASTCODEUNIT                    = 11
+  PCRE2_INFO_LASTCODETYPE                    = 12
+  PCRE2_INFO_MATCHEMPTY                      = 13
+  PCRE2_INFO_MATCHLIMIT                      = 14
+  PCRE2_INFO_MAXLOOKBEHIND                   = 15
+  PCRE2_INFO_MINLENGTH                       = 16
+  PCRE2_INFO_NAMECOUNT                       = 17
+  PCRE2_INFO_NAMEENTRYSIZE                   = 18
+  PCRE2_INFO_NAMETABLE                       = 19
+  PCRE2_INFO_NEWLINE                         = 20
+  PCRE2_INFO_DEPTHLIMIT                      = 21
+  PCRE2_INFO_RECURSIONLIMIT                  = 21  # Obsolete synonym
+  PCRE2_INFO_SIZE                            = 22
+  PCRE2_INFO_HASBACKSLASHC                   = 23
+  PCRE2_INFO_FRAMESIZE                       = 24
+  PCRE2_INFO_HEAPLIMIT                       = 25
+  PCRE2_INFO_EXTRAOPTIONS                    = 26
+
+  # Request types for pcre2_config().
+
+  PCRE2_CONFIG_BSR                           = 0
+  PCRE2_CONFIG_JIT                           = 1
+  PCRE2_CONFIG_JITTARGET                     = 2
+  PCRE2_CONFIG_LINKSIZE                      = 3
+  PCRE2_CONFIG_MATCHLIMIT                    = 4
+  PCRE2_CONFIG_NEWLINE                       = 5
+  PCRE2_CONFIG_PARENSLIMIT                   = 6
+  PCRE2_CONFIG_DEPTHLIMIT                    = 7
+  PCRE2_CONFIG_RECURSIONLIMIT                = 7  # Obsolete synonym
+  PCRE2_CONFIG_STACKRECURSE                  = 8  # Obsolete
+  PCRE2_CONFIG_UNICODE                       = 9
+  PCRE2_CONFIG_UNICODE_VERSION               = 10
+  PCRE2_CONFIG_VERSION                       = 11
+  PCRE2_CONFIG_HEAPLIMIT                     = 12
+  PCRE2_CONFIG_NEVER_BACKSLASH_C             = 13
+  PCRE2_CONFIG_COMPILED_WIDTHS               = 14
+end

data/lib/pcre2/matchdata.rb

@@ -0,0 +1,41 @@
+class PCRE2::MatchData
+  attr :regexp, :pairs, :string
+
+  def initialize(regexp, string, pairs)
+    @regexp = regexp
+    @string = string
+    @pairs = pairs
+  end
+
+  def [](key)
+    if !key.is_a?(Numeric)
+      key = regexp.named_captures[key.to_s].first
+    end
+
+    if pair = pairs[key]
+      string_from_pair(*pair)
+    end
+  end
+
+  def offset(n)
+    pairs[n]
+  end
+
+  def capture_pairs
+    pairs[1..-1]
+  end
+
+  def to_a
+    pairs.map { |pair| string_from_pair(*pair) }
+  end
+
+  def captures
+    to_a[1..-1]
+  end
+
+  private
+
+  def string_from_pair(start, ending)
+    string.slice(start, ending-start)
+  end
+end

data/lib/pcre2/regexp.rb

@@ -0,0 +1,35 @@
+class PCRE2::Regexp
+  attr :source, :pattern_ptr
+
+  def initialize(pattern, *options)
+    @source = pattern
+    @pattern_ptr = PCRE2::Lib.compile_pattern(pattern, options)
+  end
+
+  # Compiles the Regexp into a JIT optimised version. Returns whether it was successful
+  def jit!
+    options = PCRE2::PCRE2_JIT_COMPLETE | PCRE2::PCRE2_JIT_PARTIAL_SOFT | PCRE2::PCRE2_JIT_PARTIAL_HARD
+
+    PCRE2::Lib.pcre2_jit_compile_8(pattern_ptr, options) == 0
+  end
+
+  def match(str, pos = nil)
+    result_count, match_data_ptr = PCRE2::Lib.match(@pattern_ptr, str, position: pos)
+
+    if result_count == 0
+      nil
+    else
+      pairs = PCRE2::Lib.get_ovector_pairs(match_data_ptr, result_count)
+
+      PCRE2::MatchData.new(self, str, pairs)
+    end
+  end
+
+  def named_captures
+    @named_captures ||= PCRE2::Lib.named_captures(pattern_ptr)
+  end
+
+  def names
+    named_captures.keys
+  end
+end

data/lib/pcre2/version.rb

@@ -0,0 +1,3 @@
+module PCRE2
+  VERSION = "0.1.0"
+end

data/pcre2.gemspec

@@ -0,0 +1,29 @@
+require_relative 'lib/pcre2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pcre2"
+  spec.version       = PCRE2::VERSION
+  spec.authors       = ["David Verhasselt"]
+  spec.email         = ["david@crowdway.com"]
+
+  spec.summary       = %q{Use the PCRE2 library inside your Ruby projects}
+  spec.description   = %q{Wraps the PCRE2 library using FFI so it and the advanced functionality it provides can be used in Ruby projects}
+  spec.homepage      = "https://github.com/dv/pcre2"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ffi"
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: pcre2
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Verhasselt
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-08-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Wraps the PCRE2 library using FFI so it and the advanced functionality
+  it provides can be used in Ruby projects
+email:
+- david@crowdway.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/tests.yml"
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark.rake
+- bin/console
+- bin/setup
+- lib/pcre2.rb
+- lib/pcre2/error.rb
+- lib/pcre2/lib.rb
+- lib/pcre2/lib/constants.rb
+- lib/pcre2/matchdata.rb
+- lib/pcre2/regexp.rb
+- lib/pcre2/version.rb
+- pcre2.gemspec
+homepage: https://github.com/dv/pcre2
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/dv/pcre2
+  source_code_uri: https://github.com/dv/pcre2
+  changelog_uri: https://github.com/dv/pcre2
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Use the PCRE2 library inside your Ruby projects
+test_files: []