unmagic-components 0.3.0 → 0.4.0

data/lib/unmagic/components/ai_chat/workspace.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Unmagic
+  module Components
+    module AIChat
+      # The files an agent has put aside while it works. A flat list for now: a
+      # nested tree waits on the gem's tree_view, rather than the gem growing two
+      # tree implementations. See ActionViewHelpers#ai_chat_workspace.
+      class Workspace
+        File = Struct.new(:path, :size, :url, :icon)
+
+        def initialize(view, title: nil, count: nil, open: true, empty: nil, collapsible: true, title_tag: :h2, **options)
+          @view = view
+          @title = title || AIChat.t("workspace.title", default: "Workspace")
+          @count = count
+          @open = open
+          @empty = empty
+          @collapsible = collapsible
+          @title_tag = title_tag
+          @options = options
+          @files = []
+        end
+
+        def file(path, size: nil, url: nil, icon: :file)
+          @files << File.new(path.to_s, size, url, icon)
+          nil
+        end
+
+        def render
+          count = @count || (@files.size if @files.any?)
+
+          Section.new(view, block: "UnmagicAIChatWorkspace", icon: :folder, title: @title, count: count,
+            open: @open, collapsible: @collapsible, title_tag: @title_tag, options: @options).render(body)
+        end
+
+        private
+
+        attr_reader :view
+
+        delegate :tag, :safe_join, to: :view, private: true
+
+        def body
+          if @files.empty?
+            tag.p(@empty || AIChat.t("workspace.empty", default: "No files yet."), class: "UnmagicAIChatWorkspace__empty")
+          else
+            tag.ul(safe_join(@files.map { |file| item(file) }), class: "UnmagicAIChatWorkspace__files")
+          end
+        end
+
+        # Not a link without a url: a workspace is usually read-only, and a link
+        # that goes nowhere is worse than plain text.
+        def item(file)
+          name = ::File.basename(file.path)
+          directory = ::File.dirname(file.path)
+
+          row = safe_join [
+            Icons.svg(view, file.icon, class: "UnmagicAIChatWorkspace__icon"),
+            tag.span(class: "UnmagicAIChatWorkspace__name") do
+              safe_join [
+                (tag.span("#{directory}/", class: "UnmagicAIChatWorkspace__directory") unless directory == "."),
+                name
+              ].compact
+            end,
+            (tag.span(view.number_to_human_size(file.size), class: "UnmagicAIChatWorkspace__size") if file.size)
+          ].compact
+
+          tag.li(class: "UnmagicAIChatWorkspace__file", title: file.path) do
+            file.url ? view.link_to(row, file.url, class: "UnmagicAIChatWorkspace__link") : row
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unmagic/components/ai_chat.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Unmagic
+  module Components
+    # The components for rendering an agent's work: a transcript of turns, the
+    # tools it reached for, the plan it is following, the questions it stopped to
+    # ask, and the box a person answers in. ai_chat is the root; the rest are
+    # ai_chat_* helpers. See docs/components/ai_chat.
+    module AIChat
+      # Validates an enumerated option the way every component in the gem does.
+      def self.validate!(component, option, value, allowed)
+        return if allowed.include?(value)
+
+        raise ArgumentError, "unknown #{component} #{option} #{value.inspect} (expected one of #{allowed.inspect})"
+      end
+
+      # A word the gem prints, under the family's I18n scope.
+      def self.t(key, **options)
+        I18n.t("unmagic.components.ai_chat.#{key}", **options)
+      end
+
+      # A base for element ids that must reference each other when the caller
+      # gave none.
+      def self.random_id(name)
+        "unmagic_ai_chat_#{name}_#{SecureRandom.hex(4)}"
+      end
+    end
+  end
+end

