json-merge 1.1.2 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38f954bb103511024a69c2d85caa277ff1de782b88cd1c9b77ff0ae4809b6568
-  data.tar.gz: 5beaadc8745638f82acac95e7d62be37dbfce579a250cde95cc9efafa329463c
+  metadata.gz: '07183e1164d6af24dd6dad4a4ded1b57b591bb5e9197bdb2fab3e49af2b176a3'
+  data.tar.gz: 3dc67caacf7ed48b31cf0f7860d9f6381fef38c68b7c5671b3a7a327c6e43240
 SHA512:
-  metadata.gz: 3b6b6dc2287465a4789a78bdc32cbbb317924ead1bf24305642946b21a5b1dece510e829cde881f2c23d1f3a31d31a789812bfe23fc7dc38e6f7729ce9953837
-  data.tar.gz: 210cfe2fa6b47a09f0949feddf641e57a499c939df837de420df8f0e7f0c4401b778922f6f1aa7a41ef9e645c2fe1a5be2330617deeaa7abb4ee15e1922e94db
+  metadata.gz: 79d8e551876b7b8cca367a73ab5d5b0041d35f649737983bb1029b85a5c7388aaa5f6f80605004183f2d107a3dff34292ca5b15ecbe38380b0efb2651d3fd2d5
+  data.tar.gz: e16ebd70f7f0b5776d1d21d290f3980031c87aa3adbd9b69c4870010f249ff6b04c5d391554390eb7dc08186b39b3f8f2efe1549a1b1e23c00586ad5d86dffd8

data/lib/json/merge/version.rb

@@ -2,11 +2,10 @@
 
 module Json
   module Merge
-    # Version information for Json::Merge
     module Version
-      # Current version of the json-merge gem
-      VERSION = "1.1.2"
+      VERSION = "7.0.0"
     end
-    VERSION = Version::VERSION # traditional location
+
+    VERSION = Version::VERSION
   end
 end

data/lib/json/merge.rb

@@ -1,125 +1,407 @@
 # frozen_string_literal: true
 
-# std libs
-require "set"
-
-# External gems
-# TreeHaver provides a unified cross-Ruby interface to tree-sitter.
-# It handles grammar discovery and backend selection automatically
-# via parser_for(:json). No manual registration needed.
+require "json"
 require "tree_haver"
-require "version_gem"
-
-# Shared merge infrastructure
-require "ast/merge"
-
-# This gem
-require_relative "merge/version"
-
-# Json::Merge provides a JSON file smart merge system using tree-sitter AST analysis.
-# It intelligently merges template and destination JSON files by identifying matching
-# keys and resolving differences using structural signatures.
-#
-# For JSONC (JSON with Comments) support, see the jsonc-merge gem which handles
-# configuration files that include comments
-# (like devcontainer.json, tsconfig.json, VS Code settings, etc.).
-#
-# @example Basic usage
-#   template = File.read("template.json")
-#   destination = File.read("destination.json")
-#   merger = Json::Merge::SmartMerger.new(template, destination)
-#   result = merger.merge
-#
-# @example With debug information
-#   merger = Json::Merge::SmartMerger.new(template, destination)
-#   debug_result = merger.merge_with_debug
-#   puts debug_result[:content]
-#   puts debug_result[:statistics]
+
 module Json
-  # Smart merge system for JSON files using tree-sitter AST analysis.
-  # Provides intelligent merging by understanding JSON structure
-  # rather than treating files as plain text.
-  #
-  # For JSONC (JSON with Comments) support, use the jsonc-merge gem instead.
-  #
-  # @see SmartMerger Main entry point for merge operations
-  # @see FileAnalysis Analyzes JSON structure
-  # @see ConflictResolver Resolves content conflicts
   module Merge
-    # Base error class for Json::Merge
-    # Inherits from Ast::Merge::Error for consistency across merge gems.
-    class Error < Ast::Merge::Error; end
-
-    # Raised when a JSON file has parsing errors.
-    # Inherits from Ast::Merge::ParseError for consistency across merge gems.
-    #
-    # @example Handling parse errors
-    #   begin
-    #     analysis = FileAnalysis.new(json_content)
-    #   rescue ParseError => e
-    #     puts "JSON syntax error: #{e.message}"
-    #     e.errors.each { |error| puts "  #{error}" }
-    #   end
-    class ParseError < Ast::Merge::ParseError
-      # @param message [String, nil] Error message (auto-generated if nil)
-      # @param content [String, nil] The JSON source that failed to parse
-      # @param errors [Array] Parse errors from tree-sitter
-      def initialize(message = nil, content: nil, errors: [])
-        super(message, errors: errors, content: content)
+    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"
+    }.freeze
+
+    module_function
+
+    def json_feature_profile
+      {
+        family: "json",
+        supported_dialects: %w[json jsonc],
+        supported_policies: [DESTINATION_WINS_ARRAY_POLICY, TRAILING_COMMA_FALLBACK_POLICY]
+      }
+    end
+
+    def json_parse_request(source, dialect)
+      TreeHaver::ParserRequest.new(source: source, language: "json", dialect: dialect)
+    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]
+
+      parse_json(source, dialect)
+    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)
+
+      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)
+      }
+      {
+        ok: true,
+        diagnostics: [],
+        analysis: analysis
+      }
+    rescue JSON::ParserError => 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] }
+      }
+    end
+
+    def merge_json(template_source, destination_source, dialect)
+      template_result = parse_json(template_source, dialect)
+      return { ok: false, diagnostics: template_result[:diagnostics] } unless template_result[:ok]
+
+      destination_result = parse_json(destination_source, dialect)
+      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,
+          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
+        end
+      }
     end
 
