proscenium 0.16.0

data/lib/proscenium/builder.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'oj'
+
+module Proscenium
+  class Builder
+    class CompileError < StandardError; end
+
+    class Result < FFI::Struct
+      layout :success, :bool,
+             :response, :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?
+      ], 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?
+      ], Result.by_value
+    end
+
+    class BuildError < StandardError
+      attr_reader :error
+
+      def initialize(error)
+        @error = Oj.load(error, mode: :strict).deep_transform_keys(&:underscore)
+
+        msg = @error['text']
+        if (location = @error['location'])
+          msg << " at #{location['file']}:#{location['line']}:#{location['column']}"
+        end
+
+        super(msg)
+      end
+    end
+
+    class ResolveError < StandardError
+      attr_reader :error_msg, :path
+
+      def initialize(path, error_msg)
+        super("Failed to resolve '#{path}' -- #{error_msg}")
+      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)
+    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
+    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
+    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)
+
+        raise BuildError, result[:response] unless result[:success]
+
+        result[:response]
+      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)
+        raise ResolveError.new(path, result[:response]) unless result[:success]
+
+        result[:response]
+      end
+    end
+
+    private
+
+    # Build the ENV variables as determined by `Proscenium.config.env_vars` and
+    # `Proscenium::DEFAULT_ENV_VARS` to pass to esbuild.
+    def env_vars
+      ENV['NODE_ENV'] = ENV.fetch('RAILS_ENV', nil)
+      ENV.slice(*Proscenium.config.env_vars + Proscenium::DEFAULT_ENV_VARS)
+    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
+    end
+
+    def gem_root
+      Pathname.new(__dir__).join('..', '..').to_s
+    end
+  end
+end

data/lib/proscenium/core_ext/object/css_module_ivars.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Object
+  def instance_variable_get(name)
+    name.is_a?(::Proscenium::CssModule::Name) ? super(name.to_sym) : super
+  end
+
+  def instance_variable_set(name, obj)
+    name.is_a?(::Proscenium::CssModule::Name) ? super(name.to_sym, obj) : super
+  end
+
+  def instance_variable_defined?(name)
+    name.is_a?(::Proscenium::CssModule::Name) ? super(name.to_sym) : super
+  end
+
+  def remove_instance_variable(name)
+    name.is_a?(::Proscenium::CssModule::Name) ? super(name.to_sym) : super
+  end
+end

data/lib/proscenium/css_module/path.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module CssModule::Path
+    # Returns the path to the CSS module file for this class, where the file is located alongside
+    # the class file, and has the same name as the class file, but with a `.module.css` extension.
+    #
+    # If the CSS module file does not exist, it's ancestry is checked, returning the first that
+    # exists. Then finally `nil` is returned if never found.
+    #
+    # @return [Pathname]
+    def css_module_path
+      return @css_module_path if instance_variable_defined?(:@css_module_path)
+
+      path = source_path.sub_ext('.module.css')
+      @css_module_path = path.exist? ? path : nil
+
+      unless @css_module_path
+        klass = superclass
+
+        while klass.respond_to?(:css_module_path) && !klass.abstract_class
+          break if (@css_module_path = klass.css_module_path)
+
+          klass = klass.superclass
+        end
+      end
+
+      @css_module_path
+    end
+  end
+end

data/lib/proscenium/css_module/rewriter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'ruby-next/language'
+require 'proscenium/core_ext/object/css_module_ivars'
+
+module Proscenium
+  module CssModule
+    class Rewriter < RubyNext::Language::Rewriters::Text
+      NAME = 'proscenium-css-module'
+
+      def rewrite(source)
+        source = source.gsub(/%i\[((@[\w@ ]+)|([\w@ ]+ @[\w@ ]+))\]/) do |_|
+          arr = ::Regexp.last_match(1).split.map do |x|
+            x.start_with?('@') ? css_module_string(x[1..]) : ":#{x}"
+          end
+          "[#{arr.join(',')}]"
+        end
+
+        source.gsub(/:@([\w]+)/) do |_|
+          context.track!(self)
+          css_module_string(::Regexp.last_match(1))
+        end
+      end
+
+      private
+
+      def css_module_string(name)
+        if (path = Pathname.new(context.path).sub_ext('.module.css')).exist?
+          tname = Transformer.new(path).class_name!(name, name.dup).first
+          "Proscenium::CssModule::Name.new(:@#{name}, '#{tname}')"
+        else
+          "Proscenium::CssModule::Name.new(:@#{name}, css_module(:#{name}))"
+        end
+      end
+    end
+  end
+end
+
+RubyNext::Language.send :include_patterns=, []
+RubyNext::Language.include_patterns << "#{Rails.root.join('app', 'components')}/*.rb"
+RubyNext::Language.include_patterns << "#{Rails.root.join('app', 'views')}/*.rb"
+RubyNext::Language.rewriters = [Proscenium::CssModule::Rewriter]
+
+require 'ruby-next/language/runtime'

