proscenium 0.26.0-x64-mingw-ucrt

data/lib/proscenium/middleware/base.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    class Base
+      include ActiveSupport::Benchmarkable
+
+      def self.attempt(request)
+        new(request).renderable!&.attempt
+      end
+
+      def initialize(request)
+        @request = request
+      end
+
+      def renderable!
+        # The single funnel every subclass reaches, so the guard sits here rather than in
+        # `renderable?` - a subclass that overrides that (RubyGems does) cannot skip it.
+        return unless normalised_path
+
+        renderable? ? self : nil
+      end
+
+      private
+
+      # The request path, decoded and with `.` and `..` segments resolved. Everything below is
+      # derived from this one value; see `Middleware.normalise_path` for why that matters.
+      def normalised_path
+        return @normalised_path if defined?(@normalised_path)
+
+        @normalised_path = Middleware.normalise_path(@request.path)
+      end
+
+      def real_path
+        @real_path ||= normalised_path
+      end
+
+      # @return [String] the path to the file without the leading slash which will be built.
+      def path_to_build
+        @path_to_build ||= normalised_path[1..]
+      end
+
+      def sourcemap?
+        normalised_path.ends_with?('.map')
+      end
+
+      def renderable?
+        file_readable?
+      end
+
+      # Probes the path exactly as it will be built. `real_path` is already decoded and cleaned, so
+      # decoding it again here - as this once did - probed a different file than the one built
+      # whenever the request was double-encoded: `%252e%252e` was built as a literal `%2e%2e`
+      # segment but probed as `..`.
+      def file_readable?
+        path = sourcemap? ? real_path[0...-4] : real_path
+        file_stat = File.stat(root_for_readable.join(path.delete_prefix('/').b).to_s)
+      rescue SystemCallError
+        false
+      else
+        file_stat.file? && file_stat.readable?
+      end
+
+      def root_for_readable
+        Rails.root
+      end
+
+      def content_type
+        case ::File.extname(path_to_build)
+        when '.js', '.mjs', '.ts', '.tsx', '.jsx' then 'application/javascript'
+        when '.css' then 'text/css'
+        when '.map' then 'application/json'
+        else
+          ::Rack::Mime.mime_type(::File.extname(path_to_build), nil) || 'application/javascript'
+        end
+      end
+
+      def render_response(result)
+        content = result[:response]
+
+        response = Rack::Response.new
+        response['X-Proscenium-Middleware'] = name
+        response.set_header 'SourceMap', "#{@request.path_info}.map"
+        response.content_type = content_type
+        response.etag = result[:content_hash]
+
+        if @request.fresh?(response)
+          response.status = 304
+          response.body = []
+        else
+          response.write content
+        end
+
+        response.finish
+      end
+
+      def name
+        @name ||= self.class.name.split('::').last.downcase
+      end
+    end
+  end
+end

data/lib/proscenium/middleware/chunks.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    class Chunks
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+
+        # Decode and clean the path BEFORE deciding anything about it, then hand that same path
+        # to the file handler. `ActionDispatch::FileHandler` normalises `PATH_INFO` itself before
+        # it resolves a file, so a guard reading the raw path is not looking at the path that
+        # gets served: `/_asset_chunks/x-$FAKE$/%2e%2e/real-$ABC123$.js` passed both checks and
+        # then served `real-$ABC123$.js` tagged `FAKE`, and `x-$FAKE$/../../lib/foo.js` left the
+        # chunk directory altogether, since the handler's root is the whole output directory.
+        # Both under `immutable, max-age=100.years`, so a wrong ETag is not something a client
+        # can clear.
+        #
+        # The path also has to yield a content hash, not just match the prefix - `CHUNKS_PATH`
+        # checks only the latter, and `/_asset_chunks/nohash.js` used to index the nil match and
+        # return a 500 from here.
+        #
+        # FileHandler decodes `PATH_INFO` again, and that cannot be switched off, so a path still
+        # holding a `%` after the first decode is refused: the handler would resolve it to a
+        # different file than the one checked here. esbuild never puts a `%` in a chunk name.
+        return @app.call(env) unless (path = Middleware.normalise_path(request.path)) &&
+                                     !path.include?('%') &&
+                                     path.match?(CHUNKS_PATH) &&
+                                     (etag = path[/-\$([a-z0-9]+)\$/i, 1])
+
+        ActionDispatch::FileHandler.new(
+          Proscenium.config.output_path.to_s,
+          headers: {
+            'X-Proscenium-Middleware' => 'chunks',
+            'SourceMap' => "#{path}.map",
+            'Cache-Control' => "public, max-age=#{100.years}, immutable",
+            'ETag' => etag
+          }
+        ).attempt(env.merge('PATH_INFO' => path)) || @app.call(env)
+      end
+    end
+  end
+end

