proscenium 0.7.0-aarch64-linux

data/lib/proscenium/esbuild/golib.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require 'oj'
+
+module Proscenium
+  class Esbuild::Golib
+    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, [
+        :string,      # path or entry point
+        :string,      # root
+        :string,      # base URL of the Rails app. eg. https://example.com
+        :environment, # Rails environment as a Symbol
+        :string,      # path to import map, relative to root
+        :bool         # debugging enabled?
+      ], Result.by_value
+
+      attach_function :resolve, [
+        :string,      # path or entry point
+        :string,      # root
+        :environment, # Rails environment as a Symbol
+        :string       # path to import map, relative to root
+      ], Result.by_value
+    end
+
+    class BuildError < StandardError
+      attr_reader :error, :path
+
+      def initialize(path, error)
+        error = Oj.load(error, mode: :strict).deep_transform_keys(&:underscore)
+
+        super "Failed to build '#{path}' -- #{error['text']}"
+      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 initialize(root: nil, base_url: nil)
+      @root = root || Rails.root
+      @base_url = base_url
+    end
+
+    def self.resolve(path)
+      new.resolve(path)
+    end
+
+    def self.build(path)
+      new.build(path)
+    end
+
+    def build(path)
+      result = Request.build(path, @root.to_s, @base_url, Rails.env.to_sym, import_map,
+                             Rails.env.development?)
+      raise BuildError.new(path, result[:response]) unless result[:success]
+
+      result[:response]
+    end
+
+    def resolve(path)
+      result = Request.resolve(path, @root.to_s, Rails.env.to_sym, import_map)
+      raise ResolveError.new(path, result[:response]) unless result[:success]
+
+      result[:response]
+    end
+
+    private
+
+    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
+  end
+end

data/lib/proscenium/esbuild.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Esbuild
+    class CompileError < StandardError; end
+
+    extend ActiveSupport::Autoload
+
+    autoload :Golib
+
+    def self.build(...)
+      new(...).build
+    end
+
+    def initialize(path, root:, base_url:)
+      @path = path
+      @root = root
+      @base_url = base_url
+    end
+
+    def build
+      Proscenium::Esbuild::Golib.new(root: @root, base_url: @base_url).build(@path)
+    end
+
+    private
+
+    def cache_query_string
+      q = Proscenium.config.cache_query_string
+      q ? "--cache-query-string #{q}" : nil
+    end
+  end
+end

data/lib/proscenium/ext/proscenium.h

