plum-cms 0.2.1 → 0.2.3

data/app/controllers/plum/form_submissions_controller.rb

@@ -1,6 +1,15 @@
 module Plum
   class FormSubmissionsController < ApplicationController
+    # Public forms are served from the static cache, so they can't carry a
+    # per-session CSRF token. Submissions are unauthenticated writes guarded
+    # by the honeypot below instead.
+    skip_forgery_protection
+
     def create
+      # Pretend success when the honeypot is filled so bots don't learn
+      # they were caught.
+      return redirect_to safe_return_path, notice: "Form submitted" if honeypot_tripped?
+
       form_definition = current_site.form_definitions.find_by!(handle: params[:handle])
       submission = form_definition.form_submissions.build(
         site: current_site,
@@ -17,6 +26,10 @@ module Plum
 
     private
 
+    def honeypot_tripped?
+      params.dig(:form_submission, :website).present?
+    end
+
     def deliver_submission_notification(submission)
       return if submission.form_definition.notification_email.blank?
 

data/app/controllers/plum/pages_controller.rb

@@ -2,6 +2,10 @@ module Plum
   class PagesController < ApplicationController
     HOMEPAGE_SLUG = "home".freeze
 
+    # Search stays dynamic (query-dependent); the middleware also refuses to
+    # store any response with a query string or a non-200 status.
+    after_action :mark_static_cacheable, only: [ :home, :localized_home, :show ]
+
     def home
       @site_settings = SiteSetting.instance(current_site)
       @entry = Entry.for_site(current_site).live
@@ -91,6 +95,10 @@ module Plum
 
     PER_PAGE = 12
 
+    def mark_static_cacheable
+      response.headers[Plum::StaticCache::MARKER_HEADER] = "store" if response.status == 200
+    end
+
     def render_collection(content_type)
       context = build_context
       page = [ params.fetch(:page, 1).to_i, 1 ].max

data/app/controllers/plum/theme_assets_controller.rb

@@ -6,6 +6,8 @@ module Plum
       asset_path = ThemeResolver.new.find_asset(params[:theme_handle], params[:path])
       return head :not_found unless asset_path
 
+      expires_in 1.hour, public: true
+      response.headers[Plum::StaticCache::MARKER_HEADER] = "store"
       send_file asset_path,
         type: Rack::Mime.mime_type(asset_path.extname, "application/octet-stream"),
         disposition: "inline"

data/app/javascript/controllers/plum/write_controller.js

@@ -0,0 +1,174 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Distraction-free writing mode: autosaves the title and one rich text field
+// a moment after typing stops, without leaving the page.
+export default class extends Controller {
+  static targets = ["form", "title", "editor", "status", "statusText", "words", "bar"]
+  static values = { publishUrl: String }
+
+  connect() {
+    this.dirty = false
+    this.saving = false
+    this.resizeTitle()
+    this.refreshWordCount()
+
+    // Lexical swallows native input events, so "input" alone misses typing
+    // in the body — lexxy:change is the editor's own any-edit signal.
+    this.editorListener = () => this.contentChanged()
+    this.editorTarget.addEventListener("lexxy:change", this.editorListener)
+    this.editorTarget.addEventListener("input", this.editorListener)
+
+    this.keyListener = (event) => {
+      if ((event.metaKey || event.ctrlKey) && event.key === "s") {
+        event.preventDefault()
+        this.save()
+      }
+    }
+    document.addEventListener("keydown", this.keyListener)
+
+    // Flush pending edits when leaving instead of nagging with a dialog;
+    // keepalive lets the request outlive the page. Only block navigation
+    // when a save actually failed and edits would truly be lost.
+    this.unloadListener = (event) => {
+      if (!this.dirty) return
+      this.flushSave()
+      if (this.saveFailed) {
+        event.preventDefault()
+        event.returnValue = ""
+      }
+    }
+    window.addEventListener("beforeunload", this.unloadListener)
+  }
+
+  disconnect() {
+    this.editorTarget.removeEventListener("lexxy:change", this.editorListener)
+    this.editorTarget.removeEventListener("input", this.editorListener)
+    document.removeEventListener("keydown", this.keyListener)
+    window.removeEventListener("beforeunload", this.unloadListener)
+    clearTimeout(this.saveTimer)
+  }
+
+  titleChanged() {
+    this.resizeTitle()
+    this.contentChanged()
+  }
+
+  contentChanged() {
+    this.dirty = true
+    this.setStatus("dirty", "Unsaved changes")
+    this.refreshWordCount()
+    clearTimeout(this.saveTimer)
+    this.saveTimer = setTimeout(() => this.save(), 2000)
+  }
+
+  // The top bar normally fades away; save activity has to be able to pull
+  // it back so the state change is actually seen.
+  setStatus(state, text) {
+    this.statusTarget.dataset.state = state
+    this.statusTextTarget.textContent = text
+
+    clearTimeout(this.attentionTimer)
+    if (state === "saving" || state === "error") {
+      this.barTarget.classList.add("plum-write-bar--active")
+    } else if (state === "saved") {
+      this.barTarget.classList.add("plum-write-bar--active")
+      this.attentionTimer = setTimeout(() => this.barTarget.classList.remove("plum-write-bar--active"), 1800)
+    } else {
+      this.barTarget.classList.remove("plum-write-bar--active")
+    }
+  }
+
+  save() {
+    if (this.saving) return this.savePromise
+    this.savePromise = this.performSave()
+    return this.savePromise
+  }
+
+  async performSave() {
+    clearTimeout(this.saveTimer)
+    this.saving = true
+    this.dirty = false
+    this.setStatus("saving", "Saving…")
+
+    const hidden = document.getElementById(this.editorTarget.dataset.hiddenField)
+    if (hidden) hidden.value = this.editorTarget.value
+
+    try {
+      const response = await fetch(this.formTarget.action, {
+        method: "POST",
+        body: new FormData(this.formTarget),
+        headers: { Accept: "application/json" }
+      })
+      const result = await response.json().catch(() => ({}))
+
+      if (response.ok && result.saved) {
+        const label = result.draft ? "Draft saved" : "Saved"
+        this.setStatus("saved", `${label} at ${this.timeNow()}`)
+        this.saveFailed = false
+      } else {
+        this.dirty = true
+        this.saveFailed = true
+        this.setStatus("error", (result.errors || ["Couldn't save"]).join(", "))
+      }
+    } catch {
+      this.dirty = true
+      this.saveFailed = true
+      this.setStatus("error", "Offline — changes not saved yet")
+    } finally {
+      this.saving = false
+    }
+  }
+
+  flushSave() {
+    const hidden = document.getElementById(this.editorTarget.dataset.hiddenField)
+    if (hidden) hidden.value = this.editorTarget.value
+    this.dirty = false
+    fetch(this.formTarget.action, {
+      method: "POST",
+      body: new FormData(this.formTarget),
+      headers: { Accept: "application/json" },
+      keepalive: true
+    }).catch(() => {})
+  }
+
+  async publishDraft() {
+    await this.save()
+    if (this.dirty) return // the save failed; don't publish a stale draft
+
+    this.setStatus("saving", "Publishing…")
+    try {
+      const response = await fetch(this.publishUrlValue, {
+        method: "POST",
+        headers: {
+          Accept: "application/json",
+          "X-CSRF-Token": document.querySelector('meta[name="csrf-token"]')?.content || ""
+        }
+      })
+      if (response.ok) {
+        this.setStatus("saved", `Published at ${this.timeNow()}`)
+      } else {
+        this.setStatus("error", "Couldn't publish")
+      }
+    } catch {
+      this.setStatus("error", "Offline — couldn't publish")
+    }
+  }
+
+  timeNow() {
+    return new Date().toLocaleTimeString([], { hour: "numeric", minute: "2-digit" })
+  }
+
+  resizeTitle() {
+    const title = this.titleTarget
+    title.style.height = "auto"
+    title.style.height = `${title.scrollHeight}px`
+  }
+
+  refreshWordCount() {
+    const scratch = document.createElement("div")
+    scratch.innerHTML = this.editorTarget.value || ""
+    const text = scratch.textContent || ""
+    const words = (text.trim().match(/\S+/g) || []).length
+    this.wordsTarget.textContent = `${words} ${words === 1 ? "word" : "words"}`
+  }
+}

data/app/models/plum/asset.rb

@@ -1,6 +1,7 @@
 module Plum
   class Asset < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     has_one_attached :file
 

data/app/models/plum/content_type.rb

@@ -1,6 +1,7 @@
 module Plum
   class ContentType < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     FIELD_TYPES = FieldTypeRegistry.handles.freeze
 

data/app/models/plum/entry.rb

@@ -1,6 +1,7 @@
 module Plum
   class Entry < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     belongs_to :content_type
     belongs_to :author, class_name: "Plum::User", optional: true
@@ -10,6 +11,9 @@ module Plum
     has_many :terms, through: :entry_terms
     has_many :revisions, class_name: "Plum::EntryRevision", dependent: :destroy
     has_many :translations, class_name: "Plum::Entry", foreign_key: :origin_id, dependent: :destroy
+    # A deleted entry takes its nav links with it — nav items have a FK on
+    # entry_id, so without this both entry and site destroys crash.
+    has_many :nav_items, dependent: :destroy
 
     # The page served at "/" — Plum resolves the homepage by this slug
     # (convention over configuration). Its slug is locked and it can't be
@@ -45,6 +49,49 @@ module Plum
       data&.dig(handle)
     end
 
+    # Working copy ("draft of a published entry"): pending edits stored in
+    # draft_data as { "title" => ..., "data" => {...} }. The live `title` and
+    # `data` stay untouched until publish_draft!, so the public site never
+    # sees half-written content.
+    def has_draft?
+      draft_data.present?
+    end
+
+    def draft_title
+      draft_data.to_h["title"].presence || title
+    end
+
+    def draft_field_value(handle)
+      draft_data.to_h.dig("data", handle) || field_value(handle)
+    end
+
+    def save_draft!(title: nil, data: {})
+      base = draft_data.to_h
+      merged = (base["data"] || self.data.to_h).merge(data.to_h)
+      update!(draft_data: {
+        "title" => title.presence || base["title"].presence || self.title,
+        "data" => merged
+      })
+    end
+
+    def publish_draft!(editor: nil)
+      return false unless has_draft?
+
+      transaction do
+        update!(
+          title: draft_data["title"].presence || title,
+          data: draft_data["data"] || data,
+          draft_data: nil
+        )
+        record_revision!(editor: editor)
+      end
+      true
+    end
+
+    def discard_draft!
+      update!(draft_data: nil)
+    end
+
     def homepage?
       slug == HOMEPAGE_SLUG
     end
@@ -66,6 +113,12 @@ module Plum
         }
       }
       attributes[:editor] = editor if editor.is_a?(Plum::User)
