ruact 0.0.10 → 0.0.12

data/spec/ruact/server_functions/route_source_spec.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "active_support/all"
-require "action_dispatch"
-require "ruact/server_functions/route_source"
-
-module Ruact
-  module ServerFunctions
-    # Story 9.3 — route introspection: Rails.application.routes (filtered to
-    # non-GET routes on controllers that include Ruact::Server) → v2 mutation
-    # entries with the derivation table locked in the 2026-06-09 ADR addendum.
-    RSpec.describe RouteSource, :story_9_3 do
-      # Builds an isolated RouteSet so specs never depend on a host app's routes.
-      def route_set(&blk)
-        rs = ActionDispatch::Routing::RouteSet.new
-        rs.draw(&blk)
-        rs
-      end
-
-      # All controllers count as Ruact::Server hosts (isolates the derivation
-      # table from constant-resolution); the filter behaviour is tested
-      # separately below.
-      def collect(routes, overrides: {})
-        described_class.collect(
-          routes,
-          host_predicate: ->(_controller) { true },
-          overrides_for: ->(controller) { overrides.fetch(controller, {}) }
-        )
-      end
-
-      def ids(entries) = entries.map { |e| e["js_identifier"] }
-
-      describe "derivation table (AC3)" do
-        it "names the RESTful collection create as singular verb+resource" do
-          rs = route_set { resources :posts, only: %i[create] }
-          entry = collect(rs).fetch(0)
-          expect(entry["js_identifier"]).to eq("createPost")
-          expect(entry["http_method"]).to eq("POST")
-          expect(entry["path"]).to eq("/posts")
-          expect(entry["segments"]).to eq([])
-          expect(entry["kind"]).to eq("action")
-        end
-
-        it "names update (member) singular and prefers PATCH over the PUT alias" do
-          rs = route_set { resources :posts, only: %i[update] }
-          entries = collect(rs)
-          expect(entries.size).to eq(1) # PATCH + PUT collapse to one entry
-          entry = entries.fetch(0)
-          expect(entry["js_identifier"]).to eq("updatePost")
-          expect(entry["http_method"]).to eq("PATCH")
-          expect(entry["path"]).to eq("/posts/:id")
-          expect(entry["segments"]).to eq(["id"])
-        end
-
-        it "names destroy (member) singular" do
-          rs = route_set { resources :posts, only: %i[destroy] }
-          entry = collect(rs).fetch(0)
-          expect(entry["js_identifier"]).to eq("destroyPost")
-          expect(entry["http_method"]).to eq("DELETE")
-          expect(entry["path"]).to eq("/posts/:id")
-        end
-
-        it "skips the GET RESTful actions (index/show/new/edit)" do
-          rs = route_set { resources :posts }
-          expect(ids(collect(rs))).to match_array(%w[createPost updatePost destroyPost])
-        end
-
-        it "names a custom member route singular (verb-action + singular resource)" do
-          rs = route_set do
-            resources :posts do
-              member { post :publish }
-            end
-          end
-          entry = collect(rs).find { |e| e["js_identifier"] == "publishPost" }
-          expect(entry).not_to be_nil
-          expect(entry["http_method"]).to eq("POST")
-          expect(entry["path"]).to eq("/posts/:id/publish")
-          expect(entry["segments"]).to eq(["id"])
-        end
-
-        it "names a custom collection route plural" do
-          rs = route_set do
-            resources :posts do
-              collection { post :publish_all }
-            end
-          end
-          entry = collect(rs).find { |e| e["js_identifier"] == "publishAllPosts" }
-          expect(entry).not_to be_nil
-          expect(entry["path"]).to eq("/posts/publish_all")
-          expect(entry["segments"]).to eq([])
-        end
-
-        it "names singular-resource create/destroy singular" do
-          rs = route_set { resource :session, only: %i[create destroy] }
-          expect(ids(collect(rs))).to match_array(%w[createSession destroySession])
-        end
-
-        it "prefixes namespaced controllers (verb + Namespace + Resource)" do
-          rs = route_set { namespace(:admin) { resources :posts, only: %i[create update] } }
-          expect(ids(collect(rs))).to match_array(%w[createAdminPost updateAdminPost])
-        end
-
-        it "deep-prefixes multi-level namespaces" do
-          rs = route_set do
-            namespace(:admin) { namespace(:reports) { resources :posts, only: %i[create] } }
-          end
-          expect(ids(collect(rs))).to eq(%w[createAdminReportsPost])
-        end
-
-        it "sorts entries by js_identifier for deterministic output" do
-          rs = route_set { resources :posts }
-          expect(ids(collect(rs))).to eq(%w[createPost destroyPost updatePost])
-        end
-
-        it "classifies a custom-param member route (param: :slug) as member → singular" do
-          rs = route_set do
-            resources :posts, param: :slug do
-              member { post :publish }
-            end
-          end
-          entry = collect(rs).find { |e| e["action"] == "publish" }
-          expect(entry["js_identifier"]).to eq("publishPost")
-          expect(entry["segments"]).to eq(["slug"])
-        end
-
-        it "classifies a nested collection route (only parent :id present) as collection → plural" do
-          rs = route_set do
-            resources :posts, only: [] do
-              resources :comments, only: [] do
-                collection { post :flag_all }
-              end
-            end
-          end
-          entry = collect(rs).find { |e| e["action"] == "flag_all" }
-          expect(entry["js_identifier"]).to eq("flagAllComments")
-        end
-      end
-
-      describe "rename override (AC4 input)" do
-        it "uses the per-controller override identifier when present" do
-          rs = route_set do
-            resources :posts do
-              collection { post :publish_all }
-            end
-          end
-          entries = collect(rs, overrides: { "posts" => { "publish_all" => "publishEverything" } })
-          expect(ids(entries)).to include("publishEverything")
-          expect(ids(entries)).not_to include("publishAllPosts")
-        end
-      end
-
-      describe "collision detection (AC4)" do
-        it "fails loudly naming BOTH origins when two routes map to the same identifier" do
-          rs = route_set do
-            resources :posts, only: %i[create]
-            resources :comments, only: %i[create]
-          end
-          # Force a collision: comments#create is renamed onto posts#create's name.
-          overrides = { "comments" => { "create" => "createPost" } }
-          expect do
-            collect(rs, overrides: overrides)
-          end.to raise_error(Ruact::ConfigurationError, /naming collision/) { |err|
-            expect(err.message).to include("posts#create")
-            expect(err.message).to include("comments#create")
-            expect(err.message).to include("createPost")
-          }
-        end
-
-        it "boot succeeds once the colliding route is renamed to a free identifier (full cycle)" do
-          rs = route_set do
-            resources :posts, only: %i[create]
-            resources :comments, only: %i[create]
-          end
-          overrides = { "comments" => { "create" => "createComment" } }
-          ids_out = ids(collect(rs, overrides: overrides))
-          expect(ids_out).to eq(%w[createComment createPost])
-        end
-      end
-
-      describe "host filter (Ruact::Server only)" do
-        it "skips routes whose controller is not a Ruact::Server host" do
-          rs = route_set do
-            resources :posts, only: %i[create]
-            resources :widgets, only: %i[create]
-          end
-          entries = described_class.collect(
-            rs,
-            host_predicate: ->(controller) { controller == "posts" },
-            overrides_for: ->(_c) { {} }
-          )
-          expect(ids(entries)).to eq(%w[createPost])
-        end
-
-        it "skips GET/HEAD routes even on a host controller" do
-          rs = route_set { get "/posts/search", to: "posts#search" }
-          expect(collect(rs)).to be_empty
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/snapshot_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "tmpdir"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe Snapshot, :story_9_3 do
-      let(:frozen_time) { Time.utc(2026, 5, 13, 12, 34, 56) }
-      let(:entries) do
-        [
-          { "js_identifier" => "createPost", "kind" => "action", "http_method" => "POST",
-            "path" => "/posts", "segments" => [], "controller" => "posts", "action" => "create" }
-        ]
-      end
-
-      describe ".dump_v2" do
-        it "wraps entries in a version-2 snapshot Hash" do
-          snap = described_class.dump_v2(entries, now: frozen_time)
-          expect(snap[:version]).to eq(2)
-          expect(snap[:generated_at]).to eq(frozen_time.iso8601)
-          expect(snap[:functions]).to eq(entries)
-        end
-      end
-
-      describe ".generate_v2! (write-if-changed)" do
-        around do |example|
-          Dir.mktmpdir do |dir|
-            @tmpdir = dir
-            example.run
-          end
-        end
-
-        let(:path) { File.join(@tmpdir, "server-functions.json") }
-
-        it "writes a version-2 bridge on first call" do
-          expect(described_class.generate_v2!(entries: entries, path: path, now: frozen_time)).to be(true)
-          parsed = JSON.parse(File.read(path))
-          expect(parsed.fetch("version")).to eq(2)
-          expect(parsed.fetch("functions").first.fetch("js_identifier")).to eq("createPost")
-        end
-
-        it "short-circuits when entries are unchanged (no timestamp churn)" do
-          described_class.generate_v2!(entries: entries, path: path, now: frozen_time)
-          expect(described_class.generate_v2!(entries: entries, path: path, now: Time.now.utc)).to be(false)
-        end
-
-        it "rewrites when entries change" do
-          described_class.generate_v2!(entries: entries, path: path, now: frozen_time)
-          more = entries + [{ "js_identifier" => "destroyPost", "kind" => "action",
-                              "http_method" => "DELETE", "path" => "/posts/:id",
-                              "segments" => ["id"], "controller" => "posts", "action" => "destroy" }]
-          expect(described_class.generate_v2!(entries: more, path: path, now: frozen_time)).to be(true)
-        end
-
-        it "creates the parent directory if missing" do
-          nested = File.join(@tmpdir, "deep", "nested", "server-functions.json")
-          expect(described_class.generate_v2!(entries: entries, path: nested, now: frozen_time)).to be(true)
-          expect(File.exist?(nested)).to be(true)
-        end
-
-        it "recovers from a corrupted existing file by overwriting it" do
-          File.write(path, "{ not json")
-          expect(described_class.generate_v2!(entries: entries, path: path, now: frozen_time)).to be(true)
-          expect(JSON.parse(File.read(path)).fetch("version")).to eq(2)
-        end
-
-        # Story 13.4 — the new typed-query metadata must survive the JSON
-        # round-trip unchanged AND keep the file byte-stable (no churn on a
-        # second pass with identical entries).
-        context "with typed-query params metadata (Story 13.4)", :story_13_4 do
-          let(:query_entries) do
-            [
-              { "js_identifier" => "searchUsers", "kind" => "query", "http_method" => "GET",
-                "path" => "/q/searchUsers", "segments" => [], "accepts_params" => true,
-                "params" => [{ "name" => "term", "required" => true },
-                             { "name" => "limit", "required" => false }],
-                "params_rest" => false, "controller" => "CatalogQuery", "action" => "search_users" }
-            ]
-          end
-
-          it "round-trips the params metadata unchanged" do
-            described_class.generate_v2!(entries: query_entries, path: path, now: frozen_time)
-            parsed = JSON.parse(File.read(path))
-            expect(parsed.fetch("functions")).to eq(query_entries)
-          end
-
-          it "is byte-stable: a second pass with identical entries writes nothing" do
-            described_class.generate_v2!(entries: query_entries, path: path, now: frozen_time)
-            expect(described_class.generate_v2!(entries: query_entries, path: path, now: Time.now.utc)).to be(false)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/snapshot_writer_spec.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "tmpdir"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe SnapshotWriter, :story_8_0a do
-      around do |example|
-        Dir.mktmpdir do |dir|
-          @tmpdir = dir
-          example.run
-        end
-      end
-
-      let(:path) { File.join(@tmpdir, "out.txt") }
-
-      describe ".write_if_changed! (Story 8.0a — atomic, byte-aware writer)" do
-        it "writes the file when it does not yet exist and returns true" do
-          expect(described_class.write_if_changed!(path: path, content: "hello\n"))
-            .to be(true)
-          expect(File.read(path)).to eq("hello\n")
-        end
-
-        it "skips writing when the existing content matches byte-for-byte" do
-          File.write(path, "hello\n")
-          original_mtime = File.mtime(path)
-          sleep 1.05
-
-          expect(described_class.write_if_changed!(path: path, content: "hello\n"))
-            .to be(false)
-          expect(File.mtime(path)).to eq(original_mtime)
-        end
-
-        it "writes when the existing content differs by even a single byte" do
-          File.write(path, "hello\n")
-          expect(described_class.write_if_changed!(path: path, content: "hello!\n"))
-            .to be(true)
-          expect(File.read(path)).to eq("hello!\n")
-        end
-
-        it "creates missing parent directories" do
-          nested = File.join(@tmpdir, "a", "b", "c", "out.txt")
-          described_class.write_if_changed!(path: nested, content: "x")
-          expect(File.read(nested)).to eq("x")
-        end
-
-        it "writes via a same-directory tmpfile so partial reads never see " \
-           "a torn file (Story 8.0a)" do
-          described_class.write_if_changed!(path: path, content: "atomic\n")
-          # After the write the temp sibling must not linger.
-          siblings = Dir.children(@tmpdir)
-          expect(siblings).to eq(["out.txt"])
-        end
-
-        it "raises Ruact::ConfigurationError when the parent directory is unwritable " \
-           "(Story 8.0a)" do
-          read_only = File.join(@tmpdir, "ro")
-          FileUtils.mkdir_p(read_only)
-          FileUtils.chmod(0o500, read_only)
-          target = File.join(read_only, "nested", "out.txt")
-
-          expect { described_class.write_if_changed!(path: target, content: "x") }
-            .to raise_error(Ruact::ConfigurationError, /cannot create/)
-        ensure
-          FileUtils.chmod(0o700, read_only) if read_only && File.exist?(read_only)
-        end
-      end
-    end
-  end
-end