proscenium 0.26.0-aarch64-linux-gnu

data/lib/proscenium/dependency_context.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+
+module Proscenium
+  # A participating gem's dependency context (#154): its package.json through the
+  # `dependency-context-v1` projection, which keeps installation metadata only and is committed at
+  # `.proscenium/packages/<gem>/package.json`.
+  #
+  # The one owner of the projection and its hash, shared by the CLI and the engine, so it must not
+  # load ActiveSupport or anything else the CLI may not.
+  module DependencyContext
+    PROJECTION = 'dependency-context-v1'
+
+    # The manifest fields a context keeps, in the order it writes them. Everything else (scripts,
+    # devDependencies, version, entry points, workspaces) is left in the gem's own package.json.
+    FIELDS = %w[dependencies peerDependencies peerDependenciesMeta optionalDependencies engines os
+                cpu libc].freeze
+
+    module_function
+
+    def name_for(gem) = "@rubygems/#{gem}"
+
+    def description_for(gem)
+      "Generated by Proscenium from the #{gem} gem. Do not edit; " \
+        'run bundle exec proscenium install.'
+    end
+
+    # The context for `gem` from its parsed `manifest`. An empty field is left out, as an absent
+    # one is: the two install the same, so they hash the same.
+    def project(gem, manifest)
+      fields = FIELDS.each_with_object({}) do |key, kept|
+        value = manifest[key]
+        kept[key] = value unless value.nil? || (value.respond_to?(:empty?) && value.empty?)
+      end
+
+      { 'name' => name_for(gem), 'private' => true, 'description' => description_for(gem),
+        **fields,
+        'proscenium' => { 'projection' => PROJECTION, 'projectionSha256' => digest(gem, fields) } }
+    end
+
+    # The bytes committed for a context: fixed key order, two-space indent, a trailing newline, and
+    # nothing that varies by host or time.
+    def to_json(context) = "#{JSON.pretty_generate(context)}\n"
+
+    # The projection hash. It hashes a fixed-field encoding of the projected fields, not JSON, so
+    # it does not move with the json gem's output, key order, whitespace or escaping, and an edit
+    # to anything the projection drops leaves it alone.
+    def digest(gem, fields)
+      Digest::SHA256.hexdigest("#{PROJECTION}\n#{encode(name_for(gem))}#{encode(fields)}")
+    end
+
+    # A self-delimiting encoding: a type tag, a length where there is one, then the value. Hash
+    # keys are sorted by their bytes, so key order in the manifest does not matter; array order
+    # does, as it does to npm.
+    def encode(value)
+      case value
+      when String then "s#{value.bytesize}:#{value.b}"
+      when true then 't'
+      when false then 'f'
+      when nil then 'n'
+      when Integer then "i#{value};"
+      when Float then "d#{value};"
+      when Array then "a#{value.size}:#{value.map { encode(it) }.join}"
+      when Hash
+        pairs = value.sort_by { |key, _| key.to_s.b }
+        "h#{value.size}:#{pairs.map { |key, val| encode(key.to_s) + encode(val) }.join}"
+      else
+        raise ArgumentError, "cannot encode #{value.class} in a dependency context"
+      end
+    end
+  end
+end

data/lib/proscenium/ensure_loaded.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Proscenium
+  NotIncludedError = Class.new(Error) # rubocop:disable Style/EmptyClassDefinition
+
+  module EnsureLoaded
+    def self.included(child)
+      child.class_eval do
+        append_after_action do
+          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 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
+      end
+    end
+  end
+end

data/lib/proscenium/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Proscenium
+  # The base of every error Proscenium raises.
+  #
+  # In a file of its own so that lib/proscenium/builder.rb can load without the rest of the gem:
+  # the release workflow loads the compiled library from an installed gem to prove it works, with
+  # no Rails app and no Rails, and builder.rb subclasses this at class-definition time.
+  class Error < StandardError; end
+end

data/lib/proscenium/ext/proscenium.h

