plum-cms 0.1.2 → 0.2.0

data/app/models/plum/entry.rb

@@ -4,9 +4,12 @@ module Plum
 
     belongs_to :content_type
     belongs_to :author, class_name: "Plum::User", optional: true
+    belongs_to :origin, class_name: "Plum::Entry", optional: true
 
     has_many :entry_terms, dependent: :destroy
     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
 
     # The page served at "/" — Plum resolves the homepage by this slug
     # (convention over configuration). Its slug is locked and it can't be
@@ -17,11 +20,16 @@ module Plum
     enum :status, { draft: 0, published: 1, scheduled: 2 }
 
     validates :title, presence: true
-    validates :slug, presence: true, uniqueness: { scope: :site_id }, format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/ }
+    validates :slug, presence: true, uniqueness: { scope: [ :site_id, :locale ] }, format: { with: /\A[a-z0-9]+(?:-[a-z0-9]+)*\z/ }
+    validates :locale, presence: true, format: { with: /\A[a-z]{2}(?:-[A-Z]{2})?\z/ }
+    validate :origin_matches_site_and_content_type
     validates :status, presence: true
     validate :homepage_slug_is_unchanged
+    validate :required_blueprint_fields_are_present
+    validate :blueprint_field_values_are_valid
 
     before_validation :generate_slug
+    before_validation :set_default_locale, on: :create
     before_validation :set_published_at, if: :published?
     before_destroy :prevent_homepage_destroy
 
@@ -41,8 +49,66 @@ module Plum
       slug == HOMEPAGE_SLUG
     end
 
+    def record_revision!(editor: nil)
+      identity = revision_editor_identity(editor)
+      attributes = {
+        site: site,
+        editor_name: identity[:name],
+        editor_email: identity[:email],
+        editor_gid: identity[:gid],
+        snapshot: {
+          "title" => title,
+          "slug" => slug,
+          "status" => status,
+          "published_at" => published_at&.iso8601,
+          "data" => data.to_h.deep_dup,
+          "term_ids" => term_ids
+        }
+      }
+      attributes[:editor] = editor if editor.is_a?(Plum::User)
+      revisions.create!(attributes)
+    end
+
+    def restore_revision!(revision, editor: nil)
+      raise ArgumentError, "Revision does not belong to this entry" unless revision.entry_id == id && revision.site_id == site_id
+
+      snapshot = revision.snapshot.to_h
+      transaction do
+        update!(snapshot.slice("title", "slug", "status", "published_at", "data"))
+        self.term_ids = site.terms.where(id: Array(snapshot["term_ids"])).pluck(:id)
+        record_revision!(editor: editor)
+      end
+    end
+
+    def translation_group
+      source = origin || self
+      [ source, *source.translations ].uniq.sort_by(&:locale)
+    end
+
     private
 
+    def set_default_locale
+      self.locale = site&.default_locale if locale.blank?
+    end
+
+    def origin_matches_site_and_content_type
+      return unless origin
+
+      errors.add(:origin, "must belong to the same site") if origin.site_id != site_id
+      errors.add(:origin, "must use the same content type") if origin.content_type_id != content_type_id
+      errors.add(:origin, "cannot itself be a translation") if origin.origin_id.present?
+    end
+
+    def revision_editor_identity(editor)
+      return {} unless editor
+
+      {
+        name: editor.respond_to?(:name) ? editor.name : nil,
+        email: editor.respond_to?(:email) ? editor.email : nil,
+        gid: editor.respond_to?(:to_global_id) ? editor.to_global_id.to_s : nil
+      }
+    end
+
     def generate_slug
       self.slug = title&.parameterize if slug.blank?
     end
@@ -53,6 +119,164 @@ module Plum
       errors.add(:slug, "can't be changed — this is the homepage")
     end
 
