alchemy_cms 5.3.4 → 6.0.0.b1

data/app/controllers/alchemy/api/pages_controller.rb

@@ -2,19 +2,15 @@
 
 module Alchemy
   class Api::PagesController < Api::BaseController
-    serialization_scope :current_ability
     before_action :load_page, only: [:show]
 
     # Returns all pages as json object
     #
     def index
+      @pages = Language.current&.pages.presence || Alchemy::Page.none
       # Fix for cancancan not able to merge multiple AR scopes for logged in users
-      if can? :edit_content, Alchemy::Page
-        @pages = Alchemy::Page.all
-      else
-        language = Alchemy::Language.find_by(id: params[:language_id]) || Alchemy::Language.current
-        @pages = Alchemy::Page.accessible_by(current_ability, :index)
-        @pages = @pages.where(language: language)
+      if cannot? :edit_content, Alchemy::Page
+        @pages = @pages.accessible_by(current_ability, :index)
       end
       @pages = @pages.includes(*page_includes)
       @pages = @pages.ransack(params[:q]).result
@@ -51,14 +47,6 @@ module Alchemy
       respond_with @page
     end
 
-    def move
-      @page = Page.find(params[:id])
-      authorize! :update, @page
-      target_parent_page = Page.find(params[:target_parent_id])
-      @page.move_to_child_with_index(target_parent_page, params[:new_position])
-      render json: @page, serializer: PageSerializer
-    end
-
     private
 
     def load_page

data/app/controllers/concerns/alchemy/admin/archive_overlay.rb

@@ -2,18 +2,28 @@
 module Alchemy
   module Admin
     module ArchiveOverlay
+      # Sets assignable id on given form field via JS.
+      #
+      # When the user saves the model the assignable
+      # gets persisted with the model as well.
+      #
+      def assign
+        @assignable_id = params[:id]
+        @form_field_id = params[:form_field_id]
+      end
+
       private
 
       def in_overlay?
-        params[:content_id].present?
+        params[:form_field_id].present?
       end
 
       def archive_overlay
-        @content = Content.find_by(id: params[:content_id])
+        @form_field_id = params[:form_field_id]
 
         respond_to do |format|
           format.html { render partial: "archive_overlay" }
-          format.js   { render action:  "archive_overlay" }
+          format.js { render action: "archive_overlay" }
         end
       end
     end

data/app/controllers/concerns/alchemy/admin/crop_action.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module CropAction
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :load_croppable_resource, only: [:crop]
+      end
+
+      def crop
+        @picture = Alchemy::Picture.find_by(id: params[:picture_id])
+        if @picture
+          @croppable_resource.picture = @picture
+          @settings = @croppable_resource.image_cropper_settings
+          @element = @croppable_resource.element
+        else
+          @no_image_notice = Alchemy.t(:no_image_for_cropper_found)
+        end
+
+        render template: "alchemy/admin/crop"
+      end
+    end
+  end
+end

data/app/decorators/alchemy/element_editor.rb

@@ -19,6 +19,23 @@ module Alchemy
       end
     end
 
