alchemy_cms 6.0.0.pre.rc5 → 6.0.0

data/app/views/alchemy/admin/partials/_routes.html.erb

@@ -5,6 +5,10 @@
       return '<%= alchemy.admin_picture_path(id: 1) %>'.replace(/1/, id);
     },
 
+    url_admin_picture_path: function(id) {
+      return '<%= alchemy.url_admin_picture_path(id: 1) %>'.replace(/1/, id);
+    },
+
     fold_admin_element_path: function(id) {
       return '<%= alchemy.fold_admin_element_path(id: 1) %>'.replace(/1/, id);
     },
@@ -19,8 +23,15 @@
       },
     },
 
+    move_admin_page_path: function(id) {
+      return '<%= alchemy.move_api_page_path(id: 1) %>'.replace(/1/, id);
+    },
+
+    fold_admin_page_path: function(id) {
+      return '<%= alchemy.fold_admin_page_path(id: 1) %>'.replace(/1/, id);
+    },
+
     order_admin_elements_path: '<%= alchemy.order_admin_elements_path %>',
-    order_admin_pages_path: '<%= alchemy.order_admin_pages_path %>',
     link_admin_pages_path: '<%= alchemy.link_admin_pages_path %>',
     api_pages_path: '<%= alchemy.api_pages_path %>',
     api_elements_path: '<%= alchemy.api_elements_path %>'

data/app/views/alchemy/admin/resources/_form.html.erb

@@ -8,6 +8,11 @@
         input_html: {class: 'alchemy_selectbox'} %>
     <% elsif attribute[:type].in? %i[date time datetime] %>
       <%= f.datepicker attribute[:name], resource_attribute_field_options(attribute) %>
+    <% elsif attribute[:enum].present? %>
+      <%= f.input attribute[:name],
+        collection: attribute[:enum],
+        include_blank: Alchemy.t(:blank, scope: 'resources.relation_select'),
+        input_html: {class: 'alchemy_selectbox'} %>
     <% else %>
       <%= f.input attribute[:name], resource_attribute_field_options(attribute) %>
     <% end %>

data/app/views/alchemy/essences/_essence_page_editor.html.erb

