alchemy_cms 4.1.2 → 4.2.0.rc1

data/app/models/alchemy/element.rb

@@ -9,13 +9,13 @@
 #  position          :integer
 #  page_id           :integer          not null
 #  public            :boolean          default(TRUE)
+#  fixed             :boolean          default(FALSE)
 #  folded            :boolean          default(FALSE)
 #  unique            :boolean          default(FALSE)
 #  created_at        :datetime         not null
 #  updated_at        :datetime         not null
 #  creator_id        :integer
 #  updater_id        :integer
-#  cell_id           :integer
 #  cached_tag_list   :text
 #  parent_element_id :integer
 #
@@ -28,11 +28,12 @@ module Alchemy
 
     FORBIDDEN_DEFINITION_ATTRIBUTES = [
       "amount",
+      "autogenerate",
       "nestable_elements",
       "contents",
       "hint",
-      "picture_gallery",
-      "taggable"
+      "taggable",
+      "compact"
     ].freeze
 
     SKIPPED_ATTRIBUTES_ON_COPY = [
@@ -46,15 +47,15 @@ module Alchemy
       "updater_id"
     ].freeze
 
-    # All Elements that share the same page id, cell id and parent element id are considered a list.
+    # All Elements that share the same page id and parent element id and are fixed or not are considered a list.
     #
-    # If cell id and parent element id are nil (typical case for a simple page),
+    # If parent element id is nil (typical case for a simple page),
     # then all elements on that page are still in one list,
     # because acts_as_list correctly creates this statement:
     #
-    #   WHERE page_id = 1 and cell_id = NULL AND parent_element_id = NULL
+    #   WHERE page_id = 1 and fixed = FALSE AND parent_element_id = NULL
     #
-    acts_as_list scope: [:page_id, :cell_id, :parent_element_id]
+    acts_as_list scope: [:page_id, :fixed, :parent_element_id]
 
     stampable stamper_class_name: Alchemy.user_class_name
 
@@ -69,7 +70,6 @@ module Alchemy
       foreign_key: :parent_element_id,
       dependent: :destroy
 
-    belongs_to :cell, optional: true, touch: true
     belongs_to :page, touch: true, inverse_of: :descendent_elements
 
     # A nested element belongs to a parent element.
@@ -85,20 +85,22 @@ module Alchemy
     validates_presence_of :name, on: :create
     validates_format_of :name, on: :create, with: /\A[a-z0-9_-]+\z/
 
-    attr_accessor :create_contents_after_create
+    attr_accessor :autogenerate_contents
+    attr_accessor :autogenerate_nested_elements
+    after_create :create_contents, unless: -> { autogenerate_contents == false }
+    after_create :generate_nested_elements, unless: -> { autogenerate_nested_elements == false }
 
-    after_create :create_contents, unless: proc { |e| e.create_contents_after_create == false }
     after_update :touch_touchable_pages
 
     scope :trashed,           -> { where(position: nil).order('updated_at DESC') }
-    scope :not_trashed,       -> { where(Element.arel_table[:position].not_eq(nil)) }
+    scope :not_trashed,       -> { where.not(position: nil) }
     scope :published,         -> { where(public: true) }
     scope :not_restricted,    -> { joins(:page).merge(Page.not_restricted) }
     scope :available,         -> { published.not_trashed }
     scope :named,             ->(names) { where(name: names) }
     scope :excluded,          ->(names) { where(arel_table[:name].not_in(names)) }
-    scope :not_in_cell,       -> { where(cell_id: nil) }
-    scope :in_cell,           -> { where("#{table_name}.cell_id IS NOT NULL") }
+    scope :fixed,             -> { where(fixed: true) }
+    scope :unfixed,           -> { where(fixed: false) }
     scope :from_current_site, -> { where(Language.table_name => {site_id: Site.current || Site.default}).joins(page: 'language') }
     scope :folded,            -> { where(folded: true) }
     scope :expanded,          -> { where(folded: false) }
