plum-cms 0.1.2 → 0.2.1

data/app/controllers/plum/cp/entries_controller.rb

@@ -11,16 +11,16 @@ module Plum
       ].freeze
 
       before_action :set_content_type
-      before_action :set_entry, only: [ :edit, :update, :destroy, :image_field ]
+      before_action :set_entry, only: [ :edit, :update, :destroy, :image_field, :translate ]
       before_action :set_form_collections, only: [ :new, :create, :edit, :update ]
-      before_action :require_editor, only: [ :new, :create, :edit, :update, :destroy, :image_field ]
+      before_action :require_editor, only: [ :new, :create, :edit, :update, :destroy, :image_field, :translate ]
 
       def index
         @entries = @content_type.entries.order(updated_at: :desc)
       end
 
       def new
-        @entry = @content_type.entries.build(status: :draft, site: current_site)
+        @entry = @content_type.entries.build(status: :draft, site: current_site, locale: current_site.default_locale)
       end
 
       def create
@@ -73,6 +73,29 @@ module Plum
         redirect_to cp_content_type_entries_path(@content_type), notice: "Entry deleted"
       end
 
+      def translate
+        locale = params[:locale].to_s
+        unless current_site.locales.include?(locale)
+          return redirect_to edit_cp_content_type_entry_path(@content_type, @entry), alert: "Locale is not configured"
+        end
+
+        source = @entry.origin || @entry
+        translation = source.translations.find_or_initialize_by(locale: locale)
+        if translation.new_record?
+          translation.assign_attributes(
+            site: current_site,
+            content_type: @content_type,
+            author: current_user.is_a?(Plum::User) ? current_user : nil,
+            title: @entry.title,
+            slug: @entry.slug,
+            status: :draft,
+            data: @entry.data.to_h.deep_dup
+          )
+          translation.save!
+        end
+        redirect_to edit_cp_content_type_entry_path(@content_type, translation), notice: "#{locale} translation ready"
+      end
+
       private
 
       def set_content_type
@@ -96,7 +119,7 @@ module Plum
       end
 
       def entry_params
-        permitted = params.require(:entry).permit(:title, :slug, :status, :published_at)
+        permitted = params.require(:entry).permit(:title, :slug, :status, :published_at, :locale)
         if params[:entry][:data].is_a?(ActionController::Parameters)
           permitted[:data] = params[:entry][:data].permit!.to_h
         end
@@ -104,10 +127,17 @@ module Plum
       end
 
       def save_entry(entry)
-        return false unless entry.valid?
-        return false unless attach_uploaded_image_fields(entry)
+        saved = false
+        entry.transaction do
+          unless attach_uploaded_image_fields(entry) && entry.valid? && entry.save
+            raise ActiveRecord::Rollback
+          end
 
-        entry.save.tap { |saved| sync_entry_terms(entry) if saved }
+          sync_entry_terms(entry)
+          entry.record_revision!(editor: current_user)
+          saved = true
+        end
+        saved
       end
 
       def sync_entry_terms(entry)
@@ -150,7 +180,7 @@ module Plum
 
         @content_type.fields.each do |field|
           handle = field["handle"].to_s
-          next if handle.blank?
+          next if handle.blank? || field["type"] == "section"
 
           value = entry.data[handle]
           entry.data[handle] = normalized_field_value(entry, field, value)
@@ -161,25 +191,105 @@ module Plum
       end
 
       def normalized_field_value(entry, field, value)
+        definition = FieldTypeRegistry.find(field["type"])
+        if definition&.normalizer
+          return definition.normalizer.call(value: value, field: field, entry: entry, controller: self)
+        end
+
         case field["type"]
         when "boolean"
           ActiveModel::Type::Boolean.new.cast(value)
+        when "number"
+          normalized_number_value(value, field)
         when "checkboxes"
           Array(value).select(&:present?)
         when "image"
-          value.present? ? value.to_i : nil
+          normalized_image_value(entry, field, value)
+        when "images"
+          normalized_asset_ids(entry, field, value)
         when "rich_text"
           value
         when "relationship"
           normalized_relationship_value(entry, field, value)
         when "blocks"
           normalized_blocks_value(value)
+        when "list"
+          Array(parsed_structured_value(value, fallback: [])).map { |item| item.to_s.strip }.select(&:present?)
+        when "group"
+          normalized_structured_row(field, parsed_structured_value(value, fallback: {}))
+        when "repeater"
+          Array(parsed_structured_value(value, fallback: [])).filter_map do |row|
+            normalized = normalized_structured_row(field, row)
+            normalized if normalized.values.any?(&:present?)
+          end
         else
           value
         end
       end
 
