plum-cms 0.1.0

data/app/models/plum/site.rb

@@ -0,0 +1,112 @@
+module Plum
+  class Site < ApplicationRecord
+    belongs_to :owner, polymorphic: true, optional: true
+
+    has_one :site_setting, dependent: :destroy
+    has_many :content_types, dependent: :destroy
+    has_many :entries, dependent: :destroy
+    has_many :globals, dependent: :destroy
+    has_many :nav_menus, dependent: :destroy
+    has_many :nav_items, dependent: :destroy
+    has_many :assets, dependent: :destroy
+    has_many :form_definitions, dependent: :destroy
+    has_many :form_submissions, dependent: :destroy
+    has_many :taxonomies, dependent: :destroy
+    has_many :terms, dependent: :destroy
+
+    attribute :skip_defaults, :boolean, default: false
+
+    before_validation :set_theme_defaults
+    after_create :seed_defaults, unless: :skip_defaults
+
+    validates :name, presence: true
+    validates :theme_name, presence: true
+    validates :owner_id, uniqueness: { scope: :owner_type }, if: :owner_present?
+
+    def self.first_or_create_standalone!(skip_defaults: false)
+      first_or_create!(name: "My Site", theme_name: "default", skip_defaults: skip_defaults)
+    end
+
+    def self.for_owner!(owner, attributes = {})
+      unless owner.respond_to?(:persisted?) && owner.persisted?
+        raise ArgumentError, "Owner must be a persisted Active Record model"
+      end
+
+      find_or_create_by!(owner: owner) do |site|
+        site.name = attributes.fetch(:name) { owner_default_name(owner) }
+        site.theme_name = attributes.fetch(:theme_name, "default")
+        site.skip_defaults = attributes.fetch(:skip_defaults, false)
+        site.domain = attributes[:domain] if attributes.key?(:domain)
+        site.settings = attributes[:settings] if attributes.key?(:settings)
+        site.theme_settings = attributes[:theme_settings] if attributes.key?(:theme_settings)
+        site.custom_css = attributes[:custom_css] if attributes.key?(:custom_css)
+      end
+    end
+
+    def theme
+      ThemeRegistry.new.fetch(theme_name)
+    end
+
+    def theme_settings
+      super || {}
+    end
+
+    private
+
+    def self.owner_default_name(owner)
+      return owner.name if owner.respond_to?(:name) && owner.name.present?
+
+      owner.to_s.presence || "Site"
+    end
+
+    private_class_method :owner_default_name
+
+    def owner_present?
+      owner_type.present? && owner_id.present?
+    end
+
+    def set_theme_defaults
+      self.theme_name = "default" if theme_name.blank?
+      self.theme_settings = {} if has_attribute?(:theme_settings) && theme_settings.blank?
+    end
+
+    def seed_defaults
+      return if content_types.exists?
+
+      pages = content_types.find_or_create_by!(handle: "pages") do |ct|
+        ct.name = "Pages"
+        ct.blueprint = { "fields" => [
+          { "handle" => "body", "type" => "rich_text", "label" => "Body" }
+        ] }
+      end
+
+      entries.find_or_create_by!(slug: "home") do |e|
+        e.content_type = pages
+        e.title = "Home"
+        e.status = :published
+        e.published_at = Time.current
+        e.data = { "body" => "<p>Welcome to your new website.</p>" }
+      end
+
+      content_types.find_or_create_by!(handle: "posts") do |ct|
+        ct.name = "Blog Posts"
+        ct.blueprint = { "fields" => [
+          { "handle" => "hero_image", "type" => "image", "label" => "Hero Image" },
+          { "handle" => "body", "type" => "rich_text", "label" => "Body" },
+          { "handle" => "excerpt", "type" => "textarea", "label" => "Excerpt" }
+        ] }
+      end
+
+      nav = nav_menus.find_or_create_by!(handle: "main") do |n|
+        n.name = "Main"
+      end
+      home = entries.find_by(slug: "home")
+      nav.nav_items.find_or_create_by!(entry: home, site: self) do |item|
+        item.label = "Home"
+        item.position = 0
+      end if home
+
+      SiteSetting.instance(self)
+    end
+  end
+end

