tree_sitter 0.1.0-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d8c782c0496a1303ac908be404481b5a5c3689952689e0d5039ff75fad6d2dd5
+  data.tar.gz: 3ed5e9d23d35958672860377a90a2227bb316c475d8a8c7ec8aaea6d22c2be74
+SHA512:
+  metadata.gz: ecfbc952e455d3034e6c66808245218f907a68a4c6868d80a3efc11eb6f5e91ae317e578be991babee2172d962fdd8effc73d6da6d28259044130811496a6620
+  data.tar.gz: 115d5a2b323b9841d6d90d27af3a6e34abb2bce91194fe9af62e6f3b87bdabd393c21e19c6b12d86712f5be3be9f6664f9f7c8e45de87096bcb675e84b8aebcd

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# [v0.1.0] - 13-01-2026
+## What's Changed
+* Bump libloading from 0.8.9 to 0.9.0 by @dependabot[bot] in https://github.com/gjtorikian/tree_sitter/pull/2
+* Bump tree-sitter from 0.25.10 to 0.26.3 by @dependabot[bot] in https://github.com/gjtorikian/tree_sitter/pull/3
+* Bump actions/checkout from 4 to 6 by @dependabot[bot] in https://github.com/gjtorikian/tree_sitter/pull/1
+* Test build bump by @gjtorikian in https://github.com/gjtorikian/tree_sitter/pull/4
+
+## New Contributors
+* @dependabot[bot] made their first contribution in https://github.com/gjtorikian/tree_sitter/pull/2
+* @gjtorikian made their first contribution in https://github.com/gjtorikian/tree_sitter/pull/4
+
+**Full Changelog**: https://github.com/gjtorikian/tree_sitter/commits/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Garen J. Torikian
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Makefile

