RubyGems - ruact - Versions diffs - 0.0.8 → 0.0.10 - Mend

ruact 0.0.8 → 0.0.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +59 -1
data/LICENSE.txt +21 -0
data/README.md +124 -18
data/SECURITY.md +1 -1
data/lib/generators/ruact/install/install_generator.rb +264 -5
data/lib/generators/ruact/install/templates/Procfile.dev.tt +3 -0
data/lib/generators/ruact/install/templates/globals.css.tt +20 -0
data/lib/generators/ruact/install/templates/initializer.rb.tt +9 -0
data/lib/generators/ruact/install/templates/package.json.tt +7 -1
data/lib/generators/ruact/install/templates/tsconfig.json.tt +18 -0
data/lib/generators/ruact/scaffold/scaffold_shadcn_preflight.rb +10 -0
data/lib/ruact/configuration.rb +73 -0
data/lib/ruact/controller/document_rendering.rb +210 -0
data/lib/ruact/controller.rb +5 -46
data/lib/ruact/doctor.rb +37 -5
data/lib/ruact/layout_source.rb +59 -0
data/lib/ruact/version.rb +1 -1
data/lib/ruact/view_helper.rb +10 -1
data/lib/ruact.rb +1 -0
data/spec/fixtures/readme/children-error.html.erb +3 -0
data/spec/fixtures/readme/children-error.txt +1 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/exploding_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/ghost_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/rootless_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/controller_request_spec_support/unwired_layout_demo/show.html.erb +3 -0
data/spec/fixtures/story_7_9_views/layouts/bare_host.html.erb +16 -0
data/spec/fixtures/story_7_9_views/layouts/exploding_host.html.erb +24 -0
data/spec/fixtures/story_7_9_views/layouts/rootless_host.html.erb +15 -0
data/spec/fixtures/story_7_9_views/layouts/ruact_host.html.erb +17 -0
data/spec/readme_demo_message_spec.rb +67 -0
data/spec/readme_spec.rb +282 -0
data/spec/ruact/controller_request_spec.rb +203 -0
data/spec/ruact/doctor_spec.rb +81 -6
data/spec/ruact/install_generator_spec.rb +442 -70
data/spec/ruact/layout_source_spec.rb +108 -0
data/spec/ruact/scaffold_generator_spec.rb +14 -0
metadata +30 -5

data/spec/ruact/doctor_spec.rb CHANGED Viewed

@@ -23,10 +23,20 @@ RSpec.describe Ruact::Doctor do
     File.write(dir.join("application_controller.rb"), content)
   end
-  def make_layout(with_sentinel: true)
+  # `with_assets` is the second half of a migrated layout: the React root alone
+  # leaves ruact on its built-in (CSS-less) shell, so the two markers are
+  # independent inputs, not one sentinel.
+  def make_layout(with_sentinel: true, with_assets: true)
     dir = tmpdir.join("app", "views", "layouts")
     FileUtils.mkdir_p(dir)
-    content = with_sentinel ? "<%# ruact: root %>\n<div id=\"root\"></div>\n" : "<body></body>\n"
+    content =
+      if !with_sentinel
+        "<body></body>\n"
+      elsif with_assets
+        "<%# ruact: root %>\n<div id=\"root\"></div>\n<%= ruact_js_assets %>\n"
+      else
+        "<%# ruact: root %>\n<div id=\"root\"></div>\n"
+      end
     File.write(dir.join("application.html.erb"), content)
   end
@@ -131,8 +141,11 @@ RSpec.describe Ruact::Doctor do
   describe "#check_layout (AC#1, #5)" do
     subject(:doctor) { described_class.new }
-    context "when layout contains the React shell sentinel" do
-      before { make_layout(with_sentinel: true) }
+    context "when the layout is wired and the app opted in" do
+      before do
+        make_layout(with_sentinel: true, with_assets: true)
+        Ruact.configure { |c| c.layout = true }
+      end
       it "returns :pass" do
         status, = doctor.send(:check_layout)
@@ -140,7 +153,60 @@ RSpec.describe Ruact::Doctor do
       end
     end
