alchemy_cms 5.1.4 → 6.0.0.b1

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.
   #
@@ -26,28 +26,22 @@ module Alchemy
     #   Randomize the output of elements
     # @option options [Boolean] :reverse (false)
     #   Reverse the load order
-    # @option options [Hash] :fallback
-    #   Define elements that are loaded from another page if no element was found on given page.
     def initialize(options = {})
       @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])
@@ -55,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])
@@ -77,38 +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::Page.find_by(
-          language: Alchemy::Language.current,
-          page_layout: page_or_layout,
-          restricted: false,
-        )
-      end
-    end
-
-    def fallback_required?(elements)
-      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}
@@ -83,7 +82,7 @@ module Alchemy #:nodoc:
 
         if configuration[:belongs_to]
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
-            belongs_to :ingredient_association, #{configuration[:belongs_to]}
+            belongs_to :ingredient_association, **#{configuration[:belongs_to]}
 
             alias_method :#{configuration[:ingredient_column]}, :ingredient_association
             alias_method :#{configuration[:ingredient_column]}=, :ingredient_association=
@@ -108,9 +107,9 @@ module Alchemy #:nodoc:
       # Register the current class as has_many association on +Alchemy::Page+ and +Alchemy::Element+ models
       def register_as_essence_association!
         klass_name = model_name.to_s
-        arguments = [:has_many, klass_name.demodulize.tableize.to_sym, through: :contents,
-                                                                       source: :essence, source_type: klass_name]
-        %w(Page Element).each { |k| "Alchemy::#{k}".constantize.send(*arguments) }
+        arguments = [:has_many, klass_name.demodulize.tableize.to_sym]
+        kwargs = { through: :contents, source: :essence, source_type: klass_name }
+        %w(Page Element).each { |k| "Alchemy::#{k}".constantize.send(*arguments, **kwargs) }
       end
     end
 

data/lib/alchemy/filetypes.rb

@@ -40,7 +40,20 @@ module Alchemy
     EXCEL_FILE_TYPES = [
       "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
       "application/vnd.ms-excel",
+      "application/msexcel",
       "text/csv",
     ]
+
+    WORD_FILE_TYPES = [
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      "application/vnd.ms-word",
+      "application/msword",
+    ]
+
+    POWERPOINT_FILE_TYPES = [
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+      "application/vnd.ms-powerpoint",
+      "application/mspowerpoint",
+    ]
   end
 end

data/lib/alchemy/forms/builder.rb

@@ -11,7 +11,7 @@ module Alchemy
         if object.respond_to?(:attribute_fixed?) && object.attribute_fixed?(attribute_name)
           options[:disabled] = true
           options[:input_html] = options.fetch(:input_html, {}).merge(
-            "data-alchemy-tooltip" => Alchemy.t(:attribute_fixed, attribute_name),
+            "data-alchemy-tooltip" => Alchemy.t(:attribute_fixed, attribute: attribute_name),
           )
         end
 

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/i18n.rb

@@ -12,8 +12,8 @@ module Alchemy
     #
     #     Alchemy.t(:hello)
     #
-    def t(msg, *args)
-      Alchemy::I18n.translate(msg, *args)
+    def t(msg, **kwargs)
+      Alchemy::I18n.translate(msg, **kwargs)
     end
   end
 
@@ -47,11 +47,10 @@ module Alchemy
       #       world:
       #         hello: Hallo
       #
-      def translate(msg, *args)
-        options = args.extract_options!
+      def translate(msg, **options)
         humanize_default_string!(msg, options)
         scope = alchemy_scoped_scope(options)
-        ::I18n.t(msg, options.merge(scope: scope))
+        ::I18n.t(msg, **options.merge(scope: scope))
       end
 
       def available_locales

data/lib/alchemy/page_layout.rb

@@ -63,18 +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
-
       # 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,9 +141,6 @@ module Alchemy
           :alchemy_admin_users,
         ]
 
-        # Controller actions
-        can :clear, :trash
-
         # Resources
         can [
           :copy,
@@ -164,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
 
@@ -185,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.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module TestSupport
+    def self.factories_path
+      ::Alchemy::Engine.root.join("lib", "alchemy", "test_support", "factories")
+    end
+  end
+end