+    # Returns ingredient editor instances for defined ingredients
+    #
+    # Creates ingredient on demand if the ingredient is not yet present on the element
+    #
+    # @return Array<Alchemy::IngredientEditor>
+    def ingredients
+      element.definition.fetch(:ingredients, []).map do |ingredient|
+        Alchemy::IngredientEditor.new(find_or_create_ingredient(ingredient[:role]))
+      end
+    end
+
+    # Are any ingredients defined?
+    # @return [Boolean]
+    def has_ingredients_defined?
+      element.definition.fetch(:ingredients, []).any?
+    end
+
     # CSS classes for the element editor partial.
     def css_classes
       [
@@ -38,7 +55,7 @@ module Alchemy
     def editable?
       return false if folded?
 
-      content_definitions.present? || taggable?
+      content_definitions.present? || ingredient_definitions.any? || taggable?
     end
 
     # Fixes Rails partial renderer calling to_model on the object
@@ -103,5 +120,10 @@ module Alchemy
     def create_content(name)
       Alchemy::Content.create(element: element, name: name)
     end
+
+    def find_or_create_ingredient(role)
+      element.ingredients.find { |i| i.role == role } ||
+        Ingredient.create(element: element, role: role)
+    end
   end
 end

data/app/decorators/alchemy/ingredient_editor.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class IngredientEditor < SimpleDelegator
+    alias_method :ingredient, :__getobj__
+
+    def to_partial_path
+      "alchemy/ingredients/#{partial_name}_editor"
+    end
+
+    # Returns the translated role for displaying in labels
+    #
+    # Translate it in your locale yml file:
+    #
+    #   alchemy:
+    #     ingredient_roles:
+    #       foo: Bar
+    #
+    # Optionally you can scope your ingredient role to an element:
+    #
+    #   alchemy:
+    #     ingredient_roles:
+    #       article:
+    #         foo: Baz
+    #
+    def translated_role
+      Alchemy.t(
+        role,
+        scope: "ingredient_roles.#{element.name}",
+        default: Alchemy.t("ingredient_roles.#{role}", default: role.humanize),
+      )
+    end
+
+    def css_classes
+      [
+        "ingredient-editor",
+        partial_name,
+        deprecated? ? "deprecated" : nil,
+      ].compact
+    end
+
+    def data_attributes
+      {
+        ingredient_id: id,
+        ingredient_role: role,
+      }
+    end
+
+    # Returns a string to be passed to Rails form field tags to ensure it can be used with Rails' nested attributes.
+    #
+    # === Example:
+    #
+    #   <%= text_field_tag text_editor.form_field_name, text_editor.value %>
+    #
+    # === Options:
+    #
+    # You can pass an Ingredient column_name. Default is 'value'
+    #
+    # ==== Example:
+    #
+    #   <%= text_field_tag text_editor.form_field_name(:link), text_editor.value %>
+    #
+    def form_field_name(column = "value")
+      "element[ingredients_attributes][#{form_field_counter}][#{column}]"
+    end
+
+    def form_field_id(column = "value")
+      "element_ingredients_attributes_#{form_field_counter}_#{column}"
+    end
+
+    # Fixes Rails partial renderer calling to_model on the object
+    # which reveals the delegated ingredient instead of this decorator.
+    def respond_to?(method_name)
+      return false if method_name == :to_model
+
+      super
+    end
+
+    def has_warnings?
+      definition.blank? || deprecated?
+    end
+
+    def linked?
+      link.try(:present?)
+    end
+
+    def warnings
+      return unless has_warnings?
+
+      if definition.blank?
+        Logger.warn("ingredient #{role} is missing its definition", caller(1..1))
+        Alchemy.t(:ingredient_definition_missing)
+      else
+        deprecation_notice
+      end
+    end
+
+    # Returns a deprecation notice for ingredients marked deprecated
+    #
+    # You can either use localizations or pass a String as notice
+    # in the ingredient definition.
+    #
+    # == Custom deprecation notices
+    #
+    # Use general ingredient deprecation notice
+    #
+    #     - name: element_name
+    #       ingredients:
+    #         - role: old_ingredient
+    #           type: Text
+    #           deprecated: true
+    #
+    # Add a translation to your locale file for a per ingredient notice.
+    #
+    #     en:
+    #       alchemy:
+    #         ingredient_deprecation_notices:
+    #           element_name:
+    #             old_ingredient: Foo baz widget is deprecated
+    #
+    # or use the global translation that apply to all deprecated ingredients.
+    #
+    #     en:
+    #       alchemy:
+    #         ingredient_deprecation_notice: Foo baz widget is deprecated
+    #
+    # or pass string as deprecation notice.
+    #
+    #     - name: element_name
+    #       ingredients:
+    #         - role: old_ingredient
+    #           type: Text
+    #           deprecated: This ingredient will be removed soon.
+    #
+    def deprecation_notice
+      case definition[:deprecated]
+      when String
+        definition[:deprecated]
+      when TrueClass
+        Alchemy.t(
+          role,
+          scope: [:ingredient_deprecation_notices, element.name],
+          default: Alchemy.t(:ingredient_deprecated),
+        )
+      end
+    end
+
+    private
+
+    def form_field_counter
+      element.definition.fetch(:ingredients, []).index { |i| i[:role] == role }
+    end
+  end
+end

data/app/helpers/alchemy/admin/elements_helper.rb

@@ -3,6 +3,7 @@
 module Alchemy
   module Admin
     module ElementsHelper
+      include Alchemy::Admin::IngredientsHelper
       include Alchemy::Admin::ContentsHelper
       include Alchemy::Admin::EssencesHelper
 

data/app/helpers/alchemy/admin/essences_helper.rb

@@ -14,7 +14,7 @@ module Alchemy
           essence.thumbnail_url,
           alt: picture.name,
           class: "img_paddingtop",
-          title: Alchemy.t(:image_name) + ": #{picture.name}",
+          title: Alchemy.t(:image_name, name: picture.name),
         )
       end
 

