ruact 0.0.10 → 0.0.12

data/spec/ruact/server_functions/error_suggestion_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "ruact/server_functions/error_suggestion"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe ErrorSuggestion, :story_8_4 do
-      # Test fixtures using class-name spoofing so the module can be exercised
-      # without requiring ActiveRecord or ActionController to be loaded
-      # (Pitfall #4).
-      def error_with_class_name(name)
-        klass = Class.new(StandardError) do
-          define_singleton_method(:name) { name }
-        end
-        klass.new("fixture")
-      end
-
-      describe "Story 8.4 — .for returns the NFR30-mandated suggestion" do
-        it "returns the RecordInvalid suggestion for ActiveRecord::RecordInvalid" do
-          err = error_with_class_name("ActiveRecord::RecordInvalid")
-          expect(described_class.for(err))
-            .to eq("Validation failed — check the model's `validates` rules")
-        end
-
-        it "returns the CSRF suggestion for ActionController::InvalidAuthenticityToken" do
-          err = error_with_class_name("ActionController::InvalidAuthenticityToken")
-          expect(described_class.for(err))
-            .to eq(
-              "CSRF token mismatch — ensure the page was rendered after the most recent server restart and the session cookie is intact"
-            )
-        end
-
-        it "returns nil for StandardError" do
-          expect(described_class.for(StandardError.new("boom"))).to be_nil
-        end
-
-        it "returns nil for RuntimeError" do
-          expect(described_class.for(RuntimeError.new("boom"))).to be_nil
-        end
-
-        it "returns nil for ArgumentError" do
-          expect(described_class.for(ArgumentError.new("boom"))).to be_nil
-        end
-
-        it "returns nil for a custom user exception class" do
-          custom_class = Class.new(StandardError) { define_singleton_method(:name) { "MyApp::PaymentDeclined" } }
-          expect(described_class.for(custom_class.new("declined"))).to be_nil
-        end
-      end
-
-      describe "Story 8.5 — UploadTooLargeError suggestion", :story_8_5 do
-        it "returns the upload-too-large suggestion for Ruact::UploadTooLargeError" do
-          err = Ruact::UploadTooLargeError.new(received_bytes: 11_000_000, limit_bytes: 10_485_760)
-          expect(described_class.for(err))
-            .to eq(
-              "Upload exceeded the configured size limit. " \
-              "Increase Ruact.config.max_upload_bytes or use Active Storage Direct Upload / " \
-              "a presigned S3 URL for large files."
-            )
-        end
-
-        it "has a SUGGESTIONS entry keyed by the exception class name" do
-          expect(described_class::SUGGESTIONS).to have_key("Ruact::UploadTooLargeError")
-        end
-      end
-
-      describe "Story 8.4 — SUGGESTIONS constant" do
-        it "is frozen so runtime mutation cannot extend the table" do
-          expect(described_class::SUGGESTIONS).to be_frozen
-        end
-
-        it "uses class-name strings as keys (not constants)" do
-          expect(described_class::SUGGESTIONS.keys).to all(be_a(String))
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/introspection_spec.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "active_support/all"
-require "action_dispatch"
-require "ruact/server_functions"
-
-module Ruact
-  module ServerFunctions
-    # Plain query class — only `instance_method(...).parameters` (kwargs) and
-    # `.name` (collision origin) are read; no Rails boot needed. Defined at module
-    # level (mirrors query_source_spec) so it is not an example-group-leaky
-    # constant.
-    class CatalogIntrospectQ
-      def categories; end
-
-      def search_users(term:, limit: 10); end
-    end
-
-    # Story 15.3 (FR107) — `ruact:routes --json` introspection. Exercised through
-    # a REAL RouteSet carrying both a mutation action and mounted query routes,
-    # with the host/query resolvers injected (no controller boot), so the document
-    # is proven byte-derived from RouteSource + QuerySource (the same single
-    # source of truth codegen consumes) and side-effect-free.
-    RSpec.describe Introspection, :story_15_3 do
-      let(:query_prefix) { QuerySource::QUERY_CONTROLLER_PREFIX }
-
-      # A real RouteSet with a mutation action (createPost, updatePost) AND two
-      # mounted query GET routes under the query dispatch controller prefix.
-      def combined_route_set
-        prefix = query_prefix
-        rs = ActionDispatch::Routing::RouteSet.new
-        rs.draw do
-          resources :posts, only: %i[create update]
-          get "/q/categories", to: "#{prefix}catalog_introspect_q#categories"
-          get "/q/search_users", to: "#{prefix}catalog_introspect_q#search_users"
-        end
-        rs
-      end
-
-      def as_json(route_set)
-        described_class.as_json(
-          route_set: route_set,
-          host_predicate: ->(_controller) { true },
-          query_class_for: lambda { |controller|
-            controller.start_with?(query_prefix) ? CatalogIntrospectQ : nil
-          }
-        )
-      end
-
-      describe ".as_json" do
-        subject(:document) { as_json(combined_route_set) }
-
-        it "gates the document with the EXPERIMENTAL schema_version (0)", :aggregate_failures do
-          expect(document["schema_version"]).to eq(0)
-          expect(document["schema_version"]).to eq(described_class::SCHEMA_VERSION)
-        end
-
-        it "round-trips through JSON.parse" do
-          expect(JSON.parse(JSON.generate(document))).to eq(document)
-        end
-
-        it "reports BOTH action and query accessors sorted by name", :aggregate_failures do
-          names = document["accessors"].map { |a| a["accessor"] }
-          expect(names).to include("createPost", "updatePost", "categories", "searchUsers")
-          expect(names).to eq(names.sort)
-        end
-
-        it "shapes an action with its required path segments as declared params", :aggregate_failures do
-          update = document["accessors"].find { |a| a["accessor"] == "updatePost" }
-          expect(update["kind"]).to eq("action")
-          expect(update["verb"]).to eq("PATCH")
-          expect(update["path"]).to eq("/posts/:id")
-          expect(update["segments"]).to eq(["id"])
-          expect(update["params"]).to eq([{ "name" => "id", "required" => true }])
-        end
-
-        it "shapes a query with its declared kwargs as params (Story 13.4)", :aggregate_failures do
-          search = document["accessors"].find { |a| a["accessor"] == "searchUsers" }
-          expect(search["kind"]).to eq("query")
-          expect(search["verb"]).to eq("GET")
-          expect(search["path"]).to eq("/q/search_users")
-          expect(search["segments"]).to eq([])
-          expect(search["params"]).to eq(
-            [{ "name" => "term", "required" => true }, { "name" => "limit", "required" => false }]
-          )
-        end
-
-        it "carries exactly the AC2 keys per accessor" do
-          document["accessors"].each do |accessor|
-            expect(accessor.keys).to contain_exactly("accessor", "kind", "verb", "path", "segments", "params")
-          end
-        end
-
-        it "does NOT include a per-accessor component-contract link (D3 = report accessors faithfully)" do
-          document["accessors"].each do |accessor|
-            expect(accessor).not_to have_key("contract")
-            expect(accessor).not_to have_key("has_contract")
-            expect(accessor).not_to have_key("contract_exists")
-          end
-        end
-      end
-
-      describe "side-effect-free (AC2 / AC4d — writes NO bridge or TS)" do
-        it "never writes the codegen bridge / TS module", :aggregate_failures do
-          allow(SnapshotWriter).to receive(:write_if_changed!)
-          allow(Snapshot).to receive(:generate_v2!)
-          allow(Codegen).to receive(:generate_ts!)
-          allow(File).to receive(:write).and_call_original
-
-          as_json(combined_route_set)
-
-          expect(SnapshotWriter).not_to have_received(:write_if_changed!)
-          expect(Snapshot).not_to have_received(:generate_v2!)
-          expect(Codegen).not_to have_received(:generate_ts!)
-          expect(File).not_to have_received(:write)
-        end
-      end
-
-      describe "single source of truth (AC2)" do
-        it "is byte-derived from ServerFunctions.introspect (same collectors as codegen)" do
-          # Both introspection and write_v2_snapshot! flow through .introspect;
-          # the document's accessors mirror those entries' identifiers exactly.
-          entries = ServerFunctions.introspect(
-            route_set: combined_route_set,
-            host_predicate: ->(_c) { true },
-            query_class_for: ->(c) { c.start_with?(query_prefix) ? CatalogIntrospectQ : nil }
-          )
-          expect(as_json(combined_route_set)["accessors"].map { |a| a["accessor"] })
-            .to eq(entries.map { |e| e["js_identifier"] })
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/name_bridge_spec.rb

