tree_sitter 0.0.1

data/ext/tree_sitter/src/point.rs

@@ -0,0 +1,45 @@
+use magnus::{RArray, Ruby};
+
+#[magnus::wrap(class = "TreeSitter::Point")]
+#[derive(Clone)]
+pub struct Point {
+    row: usize,
+    column: usize,
+}
+
+impl Point {
+    pub fn new(row: usize, column: usize) -> Self {
+        Self { row, column }
+    }
+
+    pub fn from_ts(point: tree_sitter::Point) -> Self {
+        Self {
+            row: point.row,
+            column: point.column,
+        }
+    }
+
+    pub fn row(&self) -> usize {
+        self.row
+    }
+
+    pub fn column(&self) -> usize {
+        self.column
+    }
+
+    pub fn to_a(&self) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        let _ = array.push(self.row);
+        let _ = array.push(self.column);
+        array
+    }
+
+    pub fn inspect(&self) -> String {
+        format!("#<TreeSitter::Point row={} column={}>", self.row, self.column)
+    }
+
+    pub fn eq(&self, other: &Point) -> bool {
+        self.row == other.row && self.column == other.column
+    }
+}

data/ext/tree_sitter/src/query.rs

@@ -0,0 +1,161 @@
+use crate::language::Language;
+use crate::node::Node;
+use magnus::{Error, RArray, Ruby};
+use std::cell::RefCell;
+use streaming_iterator::StreamingIterator;
+
+#[magnus::wrap(class = "TreeSitter::Query")]
+pub struct Query {
+    inner: tree_sitter::Query,
+    capture_names: Vec<String>,
+}
+
+impl Query {
+    pub fn new(language: &Language, source: String) -> Result<Self, Error> {
+        let ruby = Ruby::get().unwrap();
+
+        let query = tree_sitter::Query::new(&language.inner, &source).map_err(|e| {
+            Error::new(
+                ruby.exception_syntax_error(),
+                format!("Query syntax error: {}", e),
+            )
+        })?;
+
+        let capture_names = query.capture_names().iter().map(|s| s.to_string()).collect();
+
+        Ok(Self {
+            inner: query,
+            capture_names,
+        })
+    }
+
+    pub fn capture_names(&self) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        for name in &self.capture_names {
+            let _ = array.push(name.clone());
+        }
+        array
+    }
+
+    pub fn pattern_count(&self) -> usize {
+        self.inner.pattern_count()
+    }
+}
+
+#[magnus::wrap(class = "TreeSitter::QueryCursor")]
+pub struct QueryCursor {
+    inner: RefCell<tree_sitter::QueryCursor>,
+}
+
+impl QueryCursor {
+    pub fn new() -> Self {
+        Self {
+            inner: RefCell::new(tree_sitter::QueryCursor::new()),
+        }
+    }
+
+    pub fn matches(
+        &self,
+        query: &Query,
+        node: &Node,
+        source: String,
+    ) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        let Some(ts_node) = node.get_ts_node_pub() else {
+            return array;
+        };
+
+        let mut cursor = self.inner.borrow_mut();
+        let mut matches = cursor.matches(&query.inner, ts_node, source.as_bytes());
+
+        while let Some(m) = matches.next() {
+            let captures: Vec<QueryCapture> = m
+                .captures
+                .iter()
+                .map(|c| {
+                    let capture_name = query.capture_names[c.index as usize].clone();
+                    QueryCapture {
+                        name: capture_name,
+                        node: Node::new(c.node, node.source.clone(), node.tree.clone()),
+                    }
+                })
+                .collect();
+
+            let _ = array.push(QueryMatch {
+                pattern_index: m.pattern_index,
+                captures,
+            });
+        }
+
+        array
+    }
+
+    pub fn captures(
+        &self,
+        query: &Query,
+        node: &Node,
+        source: String,
+    ) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        let Some(ts_node) = node.get_ts_node_pub() else {
+            return array;
+        };
+
+        let mut cursor = self.inner.borrow_mut();
+        let mut captures = cursor.captures(&query.inner, ts_node, source.as_bytes());
+
+        while let Some((m, capture_index)) = captures.next() {
+            if let Some(c) = m.captures.get(*capture_index) {
+                let capture_name = query.capture_names[c.index as usize].clone();
+                let _ = array.push(QueryCapture {
+                    name: capture_name,
+                    node: Node::new(c.node, node.source.clone(), node.tree.clone()),
+                });
+            }
+        }
+
+        array
+    }
+}
+
+#[magnus::wrap(class = "TreeSitter::QueryMatch")]
+#[derive(Clone)]
+pub struct QueryMatch {
+    pattern_index: usize,
+    captures: Vec<QueryCapture>,
+}
+
+impl QueryMatch {
+    pub fn pattern_index(&self) -> usize {
+        self.pattern_index
+    }
+
+    pub fn captures(&self) -> RArray {
+        let ruby = Ruby::get().unwrap();
+        let array = ruby.ary_new();
+        for capture in &self.captures {
+            let _ = array.push(capture.clone());
+        }
+        array
+    }
+}
+
+#[magnus::wrap(class = "TreeSitter::QueryCapture")]
+#[derive(Clone)]
+pub struct QueryCapture {
+    name: String,
+    node: Node,
+}
+
+impl QueryCapture {
+    pub fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    pub fn node(&self) -> Node {
+        self.node.clone()
+    }
+}

