json-merge 1.0.0

data/lib/json/merge/file_analysis.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Json
+  module Merge
+    # Analyzes JSON file structure, extracting statements for merging.
+    # This is the main analysis class that prepares JSON content for merging.
+    #
+    # @example Basic usage
+    #   analysis = FileAnalysis.new(json_source)
+    #   analysis.valid? # => true
+    #   analysis.statements # => [NodeWrapper, ...]
+    class FileAnalysis
+      include Ast::Merge::FileAnalyzable
+
+      # @return [TreeHaver::Tree, nil] Parsed AST
+      attr_reader :ast
+
+      # @return [Array] Parse errors if any
+      attr_reader :errors
+
+      class << self
+        # Find the parser library path using TreeHaver::GrammarFinder
+        #
+        # @return [String, nil] Path to the parser library or nil if not found
+        def find_parser_path
+          TreeHaver::GrammarFinder.new(:json).find_library_path
+        end
+      end
+
+      # Initialize file analysis
+      #
+      # @param source [String] JSON source code to analyze
+      # @param signature_generator [Proc, nil] Custom signature generator
+      # @param parser_path [String, nil] Path to tree-sitter-json parser library
+      # @param options [Hash] Additional options (forward compatibility - freeze_token, node_typing, etc.)
+      def initialize(source, signature_generator: nil, parser_path: nil, **options)
+        @source = source
+        @lines = source.lines.map(&:chomp)
+        @signature_generator = signature_generator
+        @parser_path = parser_path || self.class.find_parser_path
+        @errors = []
+        # **options captures any additional parameters (e.g., freeze_token, node_typing) for forward compatibility
+
+        # Parse the JSON
+        DebugLogger.time("FileAnalysis#parse_json") { parse_json }
+
+        @statements = integrate_nodes
+
+        DebugLogger.debug("FileAnalysis initialized", {
+          signature_generator: signature_generator ? "custom" : "default",
+          statements_count: @statements.size,
+          valid: valid?,
+        })
+      end
+
+      # Check if parse was successful
+      # @return [Boolean]
+      def valid?
+        @errors.empty? && !@ast.nil?
+      end
+
+      # Override to detect tree-sitter nodes for signature generator fallthrough
+      # @param value [Object] The value to check
+      # @return [Boolean] true if this is a fallthrough node
+      def fallthrough_node?(value)
+        value.is_a?(NodeWrapper) || super
+      end
+
+      # Get the root node of the parse tree
+      # @return [NodeWrapper, nil]
+      def root_node
+        return unless valid?
+
+        NodeWrapper.new(@ast.root_node, lines: @lines, source: @source)
+      end
+
+      # Get the root object if the JSON document is an object
+      # @return [NodeWrapper, nil]
+      def root_object
+        return unless valid?
+
+        root = @ast.root_node
+        return unless root
+
+        # JSON root should be a document containing an object or array
+        root.each do |child|
+          if child.type.to_s == "object"
+            return NodeWrapper.new(child, lines: @lines, source: @source)
+          end
+        end
+        nil
+      end
+
+      # Get the opening brace line of the root object (the line containing `{`)
+      # @return [String, nil]
+      def root_object_open_line
+        obj = root_object
+        return unless obj&.start_line
+
+        line_at(obj.start_line)&.chomp
+      end
+
+      # Get the closing brace line of the root object (the line containing `}`)
+      # @return [String, nil]
+      def root_object_close_line
+        obj = root_object
+        return unless obj&.end_line
+
+        line_at(obj.end_line)&.chomp
+      end
+
+      # Get key-value pairs from the root object
+      # @return [Array<NodeWrapper>]
+      def root_pairs
+        obj = root_object
+        return [] unless obj
+
+        obj.pairs
+      end
+
+      private
+
+      def parse_json
+        # Use TreeHaver's high-level API - it handles:
+        # - Grammar auto-discovery
+        # - Backend selection
+        parser = TreeHaver.parser_for(:json, library_path: @parser_path)
+
+        @ast = parser.parse(@source)
+
+        # Check for parse errors in the tree
+        if @ast&.root_node&.has_error?
+          collect_parse_errors(@ast.root_node)
+        end
+      rescue TreeHaver::Error => e
+        # TreeHaver::Error inherits from Exception, not StandardError.
+        # This also catches TreeHaver::NotAvailable (subclass of Error).
+        @errors << e.message
+        @ast = nil
+      rescue StandardError => e
+        @errors << e
+        @ast = nil
+      end
+
+      def collect_parse_errors(node)
+        # Collect ERROR and MISSING nodes from the tree
+        if node.type.to_s == "ERROR" || node.missing?
+          @errors << {
+            type: node.type.to_s,
+            start_point: node.start_point,
+            end_point: node.end_point,
+            text: node.to_s,
+          }
+        end
+
+        node.each { |child| collect_parse_errors(child) }
+      end
+
+      def integrate_nodes
+        return [] unless valid?
+
+        result = []
+        root = @ast.root_node
+        return result unless root
+
+        # Return all root-level nodes (document children)
+        # For JSON, this is typically just the root object or array
+        # The tree structure is preserved - children are accessed via NodeWrapper#children
+        root.each do |child|
+          # Skip whitespace-only or empty nodes
+          next if child.type.to_s == "comment" # Comments handled separately in JSONC
+
+          wrapper = NodeWrapper.new(child, lines: @lines, source: @source)
+          next unless wrapper.start_line && wrapper.end_line
+
+          result << wrapper
+        end
+
+        # Sort by start line
+        result.sort_by { |node| node.start_line || 0 }
+      end
+
+      def compute_node_signature(node)
+        return unless node.is_a?(NodeWrapper)
+
+        node.signature
+      end
+    end
+  end
+end

