ruby-spacy 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b759c507a1cad8e726bd36ad39e4539894395407e2ac5d64a31b7b907a4e34d8
-  data.tar.gz: 0f02f9b8f6bcf39a49b50b1934905e72c0c13bb9652eee8fbaad3a3b7b58b7e7
+  metadata.gz: 055dc3da59c059df185ce0d868ba8da07453f0c5c1501d2a61fc5e27e5abee28
+  data.tar.gz: adc27ca2bfcc46ea0ad90bcd2469c2fc5abfdad47982339a7acb085ddeb20de0
 SHA512:
-  metadata.gz: 5b7d8078148e05c860f3ef698b5103cfca533fabfac5001c5afd12419efaae21d6492aa22fcebfba9d9d22bf8701fe2c6a21eb1ee879344cdbd5d897af9b8853
-  data.tar.gz: 4ffab4be8e0338e86c34aad0285cd9471a3d5c570fbf48b4214cdbe5ca5cc01c7d251d4f6d5edc778de2185d89fc3858e094c363499c81f89d5c3a61ab8859c2
+  metadata.gz: 0ef618c78e55a8607b2975bd91946ab0d337a7fa73982f05fda1bb6db4f8e773b5535b90833fe79de63f8def8a3fb08ce363592a54f941de85b57618f7b7945e
+  data.tar.gz: 0bd57b4cfe238a630c85c93c4b84b0d95b1e07dc74583cf4916fc2b16ba51222c4a35b2a5d5e18e470050ba8680ef642a1d0ba50c6d830b506bf4c4f7b6523f3

data/.github/workflows/ci.yml

@@ -0,0 +1,74 @@
+name: CI
+
+on:
+  # Every branch, so that work in progress is tested before a pull request exists
+  push:
+    branches: ["**"]
+  pull_request:
+  # Weekly run to detect breakage from new spaCy / PyCall / Ruby releases
+  # even when the repository itself is untouched
+  schedule:
+    - cron: "23 3 * * 2"
+
+jobs:
+  test:
+    name: ruby ${{ matrix.ruby }} / python ${{ matrix.python }}
+    runs-on: ubuntu-latest
+    # Pull requests from this repository are already covered by the push event;
+    # only run the pull_request event for forks, to avoid duplicate matrices
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name != github.repository
+    # This project has known hang paths (pipeline calls from non-main threads,
+    # spacy.load hangs that Ruby's Timeout cannot interrupt); never let a job
+    # run until GitHub's 6-hour limit
+    timeout-minutes: 30
+    continue-on-error: ${{ matrix.experimental == true }}
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ["3.2", "3.3", "3.4", "4.0"]
+        python: ["3.11", "3.12", "3.13", "3.14"]
+        include:
+          # Ruby 4.1 is not released yet; track the development branch instead
+          - { ruby: head, python: "3.13", experimental: true }
+    env:
+      # PyCall locates the Python interpreter via this variable
+      PYTHON: python
+    steps:
+      - uses: actions/checkout@v7
+
+      # Must precede ruby/setup-ruby: installing the pycall gem compiles its
+      # native extension against this Python
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python }}
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+
+      - id: site-packages
+        run: echo "path=$(python -c 'import site; print(site.getsitepackages()[0])')" >> "$GITHUB_OUTPUT"
+
+      # Cache the language models only (en_core_web_lg alone is several hundred
+      # MB). spaCy itself is intentionally installed fresh on every run so that
+      # new releases are exercised immediately. Bump the key suffix when
+      # upgrading the models.
+      - uses: actions/cache@v6
+        with:
+          path: |
+            ${{ steps.site-packages.outputs.path }}/en_core_web_sm*
+            ${{ steps.site-packages.outputs.path }}/en_core_web_lg*
+          key: spacy-models-${{ matrix.python }}-v1
+
+      # en_core_web_lg is large; install it only on representative jobs.
+      # Tests that need it are skipped automatically where it is absent.
+      - name: Install spaCy and language models
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install --upgrade spacy
+          python -m spacy download en_core_web_sm
+          if [ "${{ matrix.python }}" = "3.13" ]; then python -m spacy download en_core_web_lg; fi
+
+      - name: Run tests
+        run: bundle exec rake test

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Change Log
 
