proscenium 0.7.0-aarch64-linux

data/lib/proscenium/phlex/resolve_css_modules.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Phlex::ResolveCssModules
+    extend ActiveSupport::Concern
+
+    class_methods do
+      attr_accessor :side_load_cache
+    end
+
+    def before_template
+      self.class.side_load_cache ||= Set.new
+      super
+    end
+
+    # Resolve and side load any CSS modules in the "class" attributes, where a CSS module is a class
+    # name beginning with a `@`. The class name is resolved to a CSS module name based on the file
+    # system path of the Phlex class, and any CSS file is side loaded.
+    #
+    # For example, the following will side load the CSS module file at
+    # app/components/user/component.module.css, and add the CSS Module name `user_name` to the
+    # <div>.
+    #
+    #   # app/components/user/component.rb
+    #   class User::Component < Proscenium::Phlex
+    #     def template
+    #       div class: :@user_name do
+    #         'Joel Moss'
+    #       end
+    #     end
+    #   end
+    #
+    # Additionally, any class name containing a `/` is resolved as a CSS module path. Allowing you
+    # to use the same syntax as a CSS module, but without the need to manually import the CSS file.
+    #
+    # For example, the following will side load the CSS module file at /lib/users.module.css, and
+    # add the CSS Module name `name` to the <div>.
+    #
+    #   class User::Component < Proscenium::Phlex
+    #     def template
+    #       div class: '/lib/users@name' do
+    #         'Joel Moss'
+    #       end
+    #     end
+    #   end
+    #
+    # The given class name should be underscored, and the resulting CSS module name will be
+    # `camelCased` with a lower case first character.
+    #
+    # @raise [Proscenium::CssModule::Resolver::NotFound] If a CSS module file is not found for the
+    #   Phlex class file path.
+    def process_attributes(**attributes)
+      if attributes.key?(:class) && (attributes[:class] = tokens(attributes[:class])).include?('@')
+        resolver = CssModule::ClassNamesResolver.new(attributes[:class], path)
+        self.class.side_load_cache.merge resolver.stylesheets
+        attributes[:class] = resolver.class_names
+      end
+
+      attributes
+    end
+
+    def after_template
+      super
+      self.class.side_load_cache&.each { |path| SideLoad.append! path, :css }
+    end
+  end
+end

data/lib/proscenium/phlex.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'phlex-rails'
+
+module Proscenium
+  class Phlex < ::Phlex::HTML
+    extend ActiveSupport::Autoload
+    include Proscenium::CssModule
+
+    autoload :Page
+    autoload :ReactComponent
+    autoload :ResolveCssModules
+    autoload :ComponentConcerns
+
+    extend ::Phlex::Rails::HelperMacros
+    include ::Phlex::Rails::Helpers::JavaScriptIncludeTag
+    include ::Phlex::Rails::Helpers::StyleSheetLinkTag
+
+    define_output_helper :side_load_stylesheets
+    define_output_helper :side_load_javascripts
+
+    # Side loads the class, and its super classes that respond to `.path`. Assign the
+    # `abstract_class` class variable to any abstract class, and it will not be side loaded.
+    # Additionally, if the class responds to `side_load`, then that method is called.
+    module Sideload
+      def before_template
+        klass = self.class
+
+        if !klass.abstract_class && respond_to?(:side_load, true)
+          side_load
+          klass = klass.superclass
+        end
+
+        while !klass.abstract_class && klass.respond_to?(:path) && klass.path
+          Proscenium::SideLoad.append klass.path
+          klass = klass.superclass
+        end
+
+        super
+      end
+    end
+
+    class << self
+      attr_accessor :path, :abstract_class
+
+      def inherited(child)
+        unless child.path
+          child.path = if caller_locations(1, 1).first.label == 'inherited'
+                         Pathname.new caller_locations(2, 1).first.path
+                       else
+                         Pathname.new caller_locations(1, 1).first.path
+                       end
+        end
+
+        child.prepend Sideload if Rails.application.config.proscenium.side_load
+
+        super
+      end
+    end
+  end
+end