data/lib/proscenium/middleware/esbuild.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    class Esbuild < Base
+      def attempt
+        render_response Builder.build_to_string(path_to_build)
+      end
+    end
+  end
+end

data/lib/proscenium/middleware/ruby_gems.rb

@@ -0,0 +1,37 @@
+# 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
+
+      # An unknown gem is "not mine", the same answer a missing file under an app path gets from
+      # `Base#file_readable?`. Without this, `pathname_for!` raised out of the readability probe
+      # and a request for a gem that is not in the Gemfile 500'd, while the sibling app-path
+      # branch quietly passed the same shape of miss down the stack.
+      def renderable?
+        BundledGems.pathname_for(gem_name) && super
+      end
+
+      def root_for_readable
+        BundledGems.pathname_for!(gem_name)
+      end
+
+      def gem_name
+        @gem_name ||= gem_request_path.split('/').first
+      end
+
+      # Taken from the normalised path, so the gem name and the suffix describe the file that
+      # will actually be built. Read from the request verbatim, `@rubygems/gem1/../index.js`
+      # named gem1 and a suffix the readability probe then cleaned to `index.js` - approving
+      # `<gem1>/index.js` while the builder resolved `../index.js` and served the file BESIDE
+      # the gem root. Normalised, it names a gem called `index.js`, which is not bundled, so
+      # the request passes through.
+      def gem_request_path
+        @gem_request_path ||= normalised_path.delete_prefix('/node_modules/@rubygems/')
+      end
+    end
+  end
+end

data/lib/proscenium/middleware/silence_request.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'active_support/logger_silence'
+
+module Proscenium
+  class Middleware::SilenceRequest
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+
+      if (request.get? || request.head?) && proscenium_request?(request)
+        Rails.logger.silence { @app.call(env) }
+      else
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def proscenium_request?(request)
+      return true if request.path.match?(CHUNKS_PATH)
+
+      pathname = Pathname.new(request.path)
+      pathname.fnmatch?(GEMS_PATH_GLOB, File::FNM_EXTGLOB) ||
+        pathname.fnmatch?(APP_PATH_GLOB, File::FNM_EXTGLOB)
+    end
+  end
+end

data/lib/proscenium/middleware/vendor.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    class Vendor
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        request = ActionDispatch::Request.new(env)
+        pathname = Pathname.new(request.path)
+
+        return @app.call(env) unless pathname.fnmatch?(VENDOR_PATH_GLOB, File::FNM_EXTGLOB)
+
+        # The prefix strip is an argument to the file lookup, not a rewrite of the request. It used
+        # to assign `request.path_info`, which writes `env['PATH_INFO']` - the same hash handed to
+        # `@app.call` on a miss - so `/vendor/lib/foo.js` with nothing under `vendor/` continued
+        # down the stack as `/lib/foo.js`, matched `APP_PATH_GLOB`, and was built and served from
+        # the app root under the URL the client had actually asked for.
+        ActionDispatch::FileHandler.new(
+          Rails.root.join('vendor').to_s,
+          headers: {
+            'X-Proscenium-Middleware' => 'vendor',
+            'Cache-Control' => "public, max-age=#{100.years}, immutable"
+          }
+        ).attempt(env.merge('PATH_INFO' => request.path.delete_prefix('/vendor'))) || @app.call(env)
+      end
+    end
+  end
+end