data/app/models/plum/site_scoped.rb

@@ -0,0 +1,17 @@
+module Plum
+  module SiteScoped
+    extend ActiveSupport::Concern
+
+    included do
+      belongs_to :site, class_name: "Plum::Site"
+      before_validation :assign_default_site, on: :create
+      scope :for_site, ->(site) { where(site: site) }
+    end
+
+    private
+
+    def assign_default_site
+      self.site ||= Plum::Site.first_or_create_standalone!
+    end
+  end
+end

data/app/models/plum/site_setting.rb

@@ -0,0 +1,35 @@
+module Plum
+  class SiteSetting < ApplicationRecord
+    include SiteScoped
+
+    before_validation :set_defaults
+    after_save :sync_site_summary
+
+    validates :name, presence: true
+    validates :site_id, uniqueness: true
+    validates :theme_name, presence: true
+    validates :primary_color, format: { with: /\A#[0-9a-fA-F]{6}\z/ }, allow_blank: true
+    validates :support_email, format: { with: URI::MailTo::EMAIL_REGEXP }, allow_blank: true
+
+    def self.instance(site = Plum::Site.first_or_create_standalone!)
+      find_or_create_by!(site: site) do |settings|
+        settings.name = site.name.presence || "My Site"
+        settings.theme_name = site.theme_name.presence || "default"
+      end
+    end
+
+    private
+
+    def set_defaults
+      self.theme_name = "default" if theme_name.blank?
+      self.primary_color = "#7c3aed" if primary_color.blank?
+    end
+
+    def sync_site_summary
+      return unless site
+      return if site.name == name && site.theme_name == theme_name
+
+      site.update!(name: name, theme_name: theme_name)
+    end
+  end
+end

data/app/models/plum/taxonomy.rb

@@ -0,0 +1,24 @@
+module Plum
+  class Taxonomy < ApplicationRecord
+    include SiteScoped
+
+    has_many :terms, dependent: :destroy
+
+    validates :name, presence: true
+    validates :handle, presence: true, uniqueness: { scope: :site_id }, format: { with: /\A[a-z][a-z0-9_]*\z/ }
+    validates :slug, presence: true, uniqueness: { scope: :site_id }, format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/ }
+
+    before_validation :generate_handle
+    before_validation :generate_slug
+
+    private
+
+    def generate_handle
+      self.handle = name&.parameterize(separator: "_") if handle.blank?
+    end
+
+    def generate_slug
+      self.slug = name&.parameterize if slug.blank?
+    end
+  end
+end

data/app/models/plum/term.rb

@@ -0,0 +1,23 @@
+module Plum
+  class Term < ApplicationRecord
+    include SiteScoped
+
+    belongs_to :taxonomy
+
+    has_many :entry_terms, dependent: :destroy
+    has_many :entries, through: :entry_terms
+
+    validates :name, presence: true
+    validates :slug, presence: true, uniqueness: { scope: :taxonomy_id }, format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/ }
+
+    before_validation :generate_slug
+
+    scope :ordered, -> { order(:position, :name) }
+
+    private
+
+    def generate_slug
+      self.slug = name&.parameterize if slug.blank?
+    end
+  end
+end

data/app/models/plum/user.rb

@@ -0,0 +1,16 @@
+module Plum
+  class User < ApplicationRecord
+    has_secure_password
+
+    has_many :entries, foreign_key: :author_id, dependent: :nullify
+
+    enum :role, { viewer: 0, editor: 1, admin: 2 }
+
+    validates :email, presence: true, uniqueness: true, format: { with: URI::MailTo::EMAIL_REGEXP }
+    validates :role, presence: true
+
+    def admin?
+      role == "admin"
+    end
+  end
+end

