yaml-merge 7.1.1 → 7.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4c26a79265545e7b520e68b2d4c68c5462968352f99b7bcd084a7135648cfc72
-  data.tar.gz: '092b5b792e8e73c4deab1ac3daca37171b8a3b65ae78917369ced3c46536f4d1'
+  metadata.gz: 48a5059a57b0ae4e4a6c114f2a867611725094229e1d813d1db3ae648ac011af
+  data.tar.gz: e9b8d83835c84f4ffdf1c0699cdc6c81c3737a9c5948711d6cf690934456fec4
 SHA512:
-  metadata.gz: 2cc02e011d243ac5c3514df795144d5934b0ce4c144c92f19f946a5e0773c4ecdd97da17218bbfb224fd925e40328c84d64ebea18f7741fc6f5998e5021dc5b2
-  data.tar.gz: f2e12622a2ea98eca51165bc28dbe1db6e58c0e9ec5bd3ad115b7be4c075b44787c0cbc3ee4c4315527c44dcf22e13f87932a0163ad1fad6d6038a1f27162bf3
+  metadata.gz: 680650bcce9925958c92b042b9873d71b33fd3509e847d8dfed3f6c4d3fad7041b359f1310b30b4a4f00828c73414ef02e1538e1e8894568f71b3ce7fb30577f
+  data.tar.gz: 33843a20386ebc9c5d59e5815b952f814880706a38bbe6c45f9295469438e3e69d664dc69200e09113985f2d326262ed8e388092a37eee5eb0080d23455e7548

data/README.md

@@ -23,22 +23,22 @@ I've summarized my thoughts in [this blog post](https://dev.to/galtzo/hostile-ta
 
 `Yaml::Merge` is the canonical YAML family package. It is the YAML substrate for
 StructuredMerge Ruby: it registers the tree-sitter YAML path and should own the
-shared YAML merge behavior used by all YAML backends, including `psych-merge`.
-YAML parsing and backend selection enter through `tree_haver`; source-preserving
+shared YAML merge behavior used by provider implementations. YAML parsing and
+backend selection enter through `tree_haver`; source-preserving
 partial document insertion, replacement, and removal should enter through
 `ast-crispr`; merge orchestration should use `ast-merge`.
 
-Direct parser calls in YAML merge behavior are a smell. Tree-sitter YAML details
-belong behind the TreeHaver backend path, and Psych details belong behind the
-Psych TreeHaver backend. YAML-family code should operate on normalized owners,
-ranges, comments, and edit plans rather than native Ruby Hash/Array round-trips.
+Direct parser calls in YAML merge behavior are a smell. Parser-specific details
+belong behind the provider boundary. YAML-family code should operate on
+normalized owners, ranges, comments, and edit plans rather than native Ruby
+Hash/Array round-trips.
 
 ### Key Features
 
 - YAML mapping-root validation.
 - Backend feature profiles for the shared language-pack parser.
 - Path-based owner matching for mapping entries.
-- Shared YAML-family merge semantics for provider gems such as `psych-merge`.
+- Shared YAML-family merge semantics for provider gems.
 - Destination-wins array policy.
 - Hash result API for fixture runners and higher-level tools.
 
@@ -57,7 +57,7 @@ ranges, comments, and edit plans rather than native Ruby Hash/Array round-trips.
 
 ### Compatibility
 
-Compatible with MRI Ruby 4.0.0+, and concordant releases of JRuby, and TruffleRuby.
+Compatible with MRI Ruby 4.0.0+, JRuby, and TruffleRuby.
 CI workflows and Appraisals are generated for MRI Ruby 4.0.0+.
 This test floor is configured by `ruby.test_minimum` in `.kettle-jem.yml` and
 may be higher than the gem's runtime compatibility floor when legacy Rubies are
@@ -132,20 +132,12 @@ See [SECURITY.md][🔐security].
 ## 🤝 Contributing
 
 If you need some ideas of where to help, you could work on adding more code coverage,