+
+      # Autosave calls this on every save; identical content shouldn't pile
+      # up as duplicate history entries.
+      last = revisions.order(id: :desc).first
+      return last if last && last.snapshot == attributes[:snapshot]
+
       revisions.create!(attributes)
     end
 
@@ -278,6 +331,10 @@ module Plum
     end
 
     def prevent_homepage_destroy
+      # Only protect the homepage while its site survives — when the whole
+      # site is going away (site destroy, plum:site:replace), the cascade
+      # must be allowed through.
+      return if destroyed_by_association
       return unless homepage?
 
       errors.add(:base, "The homepage can't be deleted")

data/app/models/plum/entry_term.rb

@@ -1,5 +1,6 @@
 module Plum
   class EntryTerm < ApplicationRecord
+    include StaticCacheInvalidation
     belongs_to :entry
     belongs_to :term
 

data/app/models/plum/form_definition.rb

@@ -1,6 +1,7 @@
 module Plum
   class FormDefinition < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     FIELD_TYPES = %w[text email textarea select checkbox].freeze
     HANDLE_PATTERN = /\A[a-z][a-z0-9_]*\z/

data/app/models/plum/global.rb

@@ -1,6 +1,7 @@
 module Plum
   class Global < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     validates :name, presence: true
     validates :handle, presence: true, uniqueness: { scope: :site_id }, format: { with: /\A[a-z][a-z0-9_]*\z/ }

