ruact 0.0.11 → 0.0.12

data/spec/support/matchers/flight_fixture_matcher.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../flight_wire_parser"
-require "ruact/testing/flight_structure_diff"
-
-module Ruact
-  module Spec
-    # Story 15.4 (FR108) — the structural diff engine was PROMOTED onto the
-    # gem's `lib/` load path as `Ruact::Testing::FlightStructureDiff` (shared,
-    # single implementation — wrap, not fork). This test-only `Ruact::Spec`
-    # alias keeps the internal matcher wrappers below and their self-tests
-    # working unchanged.
-    FlightStructureDiff = Ruact::Testing::FlightStructureDiff
-  end
-end
-
-# `match_flight_fixture(name)` — Phase 1 byte-exact snapshot matcher.
-#
-# Reads `spec/fixtures/flight/<name>.txt` and compares the actual wire bytes
-# to the file contents via `==`. Used when the wire format itself is the
-# contract (escape rules, ordering invariants, payload framing).
-#
-# @example
-#   expect(serializer.serialize_value("$danger")).to match_flight_fixture("string_dollar_escape")
-RSpec::Matchers.define :match_flight_fixture do |name|
-  match do |actual|
-    fixtures_dir = File.expand_path("../../fixtures/flight", __dir__)
-    fixture_path = File.join(fixtures_dir, "#{name}.txt")
-    @fixture_path = fixture_path
-    @expected = File.read(fixture_path)
-    actual == @expected
-  end
-
-  failure_message do |actual|
-    "Expected output to match fixture at #{@fixture_path}.\n\n" \
-      "Expected:\n#{@expected.inspect}\n\n" \
-      "Got:\n#{actual.inspect}"
-  end
-
-  failure_message_when_negated do |_actual|
-    "Expected output NOT to match fixture at #{@fixture_path}, but it did."
-  end
-
-  description do
-    "match Flight wire fixture '#{name}'"
-  end
-end
-
-# `match_flight_structure(expected)` — Phase 2 structural matcher (Story 7.5).
-#
-# Parses the actual Flight wire output via `Ruact::Spec::FlightWireParser`,
-# then compares the resulting array of row records against `expected`. Hash
-# payloads are compared structurally (key insertion order is ignored), so
-# cosmetic JSON re-ordering does not break specs that assert on semantics.
-# Import rows are matched as a multiset; non-import rows are compared
-# positionally because Flight semantics depend on their order.
-#
-# Failure messages name the row index and the differing field — bytes are
-# only printed when no narrower diff is available.
-#
-# @example
-#   expect(wire).to match_flight_structure([
-#     { id: 1, class: :import, payload: ["/L.jsx", "L", ["/L.jsx"]] },
-#     { id: 0, class: :model,  payload: ["$", "$L1", nil, {}] }
-#   ])
-RSpec::Matchers.define :match_flight_structure do |expected|
-  match do |actual|
-    @parsed = Ruact::Spec::FlightWireParser.parse(actual)
-    @expected_rows = expected
-    @diffs = Ruact::Spec::FlightStructureDiff.compute(@parsed, expected)
-    @diffs.empty?
-  end
-
-  failure_message do |_actual|
-    if @diffs.length == 1
-      Ruact::Spec::FlightStructureDiff.format_single(@diffs.first)
-    else
-      Ruact::Spec::FlightStructureDiff.format_multi(@diffs, @parsed, @expected_rows)
-    end
-  end
-
-  failure_message_when_negated do |_actual|
-    "Expected output NOT to match the given Flight wire structure, but it did."
-  end
-
-  description do
-    "match Flight wire structure (#{expected.length} row(s))"
-  end
-end
-
-# `include_flight_row(predicate)` — Phase 2 ordering-independent presence matcher (Story 7.5).
-#
-# Parses the actual Flight wire output, then asserts at least one parsed row
-# satisfies the predicate hash. Subset semantics: only the keys present in
-# `predicate` are compared. Predicate keys must be one of `:id`, `:class`,
-# `:payload`, `:raw` — unknown keys raise upfront so typos don't silently
-# match every row. Values may be plain Ruby values (compared with `==`) or
-# RSpec argument matchers like `hash_including(...)` (compared with `===`).
-# Negation (`not_to`) is supported.
-#
-# @example
-#   expect(wire).to include_flight_row(class: :model, payload: hash_including("postId" => 42))
-RSpec::Matchers.define :include_flight_row do |predicate|
-  match do |actual|
-    Ruact::Spec::FlightStructureDiff.validate_predicate!(predicate)
-    @parsed = Ruact::Spec::FlightWireParser.parse(actual)
-    @predicate = predicate
-    @matched_idx = @parsed.find_index { |row| Ruact::Spec::FlightStructureDiff.row_matches?(row, predicate) }
-    !@matched_idx.nil?
-  end
-
-  failure_message do |_actual|
-    summary = @parsed.each_with_index.map do |row, i|
-      payload_snippet = row[:payload].inspect
-      payload_snippet = "#{payload_snippet[0, 80]}…" if payload_snippet.length > 80
-      "  [#{i}] id=#{row[:id].inspect}, class=#{row[:class]}, payload=#{payload_snippet}"
-    end.join("\n")
-    summary = "  (no rows parsed)" if @parsed.empty?
-
-    "Expected Flight output to include a row matching: #{predicate.inspect}.\nParsed rows:\n#{summary}"
-  end
-
-  failure_message_when_negated do |_actual|
-    "Expected Flight output NOT to include a row matching: #{predicate.inspect}, but row #{@matched_idx} matched."
-  end
-
-  description do
-    "include a Flight row matching #{predicate.inspect}"
-  end
-end

