alchemy_cms 5.3.5 → 6.0.0.b1

data/db/migrate/20201207135820_add_page_version_id_to_alchemy_elements.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class AddPageVersionIdToAlchemyElements < ActiveRecord::Migration[5.2]
+  class LocalPage < ActiveRecord::Base
+    self.table_name = :alchemy_pages
+    has_many :elements, class_name: "LocalElement", inverse_of: :page
+    has_many :versions, class_name: "LocalVersion", inverse_of: :page, foreign_key: :page_id
+  end
+
+  class LocalVersion < ActiveRecord::Base
+    self.table_name = :alchemy_page_versions
+    belongs_to :page, class_name: "LocalPage", inverse_of: :versions
+    has_many :elements, class_name: "LocalElement", inverse_of: :versions
+  end
+
+  class LocalElement < ActiveRecord::Base
+    self.table_name = :alchemy_elements
+    belongs_to :page, class_name: "LocalPage", inverse_of: :elements
+    belongs_to :page_version, class_name: "LocalVersion", inverse_of: :elements
+  end
+
+  def change
+    add_reference :alchemy_elements, :page_version,
+                  index: false,
+                  foreign_key: {
+                    to_table: :alchemy_page_versions,
+                    on_delete: :cascade,
+                  }
+    add_index :alchemy_elements, [:page_version_id, :parent_element_id],
+              name: "idx_alchemy_elements_on_page_version_id_and_parent_element_id"
+    add_index :alchemy_elements, [:page_version_id, :position],
+              name: "idx_alchemy_elements_on_page_version_id_and_position"
+
+    # Add a page version for each page so we can add a not null constraint
+    reversible do |dir|
+      dir.up do
+        say_with_time "Create draft version for each page." do
+          LocalPage.find_each do |page|
+            next if page.versions.any?
+
+            page.versions.create!.tap do |version|
+              Alchemy::Element.where(page_id: page.id).update_all(page_version_id: version.id)
+            end
+          end
+          LocalVersion.count
+        end
+      end
+    end
+
+    change_column_null :alchemy_elements, :page_version_id, false
+
+    # Remove the existing page relation
+    remove_reference :alchemy_elements, :page,
+                     null: false,
+                     index: false,
+                     foreign_key: {
+                       to_table: :alchemy_pages,
+                       on_delete: :cascade,
+                       on_update: :cascade,
+                     }
+    if index_exists? :alchemy_elements,
+                     :parent_element_id,
+                     name: "index_alchemy_elements_on_page_id_and_parent_element_id"
+      remove_index :alchemy_elements,
+                   column: [:parent_element_id],
+                   name: "index_alchemy_elements_on_page_id_and_parent_element_id"
+    end
+    if index_exists? :alchemy_elements,
+                     :position,
+                     name: "index_elements_on_page_id_and_position"
+      remove_index :alchemy_elements,
+                   column: [:position],
+                   name: "index_elements_on_page_id_and_position"
+    end
+  end
+end

data/db/migrate/20210205143548_rename_public_on_and_public_until_on_alchemy_pages.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class RenamePublicOnAndPublicUntilOnAlchemyPages < ActiveRecord::Migration[6.0]
+  def change
+    remove_index :alchemy_pages, column: [:public_on, :public_until],
+      name: "index_alchemy_pages_on_public_on_and_public_until"
+    rename_column :alchemy_pages, :public_on, :legacy_public_on
+    rename_column :alchemy_pages, :public_until, :legacy_public_until
+  end
+end

data/db/migrate/20210326105046_add_sanitized_body_to_alchemy_essence_richtexts.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddSanitizedBodyToAlchemyEssenceRichtexts < ActiveRecord::Migration[6.0]
+  def change
+    add_column :alchemy_essence_richtexts, :sanitized_body, :text
+  end
+end

data/db/migrate/20210406093436_add_alchemy_essence_headlines.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class AddAlchemyEssenceHeadlines < ActiveRecord::Migration[6.0]
+  def change
+    create_table :alchemy_essence_headlines do |t|
+      t.text :body
+      t.integer :level
+      t.integer :size
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20210506135919_create_essence_audios.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateEssenceAudios < ActiveRecord::Migration[6.0]
+  def up
+    return if table_exists? :alchemy_essence_audios
+
+    create_table :alchemy_essence_audios do |t|
+      t.references :attachment
+      t.boolean :controls, default: true, null: false
+      t.boolean :autoplay, default: false
+      t.boolean :loop, default: false, null: false
+      t.boolean :muted, default: false, null: false
+    end
+  end
+
+  def down
+    drop_table :alchemy_essence_audios
+  end
+end