data/app/models/plum/nav_item.rb

@@ -1,6 +1,7 @@
 module Plum
   class NavItem < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     belongs_to :nav_menu
     belongs_to :parent, class_name: "Plum::NavItem", optional: true

data/app/models/plum/nav_menu.rb

@@ -1,6 +1,7 @@
 module Plum
   class NavMenu < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     has_many :nav_items, dependent: :destroy
 

data/app/models/plum/site.rb

@@ -1,5 +1,7 @@
 module Plum
   class Site < ApplicationRecord
+    include StaticCacheInvalidation
+
     belongs_to :owner, polymorphic: true, optional: true
 
     has_one :site_setting, dependent: :destroy

data/app/models/plum/site_setting.rb

@@ -1,6 +1,7 @@
 module Plum
   class SiteSetting < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     before_validation :set_defaults
     after_save :sync_site_summary

data/app/models/plum/static_cache_invalidation.rb

@@ -0,0 +1,30 @@
+module Plum
+  # Flushes the static page cache whenever content that appears in rendered
+  # pages changes. Flushing is deletion-only and per-site, so being liberal
+  # here costs one lazy re-render per page, never a wrong page.
+  module StaticCacheInvalidation
+    extend ActiveSupport::Concern
+
+    included do
+      after_commit :flush_plum_static_cache
+    end
+
+    # Columns that never appear in rendered pages — saves touching only these
+    # (draft autosaves) keep the cache warm.
+    CACHE_IRRELEVANT_COLUMNS = %w[draft_data updated_at].freeze
+
+    private
+
+    def flush_plum_static_cache
+      return unless Plum::StaticCache.enabled?
+
+      changed = respond_to?(:saved_changes) ? saved_changes.keys : []
+      return if changed.present? && (changed - CACHE_IRRELEVANT_COLUMNS).empty?
+
+      owner = is_a?(Plum::Site) ? self : (respond_to?(:site) ? site : nil)
+      Plum::StaticCache.flush_site!(owner)
+    rescue StandardError => e
+      Rails.logger.error("[Plum] static cache flush failed: #{e.message}")
+    end
+  end
+end

data/app/models/plum/taxonomy.rb

@@ -1,6 +1,7 @@
 module Plum
   class Taxonomy < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     has_many :terms, dependent: :destroy
 

data/app/models/plum/term.rb

@@ -1,6 +1,7 @@
 module Plum
   class Term < ApplicationRecord
     include SiteScoped
+    include StaticCacheInvalidation
 
     belongs_to :taxonomy