proscenium 0.19.0.beta6 → 0.19.0.beta7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ca20bfda08fd5e1d90c583a57907aa50e218027dc49b5ad7c26cf2a688d69dd
-  data.tar.gz: 0e261b5d63adb2bbf0cb74059e45a29d1b5650a7b4febac561a16f67cc872f45
+  metadata.gz: e9c86c8fc9ea5069434688a114679c39ea03b431af308efbe0b65360f0b5b935
+  data.tar.gz: 4d74b86e4d0aed1651fdc369c4f830b1f85b9b33dad0d109905df3df9581dddc
 SHA512:
-  metadata.gz: 3687fac51a5d0960c8e663efabdba3f15a49a77a95be9e13958de9919f63958ca54358a26c9952fe04840b7959355436ca3cf030e9dfcd4da861f0e138382016
-  data.tar.gz: 2d44a7e5b0240cce9107449f86c8ce0ab2bcebe64825001984024135d9f4c88b184b35d3f5abcadce67bc2f7037d05044bc7146c2454b76fb653a8e4493860a9
+  metadata.gz: c64c401d4ef4e70fedf4e6327177dc53645bcd540de6301f64edfb9020cf8686fe444377ea538ef9a09d2b0699229ab3a138f8704f006e89b5acfb0a39666355
+  data.tar.gz: 249ae5d9c8fe4884b2ad5c7ab2712665522007f75ced0c2d56b4f6ee189e868c0e58122a4f96aade3b24443037b3977356595fd3881dc4fd107151e28c3c751d

data/README.md

