tree_haver 5.0.5 → 7.1.0

data/lib/tree_haver/backends/psych.rb

@@ -28,19 +28,20 @@ module TreeHaver
       # @return [Boolean] true if psych is available
       class << self
         def available?
-          return @loaded if @load_attempted # rubocop:disable ThreadSafety/ClassInstanceVariable
-          @load_attempted = true # rubocop:disable ThreadSafety/ClassInstanceVariable
+          return @loaded if @load_attempted
+
+          @load_attempted = true
           begin
-            require "psych"
-            @loaded = true # rubocop:disable ThreadSafety/ClassInstanceVariable
+            require 'psych'
+            @loaded = true
           rescue LoadError
-            @loaded = false # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @loaded = false
           rescue StandardError
-            # :nocov: defensive code - StandardError during require is extremely rare
-            @loaded = false # rubocop:disable ThreadSafety/ClassInstanceVariable
-            # :nocov:
+            # simplecov:disable defensive code - StandardError during require is extremely rare
+            @loaded = false
+            # simplecov:enable
           end
-          @loaded # rubocop:disable ThreadSafety/ClassInstanceVariable
+          @loaded
         end
 
         # Reset the load state (primarily for testing)
@@ -48,8 +49,8 @@ module TreeHaver
         # @return [void]
         # @api private
         def reset!
-          @load_attempted = false # rubocop:disable ThreadSafety/ClassInstanceVariable
-          @loaded = false # rubocop:disable ThreadSafety/ClassInstanceVariable
+          @load_attempted = false
+          @loaded = false
         end
 
         # Get capabilities supported by this backend
@@ -57,6 +58,7 @@ module TreeHaver
         # @return [Hash{Symbol => Object}] capability map
         def capabilities
           return {} unless available?
+
           {
             backend: :psych,
             query: false,           # Psych doesn't have tree-sitter-style queries
@@ -65,6 +67,7 @@ module TreeHaver
             pure_ruby: false,       # Psych has native libyaml C extension
             yaml_only: true,        # Psych only parses YAML
             error_tolerant: false,  # Psych raises on syntax errors
+            comment_support: :none
           }
         end
       end
@@ -108,8 +111,8 @@ module TreeHaver
 
             unless lang_name == :yaml
               raise TreeHaver::NotAvailable,
-                "Psych backend only supports YAML, not #{lang_name}. " \
-                  "Use a tree-sitter backend for #{lang_name} support."
+                    "Psych backend only supports YAML, not #{lang_name}. " \
+                      "Use a tree-sitter backend for #{lang_name} support."
             end
 
             yaml
@@ -132,8 +135,9 @@ module TreeHaver
         # @return [Tree] Parsed tree
         # @raise [::Psych::SyntaxError] on syntax errors
         def parse(source)
-          raise "Language not set" unless language
-          Psych.available? or raise "Psych not available"
+          raise 'Language not set' unless language
+
+          Psych.available? or raise 'Psych not available'
 
           ast = ::Psych.parse_stream(source)
           Tree.new(ast, source)
@@ -193,7 +197,7 @@ module TreeHaver
         #
         # @return [String] Node type
         def type
-          inner_node.class.name.split("::").last.downcase
+          inner_node.class.name.split('::').last.downcase
         end
 
         # Alias for type (API compatibility)
@@ -336,7 +340,7 @@ module TreeHaver
         #
         # @return [String] Extracted text
         def extract_text_from_location
-          return "" unless inner_node.respond_to?(:start_line) && inner_node.respond_to?(:end_line)
+          return '' unless inner_node.respond_to?(:start_line) && inner_node.respond_to?(:end_line)
 
           start_ln = inner_node.start_line || 0
           end_ln = inner_node.end_line || start_ln
@@ -344,19 +348,19 @@ module TreeHaver
           end_col = inner_node.end_column || 0
 
           if start_ln == end_ln
-            line = lines[start_ln] || ""
-            line[start_col...end_col] || ""
+            line = lines[start_ln] || ''
+            line[start_col...end_col] || ''
           else
             result = []
             (start_ln..end_ln).each do |ln|
-              line = lines[ln] || ""
+              line = lines[ln] || ''
               result << if ln == start_ln
