ruact 0.0.11 → 0.0.12

data/spec/ruact/server_function_name_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "ruact/server"
-
-# Story 9.3 AC4 — the `ruact_function_name` rename-override macro. Tested via
-# the concern's ClassMethods in isolation (no ActionController boot needed) so
-# the validation + storage contract is pinned independently of the request
-# cycle. RouteSource consumes the resulting `__ruact_function_name_overrides`.
-RSpec.describe "Ruact::Server.ruact_function_name", :story_9_3 do
-  subject(:host) { Class.new { extend Ruact::Server::ClassMethods } }
-
-  it "stores the override keyed by action name (string)" do
-    host.ruact_function_name(:publish_all, as: "publishEverything")
-    expect(host.__ruact_function_name_overrides).to eq("publish_all" => "publishEverything")
-  end
-
-  it "accepts a symbol target and stringifies it" do
-    host.ruact_function_name(:publish_all, as: :publishEverything)
-    expect(host.__ruact_function_name_overrides.fetch("publish_all")).to eq("publishEverything")
-  end
-
-  it "starts empty and is per-class (not shared)" do
-    other = Class.new { extend Ruact::Server::ClassMethods }
-    host.ruact_function_name(:create, as: "makePost")
-    expect(host.__ruact_function_name_overrides).to eq("create" => "makePost")
-    expect(other.__ruact_function_name_overrides).to eq({})
-  end
-
-  it "rejects an invalid JS identifier at class-load time" do
-    expect do
-      host.ruact_function_name(:create, as: "2bad name")
-    end.to raise_error(Ruact::ConfigurationError, /not a valid JS identifier/)
-  end
-
-  it "rejects a reserved JS word" do
-    expect do
-      host.ruact_function_name(:create, as: "class")
-    end.to raise_error(Ruact::ConfigurationError, /reserved/)
-  end
-
-  it "rejects a runtime-bound name (revalidate)" do
-    expect do
-      host.ruact_function_name(:create, as: "revalidate")
-    end.to raise_error(Ruact::ConfigurationError, /reserved|ruact runtime/)
-  end
-
-  it "rejects the v2 runtime accessor name (_makeServerFunction)" do
-    expect do
-      host.ruact_function_name(:create, as: "_makeServerFunction")
-    end.to raise_error(Ruact::ConfigurationError, /reserved|ruact runtime/)
-  end
-end

data/spec/ruact/server_functions/backtrace_cleaner_spec.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "ruact/server_functions/backtrace_cleaner"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe BacktraceCleaner, :story_8_4 do
-      describe "Story 8.4 — .split classifies frames by Ruact.gem_path prefix" do
-        let(:gem_root) { "/tmp/ruact-test-gem" }
-
-        before { allow(Ruact).to receive(:gem_path).and_return(gem_root) }
-
-        it "puts non-gem frames into :app, preserving order" do
-          frames = [
-            "/Users/dev/host/app/controllers/posts_controller.rb:12:in `create'",
-            "/Users/dev/host/app/models/post.rb:7:in `save!'"
-          ]
-          expect(described_class.split(frames)).to eq(
-            app: frames,
-            gem: []
-          )
-        end
-
-        it "puts frames under Ruact.gem_path into :gem, preserving order" do
-          frames = [
-            "#{gem_root}/lib/ruact/server_functions/endpoint_controller.rb:111:in `dispatch'",
-            "#{gem_root}/lib/ruact/server_functions/standalone_dispatcher.rb:42:in `apply'"
-          ]
-          expect(described_class.split(frames)).to eq(
-            app: [],
-            gem: frames
-          )
-        end
-
-        it "interleaves app+gem frames into separate buckets while preserving relative order in each bucket" do
-          frames = [
-            "/Users/dev/host/app/controllers/posts_controller.rb:12:in `create'",
-            "#{gem_root}/lib/ruact/server_functions/endpoint_controller.rb:111:in `dispatch'",
-            "/Users/dev/host/app/models/post.rb:7:in `save!'",
-            "#{gem_root}/lib/ruact/server_functions/standalone_dispatcher.rb:42:in `apply'"
-          ]
-          result = described_class.split(frames)
-          expect(result[:app]).to eq([frames[0], frames[2]])
-          expect(result[:gem]).to eq([frames[1], frames[3]])
-        end
-
-        it "returns { app: [], gem: [] } for nil input" do
-          expect(described_class.split(nil)).to eq(app: [], gem: [])
-        end
-
-        it "returns { app: [], gem: [] } for an empty array" do
-          expect(described_class.split([])).to eq(app: [], gem: [])
-        end
-
-        it "classifies a frame whose path is exactly Ruact.gem_path as GEM (edge case)" do
-          frames = ["#{gem_root}:0:in `<top>'"]
-          expect(described_class.split(frames)).to eq(app: [], gem: frames)
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/bucket_two_payload_spec.rb