-or if it is already 💯 (see [below](#code-coverage)) check [issues][🤝gh-issues] or [PRs][🤝gh-pulls],
-or use the gem and think about how it could be better.
+check [issues][🤝gh-issues] or [PRs][🤝gh-pulls], or use the gem and think about how it could be better.
 
 We [![Keep A Changelog][📗keep-changelog-img]][📗keep-changelog] so if you make changes, remember to update it.
 
 See [CONTRIBUTING.md][🤝contributing] for more detailed instructions.
 
-### Code Coverage
-
-<details markdown="1">
-<summary>Coverage service badges</summary>
-
-</details>
-
 ## 📌 Versioning
 
 This library follows [![Semantic Versioning 2.0.0][📌semver-img]][📌semver] for its public API where practical.
@@ -285,7 +277,7 @@ If none of the available licenses suit your use case, please [contact us](mailto
 [📌gitmoji]: https://gitmoji.dev
 [📌gitmoji-img]: https://img.shields.io/badge/gitmoji_commits-%20%F0%9F%98%9C%20%F0%9F%98%8D-34495e.svg?style=flat-square
 [🧮kloc]: https://www.youtube.com/watch?v=dQw4w9WgXcQ
-[🧮kloc-img]: https://img.shields.io/badge/KLOC-0.606-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
+[🧮kloc-img]: https://img.shields.io/badge/KLOC-0.667-FFDD67.svg?style=for-the-badge&logo=YouTube&logoColor=blue
 [🔐security]: https://github.com/structuredmerge/structuredmerge-ruby/blob/main/SECURITY.md
 [🔐security-img]: https://img.shields.io/badge/security-policy-259D6C.svg?style=flat
 [📄copyright-notice-explainer]: https://opensource.stackexchange.com/questions/5778/why-do-licenses-such-as-the-mit-license-specify-a-single-year

data/lib/yaml/merge/version.rb

@@ -5,7 +5,7 @@ module Yaml
     # Version namespace for this gem.
     module Version
       # Current gem version.
-      VERSION = '7.1.1'
+      VERSION = '7.1.4'
     end
     # Current gem version exposed at the traditional constant location.
     VERSION = Version::VERSION # Traditional Constant Location

data/lib/yaml/merge.rb

@@ -6,6 +6,9 @@ require 'ast/merge'
 require_relative 'merge/version'
 
 module Yaml
+  # The YAML language layer owns this parser-neutral contract. Keep this
+  # facade co-located so psych-merge can depend on it without a reverse edge.
+  # rubocop:disable Metrics/ModuleLength -- the public YAML facade owns this structural boundary
   module Merge
     PACKAGE_NAME = 'yaml-merge'
     DESTINATION_WINS_ARRAY_POLICY = {
@@ -14,6 +17,22 @@ module Yaml
     }.freeze
     BACKEND_REFERENCE = TreeHaver::KREUZBERG_LANGUAGE_PACK_BACKEND
     BACKEND_REGISTRY = Struct.new(:registered, :mutex).new(false, Mutex.new)
+    YAML_TREE_NODE_HANDLERS = {
+      child: :yaml_value_from_tree_child_node,
+      mapping: :yaml_mapping_from_tree_node,
+      sequence: :yaml_sequence_from_tree_node,
+      scalar: :yaml_scalar_from_tree_node
+    }.freeze
+    YAML_DOUBLE_QUOTE_ESCAPES = {
+      '"' => '"',
+      '\\' => '\\',
+      '/' => '/',
+      'b' => "\b",
+      'f' => "\f",
+      'n' => "\n",
+      'r' => "\r",
+      't' => "\t"
+    }.freeze
 
     class Error < Ast::Merge::Error; end
     class ParseError < Ast::Merge::ParseError; end
@@ -89,48 +108,58 @@ module Yaml
         return unsupported_feature_parse_result("Unsupported YAML backend #{diagnostic_backend}.")
       end
 
-      tree = parse_tree_sitter_source(:yaml, source, backend: requested)
-      collect_parse_errors(tree.root_node)
-
-      analyze_yaml_document(yaml_value_from_tree(tree.root_node, source), dialect)
+      parse_yaml_tree(source, dialect, requested)
     rescue TreeHaver::Error, StandardError => e
       parse_error_result(e.message)
     end
 
+    def parse_yaml_tree(source, dialect, backend)
+      tree = parse_tree_sitter_source(:yaml, source, backend: backend)
+      collect_parse_errors(tree.root_node)
+      analyze_yaml_document(yaml_value_from_tree(tree.root_node, source), dialect)
+    end
+    private_class_method :parse_yaml_tree
+
     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]
+      return invalid_yaml_analysis(validated) unless validated[:ok]
+
+      yaml_analysis_result(validated[:value])
+    end
 
+    def yaml_analysis_result(value)
       {
         ok: true,
         diagnostics: [],
-        analysis: {
-          kind: 'yaml',
-          dialect: 'yaml',
-          normalized_source: canonical_yaml(validated[:value]),
-          document: validated[:value],
-          root_kind: 'mapping',
-          owners: collect_yaml_owners(validated[:value])
-        },
+        analysis: yaml_document_analysis(value),
         policies: []
       }
     end
+    private_class_method :yaml_analysis_result
 
-    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] }
-
+    def yaml_document_analysis(value)
       {
-        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] }
+        kind: 'yaml',
+        dialect: 'yaml',
+        normalized_source: canonical_yaml(value),
+        document: value,
+        root_kind: 'mapping',
+        owners: collect_yaml_owners(value)
       }
     end
