alchemy_cms 5.3.8 → 6.0.0.b1

data/app/models/concerns/alchemy/picture_thumbnails.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # Picture thumbnails and cropping concerns
+  module PictureThumbnails
+    extend ActiveSupport::Concern
+
+    included do
+      before_save :fix_crop_values
+
+      delegate :image_file_width, :image_file_height, :image_file, to: :picture, allow_nil: true
+    end
+
+    # The url to show the picture.
+    #
+    # Takes all values like +name+ and crop sizes (+crop_from+, +crop_size+ from the build in graphical image cropper)
+    # and also adds the security token.
+    #
+    # You typically want to set the size the picture should be resized to.
+    #
+    # === Example:
+    #
+    #   essence_picture.picture_url(size: '200x300', crop: true, format: 'gif')
+    #   # '/pictures/1/show/200x300/crop/cats.gif?sh=765rfghj'
+    #
+    # @option options size [String]
+    #   The size the picture should be resized to.
+    #
+    # @option options format [String]
+    #   The format the picture should be rendered in.
+    #   Defaults to the +image_output_format+ from the +Alchemy::Config+.
+    #
+    # @option options crop [Boolean]
+    #   If set to true the picture will be cropped to fit the size value.
+    #
+    # @return [String]
+    def picture_url(options = {})
+      return if picture.nil?
+
+      picture.url(picture_url_options.merge(options)) || "missing-image.png"
+    end
+
+    # Picture rendering options
+    #
+    # Returns the +default_render_format+ of the associated +Alchemy::Picture+
+    # together with the +crop_from+ and +crop_size+ values
+    #
+    # @return [HashWithIndifferentAccess]
+    def picture_url_options
+      return {} if picture.nil?
+
+      crop = !!settings[:crop]
+
+      {
+        format: picture.default_render_format,
+        crop: crop,
+        crop_from: crop && crop_from.presence || nil,
+        crop_size: crop && crop_size.presence || nil,
+        size: settings[:size],
+      }.with_indifferent_access
+    end
+
+    # Returns an url for the thumbnail representation of the assigned picture
+    #
+    # It takes cropping values into account, so it always represents the current
+    # image displayed in the frontend.
+    #
+    # @return [String]
+    def thumbnail_url
+      return if picture.nil?
+
+      picture.url(thumbnail_url_options) || "alchemy/missing-image.svg"
+    end
+
+    # Thumbnail rendering options
+    #
+    # @return [HashWithIndifferentAccess]
+    def thumbnail_url_options
+      crop = !!settings[:crop]
+
+      {
+        size: "160x120",
+        crop: crop,
+        crop_from: crop && crop_from.presence || default_crop_from&.join("x"),
+        crop_size: crop && crop_size.presence || default_crop_size&.join("x"),
+        flatten: true,
+        format: picture&.image_file_format || "jpg",
+      }
+    end
+
+    # Settings for the graphical JS image cropper
+    def image_cropper_settings
+      Alchemy::ImageCropperSettings.new(
+        render_size: dimensions_from_string(render_size.presence || settings[:size]),
+        default_crop_from: default_crop_from,
+        default_crop_size: default_crop_size,
+        fixed_ratio: settings[:fixed_ratio],
+        image_width: picture&.image_file_width,
+        image_height: picture&.image_file_height,
+      ).to_h
+    end
+
+    # Show image cropping link for content
+    def allow_image_cropping?
+      settings[:crop] && picture &&
+        picture.can_be_cropped_to?(
+          settings[:size],
+          settings[:upsample],
+        ) && !!picture.image_file
+    end
+
+    private
+
+    def default_crop_size
+      return nil unless settings[:crop] && settings[:size]
+
+      mask = inferred_dimensions_from_string(settings[:size])
+      zoom = thumbnail_zoom_factor(mask)
+      return nil if zoom.zero?
+
+      [(mask[0] / zoom), (mask[1] / zoom)].map(&:round)
+    end
+
+    def thumbnail_zoom_factor(mask)
+      [
+        mask[0].to_f / (image_file_width || 1),
+        mask[1].to_f / (image_file_height || 1),
+      ].max
+    end
+
+    def default_crop_from
+      return nil unless settings[:crop]
+      return nil if default_crop_size.nil?
+
+      [
+        ((image_file_width || 0) - default_crop_size[0]) / 2,
+        ((image_file_height || 0) - default_crop_size[1]) / 2,
+      ].map(&:round)
+    end
+
+    def dimensions_from_string(string)
+      return if string.nil?
+
+      string.split("x", 2).map(&:to_i)
+    end
+
+    def inferred_dimensions_from_string(string)
+      return if string.nil?
+
+      width, height = dimensions_from_string(string)
+      ratio = image_file_width.to_f / image_file_height.to_i
+
+      if width.zero? && ratio.is_a?(Float)
+        width = height * ratio
+      end
+
+      if height.zero? && ratio.is_a?(Float)
+        height = width / ratio
+      end
+
+      [width.to_i, height.to_i]
+    end
+
+    def fix_crop_values
+      %i[crop_from crop_size].each do |crop_value|
+        if public_send(crop_value).is_a?(String)
+          public_send("#{crop_value}=", normalize_crop_value(crop_value))
+        end
+      end
+    end
+
+    def normalize_crop_value(crop_value)
+      public_send(crop_value).split("x").map { |n| normalize_number(n) }.join("x")
+    end
+
+    def normalize_number(number)
+      number = number.to_f.round
+      number.negative? ? 0 : number
+    end
+  end
+end

