cafe_car 0.1.0 → 0.1.2

data/app/assets/stylesheets/ui/Page.css

@@ -0,0 +1,105 @@
+.Page {
+  container: Page;
+  display: flex;
+  flex-flow: wrap;
+  justify-content: start;
+  gap: var(--gap);
+  background: var(--background);
+  border-radius: var(--radius);
+  min-height: 100%;
+  align-content: start;
+}
+
+.Page-center {
+  justify-content: start;
+  padding: var(--gap);
+}
+
+.Page_Head {
+  display: flex;
+  align-items: center;
+  gap: var(--gap);
+  padding-left: var(--gap);
+  width: 100%;
+  top: var(--gap);
+  left: var(--gap);
+}
+
+.Page_Foot {
+  width: 100%;
+}
+
+.Page_Title {
+  margin: 0;
+}
+
+.Page_Actions {
+  display: flex;
+  gap: var(--gap);
+  margin-left: auto;
+}
+
+@keyframes Page_Aside-popup {
+  from {
+    margin-right: -400px;
+    opacity: 0;
+  }
+
+  to {
+    margin-right: 0px;
+    opacity: 1;
+  }
+}
+
+.Page_Aside {
+  min-width: 300px;
+  max-width: 720px;
+  display: flex;
+  flex-flow: column;
+  gap: var(--gap);
+
+  &.popup {
+    animation: Page_Aside-popup var(--duration);
+    z-index: 2;
+  }
+
+  &.remove {
+    opacity: 1;
+    margin-right: -400px;
+    pointer-events: none;
+  }
+}
+
+.Page_Body {
+  flex: 1 1;
+  width: 0;
+  display: flex;
+  flex-flow: column;
+  gap: var(--gap);
+  /* overflow: auto; */
+}
+
+.Page-slim .Page_Body,
+.Page_Body-slim {
+  max-width: 720px;
+}
+
+.Page-center .Page_Body {
+  margin-left: auto;
+  margin-right: auto;
+}
+
+@media (width < 720px) {
+  .Page {
+    flex-flow: column;
+    justify-items: stretch;
+  }
+
+  .Page_Head,
+  .Page_Body,
+  .Page_Aside,
+  .Page_Foot {
+    justify-self: stretch;
+    width: auto;
+  }
+}

data/app/assets/stylesheets/ui/Row.css

@@ -0,0 +1,9 @@
+.Row {
+  display: inline-flex;
+  justify-items: stretch;
+  align-items: center;
+}
+
+.Row-space {
+  gap: .3em;
+}

data/app/assets/stylesheets/ui/Table.css

@@ -0,0 +1,101 @@
+.Table {
+  display: grid;
+  grid-template-columns: repeat(20, auto);
+  align-items: stretch;
+  box-shadow: var(--box-shadow);
+  border-radius: var(--radius);
+  background: var(--card);
+  min-width: min-content;
+}
+
+.Table_Head,
+.Table_Body,
+.Table_Foot,
+.Table_Row {
+  display: grid;
+  grid-template-columns: subgrid;
+  grid-column: 1/-1;
+}
+
+.Table_Head {
+  z-index: 2;
+  white-space: nowrap;
+  font-weight: bold;
+  position: relative;
+  background: var(--card);
+  border-bottom: solid 2px var(--border);
+  border-top-left-radius: inherit;
+  border-top-right-radius: inherit;
+
+  .Table_Cell {
+    &:first-child {
+      border-top-left-radius: inherit;
+    }
+
+    &:last-child {
+      border-top-right-radius: inherit;
+    }
+
+    &:not(:empty) + &:not(:empty)::before {
+      display: block;
+      cursor: col-resize;
+      content: "";
+      inset: var(--gap) auto var(--gap) 0;
+      position: absolute;
+      border-left: 1px solid var(--border);
+    }
+  }
+
+  a {
+    text-decoration: none;
+    color: inherit;
+  }
+}
+
+.Table_Head-sticky {
+  position: sticky;
+  top: 0;
+}
+
+.Table_Row {
+  align-items: center;
+
+  &:not(:hover) .Table_Cell-shy {
+    visibility: hidden;
+  }
+
+  & + & {
+    border-top: 1px solid var(--background);
+  }
+}
+
+.Table_Cell {
+  position: relative;
+  padding: 0.75em 1em;
+  align-items: center;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  gap: 2px;
+
+  > code {
+    white-space: nowrap;
+  }
+
+  &:has(img) {
+    padding-block: 0;
+  }
+
+  > img,
+  > a > img {
+    height: 2em;
+    /* margin: 4px; */
+    display: inline-block;
+    border-radius: 99px;
+    max-width: none;
+  }
+
+  &-controls {
+    text-align: right;
+  }
+}