+      def normalized_asset_ids(entry, field, value)
+        ids = Array(value).select(&:present?).map(&:to_i).uniq
+        valid_ids = current_site.assets.where(id: ids).pluck(:id)
+        if valid_ids.length != ids.length
+          entry.errors.add(:base, "#{field_label(field)} contains an invalid image")
+          return []
+        end
+
+        ids
+      end
+
+      def normalized_image_value(entry, field, value)
+        return nil if value.blank?
+
+        asset = current_site.assets.find_by(id: value.to_i)
+        unless asset
+          entry.errors.add(:base, "#{field_label(field)} is not a valid image")
+          return nil
+        end
+
+        asset.update!(alt_text: default_asset_alt_text(entry, field)) if asset.alt_text.blank?
+        asset.id
+      end
+
+      def normalized_number_value(value, field)
+        return nil if value.blank?
+
+        field["number_kind"] == "integer" ? Integer(value, 10) : Float(value)
+      rescue ArgumentError, TypeError
+        value
+      end
+
+      def parsed_structured_value(value, fallback:)
+        return value unless value.is_a?(String)
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        fallback
+      end
+
+      def normalized_structured_row(field, value)
+        row = value.respond_to?(:to_h) ? value.to_h : {}
+        Array(field["fields"]).each_with_object({}) do |nested_field, normalized|
+          handle = nested_field["handle"].to_s
+          next if handle.blank?
+
+          nested_value = row[handle]
+          nested_value = nested_field["default"] if nested_value.nil? && nested_field.key?("default")
+          normalized[handle] = nested_field["type"] == "boolean" ? ActiveModel::Type::Boolean.new.cast(nested_value) : nested_value
+        end
+      end
+
       def normalized_relationship_value(entry, field, value)
+        if ActiveModel::Type::Boolean.new.cast(field["multiple"])
+          ids = Array(value).select(&:present?).map(&:to_i).uniq
+          valid_ids = relationship_entry_scope(entry, field).where(id: ids).pluck(:id)
+          if valid_ids.length != ids.length
+            entry.errors.add(:base, "#{field_label(field)} contains an invalid entry")
+            return []
+          end
+          return ids
+        end
+
         return nil if value.blank?
 
         related_entry = relationship_entry_scope(entry, field).find_by(id: value.to_i)

data/app/controllers/plum/cp/entry_revisions_controller.rb

@@ -0,0 +1,27 @@
+module Plum
+  module Cp
+    class EntryRevisionsController < BaseController
+      before_action :require_editor
+      before_action :set_entry
+
+      def index
+        @revisions = @entry.revisions.order(created_at: :desc)
+      end
+
+      def restore
+        revision = @entry.revisions.find(params[:id])
+        @entry.restore_revision!(revision, editor: current_user)
+        redirect_to edit_cp_content_type_entry_path(@content_type, @entry), notice: "Revision restored"
+      rescue ActiveRecord::RecordInvalid => error
+        redirect_to cp_content_type_entry_revisions_path(@content_type, @entry), alert: "Could not restore revision: #{error.record.errors.full_messages.to_sentence}"
+      end
+
+      private
+
+      def set_entry
+        @content_type = current_site.content_types.find(params[:content_type_id])
+        @entry = @content_type.entries.find(params[:entry_id])
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/fieldsets_controller.rb

@@ -0,0 +1,37 @@
+module Plum
+  module Cp
+    class FieldsetsController < BaseController
+      before_action :require_admin
+
+      def index
+        @fieldsets = current_site.fieldsets.order(:name)
+        @content_types = current_site.content_types.order(:name)
+      end
+
+      def create
+        source = current_site.content_types.find(params.require(:fieldset)[:content_type_id])
+        fieldset = current_site.fieldsets.build(fieldset_params.except(:content_type_id))
+        fieldset.fields = source.fields.deep_dup
+        if fieldset.save
+          redirect_to cp_fieldsets_path, notice: "Fieldset created from #{source.name}"
+        else
+          @fieldsets = current_site.fieldsets.order(:name)
+          @content_types = current_site.content_types.order(:name)
+          @fieldset = fieldset
+          render :index, status: :unprocessable_entity
+        end
+      end
+
+      def destroy
+        current_site.fieldsets.find(params[:id]).destroy!
+        redirect_to cp_fieldsets_path, notice: "Fieldset deleted"
+      end
+
+      private
+
+      def fieldset_params
+        params.require(:fieldset).permit(:name, :handle, :content_type_id)
+      end
+    end
+  end
+end

data/app/controllers/plum/cp/site_settings_controller.rb

@@ -20,10 +20,19 @@ module Plum
       def update
         settings_attributes = site_settings_params
         theme_settings_by_theme = settings_attributes.delete(:theme_settings_by_theme).to_h
+        locales = normalized_locales(settings_attributes.delete(:locales))
+        default_locale = settings_attributes.delete(:default_locale).to_s
         @site_settings.assign_attributes(settings_attributes)
 
+        unless locales.any? && locales.include?(default_locale)
+          @site_settings.errors.add(:base, "Locales must be valid codes and include the default locale")
+          set_theme_options
+          return render :edit, status: :unprocessable_entity
+        end
+
         if @site_settings.save
-          current_site.update!(theme_settings: theme_settings_for(@site_settings.theme_name, theme_settings_by_theme))
+          site_settings = current_site.settings.to_h.merge("locales" => locales, "default_locale" => default_locale)
+          current_site.update!(theme_settings: theme_settings_for(@site_settings.theme_name, theme_settings_by_theme), settings: site_settings)
           redirect_to edit_cp_site_settings_path, notice: "Site settings updated"
         else
           set_theme_options