@@ -1,200 +0,0 @@
-# frozen_string_literal: true
-
-# Story 9.2 — unit spec for the pure Bucket-2 response serializer. Pins the
-# prop-exposure policy mirrored from Ruact::Flight::Serializer#serialize_unknown
-# (Serializable → ruact_props only; strict → raise; vetted as_json fallback),
-# producing a plain JSON-ready Hash (no Flight wire encoding). Pure function —
-# no Rails / request / Ruact.config reads (NFR26 / AC8).
-
-require "spec_helper"
-require "ruact/server_functions/bucket_two_payload"
-
-# Fixtures live OUTSIDE the example group (no leaky constants in the block).
-module B2Fixtures
-  # A Serializable model exposing only some attributes.
-  class Post
-    include Ruact::Serializable
-
-    attr_reader :id, :title, :secret
-
-    def initialize(id:, title:, secret:)
-      @id = id
-      @title = title
-      @secret = secret
-    end
-
-    ruact_props :id, :title
-  end
-
-  # Serializable whose prop is itself a Serializable (nested).
-  class AuthoredPost
-    include Ruact::Serializable
-
-    attr_reader :title, :author
-
-    def initialize(title:, author:)
-      @title = title
-      @author = author
-    end
-
-    ruact_props :title, :author
-  end
-
-  class Author
-    include Ruact::Serializable
-
-    attr_reader :name, :password_digest
-
-    def initialize(name:, password_digest:)
-      @name = name
-      @password_digest = password_digest
-    end
-
-    ruact_props :name
-  end
-
-  # A plain object with as_json (AR-like).
-  class PlainRecord
-    def as_json(_opts = nil)
-      { "id" => 7, "leaked" => "everything" }
-    end
-  end
-
-  class SelfReturningAsJson
-    def as_json(_opts = nil)
-      self
-    end
-  end
-
-  class RaisingAsJson
-    def as_json(_opts = nil)
-      raise "boom in as_json"
-    end
-  end
-end
-
-RSpec.describe Ruact::ServerFunctions::BucketTwoPayload, :story_9_2 do
-  describe ".build (AC2 — keyed by ivar name, all exposed ivars)" do
-    it "keys the result by the assigns names and serializes each value" do
-      result = described_class.build(
-        { "post" => B2Fixtures::Post.new(id: 1, title: "Hi", secret: "x"), "count" => 3 },
-        strict: true
-      )
-      expect(result).to eq("post" => { "id" => 1, "title" => "Hi" }, "count" => 3)
-    end
-
-    it "does NOT unwrap a single ivar — it stays keyed (no magic unwrap)" do
-      result = described_class.build({ "post" => B2Fixtures::Post.new(id: 1, title: "Hi", secret: "x") }, strict: true)
-      expect(result).to eq("post" => { "id" => 1, "title" => "Hi" })
-    end
-  end
-
-  describe "Serializable policy" do
-    it "exposes ONLY ruact_props, never undeclared attributes (no secret leak)" do
-      result = described_class.build({ "post" => B2Fixtures::Post.new(id: 1, title: "Hi", secret: "nope") },
-                                     strict: true)
-      expect(result.fetch("post")).to eq("id" => 1, "title" => "Hi")
-      expect(result.fetch("post")).not_to have_key("secret")
-    end
-
-    it "recurses into a Serializable-valued prop (nested), applying ruact_props at each level" do
-      author = B2Fixtures::Author.new(name: "Ada", password_digest: "HASH")
-      post = B2Fixtures::AuthoredPost.new(title: "T", author: author)
-      result = described_class.build({ "post" => post }, strict: true)
-      expect(result.fetch("post")).to eq("title" => "T", "author" => { "name" => "Ada" })
-    end
-
-    it "serializes an Array of Serializables element-wise" do
-      posts = [B2Fixtures::Post.new(id: 1, title: "A", secret: "s"),
-               B2Fixtures::Post.new(id: 2, title: "B", secret: "s")]
-      result = described_class.build({ "posts" => posts }, strict: true)
-      expect(result.fetch("posts")).to eq([{ "id" => 1, "title" => "A" }, { "id" => 2, "title" => "B" }])
-    end
-  end
-
-  describe "primitive pass-through (NOT subject to strict policy)" do
-    it "passes scalars through untouched even under strict" do
-      result = described_class.build(
-        { "i" => 5, "f" => 1.5, "s" => "x", "t" => true, "n" => nil, "sym" => :ok },
-        strict: true
-      )
-      expect(result).to eq("i" => 5, "f" => 1.5, "s" => "x", "t" => true, "n" => nil, "sym" => :ok)
-    end
-
-    it "passes Time through untouched (Rails render json: handles ISO formatting)" do
-      time = Time.utc(2026, 1, 2, 3, 4, 5)
-      result = described_class.build({ "at" => time }, strict: true)
-      expect(result.fetch("at")).to equal(time)
-    end
-
-    it "stringifies Hash keys and recurses values" do
-      assigns = { "meta" => { a: 1, b: B2Fixtures::Post.new(id: 9, title: "N", secret: "s") } }
-      result = described_class.build(assigns, strict: true)
-      expect(result.fetch("meta")).to eq("a" => 1, "b" => { "id" => 9, "title" => "N" })
-    end
-  end
-
-  describe "strict_serialization policy (AC5)" do
-    it "raises Ruact::SerializationError for a non-Serializable object under strict" do
-      expect { described_class.build({ "rec" => B2Fixtures::PlainRecord.new }, strict: true) }
-        .to raise_error(Ruact::SerializationError, /Cannot serialize B2Fixtures::PlainRecord/)
-    end
-
-    it "falls back to as_json when strict is false" do
-      result = described_class.build({ "rec" => B2Fixtures::PlainRecord.new }, strict: false)
-      expect(result.fetch("rec")).to eq("id" => 7, "leaked" => "everything")
-    end
-
-    it "raises when as_json returns self (infinite-recursion guard), regardless of strict" do
-      expect { described_class.build({ "x" => B2Fixtures::SelfReturningAsJson.new }, strict: false) }
-        .to raise_error(Ruact::SerializationError, /as_json returned self/)
-    end
-
-    it "wraps an exception raised inside as_json as Ruact::SerializationError" do
-      expect { described_class.build({ "x" => B2Fixtures::RaisingAsJson.new }, strict: false) }
-        .to raise_error(Ruact::SerializationError, /as_json raised RuntimeError: boom in as_json/)
-    end
-  end
-
-  describe "Story 9.4 — .serialize_value (single value, same policy as .build — D6)", :story_9_4 do
-    it "serializes a Serializable through ruact_props only" do
-      post = B2Fixtures::Post.new(id: 1, title: "Hi", secret: "nope")
-      expect(described_class.serialize_value(post, strict: true)).to eq("id" => 1, "title" => "Hi")
-    end
-
-    it "recurses into Arrays of Serializables" do
-      posts = [B2Fixtures::Post.new(id: 1, title: "A", secret: "x")]
-      expect(described_class.serialize_value(posts, strict: true)).to eq([{ "id" => 1, "title" => "A" }])
-    end
-
-    it "recurses into Hashes, stringifying keys" do
-      value = { total: 2, post: B2Fixtures::Post.new(id: 1, title: "A", secret: "x") }
-      expect(described_class.serialize_value(value, strict: true))
-        .to eq("total" => 2, "post" => { "id" => 1, "title" => "A" })
-    end
-
-    it "passes primitives through untouched" do
-      expect(described_class.serialize_value(42, strict: true)).to eq(42)
-    end
-
-    it "passes nil through (the dispatch controller renders it as JSON null — D6)" do
-      expect(described_class.serialize_value(nil, strict: true)).to be_nil
-    end
-
-    it "raises Ruact::SerializationError for a non-Serializable under strict" do
-      expect { described_class.serialize_value(B2Fixtures::PlainRecord.new, strict: true) }
-        .to raise_error(Ruact::SerializationError, /Cannot serialize B2Fixtures::PlainRecord/)
-    end
-
-    it "falls back to as_json when strict is false" do
-      expect(described_class.serialize_value(B2Fixtures::PlainRecord.new, strict: false))
-        .to eq("id" => 7, "leaked" => "everything")
-    end
-
-    it "is the same policy .build applies per ivar (extraction, not a fork)" do
-      post = B2Fixtures::Post.new(id: 3, title: "Same", secret: "x")
-      expect(described_class.build({ "post" => post }, strict: true))
-        .to eq("post" => described_class.serialize_value(post, strict: true))
-    end
-  end
-end