json-merge 1.0.0 → 1.1.1

data/lib/json/merge/conflict_resolver.rb

@@ -13,14 +13,16 @@ module Json
       #
       # @param template_analysis [FileAnalysis] Analyzed template file
       # @param dest_analysis [FileAnalysis] Analyzed destination file
-      # @param preference [Symbol] Which version to prefer when
+      # @param preference [Symbol, Hash] Which version to prefer when
       #   nodes have matching signatures:
       #   - :destination (default) - Keep destination version (customizations)
       #   - :template - Use template version (updates)
       # @param add_template_only_nodes [Boolean] Whether to add nodes only in template
       # @param match_refiner [#call, nil] Optional match refiner for fuzzy matching
       # @param options [Hash] Additional options for forward compatibility
-      def initialize(template_analysis, dest_analysis, preference: :destination, add_template_only_nodes: false, match_refiner: nil, **options)
+      # @param node_typing [Hash{Symbol,String => #call}, nil] Node typing configuration
+      #   for per-node-type preferences
+      def initialize(template_analysis, dest_analysis, preference: :destination, add_template_only_nodes: false, match_refiner: nil, node_typing: nil, **options)
         super(
           strategy: :batch,
           preference: preference,
@@ -30,6 +32,8 @@ module Json
           match_refiner: match_refiner,
           **options
         )
+        @node_typing = node_typing
+        @emitter = Emitter.new
       end
 
       protected
@@ -42,15 +46,25 @@ module Json
           template_statements = @template_analysis.statements
           dest_statements = @dest_analysis.statements
 
