opal-onigmo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 42b7f0d79bf4c8caa956996c2c3e719e830e4b7d5cdc36a37f259bad0817d4be
+  data.tar.gz: 5d696a5c11e17b61aca28cefc0c275295dd9c5ffafd4e59cb173578e515d30db
+SHA512:
+  metadata.gz: 6183bcc0febb8a96b3380a91ba1a1073f77ed304acc19619adf2ba570108fc68085cd3517e32abd4339c647564d8ce8cc203639fb3ff8ee80a6411ccf5d53ad3
+  data.tar.gz: e45bb5cbccbb07eb87ee9de044769aada834639012fe0fdfc8cfa0115308aaa6ad5c8548c9b0698eef34c963cd6da6be0c6e389b52381d9c1a718fc0c7cb339c

data/.gitignore

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

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "Onigmo"]
+	path = Onigmo
+	url = https://github.com/interscript/onigmo

data/.rspec

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

data/.rspec-opal

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+-I ./opal

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.1
+before_install: gem install bundler -v 2.1.4

data/Gemfile

@@ -0,0 +1,13 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in opal-onigmo.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "rspec", "~> 3.0"
+
+gem "pry"
+
+gem "opal", "~> 1.0"
+gem "opal-webassembly"
+gem "opal-rspec"

data/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: .
+  specs:
+    opal-onigmo (0.1.0)
+      opal-webassembly
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.1)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    method_source (1.0.0)
+    opal (1.0.3)
+      ast (>= 2.3.0)
+      parser (~> 2.6)
+    opal-rspec (0.8.0.alpha2)
+      opal (>= 0.11, < 1.1)
+      opal-sprockets
+      rake (~> 12.0)
+    opal-sprockets (0.4.9.1.0.3.7)
+      opal (~> 1.0.0)
+      sprockets (~> 3.7)
+      tilt (>= 1.4)
+    opal-webassembly (0.1.0)
+      opal
+    parser (2.7.1.5)
+      ast (~> 2.4.1)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rack (2.2.3)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.3)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    sprockets (3.7.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    tilt (2.0.10)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  opal (~> 1.0)
+  opal-onigmo!
+  opal-rspec
+  opal-webassembly
+  pry
+  rake (~> 12.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.adoc

@@ -0,0 +1,31 @@
+= Licenses & Copyright
+
+This license file adheres to the formatting guidelines of
+https://github.com/nevir/readable-licenses[readable-licenses].
+
+
+== Ribose BSD 2-Clause License
+
+Copyright (c) 2019-, https://www.ribose.com[Ribose Inc].
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1.  Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 TODO: Write your name
+
+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.adoc

@@ -0,0 +1,57 @@
+= Opal::Onigmo
+
+Execute regular expressions in Opal with a native Ruby regexp engine - Onigmo - compiled using clang to WebAssembly.
+
+== Installation
+
+Add this line to your application's Gemfile:
+
+[source,ruby]
+----
+gem 'opal-onigmo'
+----
+
+And then execute:
+
+[source,sh]
+----
+$ bundle install
+----
+
+Or install it yourself as:
+
+[source,sh]
+----
+$ gem install opal-onigmo
+----
+
+
+== Usage
+
+[source,ruby]
+----
+# In your Opal code
+
+require 'onigmo'
+r = Onigmo::Regexp.new("^ab+")
+"abbbcd".gsub(r, "dd") # => "ddcd"
+r.match("test") # => false
+
+require 'onigmo/core_ext'
+"test".match(r) # => false
+----
+
+
+== 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 https://rubygems.org[rubygems.org].
+
+== Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hmdne/opal-onigmo.
+
+== License
+
+The gem is available as open source under the terms of the BSD 2-clause license.

data/Rakefile

@@ -0,0 +1,35 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "opal/rspec/rake_task"
+require 'erb'
+
+RSpec::Core::RakeTask.new(:spec)
+
+Opal::RSpec::RakeTask.new("spec-opal") do |server, task|
+  require 'opal/onigmo'
+end
+
+task :generate => ['opal/onigmo/constants.rb', 'opal/onigmo/onigmo.wasm'] do
+end
+
+def render_template(template, output, vars)
+  tmpl = File.read(template)
+  erb = ERB.new(tmpl, 0, "<>")
+  File.open(output, "w") do |f|
+    f.puts erb.result_with_hash(vars)
+  end
+end
+
+file 'opal/onigmo/constants.rb' => ['opal/onigmo/constants.rb.erb', 'Onigmo/onigmo.h'] do |task|
+  render_template(
+    File.expand_path(task.prerequisites.first, __dir__),
+    task.name,
+    {onigmo_h: File.read('Onigmo/onigmo.h')}
+  )
+end
+
+file 'opal/onigmo/onigmo.wasm' => ['Onigmo/build-wasm.sh'] do |task|
+  sh "cd Onigmo; sh ./build-wasm.sh; mv onigmo.wasm #{task.name}"
+end
+
+task :default => [:spec, "spec-opal"]

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "opal/onigmo"
+
+# 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/opal/onigmo.rb

@@ -0,0 +1,5 @@
+require 'opal'
+require 'opal/webassembly'
+require 'opal/webassembly/processor'
+
+Opal.append_path File.expand_path('../../../opal', __FILE__)

data/lib/opal/onigmo/version.rb

@@ -0,0 +1,5 @@
+module Opal
+  module Onigmo
+    VERSION = "0.1.0"
+  end
+end

data/opal-onigmo.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/opal/onigmo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "opal-onigmo"
+  spec.version       = Opal::Onigmo::VERSION
+  spec.authors       = ["Ribose Inc."]
+  spec.email         = ["open.source@ribose.com"]
+
+  spec.summary       = %q{Execute regexps with Opal using Onigmo}
+  spec.description   = %q{Execute regexps in Opal with a native Ruby regexp engine - Onigmo - compiled using clang to WebAssembly}
+  spec.homepage      = "https://github.com/interscript/opal-onigmo"
+  spec.license       = "BSD-2-Clause"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/interscript/opal-onigmo"
+  spec.metadata["changelog_uri"] = "https://github.com/interscript/opal-onigmo/commits/master"
+
+  # 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|Onigmo)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "opal-webassembly"
+end

data/opal/onigmo.rb

@@ -0,0 +1,7 @@
+require 'onigmo/constants'
+require 'onigmo/onigmo-wasm'
+require 'onigmo/ffi'
+require 'onigmo/regexp'
+
+module Onigmo
+end

data/opal/onigmo/constants.rb

@@ -0,0 +1,237 @@
+# Copy constants from Onigmo/onigmo.h
+
+module Onigmo
+  module Constants
+    
+    ONIGMO_VERSION_MAJOR = 6
+    ONIGMO_VERSION_MINOR = 2
+    ONIGMO_VERSION_TEENY = 0
+    OnigCodePointMaskWidth = 3
+    OnigCodePointMask = ((1<<OnigCodePointMaskWidth)-1)
+    OnigSpecialIndexShift = 3
+    OnigSpecialIndexWidth = 10
+    ONIGENC_CASE_UPCASE = (1<<13) 
+    ONIGENC_CASE_DOWNCASE = (1<<14) 
+    ONIGENC_CASE_TITLECASE = (1<<15) 
+    ONIGENC_CASE_SPECIAL_OFFSET = 3       
+    ONIGENC_CASE_UP_SPECIAL = (1<<16) 
+    ONIGENC_CASE_DOWN_SPECIAL = (1<<17) 
+    ONIGENC_CASE_MODIFIED = (1<<18) 
+    ONIGENC_CASE_FOLD = (1<<19) 
+    ONIGENC_CASE_FOLD_TURKISH_AZERI = (1<<20) 
+    ONIGENC_CASE_FOLD_LITHUANIAN = (1<<21) 
+    ONIGENC_CASE_ASCII_ONLY = (1<<22) 
+    ONIGENC_CASE_IS_TITLECASE = (1<<23) 
+    INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR = (1<<30) 
+    ONIGENC_CASE_FOLD_MIN = INTERNAL_ONIGENC_CASE_FOLD_MULTI_CHAR
+    ONIGENC_MAX_COMP_CASE_FOLD_CODE_LEN = 3
+    ONIGENC_GET_CASE_FOLD_CODES_MAX_NUM = 13
+    ONIGENC_CODE_TO_MBC_MAXLEN = 7
+    ONIGENC_MBC_CASE_FOLD_MAXLEN = 18
+    ONIGENC_CTYPE_NEWLINE = 0
+    ONIGENC_CTYPE_ALPHA = 1
+    ONIGENC_CTYPE_BLANK = 2
+    ONIGENC_CTYPE_CNTRL = 3
+    ONIGENC_CTYPE_DIGIT = 4
+    ONIGENC_CTYPE_GRAPH = 5
+    ONIGENC_CTYPE_LOWER = 6
+    ONIGENC_CTYPE_PRINT = 7
+    ONIGENC_CTYPE_PUNCT = 8
+    ONIGENC_CTYPE_SPACE = 9
+    ONIGENC_CTYPE_UPPER = 10
+    ONIGENC_CTYPE_XDIGIT = 11
+    ONIGENC_CTYPE_WORD = 12
+    ONIGENC_CTYPE_ALNUM = 13  
+    ONIGENC_CTYPE_ASCII = 14
+    ONIGENC_MAX_STD_CTYPE = ONIGENC_CTYPE_ASCII
+    ONIGENC_FLAG_NONE = 0
+    ONIGENC_FLAG_UNICODE = 1
+    ONIG_NREGION = 10
+    ONIG_MAX_CAPTURE_GROUP_NUM = 32767
+    ONIG_MAX_BACKREF_NUM = 1000
+    ONIG_MAX_REPEAT_NUM = 100000
+    ONIG_MAX_MULTI_BYTE_RANGES_NUM = 10000
+    ONIG_MAX_ERROR_MESSAGE_LEN = 90
+    ONIG_OPTION_NONE = 0
+    ONIG_OPTION_IGNORECASE = 1
+    ONIG_OPTION_EXTEND = (ONIG_OPTION_IGNORECASE         << 1)
+    ONIG_OPTION_MULTILINE = (ONIG_OPTION_EXTEND             << 1)
+    ONIG_OPTION_DOTALL = ONIG_OPTION_MULTILINE
+    ONIG_OPTION_SINGLELINE = (ONIG_OPTION_MULTILINE          << 1)
+    ONIG_OPTION_FIND_LONGEST = (ONIG_OPTION_SINGLELINE         << 1)
+    ONIG_OPTION_FIND_NOT_EMPTY = (ONIG_OPTION_FIND_LONGEST       << 1)
+    ONIG_OPTION_NEGATE_SINGLELINE = (ONIG_OPTION_FIND_NOT_EMPTY     << 1)
+    ONIG_OPTION_DONT_CAPTURE_GROUP = (ONIG_OPTION_NEGATE_SINGLELINE  << 1)
+    ONIG_OPTION_CAPTURE_GROUP = (ONIG_OPTION_DONT_CAPTURE_GROUP << 1)
+    ONIG_OPTION_NOTBOL = (ONIG_OPTION_CAPTURE_GROUP << 1)
+    ONIG_OPTION_NOTEOL = (ONIG_OPTION_NOTBOL << 1)
+    ONIG_OPTION_NOTBOS = (ONIG_OPTION_NOTEOL << 1)
+    ONIG_OPTION_NOTEOS = (ONIG_OPTION_NOTBOS << 1)
+    ONIG_OPTION_ASCII_RANGE = (ONIG_OPTION_NOTEOS << 1)
+    ONIG_OPTION_POSIX_BRACKET_ALL_RANGE = (ONIG_OPTION_ASCII_RANGE << 1)
+    ONIG_OPTION_WORD_BOUND_ALL_RANGE = (ONIG_OPTION_POSIX_BRACKET_ALL_RANGE << 1)
+    ONIG_OPTION_NEWLINE_CRLF = (ONIG_OPTION_WORD_BOUND_ALL_RANGE << 1)
+    ONIG_OPTION_MAXBIT = ONIG_OPTION_NEWLINE_CRLF  
+    ONIG_SYN_OP_VARIABLE_META_CHARACTERS = (1<<0)
+    ONIG_SYN_OP_DOT_ANYCHAR = (1<<1)   
+    ONIG_SYN_OP_ASTERISK_ZERO_INF = (1<<2)   
+    ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF = (1<<3)
+    ONIG_SYN_OP_PLUS_ONE_INF = (1<<4)   
+    ONIG_SYN_OP_ESC_PLUS_ONE_INF = (1<<5)
+    ONIG_SYN_OP_QMARK_ZERO_ONE = (1<<6)   
+    ONIG_SYN_OP_ESC_QMARK_ZERO_ONE = (1<<7)
+    ONIG_SYN_OP_BRACE_INTERVAL = (1<<8)   
+    ONIG_SYN_OP_ESC_BRACE_INTERVAL = (1<<9)   
+    ONIG_SYN_OP_VBAR_ALT = (1<<10)   
+    ONIG_SYN_OP_ESC_VBAR_ALT = (1<<11)  
+    ONIG_SYN_OP_LPAREN_SUBEXP = (1<<12)  
+    ONIG_SYN_OP_ESC_LPAREN_SUBEXP = (1<<13)  
+    ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR = (1<<14)  
+    ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR = (1<<15)  
+    ONIG_SYN_OP_DECIMAL_BACKREF = (1<<16)  
+    ONIG_SYN_OP_BRACKET_CC = (1<<17)  
+    ONIG_SYN_OP_ESC_W_WORD = (1<<18)  
+    ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END = (1<<19)  
+    ONIG_SYN_OP_ESC_B_WORD_BOUND = (1<<20)  
+    ONIG_SYN_OP_ESC_S_WHITE_SPACE = (1<<21)  
+    ONIG_SYN_OP_ESC_D_DIGIT = (1<<22)  
+    ONIG_SYN_OP_LINE_ANCHOR = (1<<23)  
+    ONIG_SYN_OP_POSIX_BRACKET = (1<<24)  
+    ONIG_SYN_OP_QMARK_NON_GREEDY = (1<<25)  
+    ONIG_SYN_OP_ESC_CONTROL_CHARS = (1<<26)  
+    ONIG_SYN_OP_ESC_C_CONTROL = (1<<27)  
+    ONIG_SYN_OP_ESC_OCTAL3 = (1<<28)  
+    ONIG_SYN_OP_ESC_X_HEX2 = (1<<29)  
+    ONIG_SYN_OP_ESC_X_BRACE_HEX8 = (1<<30)  
+    ONIG_SYN_OP_ESC_O_BRACE_OCTAL = (1<<31)  
+    ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE = (1<<0)  
+    ONIG_SYN_OP2_QMARK_GROUP_EFFECT = (1<<1)  
+    ONIG_SYN_OP2_OPTION_PERL = (1<<2)  
+    ONIG_SYN_OP2_OPTION_RUBY = (1<<3)  
+    ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT = (1<<4)  
+    ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL = (1<<5)  
+    ONIG_SYN_OP2_CCLASS_SET_OP = (1<<6)  
+    ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP = (1<<7)  
+    ONIG_SYN_OP2_ESC_K_NAMED_BACKREF = (1<<8)  
+    ONIG_SYN_OP2_ESC_G_SUBEXP_CALL = (1<<9)  
+    ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY = (1<<10) 
+    ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL = (1<<11) 
+    ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META = (1<<12) 
+    ONIG_SYN_OP2_ESC_V_VTAB = (1<<13) 
+    ONIG_SYN_OP2_ESC_U_HEX4 = (1<<14) 
+    ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR = (1<<15) 
+    ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY = (1<<16) 
+    ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT = (1<<17) 
+    ONIG_SYN_OP2_ESC_H_XDIGIT = (1<<19) 
+    ONIG_SYN_OP2_INEFFECTIVE_ESCAPE = (1<<20) 
+    ONIG_SYN_OP2_ESC_CAPITAL_R_LINEBREAK = (1<<21) 
+    ONIG_SYN_OP2_ESC_CAPITAL_X_EXTENDED_GRAPHEME_CLUSTER = (1<<22) 
+    ONIG_SYN_OP2_ESC_V_VERTICAL_WHITESPACE = (1<<23) 
+    ONIG_SYN_OP2_ESC_H_HORIZONTAL_WHITESPACE = (1<<24) 
+    ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP = (1<<25) 
+    ONIG_SYN_OP2_ESC_G_BRACE_BACKREF = (1<<26) 
+    ONIG_SYN_OP2_QMARK_SUBEXP_CALL = (1<<27) 
+    ONIG_SYN_OP2_QMARK_VBAR_BRANCH_RESET = (1<<28) 
+    ONIG_SYN_OP2_QMARK_LPAREN_CONDITION = (1<<29) 
+    ONIG_SYN_OP2_QMARK_CAPITAL_P_NAMED_GROUP = (1<<30) 
+    ONIG_SYN_OP2_QMARK_TILDE_ABSENT = (1<<31) 
+    ONIG_SYN_CONTEXT_INDEP_ANCHORS = (1<<31) 
+    ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS = (1<<0)  
+    ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS = (1<<1)  
+    ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP = (1<<2)  
+    ONIG_SYN_ALLOW_INVALID_INTERVAL = (1<<3)  
+    ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV = (1<<4)  
+    ONIG_SYN_STRICT_CHECK_BACKREF = (1<<5)  
+    ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND = (1<<6)  
+    ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP = (1<<7)  
+    ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME = (1<<8)  
+    ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY = (1<<9)  
+    ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME_CALL = (1<<10)  
+    ONIG_SYN_USE_LEFT_MOST_NAMED_GROUP = (1<<11) 
+    ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC = (1<<20) 
+    ONIG_SYN_BACKSLASH_ESCAPE_IN_CC = (1<<21) 
+    ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC = (1<<22)
+    ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC = (1<<23) 
+    ONIG_SYN_WARN_CC_OP_NOT_ESCAPED = (1<<24) 
+    ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT = (1<<25) 
+    ONIG_SYN_WARN_CC_DUP = (1<<26) 
+    ONIG_META_CHAR_ESCAPE = 0
+    ONIG_META_CHAR_ANYCHAR = 1
+    ONIG_META_CHAR_ANYTIME = 2
+    ONIG_META_CHAR_ZERO_OR_ONE_TIME = 3
+    ONIG_META_CHAR_ONE_OR_MORE_TIME = 4
+    ONIG_META_CHAR_ANYCHAR_ANYTIME = 5
+    ONIG_INEFFECTIVE_META_CHAR = 0
+    ONIG_NORMAL = 0
+    ONIG_MISMATCH = -1
+    ONIG_NO_SUPPORT_CONFIG = -2
+    ONIGERR_MEMORY = -5
+    ONIGERR_TYPE_BUG = -6
+    ONIGERR_PARSER_BUG = -11
+    ONIGERR_STACK_BUG = -12
+    ONIGERR_UNDEFINED_BYTECODE = -13
+    ONIGERR_UNEXPECTED_BYTECODE = -14
+    ONIGERR_MATCH_STACK_LIMIT_OVER = -15
+    ONIGERR_PARSE_DEPTH_LIMIT_OVER = -16
+    ONIGERR_DEFAULT_ENCODING_IS_NOT_SET = -21
+    ONIGERR_SPECIFIED_ENCODING_CANT_CONVERT_TO_WIDE_CHAR = -22
+    ONIGERR_INVALID_ARGUMENT = -30
+    ONIGERR_END_PATTERN_AT_LEFT_BRACE = -100
+    ONIGERR_END_PATTERN_AT_LEFT_BRACKET = -101
+    ONIGERR_EMPTY_CHAR_CLASS = -102
+    ONIGERR_PREMATURE_END_OF_CHAR_CLASS = -103
+    ONIGERR_END_PATTERN_AT_ESCAPE = -104
+    ONIGERR_END_PATTERN_AT_META = -105
+    ONIGERR_END_PATTERN_AT_CONTROL = -106
+    ONIGERR_META_CODE_SYNTAX = -108
+    ONIGERR_CONTROL_CODE_SYNTAX = -109
+    ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE = -110
+    ONIGERR_CHAR_CLASS_VALUE_AT_START_OF_RANGE = -111
+    ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS = -112
+    ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED = -113
+    ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID = -114
+    ONIGERR_NESTED_REPEAT_OPERATOR = -115
+    ONIGERR_UNMATCHED_CLOSE_PARENTHESIS = -116
+    ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS = -117
+    ONIGERR_END_PATTERN_IN_GROUP = -118
+    ONIGERR_UNDEFINED_GROUP_OPTION = -119
+    ONIGERR_INVALID_POSIX_BRACKET_TYPE = -121
+    ONIGERR_INVALID_LOOK_BEHIND_PATTERN = -122
+    ONIGERR_INVALID_REPEAT_RANGE_PATTERN = -123
+    ONIGERR_INVALID_CONDITION_PATTERN = -124
+    ONIGERR_TOO_BIG_NUMBER = -200
+    ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE = -201
+    ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE = -202
+    ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS = -203
+    ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE = -204
+    ONIGERR_TOO_MANY_MULTI_BYTE_RANGES = -205
+    ONIGERR_TOO_SHORT_MULTI_BYTE_STRING = -206
+    ONIGERR_TOO_BIG_BACKREF_NUMBER = -207
+    ONIGERR_INVALID_BACKREF = -208
+    ONIGERR_NUMBERED_BACKREF_OR_CALL_NOT_ALLOWED = -209
+    ONIGERR_TOO_MANY_CAPTURE_GROUPS = -210
+    ONIGERR_TOO_SHORT_DIGITS = -211
+    ONIGERR_TOO_LONG_WIDE_CHAR_VALUE = -212
+    ONIGERR_EMPTY_GROUP_NAME = -214
+    ONIGERR_INVALID_GROUP_NAME = -215
+    ONIGERR_INVALID_CHAR_IN_GROUP_NAME = -216
+    ONIGERR_UNDEFINED_NAME_REFERENCE = -217
+    ONIGERR_UNDEFINED_GROUP_REFERENCE = -218
+    ONIGERR_MULTIPLEX_DEFINED_NAME = -219
+    ONIGERR_MULTIPLEX_DEFINITION_NAME_CALL = -220
+    ONIGERR_NEVER_ENDING_RECURSION = -221
+    ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY = -222
+    ONIGERR_INVALID_CHAR_PROPERTY_NAME = -223
+    ONIGERR_INVALID_CODE_POINT_VALUE = -400
+    ONIGERR_INVALID_WIDE_CHAR_VALUE = -400
+    ONIGERR_TOO_BIG_WIDE_CHAR_VALUE = -401
+    ONIGERR_NOT_SUPPORTED_ENCODING_COMBINATION = -402
+    ONIGERR_INVALID_COMBINATION_OF_OPTIONS = -403
+    ONIG_MAX_CAPTURE_HISTORY_GROUP = 31
+    ONIG_TRAVERSE_CALLBACK_AT_FIRST = 1
+    ONIG_TRAVERSE_CALLBACK_AT_LAST = 2
+    ONIG_REGION_NOTPOS = -1
+    ONIG_CHAR_TABLE_SIZE = 256
+    ONIG_OPTION_DEFAULT = ONIG_OPTION_NONE
+  end
+end

data/opal/onigmo/constants.rb.erb

@@ -0,0 +1,16 @@
+# Copy constants from Onigmo/onigmo.h
+
+module Onigmo
+  module Constants
+    <%
+      onigmo_h
+        .scan(/^#define\s+(\w+)\s+(\(?\s*[()<>0-9\w\t -]+)/)
+        .reject { |k,v| %w[
+          ONIG_NULL_WARN ONIG_SYNTAX_ ONIG_ENCODING_ ONIG_INFINITE_DISTANCE
+          ONIGENC_CASE_FOLD_DEFAULT ONIG_OPTION_DEFAULT].any? { |i| k.start_with? i } }
+        .each do |var, val|
+    %>
+    <%= var %> = <%= val.gsub(/U(<<|$)/,'\1') %><% end %>
+    ONIG_OPTION_DEFAULT = ONIG_OPTION_NONE
+  end
+end

data/opal/onigmo/core_ext.rb

@@ -0,0 +1,21 @@
+require 'onigmo'
+
+class String
+  alias match_before_onigmo match
+  def match(re, pos = undefined, &block)
+    if Onigmo::Regexp === re
+      re.match(self, pos, &block)
+    else
+      match_before_onigmo(re, pos, &block)
+    end
+  end
+
+  alias match_before_onigmo? match?
+  def match?(re, pos = undefined, &block)
+    if Onigmo::Regexp === re
+      re.match?(self, pos, &block)
+    else
+      match_before_onigmo?(re, pos, &block)
+    end
+  end
+end

data/opal/onigmo/ffi.rb

@@ -0,0 +1,114 @@
+require 'ffi'
+require 'corelib/array/pack'
+require 'corelib/string/unpack'
+
+module Onigmo
+  module FFI
+    include Onigmo::Constants
+    extend ::FFI::Library
+
+    ffi_lib "onigmo/onigmo-wasm"
+
+    class Regexp < ::FFI::Struct
+      layout :p, :pointer,
+             :used, :uint,
+             :alloc, :uint,
+
+             :num_mem, :int,
+             :num_repeat, :int,
+             :num_null_check, :int,
+             :num_comb_exp_check, :int,
+             :num_call, :int,
+             :capture_history, :uint,
+             :bt_mem_start, :uint,
+             :bt_mem_end, :uint,
+             :stack_pop_level, :int,
+             :repeat_range_alloc, :int,
+
+             :options, :int,
+
+             :repeat_range, :pointer,
+
+             :encoding, :pointer,
+             :syntax, :pointer,
+             :name_table, :pointer,
+             :casefold, :int,
+
+             :optimize, :int,
+             :threshold_len, :int,
+             :anchor, :int,
+             :anchor_dmin, :long,
+             :anchor_dmax, :long,
+             :sub_anchor, :int,
+             :exact, :pointer,
+             :exact_end, :pointer,
+             :map, [:uchar, 256],
+
+             :reserved1, :pointer,
+             :reserved2, :pointer,
+             :dmin, :long,
+             :dmax, :long,
+
+             :chain, :pointer
+    end
+
+    class RegexpPtr < ::FFI::Struct
+      layout :value, Regexp.ptr
+
+      def value
+        self[:value]
+      end
+    end
+
+    class Region < ::FFI::Struct
+      layout :allocated, :int,
+             :num_regs, :int,
+             :beg, :pointer,
+             :end, :pointer
+    end
+
+    class CompileInfo < ::FFI::Struct
+      layout :num_of_elements, :int,
+             :pattern_enc, :pointer,
+             :target_enc, :pointer,
+             :syntax, :pointer,
+             :option, :uint,
+             :case_fold_flag, :uint
+
+      def self.default_compile_info
+        @default ||= Onigmo::FFI.context do
+          new.tap do |ci|
+            ci[:num_of_elements] = 5
+            ci[:pattern_enc] = Onigmo::FFI.library.exports[:OnigEncodingUTF_16LE]
+            ci[:target_enc] = Onigmo::FFI.library.exports[:OnigEncodingUTF_16LE]
+            ci[:syntax] = Onigmo::FFI.library.exports[:OnigSyntaxRuby]
+            ci[:option] = Onigmo::FFI::ONIG_OPTION_NONE # To be overwritten
+            ci[:case_fold_flag] = Onigmo::FFI.library.exports[:OnigDefaultCaseFoldFlag].value
+          end
+        end
+      end
+
+      def options
+        self[:option]
+      end
+
+      def options= value
+        self[:option] = value
+      end
+    end
+
+    class ErrorInfo < ::FFI::Struct
+      layout :enc, :pointer,
+             :par, :pointer,
+             :par_end, :pointer
+    end
+
+    attach_function :onig_new_deluxe, [RegexpPtr, :pointer, :pointer, CompileInfo, ErrorInfo], :int
+    attach_function :onig_region_new, [], Region
+    attach_function :onig_match, [Regexp, :pointer, :pointer, :pointer, Region, :uint], :int
+    attach_function :onig_search, [Regexp, :pointer, :pointer, :pointer, :pointer, Region, :uint], :int
+
+  end
+
+  Onigmo::FFI.library.memory.grow(128)
+end

data/opal/onigmo/regexp.rb

@@ -0,0 +1,118 @@
+module Onigmo
+  class Regexp
+    `Opal.defineProperty(self.$$prototype, '$$is_regexp', true)`
+    # Hacks in order to make it more alike JS regexp that is perfectly compatible.
+    # This should make String#sub and friends work without a hassle.
+    `Opal.defineProperty(self.$$prototype, 'global', true)`
+    `Opal.defineProperty(self.$$prototype, 'multiline', true)`
+
+    def match(str, offset=nil, &block)
+      block ||= proc{|i| i}
+      evaluate(str, offset) && block.(MatchData.new(self, js_matches(str)))
+    end
+
+    def match?(str, offset=nil)
+      !!evaluate(str, offset)
+    end
+
+    def =~ str
+      match(str) && $~.begin(0)
+    end
+
+    def inspect
+      "/#{pattern.inspect[1..-2]}/O#{options}"
+    end
+
+    def initialize pattern, options = ''
+      @lastIndex = 0
+      @pattern = pattern.encode("UTF-16LE")
+      @options = options
+
+      out = Onigmo::FFI.context do
+        @ffi_regexpptr = Onigmo::FFI::RegexpPtr.new
+        ffi_options = Onigmo::FFI::CompileInfo.default_compile_info
+        ffi_errorinfo = Onigmo::FFI::ErrorInfo.new
+
+        ffi_pattern = ::FFI::Pointer.from_string(@pattern)
+        ffi_pattern_end = ffi_pattern + (@pattern.length * 2)
+
+        ffi_options.options = Onigmo::FFI::ONIG_OPTION_NONE
+        ffi_options.options |= Onigmo::FFI::ONIG_OPTION_IGNORECASE if options.include? "i"
+        ffi_options.options |= Onigmo::FFI::ONIG_OPTION_MULTILINE if options.include? "m"
+        ffi_options.options |= Onigmo::FFI::ONIG_OPTION_EXTEND if options.include? "x"
+
+        Onigmo::FFI.onig_new_deluxe(@ffi_regexpptr, ffi_pattern, ffi_pattern_end,
+                                    ffi_options, ffi_errorinfo)
+      end
+
+      @ffi_regexp = @ffi_regexpptr.value
+
+      @exec = proc { |re| js_exec(re) }
+
+      unless out == Onigmo::FFI::ONIG_NORMAL
+        raise RuntimeError, "Onigmo has failed with an error code '#{out}'"
+      end
+    end
+
+    def ffi_evaluate string, offset = 0
+      offset ||= 0
+
+      @ffi_region = Onigmo::FFI.onig_region_new
+
+      string = string.encode("UTF-16LE")
+
+      Onigmo::FFI.context do
+        ffi_string = ::FFI::Pointer.from_string(string)
+        ffi_string_end = ffi_string + (string.length * 2)
+        ffi_string_offset = ffi_string + offset * 2
+
+        Onigmo::FFI.onig_search(@ffi_regexp, ffi_string, ffi_string_end, ffi_string_offset,
+                                ffi_string_end, @ffi_region, Onigmo::FFI::ONIG_OPTION_NONE)
+      end
+    end
+
+    def ffi_region
+      @ffi_region[:num_regs].times.map do |i|
+        [@ffi_region[:beg].get(:long, i*4),
+         @ffi_region[:end].get(:long, i*4) ]
+      end
+    end
+
+    def evaluate string, offset = 0
+      out = ffi_evaluate(string, offset)
+      if out < 0
+        nil
+      else
+        out / 2
+      end
+    end
+
+    def matches(str)
+      ffi_region.map { |b,e| str[b/2...e/2] }
+    end
+
+    def js_matches(str)
+      matches = matches(str)
+      region = ffi_region
+      out = {
+        input: str,
+        index: region[0][0]/2,
+        length: matches.length,
+        slice: proc { |i| matches[i..-1] }
+      }
+      out = out.to_n
+      matches.each_with_index { |m,i| `out[#{i}] = #{m}` }
+      @lastIndex = region[0][1]/2
+      out
+    end
+
+    def js_exec(str)
+      if evaluate(str, @lastIndex || 0)
+        js_matches(str)
+      else
+        @lastIndex = 0
+        nil.to_n
+      end
+    end
+  end
+end

data/spec-opal/regexp_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+RSpec.describe Onigmo::Regexp do
+  it "can create a Regexp" do
+    Onigmo::Regexp.new('(?<=test)test!', 'i')
+  end
+
+  it "can evaluate a Regexp" do
+    re = Onigmo::Regexp.new('ll. wor', 'i')
+    out = re.ffi_evaluate("Hello World!")
+    expect(out).to eq(4)
+    regs = re.ffi_region
+    expect(regs).to eq([[4, 18]])
+  end
+
+  it "can find Hangul characters" do
+    re = Onigmo::Regexp.new('\\p{Hangul}')
+    out = re.ffi_evaluate("Some characters that are not Hangul and one that 봉is.")
+    expect(out).to eq(98)
+  end
+
+  it "should support String#gsub" do
+    re = Onigmo::Regexp.new('aa')
+    expect('aababaaaabbaaaba'.gsub(re, 'ZZ')).to eq('ZZbabZZZZbbZZaba')
+  end
+
+  it "should support String#sub" do
+    re = Onigmo::Regexp.new('aa')
+    expect('aababaaaabbaaaba'.sub(re, 'ZZ')).to eq('ZZbabaaaabbaaaba')
+  end
+
+  it "should support String#=~" do
+    re = Onigmo::Regexp.new('aa')
+    expect('haha' =~ re).to eq(nil)
+    expect('haaha' =~ re).to eq(1)
+  end
+
+  it "should support String#match?" do
+    require 'onigmo/core_ext'
+    re = Onigmo::Regexp.new('aa')
+    expect('haha'.match? re).to eq(false)
+    expect('haaha'.match? re).to eq(true)
+  end
+
+  it "should support String#match" do
+    require 'onigmo/core_ext'
+    re = Onigmo::Regexp.new('aa')
+    expect('haha'.match re).to eq(nil)
+    expect('haaha'.match re).to be_a(MatchData)
+  end
+
+  it "should support $1, $2..." do
+    require 'onigmo/core_ext'
+    re = Onigmo::Regexp.new('(a).(a)')
+    expect(re.match "haha").to be_a(MatchData)
+    expect($1).to eq('a')
+    expect($2).to eq('a')
+  end
+end

data/spec-opal/spec_helper.rb

@@ -0,0 +1,17 @@
+require 'onigmo'
+
+RSpec.configure do |config|
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  config.full_backtrace = true
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: opal-onigmo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ribose Inc.
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal-webassembly
+  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: Execute regexps in Opal with a native Ruby regexp engine - Onigmo - compiled
+  using clang to WebAssembly
+email:
+- open.source@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".rspec"
+- ".rspec-opal"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.adoc
+- LICENSE.txt
+- README.adoc
+- Rakefile
+- bin/console
+- bin/setup
+- lib/opal/onigmo.rb
+- lib/opal/onigmo/version.rb
+- opal-onigmo.gemspec
+- opal/onigmo.rb
+- opal/onigmo/constants.rb
+- opal/onigmo/constants.rb.erb
+- opal/onigmo/core_ext.rb
+- opal/onigmo/ffi.rb
+- opal/onigmo/onigmo-wasm.wasm
+- opal/onigmo/regexp.rb
+- spec-opal/regexp_spec.rb
+- spec-opal/spec_helper.rb
+homepage: https://github.com/interscript/opal-onigmo
+licenses:
+- BSD-2-Clause
+metadata:
+  homepage_uri: https://github.com/interscript/opal-onigmo
+  source_code_uri: https://github.com/interscript/opal-onigmo
+  changelog_uri: https://github.com/interscript/opal-onigmo/commits/master
+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: Execute regexps with Opal using Onigmo
+test_files: []