json-merge 1.1.2 → 7.1.1

data/lib/json/merge/file_analysis.rb

@@ -2,97 +2,137 @@
 
 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, ...]
+    # Analyzes JSON / JSONC file structure, extracting nodes, comments, and
+    # freeze blocks for merging.
     class FileAnalysis
       include Ast::Merge::FileAnalyzable
 
-      # @return [TreeHaver::Tree, nil] Parsed AST
-      attr_reader :ast
+      DEFAULT_FREEZE_TOKEN = 'json-merge'
 
-      # @return [Array] Parse errors if any
-      attr_reader :errors
+      attr_reader :comment_tracker, :ast, :errors, :dialect
 
       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)
+      def initialize(source, freeze_token: DEFAULT_FREEZE_TOKEN, signature_generator: nil, parser_path: nil, dialect: :jsonc,
+                     **_options)
         @source = source
         @lines = source.lines.map(&:chomp)
+        @freeze_token = freeze_token
         @signature_generator = signature_generator
-        @parser_path = parser_path || self.class.find_parser_path
+        @parser_path = parser_path
+        @dialect = dialect.to_sym
         @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 }
+        @comment_tracker = CommentTracker.new(source)
 
-        @statements = integrate_nodes
+        DebugLogger.time('FileAnalysis#parse_json') { parse_json }
+        validate_jsonc_dialect! if valid? && @dialect == :jsonc
 
-        DebugLogger.debug("FileAnalysis initialized", {
-          signature_generator: signature_generator ? "custom" : "default",
-          statements_count: @statements.size,
-          valid: valid?,
-        })
+        @freeze_blocks = extract_freeze_blocks
+        @nodes = integrate_nodes_and_freeze_blocks
+
+        DebugLogger.debug('FileAnalysis initialized', {
+                            signature_generator: signature_generator ? 'custom' : 'default',
+                            nodes_count: @nodes.size,
+                            freeze_blocks: @freeze_blocks.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 comment_capability
+        @comment_capability ||= comment_tracker.augment(owners: []).capability
+      end
+
+      def comment_support_style
+        @comment_support_style ||= shared_comment_support_style(
+          source: :json_source,
+          style: :c_style_line,
+          read_strategy: :source_augmented_portable_write
+        )
+      end
+
+      def comment_nodes
+        comment_tracker.comment_nodes
+      end
+
+      def comment_node_at(line_num)
+        comment_tracker.comment_node_at(line_num)
+      end
+
+      def comment_region_for_range(range, kind:, full_line_only: false)
+        comment_tracker.comment_region_for_range(
+          range,
+          kind: kind,
+          full_line_only: full_line_only
+        )
+      end
+
+      def comment_augmenter(owners: nil, **options)
+        comment_tracker.augment(
+          owners: owners || comment_augmenter_default_owners,
+          **options
+        )
+      end
+
+      def statements
+        @nodes || []
+      end
+      alias nodes statements
+
+      def in_freeze_block?(line_num)
+        @freeze_blocks.any? { |fb| fb.location.cover?(line_num) }
+      end
+
+      def freeze_block_at(line_num)
+        @freeze_blocks.find { |fb| fb.location.cover?(line_num) }
+      end
+
+      def generate_signature(node)
+        return super if @signature_generator
+        return super unless node.is_a?(NodeWrapper)
+        return super unless node.object?
+
+        return [:root_object] if statements.size == 1 && statements.first == node
+
+        super
+      end
+
       def fallthrough_node?(value)
-        value.is_a?(NodeWrapper) || super
+        value.is_a?(NodeWrapper) || value.is_a?(FreezeNode) || super
       end
 
-      # Get the root node of the parse tree
-      # @return [NodeWrapper, nil]
       def root_node
-        return unless valid?
+        return @root_node if defined?(@root_node)
+        return @root_node = nil unless valid?
 
-        NodeWrapper.new(@ast.root_node, lines: @lines, source: @source)
+        @root_node = NodeWrapper.new(@ast.root_node, lines: @lines, source: @source, dialect: @dialect)
       end
 
-      # Get the root object if the JSON document is an object
-      # @return [NodeWrapper, nil]
       def root_object
-        return unless valid?
+        return @root_object if defined?(@root_object)
+        return @root_object = nil unless valid?
 
         root = @ast.root_node
-        return unless root
+        return @root_object = nil 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)
+          if child.type.to_s == 'object'
+            return @root_object = NodeWrapper.new(child, lines: @lines, source: @source,
+                                                         dialect: @dialect)
           end
         end
-        nil
+
+        @root_object = 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
@@ -100,8 +140,6 @@ module Json
         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
@@ -109,81 +147,208 @@ module Json
         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
+        @root_pairs ||= begin
+          obj = root_object
+          obj ? obj.pairs : []
+        end
+      end
+
+      def comment_attachment_for(owner, line_num: nil, **options)
+        shared_comment_attachment_for(
+          owner,
+          tracker_attachment: @comment_tracker.comment_attachment_for(owner, line_num: line_num, **options),
+          line_num: line_num,
+          **options
+        )
+      end
 
-        obj.pairs
+      # @return [Symbol]
+      def comment_attachment_strategy
+        :augmenter_preferred_tracker_layout
+      end
+
+      def ruleset_owner_selector
+        :line_bound_statements
+      end
+
+      def ruleset_render_family
+        :json_object_pairs
       end
 
       private
 
+      def layout_augmenter_default_owners
+        pairs = root_pairs.select { |pair| pair.respond_to?(:start_line) && pair.respond_to?(:end_line) }
+        return pairs unless pairs.empty?
+
+        comment_augmenter_default_owners
+      end
+
+      def root_merge_node
+        return unless valid?
+
+        root = @ast.root_node
+        return unless root
+
+        root_type = root.type.to_s
+        return NodeWrapper.new(root, lines: @lines, source: @source, dialect: @dialect) if %w[object
+                                                                                              array].include?(root_type)
+
+        root.each do |child|
+          child_type = child.type.to_s
+          next if child_type == 'comment'
+          next unless %w[object array].include?(child_type)
+
+          return NodeWrapper.new(child, lines: @lines, source: @source, dialect: @dialect)
+        end
+
+        nil
+      end
+
       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)
