alchemy_cms 2.1.beta1 → 2.1.beta5

data/app/mailers/messages.rb

@@ -1,15 +0,0 @@
-class Messages < ActionMailer::Base
-  
-  default :from => Alchemy::Config.get(:mailer)[:mail_from]
-  
-  def contact_form_mail(message, mail_to, mail_from, subject)
-    @message = message
-    mail(
-      :from => mail_from,
-      :to => mail_to,
-      :reply_to => message.email,
-      :subject => subject
-    )
-  end
-  
-end

data/app/mailers/notifications.rb

@@ -1,23 +0,0 @@
-class Notifications < ActionMailer::Base
-  
-  default :from => Alchemy::Config.get(:mailer)[:mail_from]
-  
-  def registered_user_created(user)
-    @user = user
-    @url = login_url
-    mail(
-      :to => user.email,
-      :subject => I18n.t("alchemy.mailer.new_user_mail.subject")
-    )
-  end
-  
-  def admin_user_created(user)
-    @user = user
-    @url = admin_url
-    mail(
-      :to => user.email,
-      :subject => _("Your Alchemy Login")
-    )
-  end
-  
-end

data/app/models/attachment.rb

@@ -1,80 +0,0 @@
-class Attachment < ActiveRecord::Base
-
-  stampable
-
-  has_attachment(
-    :storage => :file_system,
-    :file_system_path => 'uploads/attachments',
-    :size => 0.kilobytes..1000.megabytes
-  )
-  validates_as_attachment
-
-  def name
-    read_attribute(:name).split('.').first
-  end
-
-  def extension
-    filename.split(".").last
-  end
-  alias_method :suffix, :extension
-
-  def icon_css_class
-    case content_type
-    when "application/x-flash-video"
-      then "video"
-    when "video/x-flv"
-      then "video"
-    when "video/mp4"
-      then "video"
-    when "video/mpeg"
-      then "video"
-    when "video/quicktime"
-      then "video"
-    when "video/x-msvideo"
-      then "video"
-    when "video/x-ms-wmv"
-      then "video"
-    when "application/zip"
-      then "archive"
-    when "application/x-rar"
-      then "archive"
-    when "audio/mpeg"
-      then "audio"
-    when "audio/mp4"
-      then "audio"
-    when "audio/wav"
-      then "audio"
-    when "audio/x-wav"
-      then "audio"
-    when "application/x-shockwave-flash"
-      then "flash"
-    when "image/gif"
-      then "image"
-    when "image/jpeg"
-      then "image"
-    when "image/png"
-      then "image"
-    when "image/tiff"
-      then "image"
-    when "image/x-psd"
-      then "psd"
-    when "text/plain"
-      then "text"
-    when "application/rtf"
-      then "rtf"
-    when "application/pdf"
-      then "pdf"
-    when "application/msword"
-      then "word"
-    when "application/vnd.ms-excel"
-      then "excel"
-    when "text/x-vcard"
-      then "vcard"
-    when "application/vcard"
-      then "vcard"
-    else
-      "file"
-    end
-  end
-
-end

data/app/models/cell.rb

