alchemy_cms 2.6.3 → 2.7.0

data/app/models/alchemy/content/factory.rb

@@ -0,0 +1,188 @@
+module Alchemy
+
+  # Holds everything concerning the building and creating of contents and the related essence object.
+  #
+  module Content::Factory
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      SKIPPED_ATTRIBUTES_ON_COPY = %w(position created_at updated_at creator_id updater_id id)
+
+      # Builds a new content as descriped in the elements.yml file.
+      #
+      # @param [Alchemy::Element]
+      #   The element the content is for
+      # @param [Hash]
+      #   The content description used for finding the content in +elements.yml+ file
+      #
+      def build(element, essence_hash)
+        if (description = content_description(element, essence_hash)).blank?
+          raise ContentDefinitionError, "No description found in elements.yml for #{essence_hash.inspect} and #{element.inspect}"
+        else
+          new(name: description['name'], element_id: element.id)
+        end
+      end
+
+      # Creates a new content from elements description in the +elements.yml+ file.
+      #
+      # 1. It builds the content
+      # 2. It creates the essence record (content object gets saved)
+      #
+      # @return [Alchemy::Content]
+      #
+      def create_from_scratch(element, essence_hash)
+        essence_hash.stringify_keys!
+        if content = build(element, essence_hash)
+          content.create_essence!(essence_hash['essence_type'])
+        end
+        content
+      end
+
+      # Makes a copy of source and also copies the associated essence.
+      #
+      # You can pass a differences hash to update the attributes of the copy.
+      #
+      # === Example
+      #
+      #   @copy = Alchemy::Content.copy(@content, {:element_id => 3})
+      #   @copy.element_id # => 3
+      #
+      def copy(source, differences = {})
+        attributes = source.attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY).merge(differences.stringify_keys)
+        content = self.create!(attributes)
+        new_essence = content.essence.class.new(content.essence.attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY))
+        new_essence.save!
+        raise "Essence not cloned" if new_essence.id == content.essence_id
+        content.update_attributes(essence_id: new_essence.id)
+        content
+      end
+
+      # Returns the content description for building a content.
+      #
+      # 1. It looks in the element's contents description
+      # 2. It builds a description hash from essence type, if the the name key is not present
+      #
+      def content_description(element, essence_hash)
+        essence_hash.stringify_keys!
+        # No name given. We build the content from essence type.
+        if essence_hash['name'].blank? && essence_hash['essence_type'].present?
+          content_description_from_essence_type(element, essence_hash['essence_type'])
+        else
+          content_description_from_element(element, essence_hash['name'])
+        end
+      end
+
+      # Returns a hash for building a content from essence type.
+      #
+      # @param [Alchemy::Element]
+      #   The element the content is for.
+      # @param [String]
+      #   The essence type the content is from
+      #
+      def content_description_from_essence_type(element, essence_type)
+        {
+          'type' => essence_type,
+          'name' => content_name_from_element_and_essence_type(element, essence_type)
+        }
+      end
+
+      # A name for content from its essence type and amount of same essences in element.
+      #
+      # Example:
+      #
+      #   essence_picture_1
+      #
+      def content_name_from_element_and_essence_type(element, essence_type)
+        essences_of_same_type = element.contents.where(essence_type: normalize_essence_type(essence_type))
+        "#{essence_type.classify.demodulize.underscore}_#{essences_of_same_type.count + 1}"
+      end
+
+      # Returns the content description hash from element.
+      #
+      # It first uses the normal content description described in the +elements.yml+ +contents+ array.
+      #
+      # If the content description could not be found it tries to load it from +available_contents+ array.
+      #
+      # @param [Alchemy::Element]
+      #   The element instance the content is for
+      # @param [String]
+      #   The name of the content
+      #
+      def content_description_from_element(element, name)
+        element.content_description_for(name) ||
+          element.available_content_description_for(name)
+      end
+
+      # Returns all content descriptions from elements.yml
+      #
+      def descriptions
+        Element.descriptions.collect { |e| e['contents'] }.flatten.compact
+      end
+
+      # Returns a normalized Essence type
+      #
+      # Adds Alchemy module name in front of given essence type
+      #
+      # @param [String]
+      #   the essence type to normalize
+      #
+      def normalize_essence_type(essence_type)
+        essence_type = essence_type.classify
+        if essence_type.match(/^Alchemy::/)
+          essence_type
+        else
+          essence_type.gsub!(/^Essence/, 'Alchemy::Essence')
+        end
+      end
+
+    end # end class methods
+
+    # Instance Methods
+
+    # Returns the description hash from +elements.yml+ file.
+    #
+    def description
+      if element.blank?
+        log_warning "Content with id #{self.id} is missing its Element."
+        return {}
+      end
+      Content.content_description_from_element(element, name) || {}
+    end
+    alias_method :definition, :description
+
+    # Creates essence from description.
+    #
+    # If an optional type is passed, this type of essence gets created.
+    #
+    def create_essence!(type = nil)
+      self.essence = essence_class(type).create!(prepared_attributes_for_essence)
+      self.save!
+    end
+
+  private
+
+    # Returns a class constant from description's type field.
+    #
+    # If an optional type is passed, this type of essence gets constantized.
+    #
+    def essence_class(type = nil)
+      Content.normalize_essence_type(type || description['type']).constantize
+    end
+
+    # Prepares the attributes for creating the essence.
+    #
+    # 1. It sets a default text if given in +elements.yml+
+    # 2. It sets do_not_index value for EssenceText and EssenceRichtext essences
+    #
+    def prepared_attributes_for_essence
+      attributes = {
+        ingredient: default_text(description['default'])
+      }
+      if description['type'] == "EssenceRichtext" || description['type'] == "EssenceText"
+        attributes.merge!(do_not_index: !!description['do_not_index'])
+      end
+      attributes
+    end
+
+  end
+end