@@ -0,0 +1,116 @@
+# Makefile for building tree-sitter grammars
+
+GRAMMAR_DIR := .tree-sitter-grammars
+
+# Platform detection
+UNAME_S := $(shell uname -s)
+ifeq ($(UNAME_S),Darwin)
+    EXT := dylib
+    CC_FLAGS := -shared -fPIC
+else ifeq ($(UNAME_S),Linux)
+    EXT := so
+    CC_FLAGS := -shared -fPIC
+else ifeq ($(OS),Windows_NT)
+    EXT := dll
+    CC_FLAGS := -shared
+else
+    EXT := so
+    CC_FLAGS := -shared -fPIC
+endif
+
+GRAMMARS := rust ruby python javascript go php java c_sharp
+
+.PHONY: all grammars clean $(GRAMMARS)
+
+all: grammars
+
+grammars: $(GRAMMARS)
+
+rust: $(GRAMMAR_DIR)/rust/libtree-sitter-rust.$(EXT)
+$(GRAMMAR_DIR)/rust/libtree-sitter-rust.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/rust" ]; then \
+		echo "Cloning tree-sitter-rust..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-rust.git $(GRAMMAR_DIR)/rust; \
+	fi
+	@echo "Building tree-sitter-rust..."
+	@cd $(GRAMMAR_DIR)/rust && $(CC) $(CC_FLAGS) -I src src/parser.c src/scanner.c -o libtree-sitter-rust.$(EXT)
+
+ruby: $(GRAMMAR_DIR)/ruby/libtree-sitter-ruby.$(EXT)
+$(GRAMMAR_DIR)/ruby/libtree-sitter-ruby.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/ruby" ]; then \
+		echo "Cloning tree-sitter-ruby..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-ruby.git $(GRAMMAR_DIR)/ruby; \
+	fi
+	@echo "Building tree-sitter-ruby..."
+	@cd $(GRAMMAR_DIR)/ruby && $(CC) $(CC_FLAGS) -I src src/parser.c src/scanner.c -o libtree-sitter-ruby.$(EXT)
+
+python: $(GRAMMAR_DIR)/python/libtree-sitter-python.$(EXT)
+$(GRAMMAR_DIR)/python/libtree-sitter-python.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/python" ]; then \
+		echo "Cloning tree-sitter-python..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-python.git $(GRAMMAR_DIR)/python; \
+	fi
+	@echo "Building tree-sitter-python..."
+	@cd $(GRAMMAR_DIR)/python && $(CC) $(CC_FLAGS) -I src src/parser.c src/scanner.c -o libtree-sitter-python.$(EXT)
+
+javascript: $(GRAMMAR_DIR)/javascript/libtree-sitter-javascript.$(EXT)
+$(GRAMMAR_DIR)/javascript/libtree-sitter-javascript.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/javascript" ]; then \
+		echo "Cloning tree-sitter-javascript..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-javascript.git $(GRAMMAR_DIR)/javascript; \
+	fi
+	@echo "Building tree-sitter-javascript..."
+	@cd $(GRAMMAR_DIR)/javascript && $(CC) $(CC_FLAGS) -I src src/parser.c src/scanner.c -o libtree-sitter-javascript.$(EXT)
+
+go: $(GRAMMAR_DIR)/go/libtree-sitter-go.$(EXT)
+$(GRAMMAR_DIR)/go/libtree-sitter-go.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/go" ]; then \
+		echo "Cloning tree-sitter-go..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-go.git $(GRAMMAR_DIR)/go; \
+	fi
+	@echo "Building tree-sitter-go..."
+	@cd $(GRAMMAR_DIR)/go && $(CC) $(CC_FLAGS) -I src src/parser.c -o libtree-sitter-go.$(EXT)
+
+php: $(GRAMMAR_DIR)/php/libtree-sitter-php.$(EXT)
+$(GRAMMAR_DIR)/php/libtree-sitter-php.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/php" ]; then \
+		echo "Cloning tree-sitter-php..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-php.git $(GRAMMAR_DIR)/php; \
+	fi
+	@echo "Building tree-sitter-php..."
+	@cd $(GRAMMAR_DIR)/php/php && $(CC) $(CC_FLAGS) -I src src/parser.c src/scanner.c -o ../libtree-sitter-php.$(EXT)
+
+java: $(GRAMMAR_DIR)/java/libtree-sitter-java.$(EXT)
+$(GRAMMAR_DIR)/java/libtree-sitter-java.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/java" ]; then \
+		echo "Cloning tree-sitter-java..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-java.git $(GRAMMAR_DIR)/java; \
+	fi
+	@echo "Building tree-sitter-java..."
+	@cd $(GRAMMAR_DIR)/java && $(CC) $(CC_FLAGS) -I src src/parser.c -o libtree-sitter-java.$(EXT)
+
+c_sharp: $(GRAMMAR_DIR)/c_sharp/libtree-sitter-c_sharp.$(EXT)
+$(GRAMMAR_DIR)/c_sharp/libtree-sitter-c_sharp.$(EXT):
+	@mkdir -p $(GRAMMAR_DIR)
+	@if [ ! -d "$(GRAMMAR_DIR)/c_sharp" ]; then \
+		echo "Cloning tree-sitter-c-sharp..."; \
+		git clone --depth 1 https://github.com/tree-sitter/tree-sitter-c-sharp.git $(GRAMMAR_DIR)/c_sharp; \
+	fi
+	@echo "Building tree-sitter-c-sharp..."
+	@cd $(GRAMMAR_DIR)/c_sharp && $(CC) $(CC_FLAGS) -I src src/parser.c src/scanner.c -o libtree-sitter-c_sharp.$(EXT)
+
+clean:
+	rm -rf $(GRAMMAR_DIR)
+
+# Show which extension will be used
+info:
+	@echo "Platform: $(UNAME_S)"
+	@echo "Extension: $(EXT)"
+	@echo "Grammar directory: $(GRAMMAR_DIR)"

data/README.md