+    def required_blueprint_fields_are_present
+      content_type&.fields.to_a.each do |field|
+        next if field["type"] == "section"
+        next unless blueprint_field_visible?(field)
+
+        handle = field["handle"].to_s
+        value = if field["type"] == "taxonomy"
+          terms.joins(:taxonomy).where(plum_taxonomies: { handle: field["taxonomy"].to_s }).exists?
+        else
+          data&.dig(handle)
+        end
+        value = parsed_structured_validation_value(value) if %w[group repeater].include?(field["type"])
+
+        validate_required_value(field, value, field["label"].presence || handle.titleize)
+      end
+    end
+
+    def parsed_structured_validation_value(value)
+      return value unless value.is_a?(String)
+
+      JSON.parse(value)
+    rescue JSON::ParserError
+      value
+    end
+
+    def validate_required_value(field, value, path)
+      if ActiveModel::Type::Boolean.new.cast(field["required"]) && value != false && value.blank?
+        errors.add(:data, "#{path} is required")
+        return
+      end
+
+      case field["type"]
+      when "group"
+        values = value.respond_to?(:to_h) ? value.to_h : {}
+        validate_required_nested_fields(field, values, path)
+      when "repeater"
+        Array(value).each_with_index do |row, index|
+          values = row.respond_to?(:to_h) ? row.to_h : {}
+          validate_required_nested_fields(field, values, "#{path} row #{index + 1}")
+        end
+      end
+    end
+
+    def validate_required_nested_fields(field, values, path)
+      Array(field["fields"]).each do |nested_field|
+        handle = nested_field["handle"].to_s
+        validate_required_value(nested_field, values[handle], "#{path} #{nested_field['label'].presence || handle.titleize}")
+      end
+    end
+
+    def blueprint_field_values_are_valid
+      content_type&.fields.to_a.each do |field|
+        next if field["type"] == "section"
+        next unless blueprint_field_visible?(field)
+
+        value = data&.dig(field["handle"].to_s)
+        value = parsed_structured_validation_value(value) if %w[list repeater].include?(field["type"])
+        label = field["label"].presence || field["handle"].to_s.titleize
+
+        case field["type"]
+        when "list", "repeater", "images"
+          validate_collection_constraints(field, Array(value), label)
+        when "relationship"
+          validate_collection_constraints(field, Array(value), label) if ActiveModel::Type::Boolean.new.cast(field["multiple"])
+        when "number"
+          validate_number_constraints(field, value, label)
+        when "date"
+          validate_date_constraints(field, value, label)
+        when "select", "radio", "button_group", "checkboxes"
+          validate_option_values(field, value, label)
+        else
+          validate_custom_field(definition: FieldTypeRegistry.find(field["type"]), field: field, value: value, label: label)
+        end
+      end
+    end
+
+    def validate_custom_field(definition:, field:, value:, label:)
+      return unless definition&.validator
+
+      messages = definition.validator.call(value: value, field: field, entry: self)
+      Array(messages).select(&:present?).each { |message| errors.add(:data, "#{label} #{message}") }
+    end
+
+    def blueprint_field_visible?(field)
+      condition = field["condition"]
+      return true if condition.blank?
+
+      values = Array(data&.dig(condition["field"].to_s)).map(&:to_s)
+      expected = condition["value"].to_s
+      case condition["operator"]
+      when "equals" then values.include?(expected)
+      when "not_equals" then !values.include?(expected)
+      when "contains" then values.any? { |value| value.include?(expected) }
+      when "empty" then values.empty? || values.all?(&:blank?)
+      when "not_empty" then values.any?(&:present?)
+      else true
+      end
+    end
+
+    def validate_option_values(field, value, label)
+      return if value.blank?
+
+      allowed = FieldOptions.pairs(field["options"]).map(&:last)
+      invalid = Array(value).map(&:to_s) - allowed
+      errors.add(:data, "#{label} contains an invalid option") if invalid.any?
+    end
+
+    def validate_collection_constraints(field, values, label)
+      minimum = field["min_items"].presence&.to_i
+      maximum = field["max_items"].presence&.to_i
+      errors.add(:data, "#{label} must have at least #{minimum} items") if minimum && values.length < minimum
+      errors.add(:data, "#{label} must have no more than #{maximum} items") if maximum && values.length > maximum
+      if field["type"] == "list" && ActiveModel::Type::Boolean.new.cast(field["unique"])
+        normalized = values.map { |value| value.to_s.strip.downcase }.reject(&:blank?)
+        errors.add(:data, "#{label} values must be unique") if normalized.uniq.length != normalized.length
+      end
+    end
+
+    def validate_number_constraints(field, value, label)
+      return if value.blank?
+
+      number = BigDecimal(value.to_s)
+      if field["number_kind"] == "integer" && number.frac.nonzero?
+        errors.add(:data, "#{label} must be a whole number")
+      end
+      errors.add(:data, "#{label} must be at least #{field['min']}") if field["min"].present? && number < BigDecimal(field["min"].to_s)
+      errors.add(:data, "#{label} must be no more than #{field['max']}") if field["max"].present? && number > BigDecimal(field["max"].to_s)
+      if field["step"].present? && BigDecimal(field["step"].to_s).positive?
+        base = field["min"].present? ? BigDecimal(field["min"].to_s) : 0
+        errors.add(:data, "#{label} does not match the required step") unless ((number - base) % BigDecimal(field["step"].to_s)).zero?
+      end
+    rescue ArgumentError
+      errors.add(:data, "#{label} must be a number")
+    end
+
+    def validate_date_constraints(field, value, label)
+      return if value.blank?
+
+      parsed = parsed_temporal_value(value, field["date_mode"])
+      minimum = parsed_temporal_value(field["min"], field["date_mode"]) if field["min"].present?
+      maximum = parsed_temporal_value(field["max"], field["date_mode"]) if field["max"].present?
+      errors.add(:data, "#{label} must be on or after #{field['min']}") if minimum && parsed < minimum
+      errors.add(:data, "#{label} must be on or before #{field['max']}") if maximum && parsed > maximum
+    rescue ArgumentError
+      errors.add(:data, "#{label} is not a valid #{field['date_mode'].presence || 'date'}")
+    end
+
+    def parsed_temporal_value(value, mode)
+      case mode
+      when "time"
+        Time.strptime(value.to_s, "%H:%M")
+      when "datetime"
+        Time.zone.parse(value.to_s) || raise(ArgumentError)
+      else
+        Date.iso8601(value.to_s)
+      end
+    end
+
     def prevent_homepage_destroy
       return unless homepage?
 