+## 0.6.0 - 2026-08-31
+### Added
+- GitHub Actions CI — Ruby 3.2 to 4.0 (plus ruby-head) and Python 3.11 to 3.14,
+  with a weekly run to catch breakage from new spaCy or PyCall releases
+- `:label` in `Matcher#match` results — the label string of the matched pattern
+
+### Changed
+- PyCall 1.5.3 or later is now required; earlier versions freeze the whole
+  process when Ruby's GC releases a Python object on a non-main thread, which
+  affects any threaded application (Rails, Puma, Sidekiq)
+- Minimum Ruby version raised to 3.2
+- Removed the `numpy` gem dependency; NumPy is used directly through PyCall
+- Relaxed the `terminal-table` requirement to `>= 3.0, < 5`
+- Language models are no longer stored in Python's `__main__`, so creating a
+  `Language` no longer keeps a pipeline alive until the process exits
+- `Language.new(timeout:)` now actually fires. The wait happens on a Python
+  thread rather than through Ruby's `Timeout`, whose watcher thread cannot run
+  while PyCall holds the GVL. `timeout: nil` waits indefinitely, and a timeout
+  is never retried
+- README documents the thread-safety constraint: all spaCy calls must be made
+  from the thread that initialized PyCall
+
+### Deprecated
+- `Language#spacy_nlp_id` — use `#py_nlp` instead; referencing it still works
+  but creates a Python global variable that is never released
+
+### Fixed
+- `Matcher#match` returned a corrupted `:match_id` (often `0`) for labels whose
+  hash was `2**62` or larger, since unsigned 64-bit values do not survive the
+  PyCall boundary. Ids now round-trip through `Language#vocab_string_lookup`,
+  which accepts large ids again
+- Integer attributes reached through `method_missing`, such as `Token#orth`,
+  were silently corrupted for the same reason: 7 of 12 common words returned a
+  negative `orth`. They are now fetched safely, which also restores
+  `Token#rank` for out-of-vocabulary tokens
+
 ## 0.5.0 - 2026-07-21
 ### Added
 - `Language#with_llm(provider:)` — provider-neutral block-based LLM API

data/Gemfile

@@ -5,15 +5,7 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in ruby-spacy.gemspec
 gemspec
 
-gem "fiddle" # Required for Ruby 4.0+ (moved from default to bundled gem)
-gem "numpy"
-gem "pycall", "~> 1.5.1"
-gem "terminal-table"
-
 group :development do
   gem "github-markup"
-  gem "minitest", "~> 5.0"
-  gem "rake", "~> 13.0"
   gem "redcarpet"
-  gem "yard"
 end

data/README.md

@@ -13,9 +13,9 @@
 | ✅ | Access to pre-trained word vectors                 |
 | ✅ | LLM integration: OpenAI, Anthropic (Claude), and local models |
 
-Current Version: `0.5.0`
+Current Version: `0.6.0`
 
-- Ruby 4.0 supported
+- Ruby 3.2 to 4.0 supported (PyCall 1.5.3 or later required)
 - spaCy 3.8 supported
 - Multi-provider LLM API: OpenAI, Anthropic (Claude), and local models via Ollama or any OpenAI-compatible server
 - Structured outputs (JSON Schema) support
@@ -23,16 +23,16 @@ Current Version: `0.5.0`
 
 ## Installation of Prerequisites
 
