ast-merge 7.1.7 → 7.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1af004153456efec0bb60b9fba798b42f0de4ef6e1db37a77425710fc8d19de
-  data.tar.gz: 6210d3c3b11243effad45183c086d32407b978423e640ee123f7ba8113a82bc0
+  metadata.gz: 205697b391355f6dfc618a12f26c0d567e186fe148981baa5f38f16b0bf0653f
+  data.tar.gz: 304d5c93be7f48d8f98c68229b182ae9d831baf43c3987d41ce22b2c6fcdc655
 SHA512:
-  metadata.gz: 329b0d280fa31e851f2ffb15d64a36501deed7075178cca26cae049b626bcf54d42dbfdda0547759e7aa3d4a8f43245d597c812555af1963f937097d2aef05f1
-  data.tar.gz: c91310f88ccf4d3a4a7a935a7f101138b7174af7c8dc5992a69b98163670dc4bf5af28414eaae1cd96c04ef924b22af3792a86356fa6d40fc661c520a0052058
+  metadata.gz: 38c22b55d61033a0c77f2257cc65204f87ae041bcd658e00a8d5bc87b5cfb839de897679ce6e7134008972b5f19239b050d2f40d4cb6b93f0642384e30d75d2c
+  data.tar.gz: ff57c5b383ae4634dedbc89a3028a5fbe7ba44a9668a3c50c14e953323f86bd1f206177f2642d47d630d52fb2ca4e0835b11d1c649ba149b7550b4321e9edb79

data/lib/ast/merge/line_range_support.rb

@@ -18,7 +18,8 @@ module Ast
         elsif object.respond_to?(:source_position)
           object.source_position&.dig(:start_line)
         elsif object.respond_to?(:start_point) && object.start_point
-          object.start_point.row + 1
+          row = line_point_row(object.start_point)
+          row + 1 if row
         end
       end
 
@@ -30,10 +31,18 @@ module Ast
         elsif object.respond_to?(:source_position)
           object.source_position&.dig(:end_line)
         elsif object.respond_to?(:end_point) && object.end_point
-          object.end_point.row + 1
+          row = line_point_row(object.end_point)
+          row + 1 if row
         end
       end
 
+      def line_point_row(point)
+        return point.row if point.respond_to?(:row)
+        return point[:row] if point.respond_to?(:[])
+
+        nil
+      end
+
       def source_line_at(analysis, line_number)
         line = analysis.line_at(line_number)
         line.respond_to?(:raw) ? line.raw : line

data/lib/ast/merge/rspec/README.md

@@ -17,6 +17,7 @@ That loads:
 - TreeHaver backend dependency tags
 - Ast::Merge merge-gem dependency tags
 - Shared conformance fixture helpers
+- Portable provider snapshot and differential replay helpers
 - Ast::Merge shared examples
 
 ### Split loading for `ast-merge` itself or registration-heavy suites
@@ -249,3 +250,47 @@ Use this namespace for test support shared across the merge-gem family:
 - shared examples for common contracts
 
 Format-specific parser fixtures and merge behavior specs belong in the corresponding `*-merge` gem.
+
+## Provider snapshots
+
+`Ast::Merge::RSpec::ProviderSnapshot` captures the versioned parse and analysis
+projections used by the cross-runtime fixture repository. Parsing always enters
+through an explicitly selected TreeHaver backend. The capture harness only
+reads the normalized TreeHaver node contract; a provider suite supplies a
+callback for parser-native evidence:
+
+```ruby
+snapshot = Ast::Merge::RSpec::ProviderSnapshot.new(
+  snapshot_id: "snapshot.prism.ruby",
+  provider: Prism::Merge.merge_provider,
+  source: source,
+  language: :ruby,
+  dialect: :ruby,
+  backend_id: :prism,
+  parser_contract: :prism,
+  backend_identity: {
+    id: :prism,
+    family: :native,
+    host_runtime: :ruby,
+    package: :prism,
+    parser: :Prism,
+    capabilities: %i[comments directives exact_source_spans normalized_tree],
+  },
+  extension_builder: lambda do |tree:, **|
+    {
+      schema: "structuredmerge.extension/ruby-prism/v1",
+      namespace: "ruby-prism",
+      capabilities: %w[magic-comments],
+      payload: {magic_comments: tree.magic_comments.map(&:to_s)},
+    }
+  end,
+)
+
+artifacts = snapshot.capture
+```
+
+The extension callback is intentionally provider-owned. The common harness
+does not reflect over native parser objects or flatten their capabilities.
+`#differential_replay` serializes a provider request through canonical JSON,
+replays it, and reports whether the provider result and output bytes remain
+identical.