data/app/models/plum/entry_revision.rb

@@ -0,0 +1,14 @@
+module Plum
+  class EntryRevision < ApplicationRecord
+    include SiteScoped
+
+    belongs_to :entry
+    belongs_to :editor, class_name: "Plum::User", optional: true
+
+    validates :snapshot, presence: true
+
+    def editor_label
+      editor_name.presence || editor_email.presence || editor&.email.presence || "Unknown editor"
+    end
+  end
+end

data/app/models/plum/fieldset.rb

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

data/app/models/plum/site.rb

@@ -13,6 +13,7 @@ module Plum
     has_many :form_submissions, dependent: :destroy
     has_many :taxonomies, dependent: :destroy
     has_many :terms, dependent: :destroy
+    has_many :fieldsets, dependent: :destroy
 
     attribute :skip_defaults, :boolean, default: false
 
@@ -51,6 +52,20 @@ module Plum
       super || {}
     end
 
+    def locales
+      configured = Array(settings.to_h["locales"]).map(&:to_s).select { |locale| locale.match?(/\A[a-z]{2}(?:-[A-Z]{2})?\z/) }
+      configured.presence || [ "en" ]
+    end
+
+    def default_locale
+      configured = settings.to_h["default_locale"].to_s
+      locales.include?(configured) ? configured : locales.first
+    end
+
+    def localized?
+      locales.many?
+    end
+
     private
 
     def self.owner_default_name(owner)

data/app/models/plum/user.rb

@@ -3,6 +3,7 @@ module Plum
     has_secure_password
 
     has_many :entries, foreign_key: :author_id, dependent: :nullify
+    has_many :entry_revisions, foreign_key: :editor_id, dependent: :nullify
 
     enum :role, { viewer: 0, editor: 1, admin: 2 }
 

data/app/services/plum/entry_serializer.rb

@@ -0,0 +1,36 @@
+module Plum
+  class EntrySerializer
+    def initialize(site:)
+      @site = site
+      @expander = FieldExpander.new(site: site, url_builder: method(:entry_path))
+    end
+
+    def as_json(entry)
+      {
+        "id" => entry.id,
+        "title" => entry.title,
+        "slug" => entry.slug,
+        "locale" => entry.locale,
+        "url" => entry_path(entry),
+        "status" => entry.status,
+        "published_at" => entry.published_at&.iso8601,
+        "updated_at" => entry.updated_at&.iso8601,
+        "collection" => {
+          "handle" => entry.content_type.handle,
+          "title" => entry.content_type.name
+        },
+        "data" => @expander.expand(values: entry.data, fields: entry.content_type.fields),
+        "terms" => entry.terms.group_by { |term| term.taxonomy.handle }.transform_values do |terms|
+          terms.map { |term| { "name" => term.name, "slug" => term.slug } }
+        end
+      }
+    end
+
+    private
+
+    def entry_path(entry)
+      locale_prefix = entry.locale == @site.default_locale ? nil : entry.locale
+      "/#{[ locale_prefix, entry.content_type.route_prefix, entry.slug ].compact.join('/')}"
+    end
+  end
+end

data/app/services/plum/field_expander.rb

