lc_alchemy_cms 3.2.0

data/app/helpers/alchemy/elements_helper.rb

@@ -0,0 +1,291 @@
+module Alchemy
+  # This helpers are useful to render elements from pages.
+  #
+  # The most important helper for frontend developers is the {#render_elements} helper.
+  #
+  module ElementsHelper
+    include Alchemy::EssencesHelper
+    include Alchemy::UrlHelper
+    include Alchemy::ElementsBlockHelper
+
+    # Renders all elements from current page
+    #
+    # == Examples:
+    #
+    # === Render only certain elements:
+    #
+    #   <header>
+    #     <%= render_elements only: ['header', 'claim'] %>
+    #   </header>
+    #   <section id="content">
+    #     <%= render_elements except: ['header', 'claim'] %>
+    #   </section>
+    #
+    # === Render elements from global page:
+    #
+    #   <footer>
+    #     <%= render_elements from_page: 'footer' %>
+    #   </footer>
+    #
+    # === Render elements from cell:
+    #
+    #   <aside>
+    #     <%= render_elements from_cell: 'sidebar' %>
+    #   </aside>
+    #
+    # === Fallback to elements from global page:
+    #
+    # You can use the fallback option as an override for elements that are stored on another page.
+    # So you can take elements from a global page and only if the user adds an element on current page the
+    # local one gets rendered.
+    #
+    # 1. You have to pass the the name of the element the fallback is for as <tt>for</tt> key.
+    # 2. You have to pass a <tt>page_layout</tt> name or {Alchemy::Page} from where the fallback elements is taken from as <tt>from</tt> key.
+    # 3. You can pass the name of element to fallback with as <tt>with</tt> key. This is optional (the element name from the <tt>for</tt> key is taken as default).
+    #
+    #   <%= render_elements(fallback: {
+    #     for: 'contact_teaser',
+    #     from: 'sidebar',
+    #     with: 'contact_teaser'
+    #   }) %>
+    #
+    # @param [Hash] options
+    #   Additional options.
+    #
+    # @option options [Number] :count
+    #   The amount of elements to be rendered (begins with first element found)
+    # @option options [Array or String] :except ([])
+    #   A list of element names not to be rendered.
+    # @option options [Hash] :fallback
+    #   Define elements that are rendered from another page.
+    # @option options [Alchemy::Cell or String] :from_cell
+    #   The cell the elements are rendered from. You can pass a {Alchemy::Cell} name String or a {Alchemy::Cell} object.
+    # @option options [Alchemy::Page or String] :from_page (@page)
+    #   The page the elements are rendered from. You can pass a page_layout String or a {Alchemy::Page} object.
+    # @option options [Array or String] :only ([])
+    #   A list of element names only to be rendered.
+    # @option options [Boolean] :random
+    #   Randomize the output of elements
+    # @option options [Boolean] :reverse
+    #   Reverse the rendering order
+    # @option options [String] :sort_by
+    #   The name of a {Alchemy::Content} to sort the elements by
+    # @option options [String] :separator
+    #   A string that will be used to join the element partials. Default nil
+    #
+    def render_elements(options = {})
+      options = {
+        from_page: @page,
+        render_format: 'html'
+      }.update(options)
+
+      pages = pages_holding_elements(options.delete(:from_page))
+
+      if pages.blank?
+        warning('No page to get elements from was found')
+        return
+      end
+
+      elements = collect_elements_from_pages(pages, options)
+
+      if options[:sort_by].present?
+        elements = sort_elements_by_content(elements, options.delete(:sort_by))
+      end
+
+      render_element_view_partials(elements, options)
+    end
+
+    # This helper renders a {Alchemy::Element} partial.
+    #
+    # A element has always two partials:
+    #
+    # 1. A view partial (This is the view presented to the website visitor)
+    # 2. A editor partial (This is the form presented to the website editor while in page edit mode)
+    #
+    # The partials are located in <tt>app/views/alchemy/elements</tt>.
+    #
+    # == View partial naming
+    #
+    # The partials have to be named after the name of the element as defined in the <tt>elements.yml</tt> file and has to be suffixed with the partial part.
+    #
+    # === Example
+    #
+    # Given a headline element
+    #
+    #   # elements.yml
+    #   - name: headline
+    #     contents:
+    #     - name: text
+    #       type: EssenceText
+    #
+    # Then your element view partials has to be named like:
+    #
+    #   app/views/alchemy/elements/_headline_editor.html.erb
+    #   app/views/alchemy/elements/_headline_view.html.erb
+    #
+    # === Element partials generator
+    #
+    # You can use this handy generator to let Alchemy generate the partials for you:
+    #
+    #   $ rails generate alchemy:elements --skip
+    #
+    # == Usage
+    #
+    #   <%= render_element(Alchemy::Element.published.named(:headline).first) %>
+    #
+    # @param [Alchemy::Element] element
+    #   The element you want to render the view for
+    # @param [Symbol] part
+    #   The type of element partial (<tt>:editor</tt> or <tt>:view</tt>) you want to render
+    # @param [Hash] options
+    #   Additional options
+    # @param [Number] counter
+    #   a counter
+    #
+    # @note If the view partial is not found <tt>alchemy/elements/_view_not_found.html.erb</tt>
+    #   or <tt>alchemy/elements/_editor_not_found.html.erb</tt> gets rendered.
+    #
+    def render_element(element, part = :view, options = {}, counter = 1)
+      if element.nil?
+        warning('Element is nil')
+        render "alchemy/elements/#{part}_not_found", {name: 'nil'}
+        return
+      end
+
+      element.store_page(@page) if part.to_sym == :view
+
+      render "alchemy/elements/#{element.name}_#{part}", {
+        element: element,
+        counter: counter,
+        options: options
+      }.merge(options.delete(:locals) || {})
+
+    rescue ActionView::MissingTemplate => e
+      warning(%(
+        Element #{part} partial not found for #{element.name}.\n
+        #{e}
+      ))
+      render "alchemy/elements/#{part}_not_found", {
+        name: element.name,
+        error: "Element #{part} partial not found.<br>Use <code>rails generate alchemy:elements</code> to generate it."
+      }
+    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}".html_safe
+    end
+
+    # Renders the HTML tag attributes required for preview mode.
+    def element_preview_code(element)
+      tag_options(element_preview_code_attributes(element))
+    end
+
+    # Returns a hash containing the HTML tag attributes required for preview mode.
+    def element_preview_code_attributes(element)
+      return {} unless element.present? && @preview_mode && element.page == @page
+      { :'data-alchemy-element' => element.id }
+    end
+
+    # Returns the element's tags information as a string. Parameters and options
+    # are equivalent to {#element_tags_attributes}.
+    #
+    # @see #element_tags_attributes
+    #
+    # @return [String]
+    #   HTML tag attributes containing the element's tag information.
+    #
+    def element_tags(element, options = {})
+      tag_options(element_tags_attributes(element, options))
+    end
+
+    # Returns the element's tags information as an attribute hash.
+    #
+    # @param [Alchemy::Element] element The {Alchemy::Element} you want to render the tags from.
+    #
+    # @option options [Proc] :formatter
+    #   ('lambda { |tags| tags.join(' ') }')
+    #   Lambda converting array of tags to a string.
+    #
+    # @return [Hash]
+    #   HTML tag attributes containing the element's tag information.
+    #
+    def element_tags_attributes(element, options = {})
+      options = {
+        formatter: lambda { |tags| tags.join(' ') }
+      }.merge(options)
+
+      return {} if !element.taggable? || element.tag_list.blank?
+      { :'data-element-tags' => options[:formatter].call(element.tag_list) }
+    end
+
+    # Sort given elements by content.
+    #
+    # @param [Array] elements - The elements you want to sort
+    # @param [String] content_name - The name of the content you want to sort by
+    #
+    # @return [Array]
+    #
+    def sort_elements_by_content(elements, content_name)
+      elements.sort_by do |element|
+        content = element.content_by_name(content_name)
+        content ? content.ingredient.to_s : ''
+      end
+    end
+
+    private
+
+    def pages_holding_elements(page)
+      case page
+      when String
+        Language.current.pages.where(
+          page_layout: page,
+          restricted: false
+        ).to_a
+      when Page
+        page
+      end
+    end
+
+    def collect_elements_from_pages(page, options)
+      if page.is_a? Array
+        elements = page.collect { |p| p.find_elements(options) }.flatten
+      else
+        elements = page.find_elements(options)
+      end
+      if fallback_required?(elements, options)
+        elements += fallback_elements(options)
+      end
+      elements
+    end
+
+    def fallback_required?(elements, options)
+      options[:fallback] && elements.detect { |e| e.name == options[:fallback][:for] }.nil?
+    end
+
+    def fallback_elements(options)
+      fallback_options = options.delete(:fallback)
+      case fallback_options[:from]
+      when String
+        page = Language.current.pages.find_by(
+          page_layout: fallback_options[:from],
+          restricted: false
+        )
+      when Page
+        page = fallback_options[:from]
+      end
+      return [] if page.blank?
+      page.elements.named(fallback_options[:with].blank? ? fallback_options[:for] : fallback_options[:with])
+    end
+
+    def render_element_view_partials(elements, options = {})
+      buff = []
+      elements.each_with_index do |element, i|
+        buff << render_element(element, :view, options, i + 1)
+      end
+      buff.join(options[:separator]).html_safe
+    end
+
+  end
+end