data/lib/ast/merge/rspec/provider_snapshot.rb

@@ -0,0 +1,497 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'ast/merge'
+require 'tree_haver'
+
+module Ast
+  module Merge
+    module RSpec
+      # Captures the portable TreeHaver and provider projections used by the
+      # cross-runtime contract fixtures. Native facts enter only through an
+      # explicit, namespaced extension builder supplied by the provider suite.
+      # rubocop:disable Metrics/AbcSize, Metrics/ClassLength, Metrics/MethodLength, Metrics/ParameterLists -- the capture boundary mirrors the complete versioned contract
+      class ProviderSnapshot
+        PARSE_REQUEST_SCHEMA = 'structuredmerge.parse-request/v1'
+        PARSE_RESULT_SCHEMA = 'structuredmerge.parse-result/v1'
+        ANALYSIS_RESULT_SCHEMA = 'structuredmerge.analysis-result/v1'
+        EXTENSION_SCHEMA_PATTERN = %r{\Astructuredmerge\.extension/[a-z0-9-]+/v\d+\z}
+        NORMALIZED_CONTRACT = 'structuredmerge.normalized-node/v1'
+
+        class Error < StandardError; end
+
+        attr_reader :snapshot_id, :source_id, :provider, :source, :language, :dialect, :backend_id,
+                    :backend_identity, :parser_contract, :profile_id, :extension_builder
+
+        def initialize(snapshot_id:, provider:, source:, language:, dialect:, backend_id:, backend_identity:,
+                       source_id: nil, parser_contract: nil, profile_id: :source_preserving, extension_builder: nil)
+          @snapshot_id = required_string(snapshot_id, :snapshot_id)
+          @source_id = required_string(source_id || "#{@snapshot_id}:source", :source_id)
+          @provider = provider
+          @source = source.to_s
+          @language = required_string(language, :language)
+          @dialect = required_string(dialect, :dialect)
+          @backend_id = required_string(backend_id, :backend_id)
+          @backend_identity = normalize_backend_identity(backend_identity)
+          @parser_contract = parser_contract&.to_sym
+          @profile_id = profile_id.to_sym
+          @extension_builder = extension_builder
+        end
+
+        def capture
+          tree = parse_tree
+          projection = TreeProjection.new(tree, source).call
+          provider_result = analyze
+          extensions = build_extensions(tree, projection, provider_result)
+          parse_request = build_parse_request
+          parse_result = build_parse_result(parse_request, projection, extensions)
+
+          {
+            parse_request: parse_request,
+            parse_result: parse_result,
+            analysis_result: build_analysis_result(parse_request, parse_result, provider_result, extensions)
+          }
+        end
+
+        def differential_replay(operation:, request:)
+          operation = ProviderContract.normalize_operation(operation)
+          original_request = ProviderContract.validate_request!(operation, request)
+          replay_request = ProviderContract.validate_request!(operation, self.class.round_trip(original_request))
+          original_result = ProviderContract.validate_result!(
+            operation,
+            provider.public_send(operation, original_request)
+          )
+          replay_result = ProviderContract.validate_result!(operation, provider.public_send(operation, replay_request))
+          original_json = self.class.canonical_json(original_result)
+          replay_json = self.class.canonical_json(replay_result)
+
+          {
+            operation: operation.to_s,
+            equivalent: original_json == replay_json,
+            original_sha256: Digest::SHA256.hexdigest(original_json),
+            replay_sha256: Digest::SHA256.hexdigest(replay_json),
+            output_bytes_equal: output_bytes(original_result) == output_bytes(replay_result),
+            original_request: original_request,
+            transported_request: replay_request,
+            original_result: original_result,
+            transported_result: replay_result
+          }
+        end
+
+        class << self
+          def tree_sitter_extension(nodes:, **)
+            {
+              schema: 'structuredmerge.extension/tree-sitter/v1',
+              namespace: 'tree-sitter',
+              capabilities: ['grammar-node-types'],
+              payload: {
+                grammar_node_types: nodes.map { |node| node.fetch(:native_type).to_s }.uniq.sort
+              }
+            }
+          end
+
+          def canonical_json(value)
+            JSON.generate(canonical_value(Ast::Merge.json_ready(value)))
+          end
+
+          def round_trip(value)
+            JSON.parse(canonical_json(value), symbolize_names: true)
+          end
+
+          def extension_forwarding_digest(extension)
+            forwarded = round_trip(extension.merge('x-unknown-forwarding-probe' => { 'retained' => true }))
+            Digest::SHA256.hexdigest(canonical_json(forwarded))
+          end
+
+          private
+
+          def canonical_value(value)
+            case value
+            when Array
+              value.map { |item| canonical_value(item) }
+            when Hash
+              value.keys.map(&:to_s).sort.to_h do |key|
+                item = value.key?(key) ? value[key] : value[key.to_sym]
+                [key, canonical_value(item)]
+              end
+            else
+              value
+            end
+          end
+        end
+
+        private
+
+        def parse_tree
+          TreeHaver.with_backend(backend_id) do
+            options = {}
+            options[:contract] = parser_contract if parser_contract
+            TreeHaver.parser_for(language.to_sym, **options).parse(source)
+          end
+        end
+
+        def analyze
+          request = {
+            provider_id: provider.provider_id,
+            family: provider.family,
+            source: source,
+            dialect: dialect,
+            backend: backend_id,
+            profile_id: profile_id
+          }
+          ProviderContract.validate_result!(:analyze, provider.analyze(request))
+        end
+
+        def build_parse_request
+          {
+            schema: PARSE_REQUEST_SCHEMA,
+            request_id: request_id,
+            source: source_descriptor(include_content: true),
+            language: language,
+            dialect: dialect,
+            selection: {
+              backend: backend_id,
+              preference: [],
+              required_capabilities: backend_identity.fetch(:capabilities)
+            },
+            options: {
+              comments: true,
+              diagnostics: true,
+              native_extensions: true,
+              tokens: false
+            },
+            metadata: { snapshot_id: snapshot_id }
+          }
+        end
+
+        def build_parse_result(parse_request, projection, extensions)
+          {
+            schema: PARSE_RESULT_SCHEMA,
+            request_id: request_id,
+            ok: projection.fetch(:diagnostics).none? { |diagnostic| diagnostic.fetch(:blocking) },
+            source: source_descriptor,
+            selection: selection_report,
+            backend: backend_identity.merge(
+              language: language,
+              dialect: dialect,
+              normalized_contract: NORMALIZED_CONTRACT
+            ),
+            root_id: projection.fetch(:root_id),
+            nodes: projection.fetch(:nodes),
+            comments: projection.fetch(:comments),
+            diagnostics: projection.fetch(:diagnostics),
+            extensions: extensions,
+            metadata: {
+              parse_request_sha256: Digest::SHA256.hexdigest(self.class.canonical_json(parse_request))
+            }
+          }
+        end
+
+        def build_analysis_result(parse_request, parse_result, provider_result, extensions)
+          analysis = provider_result.fetch(:analysis, {})
+          {
+            schema: ANALYSIS_RESULT_SCHEMA,
+            request_id: request_id,
+            ok: provider_result.fetch(:ok),
+            source: source_descriptor,
+            provider: provider_result.fetch(:provider),
+            profile: provider_result.fetch(:profile),
+            parse_result_sha256: Digest::SHA256.hexdigest(self.class.canonical_json(parse_result)),
+            analysis: analysis,
+            owners: extract_owners(analysis),
+            comment_regions: Array(analysis[:comment_regions] || analysis['comment_regions']),
+            layout_gaps: Array(analysis[:layout_gaps] || analysis['layout_gaps']),
+            attachments: Array(analysis[:attachments] || analysis['attachments']),
+            ownership: Array(analysis[:ownership] || analysis['ownership']),
+            diagnostics: provider_result.fetch(:diagnostics),
+            extensions: extensions,
+            metadata: {
+              parse_request_sha256: Digest::SHA256.hexdigest(self.class.canonical_json(parse_request)),
+              provider_result_schema: provider_result.fetch(:schema)
+            }
+          }
+        end
+
+        def extract_owners(analysis)
+          %i[owners declarations entries].each do |key|
+            value = analysis[key] || analysis[key.to_s]
+            return value if value.is_a?(Array)
+          end
+          []
+        end
+
+        def build_extensions(tree, projection, provider_result)
+          return [] unless extension_builder
+
+          extension_value = extension_builder.call(
+            tree: tree,
+            nodes: projection.fetch(:nodes),
+            provider_result: provider_result,
+            source: source
+          )
+          extensions = extension_value.is_a?(Array) ? extension_value : [extension_value]
+          extensions.map { |extension| normalize_extension(extension) }
+        end
+
+        def normalize_extension(extension)
+          normalized = Ast::Merge.json_ready(extension)
+          schema = normalized.fetch('schema', '').to_s
+          namespace = normalized.fetch('namespace', '').to_s
+          capabilities = Array(normalized['capabilities']).map(&:to_s).sort.uniq
+          raise Error, "Invalid extension schema: #{schema.inspect}" unless schema.match?(EXTENSION_SCHEMA_PATTERN)
+          raise Error, 'Extension namespace must not be empty' if namespace.empty?
+          raise Error, 'Extension payload is required' unless normalized.key?('payload')
+
+          normalized.merge(
+            'capabilities' => capabilities,
+            'opaque_forwarding_replay_sha256' => self.class.extension_forwarding_digest(normalized)
+          )
+        end
+
+        def selection_report
+          {
+            mode: 'explicit',
+            requested_backend: backend_id,
+            preference: [],
+            required_capabilities: backend_identity.fetch(:capabilities),
+            candidates: [
+              {
+                backend_id: backend_id,
+                available: true,
+                compatible: true,
+                selected: true,
+                reasons: []
+              }
+            ],
+            selected_backend: backend_id,
+            selection_reason: 'explicit-compatible-backend',
+            registry_digest: registry_digest
+          }
+        end
+
+        def registry_digest
+          registrations = TreeHaver.registered_languages(language.to_sym)
+          portable = registrations.keys.map(&:to_s).sort.to_h do |key|
+            config = registrations[key.to_sym] || {}
+            [
+              key,
+              config.slice(:gem_name, :contract, :symbol).transform_values do |value|
+                value.respond_to?(:name) && value.name ? value.name : value.to_s
+              end
+            ]
+          end
+          Digest::SHA256.hexdigest(self.class.canonical_json(portable))
+        end
+
+        def source_descriptor(include_content: false)
+          descriptor = {
+            source_id: source_id,
+            role: 'source',
+            byte_length: source.bytesize,
+            sha256: Digest::SHA256.hexdigest(source.b),
+            encoding: source.encoding.name.downcase,
+            bom: source.b.start_with?("\xEF\xBB\xBF".b),
+            line_endings: line_ending_profile,
+            final_newline: source.end_with?("\n", "\r")
+          }
+          descriptor[:content] = source if include_content
+          descriptor
+        end
+
+        def line_ending_profile
+          endings = source.scan(/\r\n|\r|\n/).uniq
+          return 'none' if endings.empty?
+          return 'mixed' if endings.length > 1
+
+          { "\n" => 'lf', "\r\n" => 'crlf', "\r" => 'cr' }.fetch(endings.first)
+        end
+
+        def normalize_backend_identity(identity)
+          normalized = Ast::Merge::ProviderContract.normalize_hash(identity)
+          required = %i[id family host_runtime package parser capabilities]
+          missing = required.reject { |key| normalized.key?(key) }
+          raise Error, "Backend identity is missing: #{missing.join(', ')}" unless missing.empty?
+          unless normalized.fetch(:id).to_s == backend_id
+            raise Error, 'Backend identity does not match selected backend'
+          end
+
+          normalized.merge(capabilities: Array(normalized.fetch(:capabilities)).map(&:to_s).sort.uniq)
+        end
+
+        def required_string(value, name)
+          normalized = value.to_s.strip
+          raise Error, "#{name} must not be empty" if normalized.empty?
+
+          normalized
+        end
+
+        def request_id
+          "#{snapshot_id}:parse:#{Digest::SHA256.hexdigest(source.b)[0, 12]}"
+        end
+
+        def output_bytes(result)
+          output = result[:output] || result['output']
+          output&.b
+        end
+
+        # Projects only the normalized TreeHaver contract. It never introspects
+        # backend-native objects; providers retain those facts in extensions.
+        class TreeProjection
+          def initialize(tree, source)
+            @tree = tree
+            @source = source
+            @nodes = []
+            @comments = []
+            @seen_comments = {}
+          end
+
+          def call
+            root_id = project_node(@tree.root_node, nil)
+            project_tree_comments
+            {
+              root_id: root_id,
+              nodes: @nodes,
+              comments: ordered_comments,
+              diagnostics: diagnostics
+            }
+          end
+
+          private
+
+          def project_node(node, parent_id)
+            id = "node:#{@nodes.length}"
+            record = node_record(node, id, parent_id)
+            @nodes << record
+            children = node.children
+            record[:children] = children.each_with_index.map do |child, index|
+              { node_id: project_node(child, id), index: index }
+            end
+            record_comment(node, id) if record.fetch(:role) == 'comment'
+            id
+          end
+
+          def project_tree_comments
+            @tree.comments.each do |comment|
+              key = comment_key(comment)
+              next if @seen_comments[key]
+
+              id = "node:#{@nodes.length}"
+              @nodes << comment_record(comment, id)
+              record_comment(comment, id)
+            end
+          end
+
+          def node_record(node, id, parent_id)
+            type = node.type.to_s
+            {
+              id: id,
+              type: type,
+              native_type: node.native_type.to_s,
+              role: node_role(node, type),
+              named: node.named?,
+              missing: node.missing?,
+              has_error: node.has_error?,
+              span: span(node),
+              parent_id: parent_id,
+              children: [],
+              semantic_roles: [],
+              unsupported_features: [],
+              extensions: [],
+              metadata: {}
+            }
+          end
+
+          def comment_record(comment, id)
+            {
+              id: id,
+              type: comment.type.to_s,
+              native_type: comment.type.to_s,
+              role: 'comment',
+              named: false,
+              missing: false,
+              has_error: false,
+              span: span(comment),
+              parent_id: nil,
+              children: [],
+              semantic_roles: ['comment'],
+              unsupported_features: [],
+              extensions: [],
+              metadata: {}
+            }
+          end
+
+          def node_role(node, type)
+            return 'error' if node.has_error? || node.missing?
+            return 'comment' if type.include?('comment')
+
+            node.named? ? 'structural' : 'token'
+          end
+
+          def record_comment(comment, node_id)
+            key = comment_key(comment)
+            @seen_comments[key] = true
+            @comments << {
+              node_id: node_id,
+              style: optional_value(comment, :style),
+              native_kind: comment.type.to_s,
+              attachment_hint: optional_value(comment, :attachment_hint) || 'unknown'
+            }
+          end
+
+          def comment_key(comment)
+            [comment.start_byte, comment.end_byte]
+          end
+
+          def ordered_comments
+            nodes_by_id = @nodes.to_h { |node| [node.fetch(:id), node] }
+            @comments.sort_by do |comment|
+              range = nodes_by_id.fetch(comment.fetch(:node_id)).dig(:span, :range)
+              [range.fetch(:start_byte), range.fetch(:end_byte), comment.fetch(:node_id)]
+            end
+          end
+
+          def optional_value(object, method_name)
+            object.respond_to?(method_name) && object.public_send(method_name)&.to_s
+          end
+
+          def span(node)
+            {
+              range: { start_byte: node.start_byte, end_byte: node.end_byte },
+              start_point: point(node.start_point),
+              end_point: point(node.end_point)
+            }
+          end
+
+          def point(value)
+            {
+              row: value.respond_to?(:row) ? value.row : value[:row],
+              column: value.respond_to?(:column) ? value.column : value[:column]
+            }
+          end
+
+          def diagnostics
+            [
+              *@tree.errors.map { |error| diagnostic(error, 'error', true) },
+              *@tree.warnings.map { |warning| diagnostic(warning, 'warning', false) }
+            ]
+          end
+
+          def diagnostic(value, severity, blocking)
+            {
+              id: "diagnostic:#{severity}:#{value.class.name}:#{value}",
+              severity: severity,
+              category: 'parser_diagnostic',
+              code: value.respond_to?(:type) ? value.type.to_s : nil,
+              message: value.to_s,
+              source_role: 'source',
+              blocking: blocking,
+              metadata: {}
+            }
+          end
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/ClassLength, Metrics/MethodLength, Metrics/ParameterLists
+    end
+  end
+end

