proscenium 0.16.0

data/lib/proscenium/side_load.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Proscenium
+  class SideLoad
+    module Controller
+      def self.included(child)
+        child.class_eval do
+          class_attribute :sideload_assets_options
+          child.extend ClassMethods
+
+          append_after_action :capture_and_replace_proscenium_stylesheets,
+                              :capture_and_replace_proscenium_javascripts,
+                              if: -> { response.content_type&.include?('html') }
+        end
+      end
+
+      module ClassMethods
+        def sideload_assets(value)
+          self.sideload_assets_options = value
+        end
+      end
+
+      def capture_and_replace_proscenium_stylesheets
+        return if response_body.nil?
+        return if response_body.first.blank? || !Proscenium::Importer.css_imported?
+        return unless response_body.first.include? '<!-- [PROSCENIUM_STYLESHEETS] -->'
+
+        imports = Proscenium::Importer.imported.dup
+        paths_to_build = []
+        Proscenium::Importer.each_stylesheet(delete: true) do |x, _|
+          paths_to_build << x.delete_prefix('/')
+        end
+
+        result = Proscenium::Builder.build_to_path(paths_to_build.join(';'),
+                                                   base_url: helpers.request.base_url)
+
+        out = []
+        result.split(';').each do |x|
+          inpath, outpath = x.split('::')
+          inpath.prepend '/'
+          outpath.delete_prefix! 'public'
+
+          next unless imports.key?(inpath)
+
+          import = imports[inpath]
+          opts = import[:css].is_a?(Hash) ? import[:css] : {}
+          opts[:data] ||= {}
+          opts[:data][:original_href] = inpath
+          out << helpers.stylesheet_link_tag(outpath, extname: false, **opts)
+        end
+
+        response_body.first.gsub! '<!-- [PROSCENIUM_STYLESHEETS] -->', out.join.html_safe
+      end
+
+      def capture_and_replace_proscenium_javascripts
+        return if response_body.nil?
+        return if response_body.first.blank? || !Proscenium::Importer.js_imported?
+
+        imports = Proscenium::Importer.imported.dup
+        paths_to_build = []
+        Proscenium::Importer.each_javascript(delete: true) do |x, _|
+          paths_to_build << x.delete_prefix('/')
+        end
+
+        result = Proscenium::Builder.build_to_path(paths_to_build.join(';'),
+                                                   base_url: helpers.request.base_url)
+
+        if response_body.first.include? '<!-- [PROSCENIUM_JAVASCRIPTS] -->'
+          out = []
+          scripts = {}
+          result.split(';').each do |x|
+            inpath, outpath = x.split('::')
+            inpath.prepend '/'
+            outpath.delete_prefix! 'public'
+
+            next unless imports.key?(inpath)
+
+            if (import = imports[inpath]).delete(:lazy)
+              scripts[inpath] = import.merge(outpath:)
+            else
+              opts = import[:js].is_a?(Hash) ? import[:js] : {}
+              out << helpers.javascript_include_tag(outpath, extname: false, **opts)
+            end
+          end
+
+          response_body.first.gsub! '<!-- [PROSCENIUM_JAVASCRIPTS] -->', out.join.html_safe
+        end
+
+        return unless response_body.first.include? '<!-- [PROSCENIUM_LAZY_SCRIPTS] -->'
+
+        lazy_script = ''
+        if scripts.present?
+          lazy_script = helpers.content_tag 'script', type: 'application/json',
+                                                      id: 'prosceniumLazyScripts' do
+            scripts.to_json.html_safe
+          end
+        end
+
+        response_body.first.gsub! '<!-- [PROSCENIUM_LAZY_SCRIPTS] -->', lazy_script
+      end
+    end
+
+    class << self
+      # Side loads the class, and its super classes that respond to `.source_path`.
+      #
+      # Set the `abstract_class` class variable to true in any class, and it will not be side
+      # loaded.
+      #
+      # 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, options)
+        return unless Proscenium.config.side_load
+
+        options = {} if options.nil?
+        options = { js: options, css: options } unless options.is_a?(Hash)
+
+        unless obj.sideload_assets_options.nil?
+          tpl_options = obj.sideload_assets_options
+          options = if tpl_options.is_a?(Hash)
+                      options.deep_merge tpl_options
+                    else
+                      { js: tpl_options, css: tpl_options }
+                    end
+        end
+
+        %i[css js].each do |k|
+          options[k] = obj.instance_eval(&options[k]) if options[k].is_a?(Proc)
+        end
+
+        css_imports = []
+
+        klass = obj.class
+        while klass.respond_to?(:source_path) && klass.source_path && !klass.abstract_class
+          if klass.respond_to?(:sideload)
+            klass.sideload options
+          elsif options[:css] == false
+            Importer.sideload klass.source_path, **options
+          else
+            Importer.sideload_js klass.source_path, **options
+            css_imports << klass.source_path
+          end
+
+          klass = klass.superclass
+        end
+
+        # The reason why we sideload CSS after JS is because the order of CSS is important.
+        # Basically, the layout should be loaded before the view so that CSS cascading works i9n the
+        # right direction.
+        css_imports.reverse_each do |it|
+          Importer.sideload_css it, **options
+        end
+      end
+    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/ui/breadcrumbs/component.module.css