@@ -0,0 +1,113 @@
+/* Code generated by cmd/cgo; DO NOT EDIT. */
+
+/* package joelmoss/proscenium */
+
+
+#line 1 "cgo-builtin-export-prolog"
+
+#include <stddef.h>
+
+#ifndef GO_CGO_EXPORT_PROLOGUE_H
+#define GO_CGO_EXPORT_PROLOGUE_H
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef struct { const char *p; ptrdiff_t n; } _GoString_;
+extern size_t _GoStringLen(_GoString_ s);
+extern const char *_GoStringPtr(_GoString_ s);
+#endif
+
+#endif
+
+/* Start of preamble from import "C" comments.  */
+
+
+#line 3 "main.go"
+
+#include <stdlib.h>
+
+struct Result {
+	int success;
+	char* response;
+	char* contentHash;
+	};
+struct ResolveResult {
+	int success;
+	char* urlPath;
+	char* absPath;
+};
+struct CompileResult {
+	int success;
+	char* messages;
+};
+
+#line 1 "cgo-generated-wrapper"
+
+
+/* End of preamble from import "C" comments.  */
+
+
+/* Start of boilerplate cgo prologue.  */
+#line 1 "cgo-gcc-export-header-prolog"
+
+#ifndef GO_CGO_PROLOGUE_H
+#define GO_CGO_PROLOGUE_H
+
+typedef signed char GoInt8;
+typedef unsigned char GoUint8;
+typedef short GoInt16;
+typedef unsigned short GoUint16;
+typedef int GoInt32;
+typedef unsigned int GoUint32;
+typedef long long GoInt64;
+typedef unsigned long long GoUint64;
+typedef GoInt64 GoInt;
+typedef GoUint64 GoUint;
+typedef size_t GoUintptr;
+typedef float GoFloat32;
+typedef double GoFloat64;
+#ifdef _MSC_VER
+#if !defined(__cplusplus) || _MSVC_LANG <= 201402L
+#include <complex.h>
+typedef _Fcomplex GoComplex64;
+typedef _Dcomplex GoComplex128;
+#else
+#include <complex>
+typedef std::complex<float> GoComplex64;
+typedef std::complex<double> GoComplex128;
+#endif
+#else
+typedef float _Complex GoComplex64;
+typedef double _Complex GoComplex128;
+#endif
+
+/*
+  static assertion to make sure the file is being used on architecture
+  at least with matching size of GoInt.
+*/
+typedef char _check_for_64_bit_pointer_matching_GoInt[sizeof(void*)==64/8 ? 1:-1];
+
+#ifndef GO_CGO_GOSTRING_TYPEDEF
+typedef _GoString_ GoString;
+#endif
+typedef void *GoMap;
+typedef void *GoChan;
+typedef struct { void *t; void *v; } GoInterface;
+typedef struct { void *data; GoInt len; GoInt cap; } GoSlice;
+
+#endif
+
+/* End of boilerplate cgo prologue.  */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern void reset_config(void);
+extern void free_cstr(char* ptr);
+extern struct Result build_to_string(char* filePath, char* configJson);
+extern struct ResolveResult resolve(char* filePath, char* configJson);
+extern struct CompileResult compile(char* configJson);
+
+#ifdef __cplusplus
+}
+#endif

data/lib/proscenium/helper.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Helper
+    # Sets the side load options of the template being rendered, for this render only. They are
+    # kept on the view, which lives for one request, keyed by template, because the template
+    # object itself is cached and shared by every request. `SideLoad.sideload_templates` scopes
+    # each value to the render that set it.
+    #
+    # Call it outside any `cache` block: a cache hit skips the block, and this call with it.
+    def sideload_assets(value)
+      # ActionView does not push a partial rendered with a block onto `@current_template`, so while
+      # its body renders, `@current_template` is still the calling template.
+      identifier = (@proscenium_block_partial || @current_template).identifier
+
+      if value.nil?
+        proscenium_sideload_assets_options.delete identifier
+      else
+        proscenium_sideload_assets_options[identifier] = value
+      end
+    end
+
+    # Renders a partial given `block`, and yields the block to render it with. While the partial's
+    # body renders, `sideload_assets` applies to the partial. While the block runs, wherever it is
+    # run from, it applies to the template that passed the block. Any template rendered from
+    # either pushes itself onto `@current_template`, and `Monkey::Base` clears this while it does.
+    def proscenium_render_block_partial(partial, block)
+      previous = @proscenium_block_partial
+      calling_template = previous || @current_template
+      @proscenium_block_partial = partial
+
+      yield(proc do |*args|
+        current = @proscenium_block_partial
+        @proscenium_block_partial = calling_template
+        block.call(*args)
+      ensure
+        @proscenium_block_partial = current
+      end)
+    ensure
+      @proscenium_block_partial = previous
+    end
+
+    # @return [Hash] the `sideload_assets` value of each template in this render, by identifier.
+    def proscenium_sideload_assets_options
+      @proscenium_sideload_assets_options ||= {}
+    end
+
+    def compute_asset_path(path, options = {})
+      if %i[javascript stylesheet].include?(options[:type])
+        return Proscenium::Manifest[path] || "/#{path}"
+      end
+
+      super
+    end
+
+    # Accepts one or more CSS class names, and transforms them into CSS module names.
+    #
+    # @see CssModule::Transformer#class_names
+    # @param names [String,Symbol,nil,false,Array<String,Symbol,nil,false>]
+    # @param path [Pathname] the path to the CSS module file to use for the transformation.
+    # @return [String] the transformed CSS module names concatenated as a string.
+    def css_module(*names, path: nil)
+      path ||= Pathname.new(@lookup_context.find(@virtual_path).identifier).sub_ext('')
+      CssModule::Transformer.new(path).class_names(*names, require_prefix: false).join(' ')
+    end
+
+    def include_assets
+      include_stylesheets + include_javascripts
+    end
+
+    def include_stylesheets
+      SideLoad::CSS_COMMENT.html_safe
+    end
+
+    # Includes all javascripts that have been imported and side loaded.
+    #
+    # @return [String] the HTML tags for the javascripts.
+    def include_javascripts
+      SideLoad::JS_COMMENT.html_safe
+    end
+  end
+end

