json-merge 1.1.2 → 7.1.1

data/lib/json/merge/node_wrapper.rb

@@ -2,137 +2,95 @@
 
 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
+    # Wraps TreeHaver nodes with line information and signatures for JSON /
+    # JSONC merging.
     class NodeWrapper < Ast::Merge::NodeWrapperBase
-      # Check if this is a JSON object
-      # @return [Boolean]
+      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"
+        @node.type.to_s == 'object'
       end
 
-      # Check if this is a JSON array
-      # @return [Boolean]
       def array?
-        @node.type.to_s == "array"
+        @node.type.to_s == 'array'
       end
 
-      # Check if this is a JSON string
-      # @return [Boolean]
       def string?
-        @node.type.to_s == "string"
+        @node.type.to_s == 'string'
       end
 
-      # Check if this is a JSON number
-      # @return [Boolean]
       def number?
-        @node.type.to_s == "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"
+        @node.type.to_s == 'null'
       end
 
-      # Check if this is a key-value pair
-      # @return [Boolean]
       def pair?
-        @node.type.to_s == "pair"
+        @node.type.to_s == 'pair'
       end
 
-      # Check if this is a comment
-      # @return [Boolean]
       def comment?
-        @node.type.to_s == "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")
-
+        key_node = find_child_by_field('key') || semantic_children.first
         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/, "")
+        Json::Merge.object_key_for_literal(node_text(key_node), dialect: dialect)
       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")
-
+        value = find_child_by_field('value') || semantic_children[1]
         return unless value
 
-        NodeWrapper.new(value, lines: @lines, source: @source)
+        NodeWrapper.new(value, lines: @lines, source: @source, dialect: dialect)
       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"
+          next if child.type.to_s == 'comment'
+          next unless child.type.to_s == 'pair'
 
-          result << NodeWrapper.new(child, lines: @lines, source: @source)
+          result << NodeWrapper.new(child, lines: @lines, source: @source, dialect: dialect)
         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 == "]"
+          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)
+          result << NodeWrapper.new(child, lines: @lines, source: @source, dialect: dialect)
         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
@@ -144,73 +102,55 @@ module Json
         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"
+        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
 
+        return opening_bracket if @start_line == @end_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
 
+        return closing_bracket if @start_line == @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?
+        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?
+        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)
 
@@ -220,67 +160,63 @@ module Json
         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
 
-      # Override wrap_child to use Json::Merge::NodeWrapper
       def wrap_child(child)
-        NodeWrapper.new(child, lines: @lines, source: @source)
+        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"
-          # Root document - signature based on root content type
+        when 'document'
           child = nil
-          node.each { |c|
-            child = c unless c.type.to_s == "comment"
+          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"
-          # 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.
+        when 'object'
           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
+        when 'array'
           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) }
