tre_regex 0.1.1-aarch64-linux-musl

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 56a7adb81052170362caf915854006c7237dc141456708612daea9decf78f593
+  data.tar.gz: d1559837ea6be746008d6c8b3b2ab35b88ef5e9ebf5fdfb0b1c961fb8c55f25c
+SHA512:
+  metadata.gz: 706b072a76212a157b6da6c0a6878bbf925f66ea5ff746f3c0a3ff02d6b8e1d82100109828f1333797d753486caa5b4ab1df94737a4481639c33d319073a4473
+  data.tar.gz: 90d84a6fc157532bd4b07beb74c1dd2e97a455718c0f2e1b267370cd7d0a32650a4f4c4b499e02b22153c5f5a52a081e56ab663284f7cfe2a04856e9ffbb50f3

data/ext/tre_regex/extconf.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+require 'rbconfig'
+require 'open-uri'
+require 'net/http'
+require 'fileutils'
+
+is_windows = RbConfig::CONFIG['host_os'] =~ /mingw|mswin/
+is_darwin  = RbConfig::CONFIG['host_os'].include?('darwin')
+
+root_dir = File.expand_path(__dir__)
+root_dir = File.dirname(root_dir) until Dir.exist?(File.join(root_dir, 'lib')) || root_dir == '/'
+
+# Download Configuration
+github_repo = 'laurikari/tre'
+version = '5ac28057f648debda76f9bf4d39dfdfa85b0df18'
+tarball_url = "https://github.com/#{github_repo}/archive/#{version}.tar.gz"
+tarball_file = File.expand_path("./tre-#{version}.tar.gz", __dir__)
+tre_src_dir = File.expand_path("./tre-#{version}", __dir__)
+dest_lib_dir = File.join(root_dir, 'lib', 'tre_regex', 'bin')
+
+def download_file(url, limit = 10)
+  raise 'Too many redirects' if limit.zero?
+
+  uri = URI(url)
+  response = Net::HTTP.get_response(uri)
+
+  case response
+  when Net::HTTPSuccess
+    response.body
+  when Net::HTTPRedirection
+    location = response['location']
+    puts "Following redirect to #{location}..."
+    download_file(location, limit - 1)
+  else
+    raise "Download failed: #{response.code} #{response.message}"
+  end
+end
+
+# Automatically Download and Extract
+unless Dir.exist?(tre_src_dir)
+  puts '========== Downloading TRE from GitHub =========='
+  begin
+    content = download_file(tarball_url)
+    File.binwrite(tarball_file, content)
+  rescue StandardError => e
+    abort "Error: #{e.message}"
+  end
+
+  puts '========== Extracting TRE Source =========='
+  # Ensure we use -z for gzip
+  system("tar -xzf #{tarball_file} -C #{__dir__}") || abort('Extraction failed')
+end
+
+# Build TRE synchronously using Ruby
+host_flag = enable_config('cross-build') ? "--host=#{RbConfig::CONFIG['host']} " : ''
+RbConfig::CONFIG['SOEXT'] || RbConfig::CONFIG['DLEXT'] || (is_windows ? 'dll' : 'so')
+
+puts '========== Building TRE =========='
+Dir.chdir(tre_src_dir) do
+  system('./utils/autogen.sh') || raise('autogen.sh failed') unless File.exist?('configure')
+
+  system("./configure #{host_flag} --enable-shared --disable-static --disable-agrep") || raise('configure failed')
+  system('make') || raise('make failed')
+end
+
+puts '========== Staging Shared Library for FFI =========='
+FileUtils.mkdir_p(dest_lib_dir)
+
+# Find the REAL physical file, strictly ignoring symlinks and static (.a) archives
+src_lib = Dir.glob("#{tre_src_dir}/lib/.libs/*").find do |f|
+  (f.include?('.so') || f.include?('.dylib') || f.end_with?('.dll')) &&
+    !f.end_with?('.a') &&
+    !File.symlink?(f)
+end
+
+# Fallback just in case libtool behaved differently
+src_lib ||= Dir.glob("#{tre_src_dir}/lib/.libs/*").find do |f|
+  (f.include?('.so') || f.include?('.dylib') || f.end_with?('.dll')) && !f.end_with?('.a')
+end
+
+if src_lib
+  # Determine the clean target filename based on the OS
+  dest_name = if is_windows
+                'tre.dll'
+              elsif is_darwin
+                'libtre.dylib'
+              else
+                'libtre.so'
+              end
+
+  # Use File.realpath to guarantee we are copying raw bytes
+  FileUtils.cp(File.realpath(src_lib), File.join(dest_lib_dir, dest_name))
+end
+
+# Create a standard dummy ruby extension to satisfy rake-compiler completely
+create_makefile('tre_regex')