data/app/assets/stylesheets/ui/components.css

@@ -0,0 +1,24 @@
+@import url("Alert.css");
+@import url("Article.css");
+@import url("Button.css");
+@import url("Close.css");
+@import url("Card.css");
+@import url("Chat.css");
+@import url("Code.css");
+@import url("Controls.css");
+@import url("Error.css");
+@import url("Field.css");
+@import url("Grid.css");
+@import url("Icon.css");
+@import url("Input.css");
+@import url("Image.css");
+@import url("InfoCircle.css");
+@import url("Layout.css");
+@import url("Menu.css");
+@import url("Modal.css");
+@import url("Navigation.css");
+@import url("Page.css");
+@import url("Row.css");
+@import url("Table.css");
+
+@import url("Group.css");

data/app/controllers/cafe_car/application_controller.rb

@@ -0,0 +1,9 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery with: :exception
+end
+
+module CafeCar
+  class ApplicationController < ::ApplicationController
+    include Controller
+  end
+end

data/app/controllers/cafe_car/examples_controller.rb

@@ -0,0 +1,22 @@
+require "rouge"
+require "faker"
+
+module CafeCar
+  class ExamplesController < const(:ApplicationController)
+    include Controller
+    helper CafeCar::Helpers
+
+    before_action :skip_policy_scope, only: :index
+    before_action :skip_authorization, only: :index
+
+    def index
+      @examples = view_context.template_glob("cafe_car/examples/ui/*")
+        .map { _1.name.sub(/\..+$/, "") }
+        .to_h { [ _1.camelize, "cafe_car/examples/ui/#{_1}" ] }
+    end
+
+    private
+
+    def model_name = @model_name ||= ActiveModel::Name.new(:components)
+  end
+end

data/app/controllers/cafe_car/sessions_controller.rb

@@ -0,0 +1,30 @@
+module CafeCar
+  class SessionsController < const(:ApplicationController)
+    include Controller
+
+    cafe_car model: CafeCar[:Session]
+    rate_limit to: 10, within: 3.minutes, only: :create # , with: -> { redirect_to new_session_path, alert: "Try again later." }
+    before_action :skip_policy_scope, except: :index
+
+    after_create :persist_session
+    after_destroy :terminate_session
+
+    def create
+      run_callbacks(:create) { object.save! }
+      respond_with object, location: after_authentication_url
+    end
+
+    def destroy
+      run_callbacks(:destroy) { object.destroy! }
+      respond_with object, location: main_app.root_path
+    end
+
+    private
+
+    def find_object
+      self.object = current_session
+    end
+
+    def build_object = find_object
+  end
+end

data/app/controllers/concerns/cafe_car/authentication.rb

@@ -0,0 +1,61 @@
+module CafeCar
+  module Authentication
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :authenticated?, :current_user, :current_session
+    end
+
+    private
+
+    # Sessions/login are opt-in: a host enables them by running the
+    # `cafe_car:sessions` generator and exposing the session routes. When that
+    # infrastructure is absent we can't redirect to a login page, so callers
+    # fall back to 403 Forbidden instead of 500ing on a missing route.
+    def sessions_available?
+      respond_to?(:new_session_path) && CafeCar.sessions_available?
+    rescue StandardError
+      false
+    end
+
+    def authenticated?
+      current_user
+    end
+
+    def current_user
+      current_session.user
+    end
+
+    def current_session
+      CafeCar[:Current].session ||= find_session_by_cookie || build_session
+    end
+
+    def build_session
+      CafeCar[:Session].new user_agent: request.user_agent,
+                            ip_address: request.remote_ip
+    end
+
+    def terminate_session
+      CafeCar[:Current].session.destroy!
+      CafeCar[:Current].session = nil
+      cookies.delete(:session_id)
+    end
+
+    def persist_session
+      cookies.signed.permanent[:session_id] = { value: current_session.id, httponly: true, same_site: :lax }
+    end
+
+    def find_session_by_cookie
+      cookies.signed[:session_id].try { Session.find(_1) }
+    end
+
+    def request_authentication
+      session[:return_to_after_authenticating] = request.url
+      redirect_to new_session_path, warning: t(:auth_required, new_session: t(:new_session))
+    end
+
+    def after_authentication_url
+      session.delete(:return_to_after_authenticating) || root_url
+    end
+  end
+end

data/app/javascript/application.js

@@ -0,0 +1,5 @@
+import "@hotwired/turbo-rails"
+import "cafe_car"
+
+import "trix"
+import "@rails/actiontext"