+            node.each { |candidate| elements_count += 1 unless %w[comment , \[ \]].include?(candidate.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
+        when 'pair'
+          [:pair, key_name]
+        when 'string'
           [:string, node_text(node)]
-        when "number"
-          # Numbers identified by their value
+        when 'number'
           [:number, node_text(node)]
-        when "true", "false"
-          # Booleans
+        when 'true', 'false'
           [:boolean, node.type.to_s]
-        when "null"
+        when 'null'
           [:null]
-        when "comment"
-          # Comments identified by their content
+        when 'comment'
           [:comment, node_text(node)&.strip]
         else
-          # Generic fallback
           content_preview = node_text(node)&.slice(0, 50)&.strip
           [node_type.to_sym, content_preview]
         end
@@ -291,13 +227,28 @@ module Json
       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 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 = node_text(key_node)&.gsub(/\A"|"\z/, "")
+          key_text = Json::Merge.object_key_for_literal(node_text(key_node), dialect: dialect)
           keys << key_text if key_text
         end
         keys

data/lib/json/merge/object_match_refiner.rb

@@ -44,7 +44,8 @@ module Json
       # @param threshold [Float] Minimum score to accept a match (default: 0.5)
       # @param key_weight [Float] Weight for key similarity (default: 0.7)
       # @param value_weight [Float] Weight for value similarity (default: 0.3)
-      def initialize(threshold: DEFAULT_THRESHOLD, key_weight: DEFAULT_KEY_WEIGHT, value_weight: DEFAULT_VALUE_WEIGHT, **options)
+      def initialize(threshold: DEFAULT_THRESHOLD, key_weight: DEFAULT_KEY_WEIGHT, value_weight: DEFAULT_VALUE_WEIGHT,
+                     **options)
         super(threshold: threshold, **options)
         @key_weight = key_weight
         @value_weight = value_weight
@@ -58,7 +59,7 @@ module Json
       # @param dest_nodes [Array] Unmatched nodes from destination
       # @param context [Hash] Additional context
       # @return [Array<MatchResult>] Array of node matches
-      def call(template_nodes, dest_nodes, context = {})
+      def call(template_nodes, dest_nodes, _context = {})
         # Match object pairs (key-value entries)
         pair_matches = match_pairs(template_nodes, dest_nodes)
 
@@ -212,9 +213,9 @@ module Json
       # @return [String] Normalized key
       def normalize_key(key)
         # Convert camelCase to snake_case first, then normalize
-        key.gsub(/([A-Z])/) { "_#{$1.downcase}" }
-          .downcase
-          .gsub(/[-_]/, "")
+        key.gsub(/([A-Z])/) { "_#{::Regexp.last_match(1).downcase}" }
+           .downcase
+           .gsub(/[-_]/, '')
       end
 
       # Compute similarity between two values.
@@ -260,8 +261,8 @@ module Json
       # @return [String]
       def extract_string_value(node)
         # String nodes include quotes, remove them
-        text = node.respond_to?(:text) ? node.text : ""
-        text.gsub(/\A"|"\z/, "")
+        text = node.respond_to?(:text) ? node.text : ''
+        text.gsub(/\A"|"\z/, '')
       end
 
       # Compute similarity between two arrays.
@@ -273,8 +274,8 @@ module Json
         len1 = arr1.respond_to?(:elements) ? arr1.elements.size : 0
         len2 = arr2.respond_to?(:elements) ? arr2.elements.size : 0
 
-        return 1.0 if len1 == 0 && len2 == 0
-        return 0.0 if len1 == 0 || len2 == 0
+        return 1.0 if len1.zero? && len2.zero?
+        return 0.0 if len1.zero? || len2.zero?
 
         [len1, len2].min.to_f / [len1, len2].max
       end
@@ -306,9 +307,7 @@ module Json
         return str1.length if str2.empty?
 
         # Ensure str1 is the shorter string for space optimization
-        if str1.length > str2.length
-          str1, str2 = str2, str1
-        end
+        str1, str2 = str2, str1 if str1.length > str2.length
 
         m = str1.length
         n = str2.length
@@ -321,11 +320,11 @@ module Json
           curr_row[0] = j
 
           (1..m).each do |i|
-            cost = (str1[i - 1] == str2[j - 1]) ? 0 : 1
+            cost = str1[i - 1] == str2[j - 1] ? 0 : 1
             curr_row[i] = [
               prev_row[i] + 1,      # deletion
               curr_row[i - 1] + 1,  # insertion
-              prev_row[i - 1] + cost, # substitution
+              prev_row[i - 1] + cost # substitution
             ].min
           end
 

data/lib/json/merge/smart_merger.rb

@@ -2,8 +2,7 @@
 
 module Json
   module Merge
-    # High-level merger for JSON/JSONC content.
-    # Orchestrates parsing, analysis, and conflict resolution.
+    # High-level merger for JSON / JSONC content.
     #
     # @example Basic usage
     #   merger = SmartMerger.new(template_content, dest_content)
@@ -23,6 +22,10 @@ module Json
     #   merger = SmartMerger.new(template, dest,
     #     regions: [{ detector: SomeDetector.new, merger_class: SomeMerger }])
     class SmartMerger < ::Ast::Merge::SmartMergerBase
+      include ::Ast::Merge::Runtime::RootSessionSupport
+
+      attr_reader :runtime_session, :corruption_handling, :dialect
+
       # Creates a new SmartMerger
       #
       # @param template_content [String] Template JSON content
@@ -30,6 +33,7 @@ module Json
       # @param signature_generator [Proc, nil] Custom signature generator
       # @param preference [Symbol, Hash] :destination, :template, or per-type Hash
       # @param add_template_only_nodes [Boolean] Whether to add nodes only found in template
+      # @param remove_template_missing_nodes [Boolean] Whether to remove nodes missing from template
       # @param freeze_token [String, nil] Token for freeze block markers
       # @param match_refiner [#call, nil] Match refiner for fuzzy matching
       # @param regions [Array<Hash>, nil] Region configurations for nested merging
@@ -43,24 +47,42 @@ module Json
         signature_generator: nil,
         preference: :destination,
         add_template_only_nodes: false,
+        remove_template_missing_nodes: false,
+        corruption_handling: :heal,
         freeze_token: nil,
         match_refiner: nil,
         regions: nil,
         region_placeholder: nil,
         node_typing: nil,
+        merge_arrays: true,
+        preserve_atomic_formatting: false,
+        dialect: :jsonc,
         **options
       )
+        @remove_template_missing_nodes = remove_template_missing_nodes
+        @corruption_handling = ::Ast::Merge::Healer.normalize_mode(corruption_handling)
+        @merge_arrays = merge_arrays
+        @preserve_atomic_formatting = preserve_atomic_formatting
+        @dialect = dialect.to_sym
+        unless %i[json jsonc json5].include?(@dialect)
+          raise ArgumentError, "Unsupported JSON dialect #{dialect.inspect}. Expected json, jsonc, or json5."
+        end
+
         super(
           template_content,
           dest_content,
           signature_generator: signature_generator,
           preference: preference,
           add_template_only_nodes: add_template_only_nodes,
+          remove_template_missing_nodes: remove_template_missing_nodes,
           freeze_token: freeze_token,
           match_refiner: match_refiner,
           regions: regions,
           region_placeholder: region_placeholder,
           node_typing: node_typing,
+          merge_arrays: merge_arrays,
+          preserve_atomic_formatting: preserve_atomic_formatting,
+          dialect: @dialect,
           **options
         )
       end
@@ -72,7 +94,64 @@ module Json
         {
           preference: @preference,
           add_template_only_nodes: @add_template_only_nodes,
+          remove_template_missing_nodes: @remove_template_missing_nodes,
+          resolution_mode: @resolution_mode,
+          unresolved_policy: @unresolved_policy.to_h,
+          corruption_handling: @corruption_handling,
           match_refiner: @match_refiner,
+          dialect: @dialect
+        }
+      end
+
+      # Perform the merge operation and return the full MergeResult object.
+      #
+      # @return [MergeResult] The merge result containing merged JSON content and metadata
+      def merge_result
+        return @merge_result if @merge_result
+
+        root_operation = start_runtime_session!
+        @merge_result = super
+        complete_runtime_session!(root_operation, @merge_result)
+        @merge_result
+      rescue StandardError => e
+        fail_runtime_session!(root_operation, e)
+        raise
+      end
+
+      # Perform the merge and return detailed runtime-aware debug information.
+      #
+      # @return [Hash] Hash containing :content, :debug, :runtime, :statistics, and :decisions
+      def merge_with_debug
+        result_obj = merge_result
+        template_analysis_debug = {
+          valid: @template_analysis.valid?,
+          nodes: @template_analysis.nodes.size,
+          freeze_blocks: @template_analysis.freeze_blocks.size
+        }
+        dest_analysis_debug = {
+          valid: @dest_analysis.valid?,
+          nodes: @dest_analysis.nodes.size,
+          freeze_blocks: @dest_analysis.freeze_blocks.size
+        }
+
+        {
+          content: result_obj.to_json,
+          debug: {
+            template_nodes: template_analysis_debug[:nodes],
+            dest_nodes: dest_analysis_debug[:nodes],
+            preference: @preference,
+            add_template_only_nodes: @add_template_only_nodes,
+            remove_template_missing_nodes: @remove_template_missing_nodes,
+            corruption_handling: @corruption_handling,
+            freeze_token: @freeze_token,
+            runtime_operation_count: runtime_session&.operations&.size || 0,
+            runtime_diagnostic_count: runtime_session&.diagnostics&.size || 0
+          },
+          runtime: runtime_session&.to_h,
+          statistics: result_obj.statistics,
+          decisions: result_obj.decision_summary,
+          template_analysis: template_analysis_debug,
+          dest_analysis: dest_analysis_debug
         }
       end
 
@@ -85,7 +164,7 @@ module Json
 
       # @return [String] The default freeze token (not used for JSON)
       def default_freeze_token
-        "json-merge"
+        'json-merge'
       end
 
       # @return [Class] The resolver class for JSON files
@@ -104,10 +183,10 @@ module Json
       def perform_merge
         @resolver.resolve(@result)
 
-        DebugLogger.debug("Merge complete", {
-          lines: @result.line_count,
-          decisions: @result.statistics,
-        })
+        DebugLogger.debug('Merge complete', {
+                            lines: @result.line_count,
+                            decisions: @result.statistics
+                          })
 
         @result
       end
@@ -119,8 +198,13 @@ module Json
           @dest_analysis,
           preference: @preference,
           add_template_only_nodes: @add_template_only_nodes,
+          remove_template_missing_nodes: @remove_template_missing_nodes,
+          resolution_mode: @resolution_mode,
+          corruption_handling: @corruption_handling,
           match_refiner: @match_refiner,
           node_typing: @node_typing,
+          merge_arrays: @merge_arrays,
+          preserve_atomic_formatting: @preserve_atomic_formatting
         )
       end
 