-                line[start_col..]
-              elsif ln == end_ln
-                line[0...end_col]
-              else
-                line
-              end
+                          line[start_col..]
+                        elsif ln == end_ln
+                          line[0...end_col]
+                        else
+                          line
+                        end
             end
             result.compact.join
           end

data/lib/tree_haver/backends/rust.rb

@@ -50,23 +50,24 @@ module TreeHaver
       #   end
       class << self
         def available?
-          return @loaded if @load_attempted # rubocop:disable ThreadSafety/ClassInstanceVariable
-          @load_attempted = true # rubocop:disable ThreadSafety/ClassInstanceVariable
+          return @loaded if @load_attempted
+
+          @load_attempted = true
           begin
             # tree_stump uses magnus which requires MRI's C API
             # It doesn't work on JRuby or TruffleRuby
-            if RUBY_ENGINE == "ruby"
-              require "tree_stump"
-              @loaded = true # rubocop:disable ThreadSafety/ClassInstanceVariable
+            if RUBY_ENGINE == 'ruby'
+              require 'tree_stump'
+              @loaded = true
             else
-              @loaded = false # rubocop:disable ThreadSafety/ClassInstanceVariable
+              @loaded = false
             end
           rescue LoadError
-            @loaded = false # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @loaded = false
           rescue StandardError
-            @loaded = false # rubocop:disable ThreadSafety/ClassInstanceVariable
+            @loaded = false
           end
-          @loaded # rubocop:disable ThreadSafety/ClassInstanceVariable
+          @loaded
         end
 
         # Reset the load state (primarily for testing)
@@ -74,8 +75,8 @@ module TreeHaver
         # @return [void]
         # @api private
         def reset!
-          @load_attempted = false # rubocop:disable ThreadSafety/ClassInstanceVariable
-          @loaded = false # rubocop:disable ThreadSafety/ClassInstanceVariable
+          @load_attempted = false
+          @loaded = false
         end
 
         # Get capabilities supported by this backend
@@ -83,14 +84,16 @@ module TreeHaver
         # @return [Hash{Symbol => Object}] capability map
         # @example
         #   TreeHaver::Backends::Rust.capabilities
-        #   # => { backend: :rust, query: true, bytes_field: true, incremental: false }
+        #   # => { backend: :rust, query: true, bytes_field: true, incremental: false, comment_support: :nodes_only }
         def capabilities
           return {} unless available?
+
           {
             backend: :rust,
             query: true,
             bytes_field: true,
-            incremental: false,  # TreeStump doesn't currently expose incremental parsing to Ruby
+            incremental: false, # TreeStump doesn't currently expose incremental parsing to Ruby
+            comment_support: :nodes_only
           }
         end
       end
@@ -145,7 +148,7 @@ module TreeHaver
         end
 
         # Alias eql? to ==
-        alias_method :eql?, :==
+        alias eql? ==
 
         # Load a language from a shared library path
         #
@@ -158,7 +161,7 @@ module TreeHaver
         #   lang = TreeHaver::Backends::Rust::Language.from_library("/usr/local/lib/libtree-sitter-toml.so")
         class << self
           def from_library(path, symbol: nil, name: nil) # rubocop:disable Lint/UnusedMethodArgument
-            raise TreeHaver::NotAvailable, "tree_stump not available" unless Rust.available?
+            raise TreeHaver::NotAvailable, 'tree_stump not available' unless Rust.available?
 
             # Validate the path exists before calling register_lang to provide a clear error
             raise TreeHaver::NotAvailable, "Language library not found: #{path}" unless File.exist?(path)
@@ -174,7 +177,7 @@ module TreeHaver
           end
 
           # Backward-compatible alias for from_library
-          alias_method :from_path, :from_library
+          alias from_path from_library
         end
       end
 
@@ -186,7 +189,8 @@ module TreeHaver
         #
         # @raise [TreeHaver::NotAvailable] if tree_stump is not available
         def initialize
-          raise TreeHaver::NotAvailable, "tree_stump not available" unless Rust.available?
+          raise TreeHaver::NotAvailable, 'tree_stump not available' unless Rust.available?
+
           @parser = ::TreeStump::Parser.new
         end
 

