alchemy_cms 2.1.beta1 → 2.1.beta5

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

@@ -0,0 +1,75 @@
+module Alchemy
+	module Admin
+		module ContentsHelper
+
+			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
+
+			# 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(
+					t('add new content'),
+					alchemy.new_admin_element_content_path(element),
+					{
+						:size => '305x40',
+						:title => t('Select an content'),
+						:overflow => 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
+
+		end
+	end
+end

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

@@ -0,0 +1,118 @@
+module Alchemy
+	module Admin
+		module ElementsHelper
+
+			include Alchemy::ElementsHelper
+			include Alchemy::Admin::BaseHelper
+			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
+
+			# Renders the element editor partial
+			def render_editor(element)
+				render_element(element, :editor)
+			end
+
+			# This helper renderes the picture editor for the elements on the Alchemy Desktop.
+			# It brings full functionality for adding images to the element, deleting images from it 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), default nil. This option let you handle the amount of images your customer can add to this element.
+			def render_picture_editor(element, options={})
+				default_options = {
+					:last_image_deletable => true,
+					:maximum_amount_of_images => nil,
+					:refresh_sortable => true
+				}
+				options = default_options.merge(options)
+				picture_contents = element.all_contents_by_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("alchemy.element_names.#{e['name']}", :default => e['name'].capitalize), e["name"]] }
+				return options_for_select(options)
+			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('other Elements')
+					options[optgroup_label] = other_elements.map do |e|
+						element_array_for_options(e, object_method)
+					end
+				end
+				return grouped_options_for_select(options)
+			end
+
+			def element_array_for_options(e, object_method, cell = nil)
+				if e.class.name == 'Element'
+					[
+						e.display_name_with_preview_text,
+						e.send(object_method).to_s + (cell ? "##{cell['name']}" : "")
+					]
+				else
+					[
+						t("alchemy.element_names.#{e['name']}", :default => e['name'].capitalize),
+						e[object_method] + (cell ? "##{cell['name']}" : "")
+					]
+				end
+			end
+
+			def tinymce_tag(name, content = '', options = {})
+				append_class_name(options, 'tinymce')
+				text_area_tag(name, content, options)
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,78 @@
+module Alchemy
+	module Admin
+		module EssencesHelper
+
+			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 = {})
+				render_essence(content, :editor, :for_editor => 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 = normalized_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(content, :editor, :for_editor => editor_options)
+					end
+				else
+					content = element.contents.find_by_essence_type_and_position(essence_type, options[:position])
+					return_string = render_essence(content, :editor, :for_editor => 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)
+				render_essence(content, :editor, :for_editor => options)
+			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 = {})
+				if element.blank?
+					return warning('Element is nil', t("no_element_given"))
+				end
+				content = element.content_by_name(name)
+				if content.blank?
+					render :partial => 'alchemy/admin/contents/missing', :locals => {:element => element, :name => name}
+				else
+					render_essence(content, :editor, :for_editor => options)
+				end
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,46 @@
+module Alchemy
+	module Admin
+		module PagesHelper
+
+			def tinymce_javascript_tags
+				init = Alchemy::Tinymce.init
+				if init.is_a?(Hash)
+					init = HashWithIndifferentAccess.new(init)
+					init = init.keys.sort.collect(&:to_s).sort.collect do |key|
+						[key, init[key]]
+					end
+				end
+				init = init.collect { |key, value| "#{key} : #{value.to_json}" }.join(', ')
+				
+				setup = "init.setup = #{Alchemy::Tinymce.setup};" if Alchemy::Tinymce.setup
+				return "
+		<script type='text/javascript'>
+			jQuery(function(){
+				if (typeof(Alchemy) !== 'object') { Alchemy = {}; };
+				Alchemy.Tinymce = {
+					init : function(callback) {
+						var init = { #{init} };
+						init.mode = 'specific_textareas';
+						init.editor_selector = 'tinymce';
+						init.plugins = '#{Alchemy::Tinymce.plugins.join(',')}';
+						init.language = '#{::I18n.locale}';
+						init.init_instance_callback = function(inst) {
+							jQuery('#' + inst.editorId).prev('.essence_richtext_loader').hide();
+						}
+						if (callback)
+							init.oninit = callback;
+						#{setup}
+						tinymce.init(init);
+					},
+					addEditor : function(dom_id) {
+						tinymce.execCommand('mceAddControl', true, dom_id);
+					}
+				};
+				Alchemy.Tinymce.init();
+			});
+		</script>".html_safe
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,30 @@
+module Alchemy
+	module Admin
+		module PicturesHelper
+
+			def create_or_assign_url(picture_to_assign, options)
+				if @content.nil?
+					{
+						:controller => :contents,
+						:action => :create,
+						:picture_id => picture_to_assign.id,
+						:content => {
+							:essence_type => "Alchemy::EssencePicture",
+							:element_id => @element.id
+						},
+						:options => options
+					}
+				else
+					{
+						:controller => :essence_pictures,
+						:action => :assign,
+						:picture_id => picture_to_assign.id,
+						:id => @content.id,
+						:options => options
+					}
+				end
+			end
+
+		end
+	end
+end

data/app/helpers/alchemy/base_helper.rb

@@ -0,0 +1,65 @@
+module Alchemy
+	module BaseHelper
+
+		# An alias for truncate.
+		# Left here for downwards compatibilty.
+		def shorten(text, length)
+			text.truncate(:length => length)
+		end
+
+		# Returns @current_language set in the action (e.g. Page.show)
+		def current_language
+			if @current_language.nil?
+				warning('@current_language is not set')
+				return nil
+			else
+				@current_language
+			end
+		end
+
+		def parse_sitemap_name(page)
+			if multi_language?
+				pathname = "/#{session[:language_code]}/#{page.urlname}"
+			else
+				pathname = "/#{page.urlname}"
+			end
+			pathname
+		end
+
+		# Logs a message in the Rails logger (warn level) and optionally displays an error message to the user.
+		def warning(message, text = nil)
+			logger.warn %(\n
+				++++ WARNING: #{message}! from: #{caller.first}\n
+			)
+			unless text.nil?
+				warning = content_tag('p', :class => 'content_editor_error') do
+					render_icon('warning') + text
+				end
+				return warning
+			end
+		end
+
+		# Taken from tinymce_hammer plugin
+		def append_class_name options, class_name #:nodoc:
+			key = options.has_key?('class') ? 'class' : :class 
+			unless options[key].to_s =~ /(^|\s+)#{class_name}(\s+|$)/
+				options[key] = "#{options[key]} #{class_name}".strip
+			end
+			options
+		end
+
+		# Returns an icon
+		def render_icon(icon_class)
+			content_tag('span', '', :class => "icon #{icon_class}")
+		end
+
+		def normalized_essence_type(essence_type)
+			if not essence_type.match(/^Alchemy::/)
+				essence_type.gsub!(/^Essence/, 'Alchemy::Essence')
+			else
+				essence_type
+			end
+		end
+
+	end
+end

data/app/helpers/alchemy/elements_helper.rb

@@ -0,0 +1,173 @@
+module Alchemy
+	module ElementsHelper
+
+		include Alchemy::EssencesHelper
+
+		# Renders all elements from @page.
+		# ---
+		# == Options are:
+		# :only => []                 A list of element names to be rendered only. Very useful if you want to render a specific element type in a special html part (e.g.. <div>) of your page and all other elements in another part.
+		# :except => []               A list of element names to be rendered. The opposite of the only option.
+		# :from_page                  The Alchemy::Page.page_layout string from which the elements are rendered from, or you even pass a Page object.
+		# :count                      The amount of elements to be rendered (begins with first element found)
+		# :fallback => {:for => 'ELEMENT_NAME', :with => 'ELEMENT_NAME', :from => 'PAGE_LAYOUT'} when no element from this name is found on page, then use this element from that page
+		# :sort_by => Content#name    A Content name to sort the elements by
+		# :reverse => boolean         Reverse the rendering order
+		# :random => boolean          Random output of elements
+		# 
+		# This helper also stores all pages where elements gets rendered on, so we can sweep them later if caching expires!
+		# 
+		def render_elements(options = {})
+			default_options = {
+				:except => [],
+				:only => [],
+				:from_page => "",
+				:from_cell => nil,
+				:count => nil,
+				:offset => nil,
+				:locals => {},
+				:render_format => "html",
+				:fallback => nil
+			}
+			options = default_options.merge(options)
+			if options[:from_page].blank?
+				page = @page
+			else
+				if options[:from_page].class == Page
+					page = options[:from_page]
+				else
+					page = Page.where(:page_layout => options[:from_page]).with_language(session[:language_id]).all
+				end
+			end
+			if page.blank?
+				warning('Page is nil')
+				return ""
+			else
+				show_non_public = configuration(:cache_pages) ? false : defined?(current_user)
+				if page.class == Array
+					all_elements = page.collect { |p| p.find_elements(options, show_non_public) }.flatten
+				else
+					all_elements = page.find_elements(options, show_non_public)
+				end
+				unless options[:sort_by].blank?
+					all_elements = all_elements.sort_by { |e| e.contents.detect { |c| c.name == options[:sort_by] }.ingredient }
+				end
+				all_elements.reverse! if options[:reverse_sort] || options[:reverse]
+				element_string = ""
+				if options[:fallback]
+					unless all_elements.detect { |e| e.name == options[:fallback][:for] }
+						if from = Page.where(:page_layout => options[:fallback][:from]).with_language(session[:language_id]).first
+							all_elements += from.elements.named(options[:fallback][:with].blank? ? options[:fallback][:for] : options[:fallback][:with])
+						end
+					end
+				end
+				all_elements.each_with_index do |element, i|
+					element_string += render_element(element, :view, options, i+1)
+				end
+				element_string.html_safe
+			end
+		end
+
+		# This helper renders the Element partial for either the view or the editor part.
+		# Generate element partials with ./script/generate elements
+		def render_element(element, part = :view, options = {}, i = 1)
+			begin
+				if element.blank?
+					warning('Element is nil')
+					render :partial => "alchemy/elements/#{part}_not_found", :locals => {:name => 'nil'}
+				else
+					default_options = {
+						:shorten_to => nil,
+						:render_format => "html"
+					}
+					options = default_options.merge(options)
+					element.store_page(@page) if part == :view
+					path1 = "#{Rails.root}/app/views/elements/"
+					path2 = "#{Rails.root}/vendor/plugins/alchemy/app/views/elements/"
+					partial_name = "_#{element.name.underscore}_#{part}.html.erb"
+					locals = options.delete(:locals)
+					render(
+						:partial => "alchemy/elements/#{element.name.underscore}_#{part}.#{options[:render_format]}.erb",
+						:locals => {
+							:element => element,
+							:options => options,
+							:counter => i
+						}.merge(locals || {})
+					)
+				end
+			rescue ActionView::MissingTemplate
+				warning(%(
+					Element #{part} partial not found for #{element.name}.\n
+					Looking for #{partial_name}, but not found
+					neither in #{path1}
+					nor in #{path2}
+					Use rails generate alchemy:elements to generate them.
+					Maybe you still have old style partial names? (like .rhtml). Then please rename them in .html.erb'
+				))
+				render :partial => "alchemy/elements/#{part}_not_found", :locals => {:name => element.name, :error => "Element #{part} partial not found. Use rails generate alchemy:elements to generate them."}
+			end
+		end
+
+		# Returns all public elements found by Element.name.
+		# Pass a count to return only an limited amount of elements.
+		def all_elements_by_name(name, options = {})
+			warning('options[:language] option not allowed any more in all_elements_by_name helper') unless options[:language].blank?
+			default_options = {
+				:count => :all,
+				:from_page => :all
+			}
+			options = default_options.merge(options)
+			if options[:from_page] == :all
+				elements = Element.find_all_by_name_and_public(name, true, :limit => options[:count] == :all ? nil : options[:count])
+			elsif options[:from_page].class == String
+				page = Page.find_by_page_layout_and_language_id(options[:from_page], session[:language_id])
+				return [] if page.blank?
+				elements = page.elements.find_all_by_name_and_public(name, true, :limit => options[:count] == :all ? nil : options[:count])
+			else
+				elements = options[:from_page].elements.find_all_by_name_and_public(name, true, :limit => options[:count] == :all ? nil : options[:count])
+			end
+		end
+
+		# Returns the public element found by Element.name from the given public Page, either by Page.id or by Page.urlname
+		def element_from_page(options = {})
+			default_options = {
+				:page_urlname => "",
+				:page_id => nil,
+				:element_name => ""
+			}
+			options = default_options.merge(options)
+			if options[:page_id].blank?
+				page = Page.find_by_urlname_and_public(options[:page_urlname], true)
+			else
+				page = Page.find_by_id_and_public(options[:page_id], true)
+			end
+			return "" if page.blank?
+			element = page.elements.find_by_name_and_public(options[:element_name], true)
+			return element
+		end
+
+		# Renders all element partials from given cell.
+		def render_cell_elements(cell)
+			return warning("No cell given.") if cell.blank?
+			render_elements({:from_cell => cell})
+		end
+
+		# Returns a string for the id attribute of a html element for the given element
+		def element_dom_id(element)
+			return "" if element.nil?
+			"#{element.name}_#{element.id}"
+		end
+
+		# Renders the data-alchemy-element HTML attribut used for the preview window hover effect.
+		def element_preview_code(element)
+			return "" if element.nil?
+			" data-alchemy-element='#{element.id}'" if @preview_mode && element.page == @page
+		end
+
+		# Returns the full url containing host, page and anchor for the given element
+		def full_url_for_element(element)
+			"http://" + request.env["HTTP_HOST"] + "/" + element.page.urlname + "##{element.name}_#{element.id}"  
+		end
+
+	end
+end