alchemy_cms 2.0.pre2

data/app/helpers/elements_helper.rb

@@ -0,0 +1,2 @@
+module ElementsHelper
+end

data/app/helpers/errors_helper.rb

@@ -0,0 +1,37 @@
+module ErrorsHelper
+
+  def error_messages_for(*params)
+    options = params.extract_options!.symbolize_keys
+    if object = options.delete(:object)
+      objects = [object].flatten
+    else
+      objects = params.collect {|object_name| instance_variable_get("@#{object_name}") }.compact
+    end
+    count   = objects.inject(0) {|sum, object| sum + object.errors.length }
+    unless count.zero?
+      html = {}
+      [:id, :class].each do |key|
+        if options.include?(key)
+          value = options[key]
+          html[key] = value unless value.blank?
+        else
+          html[key] = 'errorExplanation'
+        end
+      end
+      options[:object_name] ||= params.first
+      options[:header_message] = I18n.t("activerecord.errors.template.header", {:count => count, :model => object.class.to_s.humanize}) unless options.include?(:header_message)
+      options[:message] ||= I18n.t('activerecord.errors.template.body') unless options.include?(:message)
+      error_messages = objects.map {|object| object.errors.collect{ |column,error| content_tag( :li, error ) } }
+
+      contents = ''
+      contents << content_tag(options[:header_tag] || :h2, options[:header_message]) unless options[:header_message].blank?
+      contents << content_tag(:p, options[:message]) unless options[:message].blank?
+      contents << content_tag(:ul, error_messages)
+
+      content_tag(:div, contents, html)
+    else
+      ''
+    end
+  end
+
+end

data/app/helpers/layout_helper.rb

@@ -0,0 +1,37 @@
+# These helper methods can be called in your template to set variables to be used in the layout
+# This module should be included in all views globally,
+# to do so you may need to add this line to your ApplicationController
+#   helper :layout
+module LayoutHelper
+  def title(page_title, show_title = true)
+    @content_for_title = page_title.to_s
+    @show_title = show_title
+  end
+
+  def show_title?
+    @show_title
+  end
+
+  def stylesheet(*args)
+    content_for(:stylesheets) { stylesheet_link_tag(*args.map(&:to_s)) }
+  end
+
+  def javascript(*args)
+    args = args.map { |arg| arg == :defaults ? arg : "/plugin_assets/alchemy/javascripts/" + arg.to_s }
+    content_for(:javascripts) { javascript_include_tag(*args) }
+  end
+
+  def merged_javascript(merged_set)
+    content_for(:merged_javascripts) { javascript_include_merged(merged_set) }
+  end
+
+  def new_asset_path_with_session_information(asset_type)
+    session_key = Rails.application.config.session_options[:key]
+    if asset_type == "picture"
+      admin_pictures_path(session_key => cookies[session_key], request_forgery_protection_token => form_authenticity_token, :format => :js)
+    elsif asset_type == "attachment"
+      admin_attachments_path(session_key => cookies[session_key], request_forgery_protection_token => form_authenticity_token, :format => :js)
+    end
+  end
+
+end

data/app/helpers/pages_helper.rb