@@ -0,0 +1,14 @@
+@layer proscenium-ui-component {
+  /*
+   * Custom properties:
+   *
+   *   --puiBreadcrumbs--link-color: LinkText;
+   *   --puiBreadcrumbs--link-hover-color: HighlightText;
+   *   --puiBreadcrumbs--separator-color: GrayText;
+   *   --puiBreadcrumbs--separator: url("/proscenium/icons/angle-right-regular.svg");
+   */
+
+  .base {
+    @mixin breadcrumbs from url("./mixins.css");
+  }
+}

data/lib/proscenium/ui/breadcrumbs/component.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Proscenium::UI
+  class Breadcrumbs::Component < Component
+    include Phlex::Rails::Helpers::URLFor
+
+    # The path (route) to use as the HREF for the home segment. Defaults to `:root`.
+    option :home_path, Types::String | Types::Symbol, default: -> { :root }
+
+    # Assign false to hide the home segment.
+    option :with_home, Types::Bool, default: -> { true }
+
+    # One or more class name(s) for the base div element which will be appended to the default.
+    option :class, Types::Coercible::String | Types::Array.of(Types::Coercible::String),
+           as: :class_name, default: -> { [] }
+
+    # One or more class name(s) for the base div element which will replace the default. If both
+    # `class` and `class!` are provided, all values will be merged. Defaults to `:@base`.
+    option :class!, Types::Coercible::String | Types::Array.of(Types::Coercible::String),
+           as: :class_name_override, default: -> { :@base }
+
+    def view_template
+      div class: [*class_name_override, *class_name] do
+        ol do
+          if with_home
+            li do
+              home_template
+            end
+          end
+
+          breadcrumbs.each do |ce|
+            li do
+              path = ce.path
+              path.nil? ? ce.name : a(href: url_for(path)) { ce.name }
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    # Override this to customise the home breadcrumb. You can call super with a block to use the
+    # default template, but with custom content.
+    #
+    # @example
+    #  def home_template
+    #    super { 'hello' }
+    #  end
+    def home_template(&block)
+      a(href: url_for(home_path)) do
+        if block
+          yield
+        else
+          svg role: 'img', xmlns: 'http://www.w3.org/2000/svg', viewBox: '0 0 576 512' do |s|
+            s.path fill: 'currentColor',
+                   d: 'M488 312.7V456c0 13.3-10.7 24-24 24H348c-6.6 0-12-5.4-12-12V356c0-6.6-5.4-' \
+                      '12-12-12h-72c-6.6 0-12 5.4-12 12v112c0 6.6-5.4 12-12 12H112c-13.3 0-24-10.' \
+                      '7-24-24V312.7c0-3.6 1.6-7 4.4-9.3l188-154.8c4.4-3.6 10.8-3.6 15.3 0l188 15' \
+                      '4.8c2.7 2.3 4.3 5.7 4.3 9.3zm83.6-60.9L488 182.9V44.4c0-6.6-5.4-12-12-12h-' \
+                      '56c-6.6 0-12 5.4-12 12V117l-89.5-73.7c-17.7-14.6-43.3-14.6-61 0L4.4 251.8c' \
+                      '-5.1 4.2-5.8 11.8-1.6 16.9l25.5 31c4.2 5.1 11.8 5.8 16.9 1.6l235.2-193.7c4' \
+                      '.4-3.6 10.8-3.6 15.3 0l235.2 193.7c5.1 4.2 12.7 3.5 16.9-1.6l25.5-31c4.2-5' \
+                      '.2 3.4-12.7-1.7-16.9z'
+          end
+        end
+      end
+    end
+
+    # Don't render if @hide_breadcrumbs is true.
+    def render?
+      helpers.assigns['hide_breadcrumbs'] != true
+    end
+
+    def breadcrumbs
+      helpers.controller.breadcrumbs.map { |e| Breadcrumbs::ComputedElement.new e, helpers }
+    end
+  end
+end