+    private_class_method :yaml_document_analysis
+
+    def invalid_yaml_analysis(validated)
+      { ok: false, diagnostics: [validated[:diagnostic]], policies: [] }
+    end
+    private_class_method :invalid_yaml_analysis
+
+    def match_yaml_owners(template, destination)
+      Ast::Merge::OwnerSelection.match_by_path(template, destination)
+    end
 
     def merge_yaml(template_source, destination_source, dialect, backend: nil)
       requested = backend.to_s.empty? ? nil : backend.to_s
@@ -147,45 +176,71 @@ module Yaml
 
     def merge_yaml_with_parser(template_source, destination_source, dialect, backend: nil)
       template = yield(template_source, dialect)
-      return { ok: false, diagnostics: template[:diagnostics], policies: [] } unless template[:ok]
+      return parser_failure_result(template, :template) 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
+      return parser_failure_result(destination, :destination) unless destination[:ok]
+
+      return parse_error_merge_result('YAML documents must parse to a mapping root.') unless
+        yaml_parse_results_valid?(template, destination)
 
-      template_document = template.dig(:analysis, :document)
-      destination_document = destination.dig(:analysis, :document)
-      unless template_document.is_a?(Hash) && destination_document.is_a?(Hash)
-        return parse_error_merge_result('YAML documents must parse to a mapping root.')
+      yaml_merge_result(template_source, destination_source, backend)
+    rescue StandardError => e
+      parser_exception_result(e)
+    end
+
+    def parser_exception_result(error)
+      {
+        ok: false,
+        diagnostics: [{ severity: 'error', category: 'destination_parse_error', message: error.message }],
+        policies: []
+      }
+    end
+    private_class_method :parser_exception_result
+
+    def parser_failure_result(result, role)
+      diagnostics = result[:diagnostics]
+      if role == :destination
+        diagnostics = diagnostics.map do |diagnostic|
+          diagnostic[:category] == 'parse_error' ? diagnostic.merge(category: 'destination_parse_error') : diagnostic
+        end
       end
 
+      { ok: false, diagnostics: diagnostics, policies: [] }
+    end
+    private_class_method :parser_failure_result
+
+    def yaml_documents?(template_document, destination_document)
+      template_document.is_a?(Hash) && destination_document.is_a?(Hash)
+    end
+    private_class_method :yaml_documents?
+
+    def yaml_parse_results_valid?(template, destination)
+      yaml_documents?(template.dig(:analysis, :document), destination.dig(:analysis, :document))
+    end
+    private_class_method :yaml_parse_results_valid?
+
+    def yaml_merge_result(template_source, destination_source, backend)
       {
         ok: true,
         diagnostics: [],
-        output: with_tree_sitter_backend(backend) do
-          SmartMerger.new(
-            template_source,
-            destination_source,
-            add_template_only_nodes: true,
-            merge_sequences: false
-          ).merge_result.to_yaml
-        end,
+        output: yaml_merge_output(template_source, destination_source, backend),
         policies: [DESTINATION_WINS_ARRAY_POLICY]
       }