data/lib/unmagic/components/avatar.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+require "unmagic/color"
+
+module Unmagic
+  module Components
+    # A person's or organisation's picture, falling back to their initials. See
+    # ActionViewHelpers#avatar.
+    class Avatar
+      SIZES = %i[small medium large].freeze
+      SHAPES = %i[circle square].freeze
+      TINTS = 6
+
+      # The skeleton for each size, so a loading avatar and a loaded one line up.
+      DIMENSIONS = { small: "1.5rem", medium: "2rem", large: "2.5rem" }.freeze
+
+      class << self
+        # "Ada Lovelace" → "AL", "Plato" → "P".
+        def initials(name)
+          words = name.to_s.squish.split
+          return "" if words.empty?
+
+          [ words.first, (words.last if words.size > 1) ].compact.map { |word| word[0] }.join.upcase
+        end
+
+        # One of six palette tints, the same for a name on every page and every
+        # server. Ruby's String#hash is seeded per process, so it can't be used here;
+        # unmagic-color's string hash is stable.
+        def tint(name)
+          normalised = name.to_s.squish.downcase
+          return if normalised.empty?
+
+          (Unmagic::Color::String::HashFunction.call(normalised) % TINTS) + 1
+        end
+
+        def validate!(size, shape)
+          unless SIZES.include?(size)
+            raise ArgumentError, "unknown avatar size #{size.inspect} (expected one of #{SIZES.inspect})"
+          end
+          return if SHAPES.include?(shape)
+
+          raise ArgumentError, "unknown avatar shape #{shape.inspect} (expected one of #{SHAPES.inspect})"
+        end
+      end
+
+      def initialize(view, name, src: nil, size: :medium, shape: :circle, tint: true, skeleton: false, **options)
+        self.class.validate!(size, shape)
+
+        @view = view
+        @name = name.to_s.squish
+        @src = src
+        @size = size
+        @shape = shape
+        @tint = tint
+        @skeleton = skeleton
+        @options = options
+      end
+
+      # The initials always render and the image sits on top of them, so an image
+      # that fails to load shows the initials through it without any script.
+      def render
+        return Skeleton.new(view).circle(size: DIMENSIONS.fetch(@size), **@options) if @skeleton
+
+        tint = self.class.tint(@name) if @tint
+        view.content_tag(:span, **@options,
+          role: "img",
+          "aria-label": @name.presence,
+          title: @name.presence,
+          class: view.class_names("UnmagicAvatar", "UnmagicAvatar--#{@size}",
+            { "UnmagicAvatar--square" => @shape == :square, "UnmagicAvatar--tint-#{tint}" => tint }, @options[:class])) do
+          safe_join [
+            tag.span(@name.present? ? self.class.initials(@name) : "—", class: "UnmagicAvatar__initials", "aria-hidden": "true"),
+            (tag.img(src: @src, alt: "", loading: "lazy", decoding: "async", class: "UnmagicAvatar__image") if @src.present?)
+          ].compact
+        end
+      end
+
+      private
+
+      attr_reader :view
+
+      delegate :tag, :safe_join, to: :view, private: true
+    end
+
+    # A stack of avatars, collapsing past max: into a "+N" counter. See
+    # ActionViewHelpers#avatar_group.
+    class AvatarGroup
+      def initialize(view, max: nil, size: :medium, shape: :circle, **options)
+        Avatar.validate!(size, shape)
+
+        @view = view
+        @max = max
+        @size = size
+        @shape = shape
+        @options = options
+        @people = []
+      end
+
+      # The group sets the size, so a stack never mixes them.
+      def avatar(name, **options)
+        raise ArgumentError, "an avatar in a group takes the group's size" if options.key?(:size)
+        raise ArgumentError, "an avatar in a group takes the group's shape" if options.key?(:shape)
+
+        @people << [ name, options ]
+        nil
+      end
+
+      def render
+        shown = @max ? @people.first(@max) : @people
+        hidden = @people.drop(shown.size)
+        label = I18n.t("unmagic.components.avatar.group", count: @people.size, default: "%{count} people")
+
+        view.content_tag(:div, **@options, role: "group", "aria-label": label,
+          class: view.class_names("UnmagicAvatarGroup", "UnmagicAvatarGroup--#{@size}", @options[:class])) do
+          view.safe_join [
+            *shown.map { |name, options| Avatar.new(view, name, size: @size, shape: @shape, **options).render },
+            (more(hidden) if hidden.any?)
+          ].compact
+        end
+      end
+
+      private
+
+      attr_reader :view
+
+      def more(hidden)
+        view.tag.span(I18n.t("unmagic.components.avatar.more", count: hidden.size, default: "+%{count}"),
+          title: hidden.map(&:first).join(", "),
+          class: view.class_names("UnmagicAvatarGroup__more", { "UnmagicAvatar--square" => @shape == :square }))
+      end
+    end
+  end
+end