data/ext/tre_regex/tre_regex.c

@@ -0,0 +1 @@
+void Init_tre_regex(void) {}

data/lib/tre_regex/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TreRegex
+  VERSION = '0.1.1'
+end

data/lib/tre_regex.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'rbconfig'
+require_relative 'tre_regex/version'
+
+module TreRegex
+  class Error < StandardError; end
+
+  # The FFI Native Bridge
+  module Native
+    extend FFI::Library
+
+    # Determine OS and expected filename
+    host_os = RbConfig::CONFIG['host_os']
+    filename = case host_os
+               when /linux/ then 'libtre.so'
+               when /darwin/ then 'libtre.dylib'
+               when /mingw|mswin/ then 'tre.dll'
+               else raise "Unsupported OS: #{host_os}"
+               end
+
+    # Search for the compiled binary (checks both your extconf.rb path and standard path)
+    search_paths = [
+      File.expand_path("tre_regex/bin/#{filename}", __dir__),
+      File.expand_path(filename, __dir__)
+    ]
+
+    lib_path = search_paths.find { |p| File.exist?(p) }
+
+    unless lib_path
+      raise LoadError, "Could not find #{filename} in #{search_paths.first}. Did you compile the C extension?"
+    end
+
+    ffi_lib lib_path
+
+    # TRE Regex Configuration Flags
+    REG_EXTENDED = 1
+    REG_ICASE    = 2
+    REG_NEWLINE  = 4
+    REG_NOSUB    = 8
+
+    # Memory layout for TRE match offsets
+    class RegMatch < FFI::Struct
+      layout :rm_so, :int,
+             :rm_eo, :int
+    end
+
+    # Memory layout for TRE approximate matching parameters
+    class RegAParams < FFI::Struct
+      layout :cost_ins,   :int,
+             :cost_del,   :int,
+             :cost_subst, :int,
+             :max_cost,   :int,
+             :max_ins,    :int,
+             :max_del,    :int,
+             :max_subst,  :int,
+             :max_err,    :int
+    end
+
+    # Memory layout for TRE approximate match results
+    class RegAMatch < FFI::Struct
+      layout :nmatch,    :size_t,
+             :pmatch,    :pointer,
+             :cost,      :int,
+             :num_ins,   :int,
+             :num_del,   :int,
+             :num_subst, :int
+    end
+
+    attach_function :tre_regcomp, %i[pointer string int], :int
+    attach_function :tre_regfree, [:pointer], :void
+    attach_function :tre_regaexec, [:pointer, :string, :pointer, RegAParams.by_value, :int], :int
+    attach_function :tre_regaparams_default, [:pointer], :void
+  end
+
+  # User-Facing Ruby Class
+  class Regex
+    attr_reader :pattern
+
+    def initialize(pattern, ignore_case: false)
+      @pattern = pattern
+      # Allocate a safe 256-byte buffer in C memory for the regex_t struc
+      @preg = FFI::MemoryPointer.new(:char, 256)
+
+      flags = Native::REG_EXTENDED
+      flags |= Native::REG_ICASE if ignore_case
+
+      res = Native.tre_regcomp(@preg, pattern, flags)
+      raise TreRegex::Error, "Failed to compile regex pattern: #{pattern}" if res != 0
+
+      # Garbage Collection Hook: Tell Ruby to free the C memory when this object is destroyed
+      ObjectSpace.define_finalizer(self, self.class.finalize(@preg))
+    end
+
+    # The GC finalizer proc
+    def self.finalize(preg_ptr)
+      proc do
+        Native.tre_regfree(preg_ptr)
+        preg_ptr.free
+      end
+    end
+
+    def exec(text, options = {})
+      params = build_params(options)
+      pmatch = FFI::MemoryPointer.new(Native::RegMatch)
+      match_data = prepare_match_data(pmatch)
+
+      res = Native.tre_regaexec(@preg, text, match_data, params, 0)
+      res.zero? ? parse_result(text, match_data, pmatch) : nil
+    end
+
+    def test?(text, options = {})
+      !exec(text, options).nil?
+    end
+
+    def match_all(text, options = {})
+      return enum_for(:match_all, text, options) unless block_given?
+
+      offset = 0
+      while offset <= text.length
+        result = exec(text[offset..] || '', options)
+        break unless result
+
+        result[:index] += offset
+        result[:end_index] += offset
+        yield result
+
+        advance = (result[:end_index] - result[:index]).clamp(1, Float::INFINITY)
+        offset = result[:index] + advance
+      end
+    end
+
+    private
+
+    def build_params(opts)
+      params = Native::RegAParams.new
+      Native.tre_regaparams_default(params.to_ptr)
+      return params.tap { |p| p[:max_err] = 0 } if opts.empty?
+
+      apply_limits(params, opts)
+      apply_costs(params, opts)
+      params
+    end
+
+    def apply_limits(params, opts)
+      params[:max_err]   = opts[:max_errors] if opts.key?(:max_errors)
+      params[:max_ins]   = opts.fetch(:max_insertions, opts.key?(:max_errors) ? params[:max_ins] : 0)
+      params[:max_del]   = opts.fetch(:max_deletions, opts.key?(:max_errors) ? params[:max_del] : 0)
+      params[:max_subst] = opts.fetch(:max_substitutions, opts.key?(:max_errors) ? params[:max_subst] : 0)
+      params[:max_cost]  = opts[:max_cost] if opts.key?(:max_cost)
+
+      # Bound max_err if not explicitly set
+      return unless !opts.key?(:max_errors) && !opts.key?(:max_cost)
+
+      params[:max_err] =
+        params[:max_ins] + params[:max_del] + params[:max_subst]
+    end
+
+    def apply_costs(params, opts)
+      params[:cost_ins]   = opts[:weight_insertion] if opts.key?(:weight_insertion)
+      params[:cost_del]   = opts[:weight_deletion] if opts.key?(:weight_deletion)
+      params[:cost_subst] = opts[:weight_substitution] if opts.key?(:weight_substitution)
+    end
+
+    def prepare_match_data(pmatch)
+      Native::RegAMatch.new.tap do |m|
+        m[:nmatch] = 1
+        m[:pmatch] = pmatch
+      end
+    end
+
+    def parse_result(text, match_data, pmatch)
+      rm = Native::RegMatch.new(pmatch)
+      byte_match = text.byteslice(rm[:rm_so]...rm[:rm_eo])
+      char_start = text.byteslice(0...rm[:rm_so]).length
+
+      {
+        match: byte_match,
+        index: char_start,
+        end_index: char_start + byte_match.length,
+        cost: match_data[:cost],
+        errors: {
+          insertions: match_data[:num_ins],
+          deletions: match_data[:num_del],
+          substitutions: match_data[:num_subst]
+        }
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: tre_regex
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: aarch64-linux-musl
+authors:
+- Oleksii Vasyliev
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: TreRegex provides a high-performance Ruby interface to the TRE C library
+  using FFI. It brings robust approximate (fuzzy) regular expression matching to Ruby,
+  featuring multi-byte Unicode string safety, granular error limits, and precompiled
+  cross-platform native binaries
+email:
+- leopard.not.a@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/tre_regex/extconf.rb
+- ext/tre_regex/tre_regex.c
+- lib/tre_regex.rb
+- lib/tre_regex/3.3/tre_regex.so
+- lib/tre_regex/3.4/tre_regex.so
+- lib/tre_regex/4.0/tre_regex.so
+- lib/tre_regex/bin/libtre.so
+- lib/tre_regex/version.rb
+homepage: https://github.com/le0pard/tre_regex
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/le0pard/tre_regex
+  source_code_uri: https://github.com/le0pard/tre_regex
+  changelog_uri: https://github.com/le0pard/tre_regex/releases
+  bug_tracker_uri: https://github.com/le0pard/tre_regex/issues
+  documentation_uri: https://github.com/le0pard/tre_regex/blob/main/README.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: A fast Ruby FFI wrapper for the TRE approximate regex matching library.
+test_files: []