-    rescue StandardError => e
-      {
-        ok: false,
-        diagnostics: [{ severity: 'error', category: 'destination_parse_error', message: e.message }],
-        policies: []
-      }
     end
+    private_class_method :yaml_merge_result
+
+    def yaml_merge_output(template_source, destination_source, backend)
+      with_tree_sitter_backend(backend) do
+        SmartMerger.new(
+          template_source,
+          destination_source,
+          add_template_only_nodes: true,
+          merge_sequences: false
+        ).merge_result.to_yaml
+      end
+    end
+    private_class_method :yaml_merge_output
 
     def resolve_backend(backend)
       return backend.to_s unless backend.to_s.empty?
@@ -236,30 +291,61 @@ module Yaml
 
     def yaml_value_from_tree(node, source)
       named = yaml_named_children(node)
-      case node.type
-      when 'stream', 'document', 'block_node', 'flow_node'
-        return nil if named.empty?
-
-        yaml_value_from_tree(named.first, source)
-      when 'block_mapping', 'flow_mapping'
-        yaml_mapping_from_node(node, source)
-      when 'block_sequence', 'flow_sequence'
-        yaml_sequence_from_node(node, source)
-      when 'block_sequence_item'
-        value_node = named.first
-        value_node ? yaml_value_from_tree(value_node, source) : nil
-      when 'plain_scalar', 'string_scalar', 'double_quote_scalar', 'single_quote_scalar'
-        yaml_scalar_from_text(source[node.start_byte...node.end_byte])
-      else
-        if named.length == 1
-          yaml_value_from_tree(named.first, source)
-        else
-          yaml_scalar_from_text(source[node.start_byte...node.end_byte])
-        end
-      end
+      handler = YAML_TREE_NODE_HANDLERS[yaml_tree_node_kind(node.type)]
+      return send(handler, node, named, source) if handler
+
+      yaml_value_from_unknown_tree(node, named, source)
     end
     private_class_method :yaml_value_from_tree
 
+    def yaml_tree_node_kind(type)
+      case type
+      when 'stream', 'document', 'block_node', 'flow_node', 'block_sequence_item' then :child
+      when 'block_mapping', 'flow_mapping' then :mapping
+      when 'block_sequence', 'flow_sequence' then :sequence
+      when 'plain_scalar', 'string_scalar', 'double_quote_scalar', 'single_quote_scalar' then :scalar
+      end
+    end
+    private_class_method :yaml_tree_node_kind
+
+    def yaml_value_from_tree_child(named, source)
+      value_node = named.first
+      value_node ? yaml_value_from_tree(value_node, source) : nil
+    end
+    private_class_method :yaml_value_from_tree_child
+
+    def yaml_value_from_tree_child_node(_node, named, source)
+      yaml_value_from_tree_child(named, source)
+    end
+    private_class_method :yaml_value_from_tree_child_node
+
+    def yaml_mapping_from_tree_node(node, _named, source)
+      yaml_mapping_from_node(node, source)
+    end
+    private_class_method :yaml_mapping_from_tree_node
+
+    def yaml_sequence_from_tree_node(node, _named, source)
+      yaml_sequence_from_node(node, source)
+    end
+    private_class_method :yaml_sequence_from_tree_node
+
+    def yaml_scalar_from_tree_node(node, _named, source)
+      yaml_scalar_from_tree(node, source)
+    end
+    private_class_method :yaml_scalar_from_tree_node
+
+    def yaml_scalar_from_tree(node, source)
+      yaml_scalar_from_text(source[node.start_byte...node.end_byte])
+    end
+    private_class_method :yaml_scalar_from_tree
+
+    def yaml_value_from_unknown_tree(node, named, source)
+      return yaml_value_from_tree(named.first, source) if named.length == 1
+
+      yaml_scalar_from_text(source[node.start_byte...node.end_byte])
+    end
+    private_class_method :yaml_value_from_unknown_tree
+
     def yaml_mapping_from_node(node, source)
       yaml_named_children(node).each_with_object({}) do |child, mapping|
         next unless child.type.end_with?('mapping_pair')