data/lib/proscenium/railtie.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'rails'
+require 'proscenium/log_subscriber'
+
+ENV['RAILS_ENV'] = Rails.env
+
+module Proscenium
+  FILE_EXTENSIONS = ['js', 'mjs', 'jsx', 'css', 'js.map', 'mjs.map', 'jsx.map', 'css.map'].freeze
+
+  MIDDLEWARE_GLOB_TYPES = {
+    application: "/**.{#{FILE_EXTENSIONS.join(',')}}",
+    url: %r{^/https?%3A%2F%2F}
+  }.freeze
+
+  APPLICATION_INCLUDE_PATHS = ['config', 'app/views', 'lib', 'node_modules'].freeze
+
+  class << self
+    def config
+      @config ||= Railtie.config.proscenium
+    end
+  end
+
+  class Railtie < ::Rails::Engine
+    isolate_namespace Proscenium
+
+    config.proscenium = ActiveSupport::OrderedOptions.new
+    config.proscenium.side_load = true
+    config.proscenium.cache_query_string = Rails.env.production? && ENV.fetch('REVISION', nil)
+    config.proscenium.cache_max_age = 2_592_000 # 30 days
+    config.proscenium.include_paths = Set.new(APPLICATION_INCLUDE_PATHS)
+
+    # A hash of gems that can be side loaded. Assets from gems listed here can be side loaded.
+    #
+    # Because side loading uses URL paths, any gem dependencies that side load assets will fail,
+    # because the URL path will be relative to the application's root, and not the gem's root. By
+    # specifying a list of gems that can be side loaded, Proscenium will be able to resolve the URL
+    # path to the gem's root, and side load the asset.
+    #
+    # Side loading gems rely on NPM and a package.json file in the gem root. This ensures that any
+    # dependencies are resolved correctly. This is required even if your gem has no package
+    # dependencies.
+    #
+    # Example:
+    #   config.proscenium.side_load_gems['mygem'] = {
+    #     root: gem_root,
+    #     package_name: 'mygem'
+    #   }
+    config.proscenium.side_load_gems = {}
+
+    initializer 'proscenium.configuration' do |app|
+      options = app.config.proscenium
+      options.include_paths = Set.new(APPLICATION_INCLUDE_PATHS) if options.include_paths.blank?
+    end
+
+    initializer 'proscenium.middleware' do |app|
+      app.middleware.insert_after ActionDispatch::Static, Proscenium::Middleware
+      app.middleware.insert_after ActionDispatch::Static, Rack::ETag, 'no-cache'
+      app.middleware.insert_after ActionDispatch::Static, Rack::ConditionalGet
+    end
+
+    initializer 'proscenium.side_loading' do |app|
+      if app.config.proscenium.side_load
+        Proscenium::Current.loaded ||= SideLoad::EXTENSIONS.to_h { |e| [e, Set.new] }
+
+        ActiveSupport.on_load(:action_view) do
+          ActionView::Base.include Proscenium::SideLoad::Helper
+
+          ActionView::TemplateRenderer.prepend SideLoad::Monkey::TemplateRenderer
+          ActionView::PartialRenderer.prepend SideLoad::Monkey::PartialRenderer
+        end
+
+        ActiveSupport.on_load(:action_controller) do
+          ActionController::Base.include Proscenium::SideLoad::EnsureLoaded
+        end
+      end
+    end
+
+    initializer 'proscenium.helper' do
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Base.include Proscenium::Helper
+      end
+    end
+  end
+end