data/app/services/plum/base_blocks.rb

@@ -0,0 +1,161 @@
+module Plum
+  # Engine-level "base" blocks: a small universal palette that exists on every
+  # site regardless of theme. Themes can add their own blocks and can override a
+  # base block by declaring the same handle (see Plum::BlockLibrary for the
+  # merge/override rules). Keeping these in the engine means switching themes
+  # never orphans content built from universal sections, and a bare theme still
+  # gives owners a usable palette.
+  #
+  # Each definition matches the theme block shape (handle/label/fields), and each
+  # has a matching Liquid partial keyed by handle. Field values are exposed to the
+  # partial under `block` exactly like theme blocks.
+  module BaseBlocks
+    module_function
+
+    DEFINITIONS = [
+      {
+        "handle" => "hero", "label" => "Hero",
+        "fields" => [
+          { "handle" => "heading", "type" => "text", "label" => "Heading" },
+          { "handle" => "subheading", "type" => "textarea", "label" => "Subheading" },
+          { "handle" => "image", "type" => "image", "label" => "Image" },
+          { "handle" => "button_label", "type" => "text", "label" => "Button Label" },
+          { "handle" => "button_url", "type" => "text", "label" => "Button URL" }
+        ]
+      },
+      {
+        "handle" => "rich_text", "label" => "Rich Text",
+        "fields" => [
+          { "handle" => "body", "type" => "rich_text", "label" => "Body" }
+        ]
+      },
+      {
+        "handle" => "image", "label" => "Image",
+        "fields" => [
+          { "handle" => "image", "type" => "image", "label" => "Image" },
+          { "handle" => "caption", "type" => "text", "label" => "Caption" }
+        ]
+      },
+      {
+        "handle" => "image_text", "label" => "Image + Text",
+        "fields" => [
+          { "handle" => "heading", "type" => "text", "label" => "Heading" },
+          { "handle" => "body", "type" => "rich_text", "label" => "Body" },
+          { "handle" => "image", "type" => "image", "label" => "Image" },
+          { "handle" => "image_position", "type" => "select", "label" => "Image Position",
+            "options" => [ { "label" => "Left", "value" => "left" }, { "label" => "Right", "value" => "right" } ] }
+        ]
+      },
+      {
+        "handle" => "gallery", "label" => "Gallery",
+        "fields" => [
+          { "handle" => "heading", "type" => "text", "label" => "Heading" },
+          { "handle" => "image_one", "type" => "image", "label" => "Image One" },
+          { "handle" => "image_two", "type" => "image", "label" => "Image Two" },
+          { "handle" => "image_three", "type" => "image", "label" => "Image Three" }
+        ]
+      },
+      {
+        "handle" => "cta", "label" => "Call to Action",
+        "fields" => [
+          { "handle" => "heading", "type" => "text", "label" => "Heading" },
+          { "handle" => "text", "type" => "textarea", "label" => "Text" },
+          { "handle" => "button_label", "type" => "text", "label" => "Button Label" },
+          { "handle" => "button_url", "type" => "text", "label" => "Button URL" }
+        ]
+      },
+      {
+        "handle" => "button", "label" => "Button",
+        "fields" => [
+          { "handle" => "label", "type" => "text", "label" => "Label" },
+          { "handle" => "url", "type" => "text", "label" => "URL" }
+        ]
+      },
+      {
+        "handle" => "spacer", "label" => "Spacer",
+        "fields" => [
+          { "handle" => "size", "type" => "select", "label" => "Size",
+            "options" => [ { "label" => "Small", "value" => "small" }, { "label" => "Medium", "value" => "medium" }, { "label" => "Large", "value" => "large" } ] }
+        ]
+      }
+    ].freeze
+
+    TEMPLATES = {
+      "hero" => <<~LIQUID,
+        <section class="plum-block plum-block-hero">
+          {% if block.heading %}<h2>{{ block.heading }}</h2>{% endif %}
+          {% if block.subheading %}<p>{{ block.subheading }}</p>{% endif %}
+          {% if block.image.url %}
+            <img class="plum-block-hero-image" src="{{ block.image.url }}" alt="{{ block.image.alt_text | default: block.heading }}">
+          {% endif %}
+          {% if block.button_label and block.button_url %}
+            <a class="plum-block-cta-button" href="{{ block.button_url }}">{{ block.button_label }}</a>
+          {% endif %}
+        </section>
+      LIQUID
+      "rich_text" => <<~LIQUID,
+        <div class="plum-block plum-block-rich-text prose">
+          {{ block.body | markdown }}
+        </div>
+      LIQUID
+      "image" => <<~LIQUID,
+        <figure class="plum-block plum-block-image">
+          {% if block.image.url %}<img src="{{ block.image.url }}" alt="{{ block.image.alt_text | default: block.caption }}">{% endif %}
+          {% if block.caption %}<figcaption>{{ block.caption }}</figcaption>{% endif %}
+        </figure>
+      LIQUID
+      "image_text" => <<~LIQUID,
+        <section class="plum-block plum-block-image-text plum-image-{{ block.image_position | default: 'left' }}">
+          {% if block.image.url %}
+            <div class="plum-block-image-text-media">
+              <img src="{{ block.image.url }}" alt="{{ block.image.alt_text | default: block.heading }}">
+            </div>
+          {% endif %}
+          <div class="plum-block-image-text-body">
+            {% if block.heading %}<h2>{{ block.heading }}</h2>{% endif %}
+            <div class="prose">{{ block.body | markdown }}</div>
+          </div>
+        </section>
+      LIQUID
+      "gallery" => <<~LIQUID,
+        <section class="plum-block plum-block-gallery">
+          {% if block.heading %}<h2>{{ block.heading }}</h2>{% endif %}
+          <div class="plum-block-gallery-grid">
+            {% if block.image_one.url %}<img src="{{ block.image_one.url }}" alt="{{ block.image_one.alt_text }}">{% endif %}
+            {% if block.image_two.url %}<img src="{{ block.image_two.url }}" alt="{{ block.image_two.alt_text }}">{% endif %}
+            {% if block.image_three.url %}<img src="{{ block.image_three.url }}" alt="{{ block.image_three.alt_text }}">{% endif %}
+          </div>
+        </section>
+      LIQUID
+      "cta" => <<~LIQUID,
+        <section class="plum-block plum-block-cta">
+          {% if block.heading %}<h2>{{ block.heading }}</h2>{% endif %}
+          {% if block.text %}<p>{{ block.text }}</p>{% endif %}
+          {% if block.button_label and block.button_url %}
+            <a class="plum-block-cta-button" href="{{ block.button_url }}">{{ block.button_label }}</a>
+          {% endif %}
+        </section>
+      LIQUID
+      "button" => <<~LIQUID,
+        <div class="plum-block plum-block-button">
+          {% if block.label and block.url %}<a class="plum-block-cta-button" href="{{ block.url }}">{{ block.label }}</a>{% endif %}
+        </div>
+      LIQUID
+      "spacer" => <<~LIQUID
+        <div class="plum-block plum-block-spacer plum-spacer-{{ block.size | default: 'medium' }}"></div>
+      LIQUID
+    }.freeze
+
+    def definitions
+      DEFINITIONS
+    end
+
+    def definition(handle)
+      DEFINITIONS.find { |definition| definition["handle"] == handle.to_s }
+    end
+
+    def template(handle)
+      TEMPLATES[handle.to_s]
+    end
+  end
+end

