proscenium 0.9.1-aarch64-linux → 0.11.0-aarch64-linux

data/lib/proscenium/railtie.rb

@@ -6,11 +6,6 @@ require 'proscenium/log_subscriber'
 ENV['RAILS_ENV'] = Rails.env
 
 module Proscenium
-  FILE_EXTENSIONS = ['js', 'mjs', 'ts', 'jsx', 'tsx', 'css', 'js.map', 'mjs.map', 'jsx.map',
-                     'ts.map', 'tsx.map', 'css.map'].freeze
-
-  APPLICATION_INCLUDE_PATHS = ['config', 'app/assets', 'app/views', 'lib', 'node_modules'].freeze
-
   class << self
     def config
       @config ||= Railtie.config.proscenium
@@ -21,61 +16,74 @@ module Proscenium
     isolate_namespace Proscenium
 
     config.proscenium = ActiveSupport::OrderedOptions.new
+    config.proscenium.debug = false
     config.proscenium.side_load = true
+    config.proscenium.code_splitting = true
+
+    # TODO: implement!
     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.
+    # 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.
     #
-    # 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.
+    # 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:
-    #   config.proscenium.side_load_gems['mygem'] = {
-    #     root: gem_root,
-    #     package_name: 'mygem'
-    #   }
-    config.proscenium.side_load_gems = {}
+    #   class Gem1::Engine < ::Rails::Engine
+    #     config.proscenium.engines << self
+    #   end
+    config.proscenium.engines = Set.new
 
-    initializer 'proscenium.configuration' do |app|
-      options = app.config.proscenium
-      options.include_paths = Set.new(APPLICATION_INCLUDE_PATHS) if options.include_paths.blank?
+    config.action_dispatch.rescue_templates = {
+      'Proscenium::Builder::BuildError' => 'build_error'
+    }
+
+    initializer 'proscenium.debugging' do
+      if Rails.gem_version >= Gem::Version.new('7.1.0')
+        tpl_path = root.join('lib', 'proscenium', 'templates').to_s
+        ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS << tpl_path
+      end
     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
+      app.middleware.insert_after ActionDispatch::Static, 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
+    initializer 'proscenium.monkey_patches' do
+      ActiveSupport.on_load(:action_view) do
+        ActionView::TemplateRenderer.prepend Monkey::TemplateRenderer
+        ActionView::PartialRenderer.prepend Monkey::PartialRenderer
       end
     end
 
     initializer 'proscenium.helper' do
       ActiveSupport.on_load(:action_view) do
-        ActionView::Base.include Proscenium::Helper
+        ActionView::Base.include Helper
+      end
+
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Base.include EnsureLoaded
       end
     end
   end
 end
+
+if Rails.gem_version < Gem::Version.new('7.1.0')
+  class ActionDispatch::DebugView
+    def initialize(assigns)
+      tpl_path = Proscenium::Railtie.root.join('lib', 'proscenium', 'templates').to_s
+      paths = [RESCUES_TEMPLATE_PATH, tpl_path]
+      lookup_context = ActionView::LookupContext.new(paths)
+      super(lookup_context, assigns, nil)
+    end
+  end
+end