data/lib/json/merge/merge_result.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Json
+  module Merge
+    # Tracks the result of a merge operation, including the merged content,
+    # decisions made, and statistics.
+    #
+    # Inherits decision constants and base functionality from Ast::Merge::MergeResultBase.
+    #
+    # @example Basic usage
+    #   result = MergeResult.new
+    #   result.add_line('"key": "value"', decision: :kept_template, source: :template)
+    #   result.to_json # => '"key": "value"\n'
+    class MergeResult < Ast::Merge::MergeResultBase
+      # Inherit decision constants from base class
+      DECISION_KEPT_TEMPLATE = Ast::Merge::MergeResultBase::DECISION_KEPT_TEMPLATE
+      DECISION_KEPT_DEST = Ast::Merge::MergeResultBase::DECISION_KEPT_DEST
+      DECISION_MERGED = Ast::Merge::MergeResultBase::DECISION_MERGED
+      DECISION_ADDED = Ast::Merge::MergeResultBase::DECISION_ADDED
+
+      # @return [Hash] Statistics about the merge
+      attr_reader :statistics
+
+      # Initialize a new merge result
+      # @param options [Hash] Additional options for forward compatibility
+      def initialize(**options)
+        super(**options)
+        @statistics = {
+          template_lines: 0,
+          dest_lines: 0,
+          merged_lines: 0,
+          total_decisions: 0,
+        }
+      end
+
+      # Add a single line to the result
+      #
+      # @param line [String] Line content
+      # @param decision [Symbol] Decision that led to this line
+      # @param source [Symbol] Source of the line (:template, :destination, :merged)
+      # @param original_line [Integer, nil] Original line number
+      def add_line(line, decision:, source:, original_line: nil)
+        @lines << {
+          content: line,
+          decision: decision,
+          source: source,
+          original_line: original_line,
+        }
+
+        track_statistics(decision, source)
+        track_decision(decision, source, line: original_line)
+      end
+
+      # Add multiple lines to the result
+      #
+      # @param lines [Array<String>] Lines to add
+      # @param decision [Symbol] Decision for all lines
+      # @param source [Symbol] Source of the lines
+      # @param start_line [Integer, nil] Starting original line number
+      def add_lines(lines, decision:, source:, start_line: nil)
+        lines.each_with_index do |line, idx|
+          original_line = start_line ? start_line + idx : nil
+          add_line(line, decision: decision, source: source, original_line: original_line)
+        end
+      end
+
+      # Add a blank line
+      #
+      # @param decision [Symbol] Decision for the blank line
+      # @param source [Symbol] Source
+      def add_blank_line(decision: DECISION_MERGED, source: :merged)
+        add_line("", decision: decision, source: source)
+      end
+
+      # Add content from a node wrapper
+      #
+      # @param node [NodeWrapper] Node to add
+      # @param decision [Symbol] Decision that led to keeping this node
+      # @param source [Symbol] Source of the node
+      # @param analysis [FileAnalysis] Analysis for accessing source lines
+      def add_node(node, decision:, source:, analysis:)
+        return unless node.start_line && node.end_line
+
+        (node.start_line..node.end_line).each do |line_num|
+          line = analysis.line_at(line_num)
+          next unless line
+
+          add_line(line.chomp, decision: decision, source: source, original_line: line_num)
+        end
+      end
+
+      # Get the merged content as a JSON string
+      #
+      # @return [String]
+      def to_json
+        content = @lines.map { |l| l[:content] }.join("\n")
+        # Ensure trailing newline
+        content += "\n" unless content.end_with?("\n") || content.empty?
+        content
+      end
+
+      # Alias for to_json
+      # @return [String]
+      def content
+        to_json
+      end
+
+      # Alias for to_json (used by SmartMerger#merge)
+      # @return [String]
+      def to_s
+        to_json
+      end
+
+      # Get line count
+      # @return [Integer]
+      def line_count
+        @lines.size
+      end
+
+      private
+
+      def track_statistics(decision, source)
+        @statistics[:total_decisions] += 1
+
+        case decision
+        when DECISION_KEPT_TEMPLATE
+          @statistics[:template_lines] += 1
+        when DECISION_KEPT_DEST
+          @statistics[:dest_lines] += 1
+        else
+          @statistics[:merged_lines] += 1
+        end
+      end
+    end
+  end
+end

