yaml-merge 7.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 39fe59fba26814f205fb26d2d3c0e09ec1a34a308bfe59c0c6ce74f046468711
+  data.tar.gz: dc2cdbb601a492791ba3da595aa9ec814d543428bddcbb1e0d2bdaa5cc93070c
+SHA512:
+  metadata.gz: e87f09daeb658603e7727073b4bc6d7b8ca5b7d1de4b8e4af26ed6a9c7dc65b52d08541db2c50c53bab791e01021d14b04a1ae95dd2e573428211b08e6d279cc
+  data.tar.gz: 7c0d7b2f31a4a721385218ada4ad9fe915e041fd03e4f1e9777d07a38f3ebbe1592ee01b61e666a5805ca250440284845b68007de7c780b05e520d67f3c99ef4

data/lib/yaml/merge/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Yaml
+  module Merge
+    module Version
+      VERSION = "7.0.0"
+    end
+
+    VERSION = Version::VERSION
+  end
+end

data/lib/yaml/merge.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+require "tree_haver"
+
+module Yaml
+  module Merge
+    PACKAGE_NAME = "yaml-merge"
+    DESTINATION_WINS_ARRAY_POLICY = {
+      surface: "array",
+      name: "destination_wins_array"
+    }.freeze
+    BACKEND_REFERENCE = TreeHaver::KREUZBERG_LANGUAGE_PACK_BACKEND
+
+    module_function
+
+    def yaml_feature_profile
+      {
+        family: "yaml",
+        supported_dialects: ["yaml"],
+        supported_policies: [DESTINATION_WINS_ARRAY_POLICY]
+      }
+    end
+
+    def available_yaml_backends
+      [BACKEND_REFERENCE]
+    end
+
+    def yaml_backend_feature_profile(backend: nil)
+      resolved_backend = resolve_backend(backend)
+      return unsupported_feature_result("Unsupported YAML backend #{resolved_backend}.") unless resolved_backend == BACKEND_REFERENCE.id
+
+      yaml_feature_profile.merge(
+        backend: BACKEND_REFERENCE.id,
+        backend_ref: BACKEND_REFERENCE.to_h
+      )
+    end
+
+    def yaml_plan_context(backend: nil)
+      profile = yaml_backend_feature_profile(backend: backend)
+      return profile if profile[:ok] == false
+
+      {
+        family_profile: yaml_feature_profile,
+        feature_profile: {
+          backend: profile[:backend],
+          supports_dialects: false,
+          supported_policies: profile[:supported_policies]
+        }
+      }
+    end
+
+    def parse_yaml(source, dialect, backend: nil)
+      return unsupported_feature_parse_result("Unsupported YAML dialect #{dialect}.") unless dialect == "yaml"
+
+      resolved_backend = resolve_backend(backend)
+      return unsupported_feature_parse_result("Unsupported YAML backend #{resolved_backend}.") unless resolved_backend == BACKEND_REFERENCE.id
+
+      syntax_result = TreeHaver.parse_with_language_pack(
+        TreeHaver::ParserRequest.new(source: source, language: "yaml")
+      )
+      return { ok: false, diagnostics: syntax_result[:diagnostics], policies: [] } unless syntax_result[:ok]
+
+      parsed = YAML.safe_load(source, permitted_classes: [], aliases: false)
+      analyze_yaml_document(parsed, dialect)
+    rescue StandardError => e
+      parse_error_result(e.message)
+    end
+
+    def analyze_yaml_document(parsed, dialect)
+      return unsupported_feature_parse_result("Unsupported YAML dialect #{dialect}.") unless dialect == "yaml"
+      return parse_error_result("YAML documents must parse to a mapping root.") unless parsed.is_a?(Hash)
+
+      validated = validate_yaml_node(parsed, "")
+      return { ok: false, diagnostics: [validated[:diagnostic]], policies: [] } unless validated[:ok]
+
+      {
+        ok: true,
+        diagnostics: [],
+        analysis: {
+          kind: "yaml",
+          dialect: "yaml",
+          normalized_source: canonical_yaml(validated[:value]),
+          root_kind: "mapping",
+          owners: collect_yaml_owners(validated[:value])
+        },
+        policies: []
+      }
+    end
+
+    def match_yaml_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 { |owner| destination_paths[owner[:path]] }
+          .map { |owner| { template_path: owner[:path], destination_path: owner[:path] } },
+        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_yaml(template_source, destination_source, dialect, backend: nil)
+      resolved_backend = resolve_backend(backend)
+      return unsupported_feature_merge_result("Unsupported YAML backend #{resolved_backend}.") unless resolved_backend == BACKEND_REFERENCE.id
+
+      merge_yaml_with_parser(template_source, destination_source, dialect) do |source, parse_dialect|
+        parse_yaml(source, parse_dialect, backend: resolved_backend)
+      end
+    end
+
+    def merge_yaml_with_parser(template_source, destination_source, dialect)
+      template = yield(template_source, dialect)
+      return { ok: false, diagnostics: template[:diagnostics], policies: [] } unless template[:ok]
+
+      destination = yield(destination_source, dialect)
+      unless destination[:ok]
+        return {
+          ok: false,
+          diagnostics: destination[:diagnostics].map do |diagnostic|
+            diagnostic[:category] == "parse_error" ? diagnostic.merge(category: "destination_parse_error") : diagnostic
+          end,
+          policies: []
+        }
+      end
+
+      template_document = YAML.safe_load(template.dig(:analysis, :normalized_source), permitted_classes: [], aliases: false)
+      destination_document = YAML.safe_load(destination.dig(:analysis, :normalized_source), permitted_classes: [], aliases: false)
+      unless template_document.is_a?(Hash) && destination_document.is_a?(Hash)
+        return parse_error_merge_result("YAML documents must parse to a mapping root.")
+      end
+
+      {
+        ok: true,
+        diagnostics: [],
+        output: canonical_yaml(merge_yaml_mappings(template_document, destination_document)),
+        policies: [DESTINATION_WINS_ARRAY_POLICY]
+      }
+    rescue StandardError => e
+      {
+        ok: false,
+        diagnostics: [{ severity: "error", category: "destination_parse_error", message: e.message }],
+        policies: []
+      }
+    end
+
+    def resolve_backend(backend)
+      backend.to_s.empty? ? BACKEND_REFERENCE.id : backend.to_s
+    end
+    private_class_method :resolve_backend
+
+    def validate_yaml_node(value, path)
+      if scalar?(value)
+        { ok: true, value: value }
+      elsif value.is_a?(Array)
+        value.each_with_index.each_with_object({ ok: true, value: [] }) do |(item, index), memo|
+          validated = validate_yaml_node(item, "#{path}/#{index}")
+          return validated unless validated[:ok]
+
+          memo[:value] << validated[:value]
+        end
+      elsif value.is_a?(Hash)
+        value.keys.each_with_object({ ok: true, value: {} }) do |key, memo|
+          validated = validate_yaml_node(value[key], "#{path}/#{key}")
+          return validated unless validated[:ok]
+
+          memo[:value][key] = validated[:value]
+        end
+      else
+        unsupported_feature_result("Unsupported YAML value at #{display_path(path)}. Only mappings, scalar values, and sequences are supported.")
+      end
+    end
+    private_class_method :validate_yaml_node
+
+    def scalar?(value)
+      value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
+    end
+    private_class_method :scalar?
+
+    def display_path(path)
+      path.empty? ? "/" : path
+    end
+    private_class_method :display_path
+
+    def render_yaml_scalar(value)
+      if value.nil?
+        ""
+      elsif value.is_a?(String)
+        value.match?(/\A[A-Za-z0-9_.-]+\z/) ? value : JSON.generate(value)
+      elsif value == true || value == false
+        value ? "true" : "false"
+      else
+        value.to_s
+      end
+    end
+    private_class_method :render_yaml_scalar
+
+    def render_yaml_node(key, value, indent)
+      prefix = " " * indent
+      if value.is_a?(Array)
+        ["#{prefix}#{key}:"] + render_yaml_sequence(value, indent + 2)
+      elsif value.is_a?(Hash)
+        ["#{prefix}#{key}:"] + render_yaml_mapping(value, indent + 2)
+      elsif value.nil?
+        ["#{prefix}#{key}:"]
+      else
+        ["#{prefix}#{key}: #{render_yaml_scalar(value)}"]
+      end
+    end
+    private_class_method :render_yaml_node
+
+    def render_yaml_mapping(mapping, indent = 0)
+      mapping.keys.flat_map do |key|
+        render_yaml_node(key, mapping[key], indent)
+      end
+    end
+    private_class_method :render_yaml_mapping
+
+    def render_yaml_sequence(sequence, indent)
+      prefix = " " * indent
+      sequence.flat_map do |item|
+        if scalar?(item)
+          ["#{prefix}- #{render_yaml_scalar(item)}"]
+        elsif item.is_a?(Hash)
+          ["#{prefix}-"] + render_yaml_mapping(item, indent + 2)
+        elsif item.is_a?(Array)
+          ["#{prefix}-"] + render_yaml_sequence(item, indent + 2)
+        else
+          ["#{prefix}- #{render_yaml_scalar(item)}"]
+        end
+      end
+    end
+    private_class_method :render_yaml_sequence
+
+    def canonical_yaml(mapping)
+      "#{render_yaml_mapping(mapping).join("\n")}\n"
+    end
+    private_class_method :canonical_yaml
+
+    def collect_yaml_owners(mapping, prefix = "")
+      mapping.keys.sort.flat_map do |key|
+        path = "#{prefix}/#{key}"
+        value = mapping[key]
+        if value.is_a?(Array)
+          [{ path: path, owner_kind: "key_value", match_key: key }] +
+            value.each_with_index.flat_map do |item, index|
+              item_path = "#{path}/#{index}"
+              nested = item.is_a?(Hash) ? collect_yaml_owners(item, item_path) : []
+              [{ path: item_path, owner_kind: "sequence_item" }] + nested
+            end
+        elsif value.is_a?(Hash)
+          [{ path: path, owner_kind: "mapping", match_key: key }] + collect_yaml_owners(value, path)
+        else
+          [{ path: path, owner_kind: "key_value", match_key: key }]
+        end
+      end
+    end
+    private_class_method :collect_yaml_owners
+
+    def merge_yaml_mappings(template, destination)
+      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]
+        elsif template[key].is_a?(Hash) && destination[key].is_a?(Hash)
+          merged[key] = merge_yaml_mappings(template[key], destination[key])
+        else
+          merged[key] = destination[key]
+        end
+      end
+    end
+    private_class_method :merge_yaml_mappings
+
+    def ordered_merge_keys(template, destination)
+      template.keys + destination.keys.reject { |key| template.key?(key) }
+    end
+    private_class_method :ordered_merge_keys
+
+    def parse_error_result(message)
+      { ok: false, diagnostics: [{ severity: "error", category: "parse_error", message: message }], policies: [] }
+    end
+    private_class_method :parse_error_result
+
+    def unsupported_feature_parse_result(message)
+      { ok: false, diagnostics: [{ severity: "error", category: "unsupported_feature", message: message }], policies: [] }
+    end
+    private_class_method :unsupported_feature_parse_result
+
+    def unsupported_feature_merge_result(message)
+      { ok: false, diagnostics: [{ severity: "error", category: "unsupported_feature", message: message }], policies: [] }
+    end
+    private_class_method :unsupported_feature_merge_result
+
+    def parse_error_merge_result(message)
+      { ok: false, diagnostics: [{ severity: "error", category: "parse_error", message: message }], policies: [] }
+    end
+    private_class_method :parse_error_merge_result
+
+    def unsupported_feature_result(message)
+      { ok: false, diagnostic: { severity: "error", category: "unsupported_feature", message: message } }
+    end
+    private_class_method :unsupported_feature_result
+  end
+end

