tree_haver 1.0.0 → 3.0.0

data/sig/tree_haver/backends.rbs

@@ -47,7 +47,7 @@ module TreeHaver
         # Get list of candidate library names
         def self.lib_candidates: () -> Array[String]
 
-        # Load the Tree-sitter runtime library
+        # Load the tree-sitter runtime library
         def self.try_load!: () -> void
 
         # Check if the library is loaded
@@ -281,5 +281,72 @@ module TreeHaver
       class Node
       end
     end
+
+    # Citrus backend using pure Ruby Citrus parser
+    module Citrus
+      # Check if the Citrus backend is available
+      def self.available?: () -> bool
+
+      # Reset the load state (for testing)
+      def self.reset!: () -> void
+
+      # Get capabilities supported by this backend
+      def self.capabilities: () -> Hash[Symbol, untyped]
+
+      class Language
+        attr_reader grammar_module: untyped
+
+        # Create a new language from a Citrus grammar module
+        def initialize: (untyped grammar_module) -> void
+      end
+
+      class Parser
+        # Create a new parser instance
+        def initialize: () -> void
+
+        # Set the grammar for this parser
+        def language=: (Language | untyped grammar) -> (Language | untyped)
+
+        # Parse source code
+        def parse: (String source) -> untyped
+
+        private
+
+        @grammar: untyped
+      end
+
+      class Tree
+        attr_reader root_match: untyped
+        attr_reader source: String
+
+        def initialize: (untyped root_match, String source) -> void
+
+        def root_node: () -> Node
+      end
+
+      class Node
+        attr_reader match: untyped
+        attr_reader source: String
+
+        def initialize: (untyped match, String source) -> void
+
+        def type: () -> String
+
+        def start_byte: () -> Integer
+
+        def end_byte: () -> Integer
+
+        def text: () -> String
+
+        def child_count: () -> Integer
+
+        def child: (Integer index) -> Node?
+
+        def children: () -> Array[Node]
+
+        def each: () { (Node) -> void } -> void
+                | () -> Enumerator[Node, nil]
+      end
+    end
   end
 end

data/sig/tree_haver/path_validator.rbs

@@ -26,6 +26,7 @@ module TreeHaver
     def self.sanitize_language_name: (String | Symbol | nil name) -> Symbol?
     def self.validation_errors: (String? path) -> Array[String]
     def self.windows_absolute_path?: (String path) -> bool
+    def self.has_valid_extension?: (String path) -> bool
   end
 end
 

data/sig/tree_haver.rbs

@@ -1,6 +1,6 @@
 # Type definitions for TreeHaver
 #
-# TreeHaver is a cross-Ruby adapter for the Tree-sitter parsing library
+# TreeHaver is a cross-Ruby adapter for the tree-sitter parsing library
 
 module TreeHaver
   VERSION: String
@@ -44,7 +44,7 @@ module TreeHaver
   # Fetch a registered language entry
   def self.registered_language: (Symbol | String name) -> Hash[Symbol, String?]?
 
-  # Represents a Tree-sitter language grammar
+  # Represents a tree-sitter language grammar
   class Language
     # Load a language grammar from a shared library
     def self.from_library: (String path, ?symbol: String?, ?name: String?) -> Language
@@ -57,7 +57,7 @@ module TreeHaver
     def self.respond_to_missing?: (Symbol method_name, ?bool include_private) -> bool
   end
 
-  # Represents a Tree-sitter parser instance
+  # Represents a tree-sitter parser instance
   class Parser
     # Create a new parser instance
     def initialize: () -> void
@@ -68,6 +68,9 @@ module TreeHaver
     # Parse source code into a syntax tree
     def parse: (String source) -> Tree
 
+    # Parse with optional incremental parsing support
+    def parse_string: (Tree? old_tree, String source) -> Tree
+
     private
 
     @impl: untyped
@@ -75,30 +78,113 @@ module TreeHaver
 
   # Represents a parsed syntax tree
   class Tree
+    attr_reader inner_tree: untyped
+    attr_reader source: String?
+
     # Get the root node of the syntax tree
-    def root_node: () -> Node
+    def root_node: () -> Node?
 
-    private
+    # Edit the tree for incremental parsing
+    def edit: (
+      start_byte: Integer,
+      old_end_byte: Integer,
+      new_end_byte: Integer,
+      start_point: Hash[Symbol, Integer],
+      old_end_point: Hash[Symbol, Integer],
+      new_end_point: Hash[Symbol, Integer]
+    ) -> void
 
-    def initialize: (untyped impl) -> void
+    # Check if the current backend supports incremental parsing
+    def supports_editing?: () -> bool
 
-    @impl: untyped
+    # String representation
+    def inspect: () -> String
+
+    # Check if tree responds to a method (includes delegation to inner_tree)
+    def respond_to_missing?: (Symbol method_name, ?bool include_private) -> bool
+
+    # Delegate unknown methods to the underlying backend-specific tree
+    def method_missing: (Symbol method_name, *untyped args, **untyped kwargs) ?{ () -> untyped } -> untyped
+
+    private
+
+    def initialize: (untyped inner_tree, ?source: String?) -> void
   end
 
   # Represents a node in the syntax tree
   class Node
