tree_haver 4.0.4 → 4.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccd582c370b8637334816c198f3db0a63bf88ad68bbdf2c801d3966547d0ec8a
-  data.tar.gz: 0e42adbd1e9502a8f9c8517b21688a65c4aa8f5320b49175bbf41c67a631c5a2
+  metadata.gz: a3f6764cb2c0399f4255cc4536745156cd8391fa1818b9b84db9d0b39ca17fa9
+  data.tar.gz: d9e12364a4480307b8cd8a7ca0315bbeba7764c6bfe20747b3b8ff792e9fe2e7
 SHA512:
-  metadata.gz: 6ebd60f2b31c8ef09b5f3a12a3a77b58ca6a789b3d7b6d41ce8801aa7aa771cd8e02733206bee70cd41c0af78d213e4471f3cd5f28e3580db49ca37a08a31c00
-  data.tar.gz: 776084c8a3673c5ff1039ac1f384e6b6592b9e151a4e51d27b96002fc17e4e10107be85218365458ce9e0df283ae853d82d25c3a1b3c07ac60e3435c477485af
+  metadata.gz: 6a95af29f397cea98bc29a93885f9285637ae82469417b62c981629d21861f5b64560ca0e2c21b0405abdc541d04b39f6c1848928273b82679ba3f169f885549
+  data.tar.gz: bbd048585aed007eed86bdd117b18cff1e72e378fd20bbc07a252b6095ab38d4c5c9eb83fc572c21bcd07e515b2ad1bfae50f9705b75f69f4d955ecf65d4b844

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-# Changelog
+ed# Changelog
 
 [![SemVer 2.0.0][📌semver-img]][📌semver] [![Keep-A-Changelog 1.0.0][📗keep-changelog-img]][📗keep-changelog]
 
@@ -30,6 +30,52 @@ Please file a bug if you notice a violation of semantic versioning.
 
 ### Security
 
+## [4.0.5] - 2026-01-09
+
+- TAG: [v4.0.5][4.0.5t]
+- COVERAGE: 93.50% -- 2058/2201 lines in 28 files
+- BRANCH COVERAGE: 81.11% -- 803/990 branches in 28 files
+- 95.60% documented
+
+### Added
+
+- **FFI Backend**: Added `child_by_field_name` method to `TreeHaver::Backends::FFI::Node`
+  - Enables field-based child access using tree-sitter's `ts_node_child_by_field_name` C API
+  - Works with all grammars (JSON, JSONC, TOML, Bash, etc.) that define field names
+  - Fixes compatibility issues with json-merge, jsonc-merge, and other gems that use field access
+  - Example: `pair.child_by_field_name("key")` returns the key node from a JSON pair
+- **RSpec Dependency Tags**: Added `compute_blocked_backends` method
+  - Determines blocked backends from `TREE_HAVER_BACKEND` env and ARGV `--tag` options
+  - Called by `summary` when `@blocked_backends` isn't set yet (before RSpec.configure runs)
+  - Fixes issue where gem-specific `before(:suite)` hooks could load blocked backends
+- **RSpec Dependency Tags**: Added `LD_LIBRARY_PATH` and `DYLD_LIBRARY_PATH` to `env_summary`
+  - These library paths are relevant for tree-sitter shared library loading
+  - Useful for debugging grammar loading issues
+- **RSpec Dependency Tags**: Added `TREE_SITTER_RBS_PATH` to `env_summary`
+
+### Changed
+
+- **Language#method_missing**: Simplified error handling in `Language#method_missing`
+  - Removed unreachable rescue block for `FFI::NotFoundError`
+  - `FFI::NotFoundError` inherits from `LoadError`, so it's already caught by the prior rescue clause
+  - Reduces code complexity without changing behavior
+- **Parser#initialize**: Simplified error handling in `Parser#initialize`
+  - Same fix as Language - removed unreachable `FFI::NotFoundError` handling
+  - Added comment noting that `FFI::NotFoundError` inherits from `LoadError`
+- **FFI Backend Native#try_load!**: Removed redundant `FFI::NotFoundError` from rescue clause
+  - Only rescues `LoadError` now with comment explaining inheritance
+- **GrammarFinder.tree_sitter_runtime_usable?**: Removed redundant `StandardError` rescue clause
+  - `LoadError` already catches `FFI::NotFoundError`
+  - Added comment explaining the inheritance relationship
+
+### Fixed
+
+- **Test Isolation**: Fixed state leakage in `language_registry_spec.rb`
+  - Tests were registering real language names (`:toml`, `:json`, `:yaml`) with fake paths
+  - These registrations persisted and polluted other tests that expected real grammar paths
+  - Changed all tests to use unique test-only language names (prefixed with `test_lang_`)
+  - Fixes 2 spec failures when running all tests together (`TreeHaver::Tree#edit` specs)
+
 ## [4.0.4] - 2026-01-09
 
 - TAG: [v4.0.4][4.0.4t]