-    context "when React shell sentinel is absent" do
+    # Both halves are silent when wrong, and they are DIFFERENT fixes — "add one
+    # line to the layout" versus "flip one setting" — so they report separately.
+    context "when the layout is wired but Ruact.config.layout is false" do
+      before do
+        make_layout(with_sentinel: true, with_assets: true)
+        Ruact.configure { |c| c.layout = false }
+      end
+      it "returns :warn naming the setting, not the layout" do
+        status, message, remediation = doctor.send(:check_layout)
+        expect(status).to eq(:warn)
+        expect(message).to include("config.layout is false")
+        expect(remediation).to include("config.layout = true")
+      end
+      it "does not fail the doctor run" do
+        expect(described_class::SUCCESS_STATUSES).to include(:warn)
+      end
+    end
+    context "when the layout has the React root but never calls ruact_js_assets" do
+      before do
+        make_layout(with_sentinel: true, with_assets: false)
+        Ruact.configure { |c| c.layout = true }
+      end
+      it "fails and names the helper to add" do
+        status, _message, remediation = doctor.send(:check_layout)
+        expect(status).to eq(:fail)
+        expect(remediation).to include("ruact_js_assets")
+      end
+    end
+    # The drift this shares with the runtime and the generator: a MENTION of the
+    # helper in a comment is not a call, and reporting :pass on one sent a
+    # developer looking anywhere but at the real problem.
+    context "when the layout only mentions the helper in a comment" do
+      before do
+        dir = tmpdir.join("app", "views", "layouts")
+        FileUtils.mkdir_p(dir)
+        File.write(dir.join("application.html.erb"),
+                   "<%# ruact: root %>\n<div id=\"root\"></div>\n<%# TODO: add ruact_js_assets %>\n")
+        Ruact.configure { |c| c.layout = true }
+      end
+      it "does not report it as wired" do
+        status, = doctor.send(:check_layout)
+        expect(status).to eq(:fail)
+      end
+    end
+    context "when the layout has neither the root nor the helper" do
       before { make_layout(with_sentinel: false) }
       it "returns :fail" do
@@ -148,8 +214,17 @@ RSpec.describe Ruact::Doctor do
         expect(status).to eq(:fail)
       end
-      it "message is 'React shell missing from application.html.erb'" do
+      it "names both halves, since either could be the missing one" do
         _, msg = doctor.send(:check_layout)
+        expect(msg).to include("React root").and include("ruact_js_assets")
+      end
+    end
+    context "when there is no application layout file at all" do
+      it "reports the file, not its contents" do
+        status, msg = doctor.send(:check_layout)
+        expect(status).to eq(:fail)
         expect(msg).to eq("React shell missing from application.html.erb")
       end
     end

data/spec/ruact/install_generator_spec.rb CHANGED Viewed

@@ -88,22 +88,6 @@ RSpec.describe Ruact do # rubocop:disable RSpec/SpecFilePathFormat
       :injected
     end
-    # Reproduces inject_layout_shell logic from the generator
-    def inject_layout_shell(dest_root)
-      layout_file = File.join(dest_root, "app/views/layouts/application.html.erb")
-      return :missing unless File.exist?(layout_file)
-      content = File.read(layout_file)
-      return :already_present if content.include?("ruact: root")
-      modified = content.sub(
-        "  </body>",
-        "    <%# ruact: root %>\n    <div id=\"root\"></div>\n  </body>"
-      )
-      File.write(layout_file, modified)
-      :injected
-    end
     describe "ApplicationController injection (AC#1, AC#3)" do
       let(:controller_content) do
         "class ApplicationController < ActionController::Base\nend\n"
@@ -137,60 +121,6 @@ RSpec.describe Ruact do # rubocop:disable RSpec/SpecFilePathFormat
       end
     end