@@ -14,7 +14,7 @@
 <script>
   $('#<%= essence_page_editor.form_field_id %>').alchemyPageSelect({
     placeholder: "<%= Alchemy.t(:search_page) %>",
-    url: "<%= alchemy.api_pages_path %>",
+    url: "<%= alchemy.api_pages_path language_id: essence_page_editor.page&.language_id %>",
     query_params: <%== essence_page_editor.settings[:query_params].to_json %>,
     <% if essence_page_editor.essence.page %>
     initialSelection: {

data/config/alchemy/config.yml

@@ -173,6 +173,7 @@ uploader:
     - gif
     - png
     - svg
+    - webp
 
 # === Link Target Options
 #

data/config/locales/alchemy.en.yml

@@ -334,7 +334,6 @@ en:
     "Site successfully removed": "Website successfully removed."
     "Site successfully updated": "Website successfully updated."
     "Size": "Size"
-    "Sort pages": "Reorder pages"
     "Successfully added content": "Successfully added %{content}"
     "Successfully deleted content": "Successfully deleted %{content}"
     "Successfully deleted element": "Successfully deleted %{element}"
@@ -437,7 +436,6 @@ en:
     enter_external_link: "Please enter the URL you want to link with"
     explain_cropping: "<p>Move the frame and change its size with the mouse or arrow keys to adjust the image mask. Click on \"apply\" when you are satisfied with your selection.</p><p>If you want to return to the original centered image mask like it was defined in the layout, click \"reset\" and \"apply\" afterwards.</p>"
     explain_publishing: "Publish current page content"
-    explain_sitemap_dragndrop_sorting: "Tip: Drag the pages at the icon in order to sort them."
     explain_unlocking: "Leave page and unlock it for other users."
     external_link_notice_1: "Please enter the complete url with http:// or a similar protocol."
     external_link_notice_2: "To refer a path from your website url, start with a /."
@@ -534,7 +532,6 @@ en:
     or_replace_it_with_an_existing_tag: 'Or replace it with an existing tag'
     "Page created": "Page: '%{name}' created."
     page_infos: 'Page info'
-    page_layout_changed_notice: "Page type was changed. Elements not usable anymore have been hided."
     page_properties: "Page properties"
     page_public: "published"
     page_published: "Published page"
@@ -593,7 +590,6 @@ en:
     robot_follow: "robot may follow links."
     robot_index: "allow robot to index."
     save: "Save"
-    "save order": "Save order"
     saved_link: "Link saved."
     search: "search"
     search_engines: "Search engines"

data/config/routes.rb

@@ -28,13 +28,12 @@ Alchemy::Engine.routes.draw do
         post :copy_language_tree
         get :create_language
         get :link
-        get :sort
         get :tree
       end
       member do
         post :unlock
         post :publish
-        post :fold
+        patch :fold
         get :configure
         get :preview
         get :info
@@ -139,6 +138,9 @@ Alchemy::Engine.routes.draw do
       collection do
         get :nested
       end
+      member do
+        patch :move
+      end
     end
 
     get "/pages/*urlname(.:format)" => "pages#show", as: "page"

data/lib/alchemy/engine.rb

@@ -37,7 +37,7 @@ module Alchemy
       end
     end
 
-    initializer "alchemy.userstamp" do
+    config.after_initialize do
       if Alchemy.user_class
         ActiveSupport.on_load(:active_record) do
           Alchemy.user_class.model_stamper
@@ -45,5 +45,16 @@ module Alchemy
         end
       end
     end
+
+    initializer "alchemy.webp-mime_type" do
+      # Rails does not know anything about webp even in 2022
+      unless Mime::Type.lookup_by_extension(:webp)
+        Mime::Type.register("image/webp", :webp)
+      end
+      # Dragonfly uses Rack to read the mime type and guess what
+      unless Rack::Mime::MIME_TYPES[".webp"]
+        Rack::Mime::MIME_TYPES[".webp"] = "image/webp"
+      end
+    end
   end
 end

data/lib/alchemy/essence.rb

@@ -3,18 +3,6 @@
 require "active_record"
 
 module Alchemy #:nodoc:
-  # A bogus association that skips eager loading for essences not having an ingredient association
-  class IngredientAssociation < ActiveRecord::Associations::BelongsToAssociation
-    # Skip eager loading if called by Rails' preloader
-    def klass
-      if caller.any? { |line| line =~ /preloader\.rb/ }
-        nil
-      else
-        super
-      end
-    end
-  end
-
   module Essence #:nodoc:
     def self.included(base)
       base.extend(ClassMethods)
@@ -43,8 +31,6 @@ module Alchemy #:nodoc:
           ingredient_column: "body",
         }.update(options)
 
-        @_classes_with_ingredient_association ||= []
-
         class_eval <<-RUBY, __FILE__, __LINE__ + 1
           attr_writer :validation_errors
           include Alchemy::Essence::InstanceMethods
@@ -87,18 +73,6 @@ module Alchemy #:nodoc:
             alias_method :#{configuration[:ingredient_column]}, :ingredient_association
             alias_method :#{configuration[:ingredient_column]}=, :ingredient_association=
           RUBY
-
-          @_classes_with_ingredient_association << self
-        end
-      end
-
-      # Overwrite ActiveRecords method to return a bogus association class that skips eager loading
-      # for essence classes that do not have an ingredient association
-      def _reflect_on_association(name)
-        if name == :ingredient_association && !in?(@_classes_with_ingredient_association)
-          OpenStruct.new(association_class: Alchemy::IngredientAssociation)
-        else
-          super
         end
       end
 

data/lib/alchemy/permissions.rb

@@ -147,7 +147,6 @@ module Alchemy
           :copy_language_tree,
           :flush,
           :order,
-          :sort,
           :switch_language,
         ], Alchemy::Page
 

data/lib/alchemy/resource.rb

@@ -169,10 +169,25 @@ module Alchemy
           name: col.name,
           type: resource_column_type(col),
           relation: resource_relation(col.name),
-        }.delete_if { |_k, v| v.nil? }
+          enum: enum_values_collection_for_select(col.name),
+        }.delete_if { |_k, v| v.blank? }
       end.compact
     end
 