@@ -141,9 +225,51 @@ module Json
 
       private
 
-      # JSON FileAnalysis only accepts signature_generator, not freeze_token
-      def build_full_analysis_options
-        {signature_generator: @signature_generator}
+      def start_runtime_session!
+        start_runtime_root_session!(
+          surface_kind: :json_document,
+          declared_language: :json,
+          effective_language: :json,
+          operation_id: 'json-document-root',
+          delegate_name: 'json-runtime',
+          policy_context: {
+            preference: @preference,
+            add_template_only_nodes: @add_template_only_nodes,
+            remove_template_missing_nodes: @remove_template_missing_nodes,
+            resolution_mode: @resolution_mode,
+            unresolved_policy: @unresolved_policy.to_h
+          },
+          metadata: { merger: self.class.name },
+          options: {
+            preference: @preference,
+            add_template_only_nodes: @add_template_only_nodes,
+            remove_template_missing_nodes: @remove_template_missing_nodes,
+            resolution_mode: @resolution_mode,
+            unresolved_policy: @unresolved_policy.to_h
+          },
+          language_chain: [:json],
+          delegate_metadata: { merger: self.class.name }
+        )
+      end
+
+      def complete_runtime_session!(root_operation, merge_result)
+        complete_runtime_root_session!(
+          root_operation: root_operation,
+          replacement_text: merge_result.to_json,
+          unresolved_cases: merge_result.unresolved_cases,
+          metadata: {
+            stats: merge_result.statistics,
+            decisions: merge_result.decision_summary
+          }
+        )
+      end
+
+      def fail_runtime_session!(root_operation, error)
+        fail_runtime_root_session!(
+          root_operation: root_operation,
+          error: error,
+          kind: :merge_failed
+        )
       end
     end
   end