data/lib/proscenium/css_module/transformer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class CssModule::Transformer
+    FILE_EXT = '.module.css'
+
+    def self.class_names(path, *names)
+      new(path).class_names(*names)
+    end
+
+    def initialize(source_path)
+      return unless (@source_path = source_path)
+
+      @source_path = Pathname.new(@source_path) unless @source_path.is_a?(Pathname)
+      @source_path = @source_path.sub_ext(FILE_EXT) unless @source_path.to_s.end_with?(FILE_EXT)
+    end
+
+    # Transform each of the given class `names` to their respective CSS module name, which consist
+    # of the name, and suffixed with the digest of the resolved source path.
+    #
+    # Any name beginning with '@' will be transformed to a CSS module name. If `require_prefix` is
+    # false, then all names will be transformed to a CSS module name regardless of whether or not
+    # they begin with '@'.
+    #
+    #   class_names :@my_module_name, :my_class_name
+    #
+    # Note that the generated digest is based on the resolved (URL) path, not the original path.
+    #
+    # You can also provide a path specifier and class name. The path will be the URL path to a
+    # stylesheet. The class name will be the name of the class to transform.
+    #
+    #   class_names "/lib/button@default"
+    #   class_names "mypackage/button@large"
+    #   class_names "@scoped/package/button@small"
+    #
+    # @param names [String,Symbol,Array<String,Symbol>]
+    # @param require_prefix: [Boolean] whether or not to require the `@` prefix.
+    # @return [Array<String>] the transformed CSS module names.
+    def class_names(*names, require_prefix: true)
+      names.map do |name|
+        original_name = name.dup
+        name = name.to_s if name.is_a?(Symbol)
+
+        if name.include?('/')
+          if name.start_with?('@')
+            # Scoped bare specifier (eg. "@scoped/package/lib/button@default").
+            _, path, name = name.split('@')
+            path = "@#{path}"
+          else
+            # Local path (eg. /some/path/to/button@default") or bare specifier (eg.
+            # "mypackage/lib/button@default").
+            path, name = name.split('@')
+          end
+
+          class_name! name, original_name, path: "#{path}#{FILE_EXT}"
+        elsif name.start_with?('@')
+          class_name! name[1..], original_name
+        else
+          require_prefix ? name : class_name!(name, original_name)
+        end
+      end
+    end
+
+    def class_name!(name, original_name, path: @source_path)
+      unless path
+        raise Proscenium::CssModule::TransformError.new(original_name, 'CSS module path not given')
+      end
+
+      resolved_path = Resolver.resolve(path.to_s)
+      digest = Importer.import(resolved_path)
+
+      transformed_path = ''
+      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}"
+                         else
+                           "#{transformed_name}-#{digest}#{transformed_path}"
+                         end
+
+      [transformed_name, resolved_path]
+    end
+  end
+end

data/lib/proscenium/css_module.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Proscenium::CssModule
+  extend ActiveSupport::Autoload
+
+  autoload :Path
+  autoload :Transformer
+
+  class TransformError < StandardError
+    def initialize(name, additional_msg = nil)
+      msg = "Failed to transform CSS module `#{name}`"
+      msg << ' - ' << additional_msg if additional_msg
+
+      super(msg)
+    end
+  end
+
+  class Name
+    def initialize(name, transform)
+      @name = name
+      @transform = transform
+    end
+
+    def to_s
+      @transform
+    end
+
+    def to_sym
+      @name
+    end
+  end
+
+  # Accepts one or more CSS class names, and transforms them into CSS module names.
+  #
+  # @param name [String,Symbol,Array<String,Symbol>]
+  # @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)
+    transformer = path.nil? ? cssm : Transformer.new(path)
+    transformer.class_names(*names, require_prefix: false).map { |name, _| name }.join(' ')
+  end
+
+  # @param name [String,Symbol,Array<String,Symbol>]
+  # @param path [Pathname] the path to the CSS file to use for the transformation.
+  # @return [String] the transformed CSS module names concatenated as a string.
+  def class_names(*names, path: nil)
+    names = names.flatten.compact
+    transformer = path.nil? ? cssm : Transformer.new(path)
+    transformer.class_names(*names).map { |name, _| name }.join(' ') unless names.empty?
+  end
+
+  private
+
+  def cssm
+    @cssm ||= Transformer.new(self.class.css_module_path)
+  end
+end

data/lib/proscenium/ensure_loaded.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Proscenium
+  NotIncludedError = Class.new(StandardError)
+
+  module EnsureLoaded
+    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 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?'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/proscenium/ext/proscenium.h