@@ -1024,7 +1070,9 @@ 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/v4.0.4...HEAD
+[Unreleased]: https://github.com/kettle-rb/tree_haver/compare/v4.0.5...HEAD
+[4.0.5]: https://github.com/kettle-rb/tree_haver/compare/v4.0.4...v4.0.5
+[4.0.5t]: https://github.com/kettle-rb/tree_haver/releases/tag/v4.0.5
 [4.0.4]: https://github.com/kettle-rb/tree_haver/compare/v4.0.3...v4.0.4
 [4.0.4t]: https://github.com/kettle-rb/tree_haver/releases/tag/v4.0.4
 [4.0.3]: https://github.com/kettle-rb/tree_haver/compare/v4.0.2...v4.0.3

data/README.md

@@ -2182,7 +2182,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.134-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-2.201-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/backends/ffi.rb

@@ -236,7 +236,8 @@ module TreeHaver
               ffi_lib(name)
               lib_loaded = true
               break
-            rescue ::FFI::NotFoundError, LoadError => e
+            rescue LoadError => e
+              # Note: FFI::NotFoundError inherits from LoadError, so it's caught here too
               last_error = e
             end
 
@@ -267,6 +268,7 @@ module TreeHaver
             attach_function(:ts_node_type, [:ts_node], :string)
             attach_function(:ts_node_child_count, [:ts_node], :uint32)
             attach_function(:ts_node_child, [:ts_node, :uint32], :ts_node)
+            attach_function(:ts_node_child_by_field_name, [:ts_node, :string, :uint32], :ts_node)
             attach_function(:ts_node_start_byte, [:ts_node], :uint32)
             attach_function(:ts_node_end_byte, [:ts_node], :uint32)
             attach_function(:ts_node_start_point, [:ts_node], :ts_point)
@@ -276,6 +278,21 @@ module TreeHaver
             attach_function(:ts_node_is_missing, [:ts_node], :bool)
             attach_function(:ts_node_has_error, [:ts_node], :bool)
 
+            # Node navigation functions
+            attach_function(:ts_node_parent, [:ts_node], :ts_node)
+            attach_function(:ts_node_next_sibling, [:ts_node], :ts_node)
+            attach_function(:ts_node_prev_sibling, [:ts_node], :ts_node)
+            attach_function(:ts_node_next_named_sibling, [:ts_node], :ts_node)
+            attach_function(:ts_node_prev_named_sibling, [:ts_node], :ts_node)
+            attach_function(:ts_node_named_child, [:ts_node, :uint32], :ts_node)
+            attach_function(:ts_node_named_child_count, [:ts_node], :uint32)
+
+            # Descendant lookup functions
+            attach_function(:ts_node_descendant_for_byte_range, [:ts_node, :uint32, :uint32], :ts_node)
+            attach_function(:ts_node_descendant_for_point_range, [:ts_node, :ts_point, :ts_point], :ts_node)
+            attach_function(:ts_node_named_descendant_for_byte_range, [:ts_node, :uint32, :uint32], :ts_node)
+            attach_function(:ts_node_named_descendant_for_point_range, [:ts_node, :ts_point, :ts_point], :ts_node)
+
             # Only mark as fully loaded after all attach_function calls succeed
             @loaded = true
           end
@@ -663,6 +680,25 @@ module TreeHaver
           Node.new(child_node)
         end
 
