alchemy_cms 2.1.12 → 2.2.rc1

data/app/helpers/alchemy/admin/contents_helper.rb

@@ -1,81 +1,81 @@
 module Alchemy
-	module Admin
-		module ContentsHelper
+  module Admin
+    module ContentsHelper
 
-			include Alchemy::Admin::BaseHelper
+      include Alchemy::Admin::BaseHelper
 
-			# Returns a string for the id attribute of a html element for the given content
-			def content_dom_id(content)
-				return "" if content.nil?
-				if content.class == String
-					c = Content.find_by_name(content)
-					return "" if c.nil?
-				else
-					c = content
-				end
-				"#{c.essence_type.demodulize.underscore}_#{c.id}"
-			end
+      # Returns a string for the id attribute of a html element for the given content
+      def content_dom_id(content)
+        return "" if content.nil?
+        if content.class == String
+          c = Content.find_by_name(content)
+          return "" if c.nil?
+        else
+          c = content
+        end
+        "#{c.essence_type.demodulize.underscore}_#{c.id}"
+      end
 
-			# Renders the name of elements content or the default name defined in elements.yml
-			def render_content_name(content)
-				if content.blank?
-					warning('Element is nil')
-					return ""
-				else
-					content_name = content.name_for_label
-				end
-				if content.description.blank?
-					warning("Content #{content.name} is missing its description")
-					title = t("Warning: Content is missing its description.", :contentname => content.name)
-					content_name = %(<span class="warning icon" title="#{title}"></span>&nbsp;#{content_name}).html_safe
-				end
-				content.has_validations? ? "#{content_name}<span class='validation_indicator'>*</span>".html_safe : content_name
-			end
+      # Renders the name of elements content or the default name defined in elements.yml
+      def render_content_name(content)
+        if content.blank?
+          warning('Element is nil')
+          return ""
+        else
+          content_name = content.name_for_label
+        end
+        if content.description.blank?
+          warning("Content #{content.name} is missing its description")
+          title = t("Warning: Content is missing its description.", :contentname => content.name)
+          content_name = %(<span class="warning icon" title="#{title}"></span>&nbsp;#{content_name}).html_safe
+        end
+        content.has_validations? ? "#{content_name}<span class='validation_indicator'>*</span>".html_safe : content_name
+      end
 
-			# Renders a link to show the new content overlay
-			def render_new_content_link(element)
-				link_to_overlay_window(
-					render_icon('create') + t('add new content'),
-					alchemy.new_admin_element_content_path(element),
-					{
-						:size => '335x70',
-						:title => t('Select an content'),
-						:overflow => true
-					},
-					{
-						:id => "add_content_for_element_#{element.id}",
-						:class => 'small button with_icon new_content_link'
-					}
-				)
-			end
+      # Renders a link to show the new content overlay
+      def render_new_content_link(element)
+        link_to_overlay_window(
+          render_icon('create') + t('add new content'),
+          alchemy.new_admin_element_content_path(element),
+          {
+            :size => '335x70',
+            :title => t('Select an content'),
+            :overflow => true
+          },
+          {
+            :id => "add_content_for_element_#{element.id}",
+            :class => 'small button with_icon new_content_link'
+          }
+        )
+      end
 
-			# Renders a link to create a new content in element editor
-			def render_create_content_link(element, options = {})
-				defaults = {
-					:label => t('add new content')
-				}
-				options = defaults.merge(options)
-				link_to(
-					options[:label],
-					alchemy.admin_contents_path(
-						:content => {
-							:name => options[:content_name],
-							:element_id => element.id
-						}
-					),
-					:method => 'post',
-					:remote => true,
-					:id => "add_content_for_element_#{element.id}",
-					:class => 'button new_content_link'
-				)
-			end
+      # Renders a link to create a new content in element editor
+      def render_create_content_link(element, options = {})
+        defaults = {
+          :label => t('add new content')
+        }
+        options = defaults.merge(options)
+        link_to(
+          options[:label],
+          alchemy.admin_contents_path(
+            :content => {
+              :name => options[:content_name],
+              :element_id => element.id
+            }
+          ),
+          :method => 'post',
+          :remote => true,
+          :id => "add_content_for_element_#{element.id}",
+          :class => 'button new_content_link'
+        )
+      end
 
-			# Returns a textarea ready to use with tinymce
-			def tinymce_tag(name, content = '', options = {})
-				append_class_name(options, 'tinymce')
-				text_area_tag(name, content, options)
-			end
+      # Returns a textarea ready to use with tinymce
+      def tinymce_tag(name, content = '', options = {})
+        append_class_name(options, 'tinymce')
+        text_area_tag(name, content, options)
+      end
 
-		end
-	end
+    end
+  end
 end

data/app/helpers/alchemy/admin/elements_helper.rb

@@ -1,117 +1,118 @@
 module Alchemy
-	module Admin
-		module ElementsHelper
+  module Admin
+    module ElementsHelper
 
-			include Alchemy::ElementsHelper
-			include Alchemy::Admin::BaseHelper
-			include Alchemy::Admin::ContentsHelper
-			include Alchemy::Admin::EssencesHelper
+      include Alchemy::ElementsHelper
+      include Alchemy::Admin::BaseHelper
+      include Alchemy::Admin::ContentsHelper
+      include Alchemy::Admin::EssencesHelper
 
-			# Returns an Array for essence_text_editor select options_for_select.
-			def elements_by_name_for_select(name, options={})
-				defaults = {
-					:grouped_by_page => true,
-					:from_page => :all
-				}
-				options = defaults.merge(options)
-				elements = all_elements_by_name(
-					name,
-					:from_page => options[:from_page]
-				)
-				if options[:grouped_by_page] && options[:from_page] == :all
-					elements_for_options = {}
-					pages = elements.collect(&:page).compact.uniq
-					pages.sort{ |x,y| x.name <=> y.name }.each do |page|
-						page_elements = page.elements.select { |e| e.name == name }
-						elements_for_options[page.name] = page_elements.map { |pe| [pe.preview_text, pe.id.to_s] }
-					end
-				else
-					elements_for_options = elements.map { |e| [e.preview_text, e.id.to_s] }
-					elements_for_options = [''] + elements_for_options
-				end
-				return elements_for_options
-			end
+      # Returns an Array for essence_text_editor select options_for_select.
+      def elements_by_name_for_select(name, options={})
+        defaults = {
+          :grouped_by_page => true,
+          :from_page => :all
+        }
+        options = defaults.merge(options)
+        elements = all_elements_by_name(
+          name,
+          :from_page => options[:from_page]
+        )
+        if options[:grouped_by_page] && options[:from_page] == :all
+          elements_for_options = {}
+          pages = elements.collect(&:page).compact.uniq
+          pages.sort { |x, y| x.name <=> y.name }.each do |page|
+            page_elements = page.elements.select { |e| e.name == name }
+            elements_for_options[page.name] = page_elements.map { |pe| [pe.preview_text, pe.id.to_s] }
+          end
+        else
+          elements_for_options = elements.map { |e| [e.preview_text, e.id.to_s] }
+          elements_for_options = [''] + elements_for_options
+        end
+        return elements_for_options
+      end
 
-			# Renders the element editor partial
-			def render_editor(element)
-				render_element(element, :editor)
-			end
+      # Renders the element editor partial
+      def render_editor(element)
+        render_element(element, :editor)
+      end
 
-			# Renders a drag'n'drop picture gallery editor for all EssencePictures.
-			# 
-			# It brings full functionality for adding images, deleting images and sorting them via drag'n'drop.
-			# Just place this helper inside your element editor view, pass the element as parameter and that's it.
-			#
-			# === Options:
-			# 
-			#   :maximum_amount_of_images    [Integer]   # This option let you handle the amount of images your customer can add to this element.
-			# 
-			def render_picture_gallery_editor(element, options={})
-				default_options = {
-					:maximum_amount_of_images => nil,
-					:grouped => true
-				}
-				options = default_options.merge(options)
-				picture_contents = element.contents.where(:essence_type => "Alchemy::EssencePicture")
-				render(
-					:partial => "alchemy/admin/elements/picture_editor",
-					:locals => {
-						:picture_contents => picture_contents,
-						:element => element,
-						:options => options
-					}
-				)
-			end
-			alias_method :render_picture_editor, :render_picture_gallery_editor
+      # Renders a drag'n'drop picture gallery editor for all EssencePictures.
+      #
+      # It brings full functionality for adding images, deleting images and sorting them via drag'n'drop.
+      # Just place this helper inside your element editor view, pass the element as parameter and that's it.
+      #
+      # === Options:
+      #
+      #   :maximum_amount_of_images    [Integer]   # This option let you handle the amount of images your customer can add to this element.
+      #
+      def render_picture_gallery_editor(element, options={})
+        default_options = {
+          :maximum_amount_of_images => nil,
+          :grouped => true
+        }
+        options = default_options.merge(options)
+        picture_contents = element.contents.where(:essence_type => "Alchemy::EssencePicture")
+        render(
+          :partial => "alchemy/admin/elements/picture_editor",
+          :locals => {
+            :picture_contents => picture_contents,
+            :element => element,
+            :options => options
+          }
+        )
+      end
 
-			# Returns all elements that could be placed on that page because of the pages layout.
-			# The elements are returned as an array to be used in alchemy_selectbox form builder.
-			def elements_for_select(elements)
-				return [] if elements.nil?
-				options = elements.collect{ |e| [t(e['name'], :scope => :element_names), e["name"]] }
-				return options_for_select(options)
-			end
+      alias_method :render_picture_editor, :render_picture_gallery_editor
 
-			# Returns all elements that could be placed on that page because of the pages layout.
-			# The elements will be grouped by cell.
-			def grouped_elements_for_select(elements, object_method = 'name')
-				return "" if elements.blank?
-				cells_definition = @page.cell_definitions
-				return "" if cells_definition.blank?
-				options = {}
-				celled_elements = []
-				cells_definition.each do |cell|
-					cell_elements = elements.select { |e| cell['elements'].include?(e.class.name == 'Element' ? e.name : e['name']) }
-					celled_elements += cell_elements
-					optgroup_label = Cell.translated_label_for(cell['name'])
-					options[optgroup_label] = cell_elements.map do |e|
-						element_array_for_options(e, object_method, cell)
-					end
-				end
-				other_elements = elements - celled_elements
-				unless other_elements.blank?
-					optgroup_label = t(:main_content)
-					options[optgroup_label] = other_elements.map do |e|
-						element_array_for_options(e, object_method)
-					end
-				end
-				return grouped_options_for_select(options)
-			end
+      # Returns all elements that could be placed on that page because of the pages layout.
+      # The elements are returned as an array to be used in alchemy_selectbox form builder.
+      def elements_for_select(elements)
+        return [] if elements.nil?
+        options = elements.collect { |e| [t(e['name'], :scope => :element_names), e["name"]] }
+        return options_for_select(options)
+      end
 
-			def element_array_for_options(e, object_method, cell = nil)
-				if e.class.name == 'Alchemy::Element'
-					[
-						e.display_name_with_preview_text,
-						e.send(object_method).to_s + (cell ? "##{cell['name']}" : "")
-					]
-				else
-					[
-						Alchemy::I18n.t(e['name'], :scope => :element_names),
-						e[object_method] + (cell ? "##{cell['name']}" : "")
-					]
-				end
-			end
+      # Returns all elements that could be placed on that page because of the pages layout.
+      # The elements will be grouped by cell.
+      def grouped_elements_for_select(elements, object_method = 'name')
+        return "" if elements.blank?
+        cells_definition = @page.cell_definitions
+        return "" if cells_definition.blank?
+        options = {}
+        celled_elements = []
+        cells_definition.each do |cell|
+          cell_elements = elements.select { |e| cell['elements'].include?(e.class.name == 'Element' ? e.name : e['name']) }
+          celled_elements += cell_elements
+          optgroup_label = Cell.translated_label_for(cell['name'])
+          options[optgroup_label] = cell_elements.map do |e|
+            element_array_for_options(e, object_method, cell)
+          end
+        end
+        other_elements = elements - celled_elements
+        unless other_elements.blank?
+          optgroup_label = t(:main_content)
+          options[optgroup_label] = other_elements.map do |e|
+            element_array_for_options(e, object_method)
+          end
+        end
+        return grouped_options_for_select(options)
+      end
 
-		end
-	end
+      def element_array_for_options(e, object_method, cell = nil)
+        if e.class.name == 'Alchemy::Element'
+          [
+            e.display_name_with_preview_text,
+            e.send(object_method).to_s + (cell ? "##{cell['name']}" : "")
+          ]
+        else
+          [
+            Alchemy::I18n.t(e['name'], :scope => :element_names),
+            e[object_method] + (cell ? "##{cell['name']}" : "")
+          ]
+        end
+      end
+
+    end
+  end
 end

data/app/helpers/alchemy/admin/essences_helper.rb

@@ -1,118 +1,118 @@
 module Alchemy
-	module Admin
-		module EssencesHelper
+  module Admin
+    module EssencesHelper
 
-			include Alchemy::EssencesHelper
-			include Alchemy::Admin::ContentsHelper
+      include Alchemy::EssencesHelper
+      include Alchemy::Admin::ContentsHelper
 
-			# Renders the Content editor partial from the given Content.
-			# For options see -> render_essence
-			def render_essence_editor(content, options = {}, html_options = {})
-				render_essence(content, :editor, { :for_editor => options }, html_options)
-			end
+      # Renders the Content editor partial from the given Content.
+      # For options see -> render_essence
+      def render_essence_editor(content, options = {}, html_options = {})
+        render_essence(content, :editor, {:for_editor => options}, html_options)
+      end
 
-			# Renders the Content editor partial from essence_type.
-			# 
-			# Options are:
-			#   * element (Element) - the Element the contents are in (obligatory)
-			#   * type (String) - the type of Essence (obligatory)
-			#   * options (Hash):
-			#   ** :position (Integer) - The position of the Content inside the Element. I.E. for getting the n-th EssencePicture. Default is 1 (the first)
-			#   ** :all (String) - Pass :all to get all Contents of that name. Default false
-			#   * editor_options (Hash) - Will be passed to the render_essence_editor partial renderer
-			#
-			def render_essence_editor_by_type(element, essence_type, options = {}, editor_options = {})
-				return warning('Element is nil', t("no_element_given")) if element.blank?
-				return warning('EssenceType is blank', t("No EssenceType given")) if essence_type.blank?
-				defaults = {
-					:position => 1,
-					:all => false
-				}
-				options = defaults.merge(options)
-				essence_type = Alchemy::Content.normalize_essence_type(essence_type)
-				return_string = ""
-				if options[:all]
-					contents = element.contents.find_all_by_essence_type_and_name(essence_type, options[:all])
-					contents.each do |content|
-						return_string << render_essence_editor(content, editor_options)
-					end
-				else
-					content = element.contents.find_by_essence_type_and_position(essence_type, options[:position])
-					return_string = render_essence_editor(content, editor_options)
-				end
-				return_string
-			end
+      # Renders the Content editor partial from essence_type.
+      #
+      # Options are:
+      #   * element (Element) - the Element the contents are in (obligatory)
+      #   * type (String) - the type of Essence (obligatory)
+      #   * options (Hash):
+      #   ** :position (Integer) - The position of the Content inside the Element. I.E. for getting the n-th EssencePicture. Default is 1 (the first)
+      #   ** :all (String) - Pass :all to get all Contents of that name. Default false
+      #   * editor_options (Hash) - Will be passed to the render_essence_editor partial renderer
+      #
+      def render_essence_editor_by_type(element, essence_type, options = {}, editor_options = {})
+        return warning('Element is nil', t("no_element_given")) if element.blank?
+        return warning('EssenceType is blank', t("No EssenceType given")) if essence_type.blank?
+        defaults = {
+          :position => 1,
+          :all => false
+        }
+        options = defaults.merge(options)
+        essence_type = Alchemy::Content.normalize_essence_type(essence_type)
+        return_string = ""
+        if options[:all]
+          contents = element.contents.find_all_by_essence_type_and_name(essence_type, options[:all])
+          contents.each do |content|
+            return_string << render_essence_editor(content, editor_options)
+          end
+        else
+          content = element.contents.find_by_essence_type_and_position(essence_type, options[:position])
+          return_string = render_essence_editor(content, editor_options)
+        end
+        return_string
+      end
 
-			# Renders the Content editor partial from the given Element by position (e.g. 1).
-			# For options see -> render_essence
-			def render_essence_editor_by_position(element, position, options = {})
-				if element.blank?
-					warning('Element is nil')
-					return ""
-				end
-				content = element.contents.find_by_position(position)
-				if content.nil?
-					render_missing_content(element, position, options)
-				else
-					render_essence_editor(content, options)
-				end
-			end
+      # Renders the Content editor partial from the given Element by position (e.g. 1).
+      # For options see -> render_essence
+      def render_essence_editor_by_position(element, position, options = {})
+        if element.blank?
+          warning('Element is nil')
+          return ""
+        end
+        content = element.contents.find_by_position(position)
+        if content.nil?
+          render_missing_content(element, position, options)
+        else
+          render_essence_editor(content, options)
+        end
+      end
 
-			# Renders the Content editor partial found in views/contents/ for the content with name inside the passed Element.
-			# For options see -> render_essence
-			# 
-			# Content creation on the fly:
-			# 
-			# If you update the elements.yml file after creating an element this helper displays a error message with an option to create the content.
-			#
-			def render_essence_editor_by_name(element, name, options = {}, html_options = {})
-				if element.blank?
-					return warning('Element is nil', t("no_element_given"))
-				end
-				content = element.content_by_name(name)
-				if content.nil?
-					render_missing_content(element, name, options)
-				else
-					render_essence_editor(content, options, html_options)
-				end
-			end
+      # Renders the Content editor partial found in views/contents/ for the content with name inside the passed Element.
+      # For options see -> render_essence
+      #
+      # Content creation on the fly:
+      #
+      # If you update the elements.yml file after creating an element this helper displays a error message with an option to create the content.
+      #
+      def render_essence_editor_by_name(element, name, options = {}, html_options = {})
+        if element.blank?
+          return warning('Element is nil', t("no_element_given"))
+        end
+        content = element.content_by_name(name)
+        if content.nil?
+          render_missing_content(element, name, options)
+        else
+          render_essence_editor(content, options, html_options)
+        end
+      end
 
-			# Renders the EssenceText editor partial with a form select for storing page urlnames
-			# 
-			# === Options:
-			# 
-			#   :only            [Hash]     # Pagelayout names. Only pages with this page_layout will be displayed inside the select.
-			#   :page_attribute  [Symbol]   # The Page attribute which will be stored.
-			#   :global          [Boolean]  # Display only global pages. Default is false.
-			# 
-			def page_selector(element, content_name, options = {}, select_options = {})
-				default_options = {
-					:page_attribute => :id,
-					:global => false,
-					:prompt => t('Choose page')
-				}
-				options = default_options.merge(options)
-				pages = Page.where({
-					:language_id => session[:language_id],
-					:layoutpage => options[:global] == true,
-					:public => options[:global] == false
-				})
-				pages = pages.where({:page_layout => options[:only]}) if options[:only].present?
-				content = element.content_by_name(content_name)
-				options.update(
-					:select_values => pages_for_select(pages, content ? content.essence.body : nil, options[:prompt], options[:page_attribute])
-				)
-				if content.nil?
-					render_missing_content(element, content_name, options)
-				else
-					render_essence_editor(content, options)
-				end
-			end
+      # Renders the EssenceText editor partial with a form select for storing page urlnames
+      #
+      # === Options:
+      #
+      #   :only            [Hash]     # Pagelayout names. Only pages with this page_layout will be displayed inside the select.
+      #   :page_attribute  [Symbol]   # The Page attribute which will be stored.
+      #   :global          [Boolean]  # Display only global pages. Default is false.
+      #
+      def page_selector(element, content_name, options = {}, select_options = {})
+        default_options = {
+          :page_attribute => :id,
+          :global => false,
+          :prompt => t('Choose page')
+        }
+        options = default_options.merge(options)
+        pages = Page.where({
+                   :language_id => session[:language_id],
+                   :layoutpage => options[:global] == true,
+                   :public => options[:global] == false
+                 })
+        pages = pages.where({:page_layout => options[:only]}) if options[:only].present?
+        content = element.content_by_name(content_name)
+        options.update(
+          :select_values => pages_for_select(pages, content ? content.essence.body : nil, options[:prompt], options[:page_attribute])
+        )
+        if content.nil?
+          render_missing_content(element, content_name, options)
+        else
+          render_essence_editor(content, options)
+        end
+      end
 
-			def render_missing_content(element, name, options)
-				render :partial => 'alchemy/admin/contents/missing', :locals => {:element => element, :name => name, :options => options}
-			end
+      def render_missing_content(element, name, options)
+        render :partial => 'alchemy/admin/contents/missing', :locals => {:element => element, :name => name, :options => options}
+      end
 
-		end
-	end
+    end
+  end
 end