tree_sitter 0.0.1

data/lib/tree_sitter/refactor.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require_relative "query_rewriter"
+require_relative "transformer"
+require_relative "inserter"
+
+module TreeSitter
+  # High-level refactoring operations built on QueryRewriter and Transformer.
+  # These methods provide common code transformation patterns with a simple API.
+  #
+  # @example Rename a function throughout the code
+  #   TreeSitter::Refactor.rename_symbol(source, tree, lang,
+  #     from: "old_name", to: "new_name")
+  #
+  module Refactor
+    class << self
+      # Rename a symbol (function, variable, type) throughout the code
+      #
+      # @param source [String] Source code
+      # @param tree [Tree] Parsed syntax tree
+      # @param language [Language] Language for queries
+      # @param from [String] Original name
+      # @param to [String] New name
+      # @param kind [Symbol] Type of symbol (:identifier, :function, :type, :variable)
+      # @return [String] Modified source code
+      def rename_symbol(source, tree, language, from:, to:, kind: :identifier)
+        query_pattern = build_rename_query(kind)
+
+        QueryRewriter.new(source, tree, language)
+          .query(query_pattern)
+          .where { |m| match_has_text?(m, from) }
+          .replace("@name") { to }
+          .rewrite
+      end
+
+      # Rename a struct/class field and its usages
+      #
+      # @param source [String] Source code
+      # @param tree [Tree] Parsed syntax tree
+      # @param language [Language] Language for queries
+      # @param struct_name [String, nil] Name of struct/class (nil for all)
+      # @param from [String] Old field name
+      # @param to [String] New field name
+      # @return [String] Modified source code
+      def rename_field(source, tree, language, struct_name: nil, from:, to:)
+        # Query for field declarations and field accesses
+        query_pattern = <<~QUERY
+          [
+            (field_declaration name: (field_identifier) @name)
+            (field_expression field: (field_identifier) @name)
+            (field_identifier) @name
+          ]
+        QUERY
+
+        QueryRewriter.new(source, tree, language)
+          .query(query_pattern)
+          .where { |m| match_has_text?(m, from) }
+          .replace("@name") { to }
+          .rewrite
+      end
+
+      # Extract code into a new function
+      #
+      # @param source [String] Source code
+      # @param tree [Tree] Parsed syntax tree
+      # @param language [Language] Language for queries
+      # @param node [Node] Node to extract
+      # @param name [String] Name for extracted function
+      # @param parameters [Array<String>] Parameter names
+      # @param insert_after [Node, nil] Where to insert the new function
+      # @return [String] Modified source code
+      def extract_function(source, tree, language, node:, name:, parameters: [], insert_after: nil)
+        # Build function call
+        param_list = parameters.join(", ")
+        call_reference = parameters.empty? ? "#{name}()" : "#{name}(#{param_list})"
+
+        # Build function definition
+        node_text = source[node.start_byte...node.end_byte]
+        param_decl = parameters.map { |p| "#{p}: _" }.join(", ")
+        fn_def = "fn #{name}(#{param_decl}) {\n    #{node_text}\n}"
+
+        # Determine where to insert
+        insert_target = insert_after || find_enclosing_function(node) || tree.root_node
+
+        Transformer.new(source, tree)
+          .extract(node, to: insert_target, reference: call_reference) { fn_def }
+          .rewrite
+      end
+
+      # Inline a variable (replace usages with its value)
+      #
+      # @param source [String] Source code
+      # @param tree [Tree] Parsed syntax tree
+      # @param language [Language] Language for queries
+      # @param name [String] Variable name to inline
+      # @param scope [Node, nil] Scope to limit inlining (nil for entire tree)
+      # @return [String] Modified source code
+      def inline_variable(source, tree, language, name:, scope: nil)
+        # Find the variable declaration and its value
+        decl_query = "(let_declaration pattern: (identifier) @var_name value: (_) @value)"
+
+        query = TreeSitter::Query.new(language, decl_query)
+        cursor = TreeSitter::QueryCursor.new
+        root = scope || tree.root_node
+        matches = cursor.matches(query, root, source)
+
+        # Find the declaration for our variable
+        decl_match = matches.find do |m|
+          m.captures.any? { |c| c.name == "var_name" && c.node.text == name }
+        end
+
+        return source unless decl_match
+
+        # Get the value to inline
+        value_capture = decl_match.captures.find { |c| c.name == "value" }
+        return source unless value_capture
+
+        value_text = value_capture.node.text
+
+        # Find all usages and replace
+        usage_query = "(identifier) @usage"
+
+        QueryRewriter.new(source, tree, language)
+          .query(usage_query)
+          .where { |m| match_has_text?(m, name) && !declaration?(m, source) }
+          .replace("@usage") { value_text }
+          .rewrite
+      end
+
+      # Add an attribute/annotation to items matching a query
+      #
+      # @param source [String] Source code
+      # @param tree [Tree] Parsed syntax tree
+      # @param language [Language] Language for queries
+      # @param query_pattern [String] Query to match items
+      # @param attribute [String] Attribute to add (e.g., "#[derive(Debug)]")
+      # @return [String] Modified source code
+      def add_attribute(source, tree, language, query_pattern:, attribute:)
+        QueryRewriter.new(source, tree, language)
+          .query(query_pattern)
+          .insert_before("@item") { "#{attribute}\n" }
+          .rewrite
+      end
+
+      # Remove items matching a query
+      #
+      # @param source [String] Source code
+      # @param tree [Tree] Parsed syntax tree
+      # @param language [Language] Language for queries
+      # @param query_pattern [String] Query to match items to remove
+      # @param capture_name [String] Name of capture to remove
+      # @return [String] Modified source code
+      def remove_matching(source, tree, language, query_pattern:, capture_name: "@item")
+        QueryRewriter.new(source, tree, language)
+          .query(query_pattern)
+          .remove(capture_name)
+          .rewrite
+      end
+
+      private
+
+      def build_rename_query(kind)
+        case kind
+        when :function
+          <<~QUERY
+            [
+              (function_item name: (identifier) @name)
+              (call_expression function: (identifier) @name)
+            ]
+          QUERY
+        when :type
+          <<~QUERY
+            [
+              (struct_item name: (type_identifier) @name)
+              (enum_item name: (type_identifier) @name)
+              (type_identifier) @name
+            ]
+          QUERY
+        when :variable
+          "(identifier) @name"
+        else
+          "(identifier) @name"
+        end
+      end
+
+      def match_has_text?(match, text)
+        match.captures.any? { |c| c.node.text == text }
+      end
+
+      DECLARATION_TYPES = ["let_declaration", "parameter", "function_item"].freeze
+
+      def declaration?(match, _source)
+        # Check if this identifier is part of a declaration pattern
+        match.captures.any? do |c|
+          parent = c.node.parent
+          next false unless parent
+
+          # Common declaration patterns
+          DECLARATION_TYPES.include?(parent.type)
+        end
+      end
+
+      def find_enclosing_function(node)
+        current = node.parent
+        while current
+          return current if current.type == "function_item"
+
+          current = current.parent
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/tree_sitter/rewriter.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # Rewriter class for applying edits to parsed source code.
+  # Inspired by Parser::TreeRewriter from the parser gem.
+  #
+  # @example Basic usage
+  #   tree = TreeSitter::Parser.new.tap { |p| p.language = "rust" }.parse(source)
+  #   fn_name = tree.root_node.child(0).child_by_field_name("name")
+  #
+  #   new_source = TreeSitter::Rewriter.new(source, tree)
+  #     .replace(fn_name, "new_name")
+  #     .rewrite
+  #
+  class Rewriter
+    # Represents a single edit operation
+    Edit = Struct.new(:start_byte, :end_byte, :replacement, keyword_init: true)
+
+    attr_reader :source, :tree, :edits
+
+    # Initialize a new Rewriter
+    #
+    # @param source [String] The source code to rewrite
+    # @param tree [TreeSitter::Tree, nil] Optional parsed tree (will parse if not provided)
+    # @param parser [TreeSitter::Parser, nil] Optional parser for re-parsing (needed if tree not provided)
+    def initialize(source, tree = nil, parser: nil)
+      @source = source.dup.freeze
+      @tree = tree
+      @parser = parser
+      @edits = []
+    end
+
+    # Remove the text at the given node or range
+    #
+    # @param node_or_range [TreeSitter::Node, TreeSitter::Range] The node or range to remove
+    # @return [self] Returns self for method chaining
+    def remove(node_or_range)
+      replace(node_or_range, "")
+    end
+
+    # Replace the text at the given node or range with new content
+    #
+    # @param node_or_range [TreeSitter::Node, TreeSitter::Range] The node or range to replace
+    # @param content [String] The replacement content
+    # @return [self] Returns self for method chaining
+    def replace(node_or_range, content)
+      range = normalize_range(node_or_range)
+      @edits << Edit.new(
+        start_byte: range.start_byte,
+        end_byte: range.end_byte,
+        replacement: content.to_s,
+      )
+      self
+    end
+
+    # Insert text before the given node or range
+    #
+    # @param node_or_range [TreeSitter::Node, TreeSitter::Range] The node or range
+    # @param content [String] The content to insert
+    # @return [self] Returns self for method chaining
+    def insert_before(node_or_range, content)
+      range = normalize_range(node_or_range)
+      @edits << Edit.new(
+        start_byte: range.start_byte,
+        end_byte: range.start_byte,
+        replacement: content.to_s,
+      )
+      self
+    end
+
+    # Insert text after the given node or range
+    #
+    # @param node_or_range [TreeSitter::Node, TreeSitter::Range] The node or range
+    # @param content [String] The content to insert
+    # @return [self] Returns self for method chaining
+    def insert_after(node_or_range, content)
+      range = normalize_range(node_or_range)
+      @edits << Edit.new(
+        start_byte: range.end_byte,
+        end_byte: range.end_byte,
+        replacement: content.to_s,
+      )
+      self
+    end
+
+    # Wrap the node or range with before and after text
+    #
+    # @param node_or_range [TreeSitter::Node, TreeSitter::Range] The node or range to wrap
+    # @param before_text [String] Text to insert before
+    # @param after_text [String] Text to insert after
+    # @return [self] Returns self for method chaining
+    def wrap(node_or_range, before_text, after_text)
+      insert_before(node_or_range, before_text)
+      insert_after(node_or_range, after_text)
+      self
+    end
+
+    # Apply all accumulated edits and return the new source code
+    #
+    # Edits are applied in reverse order (from end to start) to preserve
+    # byte positions of earlier edits.
+    #
+    # @return [String] The rewritten source code
+    def rewrite
+      # Sort edits by position descending to apply from end to start
+      # This prevents earlier edits from invalidating later positions
+      sorted = @edits.sort_by { |e| [-e.start_byte, -e.end_byte] }
+
+      result = @source.dup
+      sorted.each do |edit|
+        result[edit.start_byte...edit.end_byte] = edit.replacement
+      end
+      result
+    end
+
+    # Apply edits and return both the new source and a new parse tree
+    #
+    # @return [Array<String, TreeSitter::Tree>] The new source and tree
+    # @raise [RuntimeError] If no parser is available for re-parsing
+    def rewrite_with_tree
+      new_source = rewrite
+
+      parser = @parser || create_parser_from_tree
+      raise "No parser available for re-parsing" unless parser
+
+      new_tree = parser.parse(new_source)
+      [new_source, new_tree]
+    end
+
+    private
+
+    def normalize_range(node_or_range)
+      case node_or_range
+      when TreeSitter::Node
+        node_or_range.range
+      when TreeSitter::Range
+        node_or_range
+      else
+        raise ArgumentError,
+          "Expected TreeSitter::Node or TreeSitter::Range, got #{node_or_range.class}"
+      end
+    end
+
+    def create_parser_from_tree
+      return unless @tree
+
+      parser = TreeSitter::Parser.new
+      lang = @tree.language
+      parser.language = lang.name if lang
+      parser
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/tree_sitter/transformer.rb

