tree_sitter 0.1.0-x86_64-linux

data/lib/tree_sitter/query_rewriter.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+
+module TreeSitter
+  # Query-based bulk editing for syntax tree nodes.
+  # Finds all nodes matching a tree-sitter query and applies transformations.
+  #
+  # @example Rename all function calls matching a pattern
+  #   QueryRewriter.new(source, tree, language)
+  #     .query('(call_expression function: (identifier) @fn_name)')
+  #     .where { |match| match.captures.any? { |c| c.node.text == "old_name" } }
+  #     .replace("@fn_name") { |node| "new_name" }
+  #     .rewrite
+  #
+  # @example Remove all comments
+  #   QueryRewriter.new(source, tree, language)
+  #     .query('(line_comment) @comment')
+  #     .remove("@comment")
+  #     .rewrite
+  #
+  class QueryRewriter
+    # Represents a pending operation on a capture
+    Operation = Struct.new(:type, :capture_name, :transformer, :before, :after, keyword_init: true)
+
+    attr_reader :source, :tree, :language, :edits
+
+    # Initialize a new QueryRewriter
+    #
+    # @param source [String] The source code to rewrite
+    # @param tree [TreeSitter::Tree] The parsed syntax tree
+    # @param language [TreeSitter::Language, String] The language for queries
+    # @param parser [TreeSitter::Parser, nil] Optional parser for re-parsing
+    def initialize(source, tree, language = nil, parser: nil)
+      @source = source.dup.freeze
+      @tree = tree
+      @language = resolve_language(language)
+      @parser = parser
+      @query_pattern = nil
+      @predicates = []
+      @operations = []
+      @edits = []
+    end
+
+    # Set the query pattern to match against
+    #
+    # @param pattern [String] Tree-sitter query pattern
+    # @return [self] For method chaining
+    def query(pattern)
+      @query_pattern = pattern
+      self
+    end
+
+    # Filter matches based on a predicate
+    #
+    # @yield [QueryMatch] Block that returns true for matches to keep
+    # @return [self] For method chaining
+    def where(&predicate)
+      @predicates << predicate
+      self
+    end
+
+    # Replace captured nodes with new content
+    #
+    # @param capture_name [String] The @capture to replace (e.g., "@fn_name" or "fn_name")
+    # @yield [Node] Block that returns the replacement text (receives the captured node)
+    # @yieldreturn [String] The replacement text
+    # @return [self] For method chaining
+    def replace(capture_name, &transformer)
+      @operations << Operation.new(
+        type: :replace,
+        capture_name: normalize_capture_name(capture_name),
+        transformer: transformer || proc { "" },
+      )
+      self
+    end
+
+    # Remove captured nodes
+    #
+    # @param capture_name [String] The @capture to remove
+    # @return [self] For method chaining
+    def remove(capture_name)
+      @operations << Operation.new(
+        type: :remove,
+        capture_name: normalize_capture_name(capture_name),
+      )
+      self
+    end
+
+    # Insert content before captured nodes
+    #
+    # @param capture_name [String] The @capture reference point
+    # @yield [Node] Block that returns the content to insert
+    # @yieldreturn [String] The content to insert
+    # @return [self] For method chaining
+    def insert_before(capture_name, content = nil, &content_generator)
+      generator = content_generator || proc { content.to_s }
+      @operations << Operation.new(
+        type: :insert_before,
+        capture_name: normalize_capture_name(capture_name),
+        transformer: generator,
+      )
+      self
+    end
+
+    # Insert content after captured nodes
+    #
+    # @param capture_name [String] The @capture reference point
+    # @yield [Node] Block that returns the content to insert
+    # @yieldreturn [String] The content to insert
+    # @return [self] For method chaining
+    def insert_after(capture_name, content = nil, &content_generator)
+      generator = content_generator || proc { content.to_s }
+      @operations << Operation.new(
+        type: :insert_after,
+        capture_name: normalize_capture_name(capture_name),
+        transformer: generator,
+      )
+      self
+    end
+
+    # Wrap captured nodes with before/after content
+    #
+    # @param capture_name [String] The @capture to wrap
+    # @param before [String, nil] Content before (or use block)
+    # @param after [String, nil] Content after
+    # @yield [Node] Optional block that returns [before, after] tuple
+    # @return [self] For method chaining
+    def wrap(capture_name, before: nil, after: nil, &block)
+      @operations << if block
+        Operation.new(
+          type: :wrap_dynamic,
+          capture_name: normalize_capture_name(capture_name),
+          transformer: block,
+        )
+      else
+        Operation.new(
+          type: :wrap,
+          capture_name: normalize_capture_name(capture_name),
+          before: before.to_s,
+          after: after.to_s,
+        )
+      end
+      self
+    end
+
+    # Execute the query and collect all matches
+    #
+    # @return [Array<QueryMatch>] All matches found
+    def matches
+      return [] unless @query_pattern && @language
+
+      ts_query = TreeSitter::Query.new(@language, @query_pattern)
+      cursor = TreeSitter::QueryCursor.new
+
+      all_matches = cursor.matches(ts_query, @tree.root_node, @source)
+
+      # Apply filters
+      @predicates.reduce(all_matches) do |matches, predicate|
+        matches.select(&predicate)
+      end
+    end
+
+    # Apply all accumulated edits
+    #
+    # @return [String] The rewritten source code
+    def rewrite
+      build_edits
+      apply_edits
+    end
+
+    # Apply edits 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
+
+    # Get a preview of all edits that would be applied
+    #
+    # @return [Array<Hash>] Array of edit descriptions
+    def preview_edits
+      build_edits
+      @edits.map do |edit|
+        {
+          start_byte: edit[:start_byte],
+          end_byte: edit[:end_byte],
+          original: @source[edit[:start_byte]...edit[:end_byte]],
+          replacement: edit[:replacement],
+        }
+      end
+    end
+
+    private
+
+    def resolve_language(language)
+      case language
+      when TreeSitter::Language
+        language
+      when String
+        TreeSitter.language(language)
+      when nil
+        @tree&.language
+      else
+        raise ArgumentError, "Invalid language: #{language.class}"
+      end
+    end
+
+    def normalize_capture_name(name)
+      name.to_s.delete_prefix("@")
+    end
+
+    def build_edits
+      @edits = []
+      found_matches = matches
+
+      found_matches.each do |match|
+        @operations.each do |operation|
+          # Find captures matching this operation
+          captures = match.captures.select { |c| c.name == operation.capture_name }
+
+          captures.each do |capture|
+            node = capture.node
+            range = node.range
+
+            case operation.type
+            when :replace
+              replacement = operation.transformer.call(node)
+              @edits << {
+                start_byte: range.start_byte,
+                end_byte: range.end_byte,
+                replacement: replacement.to_s,
+              }
+
+            when :remove
+              @edits << {
+                start_byte: range.start_byte,
+                end_byte: range.end_byte,
+                replacement: "",
+              }
+
+            when :insert_before
+              content = operation.transformer.call(node)
+              @edits << {
+                start_byte: range.start_byte,
+                end_byte: range.start_byte,
+                replacement: content.to_s,
+              }
+
+            when :insert_after
+              content = operation.transformer.call(node)
+              @edits << {
+                start_byte: range.end_byte,
+                end_byte: range.end_byte,
+                replacement: content.to_s,
+              }
+
+            when :wrap
+              @edits << {
+                start_byte: range.start_byte,
+                end_byte: range.start_byte,
+                replacement: operation.before,
+              }
+              @edits << {
+                start_byte: range.end_byte,
+                end_byte: range.end_byte,
+                replacement: operation.after,
+              }
+
+            when :wrap_dynamic
+              before_text, after_text = operation.transformer.call(node)
+              @edits << {
+                start_byte: range.start_byte,
+                end_byte: range.start_byte,
+                replacement: before_text.to_s,
+              }
+              @edits << {
+                start_byte: range.end_byte,
+                end_byte: range.end_byte,
+                replacement: after_text.to_s,
+              }
+            end
+          end
+        end
+      end
+    end
+
+    def apply_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 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/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