data/db/migrate/20210506140258_create_essence_videos.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class CreateEssenceVideos < ActiveRecord::Migration[6.0]
+  def up
+    return if table_exists? :alchemy_essence_videos
+
+    create_table :alchemy_essence_videos do |t|
+      t.references :attachment
+      t.string :width
+      t.string :height
+      t.boolean :allow_fullscreen, default: true, null: false
+      t.boolean :autoplay, default: false, null: false
+      t.boolean :controls, default: true, null: false
+      t.boolean :loop, default: false, null: false
+      t.boolean :muted, default: false, null: false
+      t.string :preload
+    end
+  end
+
+  def down
+    drop_table :alchemy_essence_videos
+  end
+end

data/db/migrate/20210508091432_create_alchemy_ingredients.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class CreateAlchemyIngredients < ActiveRecord::Migration[6.0]
+  def change
+    create_table :alchemy_ingredients do |t|
+      t.references :element, null: false, foreign_key: { to_table: :alchemy_elements, on_delete: :cascade }
+      t.string :type, index: true, null: false
+      t.string :role, null: false
+      t.text :value
+      if ActiveRecord::Migration.connection.adapter_name.match?(/postgres/i)
+        t.jsonb :data, default: {}
+      else
+        t.json :data
+      end
+      t.belongs_to :related_object, null: true, polymorphic: true, index: false
+      t.index [:element_id, :role], unique: true
+      t.index [:related_object_id, :related_object_type], name: "idx_alchemy_ingredient_relation"
+
+      t.timestamps
+    end
+  end
+end

data/lib/alchemy/admin/preview_url.rb

@@ -45,8 +45,10 @@ module Alchemy
         if @preview_config && uri
           uri_class.build(
             host: uri.host,
+            port: uri.port,
             path: page.url_path,
             userinfo: userinfo,
+            query: { alchemy_preview_mode: true }.to_param,
           ).to_s
         else
           routes.admin_page_path(page)

data/lib/alchemy/deprecation.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Alchemy
-  Deprecation = ActiveSupport::Deprecation.new("6.0", "Alchemy")
+  Deprecation = ActiveSupport::Deprecation.new("6.1", "Alchemy")
 end