data/ext/tree_sitter/src/range.rs

@@ -0,0 +1,50 @@
+use crate::point::Point;
+
+#[magnus::wrap(class = "TreeSitter::Range")]
+#[derive(Clone)]
+pub struct Range {
+    start_byte: usize,
+    end_byte: usize,
+    start_point: Point,
+    end_point: Point,
+}
+
+impl Range {
+    pub fn new(start_byte: usize, end_byte: usize, start_point: Point, end_point: Point) -> Self {
+        Self {
+            start_byte,
+            end_byte,
+            start_point,
+            end_point,
+        }
+    }
+
+    pub fn start_byte(&self) -> usize {
+        self.start_byte
+    }
+
+    pub fn end_byte(&self) -> usize {
+        self.end_byte
+    }
+
+    pub fn start_point(&self) -> Point {
+        self.start_point.clone()
+    }
+
+    pub fn end_point(&self) -> Point {
+        self.end_point.clone()
+    }
+
+    pub fn size(&self) -> usize {
+        self.end_byte - self.start_byte
+    }
+
+    pub fn inspect(&self) -> String {
+        format!(
+            "#<TreeSitter::Range start_byte={} end_byte={} size={}>",
+            self.start_byte,
+            self.end_byte,
+            self.size()
+        )
+    }
+}

data/ext/tree_sitter/src/tree.rs

@@ -0,0 +1,38 @@
+use crate::language::{get_language_internal, Language};
+use crate::node::Node;
+use magnus::Error;
+use std::sync::Arc;
+
+#[magnus::wrap(class = "TreeSitter::Tree")]
+pub struct Tree {
+    pub inner: Arc<tree_sitter::Tree>,
+    pub source: Arc<String>,
+    pub language_name: String,
+}
+
+impl Tree {
+    pub fn new(tree: tree_sitter::Tree, source: String, language_name: String) -> Self {
+        Self {
+            inner: Arc::new(tree),
+            source: Arc::new(source),
+            language_name,
+        }
+    }
+
+    pub fn root_node(&self) -> Node {
+        let ts_node = self.inner.root_node();
+        Node::new(ts_node, self.source.clone(), self.inner.clone())
+    }
+
+    pub fn source(&self) -> String {
+        (*self.source).clone()
+    }
+
+    pub fn language(&self) -> Result<Language, Error> {
+        let ts_lang = get_language_internal(&self.language_name)?;
+        Ok(Language {
+            name: self.language_name.clone(),
+            inner: ts_lang,
+        })
+    }
+}