-**IMPORTANT**: Make sure that the `enable-shared` option is enabled in your Python installation. You can use [pyenv](https://github.com/pyenv/pyenv) to install any version of Python you like. Install Python 3.10.6, for instance, using pyenv with `enable-shared` as follows:
+**IMPORTANT**: Make sure that the `enable-shared` option is enabled in your Python installation. You can use [pyenv](https://github.com/pyenv/pyenv) to install any version of Python you like. spaCy 3.8 supports Python 3.10 and later (wheels are provided for Python 3.10–3.14), so we recommend using one of those versions. Install Python 3.13, for instance, using pyenv with `enable-shared` as follows:
 
 ```shell
-$ env CONFIGURE_OPTS="--enable-shared" pyenv install 3.10.6
+$ env CONFIGURE_OPTS="--enable-shared" pyenv install 3.13
 ```
 
 Remember to make it accessible from your working directory. It is recommended that you set `global` to the version of python you just installed.
 
 ```shell
-$ pyenv global 3.10.6 
+$ pyenv global 3.13
 ```
 
 Then, install [spaCy](https://spacy.io/). If you use `pip`, the following command will do:
@@ -525,6 +525,30 @@ Output:
 | 9    | アルザス       | 0.5644999742507935 |
 | 10   | 南仏           | 0.5547999739646912 |
 
+### Matcher
+
+`Matcher` finds token sequences with rule-based patterns.
+
+```ruby
+require "ruby-spacy"
+
+nlp = Spacy::Language.new("en_core_web_sm")
+
+matcher = nlp.matcher
+matcher.add("GREETING", [[{ LOWER: "hello" }, { IS_PUNCT: true }, { LOWER: "world" }]])
+
+doc = nlp.read("Hello, world!")
+matcher.match(doc).each do |match|
+  span = doc.span(match[:start_index]..match[:end_index])
+  puts "#{match[:label]}: #{span.text}"
+end
+# => GREETING: Hello, world
+```
+
+`Matcher#match` returns an array of hashes with `:match_id` (the label's numeric id), `:start_index`, `:end_index`, and `:label` (the label string).
+
+See `examples/rule_based_matching/` for more examples.
+
 ### PhraseMatcher
 
 `PhraseMatcher` is more efficient than `Matcher` for matching large terminology lists. It's ideal for extracting known entities like product names, company names, or domain-specific terms.
@@ -974,6 +998,14 @@ See `examples/llm/` for complete scripts, including a spaCy-vs-LLM NER compariso
 
 ## Advanced Usage
 
+### Thread Safety
+
+All spaCy calls must be made from the same thread that initialized PyCall (normally the main thread). Calling the spaCy pipeline from another thread — e.g. `nlp.read(text)` inside a `Thread.new` block, a Rails multi-threaded server, or a Sidekiq worker — will hang the entire process.
+
+Note that attribute access (such as `nlp.pipe_names`) works from other threads, so the failure mode is not obvious: the process only freezes when the pipeline actually runs. The root cause is currently unknown (it is specific to spaCy pipeline execution; other GIL-releasing Python calls work fine from other threads).
+
+If you need concurrent processing, serialize all Python calls onto a single dedicated thread, for example with a worker thread and a queue.
+
 ### Setting a Timeout
 
 You can set a timeout for the `Spacy::Language.new` method:
@@ -982,6 +1014,8 @@ You can set a timeout for the `Spacy::Language.new` method:
 nlp = Spacy::Language.new("en_core_web_sm", timeout: 120) # Set timeout to 120 seconds
 ```
 
+If the model does not finish loading within the given seconds, a `RuntimeError` is raised. Pass `timeout: nil` to wait indefinitely.
+
 ### Document Serialization
 
 You can serialize processed documents to binary format for caching or storage. This is useful when you want to avoid re-processing the same text multiple times.

data/examples/rule_based_matching/creating_spans_from_matches.rb

@@ -14,7 +14,7 @@ doc = nlp.read("Barack Obama was the 44th president of the United States")
 matches = matcher.match(doc)
 
 matches.each do |match|
-  span = Spacy::Span.new(doc, start_index: match[:start_index], end_index: match[:end_index], options: { label: match[:match_id] })
+  span = Spacy::Span.new(doc, start_index: match[:start_index], end_index: match[:end_index], options: { label: match[:label] })
   puts "#{span.text} / #{span.label}"
 end
 

data/lib/ruby-spacy/version.rb

@@ -2,5 +2,5 @@
 
 module Spacy
   # The version number of the module
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/ruby-spacy.rb

@@ -6,9 +6,7 @@ require_relative "ruby-spacy/openai_client"
 require_relative "ruby-spacy/anthropic_client"
 require_relative "ruby-spacy/openai_helper"
 require_relative "ruby-spacy/anthropic_helper"
-require "numpy"
 require "pycall"
-require "timeout"
 require "json"
 require "base64"
 
@@ -27,6 +25,16 @@ module Spacy
   end
 
   Builtins = PyCall.import_module("builtins")
+
+  # Python `spacy` module
+  PySpacy = spacy
+
+  # Python `__main__` module (used for the deprecated `Language#spacy_nlp_id`)
+  PyMain = PyCall.import_module("__main__")
+
+  # Python `base64` module (used for `Doc.from_bytes`)
+  PyBase64 = PyCall.import_module("base64")
+
   SpacyVersion = spacy.__version__
 
   # Python `Language` class
@@ -50,6 +58,92 @@ module Spacy
   # Python `displacy` object
   PyDisplacy = PyCall.import_module('spacy.displacy')
 
+  # Python-side helpers, kept in a dedicated module so that nothing is added to
+  # the user's `__main__` namespace. They exist because spaCy's vocabulary keys,
+  # matcher ids, and integer attributes (e.g. `Token#orth`) are unsigned 64-bit
+  # integers that do not survive the PyCall boundary in either direction: on the
+  # Python -> Ruby side, values from 2**62 up to 2**63-1 are silently corrupted
+  # into negative numbers and values from 2**63 up come back as nil; on the
+  # Ruby -> Python side, passing a large Ruby Integer raises TypeError
+  # ("an integer is required"). Moving ids as decimal strings and resolving them
+  # in Python sidesteps both directions.
+  #
+  # - key_texts(nlp, keys): used by `Language#most_similar`;
+  #   returns [[key_string, text], ...]
+  # - string_lookup(nlp, key_str): used by `Language#vocab_string_lookup`;
+  #   returns the string for the given id
+  # - matcher_matches(matcher, doc): used by `Matcher#match`;
+  #   returns [(match_id_string, start, end, label_string), ...]
+  # - attr_or_call(obj, name, args): used by `Spacy.safe_py_send`; returns the
+  #   attribute (called with args if given), with Python ints stringified with
+  #   INT_PREFIX so they survive the PyCall boundary
+  # - load_with_timeout(model, seconds): used by `Language#initialize`; loads a
+  #   model on a Python thread and returns nil if it does not finish in time
+  #   (Ruby's Timeout cannot fire while PyCall holds the GVL)
+  PyHelpers = PyCall.import_module("types").ModuleType.new("ruby_spacy_helpers")
+  PyCall.exec(<<~PYTHON, globals: PyHelpers.__dict__)
+    import threading
+
+    _PREFIX = "__ruby_spacy_int__:"
+
+    def key_texts(nlp, keys):
+        return [[str(key), nlp.vocab[key].text] for key in keys]
+
+    def string_lookup(nlp, key_str):
+        return nlp.vocab.strings[int(key_str)]
+
+    def matcher_matches(matcher, doc):
+        return [(str(m[0]), m[1], m[2], matcher.vocab.strings[m[0]]) for m in matcher(doc)]
+
+    def attr_or_call(obj, name, args):
+        v = getattr(obj, name)
+        if args:
+            v = v(*args)
+        if type(v) is int:
+            return _PREFIX + str(v)
+        return v
+
+    def load_with_timeout(model, seconds):
+        import spacy
+        box = {}
+        def run():
+            try:
+                box["nlp"] = spacy.load(model)
+            except BaseException as e:
+                box["err"] = e
+        t = threading.Thread(target=run, daemon=True)
+        t.start()
+        t.join(seconds)
+        if t.is_alive():
+            return None
+        if "err" in box:
+            raise box["err"]
+        return box["nlp"]
+  PYTHON
+
+  # Marks integer values that `PyHelpers.attr_or_call` stringified so they can
+  # survive the PyCall boundary (see the comment above `PyHelpers`)
+  INT_PREFIX = "__ruby_spacy_int__:"
+
+  # Calls an attribute or method on a Python object. spaCy exposes several
+  # unsigned 64-bit integer attributes (e.g. `Token#orth`) that are silently
+  # corrupted when they cross the PyCall boundary (see the comment above
+  # `PyHelpers`), so when the result looks corrupted (nil, or a negative
+  # Integer, which cannot occur legitimately for these ids) the value is
+  # fetched again via `PyHelpers.attr_or_call`, which stringifies ints on the
+  # Python side. Ordinary values (strings, booleans, floats, Python objects,
+  # small non-negative integers) are returned as-is.
+  def self.safe_py_send(py_obj, name, args)
+    v = py_obj.send(name, *args)
+    return v unless v.nil? || (v.is_a?(Integer) && v.negative?)
+
+    r = PyHelpers.attr_or_call(py_obj, name.to_s, args)
+    r.is_a?(String) && r.start_with?(INT_PREFIX) ? r.delete_prefix(INT_PREFIX).to_i : r
+  end
+
+  # Python `numpy` module (always present as a spaCy dependency)
+  PyNp = PyCall.import_module("numpy")
+
   # A utility module method to convert Python's generator object to a Ruby array,
   # mainly used on the items inside the array returned from dependency-related methods
   # such as {Span#rights}, {Span#lefts} and {Span#subtree}.
@@ -237,7 +331,7 @@ module Spacy
     #   doc = Spacy::Doc.from_bytes(nlp, bytes)
     def self.from_bytes(nlp, byte_string)
       b64 = Base64.strict_encode64(byte_string)
-      py_bytes = PyCall.eval("__import__('base64').b64decode('#{b64}')")
+      py_bytes = PyBase64.b64decode(b64)
       py_doc = nlp.py_nlp.call("").from_bytes(py_bytes)
       new(nlp.py_nlp, py_doc: py_doc)
     end
@@ -488,7 +582,7 @@ module Spacy
 
     # Methods defined in Python but not wrapped in ruby-spacy can be called by this dynamic method handling mechanism.
     def method_missing(name, *args)
-      @py_doc.send(name, *args)
+      Spacy.safe_py_send(@py_doc, name, args)
     end
 
     def respond_to_missing?(sym, include_private = false)
@@ -502,28 +596,40 @@ module Spacy
 
   # See also spaCy Python API document for [`Language`](https://spacy.io/api/language).
   class Language
-    # @return [String] an identifier string that can be used to refer to the Python `Language` object inside `PyCall::exec` or `PyCall::eval`
-    attr_reader :spacy_nlp_id
-
     # @return [Object] a Python `Language` instance accessible via `PyCall`
     attr_reader :py_nlp
 
+    # @return [String] an identifier string that can be used to refer to the Python `Language` object inside `PyCall::exec` or `PyCall::eval`
+    # @deprecated The Python object is no longer stored in a global variable at
+    #   initialization time. Referencing this method creates a global variable in
+    #   Python's `__main__` on demand (which then stays alive until the process
+    #   exits). Use {#py_nlp} instead.
+    def spacy_nlp_id
+      @spacy_nlp_id ||= begin
+        warn "[DEPRECATION] `Spacy::Language#spacy_nlp_id` is deprecated. " \
+             "It creates a Python global variable that is never released; use `py_nlp` instead."
+        id = "nlp_#{@py_nlp.object_id}"
+        Builtins.setattr(PyMain, id, @py_nlp)
+        id
+      end
+    end
+
     # Creates a language model instance, which is conventionally referred to by a variable named `nlp`.
     # @param model [String] A language model installed in the system
+    # @param timeout [Numeric, nil] Seconds to wait for the model to load before
+    #   raising a `RuntimeError`. `nil` waits indefinitely. The timeout is
+    #   enforced on the Python side (a loading thread with `join(timeout)`)
+    #   because Ruby's `Timeout` cannot fire while PyCall holds the GVL. When it
+    #   fires, the loading thread is left running as a daemon until the process
+    #   exits (accepted: timeouts are an abnormal path).
     def initialize(model = "en_core_web_sm", max_retrial: MAX_RETRIAL, timeout: 60)
       unless model.to_s.match?(/\A[a-zA-Z0-9_\-\.\/]+\z/)
         raise ArgumentError, "Invalid model name: #{model.inspect}"
       end
 
-      @spacy_nlp_id = "nlp_#{model.object_id}"
       retrial = 0
       begin
-        Timeout.timeout(timeout) do
-          PyCall.exec("import spacy; #{@spacy_nlp_id} = spacy.load('#{model}')")
-        end
-        @py_nlp = PyCall.eval(@spacy_nlp_id)
-      rescue Timeout::Error
-        raise "PyCall execution timed out after #{timeout} seconds"
+        @py_nlp = PyHelpers.load_with_timeout(model, timeout)
       rescue StandardError => e
         retrial += 1
         if retrial <= max_retrial
@@ -533,6 +639,8 @@ module Spacy
           raise "Failed to initialize Spacy after #{max_retrial} attempts: #{e.message}"
         end
       end
+      # A timeout is not retried; it almost certainly means a hung load
+      raise "PyCall execution timed out after #{timeout} seconds" if @py_nlp.nil?
     end
 
     # Reads and analyze the given text.
@@ -559,11 +667,11 @@ module Spacy
       PhraseMatcher.new(self, attr: attr)
     end
 
-    # A utility method to lookup a vocabulary item of the given id.
-    # @param id [Integer] a vocabulary id
-    # @return [Object] a Python `Lexeme` object (https://spacy.io/api/lexeme)
+    # A utility method to lookup the string of the given vocabulary id.
+    # @param id [Integer] a vocabulary id (unsigned 64-bit values are supported)
+    # @return [String] the string corresponding to the given vocabulary id
     def vocab_string_lookup(id)
-      PyCall.eval("#{@spacy_nlp_id}.vocab.strings[#{Integer(id)}]")
+      PyHelpers.string_lookup(@py_nlp, Integer(id).to_s)
     end
 
     # A utility method to list pipeline components.
@@ -590,9 +698,9 @@ module Spacy
     # @param vector [Object] A vector representation of a word (whether existing or non-existing)
     # @return [Array<Hash{:key => Integer, :text => String, :best_rows => Array<Float>, :score => Float}>] An array of hash objects each contains the `key`, `text`, `best_row` and similarity `score` of a lexeme
     def most_similar(vector, num)
-      vec_array = Numpy.asarray([vector])
+      vec_array = PyNp.asarray([vector])
       py_result = @py_nlp.vocab.vectors.most_similar(vec_array, n: num)
-      key_texts = PyCall.eval("[[str(num), #{@spacy_nlp_id}.vocab[num].text] for num in #{py_result[0][0].tolist}]")
+      key_texts = PyCall::List.call(PyHelpers.key_texts(@py_nlp, py_result[0][0].tolist))
       keys = key_texts.map { |kt| kt[0] }
       texts = key_texts.map { |kt| kt[1] }
       best_rows = PyCall::List.call(py_result[1])[0]
@@ -708,7 +816,7 @@ module Spacy
 
     # Methods defined in Python but not wrapped in ruby-spacy can be called by this dynamic method handling mechanism.
     def method_missing(name, *args)
-      @py_nlp.send(name, *args)
+      Spacy.safe_py_send(@py_nlp, name, args)
     end
 
     def respond_to_missing?(sym, include_private = false)
@@ -740,10 +848,10 @@ module Spacy
 
     # Execute the match.
     # @param doc [Doc] an {Doc} instance
-    # @return [Array<Hash{:match_id => Integer, :start_index => Integer, :end_index => Integer}>] the id of the matched pattern, the starting position, and the end position
+    # @return [Array<Hash{:match_id => Integer, :start_index => Integer, :end_index => Integer, :label => String}>] the id of the matched pattern, the starting position, the end position, and the label string of the matched pattern
     def match(doc)
-      PyCall::List.call(@py_matcher.call(doc.py_doc)).map do |py_match|
-        { match_id: py_match[0].to_i, start_index: py_match[1].to_i, end_index: py_match[2].to_i - 1 }
+      PyCall::List.call(PyHelpers.matcher_matches(@py_matcher, doc.py_doc)).map do |py_match|
+        { match_id: py_match[0].to_i, start_index: py_match[1], end_index: py_match[2] - 1, label: py_match[3] }
       end
     end
   end
@@ -933,7 +1041,7 @@ module Spacy
 
     # Methods defined in Python but not wrapped in ruby-spacy can be called by this dynamic method handling mechanism.
     def method_missing(name, *args)
-      @py_span.send(name, *args)
+      Spacy.safe_py_send(@py_span, name, args)
     end
 
     def respond_to_missing?(sym, include_private = false)
@@ -1089,7 +1197,7 @@ module Spacy
 
     # Methods defined in Python but not wrapped in ruby-spacy can be called by this dynamic method handling mechanism.
     def method_missing(name, *args)
-      @py_token.send(name, *args)
+      Spacy.safe_py_send(@py_token, name, args)
     end
 
     def respond_to_missing?(sym, include_private = false)
@@ -1168,7 +1276,7 @@ module Spacy
 
     # Methods defined in Python but not wrapped in ruby-spacy can be called by this dynamic method handling mechanism.
     def method_missing(name, *args)
-      @py_lexeme.send(name, *args)
+      Spacy.safe_py_send(@py_lexeme, name, args)
     end
 
     def respond_to_missing?(sym, include_private = false)

data/ruby-spacy.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |spec|
 
   spec.homepage      = "https://github.com/yohasebe/ruby-spacy"
   spec.license       = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 3.1")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2")
 
   # 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.
@@ -27,15 +27,15 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-mock" # minitest 6 split the mock/stub support into a separate gem
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "solargraph"
+  spec.add_development_dependency "yard"
 
   spec.add_dependency "base64" # Required for Ruby 3.4+ (moved from default to bundled gem)
   spec.add_dependency "fiddle" # Required for Ruby 4.0+ (moved from default to bundled gem)
-  spec.add_dependency "numpy", "~> 0.4.0"
-  spec.add_dependency "pycall", "~> 1.5.1"
-  spec.add_dependency "terminal-table", "~> 3.0.1"
+  spec.add_dependency "pycall", ">= 1.5.3", "< 2.0"
+  spec.add_dependency "terminal-table", ">= 3.0", "< 5"
 
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-spacy
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Yoichiro Hasebe
@@ -24,7 +24,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,7 +38,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest-mock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: solargraph
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -66,13 +66,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: base64
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -80,7 +80,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: fiddle
+  name: base64
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -94,47 +94,59 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: numpy
+  name: fiddle
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pycall
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.1
+        version: 1.5.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.5.1
+        version: 1.5.3
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: terminal-table
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 3.0.1
+        version: '5'
 description: 'ruby-spacy is a wrapper module for using spaCy from the Ruby programming
   language via PyCall. This module aims to make it easy and natural for Ruby programmers
   to use spaCy. This module covers the areas of spaCy functionality for using many
@@ -148,6 +160,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/FUNDING.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - CHANGELOG.md
 - Gemfile
@@ -238,7 +251,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="