ruact 0.0.10 → 0.0.12

data/spec/ruact/server_functions/query_source_spec.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "ruact/server_functions"
-require "ruact/server_functions/query_source"
-
-module Ruact
-  module ServerFunctions
-    # Plain query classes — only `instance_method(...).parameters` (kwargs
-    # presence) and `.name` (collision origin) are read. Defined at module
-    # level so they are not example-group-leaky constants.
-    class CatalogQ
-      def categories; end
-
-      def search_users(term:, limit: 10); end
-    end
-
-    class PeopleQ
-      def search_users(term:); end
-    end
-
-    # Story 13.4 — kwarg shapes exercising the per-param metadata derivation:
-    # a `**keyrest` (anonymous + named), and a positional that must be ignored.
-    class ParamShapesQ
-      def with_rest(scope:, **opts); end
-
-      def rest_only(**opts); end
-
-      def positional_ignored(id, query:); end
-    end
-
-    # Story 9.5 — query introspection: the drawn route table (filtered to the
-    # generated query dispatch controllers) → v2 query entries. Pure: route set
-    # and the query-class resolver are injected, so the derivation is testable
-    # with no Rails boot and no controllers (a fake route set + plain query
-    # classes).
-    RSpec.describe QuerySource, :story_9_5 do
-      # Minimal route double exposing the surface QuerySource reads:
-      # `defaults[:controller]`, `defaults[:action]`, `path.spec.to_s`.
-      def query_route(controller, action, path)
-        spec = Object.new
-        spec.define_singleton_method(:to_s) { "#{path}(.:format)" }
-        path_obj = Object.new
-        path_obj.define_singleton_method(:spec) { spec }
-        route = Object.new
-        route.define_singleton_method(:defaults) { { controller: controller, action: action } }
-        route.define_singleton_method(:path) { path_obj }
-        route
-      end
-
-      def route_set(routes)
-        rs = Object.new
-        rs.define_singleton_method(:routes) { routes }
-        rs
-      end
-
-      let(:prefix) { QuerySource::QUERY_CONTROLLER_PREFIX }
-
-      def resolver(map)
-        ->(controller) { map[controller] }
-      end
-
-      describe ".collect" do
-        it "emits one query entry per mounted query route (route-truth)" do
-          rs = route_set([
-                           query_route("#{prefix}catalog_q", "categories", "/q/categories"),
-                           query_route("#{prefix}catalog_q", "search_users", "/q/searchUsers")
-                         ])
-          entries = described_class.collect(rs, query_class_for: resolver("#{prefix}catalog_q" => CatalogQ))
-
-          expect(entries.map { |e| e["js_identifier"] }).to eq(%w[categories searchUsers])
-          expect(entries).to all(include("kind" => "query", "http_method" => "GET", "segments" => []))
-        end
-
-        it "derives jsId via NameBridge and carries the clean path" do
-          rs = route_set([query_route("#{prefix}catalog_q", "search_users", "/q/searchUsers")])
-          entry = described_class.collect(rs, query_class_for: resolver("#{prefix}catalog_q" => CatalogQ)).first
-          expect(entry["js_identifier"]).to eq("searchUsers")
-          expect(entry["path"]).to eq("/q/searchUsers")
-          expect(entry["controller"]).to eq("Ruact::ServerFunctions::CatalogQ")
-          expect(entry["action"]).to eq("search_users")
-        end
-
-        it "flags accepts_params true when the method declares kwargs, false otherwise" do
-          rs = route_set([
-                           query_route("#{prefix}catalog_q", "categories", "/q/categories"),
-                           query_route("#{prefix}catalog_q", "search_users", "/q/searchUsers")
-                         ])
-          entries = described_class.collect(rs, query_class_for: resolver("#{prefix}catalog_q" => CatalogQ))
-          by_id = entries.to_h { |e| [e["js_identifier"], e] }
-          expect(by_id["categories"]["accepts_params"]).to be(false)
-          expect(by_id["searchUsers"]["accepts_params"]).to be(true)
-        end
-
-        it "derives per-kwarg params metadata (name + required/optional, declaration order)", :story_13_4 do
-          rs = route_set([query_route("#{prefix}catalog_q", "search_users", "/q/searchUsers")])
-          entry = described_class.collect(rs, query_class_for: resolver("#{prefix}catalog_q" => CatalogQ)).first
-          expect(entry["params"]).to eq([
-                                          { "name" => "term", "required" => true },
-                                          { "name" => "limit", "required" => false }
-                                        ])
-          expect(entry["params_rest"]).to be(false)
-        end
-
-        it "emits empty params + accepts_params false for a no-kwargs query", :story_13_4 do
-          rs = route_set([query_route("#{prefix}catalog_q", "categories", "/q/categories")])
-          entry = described_class.collect(rs, query_class_for: resolver("#{prefix}catalog_q" => CatalogQ)).first
-          expect(entry["params"]).to eq([])
-          expect(entry["params_rest"]).to be(false)
-          expect(entry["accepts_params"]).to be(false)
-        end
-
-        it "flags params_rest for a `**keyrest` and still carries the named keys", :story_13_4 do
-          rs = route_set([query_route("#{prefix}params_q", "with_rest", "/q/withRest")])
-          entry = described_class.collect(rs, query_class_for: resolver("#{prefix}params_q" => ParamShapesQ)).first
-          expect(entry["params"]).to eq([{ "name" => "scope", "required" => true }])
-          expect(entry["params_rest"]).to be(true)
-          expect(entry["accepts_params"]).to be(true)
-        end
-
-        it "treats a `**keyrest`-only query as accepts_params (rest, no named keys)", :story_13_4 do
-          rs = route_set([query_route("#{prefix}params_q", "rest_only", "/q/restOnly")])
-          entry = described_class.collect(rs, query_class_for: resolver("#{prefix}params_q" => ParamShapesQ)).first
-          expect(entry["params"]).to eq([])
-          expect(entry["params_rest"]).to be(true)
-          expect(entry["accepts_params"]).to be(true)
-        end
-
-        it "ignores positional params (only kwargs are FR88 query params)", :story_13_4 do
-          rs = route_set([query_route("#{prefix}params_q", "positional_ignored", "/q/positionalIgnored")])
-          entry = described_class.collect(rs, query_class_for: resolver("#{prefix}params_q" => ParamShapesQ)).first
-          expect(entry["params"]).to eq([{ "name" => "query", "required" => true }])
-          expect(entry["params_rest"]).to be(false)
-        end
-
-        it "ignores non-query routes (controller not under the dispatch namespace)" do
-          rs = route_set([
-                           query_route("posts", "create", "/posts"),
-                           query_route("#{prefix}catalog_q", "categories", "/q/categories")
-                         ])
-          entries = described_class.collect(rs, query_class_for: resolver("#{prefix}catalog_q" => CatalogQ))
-          expect(entries.map { |e| e["js_identifier"] }).to eq(%w[categories])
-        end
-
-        it "skips a query route whose class cannot be resolved (nil resolver result)" do
-          rs = route_set([query_route("#{prefix}gone_q", "categories", "/q/categories")])
-          expect(described_class.collect(rs, query_class_for: resolver({}))).to eq([])
-        end
-
-        it "raises a query×query collision naming both origins" do
-          rs = route_set([
-                           query_route("#{prefix}catalog_q", "search_users", "/q/searchUsers"),
-                           query_route("#{prefix}people_q", "search_users", "/q/searchUsers")
-                         ])
-          map = { "#{prefix}catalog_q" => CatalogQ, "#{prefix}people_q" => PeopleQ }
-          expect { described_class.collect(rs, query_class_for: resolver(map)) }
-            .to raise_error(Ruact::ConfigurationError, /CatalogQ#search_users and .*PeopleQ#search_users/m)
-        end
-      end
-    end
-
-    # Story 9.5 (Task 2) — the merged JS namespace (route entries + query
-    # entries share it). The route×query side is detected at the codegen
-    # combine point.
-    RSpec.describe ".detect_merged_namespace_collisions!", :story_9_5 do
-      def action_entry(js_id, controller, action)
-        { "js_identifier" => js_id, "kind" => "action", "controller" => controller, "action" => action }
-      end
-
-      def query_entry(js_id, controller, action)
-        { "js_identifier" => js_id, "kind" => "query", "controller" => controller, "action" => action }
-      end
-
-      it "raises on a route×query collision naming both origins + the rename escape hatch" do
-        entries = [
-          action_entry("categories", "posts", "categories"),
-          query_entry("categories", "CatalogQuery", "categories")
-        ]
-        expect { ServerFunctions.detect_merged_namespace_collisions!(entries) }
-          .to raise_error(Ruact::ConfigurationError,
-                          /posts#categories and CatalogQuery#categories.*ruact_function_name/m)
-      end
-
-      it "does not raise when the rename makes the identifiers distinct" do
-        entries = [
-          action_entry("listCategories", "posts", "categories"), # renamed via ruact_function_name
-          query_entry("categories", "CatalogQuery", "categories")
-        ]
-        expect { ServerFunctions.detect_merged_namespace_collisions!(entries) }.not_to raise_error
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/railtie_integration_spec.rb

@@ -1,215 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "tmpdir"
-require "fileutils"
-require "action_controller"
-
-# Spec_helper's rails_stub defines Rails; the railtie was not auto-required
-# because Rails was not yet defined when ruact.rb evaluated `require_relative
-# "ruact/railtie" if defined?(Rails)`. Load it explicitly (mirrors
-# spec/ruact/railtie_spec.rb).
-require "ruact/railtie"
-require "ruact/controller"
-require "ruact/server"
-require "ruact/routing"
-require "ruact/query"
-
-# Story 9.9 — the route-driven (v2) codegen is the sole writer of the real
-# bridge. `Railtie.write_server_functions_snapshot!` is the entry point wired
-# into `config.to_prepare`; it forces the route table to load, then delegates to
-# `ServerFunctions.write_v2_snapshot!`, which writes the v2 snapshot to the REAL
-# bridge (`tmp/cache/ruact/server-functions.json`).
-module Ruact
-  module ServerFunctions
-    RSpec.describe "Ruact::Railtie.write_server_functions_snapshot! (Story 9.9)", :story_9_9 do
-      before do
-        stub_const("WrapperDemoPostsController", Class.new(ActionController::Base) { include Ruact::Server })
-      end
-
-      around do |example|
-        Dir.mktmpdir do |dir|
-          original_root = Rails.root
-          Rails.root    = Pathname.new(dir)
-          @tmpdir       = dir
-          example.run
-        ensure
-          Rails.root = original_root
-        end
-      end
-
-      let(:path) { File.join(@tmpdir, "tmp/cache/ruact/server-functions.json") }
-
-      # Drives the wrapper by stubbing Rails.application with a routes set + a
-      # no-op routes_reloader (the cold-boot ordering fold-in).
-      def stub_application(routes)
-        reloader = Object.new
-        def reloader.execute_unless_loaded; end
-        app = Object.new
-        app.define_singleton_method(:routes) { routes }
-        app.define_singleton_method(:routes_reloader) { reloader }
-        allow(Rails).to receive(:application).and_return(app)
-      end
-
-      def route_set
-        rs = ActionDispatch::Routing::RouteSet.new
-        rs.draw { resources :wrapper_demo_posts, only: %i[create update destroy] }
-        rs
-      end
-
-      it "writes the v2 JSON to the REAL bridge (tmp/cache/ruact/server-functions.json)" do
-        stub_application(route_set)
-        entries = Ruact::Railtie.write_server_functions_snapshot!
-        expect(entries.map { |e| e["js_identifier"] })
-          .to match_array(%w[createWrapperDemoPost updateWrapperDemoPost destroyWrapperDemoPost])
-        expect(File).to exist(path)
-        expect(JSON.parse(File.read(path)).fetch("version")).to eq(2)
-      end
-
-      it "writes an empty `functions: []` array when no routes are exposed" do
-        empty = ActionDispatch::Routing::RouteSet.new
-        empty.draw { get "/health", to: "health#show" }
-        stub_application(empty)
-        Ruact::Railtie.write_server_functions_snapshot!
-        expect(JSON.parse(File.read(path)).fetch("functions")).to eq([])
-      end
-
-      it "forces the route table to load before reading it (cold-boot ordering fold-in)" do
-        reloader = Object.new
-        called = false
-        reloader.define_singleton_method(:execute_unless_loaded) { called = true }
-        routes = route_set
-        app = Object.new
-        app.define_singleton_method(:routes) { routes }
-        app.define_singleton_method(:routes_reloader) { reloader }
-        allow(Rails).to receive(:application).and_return(app)
-        Ruact::Railtie.write_server_functions_snapshot!
-        expect(called).to be(true)
-      end
-    end
-
-    RSpec.describe "Ruact::ServerFunctions.write_v2_snapshot! (Story 9.3)", :story_9_3 do
-      # A real Ruact::Server host so RouteSource's default constant-resolving
-      # host predicate recognizes it; stub_const (not a literal class) keeps the
-      # file single-definition and the constant scoped to the example.
-      before do
-        stub_const("V2DemoPostsController", Class.new(ActionController::Base) { include Ruact::Server })
-      end
-
-      around do |example|
-        Dir.mktmpdir { |dir| @tmpdir = dir and example.run }
-      end
-
-      def route_set
-        rs = ActionDispatch::Routing::RouteSet.new
-        rs.draw { resources :v2_demo_posts, only: %i[create update destroy] }
-        rs
-      end
-
-      def write!(logger: nil)
-        Ruact::ServerFunctions.write_v2_snapshot!(
-          route_set: route_set, root: Pathname.new(@tmpdir), logger: logger
-        )
-      end
-
-      # Story 9.9 — the v2 codegen writes the REAL bridge (the `.next` parallel
-      # target was demolished).
-      let(:real_json) { File.join(@tmpdir, "tmp/cache/ruact/server-functions.json") }
-      let(:real_ts)   { File.join(@tmpdir, "app/javascript/.ruact/server-functions.ts") }
-
-      it "writes the v2 bridge + TS to the REAL target" do
-        entries = write!
-
-        expect(entries.map { |e| e["js_identifier"] })
-          .to match_array(%w[createV2DemoPost updateV2DemoPost destroyV2DemoPost])
-        expect(File).to exist(real_json)
-        expect(File).to exist(real_ts)
-        expect(JSON.parse(File.read(real_json)).fetch("version")).to eq(2)
-      end
-
-      it "renders _makeServerFunction calls targeting real routes into the TS" do
-        write!
-        ts = File.read(real_ts)
-        expect(ts).to include('import { _makeServerFunction } from "ruact/server-functions-runtime";')
-        expect(ts).to include('_makeServerFunction({ method: "POST", path: "/v2_demo_posts", segments: [] });')
-        expect(ts).to include('_makeServerFunction({ method: "PATCH", path: "/v2_demo_posts/:id", segments: ["id"] });')
-      end
-
-      it "is byte-stable across calls on an unchanged route table (no churn)" do
-        write!
-        first = File.read(real_ts)
-        write!
-        expect(File.read(real_ts)).to eq(first)
-      end
-
-      it "logs the exposed function names (AC2 — transparency over silence)" do
-        logger = instance_double(Logger, info: nil)
-        write!(logger: logger)
-        expect(logger).to have_received(:info).with(/\[ruact\] codegen: exposing .*createV2DemoPost/)
-      end
-    end
-
-    RSpec.describe "Ruact::ServerFunctions.write_v2_snapshot! — queries (Story 9.5)", :story_9_5 do
-      around do |example|
-        Dir.mktmpdir { |dir| @tmpdir = dir and example.run }
-      end
-
-      before do
-        stub_const("V2QueryParentController", Class.new(ActionController::Base))
-        Ruact.configure { |c| c.query_parent_controller = "V2QueryParentController" }
-        stub_const("V2CatalogQuery", Class.new(Ruact::Query) do
-          def categories; end
-          def search(term:); end
-        end)
-      end
-
-      def route_set
-        route_set = ActionDispatch::Routing::RouteSet.new
-        route_set.draw { ruact_queries V2CatalogQuery }
-        route_set
-      end
-
-      def write!(routes = route_set)
-        Ruact::ServerFunctions.write_v2_snapshot!(route_set: routes, root: Pathname.new(@tmpdir))
-      end
-
-      let(:real_ts) { File.join(@tmpdir, "app/javascript/.ruact/server-functions.ts") }
-
-      it "emits query entries (route-truth) merged into the v2 snapshot" do
-        entries = write!
-        expect(entries.map { |e| e["js_identifier"] }).to match_array(%w[categories search])
-        expect(entries).to all(include("kind" => "query", "http_method" => "GET"))
-      end
-
-      it "renders _makeQuery refs + the useQuery re-export into the TS" do
-        write!
-        ts = File.read(real_ts)
-        expect(ts).to include('import { _makeQuery } from "ruact/server-functions-runtime";')
-        expect(ts).to include('_makeQuery({ path: "/q/categories", kind: "query" });')
-        expect(ts).to include("export const categories: () => Promise<unknown> =")
-        # Story 13.4 — the real pipeline now narrows `params` to the declared
-        # kwargs end-to-end (`def search(term:)` → a required `term` of the FR88
-        # wire union), not the opaque `Record<string, unknown>`.
-        expect(ts).to include(
-          "export const search: (params: { term: string | number | boolean | null }) => Promise<unknown> ="
-        )
-        expect(ts).to include('export { useQuery } from "ruact/server-functions-runtime";')
-      end
-
-      it "raises a route×query collision when an action and a query share a js_identifier" do
-        stub_const("CategoriesController", Class.new(ActionController::Base) { include Ruact::Server })
-        stub_const("CollideQuery", Class.new(Ruact::Query) { def categories; end })
-        rs = ActionDispatch::Routing::RouteSet.new
-        rs.draw do
-          post "categories", to: "categories#categories"
-          ruact_queries CollideQuery
-        end
-        CategoriesController.define_singleton_method(:__ruact_function_name_overrides) do
-          { "categories" => "categories" }
-        end
-        expect { Ruact::ServerFunctions.write_v2_snapshot!(route_set: rs, root: Pathname.new(@tmpdir)) }
-          .to raise_error(Ruact::ConfigurationError, /both map to JS identifier "categories".*ruact_function_name/m)
-      end
-    end
-  end
-end

data/spec/ruact/server_functions/rake_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "rake"
-require "tmpdir"
-require "fileutils"
-require "action_controller"
-require "ruact/server"
-
-# Story 9.9 — exercises `rake ruact:server_functions:generate` end-to-end. The
-# task forces the route table to load, then writes the route-driven (v2)
-# snapshot to the REAL bridge (tmp/cache/ruact/server-functions.json) and
-# renders the TS module. It runs against a tmpdir as Rails.root with a stubbed
-# Rails.application providing a route set + a no-op routes_reloader.
-module Ruact
-  module ServerFunctions
-    RSpec.describe "rake ruact:server_functions:generate", :story_9_9 do
-      before do
-        stub_const("RakeDemoPostsController", Class.new(ActionController::Base) { include Ruact::Server })
-        reloader = Object.new
-        def reloader.execute_unless_loaded; end
-        rs = ActionDispatch::Routing::RouteSet.new
-        rs.draw { resources :rake_demo_posts, only: %i[create update destroy] }
-        app = Object.new
-        app.define_singleton_method(:routes) { rs }
-        app.define_singleton_method(:routes_reloader) { reloader }
-        allow(Rails).to receive(:application).and_return(app)
-      end
-
-      around do |example|
-        Dir.mktmpdir do |dir|
-          original_root = Rails.root
-          Rails.root    = Pathname.new(dir)
-          @tmpdir       = dir
-
-          prev = Rake.application
-          Rake.application = Rake::Application.new
-          Rake.application.define_task(Rake::Task, :environment)
-          load File.expand_path("../../../lib/tasks/ruact.rake", __dir__)
-
-          example.run
-        ensure
-          Rake.application = prev
-          Rails.root       = original_root
-        end
-      end
-
-      let(:json_path) { File.join(@tmpdir, "tmp/cache/ruact/server-functions.json") }
-      let(:ts_path)   { File.join(@tmpdir, "app/javascript/.ruact/server-functions.ts") }
-
-      def invoke!
-        Rake::Task["ruact:server_functions:generate"].reenable
-        Rake::Task["ruact:server_functions:generate"].invoke
-      end
-
-      it "registers the task under the documented name" do
-        expect(Rake.application.lookup("ruact:server_functions:generate")).not_to be_nil
-      end
-
-      it "writes both the v2 JSON bridge and the TS module on first run", :aggregate_failures do
-        invoke!
-        expect(File).to exist(json_path)
-        expect(File).to exist(ts_path)
-        expect(JSON.parse(File.read(json_path)).fetch("version")).to eq(2)
-        expect(File.read(ts_path)).to include("// AUTO-GENERATED by vite-plugin-ruact")
-        expect(File.read(ts_path)).to include("_makeServerFunction({ method: \"POST\"")
-      end
-
-      it "is idempotent: a second run does not change file contents" do
-        invoke!
-        before = File.read(ts_path)
-        invoke!
-        expect(File.read(ts_path)).to eq(before)
-      end
-
-      it "exits 1 with a `[ruact] error:` line when codegen raises a ConfigurationError" do
-        allow(Ruact::ServerFunctions).to receive(:write_v2_snapshot!)
-          .and_raise(Ruact::ConfigurationError,
-                     "server-function naming collision: PostsController#create and ...")
-        expect { invoke! }
-          .to raise_error(SystemExit)
-          .and output(/\[ruact\] error:.*naming collision/).to_stderr
-      end
-    end
-  end
-end