ruby_cms 0.2.0.3 → 0.2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6812068b183da96c729d26ae664a39d599aea509a17a11ac0851b715c652cdcf
-  data.tar.gz: b087d0fe4f6bb7af6db0aef47e195e7f4f179ab65476a2b6f1048bef514444ab
+  metadata.gz: 5cadc0fbcba9f0f9d51aba4ea436755d87c9a7a8dbc3652b35d97c0f4abc99ff
+  data.tar.gz: df887a8c0f1cb7dffe4ca59d6792502e87d2934c0f989e81db9c2ef222296add
 SHA512:
-  metadata.gz: e0f9ca986cdc2d3c5caa5681261e49d015940c9e19be90406e341fffa215c5d1092ae9f47a30d64a39db9a221d2add4e6caac4eccaa3b79f9a8d3afd8e79343f
-  data.tar.gz: 5043cc31c3d8adcd61480d3fafc64b851d468d57ee7daf6e251793150c663c4d6cae9c94e43a880bfbd940d414b38408a7d32148bcd63db18404cf8e8b579c07
+  metadata.gz: 448db9b93fb067ff98c219a893cbf5434fba9d443b666c0eb83b4d5662c57081895b74e762e03a6314c43fe966f59df33b0353690048600f1dcfc81cb679d67e
+  data.tar.gz: ee7378839a0e3a625ffb0b761a987f72b97d325ae6e724b7b7f48251f75b947468c6db783d7947c35f762f4a5f224788291a372e943591a19b03a6934f7546db

data/README.md

@@ -493,27 +493,9 @@ 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 skips non-asset runtime initializers during this phase (navigation registration,
+RubyCMS now skips non-asset runtime initializers during this phase (navigation registration,
 dashboard registration, versioning hook, settings import, and permission seeding), which reduces
-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.
+precompile overhead.
 
 Recommended Docker layer order:
 

data/lib/generators/ruby_cms/install_generator.rb

@@ -855,45 +855,18 @@ module RubyCms
           end.join("\n")
         end
 
-        # 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.
+        # Helper: add @source for RubyCMS views/components so Tailwind finds utility classes.
+        # Not a generator task.
         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)
-          return if content.match?(%r{builds/tailwind/ruby_cms_engine})
+          gem_source_lines = build_gem_source_lines(tailwind_css_path)
+          return if gem_source_lines.all? {|line| content.include?(line) }
 
-          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
+          inject_tailwind_source(tailwind_css_path, content, gem_source_lines)
         rescue StandardError => e
-          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
+          say "⚠ Task tailwind/source: Could not add @source: #{e.message}. Add manually.", :yellow
         end
 
         # Tailwind v3 support (tailwind.config.js content array)
@@ -932,6 +905,65 @@ module RubyCms
           ]
         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

data/lib/ruby_cms/engine.rb

@@ -100,8 +100,7 @@ module RubyCms
       # For importmap: ensure engine's importmap is loaded
       if app.config.respond_to?(:importmap)
         app.config.importmap.paths << config.root.join("config/importmap.rb")
-        # 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")
+        app.config.importmap.cache_sweepers << config.root.join("app/javascript")
       end
     end
 
@@ -263,18 +262,12 @@ module RubyCms
       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?
-      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")
-
       command = File.basename($PROGRAM_NAME.to_s)
-      (command == "rake" || command == "rails") && argv.include?("assets:precompile")
+      rake_assets_precompile = command == "rake" && ARGV.include?("assets:precompile")
+      rails_assets_precompile = command == "rails" && ARGV.include?("assets:precompile")
+
+      rake_assets_precompile || rails_assets_precompile
     end
   end
 end

data/lib/ruby_cms/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_cms
 version: !ruby/object:Gem::Version
-  version: 0.2.0.3
+  version: 0.2.0.4
 platform: ruby
 authors:
 - Codebyjob