+        # Get a child node by field name
+        #
+        # Tree-sitter grammars define named fields for certain child positions.
+        # For example, in JSON, a "pair" node has "key" and "value" fields.
+        #
+        # @param field_name [String] the field name to look up
+        # @return [Node, nil] the child node, or nil if no child has that field
+        # @example Get the key from a JSON pair
+        #   pair.child_by_field_name("key") #=> Node (type: "string")
+        #   pair.child_by_field_name("value") #=> Node (type: "string" or "number", etc.)
+        def child_by_field_name(field_name)
+          name = String(field_name)
+          child_node = Native.ts_node_child_by_field_name(@val, name, name.bytesize)
+          # ts_node_child_by_field_name returns a null node if field not found
+          return if Native.ts_node_is_null(child_node)
+
+          Node.new(child_node)
+        end
+
         # Get start byte offset
         #
         # @return [Integer]
@@ -718,6 +754,150 @@ module TreeHaver
           !!Native.ts_node_is_missing(@val)
         end
 
+        # Check if this is a named node
+        #
+        # Named nodes represent syntactic constructs (e.g., "pair", "object").
+        # Anonymous nodes represent syntax/punctuation (e.g., "{", ",").
+        #
+        # @return [Boolean] true if this is a named node
+        def named?
+          !!Native.ts_node_is_named(@val)
+        end
+
+        # Get the parent node
+        #
+        # @return [Node, nil] parent node or nil if this is the root
+        def parent
+          parent_node = Native.ts_node_parent(@val)
+          return if Native.ts_node_is_null(parent_node)
+
+          Node.new(parent_node)
+        end
+
+        # Get the next sibling node
+        #
+        # @return [Node, nil] next sibling or nil if none
+        def next_sibling
+          sibling = Native.ts_node_next_sibling(@val)
+          return if Native.ts_node_is_null(sibling)
+
+          Node.new(sibling)
+        end
+
+        # Get the previous sibling node
+        #
+        # @return [Node, nil] previous sibling or nil if none
+        def prev_sibling
+          sibling = Native.ts_node_prev_sibling(@val)
+          return if Native.ts_node_is_null(sibling)
+
+          Node.new(sibling)
+        end
+
+        # Get the next named sibling node
+        #
+        # @return [Node, nil] next named sibling or nil if none
+        def next_named_sibling
+          sibling = Native.ts_node_next_named_sibling(@val)
+          return if Native.ts_node_is_null(sibling)
+
+          Node.new(sibling)
+        end
+
+        # Get the previous named sibling node
+        #
+        # @return [Node, nil] previous named sibling or nil if none
+        def prev_named_sibling
+          sibling = Native.ts_node_prev_named_sibling(@val)
+          return if Native.ts_node_is_null(sibling)
+
+          Node.new(sibling)
+        end
+
+        # Get a named child by index
+        #
+        # @param index [Integer] named child index (0-based)
+        # @return [Node, nil] named child or nil if index out of bounds
+        def named_child(index)
+          return if index < 0 || index >= named_child_count
+
+          child_node = Native.ts_node_named_child(@val, index)
+          return if Native.ts_node_is_null(child_node)
+
+          Node.new(child_node)
+        end
+
+        # Get the count of named children
+        #
+        # @return [Integer] number of named children
+        def named_child_count
+          Native.ts_node_named_child_count(@val)
+        end
+
+        # Find the smallest descendant that spans the given byte range
+        #
+        # @param start_byte [Integer] start byte offset
+        # @param end_byte [Integer] end byte offset
+        # @return [Node, nil] descendant node or nil if not found
+        def descendant_for_byte_range(start_byte, end_byte)
+          node = Native.ts_node_descendant_for_byte_range(@val, start_byte, end_byte)
+          return if Native.ts_node_is_null(node)
+
+          Node.new(node)
+        end
+
+        # Find the smallest named descendant that spans the given byte range
+        #
+        # @param start_byte [Integer] start byte offset
+        # @param end_byte [Integer] end byte offset
+        # @return [Node, nil] named descendant node or nil if not found
+        def named_descendant_for_byte_range(start_byte, end_byte)
+          node = Native.ts_node_named_descendant_for_byte_range(@val, start_byte, end_byte)
+          return if Native.ts_node_is_null(node)
+
+          Node.new(node)
+        end
+
+        # Find the smallest descendant that spans the given point range
+        #
+        # @param start_point [TreeHaver::Point, Hash] start point with :row and :column
+        # @param end_point [TreeHaver::Point, Hash] end point with :row and :column
+        # @return [Node, nil] descendant node or nil if not found
+        def descendant_for_point_range(start_point, end_point)
+          start_pt = Native::TSPoint.new
+          start_pt[:row] = start_point.respond_to?(:row) ? start_point.row : start_point[:row]
+          start_pt[:column] = start_point.respond_to?(:column) ? start_point.column : start_point[:column]
+
+          end_pt = Native::TSPoint.new
+          end_pt[:row] = end_point.respond_to?(:row) ? end_point.row : end_point[:row]
+          end_pt[:column] = end_point.respond_to?(:column) ? end_point.column : end_point[:column]
+
+          node = Native.ts_node_descendant_for_point_range(@val, start_pt, end_pt)
+          return if Native.ts_node_is_null(node)
+
+          Node.new(node)
+        end
+
+        # Find the smallest named descendant that spans the given point range
+        #
+        # @param start_point [TreeHaver::Point, Hash] start point with :row and :column
+        # @param end_point [TreeHaver::Point, Hash] end point with :row and :column
+        # @return [Node, nil] named descendant node or nil if not found
+        def named_descendant_for_point_range(start_point, end_point)
+          start_pt = Native::TSPoint.new
+          start_pt[:row] = start_point.respond_to?(:row) ? start_point.row : start_point[:row]
+          start_pt[:column] = start_point.respond_to?(:column) ? start_point.column : start_point[:column]
+
+          end_pt = Native::TSPoint.new
+          end_pt[:row] = end_point.respond_to?(:row) ? end_point.row : end_point[:row]
+          end_pt[:column] = end_point.respond_to?(:column) ? end_point.column : end_point[:column]
+
+          node = Native.ts_node_named_descendant_for_point_range(@val, start_pt, end_pt)
+          return if Native.ts_node_is_null(node)
+
+          Node.new(node)
+        end
+
         # Iterate over child nodes
         #
         # @yieldparam child [Node] each child node

