json-merge 1.1.2 → 7.0.0

data/lib/json/merge/file_analysis.rb

@@ -1,190 +0,0 @@
-# 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

@@ -1,136 +0,0 @@
-# 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

@@ -1,307 +0,0 @@
-# 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
-
-      # Check if this is a root-level container (direct child of document)
-      # Root-level containers get a generic signature so they always match.
-      # @return [Boolean]
-      def root_level_container?
-        return false unless container?
-
-        # Check if parent is a document node
-        parent_node = @node.parent if @node.respond_to?(:parent)
-        return false unless parent_node
-
-        parent_node.type.to_s == "document"
-      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"
-          # For root-level objects (direct child of document), use a generic signature
-          # that always matches so merging happens at the pair level.
-          # This is critical for JSON merging - there's typically only one root object/array.
-          if root_level_container?
-            [:root_object]
-          else
-            # Nested objects identified by their keys
-            keys = extract_object_keys(node)
-            [:object, keys.sort]
-          end
-        when "array"
-          # For root-level arrays (direct child of document), use a generic signature
-          if root_level_container?
-            [:root_array]
-          else
-            # Nested 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]
-          end
-        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