@@ -121,23 +123,21 @@ module Alchemy
       # - Raises Alchemy::ElementDefinitionError if no definition for given attributes[:name]
       #   could be found
       #
-      def new_from_scratch(attributes = {})
-        return new if attributes[:name].blank?
-        new_element_from_definition_by(attributes) || raise(ElementDefinitionError, attributes)
-      end
+      def new(attributes = {})
+        return super if attributes[:name].blank?
+        element_attributes = attributes.to_h.merge(name: attributes[:name].split('#').first)
+        element_definition = Element.definition_by_name(element_attributes[:name])
+        if element_definition.nil?
+          raise(ElementDefinitionError, attributes)
+        end
 
-      # Creates a new element as described in +/config/alchemy/elements.yml+
-      #
-      # - Returns a new Alchemy::Element object if no name is given in attributes,
-      #   because the definition can not be found w/o name
-      # - Raises Alchemy::ElementDefinitionError if no definition for given attributes[:name]
-      #   could be found
-      #
-      def create_from_scratch(attributes)
-        element = new_from_scratch(attributes)
-        element.save if element
-        element
+        super(element_definition.merge(element_attributes).except(*FORBIDDEN_DEFINITION_ATTRIBUTES))
       end
+      alias_method :new_from_scratch, :new
+      deprecate new_from_scratch: :new, deprecator: Alchemy::Deprecation
+
+      alias_method :create_from_scratch, :create
+      deprecate create_from_scratch: :create, deprecator: Alchemy::Deprecation
 
       # This methods does a copy of source and all depending contents and all of their depending essences.
       #
@@ -155,7 +155,8 @@ module Alchemy
                        .except(*SKIPPED_ATTRIBUTES_ON_COPY)
                        .merge(differences)
                        .merge({
-                         create_contents_after_create: false,
+                         autogenerate_contents: false,
+                         autogenerate_nested_elements: false,
                          tag_list: source_element.tag_list
                        })
 
@@ -185,16 +186,6 @@ module Alchemy
           page.available_element_names.include?(ce.name)
         }
       end
-
-      private
-
-      def new_element_from_definition_by(attributes)
-        element_attributes = attributes.to_h.merge(name: attributes[:name].split('#').first)
-        element_definition = Element.definition_by_name(element_attributes[:name])
-        return if element_definition.nil?
-
-        new(element_definition.merge(element_attributes).except(*FORBIDDEN_DEFINITION_ATTRIBUTES))
-      end
     end
 
     # Returns next public element from same page.
@@ -235,17 +226,6 @@ module Alchemy
       position.nil?
     end
 
-    # The names of all cells from given page this element could be placed in.
-    #
-    def available_page_cell_names(page)
-      cellnames = unique_available_page_cell_names(page)
-      if cellnames.blank? || !page.has_cells?
-        ['for_other_elements']
-      else
-        cellnames
-      end
-    end
-
     # Returns true if the definition of this element has a taggable true value.
     def taggable?
       definition['taggable'] == true
@@ -256,6 +236,11 @@ module Alchemy
       !folded?
     end
 
+    # Defined as compact element?
+    def compact?
+      definition['compact'] == true
+    end
+
     # The element's view partial is dependent from its name
     #
     # == Define elements
@@ -298,31 +283,26 @@ module Alchemy
       nested_elements.map do |nested_element|
         Element.copy(nested_element, {
           parent_element_id: target_element.id,
-          page_id: target_element.page_id,
-          cell_id: target_element.cell_id
+          page_id: target_element.page_id
         })
       end
     end
 
     private
 