data/app/services/plum/block_editor_config.rb

@@ -0,0 +1,65 @@
+module Plum
+  # Translates a theme's declared blocks (theme.yml `blocks:`) into a
+  # JSON-serializable config our own block editor consumes to render the block
+  # picker and per-block field inputs. This is the seam that keeps the editor in
+  # the engine and the block library in themes: the editor never reads a theme
+  # directly — it reads this generated config. Theme authors write zero JS.
+  #
+  # Shape:
+  #   {
+  #     "blocks" => [
+  #       { "id" => "hero", "label" => "Hero", "category" => "Blocks",
+  #         "fields" => [ { "handle" => "heading", "type" => "text", "label" => "Heading" }, ... ] }
+  #     ]
+  #   }
+  #
+  # An optional `allowed` list (the blueprint field's `blocks:` whitelist) limits
+  # which theme blocks are offered for a given field.
+  class BlockEditorConfig
+    DEFAULT_CATEGORY = "Blocks".freeze
+
+    def initialize(theme, allowed: nil)
+      @theme = theme
+      @allowed = allowed.nil? ? nil : Array(allowed).map(&:to_s)
+    end
+
+    def blocks
+      definitions.map do |definition|
+        {
+          "id" => definition["handle"],
+          "label" => definition["label"],
+          "category" => definition["category"].presence || DEFAULT_CATEGORY,
+          "fields" => Array(definition["fields"]).map { |field| field_config(field) }
+        }
+      end
+    end
+
+    def to_h
+      { "blocks" => blocks }
+    end
+
+    def to_json(*args)
+      to_h.to_json(*args)
+    end
+
+    private
+
+    attr_reader :theme, :allowed
+
+    def definitions
+      list = BlockLibrary.new(theme).definitions
+      return list if allowed.nil?
+
+      list.select { |definition| allowed.include?(definition["handle"]) }
+    end
+
+    def field_config(field)
+      {
+        "handle" => field["handle"],
+        "type" => field["type"].presence || "text",
+        "label" => field["label"].presence || field["handle"].to_s.humanize,
+        "options" => Array(field["options"])
+      }
+    end
+  end
+end

