proscenium 0.18.0-arm64-darwin → 0.19.0-arm64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97b6762190186f202a4c47c31df4b917b1ac8aba94617a556bab8a3b405f10cb
-  data.tar.gz: 1aafadc1a8b26192d92982399e00552e3e2e21c2fe2cabb1699e2ce5bc19a371
+  metadata.gz: e499453d502c9d28561f82b1e150fbfc6a3f2156f0ef75f41bddc7a1a1d9f693
+  data.tar.gz: 5be3e2606e7198d94e74286f5ed3f64df99e39b01d9f56fc8d05fac77fbc0c5c
 SHA512:
-  metadata.gz: 955b20a69c4dab9a8ec2fc17892a819dbda39ddfb440e9a0a7b184f3f124f40a82dcb4b31c46c13b91d231b66811399fb465e493ce6399499583c27a15309bce
-  data.tar.gz: e10d3aec815547b202fffa97242f40afd76f16e8adf01405192135f26dc267cb271fa0e54560931775cba61b24d88a9ac3f0bccf9ba594fa2cd02ee8e9f9d9c3
+  metadata.gz: 9bcfa44958a053cdf4c0574856db0e520e2cd450b01c692cf9e4cd3737c46e56fbadbd405639c0aac98a45e693731f3b3ec71211384f8f3f91a9196359824264
+  data.tar.gz: 6ba4f3dc8c3b8df5217b2e8edb8e781f8cd870399ceaadb293a104f564f25e54fd6742b7d4dc01793e2b5c602673b030975450b012347b511fdc3cb5b49b7579

data/README.md

@@ -6,17 +6,17 @@
 >
 > - _the part of a theatre stage in front of the curtain._
 
-**_Proscenium_** treats your frontend and client-side code as first class citizens of your Rails app, and assumes a "fast by default" internet. It bundles and minifies JavaScript (+ JSX), TypeScript (+TSX) and CSS in real time, on demand, and with zero configuration.
+**_Proscenium_** treats your frontend and client-side code as first class citizens of your Rails app, and assumes a "fast by default" internet. It bundles and minifies JavaScript (+JSX), TypeScript (+TSX) and CSS in real time, on demand, and with zero configuration.
 
 **The highlights:**
 
 - Fast, real-time bundling, tree-shaking, code-splitting and minification of Javascript (.js,.jsx), Typescript (.ts,.tsx) and CSS (.css).
 - NO JavaScript runtime needed (eg. Node) - just the browser!
 - NO build step or pre-compilation.
-- NO additional process or server - Just run `rails s`!
+- NO additional process or server - Just run `rails server`!
 - Transforms newer JavaScript and CSS syntax to older syntax for older browsers.
 - Deep integration with Rails.
-- Automatically side-load your layouts, views, and partials.
+- Automatically side-load JS and CSS for your layouts, views, and partials.
 - Import from NPM, URL's, and locally.
 - Server-side import map support.
 - CSS Modules & mixins.