data/lib/proscenium/side_load/ensure_loaded.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Proscenium::SideLoad
+  module EnsureLoaded
+    def self.included(child)
+      child.class_eval do
+        append_after_action do
+          if Proscenium::Current.loaded
+            if Proscenium::Current.loaded[:js].present?
+              raise NotIncludedError, 'There are javascripts to be side loaded, but they have not ' \
+                                      'been included. Did you forget to add the ' \
+                                      '`#side_load_javascripts` helper in your views?'
+            end
+
+            if Proscenium::Current.loaded[:css].present?
+              raise NotIncludedError, 'There are stylesheets to be side loaded, but they have not ' \
+                                      'been included. Did you forget to add the ' \
+                                      '`#side_load_stylesheets` helper in your views?'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/proscenium/side_load/helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module SideLoad::Helper
+    def side_load_stylesheets
+      return unless Proscenium::Current.loaded
+
+      out = []
+      Proscenium::Current.loaded[:css].delete_if do |path|
+        out << stylesheet_link_tag(path)
+      end
+      out.join("\n").html_safe
+    end
+
+    def side_load_javascripts(**options)
+      return unless Proscenium::Current.loaded
+
+      out = []
+      Proscenium::Current.loaded[:js].delete_if do |path|
+        out << javascript_include_tag(path, options)
+      end
+      out.join("\n").html_safe
+    end
+  end
+end

data/lib/proscenium/side_load/monkey.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Proscenium::SideLoad
+  # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+  module Monkey
+    module TemplateRenderer
+      private
+
+      def render_template(view, template, layout_name, locals)
+        layout = find_layout(layout_name, locals.keys, [formats.first])
+        renderable = template.instance_variable_get(:@renderable)
+
+        if Object.const_defined?(:ViewComponent) &&
+           template.is_a?(ActionView::Template::Renderable) &&
+           renderable.class < ::ViewComponent::Base && renderable.class.format == :html
+          # Side load controller rendered ViewComponent
+          Proscenium::SideLoad.append "app/views/#{layout.virtual_path}" if layout
+          Proscenium::SideLoad.append "app/views/#{renderable.virtual_path}"
+        elsif template.respond_to?(:virtual_path) &&
+              template.respond_to?(:type) && template.type == :html
+          # Side load regular view template.
+          Proscenium::SideLoad.append "app/views/#{layout.virtual_path}" if layout
+
+          # Try side loading the variant template
+          if template.respond_to?(:variant) && template.variant
+            Proscenium::SideLoad.append "app/views/#{template.virtual_path}+#{template.variant}"
+          end
+
+          # The variant template may not exist (above), so we try the regular non-variant path.
+          Proscenium::SideLoad.append "app/views/#{template.virtual_path}"
+        end
+
+        super
+      end
+    end
+
+    module PartialRenderer
+      private
+
+      def build_rendered_template(content, template)
+        path = Rails.root.join('app', 'views', template.virtual_path)
+        cssm = Proscenium::CssModule::Resolver.new(path)
+        super cssm.compile_class_names(content), template
+      end
+    end
+  end
+  # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+end

data/lib/proscenium/side_load.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class SideLoad
+    extend ActiveSupport::Autoload
+
+    NotIncludedError = Class.new(StandardError)
+
+    autoload :Monkey
+    autoload :Helper
+    autoload :EnsureLoaded
+
+    EXTENSIONS = %i[js css].freeze
+    EXTENSION_MAP = { '.css' => :css, '.js' => :js }.freeze
+
+    attr_reader :path
+
+    class << self
+      # Side load the given asset `path`, by appending it to `Proscenium::Current.loaded`, which is a
+      # Set of 'js' and 'css' asset paths. This is idempotent, so side loading will never include
+      # duplicates.
+      #
+      # @return [Array] appended URL paths
+      def append(path, extension_map = EXTENSION_MAP)
+        new(path, extension_map).append
+      end
+
+      # Side load the given `path` at `type`, without first resolving the path. This still respects
+      # idempotency of `Proscenium::Current.loaded`.
+      #
+      # @param path [String]
+      # @param type [Symbol] :js or :css
+      def append!(path, type)
+        return if Proscenium::Current.loaded[type].include?(path)
+
+        Proscenium::Current.loaded[type] << log(path)
+      end
+
+      def log(value)
+        ActiveSupport::Notifications.instrument('sideload.proscenium', identifier: value)
+
+        value
+      end
+    end
+
+    # @param path [Pathname, String] The path of the file to be side loaded.
+    # @param extension_map [Hash] File extensions to side load.
+    def initialize(path, extension_map = EXTENSION_MAP)
+      @path = (path.is_a?(Pathname) ? path : Rails.root.join(path)).sub_ext('')
+      @extension_map = extension_map
+
+      Proscenium::Current.loaded ||= EXTENSIONS.index_with { |_e| Set.new }
+    end
+
+    def append
+      @extension_map.filter_map do |ext, type|
+        next unless (resolved_path = resolve_path(path.sub_ext(ext)))
+
+        # Make sure path is not already side loaded.
+        unless Proscenium::Current.loaded[type].include?(resolved_path)
+          Proscenium::Current.loaded[type] << log(resolved_path)
+        end
+
+        resolved_path
+      end
+    end
+
+    private
+
+    def log(...)
+      self.class.log(...)
+    end
+
+    def resolve_path(path)
+      path.exist? ? Utils.resolve_path(path.to_s) : nil
+    end
+  end
+end