data/lib/proscenium/ui/breadcrumbs/computed_element.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Proscenium::UI::Breadcrumbs
+  class ComputedElement
+    def initialize(element, context)
+      @element = element
+      @context = context
+    end
+
+    # If name is a Symbol of a controller method, that method is called.
+    # If name is a Symbol of a controller instance variable, that variable is returned.
+    # If name is a Proc, it is executed in the context of the controller instance.
+    #
+    # @return [String] the content of the breadcrumb element.
+    def name
+      @name ||= case name = @element.name
+                when Symbol
+                  if name.to_s.starts_with?('@')
+                    name = get_instance_variable(name)
+                    name.respond_to?(:for_breadcrumb) ? name.for_breadcrumb : name.to_s
+                  else
+                    res = @context.controller.send(name)
+                    res.try(:for_breadcrumb) || res.to_s
+                  end
+                when Proc
+                  @context.controller.instance_exec(&name)
+                else
+                  name.respond_to?(:for_breadcrumb) ? name.for_breadcrumb : name.to_s
+                end
+    end
+
+    # If path is a Symbol of a controller method, that method is called.
+    # If path is a Symbol of a controller instance variable, that variable is returned.
+    # If path is an Array, each element is processed as above.
+    # If path is a Proc, it is executed in the context of the controller instance.
+    #
+    # No matter what, the result is always passed to `url_for` before being returned.
+    #
+    # @return [String] the URL for the element
+    def path
+      @path ||= unless @element.path.nil?
+                  case path = @element.path
+                  when Array
+                    path.map! { |x| x.to_s.starts_with?('@') ? get_instance_variable(x) : x }
+                  when Symbol
+                    if path.to_s.starts_with?('@')
+                      path = get_instance_variable(path)
+                    elsif @context.controller.respond_to?(path, true)
+                      path = @context.controller.send(path)
+                    end
+                  when Proc
+                    path = @context.controller.instance_exec(&path)
+                  end
+
+                  @context.url_for path
+                end
+    end
+
+    private
+
+    def get_instance_variable(element)
+      unless @context.instance_variable_defined?(element)
+        raise NameError, "undefined instance variable `#{element}' for breadcrumb", caller
+      end
+
+      @context.instance_variable_get element
+    end
+  end
+end