data/app/models/concerns/alchemy/touch_elements.rb

@@ -10,7 +10,7 @@ module Alchemy
   #
   module TouchElements
     def self.included(base)
-      base.after_save(:touch_elements)
+      base.after_update(:touch_elements)
     end
 
     private
@@ -18,7 +18,7 @@ module Alchemy
     def touch_elements
       return unless respond_to?(:elements)
 
-      elements.map(&:touch)
+      elements.touch_all
     end
   end
 end

data/app/presenters/alchemy/picture_view.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # Renders a picture ingredient view
+  class PictureView
+    include ActionView::Helpers::AssetTagHelper
+    include ActionView::Helpers::UrlHelper
+    include Rails.application.routes.url_helpers
+
+    attr_reader :ingredient, :html_options, :options, :picture
+
+    DEFAULT_OPTIONS = {
+      show_caption: true,
+      disable_link: false,
+      srcset: [],
+      sizes: [],
+    }.with_indifferent_access
+
+    def initialize(ingredient, options = {}, html_options = {})
+      @ingredient = ingredient
+      @options = DEFAULT_OPTIONS.merge(ingredient.settings).merge(options || {})
+      @html_options = html_options || {}
+      @picture = ingredient.picture
+    end
+
+    def render
+      return if picture.blank?
+
+      output = caption ? img_tag + caption : img_tag
+
+      if is_linked?
+        output = link_to(output, url_for(ingredient.link), {
+          title: ingredient.link_title.presence,
+          target: ingredient.link_target == "blank" ? "_blank" : nil,
+          data: { link_target: ingredient.link_target.presence },
+        })
+      end
+
+      if caption
+        content_tag(:figure, output, { class: ingredient.css_class.presence }.merge(html_options))
+      else
+        output
+      end
+    end
+
+    def caption
+      return unless show_caption?
+
+      @_caption ||= content_tag(:figcaption, ingredient.caption)
+    end
+
+    def src
+      ingredient.picture_url(options.except(*DEFAULT_OPTIONS.keys))
+    end
+
+    def img_tag
+      @_img_tag ||= image_tag(
+        src, {
+          alt: alt_text,
+          title: ingredient.title.presence,
+          class: caption ? nil : ingredient.css_class.presence,
+          srcset: srcset.join(", ").presence,
+          sizes: options[:sizes].join(", ").presence,
+        }.merge(caption ? {} : html_options)
+      )
+    end
+
+    def show_caption?
+      options[:show_caption] && ingredient.caption.present?
+    end
+
+    def is_linked?
+      !options[:disable_link] && ingredient.link.present?
+    end
+
+    def srcset
+      options[:srcset].map do |size|
+        url = ingredient.picture_url(size: size)
+        width, height = size.split("x")
+        width.present? ? "#{url} #{width}w" : "#{url} #{height}h"
+      end
+    end
+
+    def alt_text
+      ingredient.alt_tag.presence || html_options.delete(:alt) || ingredient.picture.name&.humanize
+    end
+  end
+end

data/app/serializers/alchemy/element_serializer.rb

@@ -6,6 +6,7 @@ module Alchemy
       :name,
       :position,
       :page_id,
+      :page_version_id,
       :tag_list,
       :created_at,
       :updated_at,
@@ -23,5 +24,9 @@ module Alchemy
     def display_name
       object.display_name_with_preview_text
     end
+
+    def page_id
+      object.page.id
+    end
   end
 end

