json-merge 7.0.0 → 7.1.1

data/lib/json/merge.rb

@@ -1,131 +1,340 @@
 # frozen_string_literal: true
 
-require "json"
-require "tree_haver"
+require 'json'
+require 'tree_haver'
+require 'ast/merge'
+require_relative 'merge/version'
 
 module Json
   module Merge
-    PACKAGE_NAME = "json-merge"
+    PACKAGE_NAME = 'json-merge'
     DESTINATION_WINS_ARRAY_POLICY = {
-      surface: "array",
-      name: "destination_wins_array"
-    }.freeze
-    TRAILING_COMMA_FALLBACK_POLICY = {
-      surface: "fallback",
-      name: "trailing_comma_destination_fallback"
+      surface: 'array',
+      name: 'destination_wins_array'
     }.freeze
+    TREE_SITTER_BACKEND = TreeHaver::KREUZBERG_LANGUAGE_PACK_BACKEND
+    BACKEND_REGISTRY = Struct.new(:registered, :mutex).new(false, Mutex.new)
+
+    class Error < Ast::Merge::Error; end
+
+    class ParseError < Ast::Merge::ParseError
+      def initialize(message = nil, content: nil, errors: [])
+        super(message, errors: errors, content: content)
+      end
+    end
+
+    class TemplateParseError < ParseError; end
+    class DestinationParseError < ParseError; end
+    class JsoncDialectError < ParseError; end
+    class CorruptionDetectedError < Error; end
+
+    autoload :CommentTracker, 'json/merge/comment_tracker'
+    autoload :DebugLogger, 'json/merge/debug_logger'
+    autoload :Emitter, 'json/merge/emitter'
+    autoload :FileAnalysis, 'json/merge/file_analysis'
+    autoload :FreezeNode, 'json/merge/freeze_node'
+    autoload :MergeResult, 'json/merge/merge_result'
+    autoload :NodeWrapper, 'json/merge/node_wrapper'
+    autoload :ConflictResolver, 'json/merge/conflict_resolver'
+    autoload :SmartMerger, 'json/merge/smart_merger'
+    autoload :ObjectMatchRefiner, 'json/merge/object_match_refiner'
+
+    class << self
+      def register_backend!
+        BACKEND_REGISTRY.mutex.synchronize do
+          return if BACKEND_REGISTRY.registered
+
+          TreeHaver::BackendRegistry.register(TREE_SITTER_BACKEND)
+
+          grammar_finder = TreeHaver::GrammarFinder.new(:json)
+          grammar_finder.register! if grammar_finder.available?
+
+          json5_grammar_finder = TreeHaver::GrammarFinder.new(:json5)
+          json5_grammar_finder.register! if json5_grammar_finder.available?
+
+          BACKEND_REGISTRY.registered = true
+        end
+      end
+    end
 
     module_function
 
     def json_feature_profile
       {
-        family: "json",
-        supported_dialects: %w[json jsonc],
-        supported_policies: [DESTINATION_WINS_ARRAY_POLICY, TRAILING_COMMA_FALLBACK_POLICY]
+        family: 'json',
+        supported_dialects: %w[json jsonc json5],
+        supported_policies: [DESTINATION_WINS_ARRAY_POLICY]
       }
     end
 
-    def json_parse_request(source, dialect)
-      TreeHaver::ParserRequest.new(source: source, language: "json", dialect: dialect)
+    def available_json_backends
+      json_backend_available_for_analysis?(TREE_SITTER_BACKEND.id) ? [TREE_SITTER_BACKEND] : []
     end
 
-    def parse_json_with_language_pack(source, dialect)
-      return unsupported_jsonc_language_pack_result if dialect != "json"
-
-      backend_result = TreeHaver.parse_with_language_pack(json_parse_request(source, dialect))
-      return { ok: false, diagnostics: backend_result[:diagnostics] } unless backend_result[:ok]
+    def json_backend_feature_profile(backend: nil)
+      requested = requested_json_backend_id(backend)
+      unless available_json_backends.any? { |backend_ref| backend_ref.id == requested }
+        return unsupported_feature_result("Unsupported JSON backend #{requested}.")
+      end
 
