tree_haver 3.2.1 → 3.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3da36f96aa78d0995c76a3cbd6451889066b65d219414938e098ef9949df317f
-  data.tar.gz: 11e11da6c9f53e439d4226700c981466c3b47f0b9411d2e97a5211edade8d81d
+  metadata.gz: 02ffefe8f7a777c04ca0682c3bae06f92d383eacdf2e852755dd6e517cff68bf
+  data.tar.gz: a44f91a685d4736f7eac5a81cc04f43e274e18f8af8904eaa4e1247bf1779764
 SHA512:
-  metadata.gz: 1dce9daf70fc5573d579d699724601756db9758170fdb0e7be759ea9572a3d02fa491766786c708172e0f66c2473ae9e0da97fb20bddf7b185d93e285cc8bd3e
-  data.tar.gz: eaf3a3649233933b523a7f8e49831b7d5c7f00da268d805c7cbc043176424b5b4214da607bbe7e57e03dcd9072269dfedf3feba4383a828e6cb1abb89394b5c8
+  metadata.gz: e0d54671ac5cecea3e8496da4e5a9cf9f4ef4c3abd7bcb926f0d8830e230b2d850845e4a49e824e0144c79c35e7477abf6ee9f4a7284637c1fc0c0ff6ff15033
+  data.tar.gz: 8f7487bd3fba0f8d03128a32a485db360a1db5d97161f2885918992dd516140c37006d7bf2bc7d8f86867ad597fe5920683f126bd1d30c2257764aab19b37c88

data/CHANGELOG.md

@@ -30,6 +30,62 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [3.2.3] - 2026-01-02
+
+- TAG: [v3.2.3][3.2.3t]
+- COVERAGE: 94.91% -- 2088/2200 lines in 22 files
+- BRANCH COVERAGE: 81.37% -- 738/907 branches in 22 files
+- 90.14% documented
+
+### Fixed
+
+- **`parser_for` now respects explicitly requested non-native backends** - Previously,
+  `parser_for` would always try tree-sitter backends first and only fall back to alternative
+  backends if tree-sitter was unavailable. Now it checks `effective_backend` and skips
+  tree-sitter attempts entirely when a non-native backend is explicitly requested via:
+  - `TREE_HAVER_BACKEND=citrus` (or `prism`, `psych`, `commonmarker`, `markly`)
+  - `TreeHaver.backend = :citrus`
+  - `TreeHaver.with_backend(:citrus) { ... }`
+
+  Native backends (`:mri`, `:rust`, `:ffi`, `:java`) still use tree-sitter grammar discovery.
+
+- **`load_tree_sitter_language` now correctly ignores Citrus registrations** - Previously,
+  if a language was registered with Citrus first, `load_tree_sitter_language` would
+  incorrectly try to use it even when a native backend was explicitly requested. Now it
+  only uses registrations that have a `:tree_sitter` key, allowing proper backend switching
+  between Citrus and native tree-sitter backends.
+
+- **`load_tree_sitter_language` now validates registered paths exist** - Previously,
+  if a language had a stale/invalid tree-sitter registration with a non-existent path
+  (e.g., from a test), the code would try to use it and fail. Now it checks
+  `File.exist?(path)` before using a registered path, falling back to auto-discovery
+  via `GrammarFinder` if the registered path doesn't exist.
+
+- **`Language.method_missing` no longer falls back to Citrus when native backend explicitly requested** -
+  Previously, when tree-sitter loading failed (e.g., .so file missing), the code would
+  silently fall back to Citrus even if the user explicitly requested `:mri`, `:rust`,
+  `:ffi`, or `:java`. Now fallback to Citrus only happens when `effective_backend` is `:auto`.
+  This is a **breaking change** for users who relied on silent fallback behavior.
+
+- **Simplified `parser_for` implementation** - Refactored from complex nested conditionals to
+  cleaner helper methods (`load_tree_sitter_language`, `load_citrus_language`). The logic is
+  now easier to follow and maintain.
+
+## [3.2.2] - 2026-01-01
+
+- TAG: [v3.2.2][3.2.2t]
+- COVERAGE: 94.79% -- 2076/2190 lines in 22 files
+- BRANCH COVERAGE: 81.35% -- 733/901 branches in 22 files
+- 90.14% documented
+
+### Fixed
+
+- RSpec dependency tags now respect `TREE_HAVER_BACKEND` environment variable
+  - When `TREE_HAVER_BACKEND=ffi` is set, MRI backend availability is not checked
+  - Prevents `BackendConflict` errors when loading gems that use tree-sitter grammars
+  - The `blocked_backends` set now includes backends that would conflict with the explicitly selected backend
+  - This allows `*-merge` gems to load correctly in test suites when a specific backend is selected
+
 ## [3.2.1] - 2025-12-31
 
 - TAG: [v3.2.1][3.2.1t]