data/spec/support/matchers/flight_fixture_matcher_spec.rb

@@ -1,250 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-# Specs for the three Flight wire matcher modes added in Story 7.5
-# (`match_flight_fixture`, `match_flight_structure`, `include_flight_row`).
-RSpec.describe "Flight wire matchers" do
-  # Captures an `ExpectationNotMetError` raised by the inner block so the
-  # spec can make multiple assertions on its message without resorting to a
-  # multi-line block chained off `raise_error`.
-  def capture_failure
-    yield
-    nil
-  rescue RSpec::Expectations::ExpectationNotMetError => e
-    e
-  end
-
-  describe "match_flight_fixture (existing snapshot mode)" do
-    let(:nil_wire) { "0:null\n" }
-
-    it "passes against canonical fixture content (regression check)" do
-      expect(nil_wire).to match_flight_fixture("nil")
-    end
-  end
-
-  describe "match_flight_structure" do
-    let(:simple_wire) { %(0:{"className":"box"}\n) }
-    let(:two_row_wire) { %(1:I["/L.jsx","L",["/L.jsx"]]\n0:["$","$L1",null,{}]\n) }
-
-    it "passes when the actual wire matches a single-row expected structure" do
-      expect(simple_wire).to match_flight_structure([
-                                                      { id: 0, class: :model, payload: { "className" => "box" } }
-                                                    ])
-    end
-
-    it "passes for a two-row mixed import + model sequence" do
-      expect(two_row_wire).to match_flight_structure([
-                                                       { id: 1, class: :import, payload: ["/L.jsx", "L", ["/L.jsx"]] },
-                                                       { id: 0, class: :model, payload: ["$", "$L1", nil, {}] }
-                                                     ])
-    end
-
-    it "fails with a missing-row message when actual has fewer rows than expected" do
-      err = capture_failure do
-        expect(simple_wire).to match_flight_structure([
-                                                        { id: 0, class: :model, payload: { "className" => "box" } },
-                                                        { id: 1, class: :import, payload: [] }
-                                                      ])
-      end
-
-      expect(err.message).to include("Expected row 1 (import) was not produced.")
-      expect(err.message).to include("expected: {")
-    end
-
-    it "produces the AC3 verbatim row-indexed diff for a single-field semantic regression" do
-      broken_wire = %(0:["$X","div",null,{"className":"box","children":"hi"}]\n)
-      expected_payload = ["$", "div", nil, { "className" => "box", "children" => "hi" }]
-      got_payload      = ["$X", "div", nil, { "className" => "box", "children" => "hi" }]
-      expected_structure = [{ id: 0, class: :model, payload: expected_payload }]
-
-      # Hash#inspect changed between Ruby 3.3 (`{"a"=>"b"}`) and Ruby 3.4
-      # (`{"a" => "b"}`). The AC3 contract is "values shown via .inspect" —
-      # so we render the expected message with the same .inspect the matcher
-      # uses at runtime, keeping the spec stable across the CI Ruby matrix.
-      expected_message = <<~MSG.strip
-        Expected Flight output to match structure.
-
-        Row 0 (model) differs at .payload[0]:
-          expected: "$"
-          got:      "$X"
-
-        Row 0 (model) full diff:
-          expected: #{expected_payload.inspect}
-          got:      #{got_payload.inspect}
-      MSG
-
-      expect do
-        expect(broken_wire).to match_flight_structure(expected_structure)
-      end.to raise_error(RSpec::Expectations::ExpectationNotMetError, expected_message)
-    end
-
-    it "fails with an unexpected-row message when actual has extra rows" do
-      err = capture_failure do
-        expect(two_row_wire).to match_flight_structure([
-                                                         { id: 1, class: :import,
-                                                           payload: ["/L.jsx", "L", ["/L.jsx"]] }
-                                                       ])
-      end
-
-      expect(err.message).to include("Got unexpected row 1 (model)")
-    end
-
-    it "tolerates cosmetic JSON key reordering in payload hashes (AC4)" do
-      canonical = %(0:{"a":1,"b":2}\n)
-      perturbed = %(0:{"b":2,"a":1}\n)
-      expected_structure = [{ id: 0, class: :model, payload: { "a" => 1, "b" => 2 } }]
-
-      expect(canonical).to match_flight_structure(expected_structure)
-      expect(perturbed).to match_flight_structure(expected_structure)
-    end
-
-    it "passes negation when the structure does not match" do
-      expect(simple_wire).not_to match_flight_structure([
-                                                          { id: 0, class: :model, payload: { "className" => "circle" } }
-                                                        ])
-    end
-
-    # AC1: "multiple I rows are an unordered set". The expected list below
-    # reverses the import order vs the wire — the structural matcher must
-    # still consider this a match because import-row ordering is not
-    # protocol-significant within the import class.
-    it "treats import rows as an unordered set (AC1)" do
-      wire = %(1:I["/A.jsx","A",["/A.jsx"]]\n2:I["/B.jsx","B",["/B.jsx"]]\n0:["$","$L1",null,{}]\n)
-
-      expect(wire).to match_flight_structure([
-                                               { id: 2, class: :import, payload: ["/B.jsx", "B", ["/B.jsx"]] },
-                                               { id: 1, class: :import, payload: ["/A.jsx", "A", ["/A.jsx"]] },
-                                               { id: 0, class: :model, payload: ["$", "$L1", nil, {}] }
-                                             ])
-    end
-
-    # Defends against incomplete expected rows silently passing when actual
-    # payload happens to be nil (e.g. `{ id: 0, class: :model }` without
-    # `:payload` would otherwise satisfy any row whose payload is nil).
-    it "raises ArgumentError when an expected row is missing :payload" do
-      expect do
-        expect(simple_wire).to match_flight_structure([{ id: 0, class: :model }])
-      end.to raise_error(ArgumentError, /missing required keys.*:payload/)
-    end
-
-    it "raises ArgumentError when an expected row is missing :class" do
-      expect do
-        expect(simple_wire).to match_flight_structure([{ id: 0, payload: {} }])
-      end.to raise_error(ArgumentError, /missing required keys.*:class/)
-    end
-
-    # Multi-row failure message: the count, AC3 wording for missing/extra,
-    # plus a "✓" line for every matching row so the reader can confirm
-    # which rows passed (AC3 — "Other rows that match are summarized as
-    # `Row N (<class>): ✓`").
-    it "shows matching-row checkmarks alongside multi-row diffs" do
-      wire = %(1:I["/A.jsx","A",["/A.jsx"]]\n0:["$X","div",null,{}]\n)
-
-      err = capture_failure do
-        expect(wire).to match_flight_structure([
-                                                 { id: 1, class: :import, payload: ["/A.jsx", "A", ["/A.jsx"]] },
-                                                 { id: 0, class: :model, payload: ["$", "div", nil, {}] },
-                                                 { id: 2, class: :model, payload: ["$", "span", nil, {}] }
-                                               ])
-      end
-
-      expect(err.message).to include("Expected Flight output to match structure. 2 rows differ:")
-      expect(err.message).to include("Row 0 (import): ✓")
-      expect(err.message).to include("Row 1 (model) differs at .payload[0]:")
-      expect(err.message).to include("Expected row 2 (model) was not produced.")
-    end
-  end
-
-  describe "include_flight_row" do
-    let(:wire_with_post_id) do
-      %(1:I["/L.jsx","L",["/L.jsx"]]\n0:["$","$L1",null,{"postId":42}]\n)
-    end
-
-    it "matches when at least one row satisfies a hash_including payload predicate" do
-      expect(wire_with_post_id).to include_flight_row(
-        class: :model,
-        payload: include("postId" => 42)
-      )
-    end
-
-    it "fails listing parsed rows when no row matches the predicate" do
-      err = capture_failure do
-        expect(wire_with_post_id).to include_flight_row(
-          class: :model,
-          payload: include("postId" => 999)
-        )
-      end
-
-      expect(err.message).to include("Expected Flight output to include a row matching")
-      expect(err.message).to include("[0] id=1, class=import")
-      expect(err.message).to include("[1] id=0, class=model")
-    end
-
-    it "supports negation with not_to" do
-      expect(wire_with_post_id).not_to include_flight_row(class: :error)
-    end
-
-    it "fails negation when a row matches, naming the offending row index" do
-      expect do
-        expect(wire_with_post_id).not_to include_flight_row(class: :import)
-      end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /but row 0 matched/)
-    end
-
-    it "supports array_including for the payload key" do
-      expect(wire_with_post_id).to include_flight_row(
-        class: :import,
-        payload: include("/L.jsx")
-      )
-    end
-
-    # AC4 fixture-mode failure proof. The structural matcher tolerates the
-    # cosmetic perturbation; the fixture matcher fails *positively* with the
-    # expected-vs-got diff visible — confirming fixture mode is the wire-
-    # format contract guard. This spec verifies the failure message rather
-    # than relying on a `not_to` shortcut (which would prove only that the
-    # matcher returned false, not that the failure is loud and informative).
-    it "demonstrates cosmetic-vs-fixture asymmetry — structure tolerates re-ordering, fixture fails loudly (AC4)" do
-      canonical_wire = %(0:{"debug":true,"count":5,"label":"x"}\n)
-      perturbed_wire = %(0:{"label":"x","count":5,"debug":true}\n)
-      expected_structure = [
-        { id: 0, class: :model, payload: { "debug" => true, "count" => 5, "label" => "x" } }
-      ]
-
-      err = capture_failure do
-        expect(perturbed_wire).to match_flight_fixture("hash")
-      end
-
-      aggregate_failures do
-        # Structural mode: both pass — JSON key reordering is cosmetic.
-        expect(canonical_wire).to match_flight_structure(expected_structure)
-        expect(perturbed_wire).to match_flight_structure(expected_structure)
-
-        # Fixture mode: canonical passes — the fixture file is the canonical
-        # wire bytes.
-        expect(canonical_wire).to match_flight_fixture("hash")
-
-        # Fixture mode against the perturbed wire fails *loudly* with the
-        # bytes-for-bytes diff so a human reviewer can see the cosmetic drift.
-        expect(err).to be_a(RSpec::Expectations::ExpectationNotMetError)
-        expect(err.message).to include("Expected output to match fixture at", "hash.txt", "Expected:", "Got:")
-        expect(err.message).to include(perturbed_wire.inspect)
-      end
-    end
-
-    # Predicate validation: an unknown key (typo) must raise immediately.
-    # Otherwise `row[:payloed]` returns nil and `nil == nil` would silently
-    # match every row, hiding broken specs.
-    it "raises ArgumentError when the predicate has an unknown key" do
-      expect do
-        expect(wire_with_post_id).to include_flight_row(payloed: { "postId" => 42 })
-      end.to raise_error(ArgumentError, /unknown keys.*:payloed/)
-    end
-
-    it "raises ArgumentError when given an empty predicate" do
-      expect do
-        expect(wire_with_post_id).to include_flight_row({})
-      end.to raise_error(ArgumentError, /predicate cannot be empty/)
-    end
-  end
-end