-    def select_element(elements, name, order)
-      elements = elements.named(name) if name.present?
-      elements.reorder(position: order).limit(1).first
-    end
-
-    # Returns all cells from given page this element could be placed in.
-    #
-    def available_page_cells(page)
-      page.cells.select do |cell|
-        cell.available_elements.include?(name)
+    def generate_nested_elements
+      definition.fetch('autogenerate', []).each do |nestable_element|
+        if nestable_elements.include?(nestable_element)
+          Element.create(page: page, parent_element_id: id, name: nestable_element)
+        else
+          log_warning("Element '#{nestable_element}' not a nestable element for '#{name}'. Skipping!")
+        end
       end
     end
 
-    # Returns all uniq cell names from given page this element could be placed in.
-    #
-    def unique_available_page_cell_names(page)
-      available_page_cells(page).collect(&:name).uniq
+    def select_element(elements, name, order)
+      elements = elements.named(name) if name.present?
+      elements.reorder(position: order).limit(1).first
     end
 
     # Updates all +touchable_pages+

data/app/models/alchemy/element/element_contents.rb

@@ -139,8 +139,8 @@ module Alchemy
 
     # creates the contents for this element as described in the elements.yml
     def create_contents
-      definition.fetch("contents", []).each do |content_hash|
-        Content.create_from_scratch(self, content_hash)
+      definition.fetch('contents', []).each do |attributes|
+        Content.create(attributes.merge(element: self))
       end
     end
   end

data/app/models/alchemy/page.rb

@@ -43,7 +43,7 @@ module Alchemy
     include Alchemy::Taggable
 
     DEFAULT_ATTRIBUTES_FOR_COPY = {
-      do_not_autogenerate: true,
+      autogenerate_elements: false,
       visible: false,
       public_on: nil,
       public_until: nil,
@@ -130,7 +130,6 @@ module Alchemy
     include Alchemy::Page::PageNatures
     include Alchemy::Page::PageNaming
     include Alchemy::Page::PageUsers
-    include Alchemy::Page::PageCells
     include Alchemy::Page::PageElements
 
     # site_name accessor
@@ -188,7 +187,6 @@ module Alchemy
         page = Alchemy::Page.new(attributes_from_source_for_copy(source, differences))
         page.tag_list = source.tag_list
         if page.save!
-          copy_cells(source, page)
           copy_elements(source, page)
           page
         end
@@ -206,7 +204,7 @@ module Alchemy
           name: "Layoutroot for #{language.name}",
           layoutpage: true,
           language: language,
-          do_not_autogenerate: true,
+          autogenerate_elements: false,
           parent_id: Page.root.id
         )
       end
@@ -291,6 +289,38 @@ module Alchemy
     # Instance methods
     #
 
+    # Returns elements from page.
+    #
+    # @option options [Array<String>|String] :only
+    #   Returns only elements with given names
+    # @option options [Array<String>|String] :except
+    #   Returns all elements except the ones with given names
+    # @option options [Integer] :count
+    #   Limit the count of returned elements
+    # @option options [Integer] :offset
+    #   Starts with an offset while returning elements
+    # @option options [Boolean] :include_hidden (false)
+    #   Return hidden elements as well
+    # @option options [Boolean] :random (false)
+    #   Return elements randomly shuffled
+    # @option options [Boolean] :reverse (false)
+    #   Reverse the load order
+    # @option options [Class] :finder (Alchemy::ElementsFinder)
+    #   A class that will return elements from page.
+    #   Use this for your custom element loading logic.
+    #
+    # @return [ActiveRecord::Relation]
+    def find_elements(options = {}, show_non_public = false)
+      if show_non_public
+        Alchemy::Deprecation.warn "Passing true as second argument to page#find_elements to include" \
+          " invisible elements has been removed. Please implement your own ElementsFinder" \
+          " and pass it with options[:finder]."
+      end
+
+      finder = options[:finder] || Alchemy::ElementsFinder.new(options)
+      finder.elements(page: self)
+    end
+
     # The page's view partial is dependent from its page layout
     #
     # == Define page layouts

data/app/models/alchemy/page/page_elements.rb