data/lib/alchemy/dragonfly/processors/auto_orient.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "dragonfly/image_magick/commands"
+
+module Alchemy
+  module Dragonfly
+    module Processors
+      class AutoOrient
+        def call(content)
+          ::Dragonfly::ImageMagick::Commands.convert(
+            content,
+            "-auto-orient"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/alchemy/elements_finder.rb

@@ -3,7 +3,7 @@
 require "alchemy/logger"
 
 module Alchemy
-  # Loads elements from given page
+  # Loads elements from given page version.
   #
   # Used by {Alchemy::Page#find_elements} and {Alchemy::ElementsHelper#render_elements} helper.
   #
@@ -30,22 +30,18 @@ module Alchemy
       @options = options
     end
 
-    # @param page [Alchemy::Page|String]
-    #   The page the elements are loaded from. You can pass a page_layout String or a {Alchemy::Page} object.
-    # @return [ActiveRecord::Relation]
-    def elements(page:)
-      elements = find_elements(page)
-
-      if fallback_required?(elements)
-        elements = elements.merge(fallback_elements)
-      end
+    # @param page [Alchemy::PageVersion]
+    #   The page version the elements are loaded from.
+    # @return [Alchemy::ElementsRepository]
+    def elements(page_version:)
+      elements = find_elements(page_version)
 
       if options[:reverse]
-        elements = elements.reverse_order
+        elements = elements.reverse
       end
 
       if options[:random]
-        elements = elements.reorder(Arel.sql(random_function))
+        elements = elements.random
       end
 
       elements.offset(options[:offset]).limit(options[:count])
@@ -53,17 +49,14 @@ module Alchemy
 
     private
 
-    attr_reader :page, :options
+    attr_reader :options
 
-    def find_elements(page_or_layout)
-      @page = get_page(page_or_layout)
-      return Alchemy::Element.none unless page
+    def find_elements(page_version)
+      return Alchemy::ElementsRepository.none unless page_version
 
-      if options[:fixed]
-        elements = page.fixed_elements
-      else
-        elements = page.elements
-      end
+      elements = Alchemy::ElementsRepository.new(page_version.elements.available)
+      elements = elements.not_nested
+      elements = options[:fixed] ? elements.fixed : elements.unfixed
 
       if options[:only]
         elements = elements.named(options[:only])
@@ -75,44 +68,5 @@ module Alchemy
 
       elements
     end
-
-    def get_page(page_or_layout)
-      case page_or_layout
-      when Alchemy::Page
-        page_or_layout
-      when String
-        Alchemy::Deprecation.warn "Passing a String as `from_page` option to " \
-          "`render_elements` is deprecated and will be removed with Alchemy 6.0. " \
-          "Please load the page beforehand and pass it as an object instead."
-        Alchemy::Page.find_by(
-          language: Alchemy::Language.current,
-          page_layout: page_or_layout,
-          restricted: false,
-        )
-      end
-    end
-
-    def fallback_required?(elements)
-      if options[:fallback]
-        Alchemy::Deprecation.warn "Passing `fallback` options to `render_elements` is deprecated an will be removed with Alchemy 6.0."
-      end
-      options[:fallback] && elements
-        .where(Alchemy::Element.table_name => {name: options[:fallback][:for]})
-        .none?
-    end
-
-    def fallback_elements
-      find_elements(options[:fallback][:from])
-        .named(options[:fallback][:with] || options[:fallback][:for])
-    end
-
-    def random_function
-      case ActiveRecord::Base.connection_config[:adapter]
-      when "postgresql", "sqlite3"
-        "RANDOM()"
-      else
-        "RAND()"
-      end
-    end
   end
 end

data/lib/alchemy/engine.rb

@@ -40,27 +40,9 @@ module Alchemy
       if Alchemy.user_class
         ActiveSupport.on_load(:active_record) do
           Alchemy.user_class.model_stamper
-          Alchemy.user_class.stampable(stamper_class_name: Alchemy.user_class.name)
+          Alchemy.user_class.stampable(stamper_class_name: Alchemy.user_class_name)
         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
-
-    initializer "alchemy.error_tracking" do
-      if defined?(Airbrake)
-        require_relative "error_tracking/airbrake_handler"
-        Alchemy::ErrorTracking.notification_handler = Alchemy::ErrorTracking::AirbrakeHandler
-      end
-    end
   end
 end

data/lib/alchemy/essence.rb

@@ -59,10 +59,9 @@ module Alchemy #:nodoc:
           scope :from_element, ->(name) { joins(:element).where(Element.table_name => { name: name }) }
 
           delegate :restricted?, to: :page,    allow_nil: true
-          delegate :trashed?,    to: :element, allow_nil: true
           delegate :public?,     to: :element, allow_nil: true
 
-          after_save :touch_element
+          after_update :touch_element
 
           def acts_as_essence_class
             #{name}

data/lib/alchemy/hints.rb

@@ -35,21 +35,25 @@ module Alchemy
     # @return String
     #
     def hint
-      hint = definition["hint"]
+      hint = definition[:hint]
       if hint == true
-        Alchemy.t(name, scope: hint_translation_scope)
+        Alchemy.t(hint_translation_attribute, scope: hint_translation_scope)
       else
         hint
       end
     end
 
-    # Returns true if the element has a hint
+    # Returns true if the element has a hint defined
     def has_hint?
-      hint.present?
+      !!definition[:hint]
     end
 
     private
 
+    def hint_translation_attribute
+      name
+    end
+
     def hint_translation_scope
       "#{self.class.model_name.to_s.demodulize.downcase}_hints"
     end

data/lib/alchemy/page_layout.rb

@@ -63,19 +63,6 @@ module Alchemy
         mapped_layouts_for_select(selectable_layouts(language_id, only_layoutpages))
       end
 
-      # Returns page layouts including given layout ready for Rails' select form helper.
-      #
-      def layouts_with_own_for_select(page_layout_name, language_id, only_layoutpages = false)
-        layouts = selectable_layouts(language_id, only_layoutpages)
-        if layouts.detect { |l| l["name"] == page_layout_name }.nil?
-          @map_array = [[human_layout_name(page_layout_name), page_layout_name]]
-        else
-          @map_array = []
-        end
-        mapped_layouts_for_select(layouts)
-      end
-      deprecate :layouts_with_own_for_select, deprecator: Alchemy::Deprecation
-
       # Returns all layouts that can be used for creating a new page.
       #
       # It removes all layouts from available layouts that are unique and already taken and that are marked as hide.

data/lib/alchemy/permissions.rb

@@ -36,14 +36,13 @@ module Alchemy
     module GuestUser
       def alchemy_guest_user_rules
         can([:show, :download], Alchemy::Attachment) { |a| !a.restricted? }
-        can :see, Alchemy::Page, restricted: false
 
         can :read, Alchemy::Content, Alchemy::Content.available.not_restricted do |c|
-          c.public? && !c.restricted? && !c.trashed?
+          c.public? && !c.restricted?
         end
 
         can :read, Alchemy::Element, Alchemy::Element.available.not_restricted do |e|
-          e.public? && !e.restricted? && !e.trashed?
+          e.public? && !e.restricted?
         end
 
         can :read, Alchemy::Page, Alchemy::Page.published.not_restricted do |p|
@@ -64,14 +63,13 @@ module Alchemy
 
         # Resources
         can [:show, :download], Alchemy::Attachment
-        can :see, Alchemy::Page, restricted: true
 
         can :read, Alchemy::Content, Alchemy::Content.available do |c|
-          c.public? && !c.trashed?
+          c.public?
         end
 
         can :read, Alchemy::Element, Alchemy::Element.available do |e|
-          e.public? && !e.trashed?
+          e.public?
         end
 
         can :read, Alchemy::Page, Alchemy::Page.published do |p|
@@ -103,24 +101,27 @@ module Alchemy
         ]
 
         # Controller actions
