json-merge 7.0.0 → 7.1.3

data/lib/json/merge/merge_result.rb

@@ -0,0 +1,156 @@
+# 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
+      include Ast::Merge::StructuredReviewApplySupport
+
+      # 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
+      DECISION_FREEZE_BLOCK = Ast::Merge::MergeResultBase::DECISION_FREEZE_BLOCK
+
+      # @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,
+          freeze_preserved_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 freeze block
+      #
+      # @param freeze_node [FreezeNode] Freeze block to add
+      def add_freeze_block(freeze_node)
+        freeze_node.lines.each_with_index do |line, idx|
+          add_line(
+            line.chomp,
+            decision: DECISION_FREEZE_BLOCK,
+            source: :destination,
+            original_line: freeze_node.start_line + idx
+          )
+        end
+      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(*_args)
+        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
+        when DECISION_FREEZE_BLOCK
+          @statistics[:freeze_preserved_lines] += 1
+        else
+          @statistics[:merged_lines] += 1
+        end
+      end
+    end
+  end
+end

data/lib/json/merge/node_wrapper.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module Json
+  module Merge
+    # Wraps TreeHaver nodes with line information and signatures for JSON /
+    # JSONC merging.
+    class NodeWrapper < Ast::Merge::NodeWrapperBase
+      attr_reader :dialect
+
+      def initialize(node, lines:, source: nil, dialect: :jsonc, **options)
+        @dialect = dialect.to_sym
+        super(node, lines: lines, source: source, **options)
+      end
+
+      def object?
+        @node.type.to_s == 'object'
+      end
+
+      def array?
+        @node.type.to_s == 'array'
+      end
+
+      def string?
+        @node.type.to_s == 'string'
+      end
+
+      def number?
+        @node.type.to_s == 'number'
+      end
+
+      def boolean?
+        %w[true false].include?(@node.type.to_s)
+      end
+
+      def null?
+        @node.type.to_s == 'null'
+      end
+
+      def pair?
+        @node.type.to_s == 'pair'
+      end
+
+      def comment?
+        @node.type.to_s == 'comment'
+      end
+
+      def key_name
+        return unless pair?
+
+        key_node = find_child_by_field('key') || semantic_children.first
+        return unless key_node
+
+        Json::Merge.object_key_for_literal(node_text(key_node), dialect: dialect)
+      end
+
+      def value_node
+        return unless pair?
+
+        value = find_child_by_field('value') || semantic_children[1]
+        return unless value
+
+        NodeWrapper.new(value, lines: @lines, source: @source, dialect: dialect)
+      end
+
+      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, dialect: dialect)
+        end
+        result
+      end
+
+      def elements
+        return [] unless array?
+
+        result = []
+        @node.each do |child|
+          child_type = child.type.to_s
+          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, dialect: dialect)
+        end
+        result
+      end
+
+      def mergeable_children
+        case type
+        when :object
+          pairs
+        when :array
+          elements
+        else
+          []
+        end
+      end
+
+      def container?
+        object? || array?
+      end
+
+      def root_level_container?
+        return false unless container?
+
+        parent_node = @node.parent if @node.respond_to?(:parent)
+        return false unless parent_node
+
+        parent_node.type.to_s == 'document'
+      end
+
+      def opening_line
+        return unless container? && @start_line
+
+        return opening_bracket if @start_line == @end_line
+
+        @lines[@start_line - 1]
+      end
+
+      def closing_line
+        return unless container? && @end_line
+
+        return closing_bracket if @start_line == @end_line
+
+        @lines[@end_line - 1]
+      end
+
+      def opening_bracket
+        return '{' if object?
+        return '[' if array?
+
+        nil
+      end
+
+      def closing_bracket
+        return '}' if object?
+        return ']' if array?
+
+        nil
+      end
+
+      def find_child_by_field(field_name)
+        return unless @node.respond_to?(:child_by_field_name)
+
+        @node.child_by_field_name(field_name)
+      end
+
+      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
+
+      def semantic_children
+        return [] unless @node.respond_to?(:each)
+
+        @node.each.filter_map do |child|
+          child_type = child.type.to_s
+          next if %w[comment , : { } [ ]].include?(child_type)
+
+          child
+        end
+      end
+
+      protected
+
+      def wrap_child(child)
+        NodeWrapper.new(child, lines: @lines, source: @source, dialect: dialect)
+      end
+
+      def compute_signature(node)
+        node_type = node.type.to_s
+
+        case node_type
+        when 'document'
+          child = nil
+          node.each do |candidate|
+            child = candidate unless candidate.type.to_s == 'comment'
+            break if child
+          end
+          child_type = child&.type&.to_s
+          [:document, child_type]
+        when 'object'
+          if root_level_container?
+            [:root_object]
+          else
+            keys = extract_object_keys(node)
+            [:object, keys.sort]
+          end
+        when 'array'
+          if root_level_container?
+            [:root_array]
+          else
+            elements_count = 0
+            node.each { |candidate| elements_count += 1 unless %w[comment , \[ \]].include?(candidate.type.to_s) }
+            [:array, elements_count]
+          end
+        when 'pair'
+          [:pair, key_name]
+        when 'string'
+          [:string, node_text(node)]
+        when 'number'
+          [:number, node_text(node)]
+        when 'true', 'false'
+          [:boolean, node.type.to_s]
+        when 'null'
+          [:null]
+        when 'comment'
+          [:comment, node_text(node)&.strip]
+        else
+          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
+
+          unless key_node
+            begin
+              child_each = child.method(:each)
+              child_each.call do |pair_child|
+                pair_child_type = pair_child.type.to_s
+                next if [':', 'comment'].include?(pair_child_type)
+
+                key_node = pair_child
+                break
+              end
+            rescue StandardError
+              next
+            end
+          end
+
+          next unless key_node
+
+          key_text = Json::Merge.object_key_for_literal(node_text(key_node), dialect: dialect)
+          keys << key_text if key_text
+        end
+        keys
+      end
+    end
+  end
+end