multitenancy-rails 0.0.2

data/lib/generators/multitenancy/multitenancy_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/base"
+
+module Multitenancy
+  class MultitenancyGenerator < Rails::Generators::Base
+    source_root File.expand_path("templates", __dir__)
+
+    argument :theme_name, type: :string, desc: "Name of the theme to generate"
+    class_option :importmap, type: :boolean, default: true, desc: "Generate importmap configuration"
+    class_option :tailwindcss, type: :boolean, default: false, desc: "Generate Tailwind CSS configuration"
+
+    def create_theme_structure
+      @theme_name = theme_name.parameterize
+      @theme_class_name = theme_name.camelize
+      @theme_namespace = "Themes::#{@theme_class_name}"
+
+      create_directories
+      create_controllers
+      create_views
+      create_assets
+      create_config_files
+    end
+
+    private
+
+    def create_directories
+      dirs = %w[
+        app/controllers
+        app/views/home
+        app/views/layouts
+        config/locales
+      ]
+
+      if options[:tailwindcss]
+        dirs << "app/assets/tailwind/#{@theme_name}"
+        dirs << "app/assets/builds/#{@theme_name}"
+      else
+        dirs << "app/assets/stylesheets/#{@theme_name}"
+      end
+
+      dirs.each do |dir|
+        empty_directory File.join("themes", @theme_name, dir)
+      end
+
+      if options[:importmap]
+        empty_directory File.join("themes", @theme_name, "app/javascript/#{@theme_name}")
+        empty_directory File.join("themes", @theme_name, "app/javascript/#{@theme_name}/controllers")
+      end
+    end
+
+    def create_controllers
+      template "application_controller.rb", File.join("themes", @theme_name, "app/controllers/application_controller.rb")
+      template "home_controller.rb", File.join("themes", @theme_name, "app/controllers/home_controller.rb")
+    end
+
+    def create_views
+      template "layouts/application.html.erb", File.join("themes", @theme_name, "app/views/layouts/application.html.erb")
+      template "home/index.html.erb", File.join("themes", @theme_name, "app/views/home/index.html.erb")
+    end
+
+    def create_assets
+      if options[:tailwindcss]
+        template "tailwind/application.css", File.join("themes", @theme_name, "app/assets/tailwind/#{@theme_name}/application.css")
+        create_file File.join("themes", @theme_name, "app/assets/builds/#{@theme_name}/.keep")
+      else
+        template "stylesheets/application.css", File.join("themes", @theme_name, "app/assets/stylesheets/#{@theme_name}/application.css")
+      end
+
+      if options[:importmap]
+        template "javascript/application.js", File.join("themes", @theme_name, "app/javascript/#{@theme_name}/application.js")
+        template "javascript/controllers/hello_controller.js",
+          File.join("themes", @theme_name, "app/javascript/#{@theme_name}/controllers/hello_controller.js")
+      end
+    end
+
+    def create_config_files
+      template "routes.rb", File.join("themes", @theme_name, "config/routes.rb")
+      template "locales/en.yml", File.join("themes", @theme_name, "config/locales/en.yml")
+
+      if options[:importmap]
+        template "importmap.rb", File.join("themes", @theme_name, "config/importmap.rb")
+      end
+    end
+  end
+end
+

data/lib/generators/multitenancy/templates/application_controller.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module <%= @theme_namespace %>
+  class ApplicationController < ActionController::Base
+    include Multitenancy::Controller
+  end
+end

data/lib/generators/multitenancy/templates/home/index.html.erb

@@ -0,0 +1,2 @@
+<h1>Home#index</h1>
+<p>Find me in themes/<%= @theme_name %>/views/home/index.html.erb</p>

data/lib/generators/multitenancy/templates/home_controller.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module <%= @theme_namespace %>
+  class HomeController < ApplicationController
+    def index
+    end
+  end
+end
+

data/lib/generators/multitenancy/templates/importmap.rb

@@ -0,0 +1,4 @@
+pin "<%= @theme_name %>/application", to: "<%= @theme_name %>/application.js"
+
+pin_all_from "themes/<%= @theme_name %>/app/javascript/<%= @theme_name %>/controllers",
+  under: "<%= @theme_name %>/controllers", to: "<%= @theme_name %>/controllers"