+        Json::Merge.register_backend!
+        parser = TreeHaver.parser_for(parser_language, backend_type: :tree_sitter)
 
         @ast = parser.parse(@source)
 
-        # Check for parse errors in the tree
-        if @ast&.root_node&.has_error?
-          collect_parse_errors(@ast.root_node)
-        end
+        collect_parse_errors(@ast.root_node) if @ast&.root_node
       rescue TreeHaver::Error => e
-        # TreeHaver::Error inherits from Exception, not StandardError.
-        # This also catches TreeHaver::NotAvailable (subclass of Error).
-        @errors << e.message
+        @errors << e
         @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 << {
+      def parser_language
+        %i[jsonc json5].include?(@dialect) ? :json5 : :json
+      end
+
+      def validate_jsonc_dialect!
+        validate_jsonc_node!(@ast.root_node)
+      end
+
+      def validate_jsonc_node!(node)
+        native_type = node.respond_to?(:native_type) ? node.native_type.to_s : node.type.to_s
+        case native_type
+        when 'identifier'
+          add_jsonc_dialect_error(node, 'unquoted object keys are JSON5-only')
+        when 'string'
+          validate_json_literal!(node, String, 'single-quoted strings and JSON5 escapes are not supported')
+        when 'number'
+          validate_json_literal!(node, Numeric, 'JSON5 numeric literals are not supported')
+        end
+
+        node.each { |child| validate_jsonc_node!(child) } if node.respond_to?(:each)
+      end
+
+      # Tree-sitter identifies complete string and number tokens. Delegating those
+      # token semantics to Ruby's strict JSON parser avoids a second hand-written
+      # lexer while retaining AST-derived source locations.
+      def validate_json_literal!(node, expected_class, reason)
+        value = ::JSON.parse(node.text)
+        return if value.is_a?(expected_class)
+
+        add_jsonc_dialect_error(node, reason)
+      rescue ::JSON::ParserError
+        add_jsonc_dialect_error(node, reason)
+      end
+
+      def add_jsonc_dialect_error(node, reason)
+        @errors << Json::Merge::JsoncDialectError.new(
+          "JSONC rejects #{reason} at line #{node.start_line}, column #{node.start_point[:column] + 1}."
+        )
+      end
+
+      def collect_parse_errors(node, found_errors = [])
+        if node.type.to_s == 'ERROR' ||
+           (node.respond_to?(:has_error?) && node.has_error?) ||
+           (node.respond_to?(:missing?) && node.missing?)
+          found_errors << {
             type: node.type.to_s,
-            start_point: node.start_point,
-            end_point: node.end_point,
-            text: node.to_s,
+            start_point: node.respond_to?(:start_point) ? node.start_point : nil,
+            end_point: node.respond_to?(:end_point) ? node.end_point : nil,
+            text: node.to_s
           }
         end
 
-        node.each { |child| collect_parse_errors(child) }
+        node.each { |child| collect_parse_errors(child, found_errors) } if node.respond_to?(:each)
+        @errors.concat(found_errors) unless found_errors.empty?
+        found_errors
       end
 
-      def integrate_nodes
-        return [] unless valid?
+      def extract_freeze_blocks
+        freeze_starts = []
+        freeze_ends = []
 
-        result = []
-        root = @ast.root_node
-        return result unless root
+        single_line_pattern = %r{^\s*//\s*#{Regexp.escape(@freeze_token)}:(freeze|unfreeze)\b}i
+        block_pattern = %r{^\s*/\*\s*#{Regexp.escape(@freeze_token)}:(freeze|unfreeze)\b.*\*/}i
 
-        # 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
+        @lines.each_with_index do |line, idx|
+          line_num = idx + 1
 
-          wrapper = NodeWrapper.new(child, lines: @lines, source: @source)
-          next unless wrapper.start_line && wrapper.end_line
+          marker_type = nil
+          if (match = line.match(single_line_pattern))
+            marker_type = match[1]&.downcase
+          elsif (match = line.match(block_pattern))
+            marker_type = match[1]&.downcase
+          end
 
-          result << wrapper
+          next unless marker_type
+
+          if marker_type == 'freeze'
+            freeze_starts << { line: line_num, marker: line }
+          elsif marker_type == 'unfreeze'
+            freeze_ends << { line: line_num, marker: line }
+          end
         end
 
-        # Sort by start line
-        result.sort_by { |node| node.start_line || 0 }
+        blocks = []
+        freeze_starts.each do |start_info|
+          matching_end = freeze_ends.find { |ending| ending[:line] > start_info[:line] }
+          next unless matching_end
+
+          freeze_ends.delete(matching_end)
+          blocks << FreezeNode.new(
+            start_line: start_info[:line],
+            end_line: matching_end[:line],
+            lines: @lines,
+            start_marker: start_info[:marker],
+            end_marker: matching_end[:marker]
+          )
+        end
+
+        blocks
       end
 
-      def compute_node_signature(node)
-        return unless node.is_a?(NodeWrapper)
+      def integrate_nodes_and_freeze_blocks
+        return @freeze_blocks.dup unless valid?
 
-        node.signature
+        result = []
+        processed_lines = ::Set.new
+
+        @freeze_blocks.each do |fb|
+          (fb.start_line..fb.end_line).each { |ln| processed_lines << ln }
+          result << fb
+        end
+
+        root = root_merge_node
+        if root&.start_line
+          root_lines = (root.start_line..root.end_line).to_a
+          result << root unless root_lines.any? { |ln| processed_lines.include?(ln) }
+        end
+
+        result.sort_by { |node| node&.start_line || 0 }
+      end
+
+      def compute_node_signature(node)
+        case node
+        when FreezeNode
+          node.signature
+        when NodeWrapper
+          node.signature
+        end
       end
     end
   end

data/lib/json/merge/freeze_node.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Json
+  module Merge
+    # Wrapper to represent comment-marked freeze blocks as first-class nodes in
+    # JSON / JSONC files.
+    class FreezeNode < Ast::Merge::FreezeNodeBase
+      InvalidStructureError = Ast::Merge::FreezeNodeBase::InvalidStructureError
+      Location = Ast::Merge::FreezeNodeBase::Location
+
+      def initialize(start_line:, end_line:, lines:, start_marker: nil, end_marker: nil, pattern_type: :c_style_line)
+        block_lines = (start_line..end_line).map { |ln| lines[ln - 1] }
+
+        super(
+          start_line: start_line,
+          end_line: end_line,
+          lines: block_lines,
+          start_marker: start_marker,
+          end_marker: end_marker,
+          pattern_type: pattern_type,
+        )
+
+        validate_structure!
+      end
+
+      def signature
+        normalized = @lines.map { |line| line&.strip }.compact.reject(&:empty?).join("\n")
+        [:FreezeNode, normalized]
+      end
+
+      def object?
+        false
+      end
+
+      def array?
+        false
+      end
+
+      def pair?
+        false
+      end
+
+      def inspect
+        "#<#{self.class.name} lines=#{start_line}..#{end_line} content_length=#{slice&.length || 0}>"
+      end
+
+      private
+
+      def validate_structure!
+        validate_line_order!
+
+        return unless @lines.empty? || @lines.all?(&:nil?)
+
+        raise InvalidStructureError.new(
+          'Freeze block is empty',
+          start_line: @start_line,
+          end_line: @end_line
+        )
+      end
+    end
+  end
+end

data/lib/json/merge/merge_result.rb

@@ -12,11 +12,14 @@ module Json
     #   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
@@ -29,7 +32,8 @@ module Json
           template_lines: 0,
           dest_lines: 0,
           merged_lines: 0,
-          total_decisions: 0,
+          freeze_preserved_lines: 0,
+          total_decisions: 0
         }
       end
 
@@ -44,7 +48,7 @@ module Json
           content: line,
           decision: decision,
           source: source,
-          original_line: original_line,
+          original_line: original_line
         }
 
         track_statistics(decision, source)
@@ -69,7 +73,21 @@ module Json
       # @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)
+        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
@@ -92,7 +110,7 @@ module Json
       # Get the merged content as a JSON string
       #
       # @return [String]
-      def to_json
+      def to_json(*_args)
         content = @lines.map { |l| l[:content] }.join("\n")
         # Ensure trailing newline
         content += "\n" unless content.end_with?("\n") || content.empty?
@@ -119,7 +137,7 @@ module Json
 
       private
 
-      def track_statistics(decision, source)
+      def track_statistics(decision, _source)
         @statistics[:total_decisions] += 1
 
         case decision
@@ -127,6 +145,8 @@ module Json
           @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