+    attr_reader inner_node: untyped
+    attr_reader source: String?
+
     # Get the type name of this node
     def type: () -> String
 
+    # Get the text content of this node
+    def text: () -> String?
+
+    # Get the start byte offset
+    def start_byte: () -> Integer
+
+    # Get the end byte offset
+    def end_byte: () -> Integer
+
+    # Get the start point (row, column)
+    def start_point: () -> Point
+
+    # Get the end point (row, column)
+    def end_point: () -> Point
+
+    # Get the number of child nodes
+    def child_count: () -> Integer
+
+    # Get a child node by index
+    def child: (Integer index) -> Node?
+
+    # Get all children as an array
+    def children: () -> Array[Node]
+
     # Iterate over child nodes
     def each: () { (Node child) -> void } -> nil
             | () -> Enumerator[Node, nil]
 
+    # Get a named child by field name
+    def child_by_field_name: (String | Symbol field_name) -> Node?
+
+    # Get the parent node
+    def parent: () -> Node?
+
+    # Get the next sibling node
+    def next_sibling: () -> Node?
+
+    # Get the previous sibling node
+    def prev_sibling: () -> Node?
+
+    # Check if node responds to a method (includes delegation to inner_node)
+    def respond_to_missing?: (Symbol method_name, ?bool include_private) -> bool
+
+    # Delegate unknown methods to the underlying backend-specific node
+    def method_missing: (Symbol method_name, *untyped args, **untyped kwargs) ?{ () -> untyped } -> untyped
+
     private
 
-    def initialize: (untyped impl) -> void
+    def initialize: (untyped inner_node, ?source: String?) -> void
+  end
+
+  # Position in source code that works as both object and hash
+  class Point
+    attr_reader row: Integer
+    attr_reader column: Integer
 
-    @impl: untyped
+    def initialize: (row: Integer, column: Integer) -> void
+
+    # Hash-style access
+    def []: (Symbol key) -> Integer?
+
+    # Convert to hash
+    def to_h: () -> Hash[Symbol, Integer]
+
+    # String representation
+    def inspect: () -> String
   end
 
   # Thread-safe language registrations and cache

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tree_haver
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Peter H. Boling
@@ -207,9 +207,9 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.3
-description: "\U0001F334 TreeHaver is a cross-Ruby adapter for the Tree-sitter parsing
+description: "\U0001F334 TreeHaver is a cross-Ruby adapter for the tree-sitter parsing
   library that works seamlessly across MRI Ruby, JRuby, and TruffleRuby. It provides
-  a unified API for parsing source code using Tree-sitter grammars, regardless of
+  a unified API for parsing source code using tree-sitter grammars, regardless of
   your Ruby implementation. Like Faraday for HTTP or multi_json for JSON, TreeHaver
   lets you write once and run anywhere with automatic backend selection (MRI C extensions,
   Rust extensions, FFI, or Java)."
@@ -240,14 +240,18 @@ files:
 - RUBOCOP.md
 - SECURITY.md
 - lib/tree_haver.rb
+- lib/tree_haver/backends/citrus.rb
 - lib/tree_haver/backends/ffi.rb
 - lib/tree_haver/backends/java.rb
 - lib/tree_haver/backends/mri.rb
 - lib/tree_haver/backends/rust.rb
+- lib/tree_haver/citrus_grammar_finder.rb
 - lib/tree_haver/compat.rb
 - lib/tree_haver/grammar_finder.rb
 - lib/tree_haver/language_registry.rb
+- lib/tree_haver/node.rb
 - lib/tree_haver/path_validator.rb
+- lib/tree_haver/tree.rb
 - lib/tree_haver/version.rb
 - sig/tree_haver.rbs
 - sig/tree_haver/backends.rbs
@@ -258,10 +262,10 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://tree-haver.galtzo.com/
-  source_code_uri: https://github.com/kettle-rb/tree_haver/tree/v1.0.0
-  changelog_uri: https://github.com/kettle-rb/tree_haver/blob/v1.0.0/CHANGELOG.md
+  source_code_uri: https://github.com/kettle-rb/tree_haver/tree/v3.0.0
+  changelog_uri: https://github.com/kettle-rb/tree_haver/blob/v3.0.0/CHANGELOG.md
   bug_tracker_uri: https://github.com/kettle-rb/tree_haver/issues
-  documentation_uri: https://www.rubydoc.info/gems/tree_haver/1.0.0
+  documentation_uri: https://www.rubydoc.info/gems/tree_haver/3.0.0
   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
@@ -269,7 +273,7 @@ metadata:
   rubygems_mfa_required: 'true'
 rdoc_options:
 - "--title"
-- "tree_haver - \U0001F334 Cross-Ruby adapter for Tree-sitter parsing that works on
+- "tree_haver - \U0001F334 Cross-Ruby adapter for tree-sitter parsing that works on
   MRI, JRuby, and TruffleRuby"
 - "--main"
 - README.md
@@ -293,6 +297,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.1
 specification_version: 4
-summary: "\U0001F334 Cross-Ruby adapter for Tree-sitter parsing that works on MRI,
+summary: "\U0001F334 Cross-Ruby adapter for tree-sitter parsing that works on MRI,
   JRuby, and TruffleRuby"
 test_files: []