data/lib/proscenium/middleware.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    extend ActiveSupport::Autoload
+
+    class BuildError < Error; end
+
+    autoload :Base
+    autoload :Esbuild
+    autoload :RubyGems
+    autoload :Vendor
+    autoload :Chunks
+    autoload :SilenceRequest
+
+    # The given request path, percent-decoded and with `.` and `..` segments resolved. Nil for a
+    # path Rack rejects outright, such as one containing a null byte.
+    #
+    # Every decision and every derived path in this subsystem is taken from this one form. The
+    # alternative was three derivations from the raw path that disagreed: `find_type` matched the
+    # allowed-directory glob against the request verbatim, `Base#file_readable?` normalised before
+    # probing the disk, and `Base#path_to_build` kept the request verbatim again - so a request
+    # could be routed by a directory it does not resolve to, approved against one file, and built
+    # as a third.
+    def self.normalise_path(path)
+      unescaped = Rack::Utils.unescape_path(path.chomp('/').delete_prefix('/'))
+      return unless Rack::Utils.valid_path?(unescaped)
+
+      "/#{Rack::Utils.clean_path_info(unescaped)}"
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = ActionDispatch::Request.new(env)
+
+      return @app.call(env) if !request.get? && !request.head?
+
+      attempt(request) || @app.call(env)
+    end
+
+    private
+
+    def attempt(request)
+      return unless (type = find_type(request))
+
+      type.attempt(request)
+    end
+
+    def find_type(request)
+      # Matched against the normalised path, not the request, or the allowed-directory list is
+      # bypassable: `/lib/../public/x.js` matches `APP_PATH_GLOB` as written and resolves to
+      # `public/`, which is not an allowed directory - and it was built and served from there.
+      return unless (path = Middleware.normalise_path(request.path))
+
+      pathname = Pathname.new(path)
+
+      if pathname.fnmatch?(GEMS_PATH_GLOB, File::FNM_EXTGLOB)
+        RubyGems
+      elsif pathname.fnmatch?(APP_PATH_GLOB, File::FNM_EXTGLOB)
+        Esbuild
+      end
+    end
+  end
+end

data/lib/proscenium/monkey.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Monkey
+    # A template ActionView pushes onto `@current_template` is not the body of a partial rendered
+    # with a block, so `Helper#sideload_assets` must not see that partial while one renders. Rails
+    # caches template objects, so the pushed template can be the very one that rendered the partial.
+    #
+    # Overrides ActionView's private `ActionView::Base#_run(method, template, locals, buffer,
+    # add_to_stack: true, ...)`, unchanged from Rails 7.2 to 8.1. `@proscenium_block_partial` is
+    # set by `Helper#proscenium_render_block_partial`. Every template render runs through here, so
+    # arguments are forwarded with `...`, which allocates nothing. Reading `add_to_stack` does
+    # allocate, so it is only read while a block partial is rendering.
+    module Base
+      def _run(...)
+        return super unless @proscenium_block_partial && proscenium_pushes_template?(...)
+
+        owner = @proscenium_block_partial
+        @proscenium_block_partial = nil
+        super
+      ensure
+        @proscenium_block_partial = owner if owner
+      end
+
+      private
+
+      def proscenium_pushes_template?(*, add_to_stack: true, **) = add_to_stack
+    end
+
+    module TemplateRenderer
+      private
+
+      def render_template(view, template, layout_name, locals)
+        return super unless SideLoad.sideloadable?(view, template)
+
+        layout = find_layout(layout_name, locals.keys, [formats.first])
+        SideLoad.sideload_templates(view, [layout, template]) { super }
+      end
+    end
+
+    module PartialRenderer
+      private
+
+      def render_partial_template(view, locals, template, layout, block)
+        return super unless SideLoad.sideloadable?(view, template)
+
+        SideLoad.sideload_templates(view, [layout, template]) do
+          # A view rendered before Proscenium::Helper is included cannot call `sideload_assets`.
+          if block && view.respond_to?(:proscenium_render_block_partial)
+            view.proscenium_render_block_partial(template, block) do |wrapped|
+              super(view, locals, template, layout, wrapped)
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+
+    # A collection renders each item with `Template#render`, so never reaches
+    # `PartialRenderer#render_partial_template`. Hooked above the collection cache, which skips
+    # rendering entirely on a full hit. A mixed collection has no single template, and is not side
+    # loaded.
+    module CollectionRenderer
+      private
+
+      # `args` is `path, template, layout, block`. `collection` is ActionView's CollectionIterator,
+      # which has `length` but no `empty?`.
+      def render_collection(collection, view, *args)
+        _path, template, layout, = args
+        return super unless collection.length.positive? && SideLoad.sideloadable?(view, template)
+
+        SideLoad.sideload_templates(view, [layout, template]) { super }
+      end
+    end
+  end
+end