data/app/services/plum/block_library.rb

@@ -0,0 +1,31 @@
+module Plum
+  # The merged block palette available to an entry: engine-level base blocks
+  # (Plum::BaseBlocks) plus the active theme's own blocks. A theme block overrides
+  # a base block with the same handle, so a theme can both add new sections and
+  # customize universal ones. This is the single resolution point used by the
+  # block editor (Plum::BlockEditorConfig) and the renderer (Plum::BuilderRenderer).
+  class BlockLibrary
+    def initialize(theme = nil)
+      @theme = theme
+    end
+
+    # Base blocks first, then theme blocks override (by handle) or append.
+    def definitions
+      merged = {}
+      BaseBlocks.definitions.each { |definition| merged[definition["handle"]] = definition }
+      Array(@theme&.blocks).each { |definition| merged[definition["handle"]] = definition }
+      merged.values
+    end
+
+    def definition(handle)
+      handle = handle.to_s
+      (@theme && @theme.block_definition(handle)) || BaseBlocks.definition(handle)
+    end
+
+    # The Liquid source for a block. Theme partial wins; otherwise the base block.
+    def template(handle)
+      handle = handle.to_s
+      (@theme && @theme.block_template(handle)) || BaseBlocks.template(handle)
+    end
+  end
+end

data/app/services/plum/builder_renderer.rb