@@ -5,14 +5,22 @@ module Alchemy
     extend ActiveSupport::Concern
 
     included do
-      attr_accessor :do_not_autogenerate
+      attr_accessor :autogenerate_elements
 
-      has_many :elements, -> { where(parent_element_id: nil).not_trashed.order(:position) }
+      has_many :elements,
+        -> { order(:position).not_nested.unfixed.not_trashed },
+        class_name: 'Alchemy::Element'
+      has_many :elements_including_fixed,
+        -> { order(:position).not_nested.not_trashed },
+        class_name: 'Alchemy::Element'
       has_many :trashed_elements,
         -> { Element.trashed.order(:position) },
         class_name: 'Alchemy::Element'
+      has_many :fixed_elements,
+        -> { order(:position).fixed.not_trashed },
+        class_name: 'Alchemy::Element'
       has_many :descendent_elements,
-        -> { order(:position).not_trashed },
+        -> { order(:position).unfixed.not_trashed },
         class_name: 'Alchemy::Element'
       has_many :contents, through: :elements
       has_many :descendent_contents,
@@ -23,12 +31,13 @@ module Alchemy
         class_name: 'Alchemy::Element',
         join_table: ElementToPage.table_name
 
-      after_create :autogenerate_elements, unless: -> { systempage? || do_not_autogenerate }
+      after_create :generate_elements,
+        unless: -> { systempage? || autogenerate_elements == false }
 
       after_update :trash_not_allowed_elements!,
         if: :has_page_layout_changed?
 
-      after_update :autogenerate_elements,
+      after_update :generate_elements,
         if: :has_page_layout_changed?
     end
 
@@ -41,15 +50,10 @@ module Alchemy
       #
       def copy_elements(source, target)
         new_elements = []
-        source.elements.not_trashed.each do |source_element|
-          cell = nil
-          if source_element.cell
-            cell = target.cells.find_by(name: source_element.cell.name)
-          end
-          new_element = Element.copy source_element, {
-            page_id: target.id,
-            cell_id: cell.try(:id)
-          }
+        source.elements_including_fixed.each do |source_element|
+          new_element = Element.copy(source_element, {
+            page_id: target.id
+          })
           new_element.move_to_bottom
           new_elements << new_element
         end
@@ -57,46 +61,6 @@ module Alchemy
       end
     end
 
-    # Finds elements of page.
-    #
-    # @param [Hash]
-    #   options hash
-    # @param [Boolean] (false)
-    #   Pass true, if you want to also have not published elements.
-    #
-    # @option options [Array] only
-    #   Returns only elements with given names
-    # @option options [Array] except
-    #   Returns all elements except the ones with given names
-    # @option options [Fixnum] count
-    #   Limit the count of returned elements
-    # @option options [Fixnum] offset
-    #   Starts with an offset while returning elements
-    # @option options [Boolean] random (false)
-    #   Return elements randomly shuffled
-    # @option options [Alchemy::Cell || String] from_cell
-    #   Return elements from given cell
-    #
-    # @return [ActiveRecord::Relation]
-    #
-    def find_elements(options = {}, show_non_public = false)
-      elements = elements_from_cell_or_self(options[:from_cell])
-      if options[:only].present?
-        elements = elements.named(options[:only])
-      elsif options[:except].present?
-        elements = elements.excluded(options[:except])
-      end
-      if options[:reverse_sort] || options[:reverse]
-        elements = elements.reverse_order
-      end
-      elements = elements.offset(options[:offset]).limit(options[:count])
-      if options[:random]
-        elements = elements.order("RAND()")
-      end
-      show_non_public ? elements : elements.published
-    end
-    alias_method :find_selected_elements, :find_elements
-
     # All available element definitions that can actually be placed on current page.
     #
     # It extracts all definitions that are unique or limited and already on page.
@@ -127,7 +91,7 @@ module Alchemy
 
       return [] if @_element_definitions.blank?
 