data/spec/support/rails_stub.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-# Spec-only Rails bootstrap for tests that need a `Rails` constant. Two modes:
-#
-# 1. **Augment** (default since Story 7.9): when the `rails` gem is in the
-#    bundle, load its core (`rails.rb` — just `Rails::VERSION`,
-#    `Rails::Railtie`, `ActiveSupport::StringInquirer`, etc., *not*
-#    `action_controller` / `action_view`) and add test-only writers
-#    (`Rails.root=`, `Rails.env=`, `Rails.logger=`) on top. Specs that need
-#    the full Rails request cycle (e.g. controller_request_spec.rb) require
-#    `action_controller/railtie` and `action_view/railtie` themselves — the
-#    rest of the suite never pays that cost.
-#
-# 2. **Full stub** (fallback): when `rails` is not in the bundle (e.g. a
-#    matrix run that pruned it), provide a minimal `Rails` module + a
-#    `Rails::Railtie` class with no-op class methods so `gem/lib/ruact/railtie.rb`
-#    can `class Railtie < Rails::Railtie` without crashing. `$LOADED_FEATURES`
-#    is patched so `require "rails"` inside loaded files no-ops.
-#
-# Loaded automatically by spec_helper.
-#
-# Augmentation is idempotent (each `Rails.define_singleton_method` is guarded
-# by `unless Rails.singleton_class.method_defined?(...)`), so we run through
-# this file every time it loads — even when Rails was already required by
-# another spec file (e.g. controller_request_spec.rb pre-loads
-# `action_controller/railtie`). Skipping with `return if defined?(Rails)`
-# would leave doctor_spec / railtie_spec without the test-only writers when
-# the request spec runs first.
-
-unless defined?(Rails)
-  begin
-    # Loads Rails core only — not the request-cycle subsystem. Cheap.
-    require "rails"
-  rescue LoadError
-    # Rails not available; fall through to the full stub below.
-  end
-end
-
-if defined?(Rails) && Rails.respond_to?(:application)
-  # Augment-mode: real Rails is present. Add test-only writers that the
-  # existing suite (doctor_spec, railtie_spec) relies on, without clobbering
-  # real Rails's behaviour outside the test override.
-  unless Rails.singleton_class.method_defined?(:root=)
-    original_root = Rails.method(:root) if Rails.respond_to?(:root)
-
-    Rails.define_singleton_method(:root=) { |v| @_test_root = v }
-    Rails.define_singleton_method(:root) do
-      return @_test_root if defined?(@_test_root) && @_test_root
-
-      original_root&.call
-    end
-  end
-
-  unless Rails.singleton_class.method_defined?(:env=)
-    Rails.define_singleton_method(:env=) { |v| @_test_env = v }
-    original_env = Rails.method(:env) if Rails.respond_to?(:env)
-    Rails.define_singleton_method(:env) do
-      return @_test_env if defined?(@_test_env) && @_test_env
-
-      original_env ? original_env.call : ActiveSupport::StringInquirer.new("test")
-    end
-  end
-
-  unless Rails.singleton_class.method_defined?(:logger=)
-    Rails.define_singleton_method(:logger=) { |v| @_test_logger = v }
-    original_logger = Rails.method(:logger) if Rails.respond_to?(:logger)
-    Rails.define_singleton_method(:logger) do
-      return @_test_logger if defined?(@_test_logger) && @_test_logger
-
-      original_logger&.call
-    end
-  end
-
-  return
-end
-
-# Full-stub fallback: rails gem is not in the bundle.
-$LOADED_FEATURES << "rails.rb"
-
-module Rails
-  class Railtie
-    def self.initializer(*, **); end
-    def self.rake_tasks(&); end
-
-    def self.config
-      @config ||= Class.new do
-        def method_missing(name, *, **, &); end
-
-        def respond_to_missing?(*, **)
-          true
-        end
-      end.new
-    end
-  end
-
-  class << self
-    attr_accessor :env, :logger, :root
-  end
-end
-
-module ActiveSupport # rubocop:disable Style/OneClassPerFile
-  class StringInquirer < String
-    def method_missing(method_name, *args)
-      if method_name.to_s.end_with?("?")
-        self == method_name.to_s.chomp("?")
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(*, **)
-      true
-    end
-  end
-end