data/lib/proscenium/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Proscenium
+  VERSION = '0.7.0'
+end

data/lib/proscenium/view_component/react_component.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+#
+# Renders HTML markup suitable for use with @proscenium/component-manager.
+#
+# If a content block is given, that content will be rendered inside the component, allowing for a
+# "loading" UI. If no block is given, then a loading text will be rendered.
+#
+# The parent div is not decorated with any attributes, apart from the selector class required by
+# component-manager. But if your component has a side loaded CSS module stylesheet
+# (component.module.css), with a `.component` class defined, then that class will be assigned to the
+# parent div as a CSS module.
+#
+class Proscenium::ViewComponent::ReactComponent < Proscenium::ViewComponent
+  self.abstract_class = true
+
+  attr_accessor :props, :lazy
+
+  # @param props: [Hash]
+  # @param lazy: [Boolean] Lazy load the component using IntersectionObserver. Default: true.
+  # @param [Block]
+  def initialize(props: {}, lazy: true)
+    @props = props
+    @lazy = lazy
+
+    super
+  end
+
+  def call
+    tag.div class: ['componentManagedByProscenium', css_module(:component)],
+            data: { component: { path: virtual_path, props: props, lazy: lazy } } do
+      tag.div content || 'loading...'
+    end
+  end
+end

data/lib/proscenium/view_component/tag_builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class Proscenium::ViewComponent::TagBuilder < ActionView::Helpers::TagHelper::TagBuilder
+  def tag_options(options, escape = true) # rubocop:disable Style/OptionalBooleanParameter
+    super(css_module_option(options), escape)
+  end
+
+  private
+
+  def css_module_option(options)
+    return options if options.blank?
+
+    unless (css_module = options.delete(:css_module) || options.delete('css_module'))
+      return options
+    end
+
+    css_module = @view_context.css_module(css_module)
+
+    options.tap do |x|
+      x[:class] = "#{css_module} #{options.delete(:class) || options.delete('class')}".strip
+    end
+  end
+end