data/lib/generators/multitenancy/templates/javascript/application.js

@@ -0,0 +1,12 @@
+import { Application } from "@hotwired/stimulus"
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
+
+const application = Application.start()
+application.debug = false
+window.Stimulus = application
+
+// Shared controllers from the main app (data-controller="hello")
+eagerLoadControllersFrom("controllers", application)
+
+// Theme-specific controllers (overrides shared if same name)
+eagerLoadControllersFrom("<%= @theme_name %>/controllers", application)

data/lib/generators/multitenancy/templates/javascript/controllers/hello_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  connect() {
+    this.element.textContent = "Hello from <%= @theme_class_name %> Theme!"
+  }
+}

data/lib/generators/multitenancy/templates/layouts/application.html.erb

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title><%%= content_for(:title) %></title>
+    <meta name="viewport" content="width=device-width,initial-scale=1">
+    <meta name="apple-mobile-web-app-capable" content="yes">
+    <meta name="mobile-web-app-capable" content="yes">
+    <%%= csrf_meta_tags %>
+    <%%= csp_meta_tag %>
+
+    <%%= yield :head %>
+
+    <%%# Enable PWA manifest for installable apps (make sure to enable in config/routes.rb too!) %>
+    <%%#= tag.link rel: "manifest", href: pwa_manifest_path(format: :json) %>
+
+    <link rel="icon" href="/icon.png" type="image/png">
+    <link rel="icon" href="/icon.svg" type="image/svg+xml">
+    <link rel="apple-touch-icon" href="/icon.png">
+
+    <%# Includes all stylesheet files in app/assets/stylesheets %>
+    <%%= stylesheet_link_tag "<%= @theme_name %>/application", "data-turbo-track": "reload" %>
+    <% if options[:importmap] %>
+    <%%= javascript_importmap_tags "<%= @theme_name %>/application", importmap: <%= @theme_namespace %>::Engine.importmap %>
+    <% end %>
+  </head>
+
+  <body>
+    <h1><%= @theme_class_name %> Layout</h1>
+    <%%= yield %>
+  </body>
+</html>
+

data/lib/generators/multitenancy/templates/locales/en.yml

@@ -0,0 +1,4 @@
+en:
+  themes:
+    <%= @theme_name %>:
+      hello: "Hello world from the <%= @theme_name %> theme"

data/lib/generators/multitenancy/templates/routes.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<%= @theme_namespace %>::Engine.routes.draw do
+  root "home#index"
+end
+

data/lib/generators/multitenancy/templates/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into <%= @theme_name %>/application.css.
+ *
+ * Any CSS file within this directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/lib/generators/multitenancy/templates/tailwind/application.css

@@ -0,0 +1,4 @@
+@import "tailwindcss";
+@source "../../../views/**/*.html.erb";
+@source "../../../controllers/**/*.rb";
+@source "../../../javascript/<%= @theme_name %>/**/*.js";