@@ -24,8 +24,19 @@ module Plum
         case field["type"]
         when "image"
           data[handle] = image_asset_context(data[handle])
+        when "images"
+          data[handle] = Array(data[handle]).filter_map { |value| image_asset_context(value) }
         when "relationship"
-          data[handle] = relationship_entry_context(data[handle], relationship_depth: relationship_depth)
+          data[handle] = if ActiveModel::Type::Boolean.new.cast(field["multiple"])
+            Array(data[handle]).filter_map { |value| relationship_entry_context(value, relationship_depth: relationship_depth) }
+          else
+            relationship_entry_context(data[handle], relationship_depth: relationship_depth)
+          end
+        else
+          definition = FieldTypeRegistry.find(field["type"])
+          if definition&.expander
+            data[handle] = definition.expander.call(value: data[handle], field: field, site: site, expander: self)
+          end
         end
       end
 

data/app/services/plum/field_options.rb

@@ -0,0 +1,21 @@
+module Plum
+  module FieldOptions
+    module_function
+
+    def pairs(options)
+      Array(options).filter_map do |option|
+        if option.is_a?(Hash)
+          value = option["value"] || option[:value]
+          label = option["label"] || option[:label] || value
+          [ label.to_s, value.to_s ] if value.present?
+        elsif option.present?
+          [ option.to_s, option.to_s ]
+        end
+      end
+    end
+
+    def editor_value(options)
+      pairs(options).map { |label, value| label == value ? label : "#{label} | #{value}" }.join("\n")
+    end
+  end
+end

data/app/services/plum/field_type_registry.rb

@@ -0,0 +1,88 @@
+module Plum
+  class FieldTypeRegistry
+    Definition = Struct.new(
+      :handle, :label, :configuration, :partial, :normalizer, :validator, :expander,
+      keyword_init: true
+    )
+
+    COMMON_CONFIGURATION = %w[label instructions required default placeholder].freeze
+    NESTED_FIELD_TYPES = %w[text textarea number boolean date url].freeze
+
+    DEFINITIONS = [
+      Definition.new(handle: "text", label: "Text", configuration: []),
+      Definition.new(handle: "textarea", label: "Textarea", configuration: []),
+      Definition.new(handle: "rich_text", label: "Rich Text", configuration: []),
+      Definition.new(handle: "number", label: "Number", configuration: %w[number_kind min max step unit]),
+      Definition.new(handle: "boolean", label: "Boolean", configuration: []),
+      Definition.new(handle: "date", label: "Date / Time", configuration: %w[date_mode min max]),
+      Definition.new(handle: "select", label: "Select", configuration: %w[options]),
+      Definition.new(handle: "radio", label: "Radio", configuration: %w[options]),
+      Definition.new(handle: "button_group", label: "Button Group", configuration: %w[options]),
+      Definition.new(handle: "checkboxes", label: "Checkboxes", configuration: %w[options]),
+      Definition.new(handle: "color", label: "Color", configuration: []),
+      Definition.new(handle: "url", label: "URL", configuration: []),
+      Definition.new(handle: "taxonomy", label: "Taxonomy", configuration: %w[taxonomy]),
+      Definition.new(handle: "image", label: "Image", configuration: []),
+      Definition.new(handle: "images", label: "Images", configuration: %w[min_items max_items]),
+      Definition.new(handle: "relationship", label: "Relationship", configuration: %w[content_type multiple min_items max_items]),
+      Definition.new(handle: "blocks", label: "Blocks", configuration: %w[blocks]),
+      Definition.new(handle: "list", label: "List", configuration: %w[min_items max_items unique]),
+      Definition.new(handle: "group", label: "Group", configuration: %w[fields]),
+      Definition.new(handle: "repeater", label: "Repeater", configuration: %w[fields min_items max_items]),
+      Definition.new(handle: "section", label: "Section", configuration: [])
+    ].freeze
+
+    class << self
+      def all
+        DEFINITIONS + custom_definitions.values
+      end
+
+      def handles
+        all.map(&:handle)
+      end
+
+      def find(handle)
+        all.find { |definition| definition.handle == handle.to_s }
+      end
+
+      def include?(handle)
+        find(handle).present?
+      end
+
+      def options
+        all.map { |definition| [ definition.label, definition.handle ] }
+      end
+
+      def as_json
+        all.map { |definition| { handle: definition.handle, label: definition.label } }
+      end
+
+      def register(handle:, label:, configuration: [], partial: nil, normalizer: nil, validator: nil, expander: nil)
+        normalized_handle = handle.to_s
+        raise ArgumentError, "Field type handle is invalid" unless normalized_handle.match?(/\A[a-z][a-z0-9_]*\z/)
+        raise ArgumentError, "Field type #{normalized_handle} is already registered" if include?(normalized_handle)
+        raise ArgumentError, "Custom field types require an editor partial" if partial.blank?
+
+        custom_definitions[normalized_handle] = Definition.new(
+          handle: normalized_handle,
+          label: label.to_s.presence || normalized_handle.titleize,
+          configuration: Array(configuration).map(&:to_s),
+          partial: partial.to_s,
+          normalizer: normalizer,
+          validator: validator,
+          expander: expander
+        ).freeze
+      end
+
+      def reset_custom!
+        @custom_definitions = {}
+      end
+
+      private
+
+      def custom_definitions
+        @custom_definitions ||= {}
+      end
+    end
+  end
+end