@@ -0,0 +1,109 @@
+/* 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`.
+//
+//   - path - The path to build relative to `root`.
+//   - root - The working directory.
+//   - baseUrl - base URL of the Rails app. eg. https://example.com
+//   - env - The environment (1 = development, 2 = test, 3 = production)
+//   - importMap - Path to the import map relative to `root`.
+//   - bundle
+//   - debug
+//
+extern struct Result build(char* filepath, char* root, char* baseUrl, unsigned int env, char* importMap, GoUint8 bundle, GoUint8 debug);
+
+// Resolve the given `path` relative to the `root`.
+//
+//   - path - The path to build relative to `root`.
+//   - root - The working directory.
+//   - env - The environment (1 = development, 2 = test, 3 = production)
+//   - importMap - Path to the import map relative to `root`.
+//
+extern struct Result resolve(char* path, char* root, unsigned int env, char* importMap);
+
+#ifdef __cplusplus
+}
+#endif

data/lib/proscenium/helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Proscenium
+  module Helper
+    def compute_asset_path(path, options = {})
+      if %i[javascript stylesheet].include?(options[:type])
+        result = "/#{path}"
+
+        if (qs = Proscenium.config.cache_query_string)
+          result << "?#{qs}"
+        end
+
+        return result
+      end
+
+      super
+    end
+  end
+end

data/lib/proscenium/log_subscriber.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_support/log_subscriber'
+
+module Proscenium
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def sideload(event)
+      info do
+        "  [Proscenium] Side loaded #{event.payload[:identifier]}"
+      end
+    end
+
+    def build(event)
+      path = event.payload[:identifier]
+      path = path.start_with?(/https?%3A%2F%2F/) ? CGI.unescape(path) : path
+
+      info do
+        message = +"[Proscenium] Building #{path}"
+        message << " (Duration: #{event.duration.round(1)}ms | Allocations: #{event.allocations})"
+        message << "\n" if defined?(Rails.env) && Rails.env.development?
+      end
+    end
+  end
+end
+
+Proscenium::LogSubscriber.attach_to :proscenium

data/lib/proscenium/middleware/base.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'oj'
+
+module Proscenium
+  class Middleware
+    class Base
+      include ActiveSupport::Benchmarkable
+
+      # Error when the result of the build returns an error. For example, when esbuild returns
+      # errors.
+      class CompileError < StandardError
+        attr_reader :detail, :file
+
+        def initialize(args)
+          @detail = args[:detail]
+          @file = args[:file]
+          super "Failed to build '#{args[:file]}' -- #{detail}"
+        end
+      end
+
+      def self.attempt(request)
+        new(request).renderable!&.attempt
+      end
+
+      def initialize(request)
+        @request = request
+      end
+
+      def renderable!
+        renderable? ? self : nil
+      end
+
+      private
+
+      def real_path
+        @request.path
+      end
+
+      # @return [String] the path to the file without the leading slash which will be built.
+      def path_to_build
+        @request.path[1..]
+      end
+
+      def sourcemap?
+        @request.path.ends_with?('.map')
+      end
+
+      def renderable?
+        file_readable?
+      end
+
+      def file_readable?
+        return unless (path = clean_path(sourcemap? ? real_path[0...-4] : real_path))
+
+        file_stat = File.stat(Pathname(root).join(path.delete_prefix('/').b).to_s)
+      rescue SystemCallError
+        false
+      else
+        file_stat.file? && file_stat.readable?
+      end
+
+      def clean_path(file)
+        path = Rack::Utils.unescape_path file.chomp('/').delete_prefix('/')
+        Rack::Utils.clean_path_info path if Rack::Utils.valid_path? path
+      end
+
+      def root
+        @root ||= Rails.root.to_s
+      end
+
+      def content_type
+        @content_type ||
+          ::Rack::Mime.mime_type(::File.extname(path_to_build), nil) ||
+          'application/javascript'
+      end
+
+      def render_response(content)
+        response = Rack::Response.new
+        response.write content
+        response.content_type = content_type
+        response['X-Proscenium-Middleware'] = name
+        response.set_header 'SourceMap', "#{@request.path_info}.map"
+
+        if Proscenium.config.cache_query_string && Proscenium.config.cache_max_age
+          response.cache! Proscenium.config.cache_max_age
+        end
+
+        yield response if block_given?
+
+        response.finish
+      end
+
+      def name
+        @name ||= self.class.name.split('::').last.downcase
+      end
+    end
+  end
+end

data/lib/proscenium/middleware/esbuild.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    class Esbuild < Base
+      class CompileError < Base::CompileError
+        def initialize(args)
+          detail = args[:detail]
+          detail = ActiveSupport::HashWithIndifferentAccess.new(Oj.load(detail, mode: :strict))
+
+          args[:detail] = if detail[:location]
+                            "#{detail[:text]} in #{detail[:location][:file]}:" +
+                              detail[:location][:line].to_s
+                          else
+                            detail[:text]
+                          end
+
+          super args
+        end
+      end
+
+      def attempt
+        ActiveSupport::Notifications.instrument('build.proscenium', identifier: path_to_build) do
+          render_response Proscenium::Esbuild.build(path_to_build, root: root,
+                                                                   base_url: @request.base_url)
+        end
+      rescue Proscenium::Esbuild::CompileError => e
+        raise self.class::CompileError, { file: @request.fullpath, detail: e.message }, caller
+      end
+    end
+  end
+end

data/lib/proscenium/middleware/url.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    # Handles requests for URL encoded URL's.
+    class Url < Esbuild
+      private
+
+      # @override [Esbuild] It's a URL, so always assume it is renderable (we won't actually know
+      #   until it's downloaded).
+      def renderable?
+        true
+      end
+    end
+  end
+end

data/lib/proscenium/middleware.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class Middleware
+    extend ActiveSupport::Autoload
+
+    # Error when the build command fails.
+    class BuildError < StandardError; end
+
+    autoload :Base
+    autoload :Esbuild
+    autoload :Url
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::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))
+
+      # file_handler.attempt(request.env) || type.attempt(request)
+
+      type.attempt(request)
+    end
+
+    # Returns the type of file being requested using Proscenium::MIDDLEWARE_GLOB_TYPES.
+    def find_type(request)
+      path = Pathname.new(request.path)
+
+      return Url if request.path.match?(glob_types[:url])
+      return Esbuild if path.fnmatch?(application_glob_type, File::FNM_EXTGLOB)
+    end
+
+    # TODO: handle precompiled assets
+    def file_handler
+      ::ActionDispatch::FileHandler.new Rails.public_path.join('assets').to_s,
+                                        headers: { 'X-Proscenium-Middleware' => 'precompiled' }
+    end
+
+    def glob_types
+      @glob_types ||= Proscenium::MIDDLEWARE_GLOB_TYPES
+    end
+
+    def application_glob_type
+      paths = Rails.application.config.proscenium.include_paths.join(',')
+      "/{#{paths}}#{glob_types[:application]}"
+    end
+  end
+end

data/lib/proscenium/phlex/component_concerns.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Proscenium::Phlex::ComponentConcerns
+  module CssModules
+    extend ActiveSupport::Concern
+    include Proscenium::CssModule
+    include Proscenium::Phlex::ResolveCssModules
+
+    # class_methods do
+    #   # FIXME: Still needed?
+    #   def path
+    #     pp name, super
+    #     pp Module.const_source_location(name).first
+
+    #     name && Pathname.new(Module.const_source_location(name).first)
+    #   rescue NameError
+    #     nil
+    #   end
+    # end
+
+    private
+
+    def path
+      self.class.path
+    end
+  end
+end

data/lib/proscenium/phlex/page.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'phlex/rails'
+
+# Include this in your view for additional logic for rendering a full HTML page, usually from a
+# controller.
+module Proscenium::Phlex::Page
+  include Phlex::Rails::Helpers::CSPMetaTag
+  include Phlex::Rails::Helpers::CSRFMetaTags
+  include Phlex::Rails::Helpers::FaviconLinkTag
+  include Phlex::Rails::Helpers::PreloadLinkTag
+  include Phlex::Rails::Helpers::StyleSheetLinkTag
+  include Phlex::Rails::Helpers::ActionCableMetaTag
+  include Phlex::Rails::Helpers::AutoDiscoveryLinkTag
+  include Phlex::Rails::Helpers::JavaScriptIncludeTag
+  include Phlex::Rails::Helpers::JavaScriptImportMapTags
+  include Phlex::Rails::Helpers::JavaScriptImportModuleTag
+
+  def self.included(klass)
+    klass.extend(Phlex::Rails::Layout::Interface)
+  end
+
+  def template(&block)
+    doctype
+    html do
+      head
+      body(&block)
+    end
+  end
+
+  private
+
+  def after_template
+    super
+    @_buffer.gsub!('<!-- [SIDE_LOAD_STYLESHEETS] -->', capture { side_load_stylesheets })
+  end
+
+  def page_title
+    Rails.application.class.name.deconstantize
+  end
+
+  def head
+    super do
+      title { page_title }
+
+      yield if block_given?
+
+      csp_meta_tag
+      csrf_meta_tags
+
+      comment { '[SIDE_LOAD_STYLESHEETS]' }
+    end
+  end
+
+  def body
+    super do
+      yield if block_given?
+
+      side_load_javascripts defer: true, type: :module
+    end
+  end
+end

data/lib/proscenium/phlex/react_component.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+#
+# Renders a div for use with @proscenium/component-manager.
+#
+# You can pass props to the component in the `:props` keyword argument.
+#
+# By default, the component is lazy loaded when intersecting using IntersectionObserver. Pass in
+# :lazy as false to disable this and render the component immediately.
+#
+# React components are not side loaded at all.
+#
+class Proscenium::Phlex::ReactComponent < Phlex::HTML
+  class << self
+    attr_accessor :path, :abstract_class
+
+    def inherited(child)
+      position = caller_locations(1, 1).first.label == 'inherited' ? 2 : 1
+      child.path = Pathname.new caller_locations(position, 1).first.path.sub(/\.rb$/, '')
+
+      super
+    end
+  end
+
+  self.abstract_class = true
+
+  include Proscenium::Phlex::ComponentConcerns::CssModules
+
+  attr_writer :props, :lazy
+
+  # @param props: [Hash]
+  # @param lazy: [Boolean] Lazy load the component using IntersectionObserver. Default: true.
+  def initialize(props: {}, lazy: true) # rubocop:disable Lint/MissingSuper
+    @props = props
+    @lazy = lazy
+  end
+
+  # @yield the given block to a `div` within the top level component div. If not given,
+  #   `<div>loading...</div>` will be rendered. Use this to display a loading UI while the component
+  #   is loading and rendered.
+  def template(**attributes, &block)
+    component_root(:div, **attributes, &block)
+  end
+
+  private
+
+  def component_root(element, **attributes, &block)
+    send element, data: { proscenium_component: component_data }, **attributes, &block
+  end
+
+  def props
+    @props ||= {}
+  end
+
+  def lazy
+    instance_variable_defined?(:@lazy) ? @lazy : (@lazy = false)
+  end
+
+  def component_data
+    {
+      path: virtual_path, lazy: lazy,
+      props: props.deep_transform_keys { |k| k.to_s.camelize :lower }
+    }.to_json
+  end
+
+  def virtual_path
+    path.to_s.delete_prefix(Rails.root.to_s)
+  end
+end