data/app/serializers/alchemy/page_serializer.rb

@@ -14,14 +14,8 @@ module Alchemy
       :created_at,
       :updated_at,
       :status,
-      :url_path,
-      :parent_id
+      :url_path
 
     has_many :elements
-
-    with_options if: -> { scope.can?(:edit_content, object) } do
-      belongs_to :site
-      belongs_to :language
-    end
   end
 end

data/app/serializers/alchemy/page_tree_serializer.rb

@@ -3,13 +3,13 @@
 module Alchemy
   class PageTreeSerializer < BaseSerializer
     def attributes
-      { "pages" => nil }
+      {"pages" => nil}
     end
 
     def pages
       tree = []
-      path = [{ id: object.parent_id, children: tree }]
-      page_list = object.self_and_descendants.includes(language: :site)
+      path = [{id: object.parent_id, children: tree}]
+      page_list = object.self_and_descendants
       base_level = object.level - 1
       # Load folded pages in advance
       folded_user_pages = FoldedPage.folded_for_user(opts[:user]).pluck(:page_id)
@@ -83,10 +83,11 @@ module Alchemy
     end
 
     def page_elements(page)
+      elements = page.public_version&.elements || Alchemy::Element.none
       if opts[:elements] == "true"
-        page.elements
+        elements
       else
-        page.elements.named(opts[:elements].split(",") || [])
+        elements.named(opts[:elements].split(",") || [])
       end
     end
 

data/app/services/alchemy/delete_elements.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class DeleteElements
+    class WouldLeaveOrphansError < StandardError; end
+    attr_reader :elements
+
+    def initialize(elements)
+      @elements = elements
+    end
+
+    def call
+      if orphanable_records.present?
+        raise WouldLeaveOrphansError
+      end
+
+      contents = Alchemy::Content.where(element_id: elements.map(&:id))
+      contents.group_by(&:essence_type)
+        .transform_values! { |value| value.map(&:essence_id) }
+        .each do |class_name, ids|
+          class_name.constantize.where(id: ids).delete_all
+        end
+      contents.delete_all
+      delete_elements
+    end
+
+    private
+
+    def orphanable_records
+      Alchemy::Element.where(parent_element_id: [elements]).where.not(id: elements)
+    end
+
+    def delete_elements
+      case elements
+      when ActiveRecord::Associations::CollectionProxy
+        elements.delete_all(:delete_all)
+      when ActiveRecord::Relation
+        elements.delete_all
+      else
+        Alchemy::Element.where(id: elements).delete_all
+      end
+    end
+  end
+end

data/app/services/alchemy/duplicate_element.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class DuplicateElement
+    SKIPPED_ATTRIBUTES_ON_COPY = [
+      "cached_tag_list",
+      "created_at",
+      "creator_id",
+      "position",
+      "id",
+      "folded",
+      "updated_at",
+      "updater_id",
+    ].freeze
+
+    attr_reader :source_element, :repository
+
+    def initialize(source_element, repository: source_element.page_version.element_repository)
+      @source_element = source_element
+      @repository = repository
+    end
+
+    def call(differences = {})
+      attributes = source_element.attributes.with_indifferent_access
+        .except(*SKIPPED_ATTRIBUTES_ON_COPY)
+        .merge(differences)
+        .merge(
+          autogenerate_contents: false,
+          autogenerate_ingredients: false,
+          autogenerate_nested_elements: false,
+          tags: source_element.tags,
+        )
+
+      new_element = Element.new(attributes)
+      new_element.ingredients = source_element.ingredients.map(&:dup)
+      new_element.save!
+
+      source_element.contents.map do |content|
+        Content.copy(content, element: new_element)
+      end
+
+      nested_elements = repository.children_of(source_element)
+      Element.acts_as_list_no_update do
+        nested_elements.each.with_index(1) do |nested_element, position|
+          self.class.new(nested_element, repository: repository).call(
+            parent_element: new_element,
+            page_version: new_element.page_version,
+            position: position
+          )
+        end
+      end
+
+      new_element
+    end
+  end
+end

data/app/views/alchemy/admin/attachments/_archive_overlay.html.erb

@@ -6,8 +6,7 @@
       file_attribute: 'file',
       in_dialog: true,
       redirect_url: admin_attachments_path(
-        element_id: @element.try(:id),
-        content_id: @content.try(:id)
+        form_field_id: @form_field_id
       ) %>
   <% end %>
   <%= render 'alchemy/admin/partials/remote_search_form' %>

