Implement Engines support

README.md

@@ -400,6 +400,12 @@ Then you can use yarn or npm to install the dependencies.
 
 If you need to use a custom input or output file, you can run `bundle exec tailwindcss` to access the platform-specific executable, and give it your own build options.
 
+## Rails Engines support
+
+If you have Rails Engines in your application that use Tailwind CSS, they will be automatically included in the Tailwind build as long as they conform to next conventions:
+
+- The engine must have `tailwindcss-rails` as gem dependency.
+- The engine must have a `app/assets/tailwind/<engine_name>/application.css` file or your application must have overridden file in the same location of your application root.
 
 ## Troubleshooting
 

lib/tailwindcss/commands.rb

@@ -32,6 +32,40 @@ def watch_command(always: false, poll: false, **kwargs)
       def rails_css_compressor?
         defined?(Rails) && Rails&.application&.config&.assets&.css_compressor.present?
       end
+
+      def engines_tailwindcss_roots
+        return [] unless defined?(Rails)
+
+        Rails::Engine.subclasses.select do |engine|
+          begin
+            spec = Gem::Specification.find_by_name(engine.engine_name)
+            spec.dependencies.any? { |d| d.name == 'tailwindcss-rails' }
+          rescue Gem::MissingSpecError
+            false
+          end
+        end.map do |engine|
+          [
+            Rails.root.join("app/assets/tailwind/#{engine.engine_name}/application.css"),
+            engine.root.join("app/assets/tailwind/#{engine.engine_name}/application.css")
+          ].select(&:exist?).compact.first.to_s
+        end.compact
+      end
+
+      def enhance_command(command)
+        engine_roots = Tailwindcss::Commands.engines_tailwindcss_roots
+        if engine_roots.any?
+          Tempfile.create('tailwind.css') do |file|
+            file.write(engine_roots.map { |root| "@import \"#{root}\";" }.join("\n"))
+            file.write("\n@import \"#{Rails.root.join('app/assets/tailwind/application.css')}\";\n")
+            file.rewind
+            transformed_command = command.dup
+            transformed_command[2] = file.path
+            yield transformed_command if block_given?
+          end
+        else
+          yield command if block_given?
+        end
+      end
     end
   end
 end

lib/tasks/build.rake

@@ -3,8 +3,10 @@ namespace :tailwindcss do
   task build: :environment do |_, args|
     debug = args.extras.include?("debug")
     command = Tailwindcss::Commands.compile_command(debug: debug)
-    puts command.inspect if args.extras.include?("verbose")
-    system(*command, exception: true)
+    Tailwindcss::Commands.enhance_command(command) do |transformed_command|
+      puts transformed_command.inspect if args.extras.include?("verbose")
+      system(*transformed_command, exception: true)
+    end
   end
 
   desc "Watch and build your Tailwind CSS on file changes"
@@ -13,8 +15,10 @@ namespace :tailwindcss do
     poll = args.extras.include?("poll")
     always = args.extras.include?("always")
     command = Tailwindcss::Commands.watch_command(always: always, debug: debug, poll: poll)
-    puts command.inspect if args.extras.include?("verbose")
-    system(*command)
+    Tailwindcss::Commands.enhance_command(command) do |transformed_command|
+      puts transformed_command.inspect if args.extras.include?("verbose")
+      system(*transformed_command)
+    end
   rescue Interrupt
     puts "Received interrupt, exiting tailwindcss:watch" if args.extras.include?("verbose")
   end

test/lib/tailwindcss/commands_test.rb

@@ -126,4 +126,151 @@ def setup
       assert_includes(actual, "always")
     end
   end