data/app/helpers/alchemy/admin/ingredients_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Admin
+    module IngredientsHelper
+      include Alchemy::Admin::BaseHelper
+
+      # Renders the translated role of ingredient.
+      #
+      # Displays a warning icon if ingredient is missing its definition.
+      #
+      # Displays a mandatory field indicator, if the ingredient has validations.
+      #
+      def render_ingredient_role(ingredient)
+        if ingredient.blank?
+          warning("Ingredient is nil")
+          return
+        end
+
+        content = ingredient.translated_role
+
+        if ingredient.has_warnings?
+          icon = hint_with_tooltip(ingredient.warnings)
+          content = "#{icon} #{content}".html_safe
+        end
+
+        if ingredient.has_validations?
+          "#{content}<span class='validation_indicator'>*</span>".html_safe
+        else
+          content
+        end
+      end
+
+      # Renders the label and hint for a ingredient.
+      def ingredient_label(ingredient, column = :value)
+        label_tag ingredient.form_field_id(column) do
+          [render_ingredient_role(ingredient), render_hint_for(ingredient)].compact.join("&nbsp;").html_safe
+        end
+      end
+    end
+  end
+end

data/app/helpers/alchemy/elements_block_helper.rb

@@ -26,12 +26,13 @@ module Alchemy
     class ElementViewHelper < BlockHelper
       # Renders one of the element's contents.
       #
+      # If the element uses +ingredients+ it renders the ingredient record.
+      #
       def render(name, options = {}, html_options = {})
-        content = element.content_by_name(name)
-        return if content.nil?
+        renderable = element.ingredient_by_role(name) || content(name)
+        return if renderable.nil?
 