-          # Merge root-level statements (typically just the root object)
-          merge_node_lists(
+          # Clear emitter for fresh merge
+          @emitter.clear
+
+          # Merge root-level statements via emitter
+          merge_node_lists_to_emitter(
             template_statements,
             dest_statements,
             @template_analysis,
             @dest_analysis,
-            result,
           )
 
+          # Transfer emitter output to result
+          emitted_content = @emitter.to_s
+          unless emitted_content.empty?
+            emitted_content.lines.each do |line|
+              result.add_line(line.chomp, decision: MergeResult::DECISION_MERGED, source: :merged)
+            end
+          end
+
           DebugLogger.debug("Conflict resolution complete", {
             template_statements: template_statements.size,
             dest_statements: dest_statements.size,
@@ -61,13 +75,12 @@ module Json
 
       private
 
-      # Recursively merge two lists of nodes (tree-based merge)
+      # Recursively merge two lists of nodes, emitting to emitter
       # @param template_nodes [Array<NodeWrapper>] Template nodes
       # @param dest_nodes [Array<NodeWrapper>] Destination nodes
       # @param template_analysis [FileAnalysis] Template analysis for line access
       # @param dest_analysis [FileAnalysis] Destination analysis for line access
-      # @param result [MergeResult] Result to populate
-      def merge_node_lists(template_nodes, dest_nodes, template_analysis, dest_analysis, result)
+      def merge_node_lists_to_emitter(template_nodes, dest_nodes, template_analysis, dest_analysis)
         # Build signature maps for matching
         template_by_sig = build_signature_map(template_nodes, template_analysis)
         dest_by_sig = build_signature_map(dest_nodes, dest_analysis)
@@ -84,20 +97,13 @@ module Json
         dest_nodes.each do |dest_node|
           dest_sig = dest_analysis.generate_signature(dest_node)
 
-          # Freeze blocks from destination are always preserved
-          if freeze_node?(dest_node)
-            add_node_to_result(dest_node, result, :destination, MergeResult::DECISION_FREEZE_BLOCK, dest_analysis)
-            processed_dest_sigs << dest_sig if dest_sig
-            next
-          end
-
           # Check for signature match
           if dest_sig && template_by_sig[dest_sig]
             template_info = template_by_sig[dest_sig].first
             template_node = template_info[:node]
 
             # Both have this node - merge them (recursively if containers)
-            merge_matched_nodes(template_node, dest_node, template_analysis, dest_analysis, result)
+            merge_matched_nodes_to_emitter(template_node, dest_node, template_analysis, dest_analysis)
 
             processed_dest_sigs << dest_sig
             processed_template_sigs << dest_sig
@@ -107,13 +113,13 @@ module Json
             template_sig = template_analysis.generate_signature(template_node)
 
             # Merge matched nodes
-            merge_matched_nodes(template_node, dest_node, template_analysis, dest_analysis, result)
+            merge_matched_nodes_to_emitter(template_node, dest_node, template_analysis, dest_analysis)
 
             processed_dest_sigs << dest_sig if dest_sig
             processed_template_sigs << template_sig if template_sig
           else
             # Destination-only node - always keep
-            add_node_to_result(dest_node, result, :destination, MergeResult::DECISION_KEPT_DEST, dest_analysis)
+            emit_node(dest_node, dest_analysis)
             processed_dest_sigs << dest_sig if dest_sig
           end
         end
@@ -127,35 +133,172 @@ module Json
           # Skip if already processed
           next if template_sig && processed_template_sigs.include?(template_sig)
 
-          # Skip freeze blocks from template
-          next if freeze_node?(template_node)
-
           # Add template-only node
-          add_node_to_result(template_node, result, :template, MergeResult::DECISION_ADDED, template_analysis)
+          emit_node(template_node, template_analysis)
           processed_template_sigs << template_sig if template_sig
         end
       end
 
       # Merge two matched nodes - for containers, recursively merge children
+      # Emits to emitter instead of result
       # @param template_node [NodeWrapper] Template node
       # @param dest_node [NodeWrapper] Destination node
       # @param template_analysis [FileAnalysis] Template analysis
       # @param dest_analysis [FileAnalysis] Destination analysis
-      # @param result [MergeResult] Result to populate
-      def merge_matched_nodes(template_node, dest_node, template_analysis, dest_analysis, result)
+      def merge_matched_nodes_to_emitter(template_node, dest_node, template_analysis, dest_analysis)
         if dest_node.container? && template_node.container?
           # Both are containers - recursively merge their children
-          merge_container_nodes(template_node, dest_node, template_analysis, dest_analysis, result)
-        elsif @preference == :destination
+          merge_container_to_emitter(template_node, dest_node, template_analysis, dest_analysis)
+        elsif dest_node.pair? && template_node.pair?
+          # Both are pairs - check if their values are OBJECTS (not arrays) that need recursive merge
+          template_value = template_node.value_node
+          dest_value = dest_node.value_node
+
+          # Only recursively merge if BOTH values are objects (not arrays)
+          # Arrays are replaced atomically based on preference
+          if template_value&.type == :object && dest_value&.type == :object &&
+              template_value.container? && dest_value.container?
+            # Both values are objects - recursively merge
+            @emitter.emit_nested_object_start(dest_node.key_name)
+
+            # Recursively merge the value objects
+            merge_node_lists_to_emitter(
+              template_value.mergeable_children,
+              dest_value.mergeable_children,
+              template_analysis,
+              dest_analysis,
+            )
+
+            # Emit closing brace
+            @emitter.emit_nested_object_end
+          elsif preference_for_pair(template_node, dest_node) == :destination
+            # Values are not both objects, or one/both are arrays - use preference and emit
+            # Arrays are always replaced, not merged
+            emit_node(dest_node, dest_analysis)
+          else
+            emit_node(template_node, template_analysis)
+          end
+        elsif preference_for_pair(template_node, dest_node) == :destination
           # Leaf nodes or mismatched types - use preference
-          add_node_to_result(dest_node, result, :destination, MergeResult::DECISION_KEPT_DEST, dest_analysis)
+          emit_node(dest_node, dest_analysis)
         else
-          add_node_to_result(template_node, result, :template, MergeResult::DECISION_KEPT_TEMPLATE, template_analysis)
+          emit_node(template_node, template_analysis)
+        end
+      end
+
+      # Merge container nodes by emitting via emitter
+      # @param template_node [NodeWrapper] Template container node
+      # @param dest_node [NodeWrapper] Destination container node
+      # @param template_analysis [FileAnalysis] Template analysis
+      # @param dest_analysis [FileAnalysis] Destination analysis
+      def merge_container_to_emitter(template_node, dest_node, template_analysis, dest_analysis)
+        # Emit opening bracket
+        if dest_node.object?
+          @emitter.emit_object_start
+        elsif dest_node.array?
+          @emitter.emit_array_start
+        end
+
+        # Recursively merge the children
+        template_children = template_node.mergeable_children
+        dest_children = dest_node.mergeable_children
+
+        merge_node_lists_to_emitter(
+          template_children,
+          dest_children,
+          template_analysis,
+          dest_analysis,
+        )
+
+        # Emit closing bracket
+        if dest_node.object?
+          @emitter.emit_object_end
+        elsif dest_node.array?
+          @emitter.emit_array_end
         end
       end
 
-      # Build a map of refined matches from template node to destination node.
-      # Uses the match_refiner to find additional pairings for nodes that didn't match by signature.
+      def preference_for_pair(template_node, dest_node)
+        return @preference unless @preference.is_a?(Hash)
+
+        typed_template = apply_node_typing(template_node)
+        typed_dest = apply_node_typing(dest_node)
+
+        if Ast::Merge::NodeTyping.typed_node?(typed_template)
+          merge_type = Ast::Merge::NodeTyping.merge_type_for(typed_template)
+          return @preference.fetch(merge_type) { default_preference } if merge_type
+        end
+
+        if Ast::Merge::NodeTyping.typed_node?(typed_dest)
+          merge_type = Ast::Merge::NodeTyping.merge_type_for(typed_dest)
+          return @preference.fetch(merge_type) { default_preference } if merge_type
+        end
+
+        default_preference
+      end
+
+      def apply_node_typing(node)
+        return node unless @node_typing
+        return node unless node
+
+        Ast::Merge::NodeTyping.process(node, @node_typing)
+      end
+
+      # Emit a single node to the emitter
+      # @param node [NodeWrapper] Node to emit
+      # @param analysis [FileAnalysis] Analysis for accessing source
+      def emit_node(node, analysis)
+        # Emit the node content
+        if node.pair?
+          # Emit as pair
+          key = node.key_name
+          value_node = node.value_node
+
+          if value_node
+            # Check if value is an object (not array) and needs recursive emission
+            if value_node.type == :object && value_node.container?
+              # Object value - emit structure recursively
+              @emitter.emit_nested_object_start(key)
+              # Recursively emit object children
+              value_node.mergeable_children.each do |child|
+                emit_node(child, analysis)
+              end
+              @emitter.emit_nested_object_end
+            else
+              # Leaf value or array - get its text and emit as simple pair
+              # Arrays are emitted as raw text (not recursively)
+              value_text = if value_node.start_line == value_node.end_line
+                value_node.text
+              else
+                # Multi-line value - get all lines
+                lines = []
+                (value_node.start_line..value_node.end_line).each do |ln|
+                  lines << analysis.line_at(ln)
+                end
+                lines.join("\n")
+              end
+
+              @emitter.emit_pair(key, value_text) if key && value_text
+            end
+          end
+        elsif node.start_line && node.end_line
+          # Emit raw content for non-pair nodes
+          if node.start_line == node.end_line
+            # Single line - add directly
+            @emitter.lines << node.text
+          else
+            # Multi-line - collect and emit
+            lines = []
+            (node.start_line..node.end_line).each do |ln|
+              line = analysis.line_at(ln)
+              lines << line if line
+            end
+            @emitter.emit_raw_lines(lines)
+          end
+        end
+      end
+
+      # Build a map of refined matches from template node to destination node
       # @param template_nodes [Array<NodeWrapper>] Template nodes
       # @param dest_nodes [Array<NodeWrapper>] Destination nodes
       # @param template_by_sig [Hash] Template signature map
@@ -188,62 +331,6 @@ module Json
           h[match.template_node] = match.dest_node
         end
       end
-
-      # Merge two container nodes by emitting opening, recursively merging children, then closing
-      # @param template_node [NodeWrapper] Template container node
-      # @param dest_node [NodeWrapper] Destination container node
-      # @param template_analysis [FileAnalysis] Template analysis
-      # @param dest_analysis [FileAnalysis] Destination analysis
-      # @param result [MergeResult] Result to populate
-      def merge_container_nodes(template_node, dest_node, template_analysis, dest_analysis, result)
-        # Use destination's opening line (or template if dest doesn't have one)
-        opening = dest_node.opening_line || template_node.opening_line
-        result.add_line(opening, decision: MergeResult::DECISION_MERGED, source: :merged) if opening
-
-        # Recursively merge the children
-        template_children = template_node.mergeable_children
-        dest_children = dest_node.mergeable_children
-
-        merge_node_lists(
-          template_children,
-          dest_children,
-          template_analysis,
-          dest_analysis,
-          result,
-        )
-
-        # Use destination's closing line (or template if dest doesn't have one)
-        closing = dest_node.closing_line || template_node.closing_line
-        result.add_line(closing, decision: MergeResult::DECISION_MERGED, source: :merged) if closing
-      end
-
-      # Add a node to the result (non-container or leaf node)
-      # @param node [NodeWrapper] Node to add
-      # @param result [MergeResult] Result to populate
-      # @param source [Symbol] :template or :destination
-      # @param decision [String] Decision constant
-      # @param analysis [FileAnalysis] Analysis for line access
-      def add_node_to_result(node, result, source, decision, analysis)
-        if freeze_node?(node)
-          result.add_freeze_block(node)
-        elsif node.is_a?(NodeWrapper)
-          add_wrapper_to_result(node, result, source, decision, analysis)
-        else
-          DebugLogger.debug("Unknown node type", {node_type: node.class.name})
-        end
-      end
-
-      def add_wrapper_to_result(wrapper, result, source, decision, analysis)
-        return unless wrapper.start_line && wrapper.end_line
-
-        # Add the node content line by line
-        (wrapper.start_line..wrapper.end_line).each do |line_num|
-          line = analysis.line_at(line_num)
-          next unless line
-
-          result.add_line(line.chomp, decision: decision, source: source, original_line: line_num)
-        end
-      end
     end
   end
 end

data/lib/json/merge/emitter.rb

@@ -6,31 +6,38 @@ module Json
     # This class provides utilities for emitting JSON while maintaining
     # the original structure, comments, and style choices.
     #
+    # Inherits common emitter functionality from Ast::Merge::EmitterBase.
+    #
     # @example Basic usage
     #   emitter = Emitter.new
     #   emitter.emit_object_start
     #   emitter.emit_pair("key", '"value"')
     #   emitter.emit_object_end
-    class Emitter
-      # @return [Array<String>] Output lines
-      attr_reader :lines
-
-      # @return [Integer] Current indentation level
-      attr_reader :indent_level
+    class Emitter < Ast::Merge::EmitterBase
+      # @return [Boolean] Whether next item needs a comma
+      attr_reader :needs_comma
 
-      # @return [Integer] Spaces per indent level
-      attr_reader :indent_size
+      # Initialize subclass-specific state (comma tracking for JSON)
+      def initialize_subclass_state(**options)
+        @needs_comma = false
+      end
 
-      # Initialize a new emitter
-      #
-      # @param indent_size [Integer] Number of spaces per indent level
-      def initialize(indent_size: 2)
-        @lines = []
-        @indent_level = 0
-        @indent_size = indent_size
+      # Clear subclass-specific state
+      def clear_subclass_state
         @needs_comma = false
       end
 
+      # Emit a tracked comment from CommentTracker
+      # @param comment [Hash] Comment with :text, :indent, :block
+      def emit_tracked_comment(comment)
+        indent = " " * (comment[:indent] || 0)
+        @lines << if comment[:block]
+          "#{indent}/* #{comment[:text]} */"
+        else
+          "#{indent}// #{comment[:text]}"
+        end
+      end
+
       # Emit a single-line comment
       #
       # @param text [String] Comment text (without //)
@@ -53,36 +60,17 @@ module Json
         @lines << "#{current_indent}/* #{text} */"
       end
 
-      # Emit leading comments
-      #
-      # @param comments [Array<Hash>] Comment hashes from CommentTracker
-      def emit_leading_comments(comments)
-        comments.each do |comment|
-          indent = " " * (comment[:indent] || 0)
-          @lines << if comment[:block]
-            "#{indent}/* #{comment[:text]} */"
-          else
-            "#{indent}// #{comment[:text]}"
-          end
-        end
-      end
-
-      # Emit a blank line
-      def emit_blank_line
-        @lines << ""
-      end
-
       # Emit object start
       def emit_object_start
         add_comma_if_needed
         @lines << "#{current_indent}{"
-        @indent_level += 1
+        indent
         @needs_comma = false
       end
 
       # Emit object end
       def emit_object_end
-        @indent_level -= 1 if @indent_level > 0
+        dedent
         @lines << "#{current_indent}}"
         @needs_comma = true
       end
@@ -97,13 +85,13 @@ module Json
         else
           "#{current_indent}["
         end
-        @indent_level += 1
+        indent
         @needs_comma = false
       end
 
       # Emit array end
       def emit_array_end
-        @indent_level -= 1 if @indent_level > 0
+        dedent
         @lines << "#{current_indent}]"
         @needs_comma = true
       end
@@ -133,39 +121,31 @@ module Json
         @needs_comma = true
       end
 
-      # Emit raw lines (for preserving existing content)
-      #
-      # @param raw_lines [Array<String>] Lines to emit as-is
-      def emit_raw_lines(raw_lines)
-        raw_lines.each { |line| @lines << line.chomp }
+      # Emit a key with opening brace for nested object
+      # @param key [String] Key name
+      def emit_nested_object_start(key)
+        add_comma_if_needed
+        @lines << "#{current_indent}\"#{key}\": {"
+        indent
+        @needs_comma = false
       end
 
-      # Get the output as a single string
-      #
-      # @return [String]
-      def to_json
-        content = @lines.join("\n")
-        content += "\n" unless content.empty? || content.end_with?("\n")
-        content
+      # Emit closing brace for nested object
+      def emit_nested_object_end
+        dedent
+        @lines << "#{current_indent}}"
+        @needs_comma = true
       end
 
-      # Alias for consistency
+      # Get the output as a JSON string
+      #
       # @return [String]
-      alias_method :to_s, :to_json
-
-      # Clear the output
-      def clear
-        @lines = []
-        @indent_level = 0
-        @needs_comma = false
+      def to_json
+        to_s
       end
 
       private
 
-      def current_indent
-        " " * (@indent_level * @indent_size)
-      end
-
       def add_comma_if_needed
         return unless @needs_comma && @lines.any?
 

data/lib/json/merge/node_wrapper.rb

@@ -74,6 +74,7 @@ module Json
 
         # 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
@@ -88,6 +89,7 @@ module Json
         return unless pair?
 
         value = find_child_by_field("value")
+
         return unless value
 
         NodeWrapper.new(value, lines: @lines, source: @source)
@@ -148,6 +150,19 @@ module Json
         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]
@@ -226,14 +241,26 @@ module Json
           child_type = child&.type&.to_s
           [:document, child_type]
         when "object"
-          # Objects identified by their keys
-          keys = extract_object_keys(node)
-          [:object, keys.sort]
+          # 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"
-          # 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]
+          # 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
@@ -267,6 +294,7 @@ module Json
           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/, "")

data/lib/json/merge/smart_merger.rb

@@ -120,6 +120,7 @@ module Json
           preference: @preference,
           add_template_only_nodes: @add_template_only_nodes,
           match_refiner: @match_refiner,
+          node_typing: @node_typing,
         )
       end
 

data/lib/json/merge/version.rb

@@ -5,7 +5,7 @@ module Json
     # Version information for Json::Merge
     module Version
       # Current version of the json-merge gem
-      VERSION = "1.0.0"
+      VERSION = "1.1.1"
     end
     VERSION = Version::VERSION # traditional location
   end

data/lib/json/merge.rb

@@ -108,6 +108,18 @@ module Json
   end
 end
 
+# Register with ast-merge's MergeGemRegistry for RSpec dependency tags
+# Only register if MergeGemRegistry is loaded (i.e., in test environment)
+if defined?(Ast::Merge::RSpec::MergeGemRegistry)
+  Ast::Merge::RSpec::MergeGemRegistry.register(
+    :json_merge,
+    require_path: "json/merge",
+    merger_class: "Json::Merge::SmartMerger",
+    test_source: '{"key": "value"}',
+    category: :data,
+  )
+end
+
 Json::Merge::Version.class_eval do
   extend VersionGem::Basic
 end