data/app/views/alchemy/admin/attachments/_file_to_assign.html.erb

@@ -1,7 +1,7 @@
 <li class="assign_file_file <%= cycle('even', 'odd') %>">
-  <%= link_to alchemy.assign_admin_essence_files_path(
-      attachment_id: file_to_assign.id,
-      content_id: @content.id
+  <%= link_to alchemy.assign_admin_attachment_path(
+      id: file_to_assign.id,
+      form_field_id: @form_field_id
     ),
     remote: true,
     method: 'put' do %>

data/app/views/alchemy/admin/attachments/assign.js.erb

@@ -0,0 +1,11 @@
+(function () {
+  var $form_field = $("#<%= @form_field_id -%>")
+  $("#assignable_<%= @assignable_id %> a").attr("href", "#").off("click")
+  $form_field.val("<%= @assignable_id %>")
+  $form_field.parent().find("> .file_name").text("<%= @attachment.name %>")
+  $form_field.parent().find("> .file_icon").html("<%= j render_icon(@attachment.icon_css_class) %>")
+  $form_field.parent().find("> .remove_file_link").removeClass("hidden")
+  Alchemy.closeCurrentDialog(function() {
+    Alchemy.setElementDirty($form_field.closest(".element-editor"))
+  })
+})()

data/app/views/alchemy/admin/crop.html.erb

@@ -0,0 +1,36 @@
+<div id="jscropper">
+<% if @no_image_notice %>
+  <%= render_message :warn do %>
+    <%= @no_image_notice %>
+  <% end %>
+<% else %>
+  <%= render_message do %>
+    <%= simple_format Alchemy.t(:explain_cropping) %>
+  <% end %>
+  <div class="thumbnail_background">
+    <%= image_tag @picture.url(size: '800x600', flatten: true), id: 'imageToCrop' %>
+  </div>
+  <form>
+    <%= button_tag Alchemy.t(:apply), type: 'submit' %>
+    <%= button_tag Alchemy.t('Reset Imagemask'), class: 'reset_mask', type: 'reset' %>
+  </form>
+</div>
+<% end %>
+<% if @settings %>
+<script type="text/javascript">
+  Alchemy.ImageLoader('#jscropper .thumbnail_background');
+  $('#imageToCrop').load(function() {
+    new Alchemy.ImageCropper(
+      <%= @settings[:min_size].to_json %>,
+      <%= @settings[:default_box].to_json %>,
+      <%= @settings[:ratio] %>,
+      <%= @settings[:image_size].to_json %>,
+      [
+        "<%= params[:crop_from_form_field_id] %>",
+        "<%= params[:crop_size_form_field_id] %>",
+      ],
+      <%= @element.id %>
+    );
+  });
+</script>
+<% end %>

data/app/views/alchemy/admin/elements/_element.html.erb

@@ -4,11 +4,11 @@
   class: element.css_classes do %>
 
   <% unless element.fixed? %>
-    <%= render 'alchemy/admin/elements/element_header', element: element %>
+    <%= render 'alchemy/admin/elements/header', element: element %>
   <% end %>
 
   <% if element.expanded? || element.fixed? %>
-    <%= render 'alchemy/admin/elements/element_toolbar', element: element %>
+    <%= render 'alchemy/admin/elements/toolbar', element: element %>
 
     <% element.definition[:message].tap do |message| %>
       <%= render_message(:info, sanitize(message)) if message %>
@@ -23,11 +23,15 @@
         html: {id: "element_#{element.id}_form".html_safe, class: 'element-content'} do |f| %>
 
         <div id="element_<%= element.id %>_errors" class="element_errors"></div>
-
-        <div id="element_<%= element.id %>_content" class="element-content-editors">
-          <%= render element.contents %>
-        </div>
-
+        <% if element.has_ingredients_defined? %>
+          <div class="element-ingredient-editors">
+            <%= render element.ingredients, element_form: f %>
+          </div>
+        <% else %>
+          <div id="element_<%= element.id %>_content" class="element-content-editors">
+            <%= render element.contents %>
+          </div>
+        <% end %>
         <% if element.taggable? %>
           <div class="autocomplete_tag_list">
             <%= f.label :tag_list %>
@@ -36,7 +40,7 @@
         <% end %>
       <% end %>
 
-      <%= render 'alchemy/admin/elements/element_footer', element: element %>
+      <%= render 'alchemy/admin/elements/footer', element: element %>
     <% end %>
   <% end %>
 
@@ -57,7 +61,7 @@
           <%= form_for [:admin, Alchemy::Element.new(name: nestable_element)],
             remote: true, html: { class: 'add-nested-element-form', id: nil } do |f| %>
             <%= f.hidden_field :name %>
-            <%= f.hidden_field :page_id, value: element.page_id %>
+            <%= f.hidden_field :page_version_id, value: element.page_version_id %>
             <%= f.hidden_field :parent_element_id, value: element.id %>
             <button class="button add-nestable-element-button" data-alchemy-button>
               <%= Alchemy.t(:add_nested_element) % { name: Alchemy.t(nestable_element, scope: 'element_names') } %>
@@ -67,7 +71,7 @@
           <%= link_to_dialog Alchemy.t("New Element"),
             alchemy.new_admin_element_path(
               parent_element_id: element.id,
-              page_id: element.page.id
+              page_version_id: element.page_version_id
             ), {
               size: "320x125",
               title: Alchemy.t("New Element")

data/app/views/alchemy/admin/elements/{_new_element_form.html.erb → _form.html.erb}

@@ -4,7 +4,7 @@
   <% end %>
 <%- else -%>
   <%= alchemy_form_for [:admin, @element] do |form| %>
-    <%= form.hidden_field :page_id %>
+    <%= form.hidden_field :page_version_id %>
     <%= form.input :name,
       label: Alchemy.t(:element_of_type),
       collection: elements_for_select(@elements),

data/app/views/alchemy/admin/elements/{_element_header.html.erb → _header.html.erb}

@@ -18,7 +18,7 @@
       <%= sanitize(element.preview_text.presence || '&nbsp;') %>
     </span>
   </span>
-  <%= render_hint_for(element) unless element.trashed? %>
+  <%= render_hint_for(element) %>
   <%= link_to '#', {
     'data-element-toggle' => element.id,
     title: Alchemy.t(element.folded? ? :show_element_content : :hide_element_content),

data/app/views/alchemy/admin/elements/{_element_toolbar.html.erb → _toolbar.html.erb}

@@ -22,14 +22,13 @@
       <label><%= Alchemy.t(:cut_element) %></label>
     </div>
     <div class="button_with_label">
-      <%= link_to(
+      <%= link_to_confirm_dialog(
         render_icon('trash-alt'),
-        alchemy.trash_admin_element_path(element),
-        method: :delete,
-        class: "icon_button",
-        remote: true
+        Alchemy.t(:confirm_to_delete_element),
+        alchemy.admin_element_path(element),
+        class: "icon_button"
       ) -%>
-      <label><%= Alchemy.t("trash element") %></label>
+      <label><%= Alchemy.t("Delete element") %></label>
     </div>
     <div class="button_with_label publish-element-button">
       <%= link_to(

data/app/views/alchemy/admin/elements/{trash.js.erb → destroy.js.erb}

@@ -1,9 +1,7 @@
 $('#element_<%= @element.id %>').hide(200, function() {
   $(this).remove();
-  Alchemy.growl('<%= j Alchemy.t("Element trashed") %>');
+  Alchemy.growl('<%= j @notice %>');
   $('#element_area .sortable-elements').sortable('refresh');
-  Alchemy.TrashWindow.refresh();
-  $('#element_trash_button .icon').addClass('full');
   Alchemy.PreviewWindow.refresh();
   <% @element.richtext_contents_ids.each do |id| %>
   tinymce.get('tinymce_<%= id %>').remove();

data/app/views/alchemy/admin/elements/new.html.erb

@@ -1,5 +1,5 @@
 <%- if @clipboard_items.blank? -%>
-  <%= render 'new_element_form' %>
+  <%= render 'form' %>
 <%- else -%>
 <div id="overlay_tabs">
   <ul>
@@ -7,11 +7,11 @@
     <li><a href="#paste_element_tab"><%= Alchemy.t('Paste from clipboard') %></a></li>
   </ul>
   <div id="create_element_tab">
-    <%= render 'new_element_form' %>
+    <%= render 'form' %>
   </div>
   <div id="paste_element_tab">
     <%= alchemy_form_for([:admin, @element]) do |f| %>
-      <%= f.hidden_field :page_id %>
+      <%= f.hidden_field :page_version_id %>
       <%= f.hidden_field :parent_element_id, value: @parent_element.try(:id) %>
       <div class="input select">
         <label for="paste_from_clipboard" class="control-label"><%= Alchemy.t("Element") %></label>