data/lib/tree_haver/grammar_finder.rb

@@ -271,9 +271,7 @@ module TreeHaver
           mod::Parser.new
           true
         rescue NoMethodError, LoadError, NotAvailable => _e
-          false
-        rescue StandardError => _e
-          # Catch FFI::NotFoundError and other errors when FFI is loaded
+          # Note: FFI::NotFoundError inherits from LoadError, so it's caught here too
           false
         end
       end

data/lib/tree_haver/language.rb

@@ -198,14 +198,8 @@ module TreeHaver
             return from_library(path, symbol: symbol, name: name)
           rescue NotAvailable, ArgumentError, LoadError => e
             # Tree-sitter failed to load - check for Citrus fallback
+            # Note: FFI::NotFoundError inherits from LoadError, so it's caught here too
             handle_tree_sitter_load_failure(e, all_backends)
-          rescue => e
-            # Also catch FFI::NotFoundError if FFI is loaded (can't reference directly as FFI may not exist)
-            if defined?(::FFI::NotFoundError) && e.is_a?(::FFI::NotFoundError)
-              handle_tree_sitter_load_failure(e, all_backends)
-            else
-              raise
-            end
           end
         end
 
@@ -237,7 +231,7 @@ module TreeHaver
       #
       # This handles cases where:
       # - The .so file doesn't exist or can't be loaded (NotAvailable, LoadError)
-      # - FFI can't find required symbols like ts_parser_new (FFI::NotFoundError)
+      # - FFI can't find required symbols like ts_parser_new (FFI::NotFoundError inherits from LoadError)
       # - Invalid arguments were provided (ArgumentError)
       #
       # Fallback to Citrus ONLY happens when:

data/lib/tree_haver/parser.rb

@@ -62,14 +62,8 @@ module TreeHaver
         @impl = mod::Parser.new
         @explicit_backend = backend  # Remember for introspection (always a Symbol or nil)
       rescue NoMethodError, LoadError => e