-      @_existing_element_names = elements.not_trashed.pluck(:name)
+      @_existing_element_names = elements_including_fixed.pluck(:name)
       delete_unique_element_definitions!
       delete_outnumbered_element_definitions!
 
@@ -172,26 +136,20 @@ module Alchemy
       definitions.uniq { |d| d['name'] }
     end
 
-    # All names of elements that are defined in the corresponding
-    # page and cell definition.
+    # All names of elements that are defined in the page definition.
     #
-    # Assign elements to a page in +config/alchemy/page_layouts.yml+ and/or
-    # +config/alchemy/cells.yml+ file.
+    # Assign elements to a page in +config/alchemy/page_layouts.yml+.
     #
     # == Example of page_layouts.yml:
     #
     #   - name: contact
-    #     cells: [right_column]
     #     elements: [headline, contactform]
     #
-    # == Example of cells.yml:
-    #
-    #   - name: right_column
-    #     elements: [teaser]
-    #
     def element_definition_names
-      element_names_from_definition | element_names_from_cell_definitions
+      definition['elements'] || []
     end
+    alias_method :element_names_from_definition, :element_definition_names
+    deprecate element_names_from_definition: :element_definition_names, deprecator: Alchemy::Deprecation
 
     # Element definitions with given name(s)
     #
@@ -231,43 +189,17 @@ module Alchemy
         .collect(&:id)
     end
 
-    def element_names_from_definition
-      definition['elements'] || []
-    end
-
     private
 
-    def element_names_from_cell_definitions
-      @_element_names_from_cell_definitions ||= cell_definitions.map do |d|
-        d['elements']
-      end.flatten
-    end
-
     # Looks in the page_layout descripion, if there are elements to autogenerate.
     #
     # And if so, it generates them.
     #
-    # If the page has cells, it looks if there are elements to generate.
-    #
-    def autogenerate_elements
-      elements_already_on_page = elements.available.pluck(:name)
-      elements = definition["autogenerate"]
-      if elements.present?
-        elements.each do |element|
-          next if elements_already_on_page.include?(element)
-          Element.create_from_scratch(attributes_for_element_name(element))
-        end
-      end
-    end
-
-    # Returns a hash of attributes for given element name
-    def attributes_for_element_name(element)
-      element_cell_definition = cell_definitions.detect { |c| c['elements'].include?(element) }
-      if has_cells? && element_cell_definition
-        cell = cells.find_by!(name: element_cell_definition['name'])
-        {page_id: id, cell_id: cell.id, name: element}
-      else
-        {page_id: id, name: element}
+    def generate_elements
+      elements_already_on_page = elements_including_fixed.pluck(:name)
+      definition.fetch('autogenerate', []).each do |element_name|
+        next if elements_already_on_page.include?(element_name)
+        Element.create(page: self, name: element_name)
       end
     end
 
@@ -275,7 +207,7 @@ module Alchemy
     def trash_not_allowed_elements!
       not_allowed_elements = elements.where([
         "#{Element.table_name}.name NOT IN (?)",
-        element_names_from_definition
+        element_definition_names
       ])
       not_allowed_elements.to_a.map(&:trash!)
     end
@@ -304,29 +236,5 @@ module Alchemy
         element['amount'] && outnumbered.count >= element['amount'].to_i
       end
     end
-
-    # Returns elements either from given cell or self
-    #
-    def elements_from_cell_or_self(cell)
-      case cell.class.name
-      when 'Alchemy::Cell'
-        cell.elements
-      when 'String'
-        cell_elements_by_name(cell)
-      else
-        elements.not_in_cell
-      end
-    end
-
-    # Returns all elements from given cell name
-    #
-    def cell_elements_by_name(name)
-      if cell = cells.find_by_name(name)
-        cell.elements
-      else
-        Alchemy::Logger.warn("Cell with name `#{name}` could not be found!", caller(0..0))
-        Element.none
-      end
-    end
   end
 end