data/app/helpers/alchemy/essences_helper.rb

@@ -0,0 +1,138 @@
+module Alchemy
+
+  # This helper contains methods to render the +essence+ from an +Element+ +Content+.
+  #
+  # Essences have two kinds of partials. An +editor+ and a +view+ partial.
+  #
+  # They both resist in +'app/views/alchemy/essences'+
+  #
+  # The partials are suffixed with the type of part.
+  #
+  # == Example:
+  #
+  # For an EssenceText
+  #
+  # The view partial is:
+  #
+  # +_essence_text_view.html.erb+
+  #
+  # The editor partial is:
+  #
+  # +_essence_text_editor.html.erb+
+  #
+  # == Usage:
+  #
+  # For front end web development you should mostly use the +render_essence_view_by_name+ helper.
+  #
+  # And the +render_essence_editor_by_name+ helper for Alchemy backend views.
+  #
+  module EssencesHelper
+
+    # Renders the +Essence+ view partial from +Element+ by name.
+    #
+    # Pass the name of the +Content+ from +Element+ as second argument.
+    #
+    # == Example:
+    #
+    # This renders the +Content+ named "intro" from element.
+    #
+    #   <%= render_essence_view_by_name(element, "intro") %>
+    #
+    def render_essence_view_by_name(element, name, options = {}, html_options = {})
+      if element.blank?
+        warning('Element is nil')
+        return ""
+      end
+      content = element.content_by_name(name)
+      render_essence_view(content, options, html_options)
+    end
+
+    # Renders the +Esssence+ partial for given +Content+.
+    #
+    # The helper renders the view partial as default.
+    #
+    # Pass +:editor+ as second argument to render the editor partial
+    #
+    # == Options:
+    #
+    # You can pass a options Hash to each type of essence partial as third argument.
+    #
+    # This Hash is available as +options+ local variable.
+    #
+    #   for_view: {}
+    #   for_editor: {}
+    #
+    def render_essence(content, part = :view, options = {}, html_options = {})
+      options = {for_view: {}, for_editor: {}}.update(options)
+      if content.nil?
+        return part == :view ? "" : warning('Content is nil', _t(:content_not_found))
+      elsif content.essence.nil?
+        return part == :view ? "" : warning('Essence is nil', _t(:content_essence_not_found))
+      end
+      render partial: "alchemy/essences/#{content.essence_partial_name}_#{part}", locals: {
+        content: content,
+        options: options["for_#{part}".to_sym],
+        html_options: html_options
+      }
+    end
+
+    # Renders the +Esssence+ view partial for given +Content+.
+    #
+    # == Options:
+    #
+    #   :image_size => "111x93"                        # Used by EssencePicture to render the image via RMagick to that size. [Default nil]
+    #   :date_format => "Am %d. %m. %Y, um %H:%Mh"     # Especially for EssenceDate. See Rubys Date.strftime for date formatting options. [Default nil]
+    #   :show_caption => false                         # Pass Boolean to show/hide the caption of an EssencePicture. [Default true]
+    #   :disable_link => true                          # You can surpress the link of an EssencePicture. Default false
+    #
+    def render_essence_view(content, options = {}, html_options = {})
+      render_essence(content, :view, {:for_view => options}, html_options)
+    end
+
+    # Renders a essence picture
+    #
+    def render_essence_picture_view(content, options, html_options)
+      options = {
+        show_caption: true,
+        disable_link: false
+      }.update(content.settings).update(options)
+      return if content.ingredient.blank?
+      if content.essence.caption.present? && options[:show_caption]
+        caption = content_tag(:figcaption, content.essence.caption, id: "#{dom_id(content.ingredient)}_caption", class: "image_caption")
+      end
+      img_tag = image_tag(
+        content.essence.picture_url(options), {
+          alt: (content.essence.alt_tag.blank? ? nil : content.essence.alt_tag),
+          title: (content.essence.title.blank? ? nil : content.essence.title),
+          class: (caption || content.essence.css_class.blank? ? nil : content.essence.css_class)
+        }.merge(caption ? {} : html_options)
+      )
+      output = caption ? img_tag + caption : img_tag
+      if content.essence.link.present? && !options[:disable_link]
+        output = link_to(url_for(content.essence.link), {
+          title: content.essence.link_title.blank? ? nil : content.essence.link_title,
+          target: (content.essence.link_target == "blank" ? "_blank" : nil),
+          'data-link-target' => content.essence.link_target.blank? ? nil : content.essence.link_target
+        }) do
+          output
+        end
+      end
+      if caption
+        content_tag(:figure, output, {class: content.essence.css_class.blank? ? nil : content.essence.css_class}.merge(html_options))
+      else
+        output
+      end
+    end
+
+    # Fetches value from settings of given content
+    #
+    # @param content [Alchemy::Content] - The content that settings should be taken
+    # @param key [Symbol]               - The hash key you want to fetch the value from
+    # @param options [Hash]             - An optional Hash that can override the settings.
+    #                                     Normally passed as options hash into the content editor view
+    def content_settings_value(content, key, options = {})
+      content.settings.update(options || {}).symbolize_keys[key.to_sym]
+    end
+
+  end
+end