+        # Note: FFI::NotFoundError inherits from LoadError, so it's caught here too
         handle_parser_creation_failure(e, backend)
-      rescue => e
-        # Also catch FFI::NotFoundError if FFI is loaded (can't reference directly as FFI may not exist)
-        if defined?(::FFI::NotFoundError) && e.is_a?(::FFI::NotFoundError)
-          handle_parser_creation_failure(e, backend)
-        else
-          raise
-        end
       end
     end
 

data/lib/tree_haver/rspec/dependency_tags.rb

@@ -724,39 +724,92 @@ module TreeHaver
         # Summary and Reset
         # ============================================================
 
+        # Determine which backends are blocked based on environment and ARGV
+        #
+        # This replicates the logic from RSpec.configure to determine blocked
+        # backends BEFORE the RSpec.configure block has run. This is necessary
+        # because summary may be called in a before(:suite) hook that runs
+        # before the blocked_backends instance variable is set.
+        #
+        # @return [Set<Symbol>] set of blocked backend symbols
+        def compute_blocked_backends
+          blocked = Set.new
+
+          # Check TREE_HAVER_BACKEND environment variable
+          env_backend = ENV["TREE_HAVER_BACKEND"]
+          if env_backend && !env_backend.empty? && env_backend != "auto"
+            backend_sym = env_backend.to_sym
+            TreeHaver::Backends::BLOCKED_BY[backend_sym]&.each { |blocker| blocked << blocker }
+          end
+
+          # Check ARGV for --tag options that indicate isolated backend testing
+          ARGV.each_with_index do |arg, i|
+            tag_value = nil
+            if arg == "--tag" && ARGV[i + 1]
+              tag_str = ARGV[i + 1]
+              next if tag_str.start_with?("~")
+              tag_value = tag_str.to_sym
+            elsif arg.start_with?("--tag=")
+              tag_str = arg.sub("--tag=", "")
+              next if tag_str.start_with?("~")
+              tag_value = tag_str.to_sym
+            end
+
+            next unless tag_value
+
+            # Check for standard backend tags (e.g., :ffi_backend)
+            TreeHaver::Backends::BLOCKED_BY.each do |backend, blockers|
+              standard_tag = :"#{backend}_backend"
+              legacy_tag = :"#{backend}_backend_only"
+              if tag_value == standard_tag || tag_value == legacy_tag
+                blockers.each { |blocker| blocked << blocker }
+              end
+            end
+          end
+
+          blocked
+        end
+
         # Get a summary of available dependencies (for debugging)
         #
+        # This method respects blocked_backends to avoid loading backends
+        # that would conflict with isolated test modes (e.g., FFI-only tests).
+        #
         # @return [Hash{Symbol => Boolean}] map of dependency name to availability
         def summary