data/lib/proscenium/importer.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'active_support/current_attributes'
+require 'concurrent/map'
+
+module Proscenium
+  class Importer < ActiveSupport::CurrentAttributes
+    JS_EXTENSIONS = %w[.tsx .ts .jsx .js].freeze
+    CSS_EXTENSIONS = %w[.module.css .css].freeze
+
+    # The readable suffix of a CSS module class name, by absolute path - or by URL, for a remote
+    # module, which has no file. It is a pure function of that identity, but `import` runs once per
+    # class name a view emits and `relative_path_from` is most of its cost, so it is built once per
+    # file for the life of the process.
+    SUFFIXES = Concurrent::Map.new
+
+    # Holds the JS and CSS files to include in the current request.
+    #
+    # Example:
+    #   {
+    #     '/path/to/input/file.js': {
+    #       output: '/path/to/compiled/file.js',
+    #       **options
+    #     }
+    #   }
+    attribute :imported
+
+    class << self
+      # Import the given `filepath`. This is idempotent - it will never include duplicates.
+      #
+      # @param filepath [String] Absolute URL path (relative to Rails root) of the file to import,
+      #   or a URL, which has no file on disk. Should be the actual asset file, eg. app.css,
+      #   some/component.js.
+      # @return [String|nil] the digest of the imported file path if a css module (*.module.css).
+      def import(filepath = nil, sideloaded: false, **)
+        self.imported ||= {}
+
+        if filepath.end_with?('.module.css')
+          manifest_path, non_manifest_path, abs_path = Resolver.resolve(filepath, as_array: true)
+          filepath = Array(manifest_path || non_manifest_path)[0]
+
+          # A URL has no file on disk, so the URL is the module's identity. Taken after the
+          # reassignment above, so the digest and the suffix cache below agree on it. An entry the
+          # stylesheet got as a plain file has no digest of its own.
+          digest = imported.dig(filepath, :digest) ||
+                   Utils.css_module_digest(abs_path.presence || filepath)
+          store(filepath, sideloaded, **, digest:)
+
+          transformed_path = ''
+          # Mirrors ConfigT#ShouldMinify - the suffix exists whenever identifiers are not
+          # minified, and a class name the stylesheet does not define is worse than a long one.
+          if Proscenium.config.debug || !Rails.env.production?
+            # Keyed and built from the file's path under the app, or from the URL when there is
+            # no file: `Pathname.new('').relative_path_from(Rails.root)` raises.
+            identity = abs_path.presence || filepath
+            transformed_path = SUFFIXES.compute_if_absent(identity) do
+              relative = if abs_path.present?
+                           Utils.css_module_relative_path(abs_path)
+                         else
+                           identity
+                         end
+
+              "_#{Utils.css_module_suffix(relative)}"
+            end
+          end
+
+          "#{digest}#{transformed_path}"
+        else
+          Array(Resolver.resolve(filepath)).each { |fp| store(fp, sideloaded, **) }
+        end
+      end
+
+      # Sideloads JS and CSS assets for the given Ruby filepath.
+      #
+      # Any files with the same base name and matching a supported extension will be sideloaded.
+      # Only one JS and one CSS file will be sideloaded, with the first match used in the following
+      # order:
+      #  - JS extensions: .tsx, .ts, .jsx, and .js.
+      #  - CSS extensions: .css.module, and .css.
+      #
+      # Example:
+      #  - `app/views/layouts/application.rb`
+      #  - `app/views/layouts/application.css`
+      #  - `app/views/layouts/application.js`
+      #  - `app/views/layouts/application.tsx`
+      #
+      # A request to sideload `app/views/layouts/application.rb` will result in `application.css`
+      # and `application.tsx` being sideloaded. `application.js` will not be sideloaded because the
+      # `.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)
+
+        sideload_js(filepath, **options) unless options[:js] == false
+        sideload_css(filepath, **options) unless options[:css] == false
+      end
+
+      def sideload_js(filepath, **)
+        _sideload(filepath, JS_EXTENSIONS, **)
+      end
+
+      def sideload_css(filepath, **)
+        _sideload(filepath, ['.css'], **)
+      end
+
+      def sideload_css_module(filepath, **)
+        _sideload(filepath, ['.module.css'], **)
+      end
+
+      # @param filepath [Pathname] Absolute file system path of the Ruby file to sideload.
+      # @param extensions [Array<String>] Supported file extensions to sideload.
+      # @raise [ArgumentError] if `filepath` is not an absolute file system path.
+      private def _sideload(filepath, extensions, **) # rubocop:disable Style/AccessModifierDeclarations
+        return unless Proscenium.config.side_load
+
+        if !filepath.is_a?(Pathname) || !filepath.absolute?
+          raise ArgumentError, "`filepath` (#{filepath}) must be a `Pathname`, and an absolute path"
+        end
+
+        # Ensures extensions with more than one dot are handled correctly.
+        filepath = filepath.sub_ext('').sub_ext('')
+
+        extensions.find do |x|
+          next unless (fp = filepath.sub_ext(x)).exist?
+
+          import(fp.to_s, sideloaded: filepath, **)
+        end
+      end
+
+      def each_stylesheet(delete: false)
+        return if imported.blank?
+
+        blk = proc do |key, options|
+          if key.end_with?(*CSS_EXTENSIONS)
+            yield(key, options)
+            true
+          end
+        end
+
+        delete ? imported.delete_if(&blk) : imported.each(&blk)
+      end
+
+      def each_javascript(delete: false)
+        return if imported.blank?
+
+        blk = proc do |key, options|
+          if key.end_with?(*JS_EXTENSIONS)
+            yield(key, options)
+            true
+          end
+        end
+        delete ? imported.delete_if(&blk) : imported.each(&blk)
+      end
+
+      def css_imported?
+        imported&.keys&.any? { |x| x.end_with?(*CSS_EXTENSIONS) }
+      end
+
+      def js_imported?
+        imported&.keys&.any? { |x| x.end_with?(*JS_EXTENSIONS) }
+      end
+
+      def imported?(filepath = nil)
+        filepath ? imported&.key?(filepath) : !imported.blank?
+      end
+
+      private
+
+      # Keyed by the resolved path, never the path given: a sideload passes an absolute file
+      # system path. A repeat import merges its options in, later ones winning key by key, and does
+      # not notify again; proscenium-ui's Select sideloads itself `lazy: true` over an eager
+      # sideload of the same file.
+      def store(key, sideloaded, **options)
+        if (existing = imported[key])
+          existing.merge!(options)
+        elsif sideloaded
+          ActiveSupport::Notifications.instrument 'sideload.proscenium', identifier: key,
+                                                                         sideloaded: do
+            imported[key] = options
+          end
+        else
+          imported[key] = options
+        end
+      end
+    end
+  end
+end