data/app/services/plum/liquid_context.rb

@@ -306,6 +306,7 @@ module Plum
 
     def live_entries_by_type
       @live_entries_by_type ||= Entry.for_site(site).live
+                                    .where(locale: current_locale)
                                     .includes(:content_type, terms: :taxonomy)
                                     .order(published_at: :desc, created_at: :desc)
                                     .group_by(&:content_type_id)
@@ -320,10 +321,15 @@ module Plum
     end
 
     def public_entry_path(entry)
-      path = [ entry.content_type.route_prefix, entry.slug ].compact.join("/")
+      locale_prefix = entry.locale == site.default_locale ? nil : entry.locale
+      path = [ locale_prefix, entry.content_type.route_prefix, entry.slug ].compact.join("/")
       "#{controller.request.script_name.to_s.chomp("/")}/#{path}"
     end
 
+    def current_locale
+      entry&.locale.presence || controller.params[:locale].presence || site.default_locale
+    end
+
     def public_form_path(form)
       "#{controller.request.script_name.to_s.chomp("/")}/forms/#{form.handle}"
     end

data/app/views/layouts/plum/cp.html.erb

@@ -78,6 +78,8 @@
             <% end %>
             <%= link_to "+ New Type", new_cp_content_type_path,
                 class: "flex items-center px-4 py-2 mt-2 text-sm font-medium plum-sidebar-link" %>
+            <%= link_to "Fieldsets", cp_fieldsets_path,
+                class: "flex items-center px-4 py-2 mt-2 text-sm font-medium rounded-md plum-sidebar-link #{request.path.include?('/cp/fieldsets') ? 'active' : ''}" %>
             <%= link_to "Assets", cp_assets_path,
                 class: "flex items-center px-4 py-2 mt-2 text-sm font-medium rounded-md plum-sidebar-link #{request.path.include?('/cp/assets') ? 'active' : ''}" %>
             <%= link_to "Globals", cp_globals_path,

data/app/views/plum/cp/assets/_form.html.erb

@@ -9,12 +9,24 @@
     </div>
   <% end %>
 
+  <div data-controller="plum--focal-point">
   <% if asset.persisted? && plum_asset_image_url(asset).present? %>
     <div class="overflow-hidden rounded-lg border border-gray-200 bg-gray-100">
-      <%= image_tag plum_asset_image_url(asset), alt: asset.alt_text.to_s, class: "h-44 w-full object-cover" %>
+      <%= image_tag plum_asset_image_url(asset), alt: asset.alt_text.to_s, class: "h-44 w-full object-cover", data: { "plum--focal-point-target": "preview" } %>
     </div>
   <% end %>
 
+  <div class="mt-4 grid gap-4 sm:grid-cols-2">
+    <label class="text-sm font-medium text-gray-700">Horizontal focal point
+      <%= f.range_field :focal_x, min: 0, max: 100, data: { "plum--focal-point-target": "x", action: "input->plum--focal-point#refresh" }, class: "mt-2 block w-full" %>
+    </label>
+    <label class="text-sm font-medium text-gray-700">Vertical focal point
+      <%= f.range_field :focal_y, min: 0, max: 100, data: { "plum--focal-point-target": "y", action: "input->plum--focal-point#refresh" }, class: "mt-2 block w-full" %>
+    </label>
+  </div>
+  <p class="mt-2 text-xs text-gray-500">Crop focus: <span data-plum--focal-point-target="label"></span></p>
+  </div>
+
   <div>
     <%= f.label :file, asset.persisted? ? "Replace image" : "Image", class: "block text-sm font-medium text-gray-700" %>
     <%= f.file_field :file, accept: "image/*", class: "mt-1 block w-full text-sm text-gray-700" %>