+          # Use stored blocked_backends if available, otherwise compute dynamically
+          blocked = @blocked_backends || compute_blocked_backends
+
           {
             # Backend selection from environment variables
             selected_backend: selected_backend,
             allowed_native_backends: allowed_native_backends,
             allowed_ruby_backends: allowed_ruby_backends,
-            # TreeHaver backends (*_backend)
-            ffi_backend: ffi_available?,
-            mri_backend: mri_backend_available?,
-            rust_backend: rust_backend_available?,
-            java_backend: java_backend_available?,
-            prism_backend: prism_available?,
-            psych_backend: psych_available?,
-            commonmarker_backend: commonmarker_available?,
-            markly_backend: markly_available?,
-            citrus_backend: citrus_available?,
-            rbs_backend: rbs_backend_available?,
+            # TreeHaver backends (*_backend) - skip blocked backends to avoid loading them
+            ffi_backend: blocked.include?(:ffi) ? :blocked : ffi_available?,
+            mri_backend: blocked.include?(:mri) ? :blocked : mri_backend_available?,
+            rust_backend: blocked.include?(:rust) ? :blocked : rust_backend_available?,
+            java_backend: blocked.include?(:java) ? :blocked : java_backend_available?,
+            prism_backend: blocked.include?(:prism) ? :blocked : prism_available?,
+            psych_backend: blocked.include?(:psych) ? :blocked : psych_available?,
+            commonmarker_backend: blocked.include?(:commonmarker) ? :blocked : commonmarker_available?,
+            markly_backend: blocked.include?(:markly) ? :blocked : markly_available?,
+            citrus_backend: blocked.include?(:citrus) ? :blocked : citrus_available?,
+            rbs_backend: blocked.include?(:rbs) ? :blocked : rbs_backend_available?,
             # Ruby engines (*_engine)
             ruby_engine: RUBY_ENGINE,
             mri_engine: mri?,
             jruby_engine: jruby?,
             truffleruby_engine: truffleruby?,
-            # Tree-sitter grammars (*_grammar)
+            # Tree-sitter grammars (*_grammar) - also respect blocked backends
+            # since grammar checks may load backends
             libtree_sitter: libtree_sitter_available?,
-            bash_grammar: tree_sitter_bash_available?,
-            toml_grammar: tree_sitter_toml_available?,
-            json_grammar: tree_sitter_json_available?,
-            jsonc_grammar: tree_sitter_jsonc_available?,
-            rbs_grammar: tree_sitter_rbs_available?,
-            any_native_grammar: any_native_grammar_available?,
+            bash_grammar: blocked.include?(:mri) ? :blocked : tree_sitter_bash_available?,
+            toml_grammar: blocked.include?(:mri) ? :blocked : tree_sitter_toml_available?,
+            json_grammar: blocked.include?(:mri) ? :blocked : tree_sitter_json_available?,
+            jsonc_grammar: blocked.include?(:mri) ? :blocked : tree_sitter_jsonc_available?,
+            rbs_grammar: blocked.include?(:mri) ? :blocked : tree_sitter_rbs_available?,
+            any_native_grammar: blocked.include?(:mri) ? :blocked : any_native_grammar_available?,
             # Language parsing capabilities (*_parsing)
             toml_parsing: any_toml_backend_available?,
             markdown_parsing: any_markdown_backend_available?,
@@ -776,9 +829,13 @@ module TreeHaver
             "TREE_SITTER_TOML_PATH" => ENV["TREE_SITTER_TOML_PATH"],
             "TREE_SITTER_JSON_PATH" => ENV["TREE_SITTER_JSON_PATH"],
             "TREE_SITTER_JSONC_PATH" => ENV["TREE_SITTER_JSONC_PATH"],
+            "TREE_SITTER_RBS_PATH" => ENV["TREE_SITTER_RBS_PATH"],
             "TREE_SITTER_RUNTIME_LIB" => ENV["TREE_SITTER_RUNTIME_LIB"],
             "TREE_HAVER_BACKEND" => ENV["TREE_HAVER_BACKEND"],
             "TREE_HAVER_DEBUG" => ENV["TREE_HAVER_DEBUG"],
+            # Library paths used by tree-sitter shared libraries
+            "LD_LIBRARY_PATH" => ENV["LD_LIBRARY_PATH"],
+            "DYLD_LIBRARY_PATH" => ENV["DYLD_LIBRARY_PATH"],
           }
         end
 

data/lib/tree_haver/version.rb

@@ -10,7 +10,7 @@ module TreeHaver
     # Current version of the tree_haver gem
     #
     # @return [String] the version string
-    VERSION = "4.0.4"
+    VERSION = "4.0.5"
   end
 
   # Traditional location for VERSION constant

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tree_haver
 version: !ruby/object:Gem::Version
-  version: 4.0.4
+  version: 4.0.5
 platform: ruby
 authors:
 - Peter H. Boling
@@ -298,10 +298,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://tree-haver.galtzo.com/
-  source_code_uri: https://github.com/kettle-rb/tree_haver/tree/v4.0.4
-  changelog_uri: https://github.com/kettle-rb/tree_haver/blob/v4.0.4/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-rb/tree_haver/tree/v4.0.5
+  changelog_uri: https://github.com/kettle-rb/tree_haver/blob/v4.0.5/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-rb/tree_haver/issues
-  documentation_uri: https://www.rubydoc.info/gems/tree_haver/4.0.4
+  documentation_uri: https://www.rubydoc.info/gems/tree_haver/4.0.5
   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