data/lib/ast/merge/rspec.rb

@@ -34,6 +34,9 @@ require_relative 'rspec/dependency_tags'
 # Load conformance fixture helpers for shared fixture harnesses
 require_relative 'rspec/conformance_fixtures'
 
+# Load portable provider snapshot and differential replay support
+require_relative 'rspec/provider_snapshot'
+
 # Load Ast::Merge shared examples (for testing *-merge implementations)
 require_relative 'rspec/shared_examples'
 

data/lib/ast/merge/version.rb

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

data/lib/ast/merge.rb

@@ -87,7 +87,6 @@ module Ast
     autoload :ProviderContract, 'ast/merge/provider_contract'
     autoload :ProviderRegistry, 'ast/merge/provider_registry'
     autoload :ProviderResult, 'ast/merge/provider_result'
-    autoload :YamlDocument, 'ast/merge/yaml_document'
     autoload :SectionTyping, 'ast/merge/section_typing'
     autoload :SmartMergerBase, 'ast/merge/smart_merger_base'
     autoload :SourceRegionReportSupport, 'ast/merge/source_region_report_support'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ast-merge
 version: !ruby/object:Gem::Version
-  version: 7.1.7
+  version: 7.1.8
 platform: ruby
 authors:
 - Peter H. Boling
@@ -77,14 +77,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.7
+        version: 7.1.8
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 7.1.7
+        version: 7.1.8
 - !ruby/object:Gem::Dependency
   name: version_gem
   requirement: !ruby/object:Gem::Requirement
