yaml-merge 7.1.3 → 7.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 861dc2bba17b21e44e3e46b947e458d7e5114c376f1076648cf14f15793e9a7d
-  data.tar.gz: 246f068f78244935250454a8f5c4ca38e1735286f48252f17f023083aaeedb0e
+  metadata.gz: 48a5059a57b0ae4e4a6c114f2a867611725094229e1d813d1db3ae648ac011af
+  data.tar.gz: e9b8d83835c84f4ffdf1c0699cdc6c81c3737a9c5948711d6cf690934456fec4
 SHA512:
-  metadata.gz: d87a3509a72a8c7ab1d37e098ff47bd689d1c600228e740cca1dd08565062b17e978d8ffb985d74ef4037227354cf9e75b11f84a392fc672ac97ada2bd11bb29
-  data.tar.gz: 49e729482712daec1b3a62fd3851d4e91a728bbeed26ec5af4533adf1c8a7bc1a5f155700099a0fe6ddbf526ab7d059ea738b7d8b79cd946141e7f9652206e64
+  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.
 
@@ -277,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.3'
+      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

@@ -3,10 +3,12 @@
 require 'json'
 require 'tree_haver'
 require 'ast/merge'
-require 'psych/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 = {
@@ -15,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
@@ -90,20 +108,57 @@ 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)
-      Ast::Merge::YamlDocument.analyze(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 invalid_yaml_analysis(validated) unless validated[:ok]
+
+      yaml_analysis_result(validated[:value])
     end
 
+    def yaml_analysis_result(value)
+      {
+        ok: true,
+        diagnostics: [],
+        analysis: yaml_document_analysis(value),
+        policies: []
+      }
+    end
+    private_class_method :yaml_analysis_result
+
+    def yaml_document_analysis(value)
+      {
+        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::YamlDocument.match_owners(template, destination)
+      Ast::Merge::OwnerSelection.match_by_path(template, destination)
     end
 
     def merge_yaml(template_source, destination_source, dialect, backend: nil)
@@ -121,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)
+
+      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
 
-      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.')
+    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?
@@ -210,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')
@@ -267,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
@@ -280,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
@@ -367,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
@@ -453,8 +585,7 @@ module Yaml
     end
     private_class_method :unsupported_feature_result
   end
+  # rubocop:enable Metrics/ModuleLength
 end
 
 Yaml::Merge.register_backend!
-require_relative 'merge/provider'
-Yaml::Merge.register_provider!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yaml-merge
 version: !ruby/object:Gem::Version
-  version: 7.1.3
+  version: 7.1.4
 platform: ruby
 authors:
 - Peter H. Boling
@@ -43,42 +43,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.3
+        version: 7.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.3
-- !ruby/object:Gem::Dependency
-  name: psych-merge
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 7.1.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 7.1.3
+        version: 7.1.4
 - !ruby/object:Gem::Dependency
   name: tree_haver
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.3
+        version: 7.1.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.3
+        version: 7.1.4
 - !ruby/object:Gem::Dependency
   name: version_gem
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +94,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.0.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -118,7 +104,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 3.0.7
 - !ruby/object:Gem::Dependency
   name: bundler-audit
   requirement: !ruby/object:Gem::Requirement
@@ -216,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
@@ -226,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
@@ -236,7 +222,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.5
+        version: 3.2.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -246,7 +232,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.5
+        version: 3.2.6
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -290,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
@@ -300,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:
@@ -318,20 +304,18 @@ files:
 - lib/yaml/merge/file_analysis.rb
 - lib/yaml/merge/merge_result.rb
 - lib/yaml/merge/node_wrapper.rb
-- lib/yaml/merge/provider.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.3
-  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.3/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.3
+  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/lib/yaml/merge/provider.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Yaml
-  # Portable YAML workflow integration.
-  module Merge
-    # YAML workflow selector delegating source-preserving operations to Psych.
-    class Provider
-      BACKEND = :'kreuzberg-language-pack'
-      DELEGATED_BACKEND = :psych
-      DELEGATED_PROVIDER_ID = 'ruby.yaml.psych'
-      DEFAULT_PROFILE = :source_preserving
-
-      def provider_id = 'ruby.yaml'
-      def family = 'yaml'
-
-      def capabilities
-        {
-          operations: Ast::Merge::ProviderContract::OPERATIONS,
-          dialects: %i[yaml],
-          backends: [BACKEND],
-          profiles: [DEFAULT_PROFILE],
-          role: :workflow,
-          source_preservation: Psych::Merge.merge_provider.capabilities.fetch(:source_preservation)
-        }.freeze
-      end
-
-      Ast::Merge::ProviderContract::OPERATIONS.each do |operation|
-        define_method(operation) do |request|
-          delegated = Ast::Merge.dispatch_provider(operation, delegated_request(request))
-          delegated.merge(provider: workflow_identity(request, delegated))
-        end
-      end
-
-      private
-
-      def delegated_request(request)
-        request.merge(
-          provider_id: DELEGATED_PROVIDER_ID,
-          family: :yaml,
-          dialect: :yaml,
-          backend: DELEGATED_BACKEND,
-          profile_id: DEFAULT_PROFILE
-        )
-      end
-
-      def workflow_identity(request, delegated)
-        {
-          provider_id: provider_id,
-          family: family,
-          dialect: request[:dialect] || :yaml,
-          backend: request[:backend] || BACKEND,
-          package: PACKAGE_NAME,
-          package_version: Yaml::Merge::Version::VERSION,
-          delegated_provider: delegated_identity(delegated.fetch(:provider))
-        }
-      end
-
-      def delegated_identity(identity)
-        {
-          provider_id: identity.fetch(:provider_id),
-          backend: identity.fetch(:backend),
-          package: identity[:package],
-          package_version: identity[:package_version]
-        }.compact
-      end
-    end
-
-    class << self
-      def merge_provider
-        @merge_provider ||= Provider.new
-      end
-
-      def register_provider!(replace: false)
-        Ast::Merge.register_provider(merge_provider, replace: replace)
-      end
-    end
-  end
-end

data/sig/yaml/merge.rbs

@@ -1,21 +0,0 @@
-module Yaml
-  module Merge
-    class Provider
-      def provider_id: () -> String
-      def family: () -> String
-      def capabilities: () -> Hash[Symbol, untyped]
-      def analyze: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
-      def diff2: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
-      def merge2: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
-      def merge3: (Hash[Symbol, untyped] request) -> Hash[Symbol, untyped]
-    end
-
-    def self.merge_provider: () -> Provider
-    def self.register_provider!: (?replace: bool) -> untyped
-
-    module Version
-      VERSION: String
-    end
-    VERSION: String
-  end
-end