@@ -0,0 +1,141 @@
+module PagesHelper
+
+  # DEPRICATED! Use Element.preview_text instead.
+  def get_preview_text element
+    element.preview_text
+  end
+
+  def render_classes classes=[]
+    s = classes.uniq.delete_if{|x| x == nil || x.blank?}.join(" ")
+    s.blank? ? "" : "class='#{s}'"
+  end
+
+  def picture_essence_caption(content)
+    return "" if content.nil?
+    return "" if content.essence.nil?
+    content.essence.caption
+  end
+
+  def alchemy_form_select(name, select_options, options={})
+    select "mail_data", name, select_options, :selected => (session[:mail_data][name.to_sym] rescue "")
+  end
+
+  def alchemy_form_input_field(name, options = {})
+    if options[:value].blank? && session[:mail_data].blank?
+      value = nil
+    elsif options[:value].blank? && !session[:mail_data].blank?
+      value = session[:mail_data][name.to_sym]
+    else
+      value = options[:value]
+    end
+    text_field("mail_data", name, {:value => value}.merge(options))
+  end
+
+  def alchemy_form_text_area(name, options={})
+    text_area "mail_data", name, :class => options[:class], :value => (session[:mail_data][name.to_sym] rescue "")
+  end
+
+  def alchemy_form_check_box(name, options={})
+    box = hidden_field_tag "mail_data[#{name}]", 0, :id => nil
+    box += check_box_tag("mail_data[#{name}]", 1, (session[:mail_data] && session[:mail_data][name.to_sym] == "1"))
+    box
+  end
+
+  def alchemy_form_label(element, name, options={})
+    label_tag "mail_data_#{name}", render_essence_view_by_name(element, name), options
+  end
+
+  def alchemy_form_reset_button(name, options={})
+    button_to_function(
+      name,
+      remote_function(
+        :url => {
+          :controller => "contact_form",
+          :action => "clear_session"
+        },
+        :before => %(
+          this.form.reset();
+          this.form.descendants().each(
+            function(d){
+              if ((d.type!='button') && (d.type!='submit') && (d.type!='hidden') && !d.disabled) {
+                d.value = '';
+                if (d.type == 'checkbox') {
+                  d.checked = false;
+                }
+              }
+            }
+          )
+        )
+      ),
+      options
+    )
+  end
+
+  # helper for language switching
+  def language_switches(options={})
+    default_options = {
+      :linkname => :name,
+      :spacer => "",
+      :link_to_public_child => configuration(:redirect_to_public_child),
+      :link_to_page_with_layout => nil,
+      :show_title => true,
+      :reverse => false,
+      :as_select_box => false
+    }
+    options = default_options.merge(options)
+    if multi_language?
+      languages = []
+      pages = (options[:link_to_public_child] == true) ? Page.language_roots : Page.public_language_roots
+      pages.each_with_index do |page, i|
+        if(options[:link_to_page_with_layout] != nil)
+          page_found_by_layout = Page.find_by_page_layout_and_language_id(options[:link_to_page_with_layout].to_s, page.language)
+        end
+        page = page_found_by_layout || page
+        page = (options[:link_to_public_child] ? (page.first_public_child.blank? ? nil : page.first_public_child) : nil) if !page.public?
+      
+        if !page.blank?
+          active = session[:language_id] == page.language.id
+          if options[:linkname]
+            if options[:linkname].to_sym == :code
+              linkname = page.language.code
+            else
+              linkname = I18n.t("alchemy.languages.#{page.language.code}.name", :default => page.language.name)
+            end
+          else
+            linkname = ""
+          end
+          if options[:as_select_box]
+            languages << [linkname, show_page_with_language_url(:urlname => page.urlname, :lang => page.language.code)]
+          else
+            languages << link_to(
+              "#{content_tag(:span, '', :class => "flag")}#{ content_tag(:span, linkname)}",
+              show_page_with_language_path(:urlname => page.urlname, :lang => page.language.code),
+              :class => "#{(active ? 'active ' : nil)}#{page.language.code} #{(i == 0) ? 'first' : (i==pages.length-1) ? 'last' : nil}",
+              :title => options[:show_title] ? I18n.t("alchemy.languages.#{page.language.code}.title", :default => page.language.name) : nil
+            )
+          end
+        end
+      end
+      languages.reverse! if options[:reverse]
+      if options[:as_select_box]
+        return select_tag(
+          'language',
+          options_for_select(
+            languages,
+            show_page_with_language_url(:urlname => @page.urlname, :lang => @page.language.code)
+          ),
+          :onchange => "window.location=this.value"
+        )
+      else
+        if options[:spacer].blank?
+          return languages
+        else
+          return languages.join(options[:spacer])
+        end
+      end
+    else
+      ""
+    end
+  end
+
+end

data/app/mailers/messages.rb

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

data/app/mailers/notifications.rb

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,73 @@
+require 'attachment_magic'
+
+class Attachment < ActiveRecord::Base
+
+  stampable
+
+  has_attachment(
+    :storage => :file_system,
+    :file_system_path => 'uploads/attachments',
+    :size => 0.kilobytes..1000.megabytes
+  )
+  validates_as_attachment
+
+  def extension
+    filename.split(".").last
+  end
+
+  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"
+    else
+      "file"
+    end
+  end
+
+end

data/app/models/cell.rb

@@ -0,0 +1,63 @@
+# 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.definition_for_element(element_name)
+    definitions_for_element(element_name).first
+  end
+  
+  def self.definitions_for_element(element_name)
+    return [] if definitions.blank?
+    definitions.select { |d| d['elements'].include?(element_name) }
+  end
+  
+  def self.name_for_element(element_name)
+    definition = definition_for_element(element_name)
+    return nil if definition.blank?
+    definition['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

@@ -0,0 +1,145 @@
+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 nil if description.blank?
+    settings = description['settings']
+    return nil 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.blank?
+    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