@@ -0,0 +1,131 @@
+/* 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_;
+#endif
+
+#endif
+
+/* Start of preamble from import "C" comments.  */
+
+
+#line 3 "main.go"
+
+struct Result {
+	int success;
+	char* response;
+};
+
+#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
+#include <complex.h>
+typedef _Fcomplex GoComplex64;
+typedef _Dcomplex GoComplex128;
+#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
+
+
+// Build the given `path` in the `root`.
+//
+//	BuildOptions
+//	- path - The path to build relative to `root`.
+//	- baseUrl - base URL of the Rails app. eg. https://example.com
+//	- importMap - Path to the import map relative to `root`.
+//	- envVars - JSON string of environment variables.
+//	Config:
+//	- root - The working directory.
+//	- env - The environment (1 = development, 2 = test, 3 = production)
+//	- codeSpitting?
+//	- debug?
+//
+extern struct Result build_to_string(char* filepath, char* baseUrl, char* importMap, char* envVars, char* appRoot, char* gemPath, unsigned int env, GoUint8 codeSplitting, char* engines, GoUint8 debug);
+
+// Build the given `path` in the `root`.
+//
+//	BuildOptions
+//	- path - The path to build relative to `root`. Multiple paths can be given by separating them
+//	  with a semi-colon.
+//	- baseUrl - base URL of the Rails app. eg. https://example.com
+//	- importMap - Path to the import map relative to `root`.
+//	- envVars - JSON string of environment variables.
+//	Config:
+//	- root - The working directory.
+//	- env - The environment (1 = development, 2 = test, 3 = production)
+//	- codeSpitting?
+//	- debug?
+//
+extern struct Result build_to_path(char* filepath, char* baseUrl, char* importMap, char* envVars, char* appRoot, char* gemPath, unsigned int env, GoUint8 codeSplitting, char* engines, GoUint8 debug);
+
+// Resolve the given `path` relative to the `root`.
+//
+//	ResolveOptions
+//	- path - The path to build relative to `root`.
+//	- importMap - Path to the import map relative to `root`.
+//	Config
+//	- root - The working directory.
+//	- env - The environment (1 = development, 2 = test, 3 = production)
+//	- debug?
+//
+extern struct Result resolve(char* path, char* importMap, char* appRoot, char* gemPath, unsigned int env, GoUint8 debug);
+
+#ifdef __cplusplus
+}
+#endif

data/lib/proscenium/helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Helper
+    def sideload_assets(value)
+      if value.nil?
+        @current_template.instance_variable_defined?(:@sideload_assets_options) &&
+          @current_template.remove_instance_variable(:@sideload_assets_options)
+      else
+        @current_template.instance_variable_set :@sideload_assets_options, value
+      end
+    end
+
+    # Overriden to allow regular use of javascript_include_tag and stylesheet_link_tag, while still
+    # building with Proscenium. It's important to note that `include_assets` will not call this, as
+    # those asset paths all begin with a slash, which the Rails asset helpers do not pass through to
+    # here.
+    def compute_asset_path(path, options = {})
+      if %i[javascript stylesheet].include?(options[:type])
+        result = Proscenium::Builder.build_to_path(path, base_url: request.base_url)
+        return result.split('::').last.delete_prefix 'public'
+      end
+
+      super
+    end
+
+    # Accepts one or more CSS class names, and transforms them into CSS module names.
+    #
+    # @see CssModule::Transformer#class_names
+    # @param name [String,Symbol,Array<String,Symbol>]
+    # @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)
+                            .map { |name, _| name }.join(' ')
+    end
+
+    # @param name [String,Symbol,Array<String,Symbol>]
+    # @param path [Pathname] the path to the CSS file to use for the transformation.
+    # @return [String] the transformed CSS module names concatenated as a string.
+    def class_names(*names, path: nil)
+      names = names.flatten.compact
+
+      return if names.empty?
+
+      path ||= Pathname.new(@lookup_context.find(@virtual_path).identifier).sub_ext('')
+      CssModule::Transformer.new(path).class_names(*names).map { |name, _| name }.join(' ')
+    end
+
+    def include_assets
+      include_stylesheets + include_javascripts
+    end
+
+    def include_stylesheets
+      '<!-- [PROSCENIUM_STYLESHEETS] -->'.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
+      '<!-- [PROSCENIUM_LAZY_SCRIPTS] --><!-- [PROSCENIUM_JAVASCRIPTS] -->'.html_safe
+    end
+    alias side_load_javascripts include_javascripts
+    deprecate side_load_javascripts: 'Use `include_javascripts` instead', deprecator: Deprecator.new
+  end
+end