data/lib/tree_haver/backends/tslp.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module TreeHaver
+  module Backends
+    # TSLP backend using tree_sitter_language_pack's on-demand parser API.
+    #
+    # This backend intentionally requires the real parser API. The language-pack
+    # process API is not a TreeHaver parser backend and must not be used as a
+    # merge-gem integration surface.
+    module Tslp
+      @load_attempted = false
+      @loaded = false
+      @unavailable_reason = nil
+      @language_availability = {}
+      @language_unavailable_reasons = {}
+      PARSER_SMOKE_SOURCES = {
+        'json' => '{}',
+        'json5' => '{}',
+        'bash' => "echo tree_haver\n",
+        'go' => "package main\nfunc main() {}\n",
+        'html' => "<!doctype html>\n<title>TreeHaver</title>\n",
+        'markdown' => "# TreeHaver\n",
+        'ruby' => "class TreeHaverSmoke\nend\n",
+        'rust' => "fn main() {}\n",
+        'typescript' => "export const treeHaver = true;\n",
+        'toml' => "title = \"tree_haver\"\n",
+        'yaml' => "tree_haver: true\n"
+      }.freeze
+      DEFAULT_PARSER_SMOKE_SOURCE = ''
+
+      class << self
+        attr_reader :unavailable_reason
+
+        def available?
+          return @loaded if @load_attempted
+
+          @load_attempted = true
+          begin
+            require 'tree_sitter_language_pack' unless defined?(::TreeSitterLanguagePack)
+            @loaded = parser_api_available?
+            if !@loaded && @unavailable_reason.to_s.empty?
+              @unavailable_reason = 'tree_sitter_language_pack parser API is not exposed'
+            end
+          rescue LoadError => e
+            @loaded = false
+            @unavailable_reason = e.message
+          rescue StandardError => e
+            @loaded = false
+            @unavailable_reason = e.message
+          end
+          @loaded
+        end
+
+        def reset!
+          @load_attempted = false
+          @loaded = false
+          @unavailable_reason = nil
+          @language_availability = {}
+          @language_unavailable_reasons = {}
+        end
+
+        def capabilities
+          return {} unless available?
+
+          {
+            backend: :tslp,
+            query: false,
+            bytes_field: true,
+            incremental: false,
+            comment_support: :nodes_only,
+            language_pack: true
+          }
+        end
+
+        def parser_available_for?(language_name)
+          return false unless available?
+
+          name = language_name.to_s
+          return @language_availability.fetch(name) if @language_availability.key?(name)
+
+          @language_availability[name] = smoke_parse_language(name)
+          @language_unavailable_reasons[name] = @unavailable_reason unless @language_availability.fetch(name)
+          @language_availability.fetch(name)
+        rescue StandardError => e
+          @unavailable_reason = e.message
+          @language_unavailable_reasons[language_name.to_s] = e.message
+          false
+        end
+
+        private
+
+        def parser_api_available?
+          return false unless ::TreeSitterLanguagePack.respond_to?(:get_parser)
+          return false unless defined?(::TreeSitterLanguagePack::Parser)
+          return false unless ::TreeSitterLanguagePack::Parser.instance_methods.include?(:parse)
+
+          parser_api_smoke_test
+        rescue StandardError => e
+          @unavailable_reason = e.message
+          false
+        end
+
+        def parser_api_smoke_test
+          language_name, source = PARSER_SMOKE_SOURCES.find do |name, _smoke_source|
+            !::TreeSitterLanguagePack.respond_to?(:has_language) ||
+              ::TreeSitterLanguagePack.has_language(name)
+          end
+          return false unless language_name
+
+          smoke_parse_language(language_name, source: source)
+        end
+
+        def smoke_parse_language(language_name, source: smoke_source_for(language_name))
+          name = language_name.to_s
+          if ::TreeSitterLanguagePack.respond_to?(:has_language) &&
+             !::TreeSitterLanguagePack.has_language(name)
+            @unavailable_reason = "tree_sitter_language_pack does not publish #{name}"
+            return false
+          end
+
+          parser = ::TreeSitterLanguagePack.get_parser(name)
+          return false unless parser
+
+          tree = parser.parse(source)
+          return false unless tree&.respond_to?(:root_node)
+
+          root = tree.root_node
+          root && !node_has_error?(root)
+        end
+
+        def smoke_source_for(language_name)
+          PARSER_SMOKE_SOURCES.fetch(language_name.to_s, DEFAULT_PARSER_SMOKE_SOURCE)
+        end
+
+        def node_has_error?(node)
+          if node.respond_to?(:has_error)
+            node.has_error
+          elsif node.respond_to?(:has_error?)
+            node.has_error?
+          else
+            false
+          end
+        end
+      end
+
+      class Language < TreeHaver::Base::Language
+        def initialize(name)
+          super(name.to_sym, backend: :tslp, options: {})
+        end
+
+        class << self
+          def from_library(_path = nil, symbol: nil, name: nil) # rubocop:disable Lint/UnusedMethodArgument
+            new(name || :unknown)
+          end
+        end
+      end
+
+      class Parser < TreeHaver::Base::Parser
+        def parse(source)
+          raise TreeHaver::NotAvailable, unavailable_message unless Tslp.available?
+          raise TreeHaver::NotAvailable, 'TSLP language is not set' unless language
+
+          parser = ::TreeSitterLanguagePack.get_parser(language.name.to_s)
+          raise TreeHaver::NotAvailable, "TSLP did not return a parser for #{language.name}" unless parser
+
+          raw_tree = parser.parse(source)
+          raise TreeHaver::NotAvailable, "TSLP did not return a parse tree for #{language.name}" unless raw_tree
+
+          Tree.new(raw_tree, source: source, language: language.name)
+        end
+
+        private
+
+        def unavailable_message
+          reason = Tslp.unavailable_reason
+          detail = reason.to_s.empty? ? 'unknown reason' : reason
+          "tree_sitter_language_pack parser API is unavailable: #{detail}"
+        end
+      end
+
+      class Tree < TreeHaver::Base::Tree
+        attr_reader :language
+
+        def initialize(inner_tree = nil, source: nil, lines: nil, language: nil)
+          super(inner_tree, source: source, lines: lines)
+          @language = language.to_s
+        end
+
+        def root_node
+          Node.new(inner_tree.root_node, source: source, lines: lines, language: language)
+        end
+      end
+
+      class Node < TreeHaver::Base::Node
+        NODE_TYPE_ALIASES = {
+          'json5' => {
+            'file' => 'document',
+            'member' => 'pair'
+          }
+        }.freeze
+
+        attr_reader :language
+
+        def initialize(node, source: nil, lines: nil, language: nil)
+          super(node, source: source, lines: lines)
+          @language = language.to_s
+        end
+
+        def type
+          NODE_TYPE_ALIASES.fetch(language, {}).fetch(native_type, native_type)
+        end
+
+        def native_type
+          inner_node.kind
+        end
+
+        def start_byte
+          inner_node.start_byte
+        end
+
+        def end_byte
+          inner_node.end_byte
+        end
+
+        def start_point
+          point = inner_node.start_position
+          { row: point.row, column: point.column }
+        end
+
+        def end_point
+          point = inner_node.end_position
+          { row: point.row, column: point.column }
+        end
+
+        def children
+          Array.new(inner_node.child_count) do |index|
+            child = inner_node.child(index)
+            child && self.class.new(child, source: source, lines: lines, language: language)
+          end.compact
+        end
+
+        def child_by_field_name(name)
+          child = inner_node.child_by_field_name(name.to_s) if inner_node.respond_to?(:child_by_field_name)
+          child && self.class.new(child, source: source, lines: lines, language: language)
+        end
+
+        def parent
+          parent = inner_node.parent if inner_node.respond_to?(:parent)
+          parent && self.class.new(parent, source: source, lines: lines, language: language)
+        end
+
+        def named?
+          inner_node.is_named
+        end
+
+        def has_error?
+          inner_node.has_error
+        end
+
+        def error?
+          inner_node.is_error
+        end
+
+        def missing?
+          inner_node.is_missing
+        end
+
+        def extra?
+          inner_node.is_extra
+        end
+      end
+    end
+  end
+end