-        can :leave,                 :alchemy_admin
-        can [:info, :help],         :alchemy_admin_dashboard
-        can :manage,                :alchemy_admin_clipboard
-        can :index,                 :trash
-        can :edit,                  :alchemy_admin_layoutpages
-        can :tree,                  :alchemy_admin_pages
+        can :leave, :alchemy_admin
+        can [:info, :help], :alchemy_admin_dashboard
+        can :manage, :alchemy_admin_clipboard
+        can :edit, :alchemy_admin_layoutpages
+        can :tree, :alchemy_admin_pages
 
         # Resources
-        can [:read, :download],     Alchemy::Attachment
-        can :manage,                Alchemy::Content
-        can :manage,                Alchemy::Element
-        can :manage,                Alchemy::EssenceFile
-        can :manage,                Alchemy::EssencePicture
-        can :manage,                Alchemy::LegacyPageUrl
-        can :manage,                Alchemy::Node
-        can :read,                  Alchemy::Picture
+        can [:read, :download], Alchemy::Attachment
+        can :manage, Alchemy::Content
+        can :manage, Alchemy::Element
+        can :manage, Alchemy::EssenceAudio
+        can :manage, Alchemy::EssenceFile
+        can :manage, Alchemy::EssencePicture
+        can :manage, Alchemy::EssenceVideo
+        can :manage, Alchemy::Ingredient
+        can [:crop], Alchemy::Ingredients::Picture
+        can :manage, Alchemy::LegacyPageUrl
+        can :manage, Alchemy::Node
+        can [:read, :url], Alchemy::Picture
         can [:read, :autocomplete], Alchemy::Tag
-        can(:edit_content,          Alchemy::Page) { |p| p.editable_by?(@user) }
+        can(:edit_content, Alchemy::Page) { |p| p.editable_by?(@user) }
       end
     end
 
@@ -140,15 +141,13 @@ module Alchemy
           :alchemy_admin_users,
         ]
 
-        # Controller actions
-        can :clear, :trash
-
         # Resources
         can [
           :copy,
           :copy_language_tree,
           :flush,
           :order,
+          :sort,
           :switch_language,
         ], Alchemy::Page
 
@@ -163,13 +162,16 @@ module Alchemy
         can([
           :create,
           :destroy,
-          :publish,
         ], Alchemy::Page) { |p| p.editable_by?(@user) }
 
+        can(:publish, Alchemy::Page) do |page|
+          page.language.public? && page.editable_by?(@user)
+        end
+
         can :manage, Alchemy::Picture
         can :manage, Alchemy::Attachment
         can :manage, Alchemy::Tag
-        can :index,  Alchemy::Language
+        can :index, Alchemy::Language
       end
     end
 
@@ -184,14 +186,14 @@ module Alchemy
         alchemy_editor_rules
 
         # Navigation
-        can :index,                 [:alchemy_admin_sites, :alchemy_admin_styleguide]
+        can :index, [:alchemy_admin_sites, :alchemy_admin_styleguide]
 
         # Controller actions
         can [:info, :update_check], :alchemy_admin_dashboard
 
         # Resources