@@ -48,12 +48,9 @@
   - [Typescript Caveats](#typescript-caveats)
 - [JSX](#jsx)
 - [JSON](#json)
-- [Phlex Support](#phlex-support)
-- [ViewComponent Support](#viewcomponent-support)
 - [Cache Busting](#cache-busting)
 - [rjs is back!](#rjs-is-back)
 - [Resolution](#resolution)
-  - [Assets from Rails Engines](#assets-from-rails-engines)
 - [Thanks](#thanks)
 - [Development](#development)
 
@@ -78,15 +75,15 @@ gem 'proscenium'
 
 Please note that Proscenium is designed solely for use with Rails.
 
-Now if you start your Rails app, you can open any front end code (JS, CSS, etc.). For example, a file at `app/assets/stylesheets/application.css` can be accessed at `https://localhost:3000/app/assets/stylesheets/application.css`, which will be bundled, transformed, and minified [in production] in real time.
+Now if you start your Rails app, you can open any front end code (JS, CSS, etc.). For example, a file at `app/assets/stylesheets/application.css` can be accessed at `https://localhost:3000/app/assets/stylesheets/application.css`, which will be transformed, bundled, and minified [in production] in real time.
 
 ## Client-Side Code Anywhere
 
-Proscenium believes that your frontend code is just as important as your backend code, and is not an afterthought - they should be first class citizens of your Rails app. So instead of having to throw all your JS and CSS into a "app/assets" directory, and then requiring a separate process to compile or bundle, just put them wherever you want within your app, and just run Rails!
+Proscenium believes that your frontend code is just as important as your backend code, and is not an afterthought - they should be first class citizens of your Rails app. So instead of having to throw all your JS and CSS into a "app/assets" directory, and then requiring a separate process to compile or bundle, you can simply put them wherever you want within your app, and just run Rails!
 
 For example, if you have some JS that is required by your `app/views/users/index.html.erb` view, just create a JS file alongside it at `app/views/users/index.js`. Or if you have some CSS that is used by your entire application, put it in `app/views/layouts/application.css` and load it alongside your layout. Maybe you have a few JS utility functions, so put them in `lib/utils.js`.
 
-Simply put your JS(X) and CSS anywhere you want, and they will be served by your Rails app from the location where you placed them.
+Simply put your JS(X) and CSS anywhere you want, and they will be served by your Rails app from the same location where you placed them.
 
 Using the examples above...
 
@@ -98,15 +95,15 @@ Using the examples above...
 
 ## Side Loading
 
-Proscenium is best experienced when your assets are automtically side loaded.
+Proscenium is best experienced when your assets are automatically side loaded.
 
 ### The Problem
 
-With Rails you would typically declaratively load your JavaScript and CSS assets using the `javascript_include_tag` and `stylesheet_link_tag` helpers.
+With Rails you would typically load your JavaScript and CSS assets declaratively using the `javascript_include_tag` and `stylesheet_link_tag` helpers.
 
-For example, you may have top-level "application" CSS located in a file at `/app/assets/stylesheets/application.css`. Likewise, you may have some global JavaScript located in a file at `/app/javascript/application.js`.
+For example, you may have top-level "application" styles located in a file at `/app/assets/stylesheets/application.css`. Likewise, you may have some global JavaScript located in a file at `/app/javascript/application.js`.
 
-You would manually and declaratively include those two files in your application layout, something like this:
+You would manually and declaratively include those two files in each of your layouts, something like this:
 
 ```erb
 <%# /app/views/layouts/application.html.erb %>
@@ -144,7 +141,9 @@ The main problem is that you have to keep track of all these assets, and make su
 
 When side loading your JavaScript, Typescript and CSS with Proscenium, they are automatically included alongside your views, partials, layouts, and components, and only when needed.
 
-Side loading works by looking for a JS/TS/CSS file with the same name as your view, partial, layout or component. For example, if you have a view at `app/views/users/index.html.erb`, then Proscenium will look for a JS/TS/CSS file at `app/views/users/index.js`, `app/views/users/index.ts` or `app/views/users/index.css`. If it finds one, it will include it in the HTML for that view.
+Side loading works by looking for a JS/TS/CSS file with the same name as your view, partial, layout or component. For example, if you have a view at `app/views/users/index.html.erb`, then Proscenium will look for a JS and CSS file at `app/views/users/index.js` (or TypeScript with a .ts extension) and `app/views/users/index.css`. If it finds one, it will automatically include it in the HTML for that view. And only for that view.
+
+This allows you to keep your assets organized alongside the views, partials, and components that use them, without having to manually track and include them. It also means only the assets that are needed are included.
 
 JSX is also supported for JavaScript and Typescript. Simply use the `.jsx` or `.tsx` extension instead of `.js` or `.ts`.
 
@@ -253,15 +252,13 @@ import Header from "/app/components/header";
 
 ### Unbundling
 
-Sometimes you don't want to bundle an import. For example, you want to ensure that only one instance of React is loaded. In this cases, you can use the `unbundle` prefix
+Sometimes you don't want to bundle an import. For example, you want to ensure that only one instance of React is loaded. In these cases, you can use the `unbundle` import attribute:
 
 ```js
-import React from "unbundle:react";
+import React from "react" with { unbundle: 'true' };
 ```
 
-This only works any bare and local imports.
-
-You can also use the `unbundle` prefix in your [import map](#import-maps), which ensures that all imports of a particular path is always unbundled:
+You can also unbundle entries in your [import map](#import-maps) using an `unbundle:` prefix, which ensures that all imports of a particular path are always unbundled:
 
 ```json
 {
@@ -277,6 +274,14 @@ Then just import as normal:
 import React from "react";
 ```
 
+Or if you don't want any bundling at all, simply turn it off application-wide:
+
+```ruby
+config.proscenium.bundle = false
+```
+
+This will mean every asset and import will be loaded independently.
+
 ## Import Maps
 
 > **[WIP]**
@@ -413,7 +418,7 @@ if (typeof proscenium.env?.UNKNOWN !== "undefined") {
 Basic support is provided for importing your Rails locale files from `config/locales/*.yml`, exporting them as JSON.
 
 ```js
-import translations from "@proscenium/i18n";
+import translations from "proscenium/i18n";
 // translations.en.*
 ```
 
@@ -446,8 +451,6 @@ one();
 
 ### Code Splitting
 
-> Available in `>=0.10.0`.
-
 [Side loaded](#side-loading) assets are automatically code split. This means that if you have a file that is imported and used imported several times, and by different files, it will be split off into a separate file.
 
 As an example:
@@ -685,140 +688,8 @@ import { version } from "./package.json";
 console.log(version);
 ```
 
-## Phlex Support
-
-[Phlex](https://www.phlex.fun/) is a framework for building fast, reusable, testable views in pure Ruby. Proscenium works perfectly with Phlex, with support for side-loading, CSS modules, and more. Simply write your Phlex classes and inherit from `Proscenium::Phlex`.
-
-```ruby
-class MyView < Proscenium::Phlex
-  def view_template
-    h1 { 'Hello World' }
-  end
-end
-```
-
-In your layouts, include `Proscenium::Phlex::AssetInclusions`, and call the `include_assets` helper.
-
-```ruby
-class ApplicationLayout < Proscenium::Phlex
-  include Proscenium::Phlex::AssetInclusions # <--
-
-  def view_template(&)
-    doctype
-    html do
-      head do
-        title { 'My Awesome App' }
-        include_assets # <--
-      end
-      body(&)
-    end
-  end
-end
-```
-
-You can specifically include CCS and JS assets using the `include_stylesheets` and `include_javascripts` helpers, allowing you to control where they are included in the HTML.
-
-### Side-loading
-
-Any Phlex class that inherits `Proscenium::Phlex` will automatically be [side-loaded](#side-loading).
-
-### CSS Modules
-
-[CSS Modules](#css-modules) are fully supported in Phlex classes, with access to the [`css_module` helper](#in-your-views) if you need it. However, there is a better and more seemless way to reference CSS module classes in your Phlex classes.
-
-Within your Phlex classes, any class names that begin with `@` will be treated as a CSS module class.
-
-```ruby
-# /app/views/users/show_view.rb
-class Users::ShowView < Proscenium::Phlex
-  def view_template
-    h1 class: :@user_name do
-      @user.name
-    end
-  end
-end
-```
-
-```css
-/* /app/views/users/show_view.module.css */
-.userName {
-  color: red;
-  font-size: 50px;
-}
-```
-
-In the above `Users::ShowView` Phlex class, the `@user_name` class will be resolved to the `userName` class in the `users/show_view.module.css` file.
-
-The view above will be rendered something like this:
-
-```html
-<h1 class="user_name-ABCD1234"></h1>
-```
-
-You can of course continue to reference regular class names in your view, and they will be passed through as is. This will allow you to mix and match CSS modules and regular CSS classes in your views.
-
-```ruby
-# /app/views/users/show_view.rb
-class Users::ShowView < Proscenium::Phlex
-  def view_template
-    h1 class: :[@user_name, :title] do
-      @user.name
-    end
-  end
-end
-```
-
-```html
-<h1 class="user_name-ABCD1234 title">Joel Moss</h1>
-```
-
-## ViewComponent Support
-
-[ViewComponent](https://viewcomponent.org/) iA framework for creating reusable, testable & encapsulated view components, built to integrate seamlessly with Ruby on Rails. Proscenium works perfectly with ViewComponent, with support for side-loading, CSS modules, and more. Simply write your ViewComponent classes and inherit from `Proscenium::ViewComponent`.
-
-```ruby
-class MyView < Proscenium::ViewComponent
-  def call
-    tag.h1 'Hello World'
-  end
-end
-```
-
-### Side-loading
-
-Any ViewComponent class that inherits `Proscenium::ViewComponent` will automatically be [side-loaded](#side-loading).
-
-### CSS Modules
-
-[CSS Modules](#css-modules) are fully supported in ViewComponent classes, with access to the [`css_module` helper](#in-your-views) if you need it.
-
-```ruby
-# /app/components/user_component.rb
-class UserComponent < Proscenium::ViewComponent
-  def view_template
-    div.h1 @user.name, class: css_module(:user_name)
-  end
-end
-```
-
-```css
-/* # /app/components/user_component.module.css */
-.userName {
-  color: red;
-  font-size: 50px;
-}
-```
-
-The view above will be rendered something like this:
-
-```html
-<h1 class="user_name-ABCD1234">Joel Moss</h1>
-```
-
 ## Cache Busting
 
-> _COMING SOON_
-
 By default, all assets are not cached by the browser. But if in production, you populate the `REVISION` env variable, all CSS and JS URL's will be appended with its value as a query string, and the `Cache-Control` response header will be set to `public` and a max-age of 30 days.
 
 For example, if you set `REVISION=v1`, URL's will be appended with `?v1`: `/my/imported/file.js?v1`.
@@ -851,26 +722,6 @@ You can continue to access any file in the `/public` directory as you normally w
 
 If requesting a file that exists in a root directory and the public directory, the file in the public directory will be served. For example, if you have a file at `/lib/foo.js` and `/public/lib/foo.js`, and you request `/lib/foo.js`, the file in the public directory (`/public/lib/foo.js`) will be served.
 
-### Assets from Rails Engines
-
-Proscenium can serve assets from Rails Engines that are installed in your Rails app.
-
-An engine that wants to expose its assets via Proscenium to the application must add Proscenium as a dependency, and add itself to the list of engines in the Proscenium config options `Proscenium.config.engines`.
-
-For example, we have a gem called `gem1` that has Proscenium as a dependency, and exposes a Rails engine. It has some assets that it wants to expose to the application. To do this, it adds itself to the list of engines in the Proscenium config `engines` option:
-
-```ruby
-class Gem1::Engine < ::Rails::Engine
-  config.proscenium.engines << self
-end
-```
-
-When this gem is installed in any Rails application, its assets will be available at the URL `/gem1/...`. For example, if the gem has a file `lib/styles.css`, it can be requested at `/gem1/lib/styles.css`.
-
-The same directories and file extensions are supported as for the application itself.
-
-It is important to note that the application takes precedence over the gem. So if the application has a file at `/public/gem1/lib/styles.css`, and the gem also has a file at `/lib/styles.css`, then the file in the application will be served. This is because both files would be accessible at the same URL: `/gem1/lib/styles.css`.
-
 ## Thanks
 
 HUGE thanks 🙏 go to [Evan Wallace](https://github.com/evanw) and his amazing [esbuild](https://esbuild.github.io/) project. Proscenium would not be possible without it, and it is esbuild that makes this so fast and efficient.

data/lib/proscenium/builder.rb

@@ -1,72 +1,47 @@
 # frozen_string_literal: true
 
 require 'ffi'
-require 'oj'
 
 module Proscenium
   class Builder
     class CompileError < StandardError; end
 
+    ENVIRONMENTS = { development: 1, test: 2, production: 3 }.freeze
+
     class Result < FFI::Struct
       layout :success, :bool,
-             :response, :string
+             :response, :string,
+             :content_hash, :string
     end
 
     module Request
       extend FFI::Library
+
       ffi_lib Pathname.new(__dir__).join('ext/proscenium').to_s
 
       enum :environment, [:development, 1, :test, :production]
 
       attach_function :build_to_string, [
-        :string,      # Path or entry point.
-        :string,      # Base URL of the Rails app. eg. https://example.com
-        :string,      # Path to import map, relative to root
-        :string,      # ENV variables as a JSON string
-
-        # Config
-        :string,      # Rails application root
-        :string,      # Proscenium gem root
-        :environment, # Rails environment as a Symbol
-        :bool,        # Code splitting enabled?
-        :string,      # Engine names and paths as a JSON string
-        :bool         # Debugging enabled?
-      ], Result.by_value
-
-      attach_function :build_to_path, [
-        :string,      # Path or entry point. Multiple can be given by separating with a semi-colon
-        :string,      # Base URL of the Rails app. eg. https://example.com
-        :string,      # Path to import map, relative to root
-        :string,      # ENV variables as a JSON string
-
-        # Config
-        :string,      # Rails application root
-        :string,      # Proscenium gem root
-        :environment, # Rails environment as a Symbol
-        :bool,        # Code splitting enabled?
-        :string,      # Engine names and paths as a JSON string
-        :bool         # Debugging enabled?
+        :string, # Path or entry point.
+        :pointer # Config as JSON.
       ], Result.by_value
 
       attach_function :resolve, [
-        :string,      # path or entry point
-        :string,      # path to import map, relative to root
-
-        # Config
-        :string,      # Rails application root
-        :string,      # Proscenium gem root
-        :environment, # Rails environment as a Symbol
-        :bool         # debugging enabled?
+        :string, # path or entry point
+        :pointer # Config as JSON.
       ], Result.by_value
+
+      attach_function :reset_config, [], :void
     end
 
     class BuildError < StandardError
       attr_reader :error
 
       def initialize(error)
-        @error = Oj.load(error, mode: :strict).deep_transform_keys(&:underscore)
+        @error = JSON.parse(error, strict: true).deep_transform_keys(&:underscore)
 
         msg = @error['text']
+        msg << ' - ' << @error['detail'] if @error['detail'].is_a?(String)
         if (location = @error['location'])
           msg << " at #{location['file']}:#{location['line']}:#{location['column']}"
         end
@@ -83,65 +58,47 @@ module Proscenium
       end
     end
 
-    def self.build_to_path(path, root: nil, base_url: nil)
-      new(root:, base_url:).build_to_path(path)
-    end
-
-    def self.build_to_string(path, root: nil, base_url: nil)
-      new(root:, base_url:).build_to_string(path)
+    def self.build_to_string(path, root: nil)
+      new(root:).build_to_string(path)
     end
 
     def self.resolve(path, root: nil)
       new(root:).resolve(path)
     end
 
-    def initialize(root: nil, base_url: nil)
-      @root = root || Rails.root
-      @base_url = base_url
+    # Intended for tests only.
+    def self.reset_config!
+      Request.reset_config
     end
 
-    def build_to_path(path)
-      ActiveSupport::Notifications.instrument('build_to_path.proscenium',
-                                              identifier: path,
-                                              cached: Proscenium.cache.exist?(path)) do
-        Proscenium.cache.fetch path do
-          result = Request.build_to_path(path, @base_url, import_map, env_vars.to_json,
-                                         @root.to_s,
-                                         gem_root,
-                                         Rails.env.to_sym,
-                                         Proscenium.config.code_splitting,
-                                         engines.to_json,
-                                         Proscenium.config.debug)
-
-          raise BuildError, result[:response] unless result[:success]
-
-          result[:response]
-        end
-      end
+    def initialize(root: nil)
+      @request_config = FFI::MemoryPointer.from_string({
+        RootPath: (root || Rails.root).to_s,
+        GemPath: gem_root,
+        Environment: ENVIRONMENTS.fetch(Rails.env.to_sym, 2),
+        EnvVars: env_vars,
+        CodeSplitting: Proscenium.config.code_splitting,
+        RubyGems: Proscenium::BundledGems.paths,
+        Bundle: Proscenium.config.bundle,
+        QueryString: cache_query_string,
+        Debug: Proscenium.config.debug
+      }.to_json)
     end
 
     def build_to_string(path)
-      ActiveSupport::Notifications.instrument('build_to_string.proscenium', identifier: path) do
-        result = Request.build_to_string(path, @base_url, import_map, env_vars.to_json,
-                                         @root.to_s,
-                                         gem_root,
-                                         Rails.env.to_sym,
-                                         Proscenium.config.code_splitting,
-                                         engines.to_json,
-                                         Proscenium.config.debug)
+      ActiveSupport::Notifications.instrument('build.proscenium', identifier: path) do
+        result = Request.build_to_string(path, @request_config)
 
         raise BuildError, result[:response] unless result[:success]
 
-        result[:response]
+        result
       end
     end
 
     def resolve(path)
       ActiveSupport::Notifications.instrument('resolve.proscenium', identifier: path) do
-        result = Request.resolve(path, import_map, @root.to_s,
-                                 gem_root,
-                                 Rails.env.to_sym,
-                                 Proscenium.config.debug)
+        result = Request.resolve(path, @request_config)
+
         raise ResolveError.new(path, result[:response]) unless result[:success]
 
         result[:response]
@@ -158,28 +115,7 @@ module Proscenium
     end
 
     def cache_query_string
-      q = Proscenium.config.cache_query_string
-      q ? "--cache-query-string #{q}" : nil
-    end
-
-    def engines
-      Proscenium.config.engines.to_h { |e| [e.engine_name, e.root.to_s] }.tap do |x|
-        x['proscenium/ui'] = Proscenium.ui_path.to_s
-      end
-    end
-
-    def import_map
-      return unless (path = Rails.root&.join('config'))
-
-      if (json = path.join('import_map.json')).exist?
-        return json.relative_path_from(@root).to_s
-      end
-
-      if (js = path.join('import_map.js')).exist?
-        return js.relative_path_from(@root).to_s
-      end
-
-      nil
+      Proscenium.config.cache_query_string.presence || ''
     end
 
     def gem_root

data/lib/proscenium/bundled_gems.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module BundledGems
+    module_function
+
+    def paths
+      @paths ||= begin
+        specs = Bundler.load.specs.reject { |s| s.name == 'bundler' }.sort_by(&:name)
+
+        raise 'No gems in your Gemfile' if specs.empty?
+
+        bundle = {}
+        specs.each do |s|
+          bundle[s.name] = if s.name == 'proscenium'
+                             Pathname(s.full_gem_path).join('lib/proscenium').to_s
+                           else
+                             s.full_gem_path
+                           end
+        end
+        bundle
+      end
+    end
+
+    def pathname_for(name)
+      (path = paths[name]) ? Pathname(path) : nil
+    end
+
+    def pathname_for!(name)
+      unless (path = pathname_for(name))
+        raise "Gem `#{name}` not found in your Gemfile"
+      end
+
+      path
+    end
+  end
+end

data/lib/proscenium/css_module/path.rb

@@ -18,7 +18,8 @@ module Proscenium
       unless @css_module_path
         klass = superclass
 
-        while klass.respond_to?(:css_module_path) && !klass.abstract_class
+        while klass.respond_to?(:css_module_path) &&
+              (klass.respond_to?(:abstract_class) ? !klass.abstract_class : true)
           break if (@css_module_path = klass.css_module_path)
 
           klass = klass.superclass

data/lib/proscenium/css_module/transformer.rb

@@ -70,7 +70,7 @@ module Proscenium
       digest = Importer.import(resolved_path)
 
       transformed_path = ''
-      transformed_path = "__#{resolved_path[1..].gsub(%r{[/\.]}, '-')}" if Rails.env.development?
+      transformed_path = "__#{resolved_path[1..].gsub(%r{[@/.+]}, '-')}" if Rails.env.development?
       transformed_name = name.to_s
       transformed_name = if transformed_name.start_with?('_')
                            "_#{transformed_name[1..]}-#{digest}#{transformed_path}"

data/lib/proscenium/css_module.rb

@@ -5,6 +5,7 @@ module Proscenium::CssModule
 
   autoload :Path
   autoload :Transformer
+  autoload :Rewriter
 
   class TransformError < StandardError
     def initialize(name, additional_msg = nil)
@@ -15,21 +16,27 @@ module Proscenium::CssModule
     end
   end
 
-  class Name
-    def initialize(name, transform)
-      @name = name
-      @transform = transform
-    end
+  module ClassMethods
+    def css_module(*names, path: nil)
+      path ||= respond_to?(:css_module_path) ? css_module_path : path
 
-    def to_s
-      @transform
+      cssm = Transformer.new(path)
+      cssm.class_names(*names, require_prefix: false).map { |name, _| name }.join(' ')
     end
 
-    def to_sym
-      @name
+    def class_names(*names, path: nil)
+      path ||= respond_to?(:css_module_path) ? css_module_path : path
+      names = names.flatten.compact
+
+      cssm = Transformer.new(path)
+      cssm.class_names(*names).map { |name, _| name }.join(' ') unless names.empty?
     end
   end
 
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
   # Accepts one or more CSS class names, and transforms them into CSS module names.
   #
   # @param name [String,Symbol,Array<String,Symbol>]

data/lib/proscenium/ensure_loaded.rb

@@ -7,17 +7,21 @@ module Proscenium
     def self.included(child)
       child.class_eval do
         append_after_action do
-          if request.format.html? && Importer.imported?
-            if Importer.js_imported?
-              raise NotIncludedError, 'There are side loaded javascripts to be included, but ' \
-                                      'they have not been included in the page. Did you forget ' \
-                                      'to add the `#include_assets` helper in your views?'
-            end
+          if request.format.html? && !response.redirect? && Importer.imported?
+            msg = <<-TEXT.squish
+              There are side loaded and imported assets to be included, but they have not been
+              included in the page. Did you forget to add the `#include_assets` helper in your
+              views? These assets were imported but not included:
+              #{Importer.imported.keys.to_sentence}
+            TEXT
 
-            if Importer.css_imported?
-              raise NotIncludedError, 'There are side loaded stylesheets to be included, but ' \
-                                      'they have not been included in the page. Did you forget ' \
-                                      'to add the `#include_assets` helper in your views?'
+            if Proscenium.config.ensure_loaded == :log
+              Rails.logger.warn do
+                "#{ActiveSupport::LogSubscriber.new.send(:color, '  [Proscenium]', nil,
+                                                         bold: true)} #{msg}"
+              end
+            elsif Proscenium.config.ensure_loaded == :raise
+              raise NotIncludedError, msg
             end
           end
         end