@@ -92,9 +101,19 @@ module Plum
           :primary_color,
           :support_email,
           :theme_name,
+          :locales,
+          :default_locale,
           theme_settings_by_theme: {}
         )
       end
+
+      def normalized_locales(value)
+        value.to_s.split(/[\s,]+/).filter_map do |locale|
+          parts = locale.split("-", 2)
+          normalized = [ parts[0]&.downcase, parts[1]&.upcase ].compact.join("-")
+          normalized if normalized.match?(/\A[a-z]{2}(?:-[A-Z]{2})?\z/)
+        end.uniq
+      end
     end
   end
 end

data/app/controllers/plum/pages_controller.rb

@@ -5,6 +5,7 @@ module Plum
     def home
       @site_settings = SiteSetting.instance(current_site)
       @entry = Entry.for_site(current_site).live
+                    .where(locale: requested_locale)
                     .includes(:content_type, terms: :taxonomy)
                     .find_by(slug: HOMEPAGE_SLUG)
 
@@ -13,10 +14,19 @@ module Plum
       render html: html.html_safe, layout: false
     end
 
+    def localized_home
+      raise ActiveRecord::RecordNotFound unless current_site.locales.include?(params[:locale])
+
+      home
+    rescue ActiveRecord::RecordNotFound
+      render file: Rails.public_path.join("404.html"), status: :not_found, layout: false
+    end
+
     def search
       query = params[:q].to_s.strip
       context = build_context
       results = Entry.for_site(current_site).live.search(query)
+                     .where(locale: requested_locale)
                      .includes(:content_type)
                      .order(published_at: :desc)
                      .limit(50)
@@ -33,6 +43,8 @@ module Plum
     end
 
     def show
+      raise ActiveRecord::RecordNotFound unless current_site.locales.include?(requested_locale)
+
       slug = params[:slug]
 
       @content_type = ContentType.for_site(current_site).find_by(handle: slug)
@@ -47,6 +59,7 @@ module Plum
         end
         if content_type
           @entry = Entry.for_site(current_site).live
+                        .where(locale: requested_locale)
                         .includes(:content_type, terms: :taxonomy)
                         .find_by!(content_type: content_type, slug: parts[1])
           html = Plum::LiquidRenderer.render_template("entries/#{content_type.handle}", build_context(@entry).to_h)
@@ -64,6 +77,7 @@ module Plum
       end
 
       @entry = Entry.for_site(current_site).live
+                    .where(locale: requested_locale)
                     .includes(:content_type, terms: :taxonomy)
                     .find_by!(slug: slug)
       template = "entries/#{@entry.content_type.handle}"
@@ -81,6 +95,7 @@ module Plum
       context = build_context
       page = [ params.fetch(:page, 1).to_i, 1 ].max
       all_entries = Entry.for_site(current_site).live
+                        .where(locale: requested_locale)
                         .where(content_type: content_type)
                         .order(published_at: :desc, created_at: :desc)
       total = all_entries.count
@@ -112,6 +127,7 @@ module Plum
       context = build_context
       page = [ params.fetch(:page, 1).to_i, 1 ].max
       all_entries = Entry.for_site(current_site).live
+                        .where(locale: requested_locale)
                         .joins(:entry_terms)
                         .where(plum_entry_terms: { term_id: term.id })
                         .order(published_at: :desc)
@@ -146,7 +162,7 @@ module Plum
           "name" => taxonomy.name,
           "handle" => taxonomy.handle,
           "slug" => taxonomy.slug,
-          "terms" => terms.map { |t| { "name" => t.name, "slug" => t.slug, "url" => "/#{taxonomy.slug}/#{t.slug}", "entries_count" => t.entries.live.count } }
+          "terms" => terms.map { |t| { "name" => t.name, "slug" => t.slug, "url" => localized_path("#{taxonomy.slug}/#{t.slug}"), "entries_count" => t.entries.live.where(locale: requested_locale).count } }
         }
       )
       template = "taxonomies/#{taxonomy.handle}_index"
@@ -157,5 +173,14 @@ module Plum
     def build_context(entry = nil)
       LiquidContext.new(controller: self, site: current_site, entry: entry)
     end
+
+    def requested_locale
+      params[:locale].presence || current_site.default_locale
+    end
+
+    def localized_path(path)
+      prefix = requested_locale == current_site.default_locale ? nil : requested_locale
+      "/#{[ prefix, path ].compact.join('/')}"
+    end
   end
 end

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

@@ -0,0 +1,18 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  static targets = ["checkbox", "count"]
+  static values = { max: Number }
+
+  connect() {
+    this.refresh()
+  }
+
+  refresh() {
+    const selected = this.checkboxTargets.filter(checkbox => checkbox.checked).length
+    if (this.hasCountTarget) this.countTarget.textContent = `${selected} selected`
+    this.checkboxTargets.forEach(checkbox => {
+      checkbox.disabled = this.hasMaxValue && this.maxValue > 0 && selected >= this.maxValue && !checkbox.checked
+    })
+  }
+}