+    def enum_values_collection_for_select(column_name)
+      enum = model.defined_enums[column_name]
+      return if enum.blank?
+
+      enum.keys.map do |key|
+        [
+          ::I18n.t(key, scope: [
+            :activerecord, :attributes, model.model_name.i18n_key, "#{column_name}_values"
+          ], default: key.humanize),
+          key,
+        ]
+      end
+    end
+
     def sorted_attributes
       @_sorted_attributes ||= attributes.
         sort_by  { |attr| attr[:name] == "name" ? 0 : 1 }.

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -7,18 +7,6 @@ RSpec.shared_examples_for "an essence" do
   let(:content) { Alchemy::Content.new(name: "foo") }
   let(:content_definition) { { "name" => "foo" } }
 
-  describe "eager loading" do
-    before do
-      2.times { described_class.create! }
-    end
-
-    it "does not throw error if eager loaded" do
-      expect {
-        described_class.all.includes(:ingredient_association).to_a
-      }.to_not raise_error
-    end
-  end
-
   it "touches the element after save" do
     element = FactoryBot.create(:alchemy_element)
     content = FactoryBot.create(:alchemy_content, element: element, essence: essence, essence_type: essence.class.name)

data/lib/alchemy/test_support/shared_ingredient_examples.rb

@@ -28,7 +28,7 @@ RSpec.shared_examples_for "an alchemy ingredient" do
 
     context "with element" do
       before do