data/lib/proscenium/view_component.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'view_component'
+
+class Proscenium::ViewComponent < ViewComponent::Base
+  extend ActiveSupport::Autoload
+  include Proscenium::CssModule
+
+  autoload :TagBuilder
+  autoload :ReactComponent
+
+  # Side loads the class, and its super classes that respond to `.path`. Assign the `abstract_class`
+  # class variable to any abstract class, and it will not be side loaded.
+  module Sideload
+    def before_render
+      klass = self.class
+      while !klass.abstract_class && klass.respond_to?(:path) && klass.path
+        Proscenium::SideLoad.append klass.path
+        klass = klass.superclass
+      end
+
+      super
+    end
+  end
+
+  class << self
+    attr_accessor :path, :abstract_class
+
+    def inherited(child)
+      child.path = if caller_locations(1, 1).first.label == 'inherited'
+                     Pathname.new caller_locations(2, 1).first.path
+                   else
+                     Pathname.new caller_locations(1, 1).first.path
+                   end
+
+      child.prepend Sideload if Rails.application.config.proscenium.side_load
+
+      super
+    end
+  end
+
+  # @override Auto compilation of class names to css modules.
+  def render_in(...)
+    cssm.compile_class_names(super(...))
+  end
+
+  private
+
+  # Overrides ActionView::Helpers::TagHelper::TagBuilder, allowing us to intercept the
+  # `css_module` option from the HTML options argument of the `tag` and `content_tag` helpers, and
+  # prepend it to the HTML `class` attribute.
+  def tag_builder
+    @tag_builder ||= Proscenium::ViewComponent::TagBuilder.new(self)
+  end
+end

data/lib/proscenium.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'active_support/dependencies/autoload'
+
+module Proscenium
+  extend ActiveSupport::Autoload
+
+  autoload :Current
+  autoload :Middleware
+  autoload :SideLoad
+  autoload :CssModule
+  autoload :ViewComponent
+  autoload :Phlex
+  autoload :Helper
+  autoload :Esbuild
+
+  def self.reset_current_side_loaded
+    Current.reset
+    Current.loaded = SideLoad::EXTENSIONS.to_h { |e| [e, Set.new] }
+  end
+
+  class PathResolutionFailed < StandardError
+    def initialize(path)
+      @path = path
+      super
+    end
+
+    def message
+      "Path #{@path.inspect} cannot be resolved"
+    end
+  end
+
+  module Utils
+    module_function
+
+    # @param value [#to_s] The value to create the digest from. This will usually be a `Pathname`.
+    # @return [String] string digest of the given value.
+    def digest(value)
+      Digest::SHA1.hexdigest(value.to_s)[..7]
+    end
+
+    # Resolve the given `path` to a URL path.
+    #
+    # @param path [String] Can be URL path, file system path, or bare specifier (ie. NPM package).
+    # @return [String] URL path.
+    def resolve_path(path) # rubocop:disable Metrics/AbcSize
+      raise ArgumentError, 'path must be a string' unless path.is_a?(String)
+
+      if path.starts_with?('./', '../')
+        raise ArgumentError, 'path must be an absolute file system or URL path'
+      end
+
+      matched_gem = Proscenium.config.side_load_gems.find do |_, opts|
+        path.starts_with?("#{opts[:root]}/")
+      end
+
+      if matched_gem
+        sroot = "#{matched_gem[1][:root]}/"
+        relpath = path.delete_prefix(sroot)
+
+        if matched_gem[1][:package_name]
+          return Esbuild::Golib.resolve("#{matched_gem[1][:package_name]}/#{relpath}")
+        end
+
+        # TODO: manually resolve the path without esbuild
+        raise PathResolutionFailed, path
+      end
+
+      return path.delete_prefix(Rails.root.to_s) if path.starts_with?("#{Rails.root}/")
+
+      Esbuild::Golib.resolve(path)
+    end
+
+    # Resolves CSS class `names` to CSS module names. Each name will be converted to a CSS module
+    # name, consisting of the camelCased name (lower case first character), and suffixed with the
+    # given `digest`.
+    #
+    # @param names [String, Array]
+    # @param digest: [String]
+    # @returns [Array] of class names generated from the given CSS module `names` and `digest`.
+    def css_modularise_class_names(*names, digest: nil)
+      names.flatten.compact.map { |name| css_modularise_class_name name, digest: digest }
+    end
+
+    def css_modularise_class_name(name, digest: nil)
+      sname = name.to_s
+      if sname.starts_with?('_')
+        "_#{sname[1..].camelize(:lower)}#{digest}"
+      else
+        "#{sname.camelize(:lower)}#{digest}"
+      end
+    end
+  end
+end
+
+require 'proscenium/railtie'