@@ -1,59 +0,0 @@
-# A cell is a group of elements that are rendered inside a specific area on your page_layout.
-# Think of it like a column, or section in your layout. I.e. a header or right column.
-# 
-# Elements are displayed in tabs inside the elements window in page edit view.
-# Every cell is a list of elements with the position scoped to +cell_id+ and +page_id+.
-# 
-# Define cells inside a +cells.yml+ file located in the +config/alchermy+ folder of your project.
-# 
-# Render cells with the +render_cell+ helper
-# 
-# Views for cells are inside the +app/views/cells+ folder in you project.
-# 
-class Cell < ActiveRecord::Base
-  
-  belongs_to :page
-  has_many :elements, :dependent => :destroy, :order => :position
-  
-  def self.definitions
-    cell_yml = File.join(Rails.root, 'config', 'alchemy', 'cells.yml')
-    YAML.load_file(cell_yml) if File.exist?(cell_yml)
-  end
-  
-  def self.definition_for(cellname)
-    return nil if cellname.blank?
-    definitions.detect { |c| c['name'] == cellname }
-  end
-  
-  def self.all_definitions_for(cellnames)
-    definitions.select { |c| cellnames.include? c['name'] }
-  end
-  
-  def self.all_element_definitions_for(cellnames)
-    element_names = []
-    all_definitions_for(cellnames).each do |cell|
-      element_names += cell['elements']
-    end
-    Element.all_definitions_for(element_names.uniq)
-  end
-  
-  def self.definitions_for_element(element_name)
-    return [] if definitions.blank?
-    definitions.select { |d| d['elements'].include?(element_name) }
-  end
-  
-  def self.names_for_element(element_name)
-    definitions = definitions_for_element(element_name)
-    return nil if definitions.blank?
-    definitions.collect { |d| d['name'] }
-  end
-  
-  def name_for_label
-    self.class.translated_label_for(self.name)
-  end
-  
-  def self.translated_label_for(cell_name)
-    I18n.t("alchemy.cell_names.#{cell_name}", :default => cell_name.camelcase)
-  end
-  
-end

data/app/models/content.rb

@@ -1,145 +0,0 @@
-class Content < ActiveRecord::Base
-
-  belongs_to :essence, :polymorphic => true, :dependent => :destroy
-  belongs_to :element
-  stampable :stamper_class_name => :user
-  acts_as_list
-  
-  def scope_condition
-    "element_id = '#{element_id}' AND essence_type = '#{essence_type}'"
-  end
-  
-  validates_uniqueness_of :position, :scope => [:element_id, :essence_type]
-  
-  # Creates a new Content as descriped in the elements.yml file
-  def self.create_from_scratch(element, essences_hash)
-    if essences_hash[:name].blank? && !essences_hash[:essence_type].blank?
-      essences_of_same_type = element.contents.find_all_by_essence_type(essences_hash[:essence_type])
-      description = {
-        'type' => essences_hash[:essence_type],
-        'name' => "#{essences_hash[:essence_type].underscore}_#{essences_of_same_type.length + 1}"
-      }
-    else
-      description = element.content_description_for(essences_hash[:name])
-      description = element.available_content_description_for(essences_hash[:name]) if description.blank?
-    end
-    raise "No description found in elements.yml for #{essences_hash.inspect} and #{element.inspect}" if description.blank?
-    essence_class = ObjectSpace.const_get(description['type'])
-    content = self.new(:name => description['name'], :element_id => element.id)
-    if description['type'] == "EssenceRichtext" || description['type'] == "EssenceText"
-      essence = essence_class.create(:do_not_index => !description['do_not_index'].nil?)
-    else
-      essence = essence_class.create
-    end
-    if essence
-      content.essence = essence
-      content.save
-    else
-      content = nil
-    end
-    return content
-  end
-  
-  # Settings from the elements.yml definition
-  def settings
-    return {} if description.blank?
-    settings = description['settings']
-    return {} if settings.blank?
-    settings.symbolize_keys
-  end
-  
-  # makes a copy of source and copies the polymorphic associated essence
-  def self.copy(source, differences = {})
-    differences[:position] = nil
-    differences[:id] = nil
-    attributes = source.attributes.merge(differences)
-    content = self.create!(attributes.except("id"))
-    new_essence = content.essence.clone
-    new_essence.save
-    content.essence_id = new_essence.id
-    content
-  end
-  
-  # Returns my description hash from elements.yml
-  # Returns the description from available_contents if my own description is blank
-  def description
-    if self.element.blank?
-      logger.warn("\n+++++++++++ Warning: Content with id #{self.id} is missing its Element\n")
-      return nil
-    else
-      desc = self.element.content_description_for(self.name)
-      if desc.blank?
-        desc = self.element.available_content_description_for(self.name)
-      else
-        return desc
-      end
-    end
-  end
-  
-  # Gets the ingredient from essence
-  def ingredient
-    return nil if self.essence.nil?
-    self.essence.ingredient
-  end
-  
-  # Calls essence.save_ingredient. Called from ElementController#update for each content in element.
-  # Adding errors if essence validation fails.
-  def save_essence(params, options = {})
-    if essence.save_ingredient(params, options)
-      return true
-    else
-      errors.add(:base, :essence_validation_failed)
-      return false
-    end
-  end
-  
-  def essence_validation_failed?
-    !essence.essence_errors.blank?
-  end
-  
-  def has_validations?
-    return false if description.blank?
-    !description['validate'].blank?
-  end
-  
-  # Returns a string to be passed to Rails form field tags to ensure we have same params layout everywhere.
-  # 
-  # Example:
-  # ========
-  # 	<%= text_field_tag content.form_field_name, content.ingredient %>
-  # 
-  # Options:
-  # ========
-  # You can pass an Essence column_name. Default is self.essence.ingredient_column
-  # 
-  # Example:
-  # =======
-  # 	<%= text_field_tag content.form_field_name(:link), content.ingredient %>
-  # 
-  def form_field_name(essence_column = self.essence.ingredient_column)
-    "contents[content_#{self.id}][#{essence_column}]"
-  end
-  
-  def form_field_id(essence_column = self.essence.ingredient_column)
-    "contents_content_#{self.id}_#{essence_column}"
-  end
-  
-  # Returns the translated name for displaying in labels, etc.
-  def name_for_label
-    self.class.translated_label_for(self.name, self.element.name)
-  end
-  
-  # Translates a name from string. Optional: pass an element_name to namespacing.
-  def self.translated_label_for(content_name, element_name = nil)
-    if element_name.blank?
-      I18n.t("alchemy.content_names.#{content_name}", :default => content_name.capitalize)
-    else
-      I18n.t("alchemy.content_names.#{element_name}.#{content_name}", :default => ["alchemy.content_names.#{content_name}".to_sym, content_name.capitalize])
-    end
-  end
-  
-  def linked?
-    essence && !essence.link.blank?
-  end
-  
-end