data/lib/proscenium/railtie.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+ENV['RAILS_ENV'] = Rails.env
+
+module Proscenium
+  class Railtie < ::Rails::Engine
+    isolate_namespace Proscenium
+
+    config.proscenium = ActiveSupport::OrderedOptions.new
+    config.proscenium.debug = false
+    config.proscenium.logging = true
+    config.proscenium.bundle = true
+    config.proscenium.side_load = true
+    config.proscenium.code_splitting = true
+    config.proscenium.ensure_loaded = :raise
+    config.proscenium.aliases = {}
+    config.proscenium.external = Set['*.rjs', '*.gif', '*.jpg', '*.png', '*.woff2', '*.woff']
+    config.proscenium.precompile = Set.new
+    config.proscenium.output_dir = '/assets'
+
+    # 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
+
+    config.action_dispatch.rescue_templates = {
+      'Proscenium::Builder::BuildError' => 'build_error'
+    }
+
+    config.after_initialize do |app|
+      config.proscenium.output_path ||=
+        Pathname.new(File.join(app.config.paths['public'].first, app.config.proscenium.output_dir))
+      config.proscenium.manifest_path = config.proscenium.output_path.join('.manifest.json')
+
+      Proscenium::Manifest.load!
+
+      project = Proscenium::ContextMap.project_root
+      if (notice = Proscenium::ContextMap.adoption_notice(project))
+        Rails.logger.info "[Proscenium] #{notice}"
+      end
+      # Production finds stale contexts at assets:precompile, which refuses to compile. Elsewhere
+      # the first mapping generation starts here, so a change after boot, such as running
+      # `proscenium install`, starts the next one. No Go call: Puma may fork after boot.
+      unless Rails.env.production?
+        generation, = Proscenium::MappingGeneration.refresh(project)
+        if (stale = Proscenium::StaleContexts.message(project, generation))
+          Rails.logger.warn "[Proscenium] #{stale}"
+        end
+      end
+
+      if config.proscenium.logging
+        require 'proscenium/log_subscriber'
+        Proscenium::LogSubscriber.attach_to :proscenium
+      end
+
+      ActiveSupport.on_load(:action_view) do
+        include Proscenium::Helper
+      end
+    end
+
+    initializer 'proscenium.debugging' do
+      tpl_path = root.join('lib', 'proscenium', 'templates').to_s
+      ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS << tpl_path
+    end
+
+    initializer 'proscenium.middleware' do |app|
+      unless config.proscenium.logging
+        app.middleware.insert_before Rails::Rack::Logger, Proscenium::Middleware::SilenceRequest
+      end
+
+      app.middleware.insert_after Rack::Sendfile, Proscenium::Middleware::Vendor
+      app.middleware.insert_after Rack::Sendfile, Proscenium::Middleware::Chunks
+
+      # Ensure the middleware is inserted as early as possible.
+      if app.config.consider_all_requests_local
+        app.middleware.insert_before ActionDispatch::ActionableExceptions, Proscenium::Middleware
+      elsif app.config.reloading_enabled?
+        app.middleware.insert_before ActionDispatch::Reloader, Proscenium::Middleware
+      else
+        app.middleware.insert_before ActionDispatch::Callbacks, Proscenium::Middleware
+      end
+    end
+
+    initializer 'proscenium.sideloading' do
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.include EnsureLoaded
+        ActionController::Base.include SideLoad::Controller
+      end
+    end
+
+    initializer 'proscenium.monkey_patches' do
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Base.prepend Monkey::Base
+        ActionView::TemplateRenderer.prepend Monkey::TemplateRenderer
+        ActionView::PartialRenderer.prepend Monkey::PartialRenderer
+        ActionView::CollectionRenderer.prepend Monkey::CollectionRenderer
+      end
+    end
+
+    rake_tasks do
+      load 'proscenium/railties/assets.rake'
+    end
+  end
+end