data/lib/unmagic/components/board.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Unmagic
+  module Components
+    # A Trello-style board: columns of cards, both reorderable, with a way to add
+    # to each. Built from sortable lists, so it posts the same drops. See
+    # ActionViewHelpers#board.
+    class Board
+      def initialize(view, id:, url: nil, columns_url: nil, sortable_columns: true, label: nil, column_height: nil,
+        **options)
+        raise ArgumentError, "board needs an id: (it names the board's lists)" if id.blank?
+
+        @view = view
+        @id = id.to_s
+        @url = url
+        @columns_url = columns_url.nil? ? url : columns_url
+        @sortable_columns = sortable_columns
+        @label = label || I18n.t("unmagic.components.board.label", default: "Board")
+        @column_height = column_height
+        @options = options
+        @columns = []
+        @add_column = nil
+      end
+
+      def column(record = nil, title:, key: nil, rank: nil, params: {}, count: nil, &block)
+        builder = Column.new(view, self, record: record, title: title, key: key, rank: rank, params: params, count: count)
+        view.capture(builder, &block) if block
+        @columns << builder
+        nil
+      end
+
+      # The tile at the end of the board that adds a column.
+      def add_column(url:, field:, label: nil, placeholder: nil, params: {}, method: :post)
+        label ||= I18n.t("unmagic.components.board.add_column", default: "Add a list")
+        @add_column = Board.add_form(view, id: "#{@id}_add_column", url: url, field: field, label: label,
+          placeholder: placeholder,
+          params: params, method: method, submit: I18n.t("unmagic.components.board.add_column_submit", default: "Add list"),
+          class: "UnmagicBoard__addColumn")
+        nil
+      end
+
+      attr_reader :id, :url
+
+      def cards_namespace = "#{id}-cards"
+
+      def render
+        # --unmagic-board-column-height is the board's one knob: how tall a column
+        # grows before its cards scroll.
+        style = [ @options[:style], ("--unmagic-board-column-height: #{@column_height}" if @column_height) ].compact.join("; ")
+
+        view.content_tag(:div, **@options, id: @id, role: "region", "aria-label": @label, style: style.presence,
+          class: view.class_names("UnmagicBoard", @options[:class])) do
+          if @sortable_columns
+            list = Sortable::List.new(view, namespace: "#{@id}-columns", url: @columns_url, orientation: :horizontal,
+              label: @label, class: "UnmagicBoard__columns")
+            @columns.each { |column| column.add_to(list) }
+            list.render(@add_column && view.tag.div(@add_column, class: "UnmagicBoard__tail", "data-sortable-tail": ""))
+          else
+            view.tag.div(class: "UnmagicBoard__columns") do
+              view.safe_join [ *@columns.map { |column| view.tag.div(column.panel(handle: false), class: "UnmagicBoard__column") },
+                (view.tag.div(@add_column, class: "UnmagicBoard__tail") if @add_column) ].compact
+            end
+          end
+        end
+      end
+
+      # A <details> that opens into a one-field form: Trello's "Add a card". Enter
+      # submits, Escape closes, and it stays open after adding so several can be
+      # added in a row (board.js).
+      #
+      # The field has a stable id so a morph refresh keeps the same element, and with
+      # it the focus, after each add.
+      def self.add_form(view, id:, url:, field:, label:, placeholder:, params:, method:, submit:, **options)
+        view.tag.details(**options, class: view.class_names("UnmagicBoard__add", options[:class])) do
+          view.safe_join [
+            view.tag.summary(class: "UnmagicBoard__addToggle") do
+              view.safe_join [ Icons.svg(view, :plus), label ]
+            end,
+            view.form_with(url: url, method: method, class: "UnmagicBoard__addForm", data: { board_add: "" }) do
+              view.safe_join [
+                *params.map { |name, value| view.hidden_field_tag(name, value, id: nil) },
+                Autogrow.wrap(view, view.text_area_tag(field, nil, Control.merge(view, {
+                  id: id, rows: 2, required: true, placeholder: placeholder || label, "aria-label": label,
+                  "data-board-add-field": "", class: "UnmagicBoard__addField"
+                }, :text_area))),
+                view.tag.div(class: "UnmagicBoard__addActions") do
+                  cancel = I18n.t("unmagic.components.board.cancel", default: "Cancel")
+                  view.safe_join [
+                    view.tag.button(submit, type: "submit", class: Button.classes(:primary, size: :small)),
+                    view.tag.button(Icons.svg(view, :x), type: "button", "data-board-add-cancel": "",
+                      "aria-label": cancel, title: cancel, class: Button.classes(:icon))
+                  ]
+                end
+              ]
+            end
+          ]
+        end
+      end
+
+      private
+
+      attr_reader :view
+
+      # One column: a header that is its drag handle, a sortable list of cards, and
+      # an add-card form.
+      class Column
+        def initialize(view, board, record:, title:, key:, rank:, params:, count:)
+          @view = view
+          @board = board
+          @record = record
+          @title = title
+          @key = key
+          @rank = rank
+          @params = params
+          @count = count
+          @cards = Sortable::List.new(view, namespace: board.cards_namespace, params: params, url: board.url,
+            label: title, class: "UnmagicBoard__cards")
+          @card_count = 0
+          @actions = nil
+          @add = nil
+          # Stable across renders, so a morph matches the column's elements up.
+          @dom_id = "#{board.id}_column_#{(key || record&.to_param || title).to_s.parameterize(separator: "_")}"
+        end
+
+        def card(record = nil, key: nil, rank: nil, label: nil, **options, &block)
+          @card_count += 1
+          @cards.item(record, key: key, rank: rank, label: label, **options,
+            class: view.class_names("UnmagicBoard__card", options[:class]), &block)
+        end
+
+        def actions(content = nil, &block)
+          @actions = block ? view.capture(&block) : content
+          nil
+        end
+
+        def add(url:, field:, label: nil, placeholder: nil, params: {}, method: :post)
+          label ||= I18n.t("unmagic.components.board.add_card", default: "Add a card")
+          @add = Board.add_form(view, id: "#{@dom_id}_add", url: url, field: field, label: label,
+            placeholder: placeholder, params: params,
+            method: method, submit: I18n.t("unmagic.components.board.add_card_submit", default: "Add card"))
+          nil
+        end
+
+        def add_to(list)
+          list.item(@record, key: @key, rank: @rank, label: @title, class: "UnmagicBoard__column") { panel(handle: true) }
+        end
+
+        # The header is where a column is picked up by pointer; the grip inside it is
+        # its keyboard stop. The header's own buttons stay clickable.
+        def panel(handle:)
+          view.tag.section(class: "UnmagicBoard__panel", "aria-labelledby": "#{@dom_id}_title") do
+            view.safe_join [
+              view.tag.header(class: "UnmagicBoard__head", "data-sortable-handle": (handle ? "" : nil)) do
+                view.safe_join [
+                  (Sortable.handle(view, label: I18n.t("unmagic.components.board.move_column", title: @title,
+                    default: "Move %{title}"), class: "UnmagicBoard__grip") if handle),
+                  view.tag.h3(@title, id: "#{@dom_id}_title", class: "UnmagicBoard__title"),
+                  count,
+                  (view.tag.div(@actions, class: "UnmagicBoard__actions") if @actions.present?)
+                ].compact
+              end,
+              @cards.render,
+              @add
+            ].compact
+          end
+        end
+
+        private
+
+        attr_reader :view
+
+        def count
+          number = @count || @card_count
+          noun = I18n.t("unmagic.components.board.cards", count: number, default: number == 1 ? "card" : "cards")
+          view.tag.span(class: "UnmagicBoard__count") do
+            view.safe_join [ number.to_s, view.tag.span(" #{noun}", class: "UnmagicVisuallyHidden") ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/unmagic/components/browser/app/controllers/unmagic/components/browser/application_controller.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Unmagic
+  module Components
+    module Browser
+      # Inherits ActionController::Base rather than the host's ApplicationController,
+      # so the host's authentication, layout and callbacks stay out. Access is the
+      # host's to decide where it mounts the browser.
+      class ApplicationController < ActionController::Base
+        include Unmagic::Components::DialogResponder
+
+        THEMES = %w[light dark].freeze
+
+        # Everything the browser keeps in the host's session sits under keys with
+        # this prefix, so none collides with the host's own.
+        SESSION_PREFIX = "unmagic_components_browser"
+
+        # A frame request gets no layout, as turbo-rails arranges for an app's
+        # default one; naming a layout here would otherwise override that.
+        layout -> { turbo_frame_request? ? false : "unmagic/components/browser/application" }
+
+        helper Unmagic::Components::Browser::ApplicationHelper
+        helper_method :dark_theme?
+
+        before_action :require_turbo, :remember_theme, :load_catalog
+
+        private
+
+        # Checked per request rather than at load, because a host that eager loads
+        # the browser's classes without mounting it may not have Turbo at all.
+        def require_turbo
+          return if defined?(::Turbo::Engine)
+
+          raise "Unmagic::Components::Browser needs turbo-rails: add it to your Gemfile"
+        end
+
+        # ?theme=dark or ?theme=light switches the browser and sticks for the
+        # session, so links and redirects don't each have to carry it.
+        def remember_theme
+          browser_session[:theme] = params[:theme] if THEMES.include?(params[:theme])
+        end
+
+        def dark_theme? = browser_session[:theme] == "dark"
+
+        def load_catalog
+          Catalog.reload! if Rails.env.development?
+          @components = Catalog.all
+          @component_groups = Catalog.grouped
+        end
+
+        def browser_session = BrowserSession.new(session)
+
+        def stored_profile
+          Profile.new(browser_session[:profile] || { name: "Ada Lovelace", role: "Engineer" })
+        end
+
+        def board_store = @board_store ||= BoardStore.new(browser_session)
+
+        # The host's session, seen through prefixed keys.
+        class BrowserSession
+          def initialize(session)
+            @session = session
+          end
+
+          def [](key) = @session[name(key)]
+
+          def []=(key, value)
+            @session[name(key)] = value
+          end
+
+          def delete(key) = @session.delete(name(key))
+
+          private
+
+          def name(key) = "#{SESSION_PREFIX}_#{key}"
+        end
+      end
+    end
+  end
+end

data/lib/unmagic/components/browser/app/controllers/unmagic/components/browser/demos_controller.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Unmagic
+  module Components
+    module Browser
+      # What the interactive examples talk to: the dialogs, the toasts, the board
+      # and the AI chat composer. Everything they change lives in the visitor's
+      # session.
+      class DemosController < ApplicationController
+        FLASH_TYPES = %w[notice alert warning info].freeze
+
+        def edit_profile
+          @profile = stored_profile
+        end
+
+        def update_profile
+          @profile = Profile.new(params.require(:profile).permit(:name, :role))
+
+          if @profile.valid?
+            browser_session[:profile] = @profile.attributes
+            refresh_or_redirect component_path("dialog"), notice: "Profile saved."
+          else
+            render :edit_profile, status: 422
+          end
+        end
+
+        def destroy_profile
+          browser_session.delete(:profile)
+          redirect_to component_path("confirm"), status: :see_other, notice: "Profile reset."
+        end
+
+        # Slow enough to watch the skeleton before the form arrives.
+        def slow_dialog
+          sleep 1.5
+          @profile = stored_profile
+          render :edit_profile
+        end
+
+        # An empty error response: the case Turbo ignores unless the modal catches it.
+        def forbidden_dialog
+          head :forbidden
+        end
+
+        def flash_toast
+          type = FLASH_TYPES.include?(params[:type]) ? params[:type] : "notice"
+          flash[type] = params[:message]
+          redirect_to component_path("toast"), status: :see_other
+        end
+
+        def stream_toast
+          tone = Toast::TONES.map(&:to_s).include?(params[:tone]) ? params[:tone].to_sym : :good
+          render turbo_stream: turbo_stream.toast(params[:message], tone: tone)
+        end
+
+        # The board example's server, answering as unmagic-sortable's endpoint does:
+        # a refresh, which morphs the page to the order that was saved.
+        def board_order
+          moved = board_store.move(params[:moved], prev: params[:prev], following: params[:next], column: params[:column])
+          board_refresh(moved ? :ok : :not_found)
+        end
+
+        def board_card
+          board_store.add_card(params.dig(:card, :title), params.dig(:card, :column))
+          board_refresh
+        end
+
+        def board_column
+          board_store.add_column(params.dig(:column, :title))
+          board_refresh
+        end
+
+        def board_reset
+          board_store.reset!
+          redirect_to component_path("board"), status: :see_other
+        end
+
+        # The composer example's server: confirm the question under the id the form
+        # minted, then hand the page a reply to play back as a model would stream
+        # it. The browser has no Action Cable, so the flushes ride along in the
+        # response and a small driver in the example appends them one at a time;
+        # each is the real stream_markdown action, and the last is the settled
+        # turn's upsert.
+        def ai_chat_message
+          sleep 0.8 # long enough to see the question drawn before the server confirms it
+
+          question = params.dig(:message, :content).to_s
+          question_id = params.dig(:message, :client_id).presence || SecureRandom.uuid_v7
+          reply_id = SecureRandom.uuid_v7
+          browser_session[:ai_chat_reply] = reply_id
+
+          render turbo_stream: [
+            turbo_stream.action(:upsert, "demo_entries", helpers.ai_chat_message(question, role: :user, id: question_id)),
+            turbo_stream.action(:upsert, "demo_entries", helpers.ai_chat_message(role: :assistant, id: reply_id, streaming: true)),
+            turbo_stream.replace("demo_composer_action",
+              helpers.ai_chat_composer_action(form: "demo_composer", state: :running, stop_form: "demo_stop")),
+            turbo_stream.append("demo_driver", flushes(reply_id))
+          ]
+        end
+
+        # Stop swaps in a settled note, which refuses the flushes still on their way.
+        def ai_chat_stop
+          reply_id = browser_session.delete(:ai_chat_reply)
+          streams = [ turbo_stream.replace("demo_composer_action", helpers.ai_chat_composer_action(form: "demo_composer", state: :idle)) ]
+          if reply_id
+            stopped = helpers.streaming_markdown_tag(id: "#{reply_id}_content", final: true,
+              class: "UnmagicAIChatMessage__body UnmagicProse") { helpers.tag.p("Response stopped.", class: "text-neutral-500") }
+            streams << turbo_stream.replace("#{reply_id}_content", stopped)
+          end
+
+          render turbo_stream: streams
+        end
+
+        private
+
+        def board_refresh(status = :ok)
+          render turbo_stream: turbo_stream.refresh(request_id: nil), status: status
+        end
+
+        def flushes(reply_id)
+          target = "#{reply_id}_content"
+          frames = Reply.snapshots.map do |html|
+            helpers.tag.template(turbo_stream.stream_markdown(target, html), data: { delay: rand(40..260), target: target })
+          end
+
+          settled = helpers.ai_chat_message(role: :assistant, id: reply_id) { Reply.html }
+          idle = helpers.ai_chat_composer_action(form: "demo_composer", state: :idle, stop_form: "demo_stop")
+          frames << helpers.tag.template(
+            helpers.safe_join([ turbo_stream.action(:upsert, "demo_entries", settled), turbo_stream.replace("demo_composer_action", idle) ]),
+            data: { delay: 400, target: target }
+          )
+
+          helpers.tag.template(helpers.safe_join(frames), data: { flushes: "" })
+        end
+      end
+    end
+  end
+end

data/lib/unmagic/components/browser/app/controllers/unmagic/components/browser/pages_controller.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Unmagic
+  module Components
+    module Browser
+      # The browser's pages: the overview, the getting-started pages, and one page
+      # per component with every example it lists, live and as source.
+      class PagesController < ApplicationController
+        before_action :load_fixtures, only: %i[overview component]
+
+        def overview
+        end
+
+        def installation
+        end
+
+        def theming
+        end
+
+        def component
+          @component = Catalog.find(params[:slug])
+          raise ActionController::RoutingError, "No component named #{params[:slug]}" unless @component
+        end
+
+        private
+
+        # The data examples and thumbnails render from, set for every page that
+        # shows either, so any example can use any of it.
+        def load_fixtures
+          @things = Thing.all
+          @pager = Pager.new(1, 3)
+          @profile = stored_profile
+          @invalid_profile = Profile.new(name: "", role: "Engineer").tap(&:validate)
+          @now = Time.current
+          @board = board_store
+        end
+      end
+    end
+  end
+end