data/lib/json/merge/node_wrapper.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module Json
+  module Merge
+    # Wraps TreeHaver nodes with comment associations, line information, and signatures.
+    # This provides a unified interface for working with JSON AST nodes during merging.
+    #
+    # Inherits common functionality from Ast::Merge::NodeWrapperBase:
+    # - Source context (lines, source, comments)
+    # - Line info extraction
+    # - Basic methods: #type, #type?, #text, #content, #signature
+    #
+    # @example Basic usage
+    #   parser = TreeHaver::Parser.new
+    #   parser.language = TreeHaver::Language.json
+    #   tree = parser.parse(source)
+    #   wrapper = NodeWrapper.new(tree.root_node, lines: source.lines, source: source)
+    #   wrapper.signature # => [:object, ...]
+    #
+    # @see Ast::Merge::NodeWrapperBase
+    class NodeWrapper < Ast::Merge::NodeWrapperBase
+      # Check if this is a JSON object
+      # @return [Boolean]
+      def object?
+        @node.type.to_s == "object"
+      end
+
+      # Check if this is a JSON array
+      # @return [Boolean]
+      def array?
+        @node.type.to_s == "array"
+      end
+
+      # Check if this is a JSON string
+      # @return [Boolean]
+      def string?
+        @node.type.to_s == "string"
+      end
+
+      # Check if this is a JSON number
+      # @return [Boolean]
+      def number?
+        @node.type.to_s == "number"
+      end
+
+      # Check if this is a JSON boolean (true/false)
+      # @return [Boolean]
+      def boolean?
+        %w[true false].include?(@node.type.to_s)
+      end
+
+      # Check if this is a JSON null
+      # @return [Boolean]
+      def null?
+        @node.type.to_s == "null"
+      end
+
+      # Check if this is a key-value pair
+      # @return [Boolean]
+      def pair?
+        @node.type.to_s == "pair"
+      end
+
+      # Check if this is a comment
+      # @return [Boolean]
+      def comment?
+        @node.type.to_s == "comment"
+      end
+
+      # Get the key name if this is a pair node
+      # @return [String, nil]
+      def key_name
+        return unless pair?
+
+        # In JSON tree-sitter, pair has key and value children
+        key_node = find_child_by_field("key")
+        return unless key_node
+
+        # Key is typically a string, extract its content without quotes using byte positions
+        key_text = node_text(key_node)
+        # Remove surrounding quotes if present
+        key_text&.gsub(/\A"|"\z/, "")
+      end
+
+      # Get the value node if this is a pair
+      # @return [NodeWrapper, nil]
+      def value_node
+        return unless pair?
+
+        value = find_child_by_field("value")
+        return unless value
+
+        NodeWrapper.new(value, lines: @lines, source: @source)
+      end
+
+      # Get key-value pairs if this is an object
+      # @return [Array<NodeWrapper>]
+      def pairs
+        return [] unless object?
+
+        result = []
+        @node.each do |child|
+          next if child.type.to_s == "comment"
+          next unless child.type.to_s == "pair"
+
+          result << NodeWrapper.new(child, lines: @lines, source: @source)
+        end
+        result
+      end
+
+      # Get array elements if this is an array
+      # @return [Array<NodeWrapper>]
+      def elements
+        return [] unless array?
+
+        result = []
+        @node.each do |child|
+          child_type = child.type.to_s
+          # Skip punctuation and comments
+          next if child_type == "comment"
+          next if child_type == ","
+          next if child_type == "["
+          next if child_type == "]"
+
+          result << NodeWrapper.new(child, lines: @lines, source: @source)
+        end
+        result
+      end
+
+      # Get mergeable children - the semantically meaningful children for tree merging
+      # For objects, returns pairs. For arrays, returns elements.
+      # For other node types, returns empty array (leaf nodes).
+      # @return [Array<NodeWrapper>]
+      def mergeable_children
+        case type
+        when :object
+          pairs
+        when :array
+          elements
+        else
+          []
+        end
+      end
+
+      # Check if this node is a container (has mergeable children)
+      # @return [Boolean]
+      def container?
+        object? || array?
+      end
+
+      # Get the opening line for a container node (the line with { or [)
+      # Returns the full line content including any leading whitespace
+      # @return [String, nil]
+      def opening_line
+        return unless container? && @start_line
+
+        @lines[@start_line - 1]
+      end
+
+      # Get the closing line for a container node (the line with } or ])
+      # Returns the full line content including any leading whitespace
+      # @return [String, nil]
+      def closing_line
+        return unless container? && @end_line
+
+        @lines[@end_line - 1]
+      end
+
+      # Get the opening bracket character for this container
+      # @return [String, nil]
+      def opening_bracket
+        return "{" if object?
+        return "[" if array?
+
+        nil
+      end
+
+      # Get the closing bracket character for this container
+      # @return [String, nil]
+      def closing_bracket
+        return "}" if object?
+        return "]" if array?
+
+        nil
+      end
+
+      # Find a child by field name
+      # @param field_name [String] Field name to look for
+      # @return [TreeSitter::Node, nil]
+      def find_child_by_field(field_name)
+        return unless @node.respond_to?(:child_by_field_name)
+
+        @node.child_by_field_name(field_name)
+      end
+
+      # Find a child by type
+      # @param type_name [String] Type name to look for
+      # @return [TreeSitter::Node, nil]
+      def find_child_by_type(type_name)
+        return unless @node.respond_to?(:each)
+
+        @node.each do |child|
+          return child if child.type.to_s == type_name
+        end
+        nil
+      end
+
+      protected
+
+      # Override wrap_child to use Json::Merge::NodeWrapper
+      def wrap_child(child)
+        NodeWrapper.new(child, lines: @lines, source: @source)
+      end
+
+      def compute_signature(node)
+        node_type = node.type.to_s
+
+        case node_type
+        when "document"
+          # Root document - signature based on root content type
+          child = nil
+          node.each { |c|
+            child = c unless c.type.to_s == "comment"
+            break if child
+          }
+          child_type = child&.type&.to_s
+          [:document, child_type]
+        when "object"
+          # Objects identified by their keys
+          keys = extract_object_keys(node)
+          [:object, keys.sort]
+        when "array"
+          # Arrays identified by their length and first few elements
+          elements_count = 0
+          node.each { |c| elements_count += 1 unless %w[comment , \[ \]].include?(c.type.to_s) }
+          [:array, elements_count]
+        when "pair"
+          # Pairs identified by their key name
+          key = key_name
+          [:pair, key]
+        when "string"
+          # Strings identified by their content
+          [:string, node_text(node)]
+        when "number"
+          # Numbers identified by their value
+          [:number, node_text(node)]
+        when "true", "false"
+          # Booleans
+          [:boolean, node.type.to_s]
+        when "null"
+          [:null]
+        when "comment"
+          # Comments identified by their content
+          [:comment, node_text(node)&.strip]
+        else
+          # Generic fallback
+          content_preview = node_text(node)&.slice(0, 50)&.strip
+          [node_type.to_sym, content_preview]
+        end
+      end
+
+      private
+
+      def extract_object_keys(object_node)
+        keys = []
+        object_node.each do |child|
+          next unless child.type.to_s == "pair"
+
+          key_node = child.respond_to?(:child_by_field_name) ? child.child_by_field_name("key") : nil
+          next unless key_node
+
+          key_text = node_text(key_node)&.gsub(/\A"|"\z/, "")
+          keys << key_text if key_text
+        end
+        keys
+      end
+    end
+  end
+end