-        expect(element).to receive(:ingredient_definition_for) do
+        expect(element).to receive(:ingredient_definition_for).at_least(:once) do
           {
             settings: {
               linkable: true,
@@ -63,7 +63,9 @@ RSpec.shared_examples_for "an alchemy ingredient" do
       end
 
       before do
-        expect(element).to receive(:ingredient_definition_for) { definition }
+        expect(element).to receive(:ingredient_definition_for).at_least(:once) do
+          definition
+        end
       end
 
       it "returns ingredient definition" do

data/lib/alchemy/upgrader/tasks/ingredients_migrator.rb

@@ -16,7 +16,7 @@ module Alchemy::Upgrader::Tasks
           # eager load all elements that have ingredients defined but no ingredient records yet.
           all_elements = Alchemy::Element
             .named(elements_with_ingredients.map { |d| d[:name] })
-            .includes(contents: { essence: :ingredient_association })
+            .includes(contents: :essence)
             .left_outer_joins(:ingredients).where(alchemy_ingredients: { id: nil })
             .to_a
           elements_with_ingredients.map do |element_definition|

data/lib/alchemy/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Alchemy
-  VERSION = "6.0.0-rc5"
+  VERSION = "6.0.0"
 
   def self.version
     VERSION

data/lib/generators/alchemy/install/install_generator.rb

@@ -23,6 +23,11 @@ module Alchemy
         default: false,
         desc: "Skip running the webpacker installer."
 
+      class_option :skip_db_create,
+        type: :boolean,
+        default: false,
+        desc: "Skip creting the database during install."
+
       source_root File.expand_path("files", __dir__)
 
       def setup
@@ -104,7 +109,7 @@ module Alchemy
       end
 
       def setup_database
-        rake("db:create", abort_on_failure: true)
+        rake("db:create", abort_on_failure: true) unless options[:skip_db_create]
         # We can't invoke this rake task, because Rails will use wrong engine names otherwise
         rake("railties:install:migrations", abort_on_failure: true)
         rake("db:migrate", abort_on_failure: true)

data/package/admin.js

@@ -6,6 +6,8 @@ import pictureEditors from "./src/picture_editors"
 import ImageLoader from "./src/image_loader"
 import ImageCropper from "./src/image_cropper"
 import Datepicker from "./src/datepicker"
+import Sitemap from "./src/sitemap"
+import PagePublicationFields from "./src/page_publication_fields.js"
 
 // Global Alchemy object
 if (typeof window.Alchemy === "undefined") {
@@ -22,5 +24,7 @@ Object.assign(Alchemy, {
   pictureEditors,
   ImageLoader: ImageLoader.init,
   ImageCropper,
-  Datepicker
+  Datepicker,
+  Sitemap,
+  PagePublicationFields
 })

data/package/src/image_loader.js

@@ -39,9 +39,11 @@ export default class ImageLoader {
     this.unbind()
   }
 
-  onError() {
+  onError(evt) {
+    const message = `Could not load "${this.image.src}"`
     this.removeSpinner()
-    this.parent.innerHtml = '<span class="icon warn"></span>'
+    this.parent.innerHTML = `<span class="icon error fas fa-exclamation-triangle" title="${message}" />`
+    console.error(message, evt)
     this.unbind()
   }
 

data/package/src/node_tree.js

@@ -1,12 +1,16 @@
 import Sortable from "sortablejs"
-import ajax from "./utils/ajax"
+import { patch } from "./utils/ajax"
 import { on } from "./utils/events"
 
 function displayNodeFolders() {
   document.querySelectorAll("li.menu-item").forEach((el) => {
     const leftIconArea = el.querySelector(".nodes_tree-left_images")
     const list = el.querySelector(".children")
-    const node = { folded: el.dataset.folded === "true", id: el.dataset.id, type: el.dataset.type }
+    const node = {
+      folded: el.dataset.folded === "true",
+      id: el.dataset.id,
+      type: el.dataset.type
+    }
 
     if (list.children.length > 0 || node.folded) {
       leftIconArea.innerHTML = HandlebarsTemplates.node_folder({ node: node })
@@ -17,13 +21,15 @@ function displayNodeFolders() {
 }
 
 function onFinishDragging(evt) {
-  const url = Alchemy.routes[evt.item.dataset.type].move_api_path(evt.item.dataset.id)
+  const url = Alchemy.routes[evt.item.dataset.type].move_api_path(
+    evt.item.dataset.id
+  )
   const data = {
     target_parent_id: evt.to.dataset.recordId,
     new_position: evt.newIndex
   }
 
-  ajax("PATCH", url, data)
+  patch(url, data)
     .then(() => {
       const message = Alchemy.t("Successfully moved menu item")
       Alchemy.growl(message)
@@ -38,10 +44,11 @@ function handleNodeFolders() {
   on("click", ".nodes_tree", ".node_folder", function () {
     const nodeId = this.dataset.recordId
     const menu_item = this.closest("li.menu-item")
-    const url = Alchemy.routes[this.dataset.recordType].toggle_folded_api_path(nodeId)
+    const url =
+      Alchemy.routes[this.dataset.recordType].toggle_folded_api_path(nodeId)
     const list = menu_item.querySelector(".children")
 
-    ajax("PATCH", url)
+    patch(url)
       .then(() => {
         list.classList.toggle("folded")
         menu_item.dataset.folded =

data/package/src/page_publication_fields.js

@@ -0,0 +1,28 @@
+// Handles the page publication date fields
+export default function () {
+  document.addEventListener("DialogReady.Alchemy", function (evt) {
+    const dialog = evt.detail.body
+    const public_on_field = dialog.querySelector("#page_public_on")
+    const public_until_field = dialog.querySelector("#page_public_until")
+    const publication_date_fields = dialog.querySelector(
+      ".page-publication-date-fields"
+    )
+    const public_field = dialog.querySelector("#page_public")
+
+    if(!public_field) return
+
+    public_field.addEventListener("click", function (evt) {
+      const checkbox = evt.target
+      const now = new Date()
+
+      if (checkbox.checked) {
+        publication_date_fields.classList.remove("hidden")
+        public_on_field._flatpickr.setDate(now)
+      } else {
+        publication_date_fields.classList.add("hidden")
+        public_on_field.value = ""
+      }
+      public_until_field.value = ""
+    })
+  })
+}

data/package/src/page_sorter.js

@@ -0,0 +1,62 @@
+import Sortable from "sortablejs"
+import { patch } from "./utils/ajax"
+
+function onFinishDragging(evt) {
+  const pageId = evt.item.dataset.pageId
+  const url = Alchemy.routes.move_admin_page_path(pageId)
+  const data = {
+    target_parent_id: evt.to.dataset.parentId,
+    new_position: evt.newIndex
+  }
+
+  patch(url, data)
+    .then(async (response) => {
+      const pageData = await response.data
+      const pageEl = document.getElementById(`page_${pageId}`)
+      const urlPathEl = pageEl.querySelector(".sitemap_url")
+
+      Alchemy.growl(Alchemy.t("Successfully moved page"))
+      urlPathEl.textContent = pageData.url_path
+      displayPageFolders()
+    })
+    .catch((error) => {
+      Alchemy.growl(error.message || error, "error")
+    })
+}
+
+export function displayPageFolders() {
+  document.querySelectorAll("li.sitemap-item").forEach((el) => {
+    const pageFolderEl = el.querySelector(".page_folder")
+    const list = el.querySelector(".children")
+    const page = {
+      folded: el.dataset.folded === "true",
+      id: el.dataset.pageId,
+      type: el.dataset.type
+    }
+
+    if (list.children.length > 0 || page.folded) {
+      pageFolderEl.outerHTML = HandlebarsTemplates.page_folder({ page })
+    } else {
+      pageFolderEl.innerHTML = ""
+    }
+  })
+}
+
+export function createSortables(sortables) {
+  sortables.forEach((el) => {
+    new Sortable(el, {
+      group: "pages",
+      animation: 150,
+      fallbackOnBody: true,
+      swapThreshold: 0.65,
+      handle: ".handle",
+      onEnd: onFinishDragging
+    })
+  })
+}
+
+export default function () {
+  const sortables = document.querySelectorAll("ul.children")
+  displayPageFolders()
+  createSortables(sortables)
+}

data/package/src/picture_editors.js

@@ -1,11 +1,10 @@
-import debounce from "lodash/debounce"
-import max from "lodash/max"
-import ajax from "./utils/ajax"
+import debounce from "lodash-es/debounce"
+import max from "lodash-es/max"
+import { get } from "./utils/ajax"
 import ImageLoader from "./image_loader"
 
 const UPDATE_DELAY = 125
 const IMAGE_PLACEHOLDER = '<i class="icon far fa-image fa-fw"></i>'
-const EMPTY_IMAGE = '<img src="" class="img_paddingtop" />'
 const THUMBNAIL_SIZE = "160x120"
 
 class PictureEditor {
@@ -62,7 +61,7 @@ class PictureEditor {
     this.image.removeAttribute("alt")
     this.image.removeAttribute("src")
     this.imageLoader.load(true)
-    ajax("GET", `/admin/pictures/${this.pictureId}/url`, {
+    get(Alchemy.routes.url_admin_picture_path(this.pictureId), {
       crop: this.imageCropperEnabled,
       crop_from: this.cropFrom,
       crop_size: this.cropSize,
@@ -83,9 +82,10 @@ class PictureEditor {
   ensureImage() {
     if (this.image) return
 
-    this.thumbnailBackground.innerHTML = EMPTY_IMAGE
-    this.image = this.container.querySelector("img")
-    this.imageLoader = new ImageLoader(this.image)
+    const img = new Image()
+    this.thumbnailBackground.replaceChildren(img)
+    this.image = img
+    this.imageLoader = new ImageLoader(img)
   }
 
   removeImage() {

data/package/src/sitemap.js

@@ -0,0 +1,148 @@
+// The admin sitemap Alchemy class
+import PageSorter from "./page_sorter"
+import { on } from "./utils/events"
+import { get, patch } from "./utils/ajax"
+import { createSortables, displayPageFolders } from "./page_sorter"
+
+export default class Sitemap {
+  // Storing some objects.
+  constructor(options) {
+    const list_template_html = document
+      .getElementById("sitemap-list")
+      .innerHTML.replace(/__ID__/g, "{{id}}")
+    this.search_field = document.querySelector(".search_input_field")
+    this.filter_field_clear = document.querySelector(".search_field_clear")
+    this.filter_field_clear.removeAttribute("href")
+    this.display = document.getElementById("page_filter_result")
+    this.sitemap_wrapper = document.getElementById("sitemap-wrapper")
+    this.template = Handlebars.compile(
+      document.getElementById("sitemap-template").innerHTML
+    )
+    this.list_template = Handlebars.compile(list_template_html)
+    this.items = null
+    this.options = options
+    Handlebars.registerPartial("list", list_template_html)
+    this.load(options.page_root_id)
+  }
+
+  // Loads the sitemap
+  load(pageId) {
+    const spinner = new Alchemy.Spinner("medium")
+    const spinTarget = this.sitemap_wrapper
+    spinTarget.innerHTML = ""
+    spinner.spin(spinTarget)
+    get(this.options.url, { id: pageId })
+      .then(async (response) => {
+        this.render(await response.data)
+        this.handlePageFolders()
+        spinner.stop()
+      })
+      .catch(this.errorHandler)
+  }
+
+  // Watch page folder clicks and re-render the page branch
+  handlePageFolders() {
+    on(
+      "click",
+      "#sitemap",
+      ".page_folder",
+      function (evt) {
+        const spinner = new Alchemy.Spinner("small")
+        const pageFolder = evt.target.closest(".page_folder")
+        const pageId = pageFolder.dataset.pageId
+        pageFolder.innerHTML = ""
+        spinner.spin(pageFolder)
+
+        patch(Alchemy.routes.fold_admin_page_path(pageId))
+          .then(async (response) => {
+            this.reRender(pageId, await response.data)
+            spinner.stop()
+          })
+          .catch(this.errorHandler)
+      }.bind(this)
+    )
+  }
+
+  // Renders the sitemap
+  render(data) {
+    const renderTarget = this.sitemap_wrapper
+    const renderTemplate = this.template
+
+    renderTarget.innerHTML = renderTemplate({ children: data.pages })
+    this.items = document
+      .getElementById("sitemap")
+      .querySelectorAll(".sitemap_page")
+    this.sitemap_wrapper = document.getElementById("sitemap-wrapper")
+    this._observe()
+    PageSorter()
+  }
+
+  reRender(pageId, data) {
+    let pageEl = document.getElementById(`page_${pageId}`)
+    pageEl.outerHTML = this.list_template({ children: data.pages })
+    pageEl = document.getElementById(`page_${pageId}`)
+    const sortables = pageEl.querySelectorAll("ul.children")
+    createSortables(sortables)
+    displayPageFolders()
+  }
+
+  // Filters the sitemap
+  filter(term) {
+    const results = []
+
+    this.items.forEach(function (item) {
+      if (
+        term !== "" &&
+        item.getAttribute("name").toLowerCase().indexOf(term) !== -1
+      ) {
+        item.classList.add("highlight")
+        item.classList.remove("no-match")
+        results.push(item)
+      } else {
+        item.classList.add("no-match")
+        item.classList.remove("highlight")
+      }
+    })
+    this.filter_field_clear.style.display = "inline-block"
+    const { length } = results
+
+    if (length === 1) {
+      this.display.style.display = "block"
+      this.display.innerText = `1 ${Alchemy.t("page_found")}`
+      results[0].scrollIntoView({ behavior: "smooth", block: "center" })
+    } else if (length > 1) {
+      this.display.style.display = "block"
+      this.display.innerText = `${length} ${Alchemy.t("pages_found")}`
+    } else {
+      this.items.forEach((item) =>
+        item.classList.remove("no-match", "highlight")
+      )
+      this.display.style.display = "none"
+      window.scrollTo({
+        top: 0,
+        left: 0,
+        behavior: "smooth"
+      })
+      this.filter_field_clear.style.display = "none"
+    }
+  }
+
+  // Adds onkey up observer to search field
+  _observe() {
+    this.search_field.addEventListener("keyup", (evt) => {
+      const term = evt.target.value
+      this.filter(term.toLowerCase())
+    })
+    this.search_field.addEventListener("focus", () => key.setScope("search"))
+    this.filter_field_clear.addEventListener("click", () => {
+      this.search_field.value = ""
+      this.filter("")
+      return false
+    })
+  }
+
+  errorHandler(error) {
+    Alchemy.growl(error.message || error, "error")
+    console.error(error)
+  }
+}