@@ -1,212 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe NameBridge, :story_8_0a do
-      describe ".to_js_identifier (Story 8.0a — Ruby symbol → JS identifier)" do
-        # Six canonical edge cases locked by the Story 8.0 ADR.
-
-        it "translates standard snake_case to camelCase" do
-          expect(described_class.to_js_identifier(:create_post)).to eq("createPost")
-        end
-
-        it "passes a single word through unchanged" do
-          expect(described_class.to_js_identifier(:categories)).to eq("categories")
-        end
-
-        it "preserves a single leading underscore" do
-          expect(described_class.to_js_identifier(:_internal_dump)).to eq("_internalDump")
-        end
-
-        it "collapses consecutive underscores" do
-          expect(described_class.to_js_identifier(:foo__bar)).to eq("fooBar")
-        end
-
-        it "raises ConfigurationError for SCREAMING_SNAKE" do
-          expect { described_class.to_js_identifier(:RECALCULATE) }
-            .to raise_error(Ruact::ConfigurationError) do |error|
-              expect(error.message).to include(":RECALCULATE")
-              expect(error.message).to include("/^[a-z_][a-z0-9_]*$/")
-            end
-        end
-
-        it "raises ConfigurationError for PascalCase" do
-          expect { described_class.to_js_identifier(:CreatePost) }
-            .to raise_error(Ruact::ConfigurationError) do |error|
-              expect(error.message).to include(":CreatePost")
-              expect(error.message).to include("ruact server-function name")
-            end
-        end
-
-        describe "additional shape guards" do
-          it "rejects symbols starting with a digit" do
-            expect { described_class.to_js_identifier(:"1foo") }
-              .to raise_error(Ruact::ConfigurationError, /must match/)
-          end
-
-          it "rejects symbols containing a dash" do
-            expect { described_class.to_js_identifier(:"foo-bar") }
-              .to raise_error(Ruact::ConfigurationError, /must match/)
-          end
-
-          it "rejects empty string" do
-            expect { described_class.to_js_identifier(:"") }
-              .to raise_error(Ruact::ConfigurationError, /must match/)
-          end
-
-          it "accepts a string argument identical to its symbol form" do
-            expect(described_class.to_js_identifier("create_post")).to eq("createPost")
-          end
-
-          it "preserves a leading underscore followed by digits" do
-            expect(described_class.to_js_identifier(:_2fa_check)).to eq("_2faCheck")
-          end
-        end
-
-        describe "underscore-only symbols (Story 8.0 review patch 2026-05-13)" do
-          it "rejects a single underscore" do
-            expect { described_class.to_js_identifier(:_) }
-              .to raise_error(Ruact::ConfigurationError) do |error|
-                expect(error.message).to include(":_")
-                expect(error.message).to include("entirely of underscores")
-              end
-          end
-
-          it "rejects a run of underscores" do
-            expect { described_class.to_js_identifier(:____) }
-              .to raise_error(Ruact::ConfigurationError, /entirely of underscores/)
-          end
-
-          it "still accepts a leading underscore followed by alphanumeric" do
-            expect(described_class.to_js_identifier(:_x)).to eq("_x")
-          end
-        end
-
-        describe "JS reserved words (Story 8.0 review patch 2026-05-13)" do
-          # Spot-check a handful of representative classes: keyword (`class`),
-          # module-level reserved (`export`), strict-mode reserved (`let`),
-          # contextually-reserved (`await`, `async`), literal (`true`).
-          it "rejects :class" do
-            expect { described_class.to_js_identifier(:class) }
-              .to raise_error(Ruact::ConfigurationError) do |error|
-                expect(error.message).to include(":class")
-                expect(error.message).to include("JS reserved word")
-                expect(error.message).to include('"class"')
-              end
-          end
-
-          it "rejects :export" do
-            expect { described_class.to_js_identifier(:export) }
-              .to raise_error(Ruact::ConfigurationError, /JS reserved word.*"export"/)
-          end
-
-          it "rejects :let, :await, :async, :true (representative coverage)" do
-            %i[let await async true].each do |sym|
-              expect { described_class.to_js_identifier(sym) }
-                .to raise_error(Ruact::ConfigurationError, /JS reserved word/),
-                    "expected :#{sym} to raise as a reserved word"
-            end
-          end
-
-          it "rejects :eval and :arguments (strict-mode invalid binding names — " \
-             "Story 8.0 Re-run patch 2026-05-13)" do
-            # ES module code runs in strict mode, where `eval` and `arguments`
-            # cannot be used as identifier names. The 8.0a codegen emits a
-            # `"type": "module"` file, so these guards apply unconditionally.
-            %i[eval arguments].each do |sym|
-              expect { described_class.to_js_identifier(sym) }
-                .to raise_error(Ruact::ConfigurationError, /JS reserved word/),
-                    "expected :#{sym} to raise as strict-mode invalid binding name"
-            end
-          end
-
-          it "accepts multi-word symbols whose camelCased output is not reserved" do
-            # No real Ruby snake_case maps to a single reserved word post-
-            # camelCasing (reserved words are themselves single-word), but the
-            # check happens AFTER camelCasing so a hypothetical degenerate
-            # input is still caught.
-            expect { described_class.to_js_identifier(:cl_ass) }
-              .not_to raise_error # "clAss" is not reserved — sanity guard
-            expect(described_class.to_js_identifier(:cl_ass)).to eq("clAss")
-          end
-
-          it "ACCEPTS reserved words that survive only with the leading-underscore prefix" do
-            # `:_class` → "_class" — not reserved (the underscore is a literal
-            # character); intentional escape hatch for devs whose domain
-            # vocabulary collides with JS keywords.
-            expect(described_class.to_js_identifier(:_class)).to eq("_class")
-            expect(described_class.to_js_identifier(:_export)).to eq("_export")
-          end
-
-          it "ACCEPTS the suffix-shaped escape hint from the error message" do
-            # The error message suggests `:class_action`; assert that hint
-            # produces a valid identifier — guards against a regression where
-            # the suggested fix would also fail validation.
-            expect(described_class.to_js_identifier(:class_action)).to eq("classAction")
-          end
-        end
-
-        describe "Ruact-reserved names (Story 8.2 review patch R2 — 2026-05-17)", :story_8_2 do
-          # The codegen unconditionally re-exports certain runtime helpers
-          # from `@/.ruact/server-functions` (e.g. `revalidate`). A server
-          # function named `revalidate` would emit `export const revalidate`
-          # next to the helper re-export and crash at module load with a
-          # duplicate-export error. Reject at route-draw instead.
-          it "rejects :revalidate because it collides with the unconditional helper re-export" do
-            expect { described_class.to_js_identifier(:revalidate) }
-              .to raise_error(Ruact::ConfigurationError) do |error|
-                expect(error.message).to include(":revalidate")
-                expect(error.message).to include("duplicate export")
-              end
-          end
-
-          it "accepts :revalidate_post (suffix escape hatch — same convention as JS reserved-word path)" do
-            expect(described_class.to_js_identifier(:revalidate_post)).to eq("revalidatePost")
-          end
-
-          it "accepts :_revalidate (leading-underscore escape hatch)" do
-            expect(described_class.to_js_identifier(:_revalidate)).to eq("_revalidate")
-          end
-
-          it "rejects :_make_server_function because it collides with the codegen's runtime import" do
-            expect { described_class.to_js_identifier(:_make_server_function) }
-              .to raise_error(Ruact::ConfigurationError) do |error|
-                expect(error.message).to include(":_make_server_function")
-                expect(error.message).to include("duplicate export")
-              end
-          end
-
-          it "accepts :_make_ref now that the demolished v1 runtime export is no longer reserved (Story 9.9)" do
-            expect(described_class.to_js_identifier(:_make_ref)).to eq("_makeRef")
-          end
-
-          # Story 9.5 — `_makeQuery` (the v2 query import) and `useQuery` (the
-          # query hook re-export) are new top-level bindings in the generated
-          # module; a query/action method mapping to either would redeclare the
-          # import / duplicate the export and crash at module load.
-          it "Story 9.5 — rejects :use_query because it collides with the useQuery re-export" do
-            expect { described_class.to_js_identifier(:use_query) }
-              .to raise_error(Ruact::ConfigurationError) do |error|
-                expect(error.message).to include(":use_query")
-                expect(error.message).to include("duplicate export")
-              end
-          end
-
-          it "Story 9.5 — rejects :_make_query because it collides with the codegen's runtime import" do
-            expect { described_class.to_js_identifier(:_make_query) }
-              .to raise_error(Ruact::ConfigurationError) do |error|
-                expect(error.message).to include(":_make_query")
-                expect(error.message).to include("duplicate export")
-              end
-          end
-
-          it "Story 9.5 — accepts :use_query_results (suffix escape hatch keeps working)" do
-            expect(described_class.to_js_identifier(:use_query_results)).to eq("useQueryResults")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/query_context_spec.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-# Story 9.4 — unit spec for the per-request query context (D3). The context
-# wraps the DISPATCHING controller instance and delegates to it: because the
-# internal dispatch controller inherits `Ruact.config.query_parent_controller`,
-# `controller.current_user` IS the host's own method (Devise / Pundit /
-# hand-rolled). No Rails boot needed here — a plain stub controller suffices.
-require "spec_helper"
-
-module Ruact
-  module ServerFunctions
-    RSpec.describe QueryContext, :story_9_4 do
-      describe "Story 9.4 — delegation to the dispatching controller (AC3 / D3)" do
-        let(:controller_class) do
-          Class.new do
-            def params  = { "q" => "x" }
-            def request = :the_request
-            def session = { "sid" => 1 }
-
-            def current_user
-              { "id" => 7 }
-            end
-          end
-        end
-
-        subject(:context) { described_class.new(controller: controller_class.new) }
-
-        it "delegates params" do
-          expect(context.params).to eq("q" => "x")
-        end
-
-        it "delegates request" do
-          expect(context.request).to eq(:the_request)
-        end
-
-        it "delegates session" do
-          expect(context.session).to eq("sid" => 1)
-        end
-
-        it "delegates current_user to the host's own method" do
-          expect(context.current_user).to eq("id" => 7)
-        end
-      end
-
-      describe "Story 9.4 — current_user reaches a PRIVATE host helper too" do
-        let(:controller_class) do
-          Class.new do
-            private
-
-            def current_user
-              :private_user
-            end
-          end
-        end
-
-        it "resolves it (hand-rolled apps commonly define current_user private)" do
-          context = described_class.new(controller: controller_class.new)
-          expect(context.current_user).to eq(:private_user)
-        end
-      end
-
-      describe "Story 9.4 — clear error when the host defines no current_user (D3)" do
-        it "raises NoMethodError naming the parent controller and the fix" do
-          context = described_class.new(controller: Class.new.new)
-          expect { context.current_user }.to raise_error(NoMethodError, /current_user/) do |error|
-            expect(error.message).to include("query_parent_controller")
-          end
-        end
-      end
-    end
-  end
-end