alchemy_cms 5.2.0 → 6.0.0.b3

data/db/migrate/20201207131309_create_page_versions.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreatePageVersions < ActiveRecord::Migration[5.2]
+  def change
+    create_table :alchemy_page_versions do |t|
+      t.references :page,
+                   null: false,
+                   index: true,
+                   foreign_key: {
+                     to_table: :alchemy_pages,
+                     on_delete: :cascade,
+                   }
+      t.datetime :public_on
+      t.datetime :public_until
+      t.index [:public_on, :public_until]
+      t.timestamps
+    end
+  end
+end

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/dragonfly/processors/crop_resize.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "dragonfly/image_magick/commands"
+
+module Alchemy
+  module Dragonfly
+    module Processors
+      class CropResize
+        include ::Dragonfly::ParamValidators
+
+        IS_CROP_ARGUMENT = ->(args_string) {
+          args_string.match?(::Dragonfly::ImageMagick::Processors::Thumb::CROP_GEOMETRY)
+        }
+
+        IS_RESIZE_ARGUMENT = ->(args_string) {
+          args_string.match?(::Dragonfly::ImageMagick::Processors::Thumb::RESIZE_GEOMETRY)
+        }
+
+        def call(content, crop_argument, resize_argument)
+          validate!(crop_argument, &IS_CROP_ARGUMENT)
+          validate!(resize_argument, &IS_RESIZE_ARGUMENT)
+          ::Dragonfly::ImageMagick::Commands.convert(
+            content,
+            "-crop #{crop_argument} -resize #{resize_argument}"
+          )
+        end
+
+        def update_url(attrs, _args = "", opts = {})
+          format = opts["format"]
+          attrs.ext = format if format
+        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/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/forms/builder.rb

@@ -18,11 +18,31 @@ module Alchemy
         super
       end
 
+      # Renders a simple_form input that displays a datepicker
+      #
+      def datepicker(attribute_name, options = {})
+        options[:wrapper] = :alchemy
+
+        type = options[:as] || :date
+        value = options.fetch(:input_html, {}).delete(:value)
+        date = value || object.send(attribute_name.to_sym).presence
+        date = Time.zone.parse(date) if date.is_a?(String)
+
+        input_options = {
+          type: :text,
+          class: type,
+          data: { datepicker_type: type },
+          value: date&.iso8601,
+        }.merge(options[:input_html] || {})
+
+        input attribute_name, as: :string, input_html: input_options
+      end
+
       # Renders a button tag wrapped in a div with 'submit' class.
       #
       def submit(label, options = {})
         options = {
-          wrapper_html: {class: "submit"},
+          wrapper_html: { class: "submit" },
         }.update(options)
         template.content_tag("div", options.delete(:wrapper_html)) do
           template.content_tag("button", label, options.delete(:input_html))

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