@@ -293,12 +379,18 @@ module Yaml
 
     def yaml_scalar_from_text(text)
       stripped = text.to_s.strip
-      return nil if stripped.empty? || stripped == '~' || stripped.casecmp('null').zero?
-      return true if stripped.casecmp('true').zero?
-      return false if stripped.casecmp('false').zero?
+      case stripped.downcase
+      when '', '~', 'null' then nil
+      when 'true' then true
+      when 'false' then false
+      else yaml_numeric_or_quoted_scalar(stripped)
+      end
+    end
+    private_class_method :yaml_scalar_from_text
+
+    def yaml_numeric_or_quoted_scalar(stripped)
       return stripped.to_i if stripped.match?(/\A[-+]?\d+\z/)
       return stripped.to_f if stripped.match?(/\A[-+]?(?:\d+\.\d*|\d*\.\d+)(?:[eE][-+]?\d+)?\z/)
-
       if stripped.start_with?('"') && stripped.end_with?('"')
         return unescape_yaml_double_quoted_scalar(stripped[1...-1])
       end
@@ -306,47 +398,49 @@ module Yaml
 
       stripped
     end
-    private_class_method :yaml_scalar_from_text
+    private_class_method :yaml_numeric_or_quoted_scalar
 
     def unescape_yaml_double_quoted_scalar(value)