data/lib/proscenium/ui/breadcrumbs/control.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Proscenium::UI::Breadcrumbs
+  # Include this module in your controller to add support for adding breadcrumb elements. You can
+  # then use the `add_breadcrumb` and `prepend_breadcrumb` class methods to append and/or prepend
+  # breadcrumb elements.
+  module Control
+    extend ActiveSupport::Concern
+    include ActionView::Helpers::SanitizeHelper
+
+    included do
+      helper_method :breadcrumbs_as_json, :breadcrumbs_for_title if respond_to?(:helper_method)
+    end
+
+    module ClassMethods
+      # Appends a new breadcrumb element into the collection.
+      #
+      # @param name [String, Symbol, Proc, #for_breadcrumb] The name or content of the breadcrumb.
+      # @param path [String, Symbol, Array, Proc, nil] The path (route) to use as the HREF for the
+      #   breadcrumb.
+      # @param filter_options [Hash] Options to pass through to the before_action filter.
+      def add_breadcrumb(name, path = nil, **filter_options)
+        element_options = filter_options.delete(:options) || {}
+
+        before_action(filter_options) do |controller|
+          controller.send :add_breadcrumb, name, path, element_options
+        end
+      end
+
+      # Prepend a new breadcrumb element into the collection.
+      #
+      # @param name [String, Symbol, Proc, #for_breadcrumb] The name or content of the breadcrumb.
+      # @param path [String, Symbol, Array, Proc, nil] The path (route) to use as the HREF for the
+      #   breadcrumb.
+      # @param filter_options [Hash] Options to pass through to the before_action filter.
+      def prepend_breadcrumb(name, path = nil, **filter_options)
+        element_options = filter_options.delete(:options) || {}
+
+        before_action(filter_options) do |controller|
+          controller.send :prepend_breadcrumb, name, path, element_options
+        end
+      end
+    end
+
+    # Pushes a new breadcrumb element into the collection.
+    #
+    # @param name [String, Symbol, Proc, #for_breadcrumb] The name or content of the breadcrumb.
+    # @param path [String, Symbol, Array, Proc, nil] The path (route) to use as the HREF for the
+    #   breadcrumb.
+    # @param options [Hash]
+    def add_breadcrumb(name, path = nil, options = {})
+      breadcrumbs << Element.new(name, path, options)
+    end
+
+    # Prepend a new breadcrumb element into the collection.
+    #
+    # @param name [String, Symbol, Proc, #for_breadcrumb] The name or content of the breadcrumb.
+    # @param path [String, Symbol, Array, Proc, nil] The path (route) to use as the HREF for the
+    #   breadcrumb.
+    # @param options [Hash]
+    def prepend_breadcrumb(name, path = nil, options = {})
+      breadcrumbs.prepend Element.new(name, path, options)
+    end
+
+    def breadcrumbs
+      @breadcrumbs ||= []
+    end
+
+    def breadcrumbs_as_json
+      computed_breadcrumbs.map do |ele|
+        path = ele.path
+
+        { name: ele.name, path: ele.path.nil? || helpers.current_page?(path) ? nil : path }
+      end
+    end
+
+    # @param primary [Boolean] whether to return only the primary breadcrumb.
+    def breadcrumbs_for_title(primary: false)
+      names = computed_breadcrumbs.map(&:name)
+      return names.pop if primary
+
+      out = [names.pop]
+      out << names.join(': ') unless names.empty?
+      strip_tags out.join(' - ')
+    end
+
+    private
+
+    def computed_breadcrumbs
+      @computed_breadcrumbs ||= breadcrumbs.map do |ele|
+        ComputedElement.new ele, helpers
+      end
+    end
+  end
+end

data/lib/proscenium/ui/breadcrumbs/mixins.css

@@ -0,0 +1,83 @@
+@define-mixin breadcrumbs {
+  /* Default properties */
+  --_puiBreadcrumbs--separator-color: GrayText;
+  --_puiBreadcrumbs--separator: url("/proscenium/icons/angle-right-regular.svg");
+
+  margin: 10px;
+
+  ol {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    display: flex;
+    align-items: baseline;
+
+    li {
+      text-transform: uppercase;
+      display: flex;
+      align-items: center;
+
+      @media (max-width: 426px) {
+        &:not(:nth-last-child(2)) {
+          display: none;
+        }
+
+        &:nth-last-child(2)::before {
+          @mixin _separator;
+          margin: 0 0.5rem 0 0;
+          transform: rotate(180deg);
+        }
+      }
+
+      @media (min-width: 427px) {
+        &:not(:last-child)::after {
+          @mixin _separator;
+          margin: 0 0.5rem;
+        }
+      }
+
+      &:last-child {
+        font-weight: 500;
+        text-transform: none;
+      }
+
+      &:last-child > a {
+        font-weight: 500;
+        text-transform: none;
+      }
+
+      a {
+        color: var(--puiBreadcrumbs--link-color, revert);
+        display: flex;
+
+        &:hover {
+          color: var(--puiBreadcrumbs--link-hover-color, revert);
+        }
+      }
+
+      svg {
+        height: 1em;
+        width: 1em;
+      }
+    }
+  }
+}
+
+@define-mixin _separator {
+  display: inline-block;
+  content: "";
+  height: 1rem;
+  width: 1rem;
+  -webkit-mask: var(
+      --puiBreadcrumbs--separator,
+      var(--_puiBreadcrumbs--separator)
+    )
+    no-repeat center center;
+  mask: var(--puiBreadcrumbs--separator, var(--_puiBreadcrumbs--separator))
+    no-repeat center center;
+  vertical-align: sub;
+  background-color: var(
+    --puiBreadcrumbs--separator-color,
+    var(--_puiBreadcrumbs--separator-color)
+  );
+}