-    describe "Layout injection (AC#1, AC#3)" do
-      let(:layout_content) do
-        <<~HTML
-          <!DOCTYPE html>
-          <html>
-            <body>
-              <%= yield %>
-            </body>
-          </html>
-        HTML
-      end
-      it "injects the RSC root div before </body>" do
-        write_file("app/views/layouts/application.html.erb", layout_content)
-        result = inject_layout_shell(tmpdir)
-        expect(result).to eq(:injected)
-        content = read_file("app/views/layouts/application.html.erb")
-        expect(content).to include('<div id="root"></div>')
-        expect(content).to include("ruact: root")
-      end
-      it "returns :already_present on second run (idempotent, AC#3)" do
-        content_with_marker = layout_content.sub(
-          "  </body>",
-          "    <%# ruact: root %>\n    <div id=\"root\"></div>\n  </body>"
-        )
-        write_file("app/views/layouts/application.html.erb", content_with_marker)
-        result = inject_layout_shell(tmpdir)
-        expect(result).to eq(:already_present)
-      end
-      it "does not duplicate the root div when run twice (AC#3)" do
-        write_file("app/views/layouts/application.html.erb", layout_content)
-        inject_layout_shell(tmpdir)
-        inject_layout_shell(tmpdir)
-        content = read_file("app/views/layouts/application.html.erb")
-        occurrences = content.scan('<div id="root">').size
-        expect(occurrences).to eq(1)
-      end
-      it "places the root div before the closing </body> tag" do
-        write_file("app/views/layouts/application.html.erb", layout_content)
-        inject_layout_shell(tmpdir)
-        content = read_file("app/views/layouts/application.html.erb")
-        root_pos  = content.index('<div id="root">')
-        body_pos  = content.index("</body>")
-        expect(root_pos).to be < body_pos
-      end
-    end
     describe "vite.config.js template (AC#2)" do
       let(:template_path) do
         File.expand_path(
@@ -1174,4 +1104,446 @@ RSpec.describe Ruact do # rubocop:disable RSpec/SpecFilePathFormat
       end
     end
   end
+  # The `--shadcn` prerequisites. The gap these close is concrete: shadcn's CLI
+  # aborts on a ruact app with "No Tailwind CSS configuration found" and "Could
+  # not find valid path aliases", because a ruact app ships neither Tailwind nor
+  # a tsconfig.json. Without them `ruact:scaffold --shadcn` emitted components
+  # whose classes resolved to nothing — styled markup with no styles.
+  describe "install generator — --shadcn prerequisites" do
+    require "stringio"
+    require "generators/ruact/install/install_generator"
+    let(:app_root) { Dir.mktmpdir("ruact_install_shadcn") }
+    after { FileUtils.rm_rf(app_root) }
+    def build_generator(root, opts = {})
+      Ruact::Generators::InstallGenerator.new([], opts, destination_root: root)
+    end
+    def silently
+      original = $stdout
+      $stdout = StringIO.new
+      yield
+    ensure
+      $stdout = original
+    end
+    def read(relative)
+      File.read(File.join(app_root, relative))
+    end
+    describe "with --shadcn", :aggregate_failures do
+      let(:generator) { build_generator(app_root, shadcn: true) }
+      it "writes the Tailwind entry shadcn points components.json at" do
+        silently { generator.create_shadcn_prerequisites }
+        expect(File).to exist(File.join(app_root, "app/javascript/styles/globals.css"))
+        expect(read("app/javascript/styles/globals.css")).to include('@import "tailwindcss"')
+      end
+      it "writes the tsconfig import alias shadcn probes for" do
+        silently { generator.create_shadcn_prerequisites }
+        tsconfig = JSON.parse(read("tsconfig.json"))
+        expect(tsconfig.dig("compilerOptions", "paths", "@/*")).to eq(["app/javascript/*"])
+      end
+      it "creates the builds directory Propshaft serves the compiled stylesheet from" do
+        silently { generator.create_shadcn_prerequisites }
+        expect(File).to exist(File.join(app_root, "app/assets/builds/.keep"))
+      end
+      it "declares Tailwind in package.json with a build:css script" do
+        silently { generator.create_package_json }
+        pkg = JSON.parse(read("package.json"))
+        expect(pkg.dig("devDependencies", "tailwindcss")).to be_a(String)
+        expect(pkg.dig("devDependencies", "@tailwindcss/cli")).to be_a(String)
+        expect(pkg.dig("devDependencies", "tw-animate-css")).to be_a(String)
+        expect(pkg.dig("scripts", "build:css")).to include("app/assets/builds/tailwind.css")
+      end
+      it "adds a css watch process so bin/dev rebuilds the stylesheet" do
+        silently { generator.create_launch_files }
+        expect(read("Procfile.dev")).to match(/^css: .*tailwind\.css --watch$/)
+      end
+      it "gitignores the compiled stylesheet (a build artifact of globals.css)" do
+        File.write(File.join(app_root, ".gitignore"), "/log/*\n")
+        silently { generator.append_gitignore_entries }
+        expect(read(".gitignore")).to include("app/assets/builds/tailwind.css")
+      end
+      # The one thing a reader cannot guess: current shadcn defaults to Base UI,
+      # but the components the scaffold generates import Radix primitives.
+      it "prints the two shadcn commands, pinning --base radix" do
+        expect { generator.send(:show_shadcn_next_steps) }
+          .to output(/npx shadcn@latest init --base radix/).to_stdout
+      end
+      it "prints the complete add-list, so the scaffold pre-flight cannot fail on a gap" do
+        expect { generator.send(:show_shadcn_next_steps) }
+          .to output(/add button input textarea switch select label badge table alert-dialog dropdown-menu/)
+          .to_stdout
+      end
+    end
+    # Codex review finding: the layout-migration branch was pinned only by the
+    # REPRODUCTION helper above, which cannot see the real generator's anchor
+    # regex. Invoking the actual generator caught that a layout written with
+    # single quotes matched nothing while the generator still printed a success
+    # message. These specs drive `InstallGenerator#inject_layout_shell` itself.
+    # Thor registers every PUBLIC instance method of a generator as a command and
+    # runs it in declaration order. A helper left public therefore executes on
+    # its own, out of context — this has bitten three times in this branch: a
+    # message printed twice, a `--shadcn`-only notice firing on the default
+    # path, and a helper taking a required argument being invoked with none.
+    # Pin the command list so the next one is caught here rather than in an app.
+    describe "Thor command surface" do
+      it "registers only the install steps, never the private helpers" do
+        expect(Ruact::Generators::InstallGenerator.commands.keys).to contain_exactly(
+          "create_initializer",
+          "inject_controller_concern",
+          "inject_layout_shell",
+          "create_shadcn_prerequisites",
+          "create_components_directory",
+          "create_server_functions_directory",
+          "append_gitignore_entries",
+          "prime_server_functions_codegen",
+          "create_vite_config",
+          "create_package_json",
+          "create_launch_files",
+          "advise_plumbing_migration",
+          "create_agents_md",
+          "install_javascript_dependencies",
+          "show_post_install_message"
+        )
+      end
+      it "has no command requiring arguments (Thor invokes them with none)" do
+        requiring_args = Ruact::Generators::InstallGenerator.commands.keys.reject do |name|
+          Ruact::Generators::InstallGenerator.instance_method(name).arity.zero?
+        end
+        expect(requiring_args).to be_empty
+      end
+    end
+    # Migrating an existing app is the path that matters most here, and Thor's
+    # `template` handles it badly: it raises an overwrite CONFLICT, offering a
+    # choice between losing every setting the app already had and ending up
+    # half-migrated (layout edited, `config.layout` still off) in silence.
+    describe "create_initializer on an app that already has one", :aggregate_failures do
+      def write_initializer(body)
+        path = File.join(app_root, "config/initializers/ruact.rb")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, body)
+        path
+      end
+      it "adds config.layout without touching the app's existing settings" do
+        path = write_initializer(<<~RUBY)
+          Ruact.configure do |config|
+            config.strict_serialization = true
+            config.max_upload_bytes = 25 * 1024 * 1024
+          end
+        RUBY
+        silently { build_generator(app_root).create_initializer }
+        result = File.read(path)
+        expect(result).to include("config.layout = true")
+        expect(result).to include("config.strict_serialization = true")
+        expect(result).to include("config.max_upload_bytes = 25 * 1024 * 1024")
+      end
+      # `config.layout = false` is a deliberate choice (keep the built-in
+      # shell). Re-running install must not quietly reverse it.
+      it "leaves an explicit opt-out alone" do
+        path = write_initializer("Ruact.configure do |config|\n  config.layout = false\nend\n")
+        silently { build_generator(app_root).create_initializer }
+        expect(File.read(path)).to include("config.layout = false")
+        expect(File.read(path)).not_to include("config.layout = true")
+      end
+      it "is idempotent" do
+        path = write_initializer("Ruact.configure do |config|\nend\n")
+        silently { build_generator(app_root).create_initializer }
+        silently { build_generator(app_root).create_initializer }
+        expect(File.read(path).scan("config.layout").size).to eq(1)
+      end
+      # Never guess at an initializer we do not recognise — say what to add,
+      # because the silent outcome is an app whose CSS never reaches the page.
+      it "tells the user what to add when it cannot find the configure block" do
+        write_initializer("# hand-rolled\nRuact.config\n")
+        output = capture_generator_output { build_generator(app_root).create_initializer }
+        expect(output).to include("could not find the Ruact.configure block")
+        expect(output).to include("config.layout = true")
+      end
+      def capture_generator_output
+        original = $stdout
+        $stdout = StringIO.new
+        yield
+        $stdout.string
+      ensure
+        $stdout = original
+      end
+    end
+    describe "inject_layout_shell — the REAL generator", :aggregate_failures do
+      def write_layout(body)
+        path = File.join(app_root, "app/views/layouts/application.html.erb")
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, body)
+        path
+      end
+      def layout_after_run(body)
+        path = write_layout(body)
+        silently { build_generator(app_root).inject_layout_shell }
+        File.read(path)
+      end
+      # The fresh-install path. Previously covered only by a REPRODUCTION of the
+      # generator's logic, which twice drifted from the generator itself and hid
+      # real defects; the reproduction is gone and these drive the real thing.
+      it "adds both the root div and the asset call to a layout that has neither" do
+        path = write_layout(<<~HTML)
+          <html>
+            <body>
+              <%= yield %>
+            </body>
+          </html>
+        HTML
+        silently { build_generator(app_root).inject_layout_shell }
+        result = File.read(path)
+        expect(result).to include(%(<div id="root"></div>))
+        expect(result).to include("<%= ruact_js_assets %>")
+        expect(result).to include("ruact: root")
+      end
+      it "places them inside the body, before the closing tag" do
+        path = write_layout("<html>\n  <body>\n    <%= yield %>\n  </body>\n</html>\n")
+        silently { build_generator(app_root).inject_layout_shell }
+        result = File.read(path)
+        expect(result.index(%(<div id="root">))).to be < result.index("</body>")
+        expect(result.index(%(<div id="root">))).to be < result.index("ruact_js_assets")
+      end
+      it "is a no-op on a layout that is already migrated" do
+        path = write_layout(<<~HTML)
+          <html>
+            <body>
+              <%# ruact: root %>
+              <div id="root"></div>
+              <%= ruact_js_assets %>
+            </body>
+          </html>
+        HTML
+        before = File.read(path)
+        silently { build_generator(app_root).inject_layout_shell }
+        expect(File.read(path)).to eq(before)
+      end
+      it "migrates a layout whose root div uses single quotes" do
+        result = layout_after_run(<<~HTML)
+          <html>
+            <body>
+              <%# ruact: root %>
+              <div id='root'></div>
+            </body>
+          </html>
+        HTML
+        expect(result).to include("<%= ruact_js_assets %>")
+      end
+      it "migrates a layout whose root div carries extra attributes" do
+        result = layout_after_run(<<~HTML)
+          <html>
+            <body>
+              <%# ruact: root %>
+              <div class="app" id="root" data-turbo="false"></div>
+            </body>
+          </html>
+        HTML
+        expect(result).to include("<%= ruact_js_assets %>")
+      end
+      it "migrates a layout with the marker and the div on one line" do
+        result = layout_after_run(
+          %(<html><body><%# ruact: root %><div id="root"></div></body></html>\n)
+        )
+        expect(result).to include("<%= ruact_js_assets %>")
+      end
+      it "is idempotent — a second run adds nothing" do
+        path = write_layout(<<~HTML)
+          <html>
+            <body>
+              <%# ruact: root %>
+              <div id="root"></div>
+            </body>
+          </html>
+        HTML
+        silently { build_generator(app_root).inject_layout_shell }
+        silently { build_generator(app_root).inject_layout_shell }
+        expect(File.read(path).scan("ruact_js_assets").size).to eq(1)
+      end
+      # Round-2 finding: the anchor matched any attribute ENDING in `id`, so a
+      # layout with `data-id="root"` and no real mount point got the helper
+      # injected and a success message. It now reads as "no root present" and
+      # the generator writes a proper root + helper instead of warning — the
+      # look-alike div is left alone, being none of its business.
+      it "does not mistake a look-alike attribute for the React root" do
+        path = write_layout(<<~HTML)
+          <html>
+            <body>
+              <%# ruact: root %>
+              <div data-id="root"></div>
+            </body>
+          </html>
+        HTML
+        silently { build_generator(app_root).inject_layout_shell }
+        result = File.read(path)
+        expect(result).to match(%r{<div id="root"></div>})
+        expect(result).to include("<%= ruact_js_assets %>")
+      end
+      # The mirror of the legacy migration: the call is there, the mount target
+      # is not. Injecting the whole block would duplicate the helper.
+      it "adds only the missing root when the layout already calls the helper" do
+        path = write_layout(<<~HTML)
+          <html>
+            <body>
+              <%= yield %>
+              <%= ruact_js_assets %>
+            </body>
+          </html>
+        HTML
+        silently { build_generator(app_root).inject_layout_shell }
+        result = File.read(path)
+        expect(result).to match(%r{<div id="root"></div>})
+        expect(result.scan("ruact_js_assets").size).to eq(1)
+        expect(result.index(%(<div id="root">))).to be < result.index("ruact_js_assets")
+      end
+      # A root that is NOT an empty paired div (a spinner placeholder, say) has
+      # nothing safe to inject after, so the generator says so instead of
+      # guessing where the call belongs.
+      it "warns when the root div is not the empty form it knows how to anchor on" do
+        write_layout(<<~HTML)
+          <html>
+            <body>
+              <%# ruact: root %>
+              <div id="root">loading…</div>
+            </body>
+          </html>
+        HTML
+        output = capture_generator_output { build_generator(app_root).inject_layout_shell }
+        expect(output).to include("could not locate the React root div")
+      end
+      # Round-2 finding: the "already migrated, skip" guard was a substring
+      # match, so a TODO note about the helper made the generator skip an app
+      # that was never migrated.
+      it "does not treat a TODO comment naming the helper as already migrated" do
+        path = write_layout(<<~HTML)
+          <html>
+            <body>
+              <%# TODO: add ruact_js_assets %>
+              <%# ruact: root %>
+              <div id="root"></div>
+            </body>
+          </html>
+        HTML
+        silently { build_generator(app_root).inject_layout_shell }
+        expect(File.read(path)).to include("<%= ruact_js_assets %>")
+      end
+      # Silence here is the dangerous outcome: the app keeps rendering through
+      # ruact's CSS-less shell and nothing ever says why.
+      it "says so LOUDLY when it cannot find the root div, instead of claiming success" do
+        write_layout(<<~HTML)
+          <html>
+            <body>
+              <%# ruact: root %>
+              <span id="root"></span>
+            </body>
+          </html>
+        HTML
+        output = capture_generator_output { build_generator(app_root).inject_layout_shell }
+        expect(output).to include("could not locate the React root div")
+        expect(output).not_to include("added ruact_js_assets")
+      end
+      def capture_generator_output
+        original = $stdout
+        $stdout = StringIO.new
+        yield
+        $stdout.string
+      ensure
+        $stdout = original
+      end
+    end
+    describe "without --shadcn (the default path is untouched)", :aggregate_failures do
+      let(:generator) { build_generator(app_root) }
+      it "writes no Tailwind entry and no tsconfig" do
+        silently { generator.create_shadcn_prerequisites }
+        expect(File).not_to exist(File.join(app_root, "app/javascript/styles/globals.css"))
+        expect(File).not_to exist(File.join(app_root, "tsconfig.json"))
+      end
+      it "leaves package.json free of Tailwind" do
+        silently { generator.create_package_json }
+        pkg = JSON.parse(read("package.json"))
+        expect(pkg["devDependencies"].keys).not_to include("tailwindcss", "@tailwindcss/cli")
+        expect(pkg["scripts"]).not_to have_key("build:css")
+      end
+      it "leaves Procfile.dev at the two processes it always had" do
+        silently { generator.create_launch_files }
+        expect(read("Procfile.dev")).not_to include("css:")
+      end
+    end
+  end
 end