data/lib/proscenium/react_componentable.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module ReactComponentable
+    extend ActiveSupport::Concern
+
+    included do
+      # @return [Hash] the props to pass to the React component.
+      attr_writer :props
+
+      # The HTML tag to use as the wrapping element for the component. You can reassign this in your
+      # component class to use a different tag:
+      #
+      #   class MyComponent < Proscenium::ViewComponent::ReactComponent
+      #     self.root_tag = :span
+      #   end
+      #
+      # @return [Symbol]
+      class_attribute :root_tag, instance_predicate: false, default: :div
+
+      # By default, the template block (content) of the component will be server rendered as normal.
+      # However, when React hydrates and takes control of the component, it's content will be
+      # replaced by React with the JavaScript rendered content. Enabling this option will forward
+      # the server rendered content as the `children` prop passed to the React component.
+      #
+      # @example
+      #
+      #   const Component = ({ children }) => {
+      #     return <div dangerouslySetInnerHTML={{ __html: children }} />
+      #   }
+      #
+      # @return [Boolean]
+      class_attribute :forward_children, default: false
+
+      # Lazy load the component using IntersectionObserver?
+      #
+      # @return [Boolean]
+      class_attribute :lazy, default: false
+
+      class_attribute :loader
+
+      # @return [String] the URL path to the component manager.
+      class_attribute :manager, default: '/@proscenium/react-manager/index.jsx'
+    end
+
+    class_methods do
+      def sideload
+        Importer.import manager
+        Importer.sideload source_path, lazy: true
+      end
+    end
+
+    # @param props: [Hash]
+    def initialize(lazy: self.class.lazy, loader: self.class.loader, props: {})
+      self.lazy = lazy
+      self.loader = loader
+      @props = props
+    end
+
+    # The absolute URL path to the javascript component.
+    def virtual_path
+      @virtual_path ||= Resolver.resolve self.class.source_path.sub_ext('.jsx').to_s
+    end
+
+    def props
+      @props ||= {}
+    end
+
+    private
+
+    def data_attributes
+      {
+        proscenium_component_path: Pathname.new(virtual_path).to_s,
+        proscenium_component_props: prepared_props,
+        proscenium_component_lazy: lazy
+      }.tap do |x|
+        x[:proscenium_component_forward_children] = true if forward_children?
+      end
+    end
+
+    def prepared_props
+      props.deep_transform_keys do |term|
+        # This ensures that the first letter after a slash is not capitalized.
+        string = term.to_s.split('/').map { |str| str.camelize :lower }.join('/')
+
+        # Reverses the effect of ActiveSupport::Inflector.camelize converting slashes into `::`.
+        string.gsub '::', '/'
+      end.to_json
+    end
+
+    def loader_component
+      render Loader::Component.new(loader, @html_class, data_attributes, tag: @html_tag)
+    end
+  end
+end