data/lib/proscenium/ui/breadcrumbs.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Proscenium::UI
+  # Provides breadcrumb functionality for controllers and views. Breadcrumbs are a type of
+  # navigation that show the user where they are in the application's hierarchy.
+  # The `Proscenium::UI::Breadcrumbs::Control` module provides the `add_breadcrumb` and
+  # `prepend_breadcrumb` class methods for adding breadcrumb elements, and is intended to be
+  # included in your controllers.
+  #
+  # The `add_breadcrumb` method adds a new breadcrumb element to the end of the collection, while
+  # the `prepend_breadcrumb` method adds a new breadcrumb element to the beginning of the
+  # collection. Both methods take a name, and path as arguments. The name argument is the name or
+  # content of the breadcrumb, while the path argument is the path (route) to use as the HREF for
+  # the breadcrumb.
+  #
+  #   class UsersController < ApplicationController
+  #     include Proscenium::UI::Breadcrumbs::Control
+  #     add_breadcrumb 'Users', :users_path
+  #   end
+  #
+  # Display the breadcrumbs in your views with the breadcrumbs component.
+  # @see `Proscenium::UI::Breadcrumbs::Component`.
+  #
+  # At it's simplest, you can add a breadcrumb with a name of "User", and a path of "/users" like
+  # this:
+  #
+  #   add_breadcrumb 'Foo', '/foo'
+  #
+  # The value of the path is always passed to `url_for` before being rendered. It is also optional,
+  # and if omitted, the breadcrumb will be rendered as plain text.
+  #
+  # Both name and path can be given a Symbol, which can be used to call a method of the same name on
+  # the controller. If a Symbol is given as the path, and no method of the same name exists, then
+  # `url_for` will be called with the Symbol as the argument. Likewise, if an Array is given as the
+  # path, then `url_for` will be called with the Array as the argument.
+  #
+  # If a Symbol is given as the path or name, and it begins with `@` (eg. `:@foo`), then the
+  # instance variable of the same name will be called.
+  #
+  #   add_breadcrumb :@foo, :@bar
+  #
+  # A Proc can also be given as the name and/or path. The Proc will be called within the context of
+  # the controller.
+  #
+  #   add_breadcrumb -> { @foo }, -> { @bar }
+  #
+  # Passing an object that responds to `#for_breadcrumb` as the name will call that method on the
+  # object to get the breadcrumb name.
+  #
+  module Breadcrumbs
+    extend ActiveSupport::Autoload
+
+    autoload :Control
+    autoload :ComputedElement
+    autoload :Component
+
+    # Represents a navigation element in the breadcrumb collection.
+    class Element
+      attr_accessor :name, :path, :options
+
+      # @param  name [String] the element/link name
+      # @param  path [String] the element/link URL
+      # @param  options [Hash] the element/link options
+      # @return [Element]
+      def initialize(name, path = nil, options = {})
+        self.name = name
+        self.path = path
+        self.options = options
+      end
+    end
+  end
+end

data/lib/proscenium/ui/component.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'dry-initializer'
+
+module Proscenium::UI
+  class Component < Proscenium::Phlex
+    self.abstract_class = true
+
+    extend Dry::Initializer
+  end
+end

data/lib/proscenium/ui/test.js

@@ -0,0 +1 @@
+console.log("/proscenium/ui/test.js");

data/lib/proscenium/ui.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'dry-types'
+
+module Proscenium::UI
+  extend ActiveSupport::Autoload
+
+  autoload :Component
+  autoload :Breadcrumbs
+
+  module Types
+    include Dry.Types()
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Proscenium
+  VERSION = '0.16.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