data/app/javascript/cafe_car.js

@@ -0,0 +1,174 @@
+import "@hotwired/turbo-rails"
+
+Object.assign(Turbo.StreamActions, {
+  // <turbo-stream action="navigate" target="Hello, world"></turbo-stream>
+  navigate() {
+    history.pushState({ action: "navigate" }, "", this.getAttribute("target"))
+  }
+})
+
+function last(arr) {
+  return arr[arr.length - 1];
+}
+
+addEventListener("mousedown", event => {
+  window.mouseDownTarget = event.target
+})
+
+addEventListener("mouseup", event => {
+  let isClose = event.target.closest(".Close") || event.target.matches(".Modal")
+  if (isClose && event.target === window.mouseDownTarget) {
+    event.preventDefault()
+    event.stopPropagation()
+    event.target.closest(".popup").classList.add("remove")
+  }
+}, { capture: true })
+
+addEventListener("keydown", event => {
+  switch (event.key) {
+    case "Escape":
+      let popup = event.target.closest(".popup") ||
+        last(document.querySelectorAll(".popup"))
+      if (popup) popup.classList.add("remove");
+  }
+})
+
+function animationEnd({ target }) {
+  if (target.matches(".remove")) target.remove()
+  else if (target.matches(".popup")) {
+    let input = target.querySelector("input:not([type=hidden]), textarea")
+    input?.focus()
+    input?.setSelectionRange(-1, -1)
+  }
+}
+
+addEventListener("animationend", animationEnd)
+addEventListener("transitionend", animationEnd)
+
+// NOTE: field-sizing property is used instead
+// function adjustHeight(textarea) {
+//   textarea.style.height = "1px"
+//   textarea.style.height = (textarea.scrollHeight) + "px"
+// }
+
+// addEventListener("input", ({ target }) => {
+//   if (target.matches("textarea")) adjustHeight(target)
+// })
+
+export class Selection extends Array {
+  constructor(obj, ...rest) {
+    switch (typeof obj) {
+      case "string": {
+        super(...document.querySelectorAll(obj))
+        this.selector = obj
+        break
+      }
+      default: super(obj, ...rest); break
+    }
+  }
+
+  get clone() { return structuredClone(this) }
+
+  with(...objs) {
+    return this.clone.assign(...objs)
+  }
+
+  assign(...objs) {
+    for (let obj of objs) {
+      switch (typeof obj) {
+        case "function": obj(this)
+        default: Object.assign(this, obj)
+      }
+    }
+
+    return this
+  }
+
+  tap(fn) {
+    fn(this)
+    return this
+  }
+
+  static on(...x) { return this(window).on(...x) }
+  static off(...x) { return this(window).off(...x) }
+
+  select(v, ...rest) {
+    if (!v) return this
+
+    switch (typeof v) {
+      case "function": return super.filter(v).select(...rest)
+      case "string": return super.filter(e => e.matches(v)).select(...rest)
+    }
+  }
+
+  reject(v, ...rest) {
+    if (!v) return this
+    switch (typeof v) {
+      case "function": return super.filter(e => !v(e)).reject(...rest)
+      case "string": return super.filter(e => !e.matches(v)).reject(...rest)
+    }
+  }
+
+  each(...xs) { return this.forEach(...xs) }
+
+  forEach(...xs) {
+    super.forEach(...xs)
+    return this
+  }
+
+  add(name, ...names) {
+    if (!name) return this
+    if (name[0] == '.') name = name.slice(1)
+    return this.each(el => { el.classList.add(name) }).add(...names)
+  }
+
+  remove(name, ...names) {
+    if (!name) return this
+    if (name[0] == '.') name = name.slice(1)
+    return this.each(el => el.classList.remove(name)).remove(...names)
+  }
+
+  on(eventName, fn) {
+    return this.each(el => el.addEventListener(eventName, fn))
+  }
+
+  off(eventName, fn) {
+    return this.each(el => el.removeEventListener(eventName, fn))
+  }
+
+  set onhashchange(fn) { this.on("hashchange", fn) }
+  set onload(fn) { this.on("load", fn) }
+  set onclick(fn) { this.on("click", fn) }
+
+  get isLoaded() { return document.readyState == "complete" }
+
+  loaded(fn) {
+    return this.isLoaded
+      ? this.each(fn)
+      : this.on('load', fn)
+  }
+
+  onIntersection() {}
+
+  intersection(...options) {
+    return this.clone.tap(clone => {
+      clone.observer = new IntersectionObserver(clone.onIntersection.bind(clone), ...options)
+    })
+  }
+
+  observe(...options) {
+    return this.each(el => this.observer.observe(el, ...options))
+  }
+
+  unobserve(...options) {
+    this.each(el => this.observer.unobserve(el, ...options))
+  }
+}
+
+window.Selection = Selection
+window.$ = function $(x, ...xs) {
+  switch (typeof x) {
+    case "function": return $(document).loaded(x)
+    default: return new Selection(x, ...xs)
+  }
+}