+
+  test ".engines_tailwindcss_roots when there are no engines" do
+    Rails.stub(:root, Pathname.new("/dummy")) do
+      Rails::Engine.stub(:subclasses, []) do
+        assert_empty Tailwindcss::Commands.engines_tailwindcss_roots
+      end
+    end
+  end
+
+  test ".engines_tailwindcss_roots when there are engines" do
+    Dir.mktmpdir do |tmpdir|
+      root = Pathname.new(tmpdir)
+
+      # Create multiple engines
+      engine_root1 = root.join('engine1')
+      engine_root2 = root.join('engine2')
+      engine_root3 = root.join('engine3')
+      FileUtils.mkdir_p(engine_root1)
+      FileUtils.mkdir_p(engine_root2)
+      FileUtils.mkdir_p(engine_root3)
+
+      engine1 = Class.new(Rails::Engine) do
+        define_singleton_method(:engine_name) { "test_engine1" }
+        define_singleton_method(:root) { engine_root1 }
+      end
+
+      engine2 = Class.new(Rails::Engine) do
+        define_singleton_method(:engine_name) { "test_engine2" }
+        define_singleton_method(:root) { engine_root2 }
+      end
+
+      engine3 = Class.new(Rails::Engine) do
+        define_singleton_method(:engine_name) { "test_engine3" }
+        define_singleton_method(:root) { engine_root3 }
+      end
+
+      # Create mock specs for engines
+      spec1 = Minitest::Mock.new
+      spec1.expect(:dependencies, [Gem::Dependency.new("tailwindcss-rails")])
+
+      spec2 = Minitest::Mock.new
+      spec2.expect(:dependencies, [Gem::Dependency.new("tailwindcss-rails")])
+
+      spec3 = Minitest::Mock.new
+      spec3.expect(:dependencies, [])
+
+      # Set up file structure
+      # Engine 1: CSS in engine root
+      engine1_css = engine_root1.join("app/assets/tailwind/test_engine1/application.css")
+      FileUtils.mkdir_p(File.dirname(engine1_css))
+      FileUtils.touch(engine1_css)
+
+      # Engine 2: CSS in Rails root
+      engine2_css = root.join("app/assets/tailwind/test_engine2/application.css")
+      FileUtils.mkdir_p(File.dirname(engine2_css))
+      FileUtils.touch(engine2_css)
+
+      # Engine 3: CsS in engine root, but no tailwindcss-rails dependency
+      engine3_css = engine_root2.join("app/assets/tailwind/test_engine3/application.css")
+      FileUtils.mkdir_p(File.dirname(engine3_css))
+      FileUtils.touch(engine3_css)
+
+      find_by_name_results = {
+        "test_engine1" => spec1,
+        "test_engine2" => spec2,
+        "test_engine3" => spec3,
+      }
+
+      Gem::Specification.stub(:find_by_name, ->(name) { find_by_name_results[name] }) do
+        Rails.stub(:root, root) do
+          Rails::Engine.stub(:subclasses, [engine1, engine2]) do
+            roots = Tailwindcss::Commands.engines_tailwindcss_roots
+
+            assert_equal 2, roots.size
+            assert_includes roots, engine1_css.to_s
+            assert_includes roots, engine2_css.to_s
+            assert_not_includes roots, engine3_css.to_s
+          end
+        end
+      end
+
+      spec1.verify
+      spec2.verify
+    end
+  end
+
+  test ".enhance_command when there are no engines" do
+    Dir.mktmpdir do |tmpdir|
+      root = Pathname.new(tmpdir)
+      input_path = root.join("app/assets/tailwind/application.css")
+      output_path = root.join("app/assets/builds/tailwind.css")
+
+      command = ["tailwindcss", "-i", input_path.to_s, "-o", output_path.to_s]
+
+      Rails.stub(:root, root) do
+        Tailwindcss::Commands.stub(:engines_tailwindcss_roots, []) do
+          Tailwindcss::Commands.enhance_command(command) do |actual|
+            assert_equal command, actual
+          end
+        end
+      end
+    end
+  end
+
+  test ".enhance_command when there are engines" do
+    Dir.mktmpdir do |tmpdir|
+      root = Pathname.new(tmpdir)
+      input_path = root.join("app/assets/tailwind/application.css")
+      output_path = root.join("app/assets/builds/tailwind.css")
+
+      # Create necessary files
+      FileUtils.mkdir_p(File.dirname(input_path))
+      FileUtils.touch(input_path)
+
+      # Create engine CSS file
+      engine_css_path = root.join("app/assets/tailwind/test_engine/application.css")
+      FileUtils.mkdir_p(File.dirname(engine_css_path))
+      FileUtils.touch(engine_css_path)
+
+      command = ["tailwindcss", "-i", input_path.to_s, "-o", output_path.to_s]
+
+      Rails.stub(:root, root) do
+        Tailwindcss::Commands.stub(:engines_tailwindcss_roots, [engine_css_path.to_s]) do
+          Tailwindcss::Commands.enhance_command(command) do |actual|
+            # Command should be modified to use a temporary file
+            assert_equal command[0], actual[0]  # executable
+            assert_equal command[1], actual[1]  # -i flag
+            assert_equal command[3], actual[3]  # -o flag
+            assert_equal command[4], actual[4]  # output path
+
+            temp_path = Pathname.new(actual[2])
+            refute_equal command[2], temp_path.to_s  # input path should be different
+            assert_match(/tailwind\.css/, temp_path.basename.to_s)  # should use temp file
+            assert_includes [Dir.tmpdir, '/tmp'], temp_path.dirname.to_s  # should be in temp directory
+
+            # Check temp file contents
+            temp_content = File.read(temp_path)
+            expected_content = <<~CSS
+            @import "#{engine_css_path}";
+            @import "#{input_path}";
+          CSS
+            assert_equal expected_content.strip, temp_content.strip
+          end
+        end
+      end
+    end
+  end
 end