data/app/models/alchemy/element.rb

@@ -1,3 +1,7 @@
+require 'acts-as-taggable-on'
+require 'userstamp'
+require 'acts_as_list'
+
 module Alchemy
   class Element < ActiveRecord::Base
     include Logger
@@ -24,7 +28,7 @@ module Alchemy
 
     has_many :contents, :order => :position, :dependent => :destroy
     belongs_to :cell
-    belongs_to :page
+    belongs_to :page, touch: true
     has_and_belongs_to_many :to_be_sweeped_pages, :class_name => 'Alchemy::Page', :uniq => true, :join_table => 'alchemy_elements_alchemy_pages'
 
     validates_uniqueness_of :position, :scope => [:page_id, :cell_id], :if => lambda { |e| e.position != nil }
@@ -49,6 +53,10 @@ module Alchemy
     # TODO: add this as default_scope
     #default_scope { from_current_site }
 
+    # Concerns
+    include Definitions
+    include Presenters
+
     # class methods
     class << self
 
@@ -56,14 +64,13 @@ module Alchemy
       def new_from_scratch(attributes)
         attributes = attributes.dup.symbolize_keys
         return new if attributes[:name].blank?
-        return nil if descriptions.blank?
+        return nil if definitions.blank?
         # clean the name from cell name
         attributes[:name] = attributes[:name].split('#').first
-        element_scratch = descriptions.detect { |el| el['name'] == attributes[:name] }
-        if element_scratch
+        if element_scratch = definitions.detect { |el| el['name'] == attributes[:name] }
           new(element_scratch.merge(attributes).except(*FORBIDDEN_DEFINITION_ATTRIBUTES))
         else
-          raise ElementDefinitionError, "Element description for #{attributes[:name]} not found. Please check your elements.yml"
+          raise ElementDefinitionError, "Element definition for #{attributes[:name]} not found. Please check your elements.yml"
         end
       end
 
@@ -74,73 +81,6 @@ module Alchemy
         return element
       end
 
-      # Returns the descriptions from elements.yml file.
-      #
-      # Place a elements.yml file inside your apps config/alchemy folder to define
-      # your own set of elements
-      #
-      def descriptions
-        if ::File.exists? "#{::Rails.root}/config/alchemy/elements.yml"
-          ::YAML.load_file("#{::Rails.root}/config/alchemy/elements.yml") || []
-        else
-          raise LoadError, "Could not find elements.yml file! Please run: rails generate alchemy:scaffold"
-        end
-      rescue TypeError => e
-        warn "Your elements.yml is empty."
-        []
-      end
-      alias_method :definitions, :descriptions
-
-      # pastes a element from the clipboard in the session to page
-      def paste_from_clipboard(page_id, element, method, position)
-        element_copy = copy(element, :page_id => page_id)
-        element_copy.insert_at(position)
-        if method == "move" && element_copy.valid?
-          element.destroy
-        end
-        element_copy
-      end
-
-      # List all element definitions for +self.page#page_layout+
-      def all_for_page(page)
-        raise TypeError if page.class.name != "Alchemy::Page"
-        # if page_layout has cells, collect elements from cells and group them by cellname
-        page_layout = PageLayout.get(page.page_layout)
-        if page_layout.blank?
-          warn "Could not find page_layout description for page: #{page.name}"
-          return []
-        end
-        elements_for_layout = []
-        elements_for_layout += all_definitions_for(page_layout['elements'])
-        return [] if elements_for_layout.blank?
-        # all unique and limited elements from this layout
-        limited_elements = elements_for_layout.select{ |m| m["unique"] == true || (m["amount"] > 0 unless m["amount"].nil?) }
-        elements_already_on_the_page = page.elements.not_trashed
-        # delete all elements from the elements that could be placed that are unique or limited and already and the page
-        elements_counts = Hash.new(0)
-        elements_already_on_the_page.each { |e| elements_counts[e.name] += 1 }
-        limited_elements.each do |limited_element|
-          next if elements_counts[limited_element["name"]] == 0
-          if limited_element["unique"]
-            elements_for_layout.delete(limited_element) if elements_counts[limited_element["name"]] > 0
-            next
-          end
-          unless limited_element["amount"].nil?
-            elements_for_layout.delete(limited_element) if elements_counts[limited_element["name"]] >= limited_element["amount"]
-          end
-        end
-        elements_for_layout
-      end
-
-      def all_definitions_for(element_names)
-        return [] if element_names.blank?
-        if element_names.to_s == "all"
-          definitions
-        else
-          definitions.select { |e| element_names.include? e['name'] }
-        end
-      end
-
       # This methods does a copy of source and all depending contents and all of their depending essences.
       #
       # == Options