@@ -0,0 +1,63 @@
+require "liquid"
+
+module Plum
+  # Renders an array of block instances (stored on an entry's blocks field) into
+  # HTML using theme-provided Liquid block partials.
+  #
+  # Each block instance has the shape:
+  #
+  #   { "id" => "<uuid>", "type" => "hero", "fields" => { "heading" => "Hi", "image" => 42 } }
+  #
+  # A block's own field values are exposed to its partial under the `block`
+  # variable, and the full shared site context (site, globals, nav, theme
+  # settings, registered content sources, ...) is merged in so block partials see
+  # exactly what a normal template sees. Image and relationship block fields are
+  # expanded with the same rules as entry fields via FieldExpander.
+  class BuilderRenderer
+    def initialize(blocks:, base_assigns:, site:, theme:, field_expander: nil, registers: {})
+      @blocks = Array(blocks)
+      @base_assigns = base_assigns || {}
+      @site = site
+      @theme = theme
+      @library = BlockLibrary.new(theme)
+      @field_expander = field_expander || FieldExpander.new(site: site)
+      @registers = registers
+    end
+
+    def render
+      return "".html_safe if blocks.empty?
+
+      rendered = blocks.filter_map { |block| render_block(block) }
+      rendered.join("\n").html_safe
+    end
+
+    private
+
+    attr_reader :blocks, :base_assigns, :site, :theme, :library, :field_expander, :registers
+
+    def render_block(block)
+      return unless block.is_a?(Hash)
+
+      handle = block["type"].to_s
+      definition = library.definition(handle)
+      return debug_comment("unknown block type: #{handle}") if definition.nil?
+
+      template_source = library.template(handle)
+      return debug_comment("missing block template: #{handle}") if template_source.nil?
+
+      template = Liquid::Template.parse(template_source)
+      assigns = base_assigns.merge("block" => block_assigns(block, definition))
+      template.render(assigns, filters: [ LiquidFilters ], registers: registers)
+    end
+
+    def block_assigns(block, definition)
+      field_expander.expand(values: block["fields"], fields: definition["fields"])
+    end
+
+    def debug_comment(message)
+      return "" unless defined?(Rails) && Rails.env.development?
+
+      "<!-- plum block: #{ERB::Util.html_escape(message)} -->"
+    end
+  end
+end

data/app/services/plum/field_expander.rb

@@ -0,0 +1,78 @@
+module Plum
+  # Expands raw stored field values (as kept in entry.data or a block's fields
+  # hash) into the richer structures themes expect in Liquid: image ids become
+  # asset hashes, relationship ids become published entry hashes. The same rules
+  # are reused for entry fields and block fields so blocks behave identically.
+  class FieldExpander
+    MAX_RELATIONSHIP_DEPTH = 2
+
+    def initialize(site:, url_builder: nil)
+      @site = site
+      @url_builder = url_builder
+    end
+
+    # values: hash of stored field values (handle => raw value)
+    # fields: array of blueprint/block field definitions ({ "handle", "type" })
+    def expand(values:, fields:, relationship_depth: MAX_RELATIONSHIP_DEPTH)
+      data = (values || {}).deep_dup
+      data = {} unless data.is_a?(Hash)
+
+      Array(fields).each do |field|
+        handle = field["handle"].to_s
+        next if handle.blank?
+
+        case field["type"]
+        when "image"
+          data[handle] = image_asset_context(data[handle])
+        when "relationship"
+          data[handle] = relationship_entry_context(data[handle], relationship_depth: relationship_depth)
+        end
+      end
+
+      data
+    end
+
+    private
+
+    attr_reader :site, :url_builder
+
+    def image_asset_context(value)
+      return if value.blank?
+
+      asset_cache[value.to_i]&.to_liquid
+    end
+
+    def relationship_entry_context(value, relationship_depth:)
+      return if value.blank? || relationship_depth <= 0
+
+      related_entry = relationship_entry_cache[value.to_i]
+      return unless related_entry
+
+      {
+        "title" => related_entry.title,
+        "slug" => related_entry.slug,
+        "published_at" => related_entry.published_at,
+        "url" => entry_url(related_entry),
+        "data" => expand(
+          values: related_entry.data,
+          fields: related_entry.content_type.fields,
+          relationship_depth: relationship_depth - 1
+        )
+      }
+    end
+
+    def entry_url(entry)
+      return url_builder.call(entry) if url_builder.respond_to?(:call)
+
+      "/#{entry.slug}"
+    end
+
+    def asset_cache
+      @asset_cache ||= Asset.for_site(site).with_attached_file.index_by(&:id)
+    end
+
+    def relationship_entry_cache
+      @relationship_entry_cache ||= Entry.for_site(site).live.includes(:content_type).index_by(&:id)
+    end
+  end
+end