data/lib/proscenium/log_subscriber.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support/log_subscriber'
+
+module Proscenium
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def sideload(event)
+      path = event.payload[:identifier]
+      sideloaded = event.payload[:sideloaded]
+      sideloaded = sideloaded.relative_path_from(Rails.root) if sideloaded.is_a?(Pathname)
+
+      info do
+        msg = "  #{color('[Proscenium]', nil, bold: true)} Sideloading #{path}"
+        sideloaded.is_a?(Pathname) ? msg << " from #{sideloaded}" : msg
+      end
+    end
+
+    def build(event)
+      path = event.payload[:identifier]
+      path = CGI.unescape(path) if path.start_with?(/https?%3A%2F%2F/)
+
+      info do
+        message = "  #{color('[Proscenium]', nil, bold: true)} Building /#{path}"
+        message << " (Duration: #{event.duration.round(1)}ms | Allocations: #{event.allocations})"
+      end
+    end
+
+    def resolve(event)
+      path = event.payload[:identifier]
+      path = CGI.unescape(path) if path.start_with?(/https?%3A%2F%2F/)
+
+      info do
+        message = "  #{color('[Proscenium]', nil, bold: true)} Resolving #{path}"
+        message << " (Duration: #{event.duration.round(1)}ms | Allocations: #{event.allocations})"
+      end
+    end
+  end
+end