-    # Raised when the template file has syntax errors.
-    #
-    # @example Handling template parse errors
-    #   begin
-    #     merger = SmartMerger.new(template, destination)
-    #     result = merger.merge
-    #   rescue TemplateParseError => e
-    #     puts "Template syntax error: #{e.message}"
-    #     e.errors.each do |error|
-    #       puts "  #{error.message}"
-    #     end
-    #   end
-    class TemplateParseError < ParseError; end
-
-    # Raised when the destination file has syntax errors.
-    #
-    # @example Handling destination parse errors
-    #   begin
-    #     merger = SmartMerger.new(template, destination)
-    #     result = merger.merge
-    #   rescue DestinationParseError => e
-    #     puts "Destination syntax error: #{e.message}"
-    #     e.errors.each do |error|
-    #       puts "  #{error.message}"
-    #     end
-    #   end
-    class DestinationParseError < ParseError; end
-
-    autoload :DebugLogger, "json/merge/debug_logger"
-    autoload :Emitter, "json/merge/emitter"
-    autoload :FileAnalysis, "json/merge/file_analysis"
-    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"
-  end
-end
+    def parse_failure(message)
+      {
+        ok: false,
+        diagnostics: [parse_error(message)]
+      }
+    end
+    private_class_method :parse_failure
 
-# 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
+    def unsupported_jsonc_language_pack_result
+      {
+        ok: false,
+        diagnostics: [
+          unsupported_feature("tree-sitter-language-pack json parsing currently supports only the json dialect.")
+        ]
+      }
+    end
+    private_class_method :unsupported_jsonc_language_pack_result
+
+    def parse_error(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 }
+    end
+    private_class_method :unsupported_feature
+
+    def fallback_applied(message)
+      { severity: "warning", category: "fallback_applied", message: message }
+    end
+    private_class_method :fallback_applied
+
+    def json_root_kind(value)
+      return "object" if value.is_a?(Hash)
+      return "array" if value.is_a?(Array)
+
+      "scalar"
+    end
+    private_class_method :json_root_kind
+
+    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)
+        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)
+        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
 
-Json::Merge::Version.class_eval do
-  extend VersionGem::Basic
+    def ordered_merge_keys(template, destination)
+      template.keys + destination.keys.reject { |key| template.key?(key) }
+    end
+    private_class_method :ordered_merge_keys
+
+    def detect_trailing_comma(source)
+      state = scanner_state
+      source.each_char.with_index do |char, index|
+        next_char = source[index + 1]
+        advance_scanner_state(state, char, next_char)
+        next if state[:in_line_comment] || state[:in_block_comment] || state[:in_string]
+
+        if char == ","
+          lookahead = source[(index + 1)..]
+          next unless lookahead
+
+          trimmed = lookahead.lstrip
+          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 = +""
+      state = scanner_state
+      source.each_char.with_index do |char, index|
+        next_char = source[index + 1]
+
+        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
+      end
+      result
+    end
+    private_class_method :strip_trailing_commas
+
+    def scanner_state
+      {
+        in_string: false,
+        in_line_comment: false,
+        in_block_comment: false,
+        escaped: false
+      }
+    end
+    private_class_method :scanner_state
+
+    def advance_scanner_state(state, char, next_char)
+      if state[:in_line_comment]
+        state[:in_line_comment] = false if char == "\n"
+        return
+      end
+
+      if state[:in_block_comment]
+        state[:in_block_comment] = false if char == "*" && next_char == "/"
+        return
+      end
+
+      if state[:in_string]
+        if state[:escaped]
+          state[:escaped] = false
+        elsif char == "\\"
+          state[:escaped] = true
+        elsif char == "\""
+          state[:in_string] = false
+        end
+        return
+      end
+
+      if char == "\""
+        state[:in_string] = true
+      elsif char == "/" && next_char == "/"
+        state[:in_line_comment] = true
+      elsif char == "/" && next_char == "*"
+        state[:in_block_comment] = true
+      end
+    end
+    private_class_method :advance_scanner_state
+  end
 end

data/lib/json-merge.rb

@@ -1,6 +1,3 @@
 # frozen_string_literal: true
 
-# For technical reasons, if we move to Zeitwerk, this cannot be require_relative.
-#   See: https://github.com/fxn/zeitwerk#for_gem_extension
-# Hook for other libraries to load this library (e.g. via bundler)
-require "json/merge"
+require_relative "json/merge"