tree_sitter 0.1.0-aarch64-linux

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

data/lib/tree_sitter/inserter.rb

@@ -0,0 +1,306 @@
+# frozen_string_literal: true
+
+require_relative "formatting"
+
+module TreeSitter
+  # Syntax-aware insertions that respect indentation and formatting.
+  #
+  # @example Insert a new statement with proper indentation
+  #   Inserter.new(source, tree)
+  #     .at_end_of(block_node)
+  #     .insert_statement("return result;")
+  #     .rewrite
+  #
+  # @example Insert a sibling function
+  #   Inserter.new(source, tree)
+  #     .after(existing_fn)
+  #     .insert_sibling("fn new_func() {}")
+  #     .rewrite
+  #
+  class Inserter
+    # Represents a pending insertion
+    Insertion = Struct.new(:byte_pos, :content, :newline_before, :newline_after, keyword_init: true)
+
+    attr_reader :source, :tree
+
+    # Initialize a new Inserter
+    #
+    # @param source [String] The source code
+    # @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
+      @indent_detector = Formatting::IndentationDetector.new(source)
+      @insertions = []
+      @insertion_point = nil
+      @insertion_context = nil
+    end
+
+    # Set insertion point at the beginning of a node's content (inside the node)
+    #
+    # @param node [TreeSitter::Node] Container node (e.g., a block)
+    # @return [self] For method chaining
+    def at_start_of(node)
+      # Find the first child's start, or just after the opening
+      # For blocks like { ... }, we want to insert after the opening brace
+      @insertion_context = :inside_start
+      @insertion_node = node
+      @target_indent_level = @indent_detector.level_at_byte(node.start_byte) + 1
+
+      # Find position just after opening delimiter
+      first_child = node.named_child(0)
+      if first_child
+        @insertion_point = first_child.start_byte
+      else
+        # Empty block - find end of opening line or after opening brace
+        node_text = @source[node.start_byte...node.end_byte]
+        @insertion_point = if (brace_pos = node_text.index("{"))
+          node.start_byte + brace_pos + 1
+        else
+          node.start_byte + 1
+        end
+      end
+
+      self
+    end
+
+    # Set insertion point at the end of a node's content (inside the node)
+    #
+    # @param node [TreeSitter::Node] Container node
+    # @return [self] For method chaining
+    def at_end_of(node)
+      @insertion_context = :inside_end
+      @insertion_node = node
+      @target_indent_level = @indent_detector.level_at_byte(node.start_byte) + 1
+
+      # Find position just before closing delimiter
+      node_text = @source[node.start_byte...node.end_byte]
+      @insertion_point = if (brace_pos = node_text.rindex("}"))
+        node.start_byte + brace_pos
+      else
+        node.end_byte
+      end
+
+      self
+    end
+
+    # Set insertion point before a node (as sibling)
+    #
+    # @param node [TreeSitter::Node] Reference node
+    # @return [self] For method chaining
+    def before(node)
+      @insertion_context = :before
+      @insertion_node = node
+      @insertion_point = node.start_byte
+      @target_indent_level = @indent_detector.level_at_byte(node.start_byte)
+      self
+    end
+
+    # Set insertion point after a node (as sibling)
+    #
+    # @param node [TreeSitter::Node] Reference node
+    # @return [self] For method chaining
+    def after(node)
+      @insertion_context = :after
+      @insertion_node = node
+      @insertion_point = node.end_byte
+      @target_indent_level = @indent_detector.level_at_byte(node.start_byte)
+      self
+    end
+
+    # Insert a statement with automatic indentation
+    #
+    # @param content [String] The statement to insert
+    # @param newline_before [Boolean] Add newline before (default: context-dependent)
+    # @param newline_after [Boolean] Add newline after (default: true)
+    # @return [self] For method chaining
+    def insert_statement(content, newline_before: nil, newline_after: true)
+      raise "No insertion point set. Call at_start_of, at_end_of, before, or after first." unless @insertion_point
+
+      # Determine newline_before based on context
+      newline_before = newline_before? if newline_before.nil?
+
+      # Adjust indentation of content
+      adjusted_content = adjust_content_indentation(content)
+
+      @insertions << Insertion.new(
+        byte_pos: @insertion_point,
+        content: adjusted_content,
+        newline_before: newline_before,
+        newline_after: newline_after,
+      )
+      self
+    end
+
+    # Insert raw content without indentation adjustment
+    #
+    # @param content [String] The content to insert
+    # @return [self] For method chaining
+    def insert_raw(content)
+      raise "No insertion point set. Call at_start_of, at_end_of, before, or after first." unless @insertion_point
+
+      @insertions << Insertion.new(
+        byte_pos: @insertion_point,
+        content: content,
+        newline_before: false,
+        newline_after: false,
+      )
+      self
+    end
+
+    # Insert a sibling node with matching indentation
+    #
+    # @param content [String] The sibling content
+    # @param separator [String] Separator between siblings (default: newlines based on context)
+    # @return [self] For method chaining
+    def insert_sibling(content, separator: nil)
+      raise "No insertion point set. Call before or after first." unless @insertion_point
+
+      separator ||= "\n\n" # Default to blank line between top-level items
+
+      # Adjust indentation of content
+      adjusted_content = adjust_content_indentation(content)
+
+      # For after insertion, add separator before content
+      # For before insertion, add separator after content
+      full_content = case @insertion_context
+      when :after
+        separator + adjusted_content
+      when :before
+        adjusted_content + separator
+      else
+        adjusted_content
+      end
+
+      @insertions << Insertion.new(
+        byte_pos: @insertion_point,
+        content: full_content,
+        newline_before: false,
+        newline_after: false,
+      )
+      self
+    end
+
+    # Insert a block with proper indentation (for block constructs)
+    #
+    # @param header [String] The block header (e.g., "if condition")
+    # @param body [String] The block body content (will be indented)
+    # @param open_brace [String] Opening delimiter (default: " {")
+    # @param close_brace [String] Closing delimiter (default: "}")
+    # @return [self] For method chaining
+    def insert_block(header, body, open_brace: " {", close_brace: "}")
+      raise "No insertion point set. Call at_start_of, at_end_of, before, or after first." unless @insertion_point
+
+      indent = @indent_detector.indent_string_for_level(@target_indent_level)
+      body_indent = @indent_detector.indent_string_for_level(@target_indent_level + 1)
+
+      # Build the block with proper indentation
+      indented_body = body.lines.map do |line|
+        if line.strip.empty?
+          line
+        else
+          body_indent + line.lstrip
+        end
+      end.join
+
+      block_content = "#{indent}#{header}#{open_brace}\n#{indented_body}\n#{indent}#{close_brace}"
+
+      newline_before = newline_before?
+
+      @insertions << Insertion.new(
+        byte_pos: @insertion_point,
+        content: block_content,
+        newline_before: newline_before,
+        newline_after: true,
+      )
+      self
+    end
+
+    # Apply all insertions
+    #
+    # @return [String] The source with insertions
+    def rewrite
+      return @source if @insertions.empty?
+
+      # Sort by position descending to apply from end to start
+      sorted = @insertions.sort_by { |ins| -ins.byte_pos }
+
+      result = @source.dup
+      sorted.each do |insertion|
+        content = insertion.content
+        content = "\n#{content}" if insertion.newline_before
+        content = "#{content}\n" if insertion.newline_after
+
+        result.insert(insertion.byte_pos, content)
+      end
+      result
+    end
+
+    # Apply insertions 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
+
+    # Reset insertion point to allow setting a new one
+    #
+    # @return [self] For method chaining
+    def reset_position
+      @insertion_point = nil
+      @insertion_context = nil
+      @insertion_node = nil
+      @target_indent_level = nil
+      self
+    end
+
+    private
+
+    def newline_before?
+      case @insertion_context
+      when :inside_start
+        # After opening brace, usually need newline
+        # But check if there's already content on the same line
+        true
+      when :inside_end
+        # Before closing brace, check if we need newline
+        # Look at what's before the insertion point
+        before_text = @source[0...@insertion_point]
+        last_newline = before_text.rindex("\n")
+        content_after_newline = last_newline ? before_text[(last_newline + 1)..] : before_text
+        # If there's only whitespace after the last newline, we might not need another
+        !content_after_newline.strip.empty?
+      when :before, :after
+        # Siblings usually don't need newline before (handled by separator)
+        false
+      else
+        true
+      end
+    end
+
+    def adjust_content_indentation(content)
+      return content if content.strip.empty?
+
+      @indent_detector.adjust_indentation(content.strip, @target_indent_level, current_level: 0)
+    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