data/lib/tree_sitter/formatting.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # Formatting utilities for syntax-aware code manipulation
+  module Formatting
+    # Detects and works with indentation in source code
+    class IndentationDetector
+      # Characters considered whitespace for indentation
+      INDENT_CHARS = [" ", "\t"].freeze
+
+      attr_reader :source, :indent_string, :indent_size, :style
+
+      # Initialize detector with source code
+      #
+      # @param source [String] The source code to analyze
+      def initialize(source)
+        @source = source
+        @lines = source.lines
+        detect
+      end
+
+      # Detect the indentation style used in the source
+      #
+      # @return [Hash] { style: :spaces|:tabs|:unknown, size: Integer, string: String }
+      def detect
+        space_indents = []
+        tab_count = 0
+        space_count = 0
+
+        @lines.each do |line|
+          next if line.strip.empty?
+
+          leading = line[/\A[ \t]*/]
+          next if leading.empty?
+
+          if leading.include?("\t")
+            tab_count += 1
+          else
+            space_count += 1
+            # Track indent sizes for space-indented lines
+            space_indents << leading.length if leading.length.positive?
+          end
+        end
+
+        if tab_count > space_count
+          @style = :tabs
+          @indent_size = 1
+          @indent_string = "\t"
+        elsif space_count.positive?
+          @style = :spaces
+          @indent_size = detect_space_indent_size(space_indents)
+          @indent_string = " " * @indent_size
+        else
+          # Default to 4 spaces
+          @style = :spaces
+          @indent_size = 4
+          @indent_string = "    "
+        end
+
+        { style: @style, size: @indent_size, string: @indent_string }
+      end
+
+      # Get indentation level (count) at a specific line
+      #
+      # @param line_number [Integer] Zero-based line number
+      # @return [Integer] Number of indentation units
+      def level_at_line(line_number)
+        return 0 if line_number < 0 || line_number >= @lines.length
+
+        line = @lines[line_number]
+        leading = line[/\A[ \t]*/] || ""
+
+        return leading.count("\t") if @style == :tabs
+
+        leading.length / [@indent_size, 1].max
+      end
+
+      # Get raw indentation string at a specific line
+      #
+      # @param line_number [Integer] Zero-based line number
+      # @return [String] The indentation whitespace
+      def raw_indentation_at_line(line_number)
+        return "" if line_number < 0 || line_number >= @lines.length
+
+        line = @lines[line_number]
+        line[/\A[ \t]*/] || ""
+      end
+
+      # Get indentation string at a specific byte position
+      #
+      # @param byte_pos [Integer] Byte position in source
+      # @return [String] The indentation whitespace for that line
+      def indentation_at_byte(byte_pos)
+        line_number = byte_to_line(byte_pos)
+        raw_indentation_at_line(line_number)
+      end
+
+      # Get indentation level at a specific byte position
+      #
+      # @param byte_pos [Integer] Byte position in source
+      # @return [Integer] Indentation level
+      def level_at_byte(byte_pos)
+        line_number = byte_to_line(byte_pos)
+        level_at_line(line_number)
+      end
+
+      # Create indentation string for a given level
+      #
+      # @param level [Integer] Indentation level
+      # @return [String] Indentation whitespace
+      def indent_string_for_level(level)
+        return "" if level <= 0
+
+        @indent_string * level
+      end
+
+      # Adjust indentation of content to a target level
+      #
+      # @param content [String] Content to adjust
+      # @param target_level [Integer] Target indentation level
+      # @param current_level [Integer, nil] Current base level (auto-detected if nil)
+      # @return [String] Re-indented content
+      def adjust_indentation(content, target_level, current_level: nil)
+        content_lines = content.lines
+        return content if content_lines.empty?
+
+        # Auto-detect current level from first non-empty line
+        if current_level.nil?
+          first_content_line = content_lines.find { |l| !l.strip.empty? }
+          if first_content_line
+            leading = first_content_line[/\A[ \t]*/] || ""
+            current_level = if @style == :tabs
+              leading.count("\t")
+            else
+              leading.length / [@indent_size, 1].max
+            end
+          else
+            current_level = 0
+          end
+        end
+
+        level_diff = target_level - current_level
+
+        content_lines.map do |line|
+          if line.strip.empty?
+            line
+          else
+            leading = line[/\A[ \t]*/] || ""
+            rest = line[leading.length..]
+
+            # Calculate this line's level relative to base
+            line_level = if @style == :tabs
+              leading.count("\t")
+            else
+              leading.length / [@indent_size, 1].max
+            end
+
+            # Apply the level difference
+            new_level = [line_level + level_diff, 0].max
+            indent_string_for_level(new_level) + rest
+          end
+        end.join
+      end
+
+      # Increase indentation of all lines by one level
+      #
+      # @param content [String] Content to indent
+      # @return [String] Indented content
+      def indent(content)
+        content.lines.map do |line|
+          if line.strip.empty?
+            line
+          else
+            @indent_string + line
+          end
+        end.join
+      end
+
+      # Decrease indentation of all lines by one level
+      #
+      # @param content [String] Content to dedent
+      # @return [String] Dedented content
+      def dedent(content)
+        content.lines.map do |line|
+          if line.strip.empty?
+            line
+          elsif @style == :tabs && line.start_with?("\t")
+            line[1..]
+          elsif @style == :spaces && line.start_with?(@indent_string)
+            line[@indent_size..]
+          else
+            line
+          end
+        end.join
+      end
+
+      private
+
+      # Detect the most common space indent size
+      def detect_space_indent_size(indents)
+        return 4 if indents.empty?
+
+        # Find GCD of all indent sizes to determine base unit
+        differences = []
+        sorted = indents.uniq.sort
+
+        sorted.each_cons(2) do |a, b|
+          differences << (b - a)
+        end
+
+        # Also consider the smallest non-zero indent
+        differences << sorted.first if sorted.first&.positive?
+
+        return 4 if differences.empty?
+
+        # Find GCD
+        gcd = differences.reduce { |a, b| a.gcd(b) }
+        gcd = 4 if gcd.nil? || gcd <= 0 || gcd > 8
+
+        gcd
+      end
+
+      # Convert byte position to line number (zero-based)
+      def byte_to_line(byte_pos)
+        current_byte = 0
+        @lines.each_with_index do |line, idx|
+          line_end = current_byte + line.bytesize
+          return idx if byte_pos < line_end
+
+          current_byte = line_end
+        end
+        [@lines.length - 1, 0].max
+      end
+    end
+  end
+end