data/app/models/element.rb

@@ -1,476 +0,0 @@
-class Element < ActiveRecord::Base
-  
-  # All Elements inside a cell are a list. All Elements not in cell are in the cell_id.nil list.
-  acts_as_list :scope => [:page_id, :cell_id]
-  stampable :stamper_class_name => :user
-  
-  has_many :contents, :order => :position, :dependent => :destroy
-  belongs_to :cell
-  belongs_to :page
-  has_and_belongs_to_many :to_be_sweeped_pages, :class_name => 'Page', :uniq => true
-  
-  validates_uniqueness_of :position, :scope => [:page_id, :cell_id]
-  validates_presence_of :name, :on => :create, :message => N_("Please choose an element.")
-  
-  attr_accessor :create_contents_after_create
-  after_create :create_contents, :unless => Proc.new { |m| m.create_contents_after_create == false }
-  
-  # TODO: add a trashed column to elements table
-  scope :trashed, where(:page_id => nil).order('updated_at DESC')
-  scope :not_trashed, where('`elements`.`page_id` IS NOT NULL')
-  scope :published, where(:public => true)
-  scope :named, lambda { |names| where(arel_table[:name].in(names)) }
-  scope :excluded, lambda { |names| where(arel_table[:name].not_in(names)) }
-
-  # Returns next Element on self.page or nil. Pass a Element.name to get next of this kind.
-  def next(name = nil)
-    if name.nil?
-      find_conditions = ["public = 1 AND page_id = ? AND position > ?", self.page.id, self.position]
-    else
-      find_conditions = ["public = 1 AND page_id = ? AND name = ? AND position > ?", self.page.id, name, self.position]
-    end
-    self.class.where(find_conditions).order("position ASC").limit(1)
-  end
-  
-  # Returns previous Element on self.page or nil. Pass a Element.name to get previous of this kind.
-  def prev(name = nil)
-    if name.nil?
-      find_conditions = ["public = 1 AND page_id = ? AND position < ?", self.page.id, self.position]
-    else
-      find_conditions = ["public = 1 AND page_id = ? AND name = ? AND position < ?", self.page.id, name, self.position]
-    end
-    self.class.where(find_conditions).order("position DESC").limit(1)
-  end
-
-  # Stores the page into `to_be_sweeped_pages` (Pages that have to be sweeped after updating element).
-  def store_page(page)
-    return true if page.nil?
-    unless self.to_be_sweeped_pages.include? page
-      self.to_be_sweeped_pages << page
-      self.save
-    end
-  end
-
-  # nullifies the page_id aka. trashs it.
-  def trash
-		self.attributes = {
-			:page_id => nil,
-			:cell_id => nil,
-			:folded => true,
-			:public => false
-		}
-		# If we validate the element, it will not get trashed if another element with same postion is already trashed.
-		# And we cannot remove the position, because it will not be reordered in the list if its position is nil.
-		self.remove_from_list
-  end
-  
-  def trashed?
-    page_id.nil?
-  end
-  
-  def content_by_name(name)
-    self.contents.find_by_name(name)
-  end
-
-  def content_by_type(essence_type)
-    self.contents.find_by_essence_type(essence_type)
-  end
-
-  def all_contents_by_name(name)
-    self.contents.find_all_by_name(name)
-  end
-
-  def all_contents_by_type(essence_type)
-    self.contents.find_all_by_essence_type(essence_type)
-  end
-
-	# Returns the content that is marked as rss title.
-	# 
-	# Mark a content as rss title in your +elements.yml+ file:
-	# 
-	#   - name: news
-	#     contents:
-	#     - name: headline
-	#       type: EssenceText
-	#       rss_title: true
-	# 
-	def content_for_rss_title
-		rss_title = content_descriptions.detect { |c| c['rss_title'] }
-		contents.find_by_name(rss_title['name'])
-	end
-
-	# Returns the content that is marked as rss description.
-	# 
-	# Mark a content as rss description in your +elements.yml+ file:
-	# 
-	#   - name: news
-	#     contents:
-	#     - name: body
-	#       type: EssenceRichtext
-	#       rss_description: true
-	# 
-	def content_for_rss_description
-		rss_title = content_descriptions.detect { |c| c['rss_description'] }
-		contents.find_by_name(rss_title['name'])
-	end
-
-  # Inits a new element for page as described in /config/alchemy/elements.yml from element_name
-  def self.new_from_scratch(attributes)
-    attributes.stringify_keys!
-    return Element.new if attributes['name'].blank?
-    element_descriptions = Element.descriptions
-    return if element_descriptions.blank?
-    element_scratch = element_descriptions.select{ |m| m["name"] == attributes['name'].split('#').first }.first
-    element = Element.new(
-      element_scratch.except('contents', 'available_contents', 'display_name').merge({
-        :page_id => attributes['page_id']
-      })
-    )
-    element
-  end
-
-  # Inits a new element for page as described in /config/alchemy/elements.yml from element_name and saves it
-  def self.create_from_scratch(attributes)
-    element = Element.new_from_scratch(attributes)
-    element.save if element
-    return element
-  end
-
-  # pastes a element from the clipboard in the session to page
-  def self.paste_from_clipboard(page_id, element, method, position)
-    copy = self.copy(element, :page_id => page_id)
-    copy.insert_at(position)
-    if method == "move" && copy.valid?
-      element.destroy
-    end
-    copy
-  end
-
-  # Returns the descriptions from elements.yml file.
-  # Alchemy comes with its own elements.yml file. As so called standard set.
-  # Place a elements.yml file inside your apps config/alchemy folder to define
-  # your own set of elements
-  def self.descriptions
-    if File.exists? "#{Rails.root}/config/alchemy/elements.yml"
-			element_definitions = YAML.load_file( "#{Rails.root}/config/alchemy/elements.yml" )
-		end
-		if !element_definitions
-			if File.exists?(File.join(File.dirname(__FILE__), "../../config/alchemy/elements.yml"))
-				element_definitions = YAML.load_file( File.join(File.dirname(__FILE__), "../../config/alchemy/elements.yml") )
-			end
-		end
-		if !element_definitions
-			raise LoadError, "Could not find elements.yml file! Please run: rails generate alchemy:scaffold"
-		end
-		element_definitions
-  end
-  
-  def self.definitions
-    self.descriptions
-  end
-  
-  # 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']
-  end
-
-  # Returns the description for given content_name
-  def content_description_for(content_name)
-    if content_descriptions.blank?
-      logger.warn("\n+++++++++++ Warning: Element #{self.name} is missing the content description for #{content_name}\n")
-      return nil
-    else
-      content_descriptions.detect { |d| d['name'] == content_name }
-    end
-  end
-
-  # Returns the description 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
-    self.class.descriptions.detect{ |d| d['name'] == self.name }
-  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:
-  #     element_names:
-  #       contactform: 'Kontakt Formular'
-  # 
-  # If no translation is found the capitalized name is used!
-  # 
-  def display_name
-    return name.capitalize if description.blank?
-    I18n.t(description['name'], :scope => 'alchemy.element_names', :default => name.capitalize)
-  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}"
-  end
-
-  # List all elements by from page_layout
-  def self.elements_for_layout(layout)
-    element_descriptions = Element.descriptions
-    elements = []
-    page_layout = Alchemy::PageLayout.get(layout)
-    layout_elements = page_layout["elements"]
-    return element_descriptions if layout_elements == "all"
-    element_descriptions.each do |element|
-      if layout_elements.include?(element["name"])
-        elements << element
-      end
-    end
-    return elements
-  end
-
-  def self.get_from_clipboard(clipboard)
-    return nil if clipboard.blank?
-    self.find_by_id(clipboard[:element_id])
-  end
-
-  def self.all_from_clipboard(clipboard)
-    return [] if clipboard.nil?
-    self.find_all_by_id(clipboard.collect { |i| i[:id] })
-  end
-
-  def self.all_from_clipboard_for_page(clipboard, page)
-    return [] if clipboard.nil? || page.nil?
-    allowed_elements = self.all_for_page(page)
-    clipboard_elements = self.all_from_clipboard(clipboard)
-    allowed_element_names = allowed_elements.collect { |e| e['name'] }
-    clipboard_elements.select { |ce| allowed_element_names.include?(ce.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']
-  end
-
-  # Returns the contents ingredient for passed content name.
-  def ingredient(name)
-    content = content_by_name(name)
-    return nil if content.blank?
-    content.ingredient
-  end
-  
-  def has_ingredient?(name)
-    !self.ingredient(name).blank?
-  end
-  
-  def save_contents(params)
-    contents.each do |content|
-      unless content.save_essence(params[:contents]["content_#{content.id}"], :public => !params["public"].nil?)
-        errors.add(:base, :essence_validation_failed)
-      end
-    end
-    return errors.blank?
-  end
-  
-  def essences
-    return [] if contents.blank?
-    contents.collect(&:essence)
-  end
-  
-  # Returns all essence_errors in the format:
-  # 
-  #   {
-  #     essence.content.name => [error_message_for_validation_1, error_message_for_validation_2]
-  #   }
-  # 
-  # Get translated error messages with Element#essence_error_messages
-  #
-  def essence_errors
-    essence_errors = {}
-    essences.each do |essence|
-      unless essence.essence_errors.blank?
-        essence_errors[essence.content.name] = essence.essence_errors
-      end
-    end
-    essence_errors
-  end
-  
-  # Essence validation errors messages are translated via I18n.
-  # Inside your translation file add translations like:
-  # 
-  #   alchemy:
-  #     content_validations:
-  #       name_of_the_element:
-  #         name_of_the_content:
-  #           validation_error_type: Error Message
-  # 
-  # validation_error_type has to be one of:
-  # 
-  # * blank
-  # * taken
-  # * wrong_format
-  # 
-  # Example:
-  # 
-  #   de:
-  #     alchemy:
-  #       content_validations:
-  #         contact:
-  #           email:
-  #             wrong_format: 'Die Email hat nicht das richtige Format'
-  # 
-  def essence_error_messages
-    messages = []
-    essence_errors.each do |content_name, errors|
-      errors.each do |error|
-        messages << I18n.t(
-          "alchemy.content_validations.#{self.name}.#{content_name}.#{error}",
-          :default => [
-            "alchemy.content_validations.fields.#{content_name}.#{error}".to_sym,
-            "alchemy.content_validations.errors.#{error}".to_sym
-          ]
-        ) % {:field => Content.translated_label_for(content_name)}
-      end
-    end
-    messages
-  end
-  
-  def contents_with_errors
-    contents.select(&:essence_validation_failed?)
-  end
-  
-  def has_validations?
-    !contents.detect(&:has_validations?).blank?
-  end
-  
-  def rtf_contents
-    contents.select { |content| content.essence_type == 'EssenceRichtext' }
-  end
-  alias_method :richtext_contents, :rtf_contents
-  
-  # The name of the cell the element could be placed in.
-  def belonging_cellnames(page)
-    cellnames = Cell.names_for_element(name)
-    if cellnames.blank? || !page.has_cells?
-      return ['for_other_elements']
-    else
-      return cellnames
-    end
-  end
-  
-private
-  
-  # List all elements for page_layout
-  def self.all_for_page(page)
-    raise TypeError if page.class != Page
-    # if page_layout has cells, collect elements from cells and group them by cellname
-    page_layout = Alchemy::PageLayout.get(page.page_layout)
-    if page_layout.blank?
-      logger.warn "\n++++++\nWARNING! Could not find page_layout description for page: #{page.name}\n++++++++\n"
-      return []
-    end
-    elements_for_layout = []
-    elements_for_layout += all_definitions_for(page_layout['elements'])
-    return [] if elements_for_layout.blank?
-    # all unique elements from this layout
-    unique_elements = elements_for_layout.select{ |m| m["unique"] == true }
-    elements_already_on_the_page = page.elements
-    # delete all elements from the elements that could be placed that are unique and already and the page
-    unique_elements.each do |unique_element|
-      elements_already_on_the_page.each do |already_placed_element|
-        if already_placed_element.name == unique_element["name"]
-          elements_for_layout.delete(unique_element)
-        end
-      end
-    end
-    return elements_for_layout
-  end
-  
-  def self.all_definitions_for(element_names)
-    return [] if element_names.blank?
-    if element_names.to_s == "all"
-      return element_descriptions
-    else
-      return definitions.select { |e| element_names.include? e['name'] }
-    end
-  end
-
-  # makes a copy of source and makes copies of the contents from source
-  def self.copy(source, differences = {})
-    attributes = source.attributes.except("id").merge(differences)
-    element = self.create!(attributes.merge(:create_contents_after_create => false, :id => nil, :position => nil))
-    source.contents.each do |content|
-      new_content = Content.copy(content, :element_id => element.id)
-      new_content.move_to_bottom
-    end
-    element
-  end
-
-  # creates the contents for this element as described in the elements.yml
-  def create_contents
-    contents = []
-    if description["contents"].blank?
-      logger.warn "\n++++++\nWARNING! Could not find any content descriptions for element: #{self.name}\n++++++++\n"
-    else
-      description["contents"].each do |content_hash|
-        contents << Content.create_from_scratch(self, content_hash.symbolize_keys)
-      end
-    end
-  end
-
-end