-        can :manage,                Alchemy::Language
-        can :manage,                Alchemy::Site
+        can :manage, Alchemy::Language
+        can :manage, Alchemy::Site
       end
     end
 

data/lib/alchemy/resource.rb

@@ -286,6 +286,11 @@ module Alchemy
       resource_relation(column_name).try(:[], :attr_type)
     end
 
+    def resource_relation_class(association)
+      class_name = association.options[:class_name] || association.name.to_s.classify
+      class_name.constantize
+    end
+
     def resource_column_type(col)
       resource_relation_type(col.name) || (col.try(:array) ? :array : col.type)
     end
@@ -298,10 +303,15 @@ module Alchemy
     def map_relations
       self.resource_relations = {}
       model.alchemy_resource_relations.each do |name, options|
-        name = name.to_s.gsub(/_id$/, "") # ensure that we don't have an id
-        association = association_from_relation_name(name)
+        relation_name = name.to_s.gsub(/_id$/, "") # ensure that we don't have an id
+        association = association_from_relation_name(relation_name)
         foreign_key = association.options[:foreign_key] || "#{association.name}_id".to_sym
-        resource_relations[foreign_key] = options.merge(model_association: association, name: name)
+        collection = options[:collection] || resource_relation_class(association).all
+        resource_relations[foreign_key] = options.merge(
+          model_association: association,
+          name: relation_name,
+          collection: collection,
+        )
       end
     end
 

data/lib/alchemy/tasks/tidy.rb

@@ -62,6 +62,23 @@ module Alchemy
         end
       end
 
+      def remove_trashed_elements
+        puts "\n## Removing trashed elements"
+        elements = Alchemy::Element.unscoped.where(position: nil)
+        if elements.any?
+          log "Destroying #{elements.size} trashed elements"
+          nested_elements, parent_elements = elements.partition(&:parent_element_id)
+          (nested_elements + parent_elements).each do |element|
+            element.destroy
+            print "."
+          end
+          puts "\n"
+          log "Done", :message
+        else
+          log "No trashed elements found", :skip
+        end
+      end
+
       def remove_orphaned_contents
         puts "\n## Removing orphaned contents"
         contents = Alchemy::Content.unscoped.all
@@ -81,6 +98,18 @@ module Alchemy
         end
       end
 
+      def remove_duplicate_legacy_urls
+        puts "\n## Removing duplicate legacy URLs"
+        sql = <<~SQL
+          DELETE FROM alchemy_legacy_page_urls A USING alchemy_legacy_page_urls B
+          WHERE A.page_id = B.page_id
+            AND A.urlname = B.urlname
+            AND A.id < B.id
+        SQL
+        count = ActiveRecord::Base.connection.exec_delete(sql)
+        log "Deleted #{count} duplicate legacy URLs"
+      end
+
       private
 
       def destroy_orphaned_records(records, class_name)

data/lib/alchemy/test_support/essence_shared_examples.rb

@@ -265,7 +265,6 @@ RSpec.shared_examples_for "an essence" do
 
   context "delegations" do
     it { should delegate_method(:restricted?).to(:page) }
-    it { should delegate_method(:trashed?).to(:element) }
     it { should delegate_method(:public?).to(:element) }
   end
 

data/lib/alchemy/test_support/factories/element_factory.rb

@@ -4,7 +4,8 @@ FactoryBot.define do
   factory :alchemy_element, class: "Alchemy::Element" do
     name { "article" }
     autogenerate_contents { false }
-    association :page, factory: :alchemy_page
+    autogenerate_ingredients { false }
+    association :page_version, factory: :alchemy_page_version
 
     trait :fixed do
       fixed { true }
@@ -16,23 +17,22 @@ FactoryBot.define do
       name { "header" }
     end
 
-    trait :trashed do
-      after(:create) do |element|
-        element.update_column(:position, :null)
-      end
-    end
-
     trait :with_nestable_elements do
       name { "slider" }
     end
 
     trait :nested do
-      association :parent_element, factory: :alchemy_element, name: "slider"
+      parent_element { build(:alchemy_element, name: "slider", page_version: page_version) }
       name { "slide" }
     end
 
     trait :with_contents do
       autogenerate_contents { true }
     end
+
+    trait :with_ingredients do
+      name { "element_with_ingredients" }
+      autogenerate_ingredients { true }
+    end
   end
 end