@@ -114,7 +114,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.17
+        version: 3.0.31
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -124,7 +124,7 @@ dependencies:
         version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.17
+        version: 3.0.31
 - !ruby/object:Gem::Dependency
   name: bundler-audit
   requirement: !ruby/object:Gem::Requirement
@@ -202,7 +202,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2
+        version: 3.2.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -212,7 +212,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2
+        version: 3.2.3
 - !ruby/object:Gem::Dependency
   name: kettle-test
   requirement: !ruby/object:Gem::Requirement
@@ -242,7 +242,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.6
+        version: 3.2.7
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -252,7 +252,7 @@ dependencies:
         version: '3.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.6
+        version: 3.2.7
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -400,6 +400,7 @@ files:
 - lib/ast/merge/rspec/dependency_tags_helpers.rb
 - lib/ast/merge/rspec/merge_gem_registry.rb
 - lib/ast/merge/rspec/provider_conformance.rb
+- lib/ast/merge/rspec/provider_snapshot.rb
 - lib/ast/merge/rspec/setup.rb
 - lib/ast/merge/rspec/shared_examples.rb
 - lib/ast/merge/rspec/shared_examples/comment_attachment.rb
@@ -489,7 +490,6 @@ files:
 - lib/ast/merge/unresolved_review_state.rb
 - lib/ast/merge/unresolved_support.rb
 - lib/ast/merge/version.rb