@@ -0,0 +1,466 @@
+# TreeSitter
+
+Ruby bindings for [tree-sitter](https://tree-sitter.github.io/) with code transformation and refactoring capabilities. Parse source code using tree-sitter with a Ruby-friendly API, supporting multiple languages via dynamic grammar loading. Written in Rust, wrapped in Ruby.
+
+## Features
+
+- **Multi-language support** - Load any tree-sitter grammar dynamically
+- **Full AST navigation** - Traverse nodes, access children, siblings, parents
+- **Query support** - Pattern-based node searching using S-expressions
+- **Rewriter API** - Programmatic code transformations (replace, remove, insert, wrap)
+- **Query-based editing** - Bulk edits using tree-sitter queries
+- **Transforms** - Move, copy, swap, and reorder nodes
+- **Insertions** - Syntax-aware insertions with automatic indentation
+
+The main difference with this gem and others like it is that this focuses on parsing once, transforming, and outputting. It doesn't really work as well for live syntax highlighting or fitting into tools that need sub-millisecond updates (as a user is typing, for instance).
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem "tree_sitter"
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+**Note:** You need tree-sitter grammar shared libraries (`.so` or `.dylib` files) for the languages you want to parse. See [Grammar Setup](#grammar-setup) below.
+
+## Usage
+
+### Basic Parsing
+
+```ruby
+require "tree_sitter"
+
+# Register a language from a shared library
+TreeSitter.register_language("ruby", "path/to/libtree-sitter-ruby.{so,dylib}")
+
+# Create a parser and set the language
+parser = TreeSitter::Parser.new
+parser.language = "rust"
+
+# Parse source code
+source = "fn add(a: i32, b: i32) -> i32 { a + b }"
+tree = parser.parse(source)
+
+# Navigate the AST
+root = tree.root_node
+puts root.kind          # => "source_file"
+puts root.child_count   # => 1
+
+fn_item = root.child(0)
+puts fn_item.kind       # => "function_item"
+
+fn_name = fn_item.child_by_field_name("name")
+puts fn_name.text       # => "add"
+
+# Access the original source and language from the tree
+puts tree.source        # => "fn add(a: i32, b: i32) -> i32 { a + b }"
+puts tree.language.name # => "rust"
+
+# Set a parse timeout (in microseconds) to prevent hanging on large inputs
+parser.timeout_micros = 1_000_000  # 1 second
+tree = parser.parse(very_large_source)  # Returns nil if timeout exceeded
+```
+
+### Multi-Language Support
+
+```ruby
+# Register multiple languages
+TreeSitter.register_language("ruby", ENV["TREE_SITTER_RUBY_PATH"])
+TreeSitter.register_language("python", ENV["TREE_SITTER_PYTHON_PATH"])
+
+# Parse Ruby code
+ruby_parser = TreeSitter::Parser.new
+ruby_parser.language = "ruby"
+ruby_tree = ruby_parser.parse("def hello; puts 'hi'; end")
+
+# Parse Python code
+python_parser = TreeSitter::Parser.new
+python_parser.language = "python"
+python_tree = python_parser.parse("def hello():\n    print('hi')")
+
+# List registered languages
+TreeSitter.languages # => ["ruby", "python"]
+
+# Language metadata
+lang = TreeSitter.language("ruby")
+lang.name            # => "ruby"
+lang.version         # => 15 (ABI version)
+lang.node_kind_count # => 200 (number of node types in the grammar)
+```
+
+### Node Operations
+
+Once you have a node from the AST, you can navigate, inspect, and extract information:
+
+```ruby
+# Get nodes to work with
+root = tree.root_node
+fn_item = root.child(0)
+fn_name = fn_item.child_by_field_name("name")
+
+# === Navigation ===
+fn_item.parent                        # => #<TreeSitter::Node kind="source_file" ...>
+fn_item.child(0)                      # => #<TreeSitter::Node kind="fn" ...>
+fn_item.child_count                   # => 6
+fn_item.children                      # => [#<Node>, #<Node>, ...] (array of all children)
+fn_item.named_child(0)                # => #<TreeSitter::Node kind="identifier" ...>
+fn_item.named_child_count             # => 4
+fn_item.named_children                # => [#<Node>, ...] (array of named children only)
+fn_item.child_by_field_name("name")   # => #<TreeSitter::Node kind="identifier" ...>
+
+# Sibling navigation (using parameters as example)
+params = fn_item.child_by_field_name("parameters")
+first_param = params.named_child(0)
+first_param.next_sibling              # => #<TreeSitter::Node kind="," ...>
+first_param.next_named_sibling        # => #<TreeSitter::Node kind="parameter" ...>
+
+# === Properties ===
+fn_item.kind                # => "function_item"
+fn_item.type                # => "function_item" (alias for kind)
+fn_item.kind_id             # => 188
+fn_item.named?              # => true (not anonymous like "{" or ")")
+fn_item.missing?            # => false (not inserted by parser for error recovery)
+fn_item.extra?              # => false (not extra like comments)
+fn_item.error?              # => false (not an ERROR node)
+fn_item.has_error?          # => false (no errors in subtree)
+fn_item.has_changes?        # => false (not changed in incremental parse)
+
+# === Position ===
+fn_name.start_byte          # => 3
+fn_name.end_byte            # => 6
+fn_name.start_point         # => #<TreeSitter::Point row=0 column=3>
+fn_name.end_point           # => #<TreeSitter::Point row=0 column=6>
+fn_name.range               # => #<TreeSitter::Range start_byte=3 end_byte=6 size=3>
+
+# === Text & Display ===
+fn_name.text                # => "add"
+fn_name.to_sexp             # => "(identifier)"
+fn_name.to_s                # => "(identifier)" (alias for to_sexp)
+fn_name.inspect             # => "#<TreeSitter::Node kind=\"identifier\" start_byte=3 end_byte=6>"
+
+# === Comparison ===
+root == tree.root_node      # => true
+root.eql?(tree.root_node)   # => true
+```
+
+### Point and Range
+
+Nodes provide position information via `Point` and `Range` objects:
+
+```ruby
+# Point represents a position (row/column)
+point = fn_name.start_point
+point.row                   # => 0
+point.column                # => 3
+point.to_a                  # => [0, 3]
+point.inspect               # => "#<TreeSitter::Point row=0 column=3>"
+
+# Create points directly
+point = TreeSitter::Point.new(0, 3)
+point == fn_name.start_point  # => true
+
+# Range represents a span with byte offsets and points
+range = fn_name.range
+range.start_byte            # => 3
+range.end_byte              # => 6
+range.size                  # => 3
+range.start_point           # => #<TreeSitter::Point row=0 column=3>
+range.end_point             # => #<TreeSitter::Point row=0 column=6>
+range.inspect               # => "#<TreeSitter::Range start_byte=3 end_byte=6 size=3>"
+```
+
+### Query-Based Node Finding
+
+Use tree-sitter queries to find nodes matching patterns:
+
+```ruby
+# Create a query with capture names (@fn_name, @fn)
+lang = TreeSitter.language("rust")
+query = TreeSitter::Query.new(lang, "(function_item name: (identifier) @fn_name) @fn")
+
+# Query properties
+query.pattern_count           # => 1
+query.capture_names           # => ["fn_name", "fn"]
+
+# Execute query with a cursor
+cursor = TreeSitter::QueryCursor.new
+
+# Get all matches (each match contains all captures for one pattern match)
+matches = cursor.matches(query, tree.root_node, source)
+matches.length                # => 4 (one per function in file)
+
+match = matches.first
+match.pattern_index           # => 0
+match.captures                # => [#<QueryCapture>, #<QueryCapture>]
+match.captures.length         # => 2
+
+# Get all captures directly (flattened list)
+cursor = TreeSitter::QueryCursor.new  # create new cursor
+captures = cursor.captures(query, tree.root_node, source)
+captures.length               # => 8 (2 captures x 4 functions)
+
+capture = captures.first
+capture.name                  # => "fn"
+capture.node                  # => #<TreeSitter::Node kind="function_item" ...>
+capture.node.text             # => "fn add(a: i32, b: i32) -> i32 {\n    a + b\n}"
+
+# Iterate over captures
+captures.each do |cap|
+  puts "#{cap.name}: #{cap.node.text[0..20]}..." if cap.name == "fn_name"
+end
+# => fn_name: add...
+# => fn_name: new...
+# => fn_name: distance...
+# => fn_name: main...
+```
+
+### Code Rewriting
+
+```ruby
+source = <<~RUST
+  fn add(a: i32, b: i32) -> i32 {
+      a + b
+  }
+RUST
+
+tree = parser.parse(source)
+fn_item = tree.root_node.child(0)
+fn_name = fn_item.child_by_field_name("name")
+
+# Create a rewriter and apply edits
+new_source = TreeSitter::Rewriter.new(source, tree)
+  .replace(fn_name, "sum")
+  .insert_before(fn_item, "#[inline]\n")
+  .rewrite
+
+puts new_source
+# => #[inline]
+# => fn sum(a: i32, b: i32) -> i32 {
+# =>     a + b
+# => }
+```
+
+#### Rewriter Operations
+
+```ruby
+rewriter = TreeSitter::Rewriter.new(source, tree)
+
+# Replace a node's text
+rewriter.replace(node, "new_text")
+
+# Remove a node
+rewriter.remove(node)
+
+# Insert before/after a node
+rewriter.insert_before(node, "prefix ")
+rewriter.insert_after(node, " suffix")
+
+# Wrap a node
+rewriter.wrap(node, "/* ", " */")
+
+# All methods return self for chaining
+rewriter
+  .replace(name_node, "new_name")
+  .insert_before(fn_node, "// Comment\n")
+  .rewrite
+```
+
+### Query-Based Editing
+
+Use `QueryRewriter` to find and transform multiple nodes at once:
+
+```ruby
+source = <<~RUST
+  fn main() {
+      old_func();
+      old_func();
+      other_func();
+  }
+RUST
+
+tree = parser.parse(source)
+lang = TreeSitter.language("rust")
+
+# Rename all calls to old_func
+new_source = TreeSitter::QueryRewriter.new(source, tree, lang)
+  .query('(call_expression function: (identifier) @fn)')
+  .where { |m| m.captures.any? { |c| c.node.text == "old_func" } }
+  .replace("@fn") { "new_func" }
+  .rewrite
+
+# Add #[derive(Debug)] to all structs
+new_source = TreeSitter::QueryRewriter.new(source, tree, lang)
+  .query('(struct_item) @struct')
+  .insert_before("@struct") { "#[derive(Debug)]\n" }
+  .rewrite
+
+# Remove all comments
+new_source = TreeSitter::QueryRewriter.new(source, tree, lang)
+  .query('(line_comment) @comment')
+  .remove("@comment")
+  .rewrite
+```
+
+### Transforms
+
+Use `Transformer` to move, copy, swap, or reorder nodes:
+
+```ruby
+# Swap two parameters
+transformer = TreeSitter::Transformer.new(source, tree)
+  .swap(param_a, param_b)
+  .rewrite
+
+# Move a function after another
+transformer = TreeSitter::Transformer.new(source, tree)
+  .move(first_fn, after: third_fn)
+  .rewrite
+
+# Copy a node
+transformer = TreeSitter::Transformer.new(source, tree)
+  .copy(struct_node, after: fn_node)
+  .rewrite
+
+# Duplicate with transformation
+transformer = TreeSitter::Transformer.new(source, tree)
+  .duplicate(fn_node) { |text| text.gsub("original", "copy") }
+  .rewrite
+```
+
+### Insertions
+
+Use `Inserter` for syntax-aware insertions that respect indentation:
+
+```ruby
+# Insert at end of a block with proper indentation
+new_source = TreeSitter::Inserter.new(source, tree)
+  .at_end_of(fn_body)
+  .insert_statement("println!(\"done\");")
+  .rewrite
+
+# Insert a sibling function
+new_source = TreeSitter::Inserter.new(source, tree)
+  .after(existing_fn)
+  .insert_sibling("fn new_func() {\n    // body\n}")
+  .rewrite
+
+# Insert at start of block
+new_source = TreeSitter::Inserter.new(source, tree)
+  .at_start_of(fn_body)
+  .insert_statement("let start = Instant::now();")
+  .rewrite
+```
+
+### Refactor
+
+Use the `Refactor` module for common refactoring operations:
+
+```ruby
+# Rename a symbol (function, variable, type)
+new_source = TreeSitter::Refactor.rename_symbol(
+  source, tree, lang,
+  from: "old_name",
+  to: "new_name",
+  kind: :function  # or :variable, :type, :identifier
+)
+
+# Rename a struct field
+new_source = TreeSitter::Refactor.rename_field(
+  source, tree, lang,
+  from: "old_field",
+  to: "new_field"
+)
+
+# Add attributes to matching items
+new_source = TreeSitter::Refactor.add_attribute(
+  source, tree, lang,
+  query_pattern: "(struct_item) @item",
+  attribute: "#[derive(Debug)]"
+)
+
+# Remove items matching a pattern
+new_source = TreeSitter::Refactor.remove_matching(
+  source, tree, lang,
+  query_pattern: "(line_comment) @item"
+)
+
+# For regexp matching, use QueryRewriter directly
+new_source = TreeSitter::QueryRewriter.new(source, tree, lang)
+  .query('(function_item name: (identifier) @name)')
+  .where { |m| m.captures.any? { |c| c.node.text =~ /^test_/ } }
+  .replace("@name") { |node| node.text.sub(/^test_/, "spec_") }
+  .rewrite
+```
+
+## Grammar Setup
+
+TreeSitter requires grammar shared libraries for each language you want to parse.
+
+### Using a Makefile
+
+A sample Makefile is included in the gem which builds all supported grammars locally:
+
+```bash
+make grammars
+```
+
+This clones and compiles grammars into `.tree-sitter-grammars/` with the correct extension for your platform (`.dylib` on macOS, `.so` on Linux, `.dll` on Windows).
+
+Build individual grammars:
+
+```bash
+make rust        # Just Rust
+make ruby python # Ruby and Python
+```
+
+**You can use this Makefile as a reference for your own project! The gem does NOT ship with any grammars!**
+
+### Custom Grammar Paths
+
+You can override grammar locations with environment variables:
+
+```bash
+export TREE_SITTER_RUST_PATH="/path/to/libtree-sitter-rust.dylib"
+export TREE_SITTER_RUBY_PATH="/path/to/libtree-sitter-ruby.so"
+```
+
+Environment variables take precedence over auto-discovered grammars.
+
+## Supported Languages
+
+This gem supports any language with a tree-sitter grammar. The test suite validates:
+
+- Rust
+- Ruby
+- Python
+- JavaScript
+- Go
+- PHP
+- Java
+- C#
+
+## Development
+
+After checking out the repo:
+
+```bash
+bin/setup          # Install dependencies
+make grammars      # Compile the test grammars
+rake compile       # Compile the Rust extension
+rake test          # Run tests (requires grammar libraries)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gjtorikian/tree_sitter.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).