@@ -165,53 +105,36 @@ module Alchemy
         element
       end
 
-      # List all elements from page_layout
-      def elements_for_layout(layout)
-        elements = []
-        layout_elements = PageLayout.get(layout)["elements"]
-        return Element.descriptions if layout_elements == "all"
-        Element.descriptions.each do |element|
-          if layout_elements.include?(element["name"])
-            elements << element
-          end
-        end
-        elements
-      end
-
-      def get_from_clipboard(clipboard)
-        return nil if clipboard.blank?
-        find_by_id(clipboard[:element_id])
-      end
-
       def all_from_clipboard(clipboard)
         return [] if clipboard.nil?
-        find_all_by_id(clipboard.collect { |i| i[:id] })
+        find_all_by_id(clipboard.collect { |e| e[:id] })
       end
 
+      # All elements in clipboard that could be placed on page
+      #
       def all_from_clipboard_for_page(clipboard, page)
         return [] if clipboard.nil? || page.nil?
-        allowed_elements = all_for_page(page)
-        clipboard_elements = all_from_clipboard(clipboard)
-        allowed_element_names = allowed_elements.collect { |e| e['name'] }
-        clipboard_elements.select { |ce| allowed_element_names.include?(ce.name) }
+        all_from_clipboard(clipboard).select { |ce|
+          page.available_element_names.include?(ce.name)
+        }
       end
 
     end
 
     # Returns next public element from same page.
+    #
     # Pass an element name to get next of this kind.
+    #
     def next(name = nil)
-      elements = page.elements.published.where(Element.arel_table[:position].gt(position))
-      elements = elements.named(name) if name.present?
-      elements.reorder("position ASC").limit(1).first
+      previous_or_next('>', name)
     end
 
     # Returns previous public element from same page.
+    #
     # Pass an element name to get previous of this kind.
+    #
     def prev(name = nil)
-      elements = page.elements.published.where(Element.arel_table[:position].lt(position))
-      elements = elements.named(name) if name.present?
-      elements.reorder("position DESC").limit(1).first
+      previous_or_next('<', name)
     end
 
     # Stores the page into `to_be_sweeped_pages` (Pages that have to be sweeped after updating element).
@@ -265,9 +188,9 @@ module Alchemy
       contents.find_by_name(rss_title['name'])
     end
 
-    # Returns the content that is marked as rss description.
+    # Returns the content that is marked as rss definition.
     #
-    # Mark a content as rss description in your +elements.yml+ file:
+    # Mark a content as rss definition in your +elements.yml+ file:
     #
     #   - name: news
     #     contents:
@@ -282,114 +205,29 @@ module Alchemy
 
     # Returns the array with the hashes for all element contents in the elements.yml file
     def content_descriptions
-      return nil if description.blank?
-      description['contents']
-    end
-
-    # Returns the array with the hashes for all element available_contents in the elements.yml file
-    def available_content_descriptions
-      return nil if description.blank?
-      description['available_contents']
+      return nil if definition.blank?
+      definition['contents']
     end
 
-    # Returns the description for given content_name
+    # Returns the definition for given content_name
     def content_description_for(content_name)
       if content_descriptions.blank?
-        warn "Element #{self.name} is missing the content description for #{content_name}"
+        log_warning "Element #{self.name} is missing the content definition for #{content_name}"
         return nil
       else
         content_descriptions.detect { |d| d['name'] == content_name }
       end
     end
 