data/lib/proscenium/manifest.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Manifest
+    mattr_accessor :manifest, default: {}
+
+    module_function
+
+    # Built aside and assigned once, so a resolve during a load never sees a half-built manifest,
+    # and a manifest that fails to parse leaves the previous one in place.
+    def load!
+      public_path = Rails.configuration.paths['public'].first
+      entries = {}
+
+      if Proscenium.config.manifest_path.exist?
+        JSON.parse(Proscenium.config.manifest_path.read)['outputs'].each do |outpath, details|
+          next if !details.key?('entryPoint')
+
+          outpath = fs_path(outpath).delete_prefix "#{public_path}/"
+
+          ep = fs_path(details['entryPoint'])
+          ep = BundledGems.virtual_path(ep) || ep.delete_prefix(Rails.root.to_s)
+
+          entries[ep] = [
+            "/#{outpath}",
+            details['cssBundle'] && fs_path(details['cssBundle']).delete_prefix(public_path)
+          ].compact
+        end
+      end
+
+      self.manifest = entries
+    end
+
+    # esbuild records absolute paths in the metafile in the form the platform produced. Left in
+    # Windows form, every delete_prefix above failed, the manifest was keyed by full Windows
+    # paths, and every lookup missed: the app served source paths instead of the digest URLs it
+    # had just compiled, silently.
+    def fs_path(path) = Utils.fs_path(path)
+
+    # Empty, not nil or a lazy re-read: the runtime daemon relies on a reset manifest staying
+    # empty until `load!`.
+    def reset!
+      self.manifest = {}
+    end
+
+    def [](key) = manifest[key]
+  end
+end

data/lib/proscenium/mapping_generation.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'bundled_gems'
+require_relative 'context_map'
+require_relative 'stale_contexts'
+
+module Proscenium
+  # Which mapping generation a build uses (#154). A generation is the context map and the
+  # staleness verdict, read once and kept, so every build sees one consistent view. In production
+  # a generation lasts the process: restart after a deploy. In development and test, `refresh`
+  # looks at most once a second for a change to the files the map is built from, and starts a new
+  # generation when one changed, such as `proscenium install` finishing.
+  #
+  # Gemfile.lock is watched, but a gem added or upgraded still needs a restart: Bundler loads the
+  # bundle once per process.
+  module MappingGeneration
+    # The lockfiles too: with contexts adopted, resolved paths carry each package's version.
+    WATCHED = ['Gemfile.lock', 'package.json', 'pnpm-workspace.yaml', '.npmrc',
+               'bunfig.toml', 'pnpm-lock.yaml', 'bun.lock', ContextMap::INSTALLING].freeze
+    EVERY = 1.0
+    LOCK = Mutex.new
+
+    module_function
+
+    # The current generation number, starting a new one first if a watched file changed and the
+    # last look was at least `every` seconds ago. Returns [number, whether it just changed].
+    def refresh(root, every: EVERY)
+      now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      LOCK.synchronize do
+        @looked ||= {}
+        @number ||= 0
+        at, before = @looked[root]
+        return [@number, false] if at && now - at < every
+
+        after = signature(root)
+        @looked[root] = [now, after]
+        return [@number, false] if before.nil? || before == after
+
+        ContextMap.reset!
+        StaleContexts.reset!
+        [@number += 1, true]
+      end
+    end
+
+    # The modification time of every file the map is built from, by path, nil for a missing one.
+    def signature(root)
+      files = WATCHED.map { File.join(root, it) } +
+              Dir.glob(File.join(root, ContextMap::CONTEXTS, '*', 'package.json')) +
+              manifests(root)
+      files.sort.to_h { [it, File.exist?(it) ? File.mtime(it).to_f : nil] }
+    end
+
+    # Each participating gem's package.json: editing a path gem's manifest makes its context stale.
+    def manifests(root)
+      BundledGems.participating(BundledGems.installed_specs, overrides: BundledGems.overrides(root))
+                 .values.filter_map { BundledGems.manifest_root(it) }
+                 .map { File.join(it, 'package.json') }
+    rescue BundledGems::ConfigError
+      []
+    end
+
+    def reset! = LOCK.synchronize { @looked = {} }
+  end
+end