data/lib/proscenium/railties/assets.rake

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+namespace :assets do
+  desc 'Compile Proscenium assets'
+  task precompile: :environment do
+    puts "\nPre-compiling assets..."
+
+    # Raises Proscenium::Builder::CompileError, with esbuild's messages, when the build fails.
+    Proscenium::Builder.compile
+
+    puts "\nAssets pre-compiled successfully."
+
+    if Rails.env.development?
+      puts "\nWarning: You are precompiling assets in development. Rails will not " \
+           'serve any changed assets until you delete ' \
+           "public#{Rails.application.config.proscenium.output_dir}/.manifest.json"
+    end
+  end
+end

data/lib/proscenium/resolver.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Resolver
+    mattr_accessor :resolved, instance_accessor: false, default: {}
+
+    # Resolve the given `path` to a fully qualified URL path.
+    #
+    # @param path [String] URL path, file system path, or bare specifier (ie. NPM package).
+    # @param as_array [Boolean] whether or not to return the manifest path, non-manifest path, and
+    #   absolute file system path as an array. Only returns the resolved path if false (default).
+    # @return [String, Array<String>]
+    def self.resolve(path, as_array: false)
+      # Normalised before anything reads it, the guard and the cache key included. The bun test
+      # harness hands this Bun's own spelling of a module path, which on Windows is `D:\...`;
+      # matched against a slash-form Rails.root it fell through to the Go resolver and came back
+      # as the url path unchanged - a backslash path the harness then refused to build.
+      path = Utils.fs_path(path)
+
+      if path.start_with?('./', '../')
+        raise ArgumentError, '`path` must be an absolute file system or URL path'
+      end
+
+      # A new mapping generation forgets cached resolutions (#154): polled here too, so a path
+      # resolved before an install does not keep its old URL when no Builder is made after it.
+      generation
+
+      # Caches the manifest key, not its value, so a manifest loaded or reset later is still
+      # honoured. Every string is frozen: the URL path is handed back to callers, and in the
+      # Rails.root branch it is the key itself, so mutating it would redirect later lookups.
+      key, url_path, abs_path = resolved[path] ||= entry_for(path).map(&:-@).freeze
+      manifest_path = Proscenium::Manifest[key]
+
+      as_array ? [manifest_path, url_path, abs_path] : manifest_path || url_path
+    end
+
+    # The manifest key, URL path and absolute file system path for `path`. In the gem branch the
+    # key differs from the URL path, so it is kept rather than derived.
+    def self.entry_for(path)
+      if (vpath = BundledGems.virtual_path(path))
+        [vpath, "/node_modules/#{vpath}", path]
+      elsif path.start_with?("#{Rails.root}/")
+        vpath = path.delete_prefix(Rails.root.to_s)
+        [vpath, vpath, path]
+      else
+        [path, *Builder.resolve(path)]
+      end
+    end
+    private_class_method :entry_for
+
+    # The mapping generation builds and resolutions use now (#154). Development and test start a
+    # new one when the files the context map is built from change, and forget resolved paths with
+    # it; production keeps one for the process. Here rather than on Builder, which loads the Go
+    # library when first referenced, so resolving a path never needs it.
+    def self.generation
+      return 0 if Rails.env.production?
+
+      number, changed = MappingGeneration.refresh(ContextMap.project_root)
+      reset if changed
+      number
+    end
+
+    def self.reset
+      self.resolved = {}
+    end
+  end
+end