-- lib/ast/merge/yaml_document.rb
 - sig/ast/merge.rbs
 homepage: https://github.com/structuredmerge/structuredmerge-ruby
 licenses:
@@ -497,10 +497,10 @@ licenses:
 - PolyForm-Small-Business-1.0.0
 metadata:
   homepage_uri: https://structuredmerge.org
-  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.1.7
-  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.7/CHANGELOG.md
+  source_code_uri: https://github.com/structuredmerge/structuredmerge-ruby/tree/v7.1.8
+  changelog_uri: https://github.com/structuredmerge/structuredmerge-ruby/blob/v7.1.8/CHANGELOG.md
   bug_tracker_uri: https://github.com/structuredmerge/structuredmerge-ruby/issues
-  documentation_uri: https://www.rubydoc.info/gems/ast-merge/7.1.7
+  documentation_uri: https://www.rubydoc.info/gems/ast-merge/7.1.8
   funding_uri: https://github.com/sponsors/pboling
   wiki_uri: https://github.com/structuredmerge/structuredmerge-ruby/wiki
   news_uri: https://www.railsbling.com/tags/ast-merge

data/lib/ast/merge/yaml_document.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Ast
-  module Merge
-    # Parser-neutral semantic analysis shared by YAML backend providers.
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity -- recursive YAML validation, rendering, and ownership are one parser-neutral semantic boundary
-    module YamlDocument
-      module_function
-
-      def analyze(parsed, dialect)
-        return unsupported("Unsupported YAML dialect #{dialect}.") unless dialect == 'yaml'
-        return parse_error('YAML documents must parse to a mapping root.') unless parsed.is_a?(Hash)
-
-        validated = validate_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]),
-            document: validated[:value],
-            root_kind: 'mapping',
-            owners: collect_owners(validated[:value])
-          },
-          policies: []
-        }
-      end
-
-      def match_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 validate_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_node(item, "#{path}/#{index}")
-            return validated unless validated[:ok]
-
-            memo[:value] << validated[:value]
-          end
-        elsif value.is_a?(Hash)
-          value.each_with_object({ ok: true, value: {} }) do |(key, item), memo|
-            validated = validate_node(item, "#{path}/#{key}")
-            return validated unless validated[:ok]
-
-            memo[:value][key] = validated[:value]
-          end
-        else
-          unsupported("Unsupported YAML value at #{path.empty? ? '/' : path}. " \
-                      'Only mappings, scalar values, and sequences are supported.')
-        end
-      end
-      private_class_method :validate_node
-
-      def scalar?(value)
-        value.nil? || value.is_a?(String) || value.is_a?(Numeric) || value == true || value == false
-      end
-      private_class_method :scalar?
-
-      def canonical_yaml(mapping)
-        "#{render_mapping(mapping).join("\n")}\n"
-      end
-      private_class_method :canonical_yaml
-
-      def render_mapping(mapping, indent = 0)
-        mapping.flat_map do |key, value|
-          prefix = ' ' * indent
-          if value.is_a?(Array)
-            ["#{prefix}#{key}:"] + render_sequence(value, indent + 2)
-          elsif value.is_a?(Hash)
-            ["#{prefix}#{key}:"] + render_mapping(value, indent + 2)
-          elsif value.nil?
-            ["#{prefix}#{key}:"]
-          else
-            ["#{prefix}#{key}: #{render_scalar(value)}"]
-          end
-        end
-      end
-      private_class_method :render_mapping
-
-      def render_sequence(sequence, indent)
-        prefix = ' ' * indent
-        sequence.flat_map do |item|
-          if scalar?(item)
-            ["#{prefix}- #{render_scalar(item)}"]
-          elsif item.is_a?(Hash)
-            ["#{prefix}-"] + render_mapping(item, indent + 2)
-          elsif item.is_a?(Array)
-            ["#{prefix}-"] + render_sequence(item, indent + 2)
-          end
-        end
-      end
-      private_class_method :render_sequence
-
-      def render_scalar(value)
-        return '' if value.nil?
-        return value ? 'true' : 'false' if [true, false].include?(value)
-        return value.to_s unless value.is_a?(String)
-
-        value.match?(/\A[A-Za-z0-9_.-]+\z/) ? value : JSON.generate(value)
-      end
-      private_class_method :render_scalar
-
-      def collect_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_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_owners(value, path)
-          else
-            [{ path: path, owner_kind: 'key_value', match_key: key }]
-          end
-        end
-      end
-      private_class_method :collect_owners
-
-      def parse_error(message)
-        { ok: false, diagnostics: [{ severity: 'error', category: 'parse_error', message: message }], policies: [] }
-      end
-      private_class_method :parse_error
-
-      def unsupported(message)
-        {
-          ok: false,
-          diagnostic: { severity: 'error', category: 'unsupported_feature', message: message },
-          diagnostics: [{ severity: 'error', category: 'unsupported_feature', message: message }],
-          policies: []
-        }
-      end
-      private_class_method :unsupported
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity
-  end
-end