data/lib/yaml-merge.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "yaml/merge"

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: yaml-merge
+version: !ruby/object:Gem::Version
+  version: 7.0.0
+platform: ruby
+authors:
+- Peter H. Boling
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIEgDCCAuigAwIBAgIBATANBgkqhkiG9w0BAQsFADBDMRUwEwYDVQQDDAxwZXRl
+  ci5ib2xpbmcxFTATBgoJkiaJk/IsZAEZFgVnbWFpbDETMBEGCgmSJomT8ixkARkW
+  A2NvbTAeFw0yNTA1MDQxNTMzMDlaFw00NTA0MjkxNTMzMDlaMEMxFTATBgNVBAMM
+  DHBldGVyLmJvbGluZzEVMBMGCgmSJomT8ixkARkWBWdtYWlsMRMwEQYKCZImiZPy
+  LGQBGRYDY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEAruUoo0WA
+  uoNuq6puKWYeRYiZekz/nsDeK5x/0IEirzcCEvaHr3Bmz7rjo1I6On3gGKmiZs61
+  LRmQ3oxy77ydmkGTXBjruJB+pQEn7UfLSgQ0xa1/X3kdBZt6RmabFlBxnHkoaGY5
+  mZuZ5+Z7walmv6sFD9ajhzj+oIgwWfnEHkXYTR8I6VLN7MRRKGMPoZ/yvOmxb2DN
+  coEEHWKO9CvgYpW7asIihl/9GMpKiRkcYPm9dGQzZc6uTwom1COfW0+ZOFrDVBuV
+  FMQRPswZcY4Wlq0uEBLPU7hxnCL9nKK6Y9IhdDcz1mY6HZ91WImNslOSI0S8hRpj
+  yGOWxQIhBT3fqCBlRIqFQBudrnD9jSNpSGsFvbEijd5ns7Z9ZMehXkXDycpGAUj1
+  to/5cuTWWw1JqUWrKJYoifnVhtE1o1DZ+LkPtWxHtz5kjDG/zR3MG0Ula0UOavlD
+  qbnbcXPBnwXtTFeZ3C+yrWpE4pGnl3yGkZj9SMTlo9qnTMiPmuWKQDatAgMBAAGj
+  fzB9MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQWBBQE8uWvNbPVNRXZ
+  HlgPbc2PCzC4bjAhBgNVHREEGjAYgRZwZXRlci5ib2xpbmdAZ21haWwuY29tMCEG
+  A1UdEgQaMBiBFnBldGVyLmJvbGluZ0BnbWFpbC5jb20wDQYJKoZIhvcNAQELBQAD
+  ggGBAJbnUwfJQFPkBgH9cL7hoBfRtmWiCvdqdjeTmi04u8zVNCUox0A4gT982DE9
+  wmuN12LpdajxZONqbXuzZvc+nb0StFwmFYZG6iDwaf4BPywm2e/Vmq0YG45vZXGR
+  L8yMDSK1cQXjmA+ZBKOHKWavxP6Vp7lWvjAhz8RFwqF9GuNIdhv9NpnCAWcMZtpm
+  GUPyIWw/Cw/2wZp74QzZj6Npx+LdXoLTF1HMSJXZ7/pkxLCsB8m4EFVdb/IrW/0k
+  kNSfjtAfBHO8nLGuqQZVH9IBD1i9K6aSs7pT6TW8itXUIlkIUI2tg5YzW6OFfPzq
+  QekSkX3lZfY+HTSp/o+YvKkqWLUV7PQ7xh1ZYDtocpaHwgxe/j3bBqHE+CUPH2vA
+  0V/FwdTRWcwsjVoOJTrYcff8pBZ8r2MvtAc54xfnnhGFzeRHfcltobgFxkAXdE6p
+  DVjBtqT23eugOqQ73umLcYDZkc36vnqGxUBSsXrzY9pzV5gGr2I8YUxMqf6ATrZt
+  L9nRqA==
+  -----END CERTIFICATE-----
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ast-merge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: tree_haver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+description: Portable YAML analysis, owner matching, and merge behavior for Structured
+  Merge.
+email:
+- info@structuredmerge.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/yaml-merge.rb
+- lib/yaml/merge.rb
+- lib/yaml/merge/version.rb
+homepage: https://github.com/structuredmerge/structuredmerge-ruby
+licenses:
+- AGPL-3.0-only
+- PolyForm-Small-Business-1.0.0
+metadata:
+  homepage_uri: https://structuredmerge.org
+  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.0.0
+  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.0.0/CHANGELOG.md
+  bug_tracker_uri: https://github.com/structuredmerge/structuredmerge-ruby/issues
+  documentation_uri: https://www.rubydoc.info/gems/yaml-merge/7.0.0
+  funding_uri: https://github.com/sponsors/pboling
+  wiki_uri: https://github.com/structuredmerge/structuredmerge-ruby/wiki
+  discord_uri: https://discord.gg/3qme4XHNKN
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Structured Merge YAML analysis and merge for Ruby
+test_files: []