@@ -659,7 +715,11 @@ Despite the major version bump to 3.0.0 (following semver due to the breaking `L
 
 - Initial release
 
-[Unreleased]: https://github.com/kettle-rb/tree_haver/compare/v3.2.1...HEAD
+[Unreleased]: https://github.com/kettle-rb/tree_haver/compare/v3.2.3...HEAD
+[3.2.3]: https://github.com/kettle-rb/tree_haver/compare/v3.2.2...v3.2.3
+[3.2.3t]: https://github.com/kettle-rb/tree_haver/releases/tag/v3.2.3
+[3.2.2]: https://github.com/kettle-rb/tree_haver/compare/v3.2.1...v3.2.2
+[3.2.2t]: https://github.com/kettle-rb/tree_haver/releases/tag/v3.2.2
 [3.2.1]: https://github.com/kettle-rb/tree_haver/compare/v3.2.0...v3.2.1
 [3.2.1t]: https://github.com/kettle-rb/tree_haver/releases/tag/v3.2.1
 [3.2.0]: https://github.com/kettle-rb/tree_haver/compare/v3.1.2...v3.2.0

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 Peter H. Boling
+Copyright (c) 2025-2026 Peter H. Boling
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1788,7 +1788,7 @@ See [LICENSE.txt](LICENSE.txt) for the official [Copyright Notice](https://opens
 
 <ul>
     <li>
-        Copyright (c) 2025 Peter H. Boling, of
+        Copyright (c) 2025-2026 Peter H. Boling, of
         <a href="https://discord.gg/3qme4XHNKN">
             Galtzo.com
             <picture>
@@ -1977,7 +1977,7 @@ Thanks for RTFM. ☺️
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-2.190-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-2.200-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/tree_haver/language.rb

@@ -211,10 +211,13 @@ module TreeHaver
 
         # No tree-sitter path registered - check for Citrus fallback
         # This enables auto-fallback when tree-sitter grammar is not installed
-        # but a Citrus grammar (pure Ruby) is available
-        citrus_reg = all_backends[:citrus]
-        if citrus_reg && citrus_reg[:grammar_module]
-          return Backends::Citrus::Language.new(citrus_reg[:grammar_module])
+        # but a Citrus grammar (pure Ruby) is available.
+        # Only fall back when backend is :auto - explicit native backend requests should fail.
+        if TreeHaver.effective_backend == :auto
+          citrus_reg = all_backends[:citrus]
+          if citrus_reg && citrus_reg[:grammar_module]
+            return Backends::Citrus::Language.new(citrus_reg[:grammar_module])
+          end
         end
 
         # No appropriate registration found
@@ -237,17 +240,29 @@ module TreeHaver
       # - FFI can't find required symbols like ts_parser_new (FFI::NotFoundError)
       # - Invalid arguments were provided (ArgumentError)
       #
+      # Fallback to Citrus ONLY happens when:
+      # - The effective backend is :auto (user didn't explicitly request a native backend)
+      # - A Citrus grammar is registered for the language
+      #
+      # If the user explicitly requested a native backend (:mri, :rust, :ffi, :java),
+      # we should NOT silently fall back to Citrus - that would violate the user's intent.
+      #
       # @param error [Exception] the original error
       # @param all_backends [Hash] all registered backends for the language
-      # @return [Backends::Citrus::Language] if Citrus fallback available
-      # @raise [Exception] re-raises original error if no fallback
+      # @return [Backends::Citrus::Language] if Citrus fallback available and allowed
+      # @raise [Exception] re-raises original error if no fallback or fallback not allowed
       # @api private
       def handle_tree_sitter_load_failure(error, all_backends)
-        citrus_reg = all_backends[:citrus]
-        if citrus_reg && citrus_reg[:grammar_module]
-          return Backends::Citrus::Language.new(citrus_reg[:grammar_module])
+        # Only fall back to Citrus when backend is :auto
+        # If user explicitly requested a native backend, respect that choice
+        effective = TreeHaver.effective_backend
+        if effective == :auto
+          citrus_reg = all_backends[:citrus]
+          if citrus_reg && citrus_reg[:grammar_module]
+            return Backends::Citrus::Language.new(citrus_reg[:grammar_module])
+          end
         end
-        # No Citrus fallback available, re-raise the original error
+        # No Citrus fallback allowed or available, re-raise the original error
         raise error
       end
     end

data/lib/tree_haver/rspec/dependency_tags.rb

@@ -775,9 +775,30 @@ RSpec.configure do |config|
   }
 
   # Determine which backends should NOT have availability checked
-  # based on which *_backend_only tag is being run
+  # based on which *_backend_only tag is being run OR which backend is
+  # explicitly selected via TREE_HAVER_BACKEND environment variable.
   blocked_backends = Set.new
 
+  # Track whether we're in isolated test mode (running *_backend_only tags).
+  # This is different from just having TREE_HAVER_BACKEND set.
+  # In isolated mode, we skip ALL grammar checks because they might trigger
+  # backend loading via TreeHaver.parser_for's auto-detection.
+  # When just TREE_HAVER_BACKEND is set, grammar checks are fine because
+  # parser_for will use the selected backend, not auto-detect.
+  isolated_test_mode = false
+
+  # First, check if TREE_HAVER_BACKEND explicitly selects a backend.
+  # If so, block all backends that would conflict with it.
+  # This prevents loading MRI when TREE_HAVER_BACKEND=ffi, for example.
+  env_backend = ENV["TREE_HAVER_BACKEND"]
+  if env_backend && !env_backend.empty? && env_backend != "auto"
+    backend_sym = env_backend.to_sym
+    blockers = TreeHaver::Backends::BLOCKED_BY[backend_sym]
+    if blockers
+      blockers.each { |blocker| blocked_backends << blocker }
+    end
+  end
+
   # Check which *_backend_only tags are being run and block their conflicting backends
   # config.inclusion_filter contains tags passed via --tag on command line
   inclusion_rules = config.inclusion_filter.rules
@@ -806,6 +827,7 @@ RSpec.configure do |config|
     # Check if we're running this backend's isolated tests
     isolated_tag = :"#{backend}_backend_only"
     if inclusion_rules[isolated_tag]
+      isolated_test_mode = true
       # Add all backends that would block this one
       blockers.each { |blocker| blocked_backends << blocker }
     end
@@ -813,6 +835,7 @@ RSpec.configure do |config|
 
   # Store blocked_backends in a module variable so before(:suite) can access it
   TreeHaver::RSpec::DependencyTags.instance_variable_set(:@blocked_backends, blocked_backends)
+  TreeHaver::RSpec::DependencyTags.instance_variable_set(:@isolated_test_mode, isolated_test_mode)
 
   # Now configure exclusions, skipping availability checks for blocked backends
   backend_tags.each do |backend, tag|
@@ -847,9 +870,10 @@ RSpec.configure do |config|
   # loading blocked backends. The grammar checks use TreeHaver.parser_for which
   # would load the default backend (MRI) and block FFI.
 
-  # Skip grammar availability checks if any backend is blocked
-  # (i.e., we're running isolated backend tests)
-  if blocked_backends.none?
+  # Skip grammar availability checks only when in isolated test mode.
+  # When TREE_HAVER_BACKEND is explicitly set (but not using *_backend_only tags),
+  # grammar checks are fine because TreeHaver.parser_for respects the env var.
+  unless isolated_test_mode
     config.filter_run_excluding(libtree_sitter: true) unless deps.libtree_sitter_available?
     config.filter_run_excluding(bash_grammar: true) unless deps.tree_sitter_bash_available?
     config.filter_run_excluding(toml_grammar: true) unless deps.tree_sitter_toml_available?
@@ -868,7 +892,7 @@ RSpec.configure do |config|
   # NOTE: any_toml_backend_available? calls tree_sitter_toml_available? which
   # triggers grammar_works? and loads MRI. Skip when running isolated tests.
 
-  if blocked_backends.none?
+  unless isolated_test_mode
     config.filter_run_excluding(toml_parsing: true) unless deps.any_toml_backend_available?
     config.filter_run_excluding(markdown_parsing: true) unless deps.any_markdown_backend_available?
     config.filter_run_excluding(native_parsing: true) unless deps.any_native_grammar_available?
@@ -907,7 +931,7 @@ RSpec.configure do |config|
   config.filter_run_excluding(not_truffleruby_engine: true) if deps.truffleruby?
 
   # Tree-sitter grammars - skip when running isolated backend tests
-  if blocked_backends.none?
+  unless isolated_test_mode
     config.filter_run_excluding(not_libtree_sitter: true) if deps.libtree_sitter_available?
     config.filter_run_excluding(not_bash_grammar: true) if deps.tree_sitter_bash_available?
     config.filter_run_excluding(not_toml_grammar: true) if deps.tree_sitter_toml_available?

data/lib/tree_haver/version.rb

@@ -10,7 +10,7 @@ module TreeHaver
     # Current version of the tree_haver gem
     #
     # @return [String] the version string (e.g., "3.0.0")
-    VERSION = "3.2.1"
+    VERSION = "3.2.3"
   end
 
   # Traditional location for VERSION constant

data/lib/tree_haver.rb

@@ -16,7 +16,7 @@ require_relative "tree_haver/version"
 #
 # == Backends
 #
-# Supports 10 backends:
+# Supports 9 backends:
 # - Tree-sitter: MRI (C), Rust, FFI, Java
 # - Native parsers: Prism (Ruby), Psych (YAML), Commonmarker (Markdown), Markly (GFM)
 # - Pure Ruby: Citrus (portable fallback)
@@ -266,6 +266,11 @@ module TreeHaver
   # Parser class for parsing source code into syntax trees
   autoload :Parser, File.join(__dir__, "tree_haver", "parser")
 
+  # Native tree-sitter backends that support loading shared libraries (.so files)
+  # These backends wrap the tree-sitter C library via various bindings.
+  # Pure Ruby backends (Citrus, Prism, Psych, Commonmarker, Markly) are excluded.
+  NATIVE_BACKENDS = %i[mri rust ffi java].freeze
+
   # Get the current backend selection
   #
   # @return [Symbol] one of :auto, :mri, :rust, :ffi, :java, or :citrus
@@ -590,11 +595,6 @@ module TreeHaver
       mod
     end
 
-    # Native tree-sitter backends that support loading shared libraries (.so files)
-    # These backends wrap the tree-sitter C library via various bindings.
-    # Pure Ruby backends (Citrus, Prism, Psych, Commonmarker, Markly) are excluded.
-    NATIVE_BACKENDS = %i[mri rust ffi java].freeze
-
     # Resolve a native tree-sitter backend module (for from_library)
     #
     # This method is similar to resolve_backend_module but ONLY considers
@@ -836,114 +836,107 @@ module TreeHaver
 
     # Create a parser configured for a specific language
     #
-    # This is the recommended high-level API for creating a parser. It handles:
-    # 1. Checking if the language is already registered
-    # 2. Auto-discovering tree-sitter grammar via GrammarFinder
-    # 3. Falling back to Citrus grammar if tree-sitter is unavailable
-    # 4. Creating and configuring the parser
+    # Respects the effective backend setting (via TREE_HAVER_BACKEND env var,
+    # TreeHaver.backend=, or with_backend block).
     #
     # @param language_name [Symbol, String] the language to parse (e.g., :toml, :json, :bash)
     # @param library_path [String, nil] optional explicit path to tree-sitter grammar library
     # @param symbol [String, nil] optional tree-sitter symbol name (defaults to "tree_sitter_<name>")
     # @param citrus_config [Hash, nil] optional Citrus fallback configuration
-    # @option citrus_config [String] :gem_name gem name for the Citrus grammar
-    # @option citrus_config [String] :grammar_const fully qualified constant name for grammar module
     # @return [TreeHaver::Parser] configured parser with language set
     # @raise [TreeHaver::NotAvailable] if no parser backend is available for the language
     #
     # @example Basic usage (auto-discovers grammar)
     #   parser = TreeHaver.parser_for(:toml)
-    #   tree = parser.parse("[package]\nname = \"my-app\"")
     #
-    # @example With explicit library path
-    #   parser = TreeHaver.parser_for(:toml, library_path: "/custom/path/libtree-sitter-toml.so")
-    #
-    # @example With Citrus fallback configuration
-    #   parser = TreeHaver.parser_for(:toml,
-    #     citrus_config: { gem_name: "toml-rb", grammar_const: "TomlRB::Document" }
-    #   )
+    # @example Force Citrus backend
+    #   TreeHaver.with_backend(:citrus) { TreeHaver.parser_for(:toml) }
     def parser_for(language_name, library_path: nil, symbol: nil, citrus_config: nil)
       name = language_name.to_sym
       symbol ||= "tree_sitter_#{name}"
+      requested = effective_backend
 
-      # Step 1: Try to get the language (may already be registered)
-      language = begin
-        # Check if already registered and loadable
-        if registered_language(name)
-          Language.public_send(name, path: library_path, symbol: symbol)
-        end
-      rescue NotAvailable, ArgumentError, LoadError
-        nil
-      end
+      # Determine which backends to try based on effective_backend
+      try_tree_sitter = (requested == :auto) || NATIVE_BACKENDS.include?(requested)
+      try_citrus = (requested == :auto) || (requested == :citrus)
 
-      # Step 2: If not registered, try GrammarFinder for tree-sitter
-      unless language
-        # Principle of Least Surprise: If user provides an explicit path,
-        # it MUST exist. Don't silently fall back to auto-discovery.
-        if library_path && !library_path.empty?
-          unless File.exist?(library_path)
-            raise NotAvailable,
-              "Specified parser path does not exist: #{library_path}"
-          end
-          begin
-            register_language(name, path: library_path, symbol: symbol)
-            language = Language.public_send(name)
-          rescue NotAvailable, ArgumentError, LoadError => e
-            # Re-raise with more context since user explicitly provided this path
-            raise NotAvailable,
-              "Failed to load parser from specified path #{library_path}: #{e.message}"
-          end
-        else
-          # Auto-discover via GrammarFinder (no explicit path provided)
-          begin
-            finder = GrammarFinder.new(name)
-            if finder.available?
-              finder.register!
-              language = Language.public_send(name)
-            end
-          rescue NotAvailable, ArgumentError, LoadError
-            language = nil
-          end
-        end
-      end
+      language = nil
 
-      # Step 3: Try Citrus fallback if tree-sitter failed
-      unless language
-        # Use explicit config, or fall back to built-in defaults for known languages
-        citrus_config ||= CITRUS_DEFAULTS[name] || {}
-
-        # Only attempt if we have the required configuration
-        if citrus_config[:gem_name] && citrus_config[:grammar_const]
-          begin
-            citrus_finder = CitrusGrammarFinder.new(
-              language: name,
-              gem_name: citrus_config[:gem_name],
-              grammar_const: citrus_config[:grammar_const],
-              require_path: citrus_config[:require_path],
-            )
-            if citrus_finder.available?
-              citrus_finder.register!
-              language = Language.public_send(name)
-            end
-          rescue NotAvailable, ArgumentError, LoadError, NameError, TypeError
-            language = nil
-          end
-        end
+      # Try tree-sitter if applicable
+      if try_tree_sitter && !language
+        language = load_tree_sitter_language(name, library_path: library_path, symbol: symbol)
       end
 
-      # Step 4: Raise if nothing worked
-      unless language
-        raise NotAvailable,
-          "No parser available for #{name}. " \
-            "Install tree-sitter-#{name} or the appropriate Ruby gem. " \
-            "Set TREE_SITTER_#{name.to_s.upcase}_PATH for custom grammar location."
+      # Try Citrus if applicable
+      if try_citrus && !language
+        language = load_citrus_language(name, citrus_config: citrus_config)
       end
 
-      # Step 5: Create and configure parser
+      # Raise if nothing worked
+      raise NotAvailable, "No parser available for #{name}. " \
+        "Install tree-sitter-#{name} or configure a Citrus grammar." unless language
+
+      # Create and configure parser
       parser = Parser.new
       parser.language = language
       parser
     end
+
+    private
+
+    # Load a tree-sitter language, either from registry or via auto-discovery
+    # @return [Language, nil]
+    # @raise [NotAvailable] if explicit library_path is provided but doesn't exist or can't load
+    def load_tree_sitter_language(name, library_path: nil, symbol: nil)
+      # If explicit path provided, it must work - don't swallow errors
+      if library_path && !library_path.empty?
+        raise NotAvailable, "Specified parser path does not exist: #{library_path}" unless File.exist?(library_path)
+        register_language(name, path: library_path, symbol: symbol)
+        return Language.public_send(name)
+      end
+
+      # Auto-discovery: errors are acceptable, just return nil
+      begin
+        # Try already-registered tree-sitter language (not Citrus)
+        # But only if the registered path actually exists - ignore stale/test registrations
+        registration = registered_language(name)
+        ts_reg = registration&.dig(:tree_sitter)
+        if ts_reg && ts_reg[:path] && File.exist?(ts_reg[:path])
+          return Language.public_send(name, symbol: symbol)
+        end
+
+        # Auto-discover via GrammarFinder
+        finder = GrammarFinder.new(name)
+        if finder.available?
+          finder.register!
+          return Language.public_send(name)
+        end
+      rescue NotAvailable, ArgumentError, LoadError
+        # Auto-discovery failed, that's okay
+      end
+
+      nil
+    end
+
+    # Load a Citrus language from configuration or defaults
+    # @return [Language, nil]
+    def load_citrus_language(name, citrus_config: nil)
+      config = citrus_config || CITRUS_DEFAULTS[name] || {}
+      return unless config[:gem_name] && config[:grammar_const]
+
+      finder = CitrusGrammarFinder.new(
+        language: name,
+        gem_name: config[:gem_name],
+        grammar_const: config[:grammar_const],
+        require_path: config[:require_path],
+      )
+      return unless finder.available?
+
+      finder.register!
+      Language.public_send(name)
+    rescue NotAvailable, ArgumentError, LoadError, NameError, TypeError
+      nil
+    end
   end
 
   # Language and Parser classes have been moved to separate files:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tree_haver
 version: !ruby/object:Gem::Version
-  version: 3.2.1
+  version: 3.2.3
 platform: ruby
 authors:
 - Peter H. Boling
@@ -292,10 +292,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://tree-haver.galtzo.com/
-  source_code_uri: https://github.com/kettle-rb/tree_haver/tree/v3.2.1
-  changelog_uri: https://github.com/kettle-rb/tree_haver/blob/v3.2.1/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-rb/tree_haver/tree/v3.2.3
+  changelog_uri: https://github.com/kettle-rb/tree_haver/blob/v3.2.3/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-rb/tree_haver/issues
-  documentation_uri: https://www.rubydoc.info/gems/tree_haver/3.2.1
+  documentation_uri: https://www.rubydoc.info/gems/tree_haver/3.2.3
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/kettle-rb/tree_haver/wiki
   news_uri: https://www.railsbling.com/tags/tree_haver