@@ -0,0 +1,324 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # Structural transformations for syntax tree nodes.
+  # Provides operations for moving, copying, swapping, and reordering nodes.
+  #
+  # @example Swap two function arguments
+  #   Transformer.new(source, tree)
+  #     .swap(arg1_node, arg2_node)
+  #     .rewrite
+  #
+  # @example Move a function to a different location
+  #   Transformer.new(source, tree)
+  #     .move(fn_node, after: other_fn_node)
+  #     .rewrite
+  #
+  class Transformer
+    # Represents a pending structural operation
+    Operation = Struct.new(:type, :params, keyword_init: true)
+
+    attr_reader :source, :tree, :operations
+
+    # Initialize a new Transformer
+    #
+    # @param source [String] The source code to transform
+    # @param tree [TreeSitter::Tree] The parsed syntax tree
+    # @param parser [TreeSitter::Parser, nil] Optional parser for re-parsing
+    def initialize(source, tree, parser: nil)
+      @source = source.dup.freeze
+      @tree = tree
+      @parser = parser
+      @operations = []
+    end
+
+    # Move a node to a new location (removes from original, inserts at target)
+    #
+    # @param node [TreeSitter::Node] The node to move
+    # @param before [TreeSitter::Node, nil] Insert before this node
+    # @param after [TreeSitter::Node, nil] Insert after this node
+    # @param separator [String] Separator to use (default: newline)
+    # @return [self] For method chaining
+    def move(node, before: nil, after: nil, separator: "\n")
+      raise ArgumentError, "Must specify either before: or after:" if before.nil? && after.nil?
+      raise ArgumentError, "Cannot specify both before: and after:" if before && after
+
+      @operations << Operation.new(
+        type: :move,
+        params: { node: node, before: before, after: after, separator: separator },
+      )
+      self
+    end
+
+    # Copy a node to a new location (original remains)
+    #
+    # @param node [TreeSitter::Node] The node to copy
+    # @param before [TreeSitter::Node, nil] Insert before this node
+    # @param after [TreeSitter::Node, nil] Insert after this node
+    # @param separator [String] Separator to use (default: newline)
+    # @return [self] For method chaining
+    def copy(node, before: nil, after: nil, separator: "\n")
+      raise ArgumentError, "Must specify either before: or after:" if before.nil? && after.nil?
+      raise ArgumentError, "Cannot specify both before: and after:" if before && after
+
+      @operations << Operation.new(
+        type: :copy,
+        params: { node: node, before: before, after: after, separator: separator },
+      )
+      self
+    end
+
+    # Swap two nodes
+    #
+    # @param node_a [TreeSitter::Node] First node
+    # @param node_b [TreeSitter::Node] Second node
+    # @return [self] For method chaining
+    def swap(node_a, node_b)
+      validate_non_overlapping(node_a, node_b)
+
+      @operations << Operation.new(
+        type: :swap,
+        params: { node_a: node_a, node_b: node_b },
+      )
+      self
+    end
+
+    # Reorder children of a parent node
+    #
+    # @param parent [TreeSitter::Node] The parent node
+    # @param order [Array<Integer>] New order as array of indices
+    # @return [self] For method chaining
+    # @example Reverse first three children: reorder_children(parent, [2, 1, 0, 3, 4])
+    def reorder_children(parent, order)
+      @operations << Operation.new(
+        type: :reorder,
+        params: { parent: parent, order: order },
+      )
+      self
+    end
+
+    # Extract node content to a new location with a reference
+    #
+    # @param node [TreeSitter::Node] Node to extract
+    # @param to [TreeSitter::Node] Where to place extracted content (inserted after)
+    # @param reference [String] Reference to leave in place of original
+    # @yield [String] Optional block to transform extracted content
+    # @return [self] For method chaining
+    def extract(node, to:, reference:, &wrapper)
+      @operations << Operation.new(
+        type: :extract,
+        params: { node: node, to: to, reference: reference, wrapper: wrapper },
+      )
+      self
+    end
+
+    # Duplicate a node immediately after itself
+    #
+    # @param node [TreeSitter::Node] Node to duplicate
+    # @param separator [String] Separator between original and copy
+    # @yield [String] Optional block to transform the copy
+    # @return [self] For method chaining
+    def duplicate(node, separator: "\n", &transformer)
+      @operations << Operation.new(
+        type: :duplicate,
+        params: { node: node, separator: separator, transformer: transformer },
+      )
+      self
+    end
+
+    # Apply all accumulated operations
+    #
+    # @return [String] The transformed source code
+    def rewrite
+      edits = build_edits
+      apply_edits(edits)
+    end
+
+    # Apply operations and return both source and new tree
+    #
+    # @return [Array<String, Tree>] The new source and re-parsed tree
+    def rewrite_with_tree
+      new_source = rewrite
+
+      parser = @parser || create_parser_from_tree
+      raise "No parser available for re-parsing" unless parser
+
+      new_tree = parser.parse(new_source)
+      [new_source, new_tree]
+    end
+
+    private
+
+    def build_edits
+      edits = []
+
+      @operations.each do |op|
+        case op.type
+        when :swap
+          edits.concat(build_swap_edits(op.params))
+        when :move
+          edits.concat(build_move_edits(op.params))
+        when :copy
+          edits.concat(build_copy_edits(op.params))
+        when :reorder
+          edits.concat(build_reorder_edits(op.params))
+        when :extract
+          edits.concat(build_extract_edits(op.params))
+        when :duplicate
+          edits.concat(build_duplicate_edits(op.params))
+        end
+      end
+
+      edits
+    end
+
+    def build_swap_edits(params)
+      node_a = params[:node_a]
+      node_b = params[:node_b]
+
+      text_a = node_text(node_a)
+      text_b = node_text(node_b)
+
+      [
+        { start_byte: node_a.start_byte, end_byte: node_a.end_byte, replacement: text_b },
+        { start_byte: node_b.start_byte, end_byte: node_b.end_byte, replacement: text_a },
+      ]
+    end
+
+    def build_move_edits(params)
+      node = params[:node]
+      before = params[:before]
+      after = params[:after]
+      separator = params[:separator]
+
+      text = node_text(node)
+      edits = []
+
+      # Remove from original location
+      edits << { start_byte: node.start_byte, end_byte: node.end_byte, replacement: "" }
+
+      # Insert at new location
+      if before
+        edits << { start_byte: before.start_byte, end_byte: before.start_byte, replacement: text + separator }
+      elsif after
+        edits << { start_byte: after.end_byte, end_byte: after.end_byte, replacement: separator + text }
+      end
+
+      edits
+    end
+
+    def build_copy_edits(params)
+      node = params[:node]
+      before = params[:before]
+      after = params[:after]
+      separator = params[:separator]
+
+      text = node_text(node)
+
+      if before
+        [{ start_byte: before.start_byte, end_byte: before.start_byte, replacement: text + separator }]
+      elsif after
+        [{ start_byte: after.end_byte, end_byte: after.end_byte, replacement: separator + text }]
+      else
+        []
+      end
+    end
+
+    def build_reorder_edits(params)
+      parent = params[:parent]
+      order = params[:order]
+
+      # Get all named children
+      children = []
+      parent.named_children.each { |child| children << child }
+
+      return [] if children.empty?
+
+      # Validate order indices
+      raise ArgumentError, "Order indices out of range" unless order.all? { |i| i >= 0 && i < children.length }
+
+      # Build content for each position in new order
+      new_contents = order.map { |i| node_text(children[i]) }
+
+      # Create edits to replace each child with its new content
+      edits = []
+      children.each_with_index do |child, idx|
+        new_text = new_contents[idx] || node_text(child)
+        next if new_text == node_text(child)
+
+        edits << { start_byte: child.start_byte, end_byte: child.end_byte, replacement: new_text }
+      end
+
+      edits
+    end
+
+    def build_extract_edits(params)
+      node = params[:node]
+      to = params[:to]
+      reference = params[:reference]
+      wrapper = params[:wrapper]
+
+      text = node_text(node)
+      extracted = wrapper ? wrapper.call(text) : text
+
+      [
+        # Replace original with reference
+        { start_byte: node.start_byte, end_byte: node.end_byte, replacement: reference },
+        # Insert extracted content at target
+        { start_byte: to.end_byte, end_byte: to.end_byte, replacement: "\n\n" + extracted },
+      ]
+    end
+
+    def build_duplicate_edits(params)
+      node = params[:node]
+      separator = params[:separator]
+      transformer = params[:transformer]
+
+      text = node_text(node)
+      copy_text = transformer ? transformer.call(text) : text
+
+      [{ start_byte: node.end_byte, end_byte: node.end_byte, replacement: separator + copy_text }]
+    end
+
+    def apply_edits(edits)
+      # Sort by position descending to apply from end to start
+      sorted = edits.sort_by { |e| [-e[:start_byte], -e[:end_byte]] }
+
+      result = @source.dup
+      sorted.each do |edit|
+        result[edit[:start_byte]...edit[:end_byte]] = edit[:replacement]
+      end
+      result
+    end
+
+    def node_text(node)
+      @source[node.start_byte...node.end_byte]
+    end
+
+    def validate_non_overlapping(*nodes)
+      ranges = nodes.map { |n| (n.start_byte...n.end_byte) }
+
+      ranges.combination(2).each do |r1, r2|
+        if ranges_overlap?(r1, r2)
+          raise ArgumentError, "Nodes must not overlap"
+        end
+      end
+    end
+
+    def ranges_overlap?(r1, r2)
+      r1.cover?(r2.begin) || r1.cover?(r2.end - 1) ||
+        r2.cover?(r1.begin) || r2.cover?(r1.end - 1)
+    end
+
+    def create_parser_from_tree
+      return unless @tree
+
+      parser = TreeSitter::Parser.new
+      lang = @tree.language
+      parser.language = lang.name if lang
+      parser
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/tree_sitter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  VERSION = "0.0.1"
+end