data/app/models/cafe_car/session.rb

@@ -0,0 +1,18 @@
+module CafeCar
+  class Session < ApplicationRecord
+    belongs_to :user, class_name: CafeCar.user_class_name
+
+    attribute :email, :string
+    attribute :password, :password
+    attribute :login, :boolean, default: true
+
+    validates :email, :password, presence: true, if: :login?
+
+    before_validation :authenticate, if: :login?
+
+    def authenticate
+      self.user = CafeCar.user_class.authenticate_by(email:, password:) or
+        errors.add(:base, "Could not find user with given credentials")
+    end
+  end
+end

data/app/policies/cafe_car/application_policy.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class CafeCar::ApplicationPolicy
+  include CafeCar::Policy
+
+  attr_reader :user, :object
+
+  def initialize(user, object)
+    @user   = user
+    @object = object
+  end
+
+  def index?   = false
+  def show?    = false
+  def create?  = false
+  def new?     = create?
+  def update?  = false
+  def edit?    = update?
+  def destroy? = false
+
+  def attributes
+    @attributes ||= Attributes.new(@user, @object, permitted_attributes)
+  end
+
+  class Scope
+    def initialize(user, scope)
+      @user  = user
+      @scope = scope
+    end
+
+    def resolve
+      raise NoMethodError, "You must define #resolve in #{self.class}"
+    end
+
+    private
+
+    attr_reader :user, :scope
+  end
+
+  class Attributes < CafeCar::Attributes
+  end
+end

data/app/policies/cafe_car/session_policy.rb

@@ -0,0 +1,19 @@
+module CafeCar
+  class SessionPolicy < ::ApplicationPolicy
+    def index?   = admin?
+    def create?  = true
+    def show?    = true
+    def destroy? = admin? || mine?
+    def update?  = false
+
+    def title_attribute = :user
+
+    def permitted_attributes
+      [ :email, :password ]
+    end
+
+    class Scope < Scope
+      def resolve = scope
+    end
+  end
+end

data/app/presenters/cafe_car/action_text/rich_text_presenter.rb

@@ -0,0 +1,7 @@
+module CafeCar
+  module ActionText
+    class RichTextPresenter < CafeCar[:RecordPresenter]
+      def to_html = object
+    end
+  end
+end

data/app/presenters/cafe_car/active_record/base_presenter.rb

@@ -0,0 +1,6 @@
+module CafeCar
+  module ActiveRecord
+    class BasePresenter < CafeCar[:RecordPresenter]
+    end
+  end
+end

data/app/presenters/cafe_car/active_record/relation_presenter.rb

@@ -0,0 +1,17 @@
+module CafeCar
+  module ActiveRecord
+    class RelationPresenter < CafeCar[:Presenter]
+      def human(attribute, **options)
+        object.human_attribute_name(attribute, options)
+      end
+
+      def each = object.each { yield present(_1) }
+
+      def to_html
+        objects = object.to_a.uniq
+        objects = objects.sort_by(&:sort_key) if objects.first.respond_to?(:sort_key)
+        present objects, count: object.count, **@options
+      end
+    end
+  end
+end

data/app/presenters/cafe_car/active_storage/attached/one_presenter.rb

@@ -0,0 +1,9 @@
+module CafeCar
+  module ActiveStorage
+    module Attached
+      class OnePresenter < AttachmentPresenter
+        def href = present(object.attachment).href
+      end
+    end
+  end
+end

data/app/presenters/cafe_car/active_storage/attachment_presenter.rb

@@ -0,0 +1,18 @@
+module CafeCar
+  module ActiveStorage
+    class AttachmentPresenter < CafeCar[:Presenter]
+      option :size
+
+      # def url = object.representation(resize_to_limit: [300, 300])&.processed&.url
+      def url = object.try(:url)
+      def blank = options[:blank]
+      def logo = self
+
+      def image
+        @template.image_tag url, **options, class: ui.class(:image, size) if url
+      end
+
+      def preview = image || blank
+    end
+  end
+end

data/app/presenters/cafe_car/basic_object_presenter.rb

@@ -0,0 +1,5 @@
+module CafeCar
+  class BasicObjectPresenter < CafeCar[:Presenter]
+    def to_html = captured.presence || options[:blank]
+  end
+end