-      parse_json(source, dialect)
+      json_feature_profile.merge(
+        backend: requested,
+        backend_ref: TREE_SITTER_BACKEND.to_h
+      )
     end
 
-    def parse_json(source, dialect)
-      normalized_source = dialect == "jsonc" ? strip_json_comments(source) : source
-      allows_comments = dialect == "jsonc"
-      return parse_failure("Trailing commas are not supported for #{dialect}.") if detect_trailing_comma(normalized_source)
+    def json_plan_context(backend: nil)
+      profile = json_backend_feature_profile(backend: backend)
+      return profile if profile[:ok] == false
 
-      parsed = JSON.parse(normalized_source)
-      canonical = JSON.generate(parsed)
-      analysis = {
-        kind: "json",
-        dialect: dialect,
-        allows_comments: allows_comments,
-        normalized_source: canonical,
-        root_kind: json_root_kind(parsed),
-        owners: collect_json_owners(parsed)
+      {
+        family_profile: json_feature_profile,
+        feature_profile: {
+          backend: profile[:backend],
+          supports_dialects: true,
+          supported_policies: profile[:supported_policies]
+        }
       }
+    end
+
+    def parse_json(source, dialect, backend: nil)
+      dialect = normalize_json_dialect(dialect)
+      requested = requested_json_backend_id(backend)
+      unless json_backend_available_for_analysis?(requested, dialect: dialect)
+        return unsupported_feature_result("Unsupported JSON backend #{requested}.")
+      end
+
+      if dialect == :json && detect_trailing_comma(source)
+        return parse_failure("Trailing commas are not supported for #{dialect}.")
+      end
+      if dialect == :json && detect_json_comments(source)
+        return parse_failure("Comments are not supported for #{dialect}.")
+      end
+
+      register_backend!
+      analysis = TreeHaver.with_backend(requested) { FileAnalysis.new(source, dialect: dialect) }
+      unless analysis.valid?
+        return parse_failure(analysis.errors.map do |error|
+          error.respond_to?(:message) ? error.message : error.inspect
+        end.join(', '))
+      end
+
       {
         ok: true,
         diagnostics: [],
-        analysis: analysis
+        analysis: {
+          dialect: dialect.to_s,
+          allows_comments: %i[jsonc json5].include?(dialect),
+          root_kind: json_analysis_root_kind(analysis),
+          owners: collect_file_analysis_owners(analysis)
+        },
+        policies: []
       }
-    rescue JSON::ParserError => e
+    rescue TreeHaver::Error, StandardError => e
       parse_failure(e.message)
     end
 
     def match_json_owners(template, destination)
-      destination_paths = destination[:owners].to_h { |owner| [owner[:path], true] }
-      template_paths = template[:owners].to_h { |owner| [owner[:path], true] }
-
-      {
-        matched: template[:owners].filter_map do |owner|
-          next unless destination_paths[owner[:path]]
-
-          { template_path: owner[:path], destination_path: owner[:path] }
-        end,
-        unmatched_template: template[:owners].map { |owner| owner[:path] }.reject { |path| destination_paths[path] },
-        unmatched_destination: destination[:owners].map { |owner| owner[:path] }.reject { |path| template_paths[path] }
-      }
+      Ast::Merge::OwnerSelection.match_by_path(template, destination)
     end
 
-    def merge_json(template_source, destination_source, dialect)
-      template_result = parse_json(template_source, dialect)
+    def merge_json(template_source, destination_source, dialect, backend: nil)
+      dialect = normalize_json_dialect(dialect)
+      requested = requested_json_backend_id(backend)
+      unless json_backend_available_for_analysis?(requested, dialect: dialect)
+        return unsupported_feature_result("Unsupported JSON backend #{requested}.")
+      end
+
+      template_result = parse_json(template_source, dialect, backend: requested)
       return { ok: false, diagnostics: template_result[:diagnostics] } unless template_result[:ok]
 
-      destination_result = parse_json(destination_source, dialect)
+      destination_result = parse_json(destination_source, dialect, backend: requested)
       if destination_result[:ok]
-        output = JSON.generate(
-          merge_json_values(
-            JSON.parse(template_result.dig(:analysis, :normalized_source)),
-            JSON.parse(destination_result.dig(:analysis, :normalized_source))
-          )
-        )
         return {
           ok: true,
           diagnostics: [],
-          output: output,
+          output: TreeHaver.with_backend(requested) do
+            merge_json_sources(template_source, destination_source, dialect: dialect)
+          end,
           policies: [DESTINATION_WINS_ARRAY_POLICY]
         }
       end
 
-      fallback_source = try_destination_trailing_comma_fallback(destination_source)
-      if fallback_source
-        retried = parse_json(fallback_source, dialect)
-        if retried[:ok]
-          output = JSON.generate(
-            merge_json_values(
-              JSON.parse(template_result.dig(:analysis, :normalized_source)),
-              JSON.parse(retried.dig(:analysis, :normalized_source))
-            )
-          )
-          return {
-            ok: true,
-            diagnostics: [
-              fallback_applied("stripped trailing commas from destination before retrying json merge.")
-            ],
-            output: output,
-            policies: [DESTINATION_WINS_ARRAY_POLICY, TRAILING_COMMA_FALLBACK_POLICY]
-          }
-        end
-      end
-
       {
         ok: false,
         diagnostics: destination_result[:diagnostics].map do |diagnostic|
-          diagnostic[:category] == "parse_error" ? diagnostic.merge(category: "destination_parse_error") : diagnostic
+          diagnostic[:category] == 'parse_error' ? diagnostic.merge(category: 'destination_parse_error') : diagnostic
         end
       }
     end
 
+    def merge_json_sources(template_source, destination_source, dialect:)
+      SmartMerger.new(
+        template_source,
+        destination_source,
+        dialect: dialect,
+        add_template_only_nodes: true,
+        merge_arrays: false,
+        preserve_atomic_formatting: true
+      ).merge_result.to_json
+    end
+    private_class_method :merge_json_sources
+
+    def json_value_for_source(source, dialect: 'json', backend: nil)
+      dialect = normalize_json_dialect(dialect)
+      requested = requested_json_backend_id(backend)
+      unless json_backend_available_for_analysis?(requested, dialect: dialect)
+        raise ParseError, "Unsupported JSON backend #{requested}."
+      end
+
+      if dialect == :json && detect_trailing_comma(source)
+        raise ParseError,
+              "Trailing commas are not supported for #{dialect}."
+      end
+      raise ParseError, "Comments are not supported for #{dialect}." if dialect == :json && detect_json_comments(source)
+
+      register_backend!
+      analysis = TreeHaver.with_backend(requested) { FileAnalysis.new(source, dialect: dialect) }
+      unless analysis.valid?
+        message = analysis.errors.map { |error| error.respond_to?(:message) ? error.message : error.inspect }.join(', ')
+        raise ParseError, message
+      end
+
+      json_value_for_node(analysis.root_node, dialect: dialect)
+    end
+
+    def json_value_for_node(node, dialect: :json)
+      case node.type.to_s
+      when 'document'
+        child = node.semantic_children.first
+        if child
+          json_value_for_node(NodeWrapper.new(child, lines: node.lines, source: node.source, dialect: dialect),
+                              dialect: dialect)
+        end
+      when 'object'
+        node.pairs.each_with_object({}) do |pair, object|
+          key = pair.key_name
+          next unless key
+
+          object[key] = json_value_for_node(pair.value_node, dialect: dialect)
+        end
+      when 'array'
+        node.elements.map { |element| json_value_for_node(element, dialect: dialect) }
+      when 'string'
+        decode_string_literal(node.text, dialect: dialect)
+      when 'number'
+        parse_number_literal(node.text, dialect: dialect)
+      when 'true'
+        true
+      when 'false'
+        false
+      when 'null'
+        nil
+      end
+    end
+
+    def object_key_for_literal(text, dialect: :json)
+      literal = text.to_s
+      return literal if dialect == :json5 && !%w[' "].include?(literal[0])
+
+      decode_string_literal(literal, dialect: dialect)
+    end
+
+    def decode_string_literal(text, dialect: :json)
+      return decode_json_string_literal(text) unless dialect == :json5
+
+      decode_json5_string_literal(text)
+    end
+
+    def decode_json_string_literal(text)
+      literal = text.to_s
+      literal = literal[1...-1] if literal.start_with?('"') && literal.end_with?('"')
+      literal.gsub(%r{\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4})}) do |escape|
+        case escape
+        when '\\"' then '"'
+        when '\\\\' then '\\'
+        when '\\/' then '/'
+        when '\\b' then "\b"
+        when '\\f' then "\f"
+        when '\\n' then "\n"
+        when '\\r' then "\r"
+        when '\\t' then "\t"
+        else
+          [escape[2..].to_i(16)].pack('U')
+        end
+      end
+    end
+    private_class_method :decode_json_string_literal
+
+    def decode_json5_string_literal(text)
+      literal = text.to_s
+      return literal unless literal.length >= 2 && %w[' "].include?(literal[0]) && literal[-1] == literal[0]
+
+      body = literal[1...-1]
+      result = +''
+      index = 0
+      while index < body.length
+        char = body[index]
+        unless char == '\\'
+          result << char
+          index += 1
+          next
+        end
+
+        index += 1
+        escape = body[index]
+        break unless escape
+
+        case escape
+        when "\n"
+          # JSON5 line continuations contribute no character.
+        when "\r"
+          index += 1 if body[index + 1] == "\n"
+        when 'b' then result << "\b"
+        when 'f' then result << "\f"
+        when 'n' then result << "\n"
+        when 'r' then result << "\r"
+        when 't' then result << "\t"
+        when 'v' then result << "\v"
+        when '0' then result << "\0"
+        when 'x'
+          hex = body[(index + 1), 2]
+          result << hex.to_i(16).chr(Encoding::UTF_8) if hex&.match?(/\A[0-9a-fA-F]{2}\z/)
+          index += 2
+        when 'u'
+          hex = body[(index + 1), 4]
+          result << [hex.to_i(16)].pack('U') if hex&.match?(/\A[0-9a-fA-F]{4}\z/)
+          index += 4
+        else
+          result << escape
+        end
+        index += 1
+      end
+      result
+    end
+    private_class_method :decode_json5_string_literal
+
+    def parse_number_literal(text, dialect: :json)
+      return parse_json_number(text) unless dialect == :json5
+
+      literal = text.to_s.delete('_')
+      return Float::INFINITY if ['Infinity', '+Infinity'].include?(literal)
+      return -Float::INFINITY if literal == '-Infinity'
+      return Float::NAN if %w[NaN +NaN -NaN].include?(literal)
+
+      Integer(literal, 0)
+    rescue ArgumentError
+      Float(literal)
+    end
+
+    def parse_json_number(text)
+      number = text.to_s
+      return number.to_f if number.match?(/[.eE]/)
+
+      number.to_i
+    end
+    private_class_method :parse_json_number
+
     def parse_failure(message)
       {
         ok: false,
@@ -134,77 +343,96 @@ module Json
     end
     private_class_method :parse_failure
 
-    def unsupported_jsonc_language_pack_result
-      {
-        ok: false,
-        diagnostics: [
-          unsupported_feature("tree-sitter-language-pack json parsing currently supports only the json dialect.")
-        ]
-      }
+    def requested_json_backend_id(backend)
+      return backend.to_s unless backend.to_s.empty?
+
+      current = TreeHaver.current_backend_id
+      return current if json_backend_available_for_analysis?(current)
+
+      available_json_backends.find do |backend_ref|
+        json_backend_available_for_analysis?(backend_ref.id)
+      end&.id || TREE_SITTER_BACKEND.id
+    end
+    private_class_method :requested_json_backend_id
+
+    def json_backend_available_for_analysis?(backend_id, dialect: :json)
+      register_backend!
+      languages = %i[jsonc json5].include?(dialect) ? [:json5] : [:json]
+      case backend_id.to_s
+      when TREE_SITTER_BACKEND.id
+        languages.all? do |language|
+          registrations = TreeHaver.registered_languages(language)
+          registrations.key?(:tree_sitter) || registrations.key?(:tslp)
+        end
+      else
+        false
+      end
+    end
+    private_class_method :json_backend_available_for_analysis?
+
+    def normalize_json_dialect(dialect)
+      normalized = dialect.to_s.downcase
+      return normalized.to_sym if %w[json jsonc json5].include?(normalized)
+
+      raise ArgumentError, "Unsupported JSON dialect #{dialect.inspect}. Expected json, jsonc, or json5."
     end
-    private_class_method :unsupported_jsonc_language_pack_result
+    private_class_method :normalize_json_dialect
 
     def parse_error(message)
-      { severity: "error", category: "parse_error", message: message }
+      { severity: 'error', category: 'parse_error', message: message }
     end
     private_class_method :parse_error
 
     def unsupported_feature(message)
-      { severity: "error", category: "unsupported_feature", message: message }
+      { severity: 'error', category: 'unsupported_feature', message: message }
     end
     private_class_method :unsupported_feature
 
-    def fallback_applied(message)
-      { severity: "warning", category: "fallback_applied", message: message }
+    def unsupported_feature_result(message)
+      { ok: false, diagnostics: [unsupported_feature(message)], policies: [] }
     end
-    private_class_method :fallback_applied
+    private_class_method :unsupported_feature_result
 
-    def json_root_kind(value)
-      return "object" if value.is_a?(Hash)
-      return "array" if value.is_a?(Array)
+    def json_analysis_root_kind(analysis)
+      root = analysis.root_object || analysis.root_node
+      return 'object' if root&.object?
+      return 'array' if root&.array?
 
-      "scalar"
+      'scalar'
     end
-    private_class_method :json_root_kind
+    private_class_method :json_analysis_root_kind
+
+    def collect_file_analysis_owners(analysis)
+      root = analysis.root_object || analysis.root_node
+      return [] unless root
 
-    def collect_json_owners(value, path = "")
-      if value.is_a?(Hash)
-        value.keys.sort.flat_map do |key|
-          next_path = "#{path}/#{key}"
-          [{ path: next_path, owner_kind: "member", match_key: key }] + collect_json_owners(value[key], next_path)
+      collect_json_node_owners(root, '')
+        .sort_by { |owner| owner.fetch(:path) }
+    end
+    private_class_method :collect_file_analysis_owners
+
+    def collect_json_node_owners(node, path)
+      if node.object?
+        node.pairs.flat_map do |pair|
+          key = pair.key_name
+          next [] unless key
+
+          owner_path = "#{path}/#{key}"
+          value = pair.value_node
+          [{ path: owner_path, owner_kind: 'member', match_key: key }] +
+            (value ? collect_json_node_owners(value, owner_path) : [])
         end
-      elsif value.is_a?(Array)
-        value.each_with_index.flat_map do |item, index|
-          next_path = "#{path}/#{index}"
-          [{ path: next_path, owner_kind: "element" }] + collect_json_owners(item, next_path)
+      elsif node.array?
+        node.elements.each_with_index.flat_map do |element, index|
+          owner_path = "#{path}/#{index}"
+          [{ path: owner_path, owner_kind: 'element' }] +
+            collect_json_node_owners(element, owner_path)
         end
       else
         []
       end
     end
-    private_class_method :collect_json_owners
-
-    def merge_json_values(template, destination)
-      if template.is_a?(Hash) && destination.is_a?(Hash)
-        ordered_merge_keys(template, destination).each_with_object({}) do |key, merged|
-          if !template.key?(key)
-            merged[key] = destination[key]
-          elsif !destination.key?(key)
-            merged[key] = template[key]
-          else
-            merged[key] = merge_json_values(template[key], destination[key])
-          end
-        end
-      else
-        destination
-      end
-    end
-    private_class_method :merge_json_values
-
-    def ordered_merge_keys(template, destination)
-      template.keys + destination.keys.reject { |key| template.key?(key) }
-    end
-    private_class_method :ordered_merge_keys
+    private_class_method :collect_json_node_owners
 
     def detect_trailing_comma(source)
       state = scanner_state
@@ -213,154 +441,29 @@ module Json
         advance_scanner_state(state, char, next_char)
         next if state[:in_line_comment] || state[:in_block_comment] || state[:in_string]
 
-        if char == ","
+        if char == ','
           lookahead = source[(index + 1)..]
           next unless lookahead
 
           trimmed = lookahead.lstrip
-          return true if trimmed.start_with?("]", "}")
+          return true if trimmed.start_with?(']', '}')
         end
       end
       false
     end
     private_class_method :detect_trailing_comma
 
-    def strip_json_comments(source)
-      result = +""
-      state = scanner_state
-      index = 0
-      while index < source.length
-        char = source[index]
-        next_char = source[index + 1]
-
-        if state[:in_line_comment]
-          if char == "\n"
-            state[:in_line_comment] = false
-            result << "\n"
-          end
-          index += 1
-          next
-        end
-
-        if state[:in_block_comment]
-          if char == "*" && next_char == "/"
-            state[:in_block_comment] = false
-            index += 2
-            next
-          end
-          index += 1
-          next
-        end
-
-        if state[:in_string]
-          result << char
-          if state[:escaped]
-            state[:escaped] = false
-          elsif char == "\\"
-            state[:escaped] = true
-          elsif char == "\""
-            state[:in_string] = false
-          end
-          index += 1
-          next
-        end
-
-        if char == "\""
-          state[:in_string] = true
-          result << char
-          index += 1
-          next
-        end
-
-        if char == "/" && next_char == "/"
-          state[:in_line_comment] = true
-          index += 2
-          next
-        end
-
-        if char == "/" && next_char == "*"
-          state[:in_block_comment] = true
-          index += 2
-          next
-        end
-
-        result << char
-        index += 1
-      end
-      result
-    end
-    private_class_method :strip_json_comments
-
-    def try_destination_trailing_comma_fallback(source)
-      stripped = strip_trailing_commas(source)
-      return nil if stripped == source
-
-      stripped
-    end
-    private_class_method :try_destination_trailing_comma_fallback
-
-    def strip_trailing_commas(source)
-      result = +""
+    def detect_json_comments(source)
       state = scanner_state
       source.each_char.with_index do |char, index|
         next_char = source[index + 1]
+        return true if !state[:in_string] && char == '/' && %w[/ *].include?(next_char)
 
-        if state[:in_line_comment]
-          result << char
-          state[:in_line_comment] = false if char == "\n"
-          next
-        end
-
-        if state[:in_block_comment]
-          result << char
-          if char == "*" && next_char == "/"
-            result << next_char
-            state[:in_block_comment] = false
-          end
-          next
-        end
-
-        if state[:in_string]
-          result << char
-          if state[:escaped]
-            state[:escaped] = false
-          elsif char == "\\"
-            state[:escaped] = true
-          elsif char == "\""
-            state[:in_string] = false
-          end
-          next
-        end
-
-        if char == "\""
-          state[:in_string] = true
-          result << char
-          next
-        end
-
-        if char == "/" && next_char == "/"
-          state[:in_line_comment] = true
-          result << char
-          next
-        end
-
-        if char == "/" && next_char == "*"
-          state[:in_block_comment] = true
-          result << char
-          next
-        end
-
-        if char == ","
-          lookahead = source[(index + 1)..]
-          trimmed = lookahead&.lstrip
-          next if trimmed&.start_with?("]", "}")
-        end
-
-        result << char
+        advance_scanner_state(state, char, next_char)
       end
-      result
+      false
     end
-    private_class_method :strip_trailing_commas
+    private_class_method :detect_json_comments
 
     def scanner_state
       {
@@ -379,29 +482,41 @@ module Json
       end
 
       if state[:in_block_comment]
-        state[:in_block_comment] = false if char == "*" && next_char == "/"
+        state[:in_block_comment] = false if char == '*' && next_char == '/'
         return
       end
 
       if state[:in_string]
         if state[:escaped]
           state[:escaped] = false
-        elsif char == "\\"
+        elsif char == '\\'
           state[:escaped] = true
-        elsif char == "\""
+        elsif char == '"'
           state[:in_string] = false
         end
         return
       end
 
-      if char == "\""
+      if char == '"'
         state[:in_string] = true
-      elsif char == "/" && next_char == "/"
+      elsif char == '/' && next_char == '/'
         state[:in_line_comment] = true
-      elsif char == "/" && next_char == "*"
+      elsif char == '/' && next_char == '*'
         state[:in_block_comment] = true
       end
     end
     private_class_method :advance_scanner_state
   end
 end
+
+Json::Merge.register_backend!
+
+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