data/lib/multitenancy/controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Multitenancy
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      engine = module_parent::Engine
+      prepend_view_path engine.root.join("app/views")
+      layout "application"
+      before_action { engine.importmap_reloader&.execute_if_updated }
+    end
+
+    private
+
+    def _prefixes
+      namespace_prefix = "#{self.class.module_parent.name.underscore}/"
+      super.map do |prefix|
+        prefix.sub(/^#{Regexp.escape(namespace_prefix)}/, "")
+      end.reject(&:empty?)
+    end
+  end
+end

data/lib/multitenancy/integrations/factory_bot.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Multitenancy
+  module Integrations
+    class FactoryBot
+      def self.call(app)
+        return unless app.config.respond_to?(:factory_bot)
+
+        Multitenancy.themes.each do |theme|
+          app.config.factory_bot.definition_file_paths << theme.relative_path.join("spec/factories").to_s
+        end
+      end
+    end
+  end
+end

data/lib/multitenancy/integrations/importmap.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext/module/delegation"
+
+module Multitenancy
+  module Integrations
+
+    class Importmap
+      class Reloader < Struct.new(:app, :engine)
+        delegate :execute_if_updated, :execute, :updated?, to: :updater
+
+        def reload!
+          engine.importmap = ::Importmap::Map.new
+          app_importmap_paths.each { |path| engine.importmap.draw(path) }
+          engine.importmap_paths.each { |path| engine.importmap.draw(path) }
+        end
+
+        private
+
+        def updater
+          @updater ||= app.config.file_watcher.new(engine.importmap_paths, cache_sweepers) { reload! }
+        end
+
+        def cache_sweepers
+          engine.importmap_cache_sweepers.each_with_object({}) do |path, hash|
+            hash[path] = ["js"]
+          end
+        end
+
+        def app_importmap_paths
+          app.config.importmap.paths
+        end
+      end
+
+      def self.call(app)
+        return unless app.config.respond_to?(:importmap)
+
+        Multitenancy.themes.each do |theme|
+          theme.engine.singleton_class.send(:attr_accessor, :importmap)
+          theme.engine.singleton_class.send(:attr_accessor, :importmap_paths)
+          theme.engine.singleton_class.send(:attr_accessor, :importmap_cache_sweepers)
+          theme.engine.singleton_class.send(:attr_accessor, :importmap_reloader)
+          theme.engine.importmap = ::Importmap::Map.new
+
+          # Store theme importmap paths separately — engine.config.importmap.paths
+          # is a shared object across all railties, so we can't use it per-theme.
+          importmap_file = theme.path.join("config/importmap.rb").to_s
+          theme.engine.importmap_paths = [importmap_file]
+
+          # Watch theme JavaScript directories for new/changed/deleted files
+          js_path = theme.path.join("app/javascript")
+          theme.engine.importmap_cache_sweepers = js_path.exist? ? [js_path.to_s] : []
+
+          # Draw the main app's importmap first (Turbo, Stimulus, shared libs)
+          app.config.importmap.paths.each { |path| theme.engine.importmap.draw(path) }
+
+          # Then draw the theme's own importmap (can override app pins)
+          theme.engine.importmap_paths.each { |path| theme.engine.importmap.draw(path) }
+
+          # Development reloader: re-draw theme importmap when pins or JS change
+          unless app.config.cache_classes
+            Multitenancy::Integrations::Importmap::Reloader.new(app, theme.engine).tap do |reloader|
+              theme.engine.importmap_reloader = reloader
+              app.reloaders << reloader
+              app.reloader.to_run { reloader.execute_if_updated }
+            end
+          end
+        end
+
+        # Remove theme importmap paths from the main app's shared config
+        # so the main app doesn't draw theme-specific pins into its own importmap.
+        app.config.importmap.paths.delete_if do |path|
+          path.to_s =~ %r{^#{Multitenancy.themes_root}/}
+        end
+      end
+    end
+  end
+end

data/lib/multitenancy/integrations/minitest.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Multitenancy
+  module Integrations
+    class Minitest
+      def self.call(app)
+        return unless defined?(::Minitest)
+        return unless defined?(::Rails::TestUnit::Runner)
+
+        integration = self
+
+        ::Rails::TestUnit::Runner.singleton_class.prepend(Module.new do
+          define_method(:load_tests) do |argv|
+            if argv.any?
+              # Explicit paths: expand theme directory paths to their test/ subdirs,
+              # including nested themes (e.g. themes/alpha also picks up themes/alpha-v2).
+              expanded = argv.flat_map do |path|
+                if (theme = Multitenancy.themes.find { |t| t.relative_path.to_s == path })
+                  [theme, *integration.nested_themes_for(theme)].filter_map do |t|
+                    test_path = t.relative_path.join("test")
+                    test_path.to_s if test_path.exist?
+                  end
+                else
+                  path
+                end
+              end
+              super(expanded)
+            else
+              # Default run (rails test with no args): load main app tests first,
+              # then load each theme's test/ directory separately.
+              theme_test_dirs = Multitenancy.themes.filter_map do |theme|
+                test_path = theme.relative_path.join("test")
+                test_path.to_s if test_path.exist?
+              end
+              super(argv)
+              super(theme_test_dirs) unless theme_test_dirs.empty?
+            end
+          end
+        end)
+      end
+
+      def self.nested_themes_for(parent_theme)
+        Multitenancy.themes.select do |theme|
+          theme.name != parent_theme.name && theme.name.include?(parent_theme.name)
+        end
+      end
+    end
+  end
+end

data/lib/multitenancy/integrations/rails.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/inflections"
+
+module Multitenancy
+  module Integrations
+    class Rails
+      def self.call(app)
+        Multitenancy.themes.each do |theme|
+          theme.bootstrap(app)
+        end
+      end
+    end
+  end
+end

data/lib/multitenancy/integrations/rspec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Multitenancy
+  module Integrations
+    class RSpec
+      def self.call(app)
+        return unless defined?(::RSpec)
+        return unless ::RSpec.respond_to?(:configuration)
+
+        # This is the list of directories RSpec was told to run.
+        to_run = ::RSpec.configuration.instance_variable_get(:@files_or_directories_to_run)
+        default_path = ::RSpec.configuration.default_path
+
+        if to_run == [default_path]
+          # This is the default case when you run `rspec`. We want to add all the theme's spec paths
+          # to the collection of directories to run.
+
+          theme_paths = Multitenancy.themes.map do |theme|
+            spec_path = theme.relative_path.join(default_path)
+            spec_path.to_s if spec_path.exist?
+          end
+
+          to_run.concat(theme_paths)
+        else
+          # This is when `rspec` is run with a list of directories or files. We scan this list to see
+          # if any of them matches a theme's directory. If it does, we concat the `default_path` to the
+          # end of it.
+          #
+          # themes/my_theme => themes/my_theme/spec
+          #
+          # If it doesn't match a theme path, we leave it alone.
+          to_run.map! do |path|
+            if (theme = Multitenancy.themes.find { |t| t.relative_path.to_s == path })
+              [
+                theme,
+                *nested_themes_for(theme)
+              ].map do |theme|
+                spec_path = theme.relative_path.join(default_path)
+                spec_path.to_s if spec_path.exist?
+              end
+            else
+              path
+            end
+          end
+        end
+
+        ::RSpec.configuration.files_or_directories_to_run = to_run.flatten.compact.uniq
+      end
+
+      def self.nested_themes_for(parent_theme)
+        Multitenancy.themes.select do |theme|
+          theme.name != parent_theme.name && theme.name.include?(parent_theme.name)
+        end
+      end
+
+    end
+  end
+end

data/lib/multitenancy/integrations/tailwind_css.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Multitenancy
+  module Integrations
+    class TailwindCss
+      def self.call(app)
+        return unless defined?(::Tailwindcss)
+
+        Multitenancy.themes.each do |theme|
+          tailwind_dir = theme.path.join("app/assets/tailwind")
+          next unless tailwind_dir.exist?
+
+          # Exclude raw Tailwind input files from Propshaft — they contain
+          # @import directives that can't be served directly.
+          app.config.assets.excluded_paths << tailwind_dir
+
+          # Ensure the builds output directory exists so the compiled CSS
+          # can be picked up by Propshaft.
+          builds_dir = theme.path.join("app/assets/builds/#{theme.name}")
+          FileUtils.mkdir_p(builds_dir)
+        end
+      end
+
+      def self.compilation_targets
+        return [] unless defined?(::Tailwindcss)
+
+        Multitenancy.themes.each_with_object([]) do |theme, targets|
+          input = theme.path.join("app/assets/tailwind/#{theme.name}/application.css")
+          next unless input.exist?
+
+          output = theme.path.join("app/assets/builds/#{theme.name}/application.css")
+          targets << { theme: theme, input: input, output: output }
+        end
+      end
+
+      def self.compile_command(target, debug: false)
+        args = [
+          Tailwindcss::Ruby.executable,
+          "--input", target[:input].to_s,
+          "--output", target[:output].to_s
+        ]
+        args << "--minify" unless debug
+        args
+      end
+
+      def self.watch_command(target, debug: false)
+        compile_command(target, debug: debug) + ["--watch"]
+      end
+    end
+  end
+end

data/lib/multitenancy/integrations.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+
+module Multitenancy
+  module Integrations
+    autoload :FactoryBot, "multitenancy/integrations/factory_bot"
+    autoload :Importmap, "multitenancy/integrations/importmap"
+    autoload :Rails, "multitenancy/integrations/rails"
+    autoload :TailwindCss, "multitenancy/integrations/tailwind_css"
+    autoload :Minitest, "multitenancy/integrations/minitest"
+    autoload :RSpec, "multitenancy/integrations/rspec"
+  end
+end

data/lib/multitenancy/rails.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "multitenancy"
+
+module Multitenancy
+  module Rails
+  end
+end

data/lib/multitenancy/railtie.rb

@@ -0,0 +1,32 @@
+require "rails/railtie"
+
+module Multitenancy
+  class Railtie < ::Rails::Railtie
+    config.before_configuration do |app|
+      Integrations::Rails.call(app)
+      Integrations::FactoryBot.call(app)
+      Integrations::RSpec.call(app)
+      Integrations::Minitest.call(app)
+
+      # Must run before Propshaft's `propshaft.append_assets_path` initializer,
+      # which is where `config.assets.excluded_paths` is consumed
+      # (`paths.without(excluded_paths)`). Registering the exclusion any later —
+      # e.g. in `after_initialize` — leaves the raw Tailwind input directory on
+      # the asset load path, where it collides with the compiled `builds/`
+      # output and can be served as un-compiled `@import "tailwindcss"` source.
+      Integrations::TailwindCss.call(app)
+
+      # This is not used within multitenancy. Rather, this allows OTHER tools to
+      # hook into multitenancy via ActiveSupport hooks.
+      ActiveSupport.run_load_hooks(:multitenancy, Multitenancy)
+    end
+
+    config.after_initialize do |app|
+      Integrations::Importmap.call(app)
+    end
+
+    rake_tasks do
+      load "tasks/multitenancy_tailwindcss.rake"
+    end
+  end
+end

data/lib/multitenancy/stim.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Multitenancy
+  class Stim < Module
+    attr_reader :theme, :namespace
+
+    def initialize(theme, namespace)
+      @theme = theme
+      @namespace = namespace
+      super()
+    end
+
+    def included(engine)
+      engine.called_from = theme.path
+      engine.isolate_namespace(namespace)
+      engine.config.root = theme.path
+
+      views_path = theme.path.join("app/views")
+      if views_path.exist?
+        engine.paths["app/views"] = [views_path]
+      end
+
+      assets_path = theme.path.join("app/assets")
+      if assets_path.exist?
+        engine.paths["app/assets"] = [assets_path]
+      end
+
+      locale_path = theme.path.join("config/locales")
+      if locale_path.exist?
+        engine.paths["config/locales"] = [locale_path]
+      end
+
+      js_path = theme.path.join("app/javascript")
+      if js_path.exist?
+        engine.paths["app/javascript"] = [js_path]
+      end
+    end
+  end
+end

data/lib/multitenancy/theme.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "active_support/inflections"
+require "rails/engine"
+
+module Multitenancy
+  class Theme
+    attr_reader :path, :namespace, :engine
+
+    def initialize(path:)
+      @path = path
+      @_bootstrapped = false
+    end
+
+    def bootstrap(app)
+      return if @_bootstrapped
+
+      @namespace = create_namespace
+      @engine = create_engine
+      inject_paths(app)
+
+      @_bootstrapped = true
+    end
+
+    def relative_path
+      path.relative_path_from(::Rails.root)
+    end
+
+    def name
+      path.basename.to_s.parameterize
+    end
+
+    private
+
+    def create_namespace
+      namespace_name = "themes/#{name}"
+      namespace = ActiveSupport::Inflector.camelize(namespace_name)
+      namespace.split("::").reduce(Object) do |base, mod|
+        if base.const_defined?(mod, false)
+          base.const_get(mod, false)
+        else
+          base.const_set(mod, Module.new)
+        end
+      end
+    end
+
+    def create_engine
+      stim = Stim.new(self, namespace)
+      namespace.const_set("Engine", Class.new(::Rails::Engine)).include(stim)
+    end
+
+    def inject_paths(app)
+      Multitenancy.config.paths.each do |path|
+        location = relative_path.join(path)
+
+        next unless location.exist?
+        next unless location.directory?
+
+        app.autoloaders.main.push_dir(location.to_s, namespace: namespace)
+      end
+
+      js_path = self.path.join("app/javascript")
+      app.config.assets.paths << js_path.to_s if js_path.exist?
+    end
+  end
+end

data/lib/multitenancy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Multitenancy
+  VERSION = "0.0.2"
+end