data/app/helpers/alchemy/pages_helper.rb

@@ -0,0 +1,417 @@
+module Alchemy
+  module PagesHelper
+    include Alchemy::BaseHelper
+    include Alchemy::ElementsHelper
+
+    def picture_essence_caption(content)
+      content.try(:essence).try(:caption)
+    end
+
+    # Renders links to language root pages of all published languages.
+    #
+    # @option options linkname [String] ('name')
+    #   Renders name/code of language, or I18n translation for code.
+    #
+    # @option options show_title [Boolean] (true)
+    #   Renders title attributes for the links.
+    #
+    # @option options spacer [String] ('')
+    #   Renders the passed spacer string. You can also overwrite the spacer partial: "alchemy/language_links/_spacer".
+    #
+    # @option options reverse [Boolean] (false)
+    #   Reverses the ordering of the links.
+    #
+    def language_links(options={})
+      options = {
+        linkname: 'name',
+        show_title: true,
+        spacer: '',
+        reverse: false
+      }.merge(options)
+      languages = Language.published.with_root_page.order("name #{options[:reverse] ? 'DESC' : 'ASC'}")
+      return nil if languages.count < 2
+      render(
+        partial: "alchemy/language_links/language",
+        collection: languages,
+        spacer_template: "alchemy/language_links/spacer",
+        locals: {languages: languages, options: options}
+      )
+    end
+
+    # Renders the layout for current page.
+    #
+    # Page layout files belongs in +/app/views/alchemy/page_layouts/+
+    #
+    # Falls back to +/app/views/alchemy/page_layouts/standard+ if the page_layout partial is not found.
+    #
+    def render_page_layout
+      render @page, page: @page
+    rescue ActionView::MissingTemplate
+      warning("PageLayout: '#{@page.page_layout}' not found. Rendering standard page_layout.")
+      render 'alchemy/page_layouts/standard', page: @page
+    end
+
+    # Renders a partial for current site
+    #
+    # Place a rails partial into +app/views/alchemy/site_layouts+
+    #
+    # and name it like your site name.
+    #
+    # == Example:
+    #
+    #   <%= render_site_layout %>
+    #
+    # renders +app/views/alchemy/site_layouts/_default_site.html.erb+ for the site named "Default Site".
+    #
+    def render_site_layout
+      render current_alchemy_site
+    rescue ActionView::MissingTemplate
+      warning("Site layout for #{current_alchemy_site.try(:name)} not found. Please run `rails g alchemy:site_layouts`")
+      return ""
+    end
+
+    # Renders the navigation.
+    #
+    # It produces a html <ul><li></li></ul> structure with all necessary classes so you can produce every navigation the web uses today.
+    # I.E. dropdown-navigations, simple mainnavigations or even complex nested ones.
+    #
+    # === HTML output:
+    #
+    #   <ul class="navigation level_1">
+    #     <li class="first home"><a href="/home" class="active" title="Homepage" lang="en" data-page-id="1">Homepage</a></li>
+    #     <li class="contact"><a href="/contact" title="Contact" lang="en" data-page-id="2">Contact</a></li>
+    #     <li class="last imprint"><a href="/imprint" title="Imprint" lang="en" data-page-id="3">Imprint</a></li>
+    #   </ul>
+    #
+    # As you can see: Everything you need.
+    #
+    # Not pleased with the way Alchemy produces the navigation structure?
+    #
+    # Then feel free to overwrite the partials (_renderer.html.erb and _link.html.erb) found in +views/navigation/+ or pass different partials via the options +:navigation_partial+ and +:navigation_link_partial+.
+    #
+    # === Passing HTML classes and ids to the renderer
+    #
+    # A second hash can be passed as html_options to the navigation renderer partial.
+    #
+    # ==== Example:
+    #
+    #   <%= render_navigation({from_page: 'subnavi'}, {class: 'navigation', id: 'subnavigation'}) %>
+    #
+    #
+    # @option options submenu [Boolean] (false)
+    #   Do you want a nested <ul> <li> structure for the deeper levels of your navigation, or not?
+    #   Used to display the subnavigation within the mainnaviagtion. I.e. for dropdown menues.
+    #
+    # @option options all_sub_menues [Boolean] (false)
+    #   Renders the whole page tree.
+    #
+    # @option options from_page [Alchemy::Page] (@root_page)
+    #   Do you want to render a navigation from a different page then the current page?
+    #   Then pass an Page instance or a Alchemy::PageLayout name as string.
+    #
+    # @option options spacer [String] (nil)
+    #   A spacer for the entries can be passed.
+    #   Simple string, or even a complex html structure.
+    #   I.e: "<span class='spacer'>|</spacer>".
+    #
+    # @option options navigation_partial [String] ("navigation/renderer")
+    #   Pass a different partial to be taken for the navigation rendering.
+    #   Alternatively you could override the +app/views/alchemy/navigation/renderer+ partial in your app.
+    #
+    # @option options navigation_link_partial [String] ("navigation/link")
+    #   Alchemy places an <a> html link in <li> tags.
+    #   The tag automatically has an active css class if necessary.
+    #   So styling is everything. But maybe you don't want this.
+    #   So feel free to make you own partial and pass the filename here.
+    #   Alternatively you could override the +app/views/alchemy/navigation/link+ partial in your app.
+    #
+    # @option options show_nonactive [Boolean] (false)
+    #   Commonly Alchemy only displays the submenu of the active page (if submenu: true).
+    #   If you want to display all child pages then pass true (together with submenu: true of course).
+    #   I.e. for css-driven drop down menues.
+    #
+    # @option options show_title [Boolean] (true)
+    #   For our beloved SEOs :)
+    #   Appends a title attribute to all links and places the +page.title+ content into it.
+    #
+    # @option options restricted_only [Boolean] (false)
+    #   Render only restricted pages. I.E for members only navigations.
+    #
+    # @option options reverse [Boolean] (false)
+    #   Reverse the output of the pages
+    #
+    # @option options reverse_children [Boolean] (false)
+    #   Like reverse option, but only reverse the children of the first level
+    #
+    # @option options deepness [Fixnum] (nil)
+    #   Show only pages up to this depth.
+    #
+    def render_navigation(options = {}, html_options = {})
+      options = {
+        submenu: false,
+        all_sub_menues: false,
+        from_page: @root_page || Language.current_root_page,
+        spacer: nil,
+        navigation_partial: 'alchemy/navigation/renderer',
+        navigation_link_partial: 'alchemy/navigation/link',
+        show_nonactive: false,
+        restricted_only: false,
+        show_title: true,
+        reverse: false,
+        reverse_children: false
+      }.merge(options)
+      page = page_or_find(options[:from_page])
+      return nil if page.blank?
+      pages = page.children.accessible_by(current_ability, :see)
+      pages = pages.restricted if options.delete(:restricted_only)
+      if depth = options[:deepness]
+        pages = pages.where("#{Page.table_name}.depth <= #{depth}")
+      end
+      if options[:reverse]
+        pages.reverse!
+      end
+      render options[:navigation_partial],
+        options: options,
+        pages: pages,
+        html_options: html_options
+    end
+
+    # Renders navigation the children and all siblings of the given page (standard is the current page).
+    #
+    # Use this helper if you want to render the subnavigation independent from the mainnavigation. I.E. to place it in a different area on your website.
+    #
+    # This helper passes all its options to the the render_navigation helper.
+    #
+    # === Options:
+    #
+    #   from_page: @page                              # The page to render the navigation from
+    #   submenu: true                                 # Shows the nested children
+    #   level: 2                                      # Normally there is no need to change the level parameter, just in a few special cases
+    #
+    def render_subnavigation(options = {}, html_options = {})
+      default_options = {
+        from_page: @page,
+        submenu: true,
+        level: 2
+      }
+      options = default_options.merge(options)
+      if !options[:from_page].nil?
+        while options[:from_page].level > options[:level] do
+          options[:from_page] = options[:from_page].parent
+        end
+        render_navigation(options, html_options)
+      else
+        return nil
+      end
+    end
+
+    # Returns true if page is in the active branch
+    def page_active?(page)
+      @_page_ancestors ||= Page.ancestors_for(@page)
+      @_page_ancestors.include?(page)
+    end
+
+    # Returns +'active'+ if the given external page is in the current url path or +nil+.
+    def external_page_css_class(page)
+      return nil if !page.redirects_to_external?
+      request.path.split('/').delete_if(&:blank?).first == page.urlname.gsub(/^\//, '') ? 'active' : nil
+    end
+
+    # Returns page links in a breadcrumb beginning from root to current page.
+    #
+    # === Options:
+    #
+    #   separator: %(<span class="separator">></span>)      # Maybe you don't want this separator. Pass another one.
+    #   page: @page                                         # Pass a different Page instead of the default (@page).
+    #   without: nil                                        # Pass Page object or array of Pages that must not be displayed.
+    #   restricted_only: false                              # Pass boolean for displaying restricted pages only.
+    #   reverse: false                                      # Pass boolean for displaying breadcrumb in reversed reversed.
+    #
+    def render_breadcrumb(options={})
+      options = {
+        separator: ">",
+        page: @page,
+        restricted_only: false,
+        reverse: false,
+        link_active_page: false
+      }.merge(options)
+
+      pages = Page.
+        ancestors_for(options[:page]).
+        accessible_by(current_ability, :see)
+
+      if options.delete(:restricted_only)
+        pages = pages.restricted
+      end
+
+      if options.delete(:reverse)
+        pages.to_a.reverse!
+      end
+
+      if options[:without].present?
+        if options[:without].class == Array
+          pages = pages.to_a - options[:without]
+        else
+          pages.to_a.delete(options[:without])
+        end
+      end
+
+      render 'alchemy/breadcrumb/wrapper', pages: pages, options: options
+    end
+
+    # Returns current page title
+    #
+    # === Options:
+    #
+    #   prefix: ""                 # Prefix
+    #   separator: ""              # Separating prefix and title
+    #
+    # === Webdevelopers
+    #
+    # Please use the render_meta_data() helper instead. There all important meta information gets rendered in one helper.
+    # So you dont have to worry about anything.
+    #
+    def render_page_title(options = {})
+      return "" if @page.title.blank?
+      options = {
+        prefix: "",
+        separator: ""
+      }.update(options)
+      title_parts = [options[:prefix]]
+      if response.status == 200
+        title_parts << @page.title
+      else
+        title_parts << response.status
+      end
+      title_parts.join(options[:separator])
+    end
+
+    # Returns a complete html <title> tag for the <head> part of the html document.
+    #
+    # === Webdevelopers:
+    #
+    # Please use the render_meta_data() helper. There all important meta information gets rendered in one helper.
+    # So you dont have to worry about anything.
+    #
+    def render_title_tag(options={})
+      default_options = {
+        prefix: "",
+        separator: ""
+      }
+      options = default_options.merge(options)
+      %(<title>#{render_page_title(options)}</title>).html_safe
+    end
+
+    # Renders a html <meta> tag for name: "" and content: ""
+    #
+    # === Webdevelopers:
+    #
+    # Please use the render_meta_data() helper. There all important meta information gets rendered in one helper.
+    # So you dont have to worry about anything.
+    #
+    def render_meta_tag(options={})
+      default_options = {
+        name: "",
+        default_language: "de",
+        content: ""
+      }
+      options = default_options.merge(options)
+      lang = (@page.language.blank? ? options[:default_language] : @page.language.code)
+      %(<meta name="#{options[:name]}" content="#{options[:content]}" lang="#{lang}">).html_safe
+    end
+
+    # This helper takes care of all important meta tags for your page.
+    #
+    # The meta data is been taken from the @page.title, @page.meta_description, @page.meta_keywords, @page.updated_at and @page.language database entries managed by the Alchemy user via the Alchemy cockpit.
+    #
+    # Assume that the user has entered following data into the Alchemy cockpit of the Page "home" and that the user wants that the searchengine (aka. google) robot should index the page and should follow all links on this page:
+    #
+    # Title = Homepage
+    # Description = Your page description
+    # Keywords: cms, ruby, rubyonrails, rails, software, development, html, javascript, ajax
+    #
+    # Then placing +render_meta_data(title_prefix: "Company", title_separator: "-")+ into the <head> part of the +pages.html.erb+ layout produces:
+    #
+    #   <meta charset="UTF-8">
+    #   <title>Company - #{@page.title}</title>
+    #   <meta name="description" content="Your page description">
+    #   <meta name="keywords" content="cms, ruby, rubyonrails, rails, software, development, html, javascript, ajax">
+    #   <meta name="created" content="Tue Dec 16 10:21:26 +0100 2008">
+    #   <meta name="robots" content="index, follow">
+    #
+    def render_meta_data options={}
+      if @page.blank?
+        warning("No Page found!")
+        return nil
+      end
+      default_options = {
+        title_prefix: "",
+        title_separator: "",
+        default_lang: "de"
+      }
+      options = default_options.merge(options)
+      # render meta description of the root page from language if the current meta description is empty
+      if @page.meta_description.blank?
+        description = Language.current.pages.published.language_roots.try(:meta_description)
+      else
+        description = @page.meta_description
+      end
+      # render meta keywords of the root page from language if the current meta keywords is empty
+      if @page.meta_keywords.blank?
+        keywords = Language.current.pages.published.language_roots.try(:meta_keywords)
+      else
+        keywords = @page.meta_keywords
+      end
+      robot = "#{@page.robot_index? ? "" : "no"}index, #{@page.robot_follow? ? "" : "no"}follow"
+      meta_string = %(
+        <meta charset="UTF-8">
+        #{render_title_tag(prefix: options[:title_prefix], separator: options[:title_separator])}
+        #{render_meta_tag(name: "description", content: description)}
+        #{render_meta_tag(name: "keywords", content: keywords)}
+        <meta name="created" content="#{@page.updated_at}">
+        <meta name="robots" content="#{robot}">
+      )
+      if @page.contains_feed?
+        meta_string += %(
+          <link rel="alternate" type="application/rss+xml" title="RSS" href="#{show_alchemy_page_url(@page, format: :rss)}">
+        )
+      end
+      return meta_string.html_safe
+    end
+
+    # Renders the partial for the cell with the given name of the current page.
+    # Cell partials are located in +app/views/cells/+ of your project.
+    #
+    # === Options are:
+    #
+    #   from_page: Alchemy::Page     # Alchemy::Page object from which the elements are rendered from.
+    #   locals: Hash                 # Hash of variables that will be available in the partial. Example: {user: var1, product: var2}
+    #
+    def render_cell(name, options={})
+      default_options = {
+        from_page: @page,
+        locals: {}
+      }
+      options = default_options.merge(options)
+      cell = options[:from_page].cells.find_by_name(name)
+      return "" if cell.blank?
+      render partial: "alchemy/cells/#{name}", locals: {cell: cell}.merge(options[:locals])
+    end
+
+    # Returns true or false if no elements are in the cell found by name.
+    def cell_empty?(name)
+      cell = @page.cells.find_by_name(name)
+      return true if cell.blank?
+      cell.elements.blank?
+    end
+
+    # Include this in your layout file to have element selection magic in the page edit preview window.
+    def alchemy_preview_mode_code
+      if @preview_mode
+        output = javascript_tag("Alchemy = { locale: '#{session[:alchemy_locale]}' };")
+        output += javascript_include_tag("alchemy/preview")
+      end
+    end
+
+  end
+end