-    # Returns the description for given content_name inside the available_contents
+    # Returns the definition for given content_name inside the available_contents
     def available_content_description_for(content_name)
-      return nil if available_content_descriptions.blank?
-      available_content_descriptions.detect { |d| d['name'] == content_name }
-    end
-
-    # returns the description of the element with my name in element.yml
-    def description
-      description = self.class.descriptions.detect { |d| d['name'] == self.name }
-      if description.blank?
-        warn "Could not find element definition for #{self.name}. Please check your elements.yml!"
-        return {}
-      else
-        return description
-      end
-    end
-    alias_method :definition, :description
-
-    # Human name for displaying in selectboxes and element editor views.
-    # The name is beeing translated from elements name value as described in config/alchemy/elements.yml
-    #
-    # Translate the name in your config/locales language file. Example:
-    #
-    #   de:
-    #     alchemy:
-    #       element_names:
-    #         contactform: 'Kontakt Formular'
-    #
-    # If no translation is found a humanized name is used.
-    #
-    def display_name
-      return name.humanize if description.blank?
-      I18n.t(description['name'], scope: 'element_names', default: description['name'].to_s.humanize)
-    end
-
-    # Gets the preview text from the first Content found in the +elements.yml+ Element description file.
-    # You can flag a Content as +take_me_for_preview+ to take this as preview.
-    def preview_text(maxlength = 30)
-      return "" if description.blank?
-      my_contents = description["contents"]
-      return "" if my_contents.blank?
-      content_flagged_as_preview = my_contents.select { |a| a["take_me_for_preview"] }.first
-      if content_flagged_as_preview.blank?
-        content_to_take_as_preview = my_contents.first
-      else
-        content_to_take_as_preview = content_flagged_as_preview
-      end
-      preview_content = self.contents.select { |content| content.name == content_to_take_as_preview["name"] }.first
-      return "" if preview_content.blank? || preview_content.essence.blank?
-      text = preview_content.essence.preview_text(maxlength)
-      text.size > maxlength ? "#{text[0..maxlength]}..." : text
-    end
-
-    # Generates a preview text containing Element#display_name and Element#preview_text.
-    # It is displayed inside the head of the Element in the Elements.list overlay window from the Alchemy Admin::Page#edit view.
-    #
-    # === Example
-    #
-    # A Element described as:
-    #
-    #     - name: funky_element
-    #       display_name: Funky Element
-    #       contents:
-    #       - name: headline
-    #         type: EssenceText
-    #       - name: text
-    #         type EssenceRichtext
-    #         take_me_for_preview: true
-    #
-    # With "I want to tell you a funky story" as stripped_body for the EssenceRichtext Content produces:
-    #
-    #     Funky Element: I want to tell ...
-    #
-    # Options:
-    #
-    #     maxlength(integer). [Default 30] : Length of characters after the text will be cut off.
-    #
-    def display_name_with_preview_text(maxlength = 30)
-      "#{display_name}: #{preview_text(maxlength)}"
-    end
-
-    def dom_id
-      "#{name}_#{id}"
+      return nil if available_contents.blank?
+      available_contents.detect { |d| d['name'] == content_name }
     end
 
     # returns the collection of available essence_types that can be created for this element depending on its description in elements.yml
     def available_contents
-      description['available_contents']
+      definition['available_contents']
     end
 
     # Returns the contents ingredient for passed content name.
@@ -537,7 +375,7 @@ module Alchemy
 
     # Returns true if the definition of this element has a taggable true value.
     def taggable?
-      description['taggable'] == true
+      definition['taggable'] == true
     end
 
     def to_partial_path
@@ -589,14 +427,27 @@ module Alchemy
     # creates the contents for this element as described in the elements.yml
     def create_contents
       contents = []
-      if description["contents"].blank?
-        warn "Could not find any content descriptions for element: #{self.name}"
+      if definition["contents"].blank?
+        log_warning "Could not find any content descriptions for element: #{self.name}"
       else
-        description["contents"].each do |content_hash|
+        definition["contents"].each do |content_hash|
           contents << Content.create_from_scratch(self, content_hash.symbolize_keys)
         end
       end
     end
 
+    # Returns previous or next public element from same page.
+    #
+    # @param [String]
+    #   Pass '>' or '<' to find next or previous public element.
+    # @param [String]
+    #   Pass an element name to get previous of this kind.
+    #
+    def previous_or_next(dir, name = nil)
+      elements = page.elements.published.where("#{self.class.table_name}.position #{dir} #{position}")
+      elements = elements.named(name) if name.present?
+      elements.reorder("position #{dir == '>' ? 'ASC' : 'DESC'}").limit(1).first
+    end
+
   end
 end