updates

Author: Job Hammer

CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.2.0.3] - 2026-04-02
+
+- Whole repo was scanned for comiling so it was slow.
+
 ## [0.2.0.2] - 2026-04-02
 
 - Add commands page

README.md

@@ -493,9 +493,27 @@ rails ruby_cms:css:compile_gem
 ### Faster Docker Builds (`assets:precompile`)
 
 `assets:precompile` loads the Rails app in production mode and can be slow in Docker/Fly builds.
-RubyCMS now skips non-asset runtime initializers during this phase (navigation registration,
+RubyCMS skips non-asset runtime initializers during this phase (navigation registration,
 dashboard registration, versioning hook, settings import, and permission seeding), which reduces
-precompile overhead.
+precompile overhead. Detection uses `ARGV` (not only `$PROGRAM_NAME`) so it still applies when the
+Ruby program name is `ruby` instead of `rails`.
+
+**Tailwind CSS:** Do not add multiple `@source` globs that point at the same RubyCMS gem (e.g. both
+`../../../../gems/ruby_cms/...` and `/usr/local/bundle/.../ruby_cms-*`). That scans the engine twice
+and slows `tailwindcss:build` a lot. Instead, rely on [tailwindcss-rails engine support](https://github.com/rails/tailwindcss-rails#rails-engines-support-experimental):
+
+1. RubyCMS ships `app/assets/tailwind/ruby_cms_engine/engine.css` with `@source` paths relative to the gem
+   (the directory matches Rails’ `engine_name` for `RubyCms::Engine`, which is `ruby_cms_engine`).
+2. `rails tailwindcss:engines` (run automatically before `tailwindcss:build`) generates
+   `app/assets/builds/tailwind/ruby_cms_engine.css` in the host app.
+3. In the host’s `app/assets/tailwind/application.css`, add **once**:
+
+   ```css
+   @import "../builds/tailwind/ruby_cms_engine";
+   ```
+
+   Place it next to your other `@import` lines (e.g. after `@import "tailwindcss";`). Remove any
+   hand-written `@source` lines aimed at the RubyCMS gem.
 
 Recommended Docker layer order:
 

app/assets/tailwind/ruby_cms_engine/engine.css

@@ -0,0 +1,12 @@
+/*
+ * RubyCMS Tailwind content sources (paths relative to this file).
+ * Host apps should import the generated shim — see tailwindcss-rails "Rails Engines support":
+ *   @import "../builds/tailwind/ruby_cms_engine";
+ * in app/assets/tailwind/application.css (do not duplicate @source to the gem in the host).
+ *
+ * Folder name matches Rails' engine_name for RubyCms::Engine ("ruby_cms_engine").
+ */
+@source "../../../views/**/*.erb";
+@source "../../../components/**/*.rb";
+@source "../../../helpers/**/*.rb";
+@source "../../../javascript/**/*.js";

lib/generators/ruby_cms/install_generator.rb

@@ -855,18 +855,45 @@ def remove_registration_lines(content)
           end.join("\n")
         end
 
-        # Helper: add @source for RubyCMS views/components so Tailwind finds utility classes.
-        # Not a generator task.
+        # Adds a single @import for tailwindcss-rails' engine shim (see gem app/assets/tailwind/ruby_cms_engine/engine.css).
+        # Avoids duplicate @source globs to the gem, which makes tailwindcss:build much slower.
         def add_ruby_cms_tailwind_source(tailwind_css_path)
           return unless tailwind_css_path.to_s.present? && File.exist?(tailwind_css_path)
 
           content = File.read(tailwind_css_path)
-          gem_source_lines = build_gem_source_lines(tailwind_css_path)
-          return if gem_source_lines.all? {|line| content.include?(line) }
+          return if content.match?(%r{builds/tailwind/ruby_cms_engine})
 
-          inject_tailwind_source(tailwind_css_path, content, gem_source_lines)
+          injection = +"\n/* RubyCMS: Tailwind content via tailwindcss-rails engine (see ruby_cms README). */\n"
+          injection << "@import \"../builds/tailwind/ruby_cms_engine\";\n"
+
+          inserted = inject_ruby_cms_engine_import_after_tailwind!(tailwind_css_path, content, injection)
+          unless inserted
+            inject_into_file tailwind_css_path.to_s, after: /\A/ do
+              injection
+            end
+          end
+
+          say "✓ Task tailwind/source: Added RubyCMS engine import to #{tailwind_css_path}.", :green
         rescue StandardError => e
-          say "⚠ Task tailwind/source: Could not add @source: #{e.message}. Add manually.", :yellow
+          say "⚠ Task tailwind/source: Could not add engine import: #{e.message}. Add manually.", :yellow
+        end
+
+        def inject_ruby_cms_engine_import_after_tailwind!(tailwind_css_path, content, injection)
+          patterns = [
+            %(@import "tailwindcss";\n),
+            %(@import "tailwindcss";),
+            %(@import "tailwindcss"\n),
+            %(@import "tailwindcss")
+          ]
+          patterns.each do |after_pattern|
+            next unless content.include?(after_pattern)
+
+            inject_into_file tailwind_css_path.to_s, after: after_pattern do
+              injection
+            end
+            return true
+          end
+          false
         end
 
         # Tailwind v3 support (tailwind.config.js content array)
@@ -905,65 +932,6 @@ def ruby_cms_tailwind_content_patterns
           ]
         end
 
-        def build_gem_source_lines(tailwind_css_path)
-          css_dir = Pathname.new(tailwind_css_path).dirname
-          gem_views = path_relative_to_css_or_absolute(RubyCms::Engine.root.join("app/views"),
-                                                       css_dir)
-          gem_components = path_relative_to_css_or_absolute(
-            RubyCms::Engine.root.join("app/components"), css_dir
-          )
-          [
-            %(@source "#{gem_views}/**/*.erb";),
-            %(@source "#{gem_components}/**/*.rb";)
-          ]
-        end
-
-        def path_relative_to_css_or_absolute(target_path, css_dir)
-          Pathname.new(target_path).relative_path_from(css_dir).to_s
-        rescue ArgumentError
-          # Different mount/volume: fall back to absolute path.
-          Pathname.new(target_path).to_s
-        end
-
-        def inject_tailwind_source(tailwind_css_path, content, gem_source_lines)
-          to_inject = build_tailwind_source_injection(gem_source_lines)
-          inserted = try_insert_after_patterns?(tailwind_css_path, content, to_inject)
-          inject_at_start(tailwind_css_path, to_inject) unless inserted
-          say "✓ Task tailwind/source: Added @source for RubyCMS views/components to " \
-              "tailwind/application.css.",
-              :green
-        end
-
-        def build_tailwind_source_injection(gem_source_lines)
-          to_inject = +"\n/* Include RubyCMS views/components so Tailwind finds utility classes. */\n"
-          Array(gem_source_lines).each {|line| to_inject << line << "\n" }
-          to_inject << "\n"
-          to_inject
-        end
-
-        def try_insert_after_patterns?(tailwind_css_path, content, to_inject)
-          patterns = [
-            %(@import "tailwindcss";\n),
-            %(@import "tailwindcss";),
-            %(@import "tailwindcss"\n),
-            %(@import "tailwindcss")
-          ]
-          patterns.each do |after_pattern|
-            next unless content.include?(after_pattern)
-
-            inject_into_file tailwind_css_path.to_s, after: after_pattern do
-              to_inject
-            end
-            return true
-          end
-          false
-        end
-
-        def inject_at_start(tailwind_css_path, to_inject)
-          inject_into_file tailwind_css_path.to_s, after: /\A/ do
-            to_inject
-          end
-        end
       end
 
       def run_migrate

lib/ruby_cms/engine.rb

@@ -100,7 +100,8 @@ class Engine < ::Rails::Engine
       # For importmap: ensure engine's importmap is loaded
       if app.config.respond_to?(:importmap)
         app.config.importmap.paths << config.root.join("config/importmap.rb")
-        app.config.importmap.cache_sweepers << config.root.join("app/javascript")
+        # Only sweep the engine's Stimulus tree (not the whole app/javascript tree)
+        app.config.importmap.cache_sweepers << config.root.join("app/javascript/controllers/ruby_cms")
       end
     end
 
@@ -262,12 +263,18 @@ class Engine < ::Rails::Engine
       end
     end
 
+    # True during asset pipeline tasks so we skip DB-heavy initializers (permissions, settings import).
+    # Detect by ARGV first: $PROGRAM_NAME is often "ruby" when using `ruby bin/rails`, which would
+    # miss the old rake/rails basename check; tailwindcss:build runs as a prerequisite of
+    # assets:precompile and keeps the same ARGV, but a standalone `rails tailwindcss:build` must match too.
     def self.assets_precompile_phase?
-      command = File.basename($PROGRAM_NAME.to_s)
-      rake_assets_precompile = command == "rake" && ARGV.include?("assets:precompile")
-      rails_assets_precompile = command == "rails" && ARGV.include?("assets:precompile")
+      argv = Array(ARGV).map(&:to_s)
+      return true if argv.include?("assets:precompile")
+      return true if argv.any? {|a| a.start_with?("tailwindcss:") }
+      return true if argv.include?("propshaft:compile")
 
-      rake_assets_precompile || rails_assets_precompile
+      command = File.basename($PROGRAM_NAME.to_s)
+      (command == "rake" || command == "rails") && argv.include?("assets:precompile")
     end
   end
 end

lib/ruby_cms/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyCms
-  VERSION = "0.2.0.2"
+  VERSION = "0.2.0.3"
 end