-      value.gsub(%r{\\(["\\/bfnrt])}) do
-        {
-          '"' => '"',
-          '\\' => '\\',
-          '/' => '/',
-          'b' => "\b",
-          'f' => "\f",
-          'n' => "\n",
-          'r' => "\r",
-          't' => "\t"
-        }.fetch(Regexp.last_match(1))
-      end
+      value.gsub(%r{\\(["\\/bfnrt])}) { YAML_DOUBLE_QUOTE_ESCAPES.fetch(Regexp.last_match(1)) }
     end
     private_class_method :unescape_yaml_double_quoted_scalar
 
     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]
+      return { ok: true, value: value } if scalar?(value)
+      return validate_yaml_collection(value, path) if value.is_a?(Array) || value.is_a?(Hash)
 
-          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
+      unsupported_feature_result(
+        "Unsupported YAML value at #{display_path(path)}. " \
+        'Only mappings, scalar values, and sequences are supported.'
+      )
     end
     private_class_method :validate_yaml_node
 
+    def validate_yaml_collection(value, path)
+      value.is_a?(Array) ? validate_yaml_array(value, path) : validate_yaml_hash(value, path)
+    end
+    private_class_method :validate_yaml_collection
+
+    def validate_yaml_array(value, path)
+      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
+    end
+    private_class_method :validate_yaml_array
+
+    def validate_yaml_hash(value, path)
+      value.each_with_object({ ok: true, value: {} }) do |(key, item), memo|
+        validated = validate_yaml_node(item, "#{path}/#{key}")
+        return validated unless validated[:ok]
+
+        memo[:value][key] = validated[:value]
+      end
+    end
+    private_class_method :validate_yaml_hash
+
     def scalar?(value)
       value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
     end
@@ -393,60 +487,72 @@ module Yaml
 
     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
+      sequence.flat_map { |item| render_yaml_sequence_item(item, prefix, indent) }
     end
     private_class_method :render_yaml_sequence
 
+    def render_yaml_sequence_item(item, prefix, indent)
+      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
+    private_class_method :render_yaml_sequence_item
+
     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
+      mapping.keys.sort.flat_map { |key| collect_yaml_owners_for_value(key, mapping[key], prefix) }
     end
     private_class_method :collect_yaml_owners
 
+    def collect_yaml_owners_for_value(key, value, prefix)
+      path = "#{prefix}/#{key}"
+      case value
+      when Array then collect_yaml_sequence_owners(key, value, path)
+      when Hash then [{ 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
+    private_class_method :collect_yaml_owners_for_value
+
+    def collect_yaml_sequence_owners(key, value, path)
+      [{ 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
+    end
+    private_class_method :collect_yaml_sequence_owners
+
     def merge_yaml_mappings(template, destination)
       ordered_merge_keys(template, destination).each_with_object({}) do |key, merged|
-        merged[key] = if !template.key?(key)
-                        destination[key]
-                      elsif !destination.key?(key)
-                        template[key]
-                      elsif template[key].is_a?(Hash) && destination[key].is_a?(Hash)
-                        merge_yaml_mappings(template[key], destination[key])
-                      else
-                        destination[key]
-                      end
+        merged[key] = merge_yaml_mapping_value(template, destination, key)
       end
     end
     private_class_method :merge_yaml_mappings
 
+    def merge_yaml_mapping_value(template, destination, key)
+      return destination[key] unless template.key?(key)
+      return template[key] unless destination.key?(key)
+      if template[key].is_a?(Hash) && destination[key].is_a?(Hash)
+        return merge_yaml_mappings(template[key],
+                                   destination[key])
+      end
+
+      destination[key]
+    end
+    private_class_method :merge_yaml_mapping_value
+
     def ordered_merge_keys(template, destination)
       template.keys + destination.keys.reject { |key| template.key?(key) }
     end
@@ -479,6 +585,7 @@ module Yaml
     end
     private_class_method :unsupported_feature_result
   end
+  # rubocop:enable Metrics/ModuleLength
 end
 
 Yaml::Merge.register_backend!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaml-merge
 version: !ruby/object:Gem::Version
-  version: 7.1.1
+  version: 7.1.4
 platform: ruby
 authors:
 - Peter H. Boling
@@ -43,28 +43,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.1
+        version: 7.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.1
+        version: 7.1.4
 - !ruby/object:Gem::Dependency
   name: tree_haver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.1
+        version: 7.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.1
+        version: 7.1.4
 - !ruby/object:Gem::Dependency
   name: version_gem
   requirement: !ruby/object:Gem::Requirement
@@ -91,20 +91,20 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.17
+        version: 3.0.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.5.17
+        version: 3.0.7
 - !ruby/object:Gem::Dependency
   name: bundler-audit
   requirement: !ruby/object:Gem::Requirement
@@ -182,7 +182,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 3.2.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -192,7 +192,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: 3.2.2
 - !ruby/object:Gem::Dependency
   name: kettle-test
   requirement: !ruby/object:Gem::Requirement
@@ -202,7 +202,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.19
+        version: 2.0.20
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -212,7 +212,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.19
+        version: 2.0.20
 - !ruby/object:Gem::Dependency
   name: turbo_tests2
   requirement: !ruby/object:Gem::Requirement
@@ -222,7 +222,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.4
+        version: 3.2.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -232,7 +232,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.4
+        version: 3.2.6
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -276,7 +276,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.11
+        version: 2.0.12
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -286,7 +286,7 @@ dependencies:
         version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.11
+        version: 2.0.12
 description: "☯️ Portable YAML analysis, owner matching, and merge behavior for Structured
   Merge."
 email:
@@ -306,17 +306,16 @@ files:
 - lib/yaml/merge/node_wrapper.rb
 - lib/yaml/merge/smart_merger.rb
 - lib/yaml/merge/version.rb
-- sig/yaml/merge.rbs
 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.1.1
-  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.1/CHANGELOG.md
+  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.1.4
+  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.4/CHANGELOG.md
   bug_tracker_uri: https://github.com/structuredmerge/structuredmerge-ruby/issues
-  documentation_uri: https://www.rubydoc.info/gems/yaml-merge/7.1.1
+  documentation_uri: https://www.rubydoc.info/gems/yaml-merge/7.1.4
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/structuredmerge/structuredmerge-ruby/wiki
   news_uri: https://www.railsbling.com/tags/yaml-merge

data/sig/yaml/merge.rbs

@@ -1,8 +0,0 @@
-module Yaml
-  module Merge
-    module Version
-      VERSION: String
-    end
-    VERSION: String
-  end
-end