data/lib/proscenium/resolver.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'active_support/current_attributes'
+
+module Proscenium
+  class Resolver < ActiveSupport::CurrentAttributes
+    # TODO: cache this across requests in production.
+    attribute :resolved
+
+    # 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.
+    #
+    # rubocop:disable Metrics/*
+    def self.resolve(path)
+      self.resolved ||= {}
+
+      self.resolved[path] ||= begin
+        if path.start_with?('./', '../')
+          raise ArgumentError, 'path must be an absolute file system or URL path'
+        end
+
+        if path.start_with?('@proscenium/')
+          "/#{path}"
+        elsif (engine = Proscenium.config.engines.find { |e| path.start_with? "#{e.root}/" })
+          path.sub(/^#{engine.root}/, "/#{engine.engine_name}")
+        elsif path.start_with?("#{Rails.root}/")
+          path.delete_prefix Rails.root.to_s
+        else
+          Builder.resolve path
+        end
+      end
+    end
+    # rubocop:enable Metrics/*
+  end
+end

data/lib/proscenium/side_load.rb

@@ -2,83 +2,24 @@
 
 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,
-      # '.tsx' => :js,
-      '.ts' => :js,
-      # '.jsx' => :js,
-      '.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.
+      # Side loads the class, and its super classes that respond to `.source_path`.
       #
-      # @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`.
+      # Assign the `abstract_class` class variable to any abstract class, and it will not be side
+      # loaded. Additionally, if the class responds to `#sideload?`, and it returns false, it will
+      # not be side 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)
+      # If the class responds to `.sideload`, it will be called instead of the regular side loading.
+      # You can use this to customise what is side loaded.
+      def sideload_inheritance_chain(obj)
+        return if !Proscenium.config.side_load || (obj.respond_to?(:sideload?) && !obj.sideload?)
+
+        klass = obj.class
+        while klass.respond_to?(:source_path) && klass.source_path && !klass.abstract_class
+          klass.respond_to?(:sideload) ? klass.sideload : Importer.sideload(klass.source_path)
+          klass = klass.superclass
         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/source_path.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Include this into any class to expose a `source_path` class and instance method, which will return
+# the absolute file system path to the current object.
+module Proscenium::SourcePath
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def source_path
+      @source_path ||= name.nil? ? nil : Pathname.new(const_source_location(name).first)
+    end
+  end
+end

data/lib/proscenium/templates/rescues/build_error.html.erb

@@ -0,0 +1,30 @@
+<header>
+  <h1>
+    <%= Rails.gem_version >= Gem::Version.new('7.1.0') ? @exception_wrapper.exception_class_name : @exception.class.to_s %>
+    <% if params_valid? && @request.parameters['controller'] %>
+      in <%= @request.parameters['controller'].camelize %>Controller<% if @request.parameters['action'] %>#<%= @request.parameters['action'] %><% end %>
+    <% end %>
+  </h1>
+</header>
+
+<main role="main" id="container">
+  <%= render "rescues/message_and_suggestions", exception: @exception, exception_wrapper: Rails.gem_version >= Gem::Version.new('7.1.0') ? @exception_wrapper : nil %>
+
+  <% if @exception.error['location'] %>
+    <div class="source">
+      <div class="data">
+<pre>
+
+    <%= @exception.error['location']['file'] %>:<%= @exception.error['location']['line'] %>:<%= @exception.error['location']['column'] %>
+
+<%= @exception.error['location']['line'].to_s.rjust 5 %> │    <%= @exception.error['location']['line_text'] %>
+      │    <%= (@exception.error['location']['length'] > 1 ? "~" * @exception.error['location']['length'] : "^").rjust(@exception.error['location']['column'] + @exception.error['location']['length']) %>
+<%- if @exception.error['location']['suggestion'].present? -%>    + │    <%= @exception.error['location']['suggestion'].rjust(@exception.error['location']['column'] + 1) %>
+<% else %> <%- end -%>
+</pre>
+      </div>
+    </div>
+  <% end %>
+
+  <%= render template: "rescues/_request_and_response" %>
+</main>

data/lib/proscenium/utils.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Utils
+    module_function
+
+    # @param value [#to_s] The value to create the digest from. This will usually be a `Pathname`.
+    # @return [String] digest of the given value.
+    def digest(value)
+      Digest::SHA1.hexdigest(value.to_s)[..7]
+    end
+  end
+end

data/lib/proscenium/version.rb

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

data/lib/proscenium/view_component/css_modules.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module ViewComponent::CssModules
+    include Proscenium::CssModule
+
+    def self.included(base)
+      base.extend CssModule::Path
+    end
+  end
+end

data/lib/proscenium/view_component/react_component.rb

@@ -1,35 +1,22 @@
 # 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
+module Proscenium
+  # Renders a <div> for use with React components, with data attributes specifying the component
+  # path and props.
+  #
+  # 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. It is intended
+  # that the component is mounted to this div, and the loading UI will then be replaced with the
+  # component's rendered output.
+  class ViewComponent::ReactComponent < ViewComponent
+    self.abstract_class = true
 
-  attr_accessor :props, :lazy
+    include ReactComponentable
 
-  # @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...'
+    def call
+      tag.send root_tag, data: data_attributes do
+        tag.div content || 'loading...'
+      end
     end
   end
 end

data/lib/proscenium/view_component/sideload.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Proscenium::ViewComponent::Sideload
+end

data/lib/proscenium/view_component.rb

@@ -4,52 +4,29 @@ require 'view_component'
 
 class Proscenium::ViewComponent < ViewComponent::Base
   extend ActiveSupport::Autoload
-  include Proscenium::CssModule
 
-  autoload :TagBuilder
+  autoload :Sideload
   autoload :ReactComponent
+  autoload :CssModules
+
+  include Proscenium::SourcePath
+  include CssModules
 
-  # 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
+      Proscenium::SideLoad.sideload_inheritance_chain self
 
       super
     end
   end
 
   class << self
-    attr_accessor :path, :abstract_class
+    attr_accessor :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
+      child.prepend Sideload
 
       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

@@ -5,18 +5,35 @@ require 'active_support/dependencies/autoload'
 module Proscenium
   extend ActiveSupport::Autoload
 
-  autoload :Current
+  FILE_EXTENSIONS = ['js', 'mjs', 'ts', 'jsx', 'tsx', 'css', 'js.map', 'mjs.map', 'jsx.map',
+                     'ts.map', 'tsx.map', 'css.map'].freeze
+
+  ALLOWED_DIRECTORIES = 'app,lib,config,vendor,node_modules'
+
+  # Environment variables that should always be passed to the builder.
+  DEFAULT_ENV_VARS = Set['RAILS_ENV', 'NODE_ENV'].freeze
+
+  autoload :SourcePath
+  autoload :Utils
+  autoload :Monkey
   autoload :Middleware
+  autoload :EnsureLoaded
   autoload :SideLoad
   autoload :CssModule
+  autoload :ReactComponentable
   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] }
+  autoload :Builder
+  autoload :Importer
+  autoload :Resolver
+
+  class Deprecator
+    def deprecation_warning(name, message, _caller_backtrace = nil)
+      msg = "`#{name}` is deprecated and will be removed in a near future release of Proscenium"
+      msg << " (#{message})" if message
+      Kernel.warn msg
+    end
   end
 
   class PathResolutionFailed < StandardError
@@ -29,68 +46,6 @@ module Proscenium
       "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 (package_name = matched_gem[1][:package_name] || matched_gem[0])
-          return Esbuild::Golib.resolve("#{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'