@@ -53,7 +53,6 @@
 - [Cache Busting](#cache-busting)
 - [rjs is back!](#rjs-is-back)
 - [Resolution](#resolution)
-  - [Assets from Rails Engines](#assets-from-rails-engines)
 - [Thanks](#thanks)
 - [Development](#development)
 
@@ -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
 {
@@ -851,26 +848,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

@@ -10,7 +10,8 @@ module Proscenium
 
     class Result < FFI::Struct
       layout :success, :bool,
-             :response, :string
+             :response, :string,
+             :content_hash, :string
     end
 
     module Request
@@ -24,11 +25,6 @@ module Proscenium
         :pointer # Config as JSON.
       ], Result.by_value
 
-      attach_function :build_to_path, [
-        :string, # Path or entry point. Multiple can be given by separating with a semi-colon
-        :pointer # Config as JSON.
-      ], Result.by_value
-
       attach_function :resolve, [
         :string, # path or entry point
         :pointer # Config as JSON.
@@ -44,6 +40,7 @@ module Proscenium
         @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
@@ -60,12 +57,8 @@ module Proscenium
       end
     end
 
-    def self.build_to_path(path, root: nil)
-      new(root:).build_to_path(path)
-    end
-
-    def self.build_to_string(path, root: nil, bundle: nil)
-      new(root:, bundle:).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)
@@ -77,43 +70,27 @@ module Proscenium
       Request.reset_config
     end
 
-    def initialize(root: nil, bundle: nil)
-      bundle = Proscenium.config.bundle if bundle.nil?
-
+    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),
-        Engines: Proscenium.config.engines,
         EnvVars: env_vars,
         CodeSplitting: Proscenium.config.code_splitting,
-        ExternalNodeModules: Proscenium.config.external_node_modules,
-        Bundle: bundle,
+        RubyGems: Proscenium::BundledGems.paths,
+        Bundle: Proscenium.config.bundle,
+        QueryString: cache_query_string,
         Debug: Proscenium.config.debug
       }.to_json)
     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, @request_config)
-
-          raise BuildError, result[:response] unless result[:success]
-
-          result[:response]
-        end
-      end
-    end
-
     def build_to_string(path)
       ActiveSupport::Notifications.instrument('build_to_string.proscenium', identifier: path) do
         result = Request.build_to_string(path, @request_config)
 
         raise BuildError, result[:response] unless result[:success]
 
-        result[:response]
+        result
       end
     end
 
@@ -137,8 +114,7 @@ module Proscenium
     end
 
     def cache_query_string
-      q = Proscenium.config.cache_query_string
-      q ? "--cache-query-string #{q}" : 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/ui').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/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/ext/proscenium.h

@@ -24,6 +24,7 @@ typedef struct { const char *p; ptrdiff_t n; } _GoString_;
 struct Result {
 	int success;
 	char* response;
+	char* contentHash;
 };
 
 #line 1 "cgo-generated-wrapper"
@@ -91,13 +92,6 @@ extern void reset_config();
 //
 extern struct Result build_to_string(char* filePath, char* configJson);
 
-// Build the given `path` in the `root`.
-//
-// - path - The path to build relative to `root`.
-// - config
-//
-extern struct Result build_to_path(char* filePath, char* configJson);
-
 // Resolve the given `path` relative to the `root`.
 //
 // - path - The path to build relative to `root`.

data/lib/proscenium/helper.rb

@@ -21,10 +21,8 @@ module Proscenium
     # /app/javascript.
     def compute_asset_path(path, options = {})
       if %i[javascript stylesheet].include?(options[:type])
-        path.prepend DEFAULT_RAILS_ASSET_PATHS[options[:type]] unless path.start_with?('./', '../')
-
-        result = Proscenium::Builder.build_to_path(path)
-        return result.split('::').last.delete_prefix 'public'
+        path.prepend DEFAULT_RAILS_ASSET_PATHS[options[:type]] if !path.start_with?('./', '../')
+        return path
       end
 
       super
@@ -61,16 +59,12 @@ module Proscenium
     def include_stylesheets
       SideLoad::CSS_COMMENT.html_safe
     end
-    alias side_load_stylesheets include_stylesheets
-    deprecate side_load_stylesheets: 'Use `include_stylesheets` instead', deprecator: Deprecator.new
 
     # Includes all javascripts that have been imported and side loaded.
     #
     # @return [String] the HTML tags for the javascripts.
     def include_javascripts
-      (SideLoad::LAZY_COMMENT + SideLoad::JS_COMMENT).html_safe
+      SideLoad::JS_COMMENT.html_safe
     end
-    alias side_load_javascripts include_javascripts
-    deprecate side_load_javascripts: 'Use `include_javascripts` instead', deprecator: Deprecator.new
   end
 end

data/lib/proscenium/importer.rb

@@ -23,12 +23,11 @@ module Proscenium
       #
       # @param filepath [String] Absolute URL path (relative to Rails root) of the file to import.
       #   Should be the actual asset file, eg. app.css, some/component.js.
-      # @param resolve [String] description of the file to resolve and import.
-      # @return [String] the digest of the imported file path if a css module (*.module.css).
-      def import(filepath = nil, resolve: nil, **)
+      # @return [String|nil] the digest of the imported file path if a css module (*.module.css).
+      def import(filepath = nil, **)
         self.imported ||= {}
 
-        filepath = Resolver.resolve(resolve) if !filepath && resolve
+        filepath = "/node_modules/#{filepath}" if filepath.start_with?('@rubygems/')
         css_module = filepath.end_with?('.module.css')
 
         unless self.imported.key?(filepath)
@@ -60,6 +59,7 @@ module Proscenium
       # `.tsx` extension is matched first.
       #
       # @param filepath [Pathname] Absolute file system path of the Ruby file to sideload.
+      # @param options [Hash] Options to pass to `import`.
       def sideload(filepath, **options)
         return if !Proscenium.config.side_load || (options[:js] == false && options[:css] == false)
 
@@ -75,20 +75,22 @@ module Proscenium
         _sideload(filepath, CSS_EXTENSIONS, **)
       end
 
+      # @param filepath [Pathname] Absolute file system path of the Ruby file to sideload.
+      # @param extensions [Array<String>] Supported file extensions to sideload.
+      # @param options [Hash] Options to pass to `import`.
+      # @raise [ArgumentError] if `filepath` is not an absolute file system path.
       private def _sideload(filepath, extensions, **options) # rubocop:disable Style/AccessModifierDeclarations
         return unless Proscenium.config.side_load
 
-        filepath = Rails.root.join(filepath) unless filepath.is_a?(Pathname)
+        if !filepath.is_a?(Pathname) || !filepath.absolute?
+          raise ArgumentError, "`filepath` (#{filepath}) must be a `Pathname`, and an absolute path"
+        end
+
         filepath = filepath.sub_ext('')
 
         extensions.find do |x|
           if (fp = filepath.sub_ext(x)).exist?
-            if (fp = fp.to_s).start_with?(Proscenium.ui_path.to_s)
-              fp.sub!(Proscenium.ui_path_regex, 'proscenium/')
-              import(Resolver.resolve(fp), sideloaded: true, **options)
-            else
-              import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
-            end
+            import(Resolver.resolve(fp.to_s), sideloaded: true, **options)
           end
         end
       end

data/lib/proscenium/log_subscriber.rb

@@ -10,18 +10,6 @@ module Proscenium
       end
     end
 
-    def build_to_path(event)
-      path = event.payload[:identifier]
-      cached = event.payload[:cached] ? ' | Cached!' : ''
-      path = CGI.unescape(path) if path.start_with?(/https?%3A%2F%2F/)
-
-      info do
-        message = "  #{color('[Proscenium]', nil, bold: true)} Building (to path) #{path}"
-        message << " (Duration: #{event.duration.round(1)}ms | " \
-                   "Allocations: #{event.allocations}#{cached})"
-      end
-    end
-
     def build_to_string(event)
       path = event.payload[:identifier]
       path = CGI.unescape(path) if path.start_with?(/https?%3A%2F%2F/)

data/lib/proscenium/middleware/base.rb

@@ -77,24 +77,26 @@ module Proscenium
         end
       end
 
-      def render_response(content)
+      def render_response(result)
+        content = result[:response]
+
         response = Rack::Response.new
-        response.write content
-        response.content_type = content_type
         response['X-Proscenium-Middleware'] = name
         response.set_header 'SourceMap', "#{@request.path_info}.map"
+        response.content_type = content_type
+        response.etag = result[:content_hash]
 
         if Proscenium.config.cache_query_string && Proscenium.config.cache_max_age
           response.cache! Proscenium.config.cache_max_age
         end
 
-        cache_proc = Proscenium.config.cache_middleware_response
-        if cache_proc.is_a?(Proc) && cache_proc.call(path_to_build)
-          response.cache! Proscenium.config.cache_max_age
+        if @request.fresh?(response)
+          response.status = 304
+          response.body = []
+        else
+          response.write content
         end
 
-        yield response if block_given?
-
         response.finish
       end
 

data/lib/proscenium/middleware/esbuild.rb

@@ -20,12 +20,7 @@ module Proscenium
       end
 
       def attempt
-        bundle = nil
-        if Proscenium.config.external_node_modules && path_to_build.start_with?('node_modules/')
-          bundle = false
-        end
-
-        render_response Builder.build_to_string(path_to_build, bundle:)
+        render_response Builder.build_to_string(path_to_build)
       rescue Builder::CompileError => e
         raise self.class::CompileError, { file: @request.fullpath, detail: e.message }, caller
       end

data/lib/proscenium/middleware/ruby_gems.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    class RubyGems < Esbuild
+      def real_path
+        @real_path ||= Pathname.new(gem_request_path.delete_prefix("#{gem_name}/")).to_s
+      end
+
+      def root_for_readable
+        BundledGems.pathname_for!(gem_name)
+      end
+
+      def gem_name
+        @gem_name ||= gem_request_path.split('/').first
+      end
+
+      def gem_request_path
+        @gem_request_path ||= @request.path.delete_prefix('/node_modules/@rubygems/')
+      end
+    end
+  end
+end

data/lib/proscenium/middleware.rb

@@ -9,7 +9,7 @@ module Proscenium
 
     autoload :Base
     autoload :Esbuild
-    autoload :Engines
+    autoload :RubyGems
 
     def initialize(app)
       @app = app
@@ -20,10 +20,25 @@ module Proscenium
     end
 
     def call(env)
-      request = Rack::Request.new(env)
+      request = ActionDispatch::Request.new(env)
 
       return @app.call(env) if !request.get? && !request.head?
-      return @chunk_handler.attempt(request.env) if request.path.match?(%r{^/_asset_chunks/})
+
+      if request.path.match?(%r{^/_asset_chunks/})
+        response = Rack::Response[*@chunk_handler.attempt(request.env)]
+        response.etag = request.path.match(/-\$([a-z0-9]+)\$/i)[1]
+
+        if Proscenium.config.cache_query_string && Proscenium.config.cache_max_age
+          response.cache! Proscenium.config.cache_max_age
+        end
+
+        if request.fresh?(response)
+          response.status = 304
+          response.body = []
+        end
+
+        return response.finish
+      end
 
       attempt(request) || @app.call(env)
     end
@@ -33,40 +48,29 @@ module Proscenium
     def attempt(request)
       return unless (type = find_type(request))
 
-      # file_handler.attempt(request.env) || type.attempt(request)
-
       type.attempt request
     end
 
     def find_type(request)
-      return Esbuild if Pathname.new(request.path).fnmatch?(app_path_glob, File::FNM_EXTGLOB)
-
       pathname = Pathname.new(request.path)
-      Engines if pathname.fnmatch?(ui_path_glob, File::FNM_EXTGLOB) ||
-                 pathname.fnmatch?(engines_path_glob, File::FNM_EXTGLOB)
+
+      if pathname.fnmatch?(gems_path_glob, File::FNM_EXTGLOB)
+        RubyGems
+      elsif pathname.fnmatch?(app_path_glob, File::FNM_EXTGLOB)
+        Esbuild
+      end
     end
 
     def app_path_glob
       "/{#{Proscenium::ALLOWED_DIRECTORIES}}/**.{#{file_extensions}}"
     end
 
-    def engines_path_glob
-      names = Proscenium.config.engines.keys
-      "/{#{names.join(',')}}/{#{Proscenium::ALLOWED_DIRECTORIES}}/**.{#{file_extensions}}"
-    end
-
-    def ui_path_glob
-      "/proscenium/**.{#{file_extensions}}"
+    def gems_path_glob
+      "/node_modules/@rubygems/**.{#{file_extensions}}"
     end
 
     def file_extensions
       @file_extensions ||= FILE_EXTENSIONS.join(',')
     end
-
-    # TODO: handle precompiled assets
-    # def file_handler
-    #   ::ActionDispatch::FileHandler.new Rails.public_path.join('assets').to_s,
-    #                                     headers: { 'X-Proscenium-Middleware' => 'precompiled' }
-    # end
   end
 end

data/lib/proscenium/monkey.rb

@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 
 module Proscenium
-  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
   module Monkey
     module TemplateRenderer
       private
 
-      def render_template(view, template, layout_name, locals) # rubocop:disable Metrics/*
+      def render_template(view, template, layout_name, locals)
         result = super
         return result if !view.controller || !Proscenium.config.side_load
 
@@ -48,7 +47,7 @@ module Proscenium
           options[k] = controller.instance_eval(&options[k]) if options[k].is_a?(Proc)
         end
 
-        Importer.sideload "app/views/#{tpl.virtual_path}", **options
+        Importer.sideload Rails.root.join("app/views/#{tpl.virtual_path}"), **options
       end
     end
 
@@ -87,9 +86,8 @@ module Proscenium
           options[k] = controller.instance_eval(&options[k]) if options[k].is_a?(Proc)
         end
 
-        Importer.sideload "app/views/#{tpl.virtual_path}", **options
+        Importer.sideload Rails.root.join("app/views/#{tpl.virtual_path}"), **options
       end
     end
   end
-  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 end

data/lib/proscenium/phlex/asset_inclusions.rb

@@ -6,7 +6,6 @@ module Proscenium::Phlex::AssetInclusions
   end
 
   def include_javascripts
-    comment { '[PROSCENIUM_LAZY_SCRIPTS]' }
     comment { '[PROSCENIUM_JAVASCRIPTS]' }
   end
 

data/lib/proscenium/railtie.rb

@@ -14,42 +14,15 @@ module Proscenium
     config.proscenium.bundle = true
     config.proscenium.side_load = true
     config.proscenium.code_splitting = true
-    config.proscenium.external_node_modules = false
 
-    # Cache asset paths when building to path. Enabled by default in production.
-    # @see Proscenium::Builder#build_to_path
-    config.proscenium.cache = ActiveSupport::Cache::MemoryStore.new if Rails.env.production?
-
-    # TODO: implement!
     config.proscenium.cache_query_string = Rails.env.production? && ENV.fetch('REVISION', nil)
     config.proscenium.cache_max_age = 2_592_000 # 30 days
 
-    # A proc that will be given the path to build, and should return a boolean indicating whether to
-    # cache the response.
-    #
-    # Example:
-    #   cache_middleware_response = ->(path) { path.start_with?('node_modules/') }
-    config.proscenium.cache_middleware_response = nil
-
     # List of environment variable names that should be passed to the builder, which will then be
     # passed to esbuild's `Define` option. Being explicit about which environment variables are
     # defined means a faster build, as esbuild will have less to do.
     config.proscenium.env_vars = Set.new
 
-    # Rails engines to expose and allow Proscenium to serve their assets.
-    #
-    # A Rails engine that has assets, can add Proscenium as a gem dependency, and then add itself
-    # to this list. Proscenium will then serve the engine's assets at the URL path beginning with
-    # the engine name.
-    #
-    # Example:
-    #   class Gem1::Engine < ::Rails::Engine
-    #     config.proscenium.engines[:gem1] = root
-    #   end
-    config.proscenium.engines = {
-      proscenium: Proscenium.ui_path
-    }
-
     config.action_dispatch.rescue_templates = {
       'Proscenium::Builder::BuildError' => 'build_error'
     }

data/lib/proscenium/registry/bundled_package.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rubygems/package'
+
+class Proscenium::Registry
+  class BundledPackage < Package
+    def version = @version ||= spec.version.to_s
+
+    private
+
+    def package_json
+      @package_json ||= begin
+        unless (gem_path = Proscenium::BundledGems.pathname_for(gem_name))
+          raise PackageNotInstalledError, name
+        end
+
+        if (package_path = gem_path.join('package.json')).exist?
+          JSON.parse(package_path.read)
+        else
+          default_package_json
+        end
+      end
+    end
+
+    def spec
+      @spec ||= Bundler.load.specs[gem_name].first
+    end
+  end
+end