-        helpers.render(content, {
-          content: content,
+        helpers.render(renderable, {
           options: options,
           html_options: html_options,
         })
@@ -43,16 +44,28 @@ module Alchemy
         element.content_by_name(name)
       end
 
+      deprecate content: "Use `ingredient_by_role` instead", deprecator: Alchemy::Deprecation
+
       # Returns the ingredient of one of the element's contents.
       #
+      # If the element uses +ingredients+ it returns the +value+ of the ingredient record.
+      #
       def ingredient(name)
-        element.ingredient(name)
+        element.ingredient(name).presence || element.ingredient_by_role(name)&.value
+      end
+
+      deprecate ingredient: :value, deprecator: Alchemy::Deprecation
+
+      # Returns the value of one of the element's ingredients.
+      #
+      def value(name)
+        element.ingredient_by_role(name)&.value
       end
 
-      # Returns true if the given content has been filled by the user.
+      # Returns true if the given content or ingredient has been filled by the user.
       #
       def has?(name)
-        element.has_ingredient?(name)
+        element.has_ingredient?(name) || element.has_value_for?(name)
       end
 
       # Return's the given content's essence.
@@ -60,6 +73,8 @@ module Alchemy
       def essence(name)
         content(name).try(:essence)
       end
+
+      deprecate essence: "Use `ingredient_by_role` instead", deprecator: Alchemy::Deprecation
     end
 
     # Block-level helper for element views. Constructs a DOM element wrapping

data/app/helpers/alchemy/elements_helper.rb

@@ -25,7 +25,7 @@ module Alchemy
     # === Render elements from global page:
     #
     #   <footer>
-    #     <%= render_elements from_page: 'footer' %>
+    #     <%= render_elements from_page: Alchemy::Page.find_by(page_layout: 'footer') %>
     #   </footer>
     #
     # === Custom elements finder:
@@ -50,8 +50,8 @@ module Alchemy
     #     <%= render_elements finder: MyCustomNewsArchive.new %>
     #   </div>
     #
-    # @option options [Alchemy::Page|String] :from_page (@page)
-    #   The page the elements are rendered from. You can pass a page_layout String or a {Alchemy::Page} object.
+    # @option options [Alchemy::Page] :from_page (@page)
+    #   The page the elements are rendered from.
     # @option options [Array<String>|String] :only
     #   A list of element names only to be rendered.
     # @option options [Array<String>|String] :except
@@ -77,7 +77,14 @@ module Alchemy
       }.update(options)
 
       finder = options[:finder] || Alchemy::ElementsFinder.new(options)
-      elements = finder.elements(page: options[:from_page])
+
+      page_version = if @preview_mode
+          options[:from_page]&.draft_version
+        else
+          options[:from_page]&.public_version
+        end
+
+      elements = finder.elements(page_version: page_version)
 
       buff = []
       elements.each_with_index do |element, i|
@@ -133,7 +140,7 @@ module Alchemy
     def render_element(element, options = {}, counter = 1)
       if element.nil?
         warning("Element is nil")
-        render "alchemy/elements/view_not_found", {name: "nil"}
+        render "alchemy/elements/view_not_found", { name: "nil" }
         return
       end
 
@@ -142,8 +149,8 @@ module Alchemy
       render element, {
         element: element,
         counter: counter,
-        options: options.except(:locals),
-      }.merge(options[:locals] || {})
+        options: options,
+      }.merge(options.delete(:locals) || {})
     rescue ActionView::MissingTemplate => e
       warning(%(
         Element view partial not found for #{element.name}.\n

data/app/helpers/alchemy/pages_helper.rb

@@ -66,8 +66,8 @@ module Alchemy
     #
     # renders +app/views/alchemy/site_layouts/_default_site.html.erb+ for the site named "Default Site".
     #
-    def render_site_layout
-      render current_alchemy_site
+    def render_site_layout(&block)
+      render current_alchemy_site, &block
     rescue ActionView::MissingTemplate
       warning("Site layout for #{current_alchemy_site.try(:name)} not found. Please run `rails g alchemy:site_layouts`")
       ""
@@ -98,14 +98,6 @@ module Alchemy
       WARN
     end
 
-    # Returns true if page is in the active branch
-    def page_active?(page)
-      Alchemy::Deprecation.warn("page_active? helper is deprecated and will be removed from Alchemy 6.0")
-
-      @_page_ancestors ||= @page.self_and_ancestors.contentpages
-      @_page_ancestors.include?(page)
-    end
-
     # Returns page links in a breadcrumb beginning from root to current page.
     #
     # === Options:
@@ -127,7 +119,7 @@ module Alchemy
 
       pages = options[:page].
         self_and_ancestors.contentpages.
-        accessible_by(current_ability, :see)
+        published
 
       if options.delete(:restricted_only)
         pages = pages.restricted

data/app/jobs/alchemy/base_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class BaseJob < ActiveJob::Base
+    # Automatically retry jobs that encountered a deadlock
+    # retry_on ActiveRecord::Deadlocked
+
+    # Most jobs are safe to ignore if the underlying records are no longer available
+    # discard_on ActiveJob::DeserializationError
+  end
+end

data/app/jobs/alchemy/publish_page_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PublishPageJob < BaseJob
+    queue_as :default
+
+    def perform(page, public_on:)
+      Alchemy::Page::Publisher.new(page).publish!(public_on: public_on)
+    end
+  end
+end

data/app/models/alchemy/attachment.rb

@@ -28,7 +28,7 @@ module Alchemy
       after_assign { |f| write_attribute(:file_mime_type, f.mime_type) }
     end
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     has_many :essence_files, class_name: "Alchemy::EssenceFile", foreign_key: "attachment_id"
     has_many :contents, through: :essence_files

data/app/models/alchemy/content/factory.rb

@@ -7,7 +7,7 @@ module Alchemy
     extend ActiveSupport::Concern
 
     module ClassMethods
-      SKIPPED_ATTRIBUTES_ON_COPY = %w(position created_at updated_at creator_id updater_id id)
+      SKIPPED_ATTRIBUTES_ON_COPY = %w(position created_at updated_at creator_id updater_id element_id id)
 
       # Builds a new content as descriped in the elements.yml file.
       #
@@ -19,14 +19,14 @@ module Alchemy
         return super if attributes.empty? || element.nil?
 
         definition = element.content_definition_for(attributes[:name])
-        if definition.blank?
+        if definition.blank? && attributes[:essence_type].nil?
           raise ContentDefinitionError, "No definition found in elements.yml for #{attributes.inspect} and #{element.inspect}"
         end
 
         super(
-          name: definition[:name],
-          essence_type: normalize_essence_type(definition[:type]),
-          element_id: element.id
+          name: attributes[:name],
+          essence_type: attributes[:essence_type] || normalize_essence_type(definition[:type]),
+          element: element
         ).tap(&:build_essence)
       end
 
@@ -53,18 +53,16 @@ module Alchemy
       #   @copy.element_id # => 3
       #
       def copy(source, differences = {})
-        new_content = Content.new(
-          source.attributes.
+        Content.new(
+          source.attributes.with_indifferent_access.
             except(*SKIPPED_ATTRIBUTES_ON_COPY).
-            merge(differences.with_indifferent_access),
-        )
-        new_essence = source.essence.class.create!(
-          source.essence.attributes.
-            except(*SKIPPED_ATTRIBUTES_ON_COPY),
-        )
-        new_content.tap do |content|
-          content.essence = new_essence
-          content.save
+            merge(differences.with_indifferent_access)
+        ).tap do |new_content|
+          new_content.build_essence(
+            source.essence.attributes.
+              except(*SKIPPED_ATTRIBUTES_ON_COPY)
+          )
+          new_content.save
         end
       end
 
@@ -117,29 +115,27 @@ module Alchemy
     #
     # If an optional type is passed, this type of essence gets created.
     #
-    def build_essence(type = essence_type)
-      self.essence = essence_class(type).new({
-        ingredient: default_value,
-      })
+    def build_essence(attributes = {})
+      self.essence = essence_class.new(
+        { content: self, ingredient: default_value }.merge(attributes)
+      )
     end
 
     # Creates essence from definition.
     #
     # If an optional type is passed, this type of essence gets created.
     #
-    def create_essence!(type = nil)
-      build_essence(type).save!
+    def create_essence!(attrs = {})
+      build_essence(attrs).save!
       save!
     end
 
     private
 
-    # Returns a class constant from definition's type field.
+    # Returns a class constant from definition's type field or the essence_type column
     #
-    # If an optional type is passed, this type of essence gets constantized.
-    #
-    def essence_class(type = nil)
-      Content.normalize_essence_type(type || definition["type"]).constantize
+    def essence_class
+      (essence_type || Content.normalize_essence_type(definition["type"])).constantize
     end
   end
 end

data/app/models/alchemy/content.rb

@@ -39,19 +39,14 @@ module Alchemy
     scope :essence_selects, -> { where(essence_type: "Alchemy::EssenceSelect") }
     scope :essence_texts, -> { where(essence_type: "Alchemy::EssenceText") }
     scope :named, ->(name) { where(name: name) }
-    scope :available, -> { published.not_trashed }
+    scope :available, -> { published }
     scope :published, -> { joins(:element).merge(Element.published) }
-    scope :not_trashed, -> { joins(:element).merge(Element.not_trashed) }
     scope :not_restricted, -> { joins(:element).merge(Element.not_restricted) }
 
     delegate :restricted?, to: :page, allow_nil: true
-    delegate :trashed?, to: :element, allow_nil: true
-    deprecate :trashed?, deprecator: Alchemy::Deprecation
     delegate :public?, to: :element, allow_nil: true
 
     class << self
-      deprecate :not_trashed, deprecator: Alchemy::Deprecation
-
       # Returns the translated label for a content name.
       #
       # Translate it in your locale yml file: