alchemy_cms 2.9.1 → 3.0.0.rc5

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

@@ -39,20 +39,19 @@ module Alchemy
       end
       alias_method :render_picture_editor, :render_picture_gallery_editor
 
-      # Returns a elements options string for select helper.
+      # Returns an elements array for select helper.
       #
       # @param [Array] elements descriptions
-      # @return [String]
+      # @return [Array]
       #
       def elements_for_select(elements)
         return [] if elements.nil?
-        options = elements.collect do |e|
+        elements.collect do |e|
           [
             Element.display_name_for(e['name']),
             e['name']
           ]
         end
-        options_for_select(options)
       end
 
       # Returns all elements that could be placed on that page because of the pages layout.
@@ -78,7 +77,7 @@ module Alchemy
             element_array_for_options(e, object_method)
           end
         end
-        return grouped_options_for_select(options)
+        options
       end
 
       def element_array_for_options(e, object_method, cell = nil)

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

@@ -8,40 +8,7 @@ module Alchemy
       # 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 = {})
-        ActiveSupport::Deprecation.warn("Used deprecated render_essence_editor_by_type helper. It will be removed in Alchemy v3.0. You can use render_essence_editor_by_name instead.")
-        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
+        render_essence(content, :editor, {for_editor: options}, html_options)
       end
 
       # Renders the Content editor partial found in views/contents/ for the content with name inside the passed Element.
@@ -63,50 +30,6 @@ module Alchemy
         end
       end
 
-      # Renders the EssenceSelect editor partial with a form select for storing page ids
-      #
-      # === 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. Default is id.
-      #   :global          [Boolean]  # Display only global pages. Default is false.
-      #   :order_by        [Symbol]   # Order pages by this attribute.
-      #
-      # NOTE: The +order_by+ option only works if the +only+ or the +global+ option is also set.
-      # Then the default ordering is by :name.
-      # Otherwise the pages are ordered by their position in the nested set.
-      #
-      def page_selector(element, content_name, options = {}, select_options = {})
-        ActiveSupport::Deprecation.warn("Used deprecated page_selector helper. It will be removed in Alchemy v3.0. Please use a select_tag with pages_for_select instead.")
-        default_options = {
-          :page_attribute => :id,
-          :global => false,
-          :prompt => _t('Choose page'),
-          :order_by => :name
-        }
-        options = default_options.merge(options)
-        content = element.content_by_name(content_name)
-        if options[:global] || options[:only].present?
-          pages = Page.where({
-            :language_id => session[:language_id],
-            :layoutpage => options[:global] == true,
-            :public => options[:global] == false
-          })
-          if options[:only].present?
-            pages = pages.where({:page_layout => options[:only]})
-          end
-          pages_options_tags = pages_for_select(pages.order(options[:order_by]), content ? content.ingredient : nil, options[:prompt], options[:page_attribute])
-        else
-          pages_options_tags = pages_for_select(nil, content ? content.ingredient : nil, options[:prompt], options[:page_attribute])
-        end
-        options.update(:select_values => pages_options_tags)
-        if content.nil?
-          render_missing_content(element, content_name, options)
-        else
-          render_essence_editor(content, options)
-        end
-      end
-
       # Returns all public pages from current language as an option tags string suitable or the Rails +select_tag+ helper.
       #
       # @param [Array]
@@ -122,7 +45,7 @@ module Alchemy
         values = [[_t(prompt), ""]]
         pages ||= begin
           nested = true
-          Page.with_language(session[:language_id]).published.order(:lft)
+          Language.current.pages.published.order(:lft)
         end
         values += pages_attributes_for_select(pages, page_attribute, nested)
         options_for_select(values, selected.to_s)
@@ -137,24 +60,24 @@ module Alchemy
       def essence_picture_thumbnail(content, options)
         return if content.ingredient.blank?
         image_options = {
-          :size => content.ingredient.cropped_thumbnail_size(content.essence.render_size.blank? ? options[:image_size] : content.essence.render_size),
-          :crop_from => content.essence.crop_from.blank? ? nil : content.essence.crop_from,
-          :crop_size => content.essence.crop_size.blank? ? nil : content.essence.crop_size,
-          :crop => content.essence.crop_size.blank? && content.essence.crop_from.blank? ? 'crop' : nil
+          size: content.ingredient.cropped_thumbnail_size(content.essence.render_size.blank? ? options[:image_size] : content.essence.render_size),
+          crop_from: content.essence.crop_from.blank? ? nil : content.essence.crop_from,
+          crop_size: content.essence.crop_size.blank? ? nil : content.essence.crop_size,
+          crop: content.essence.crop_size.blank? && content.essence.crop_from.blank? ? 'crop' : nil
         }
         image_tag(
           alchemy.thumbnail_path({
-            :id => content.ingredient.id,
-            :name => content.ingredient.urlname,
-            :sh => content.ingredient.security_token(image_options)
+            id: content.ingredient.id,
+            name: content.ingredient.urlname,
+            sh: content.ingredient.security_token(image_options)
           }.merge(image_options)),
-          :alt => content.ingredient.name,
-          :class => 'img_paddingtop',
-          :title => _t(:image_name) + ": #{content.ingredient.name}"
+          alt: content.ingredient.name,
+          class: 'img_paddingtop',
+          title: _t(:image_name) + ": #{content.ingredient.name}"
         )
       end
 
-    private
+      private
 
       # Returns an Array with page attributes for select options
       #

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

@@ -0,0 +1,30 @@
+module Alchemy
+  module Admin
+    module FormHelper
+
+      # Use this form helper to render any form in Alchemy admin interface.
+      #
+      # This is simply a wrapper for `simple_form_for`
+      #
+      # == Defaults
+      #
+      # * It uses Alchemy::Forms::Builder as builder
+      # * It makes a remote request, if the request was XHR request.
+      # * It adds the alchemy class to form
+      #
+      def alchemy_form_for(object, *args, &block)
+        options = args.extract_options!
+        options.merge!({
+          builder: Alchemy::Forms::Builder,
+          remote: request.xhr?,
+          html: {
+            id: options.delete(:id),
+            class: ["alchemy", options.delete(:class)].compact.join(' ')
+          }
+        })
+        simple_form_for(object, *(args << options), &block)
+      end
+
+    end
+  end
+end

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

@@ -33,10 +33,25 @@ module Alchemy
 
       # Used for checking the main navi permissions
       #
+      # To let your module be navigatable by the user you have to provide an Ability for it.
+      #
+      # === Example:
+      #
+      #   # module.yml
+      #   name: 'my_module'
+      #   navigation: {
+      #     controller: 'my/admin/posts'
+      #     action: 'index'
+      #   }
+      #
+      #   # ability.rb
+      #   can :index, :my_admin_posts
+      #
       def navigate_module(navigation)
+        navigation.stringify_keys!
         [
           navigation['action'].to_sym,
-          navigation['controller'].gsub(/^\//, '').gsub(/\//, '_').to_sym
+          navigation['controller'].to_s.gsub(/\A\//, '').gsub(/\//, '_').to_sym
         ]
       end
 
@@ -95,6 +110,23 @@ module Alchemy
         )
       end
 
+      # Alchemy modules for main navigation.
+      #
+      # Sorted by position attribute, if given.
+      #
+      def sorted_alchemy_modules
+        sorted = []
+        not_sorted = []
+        alchemy_modules.map do |m|
+          if m['position'].blank?
+            not_sorted << m
+          else
+            sorted << m
+          end
+        end
+        sorted.sort_by { |m| m['position'] } + not_sorted
+      end
+
       private
 
       # Calls +url_for+ helper on engine if present or on host app.
@@ -180,7 +212,7 @@ module Alchemy
       # Returns true if the given entry's controller is current controller
       #
       def is_entry_controller_active?(entry)
-        entry['controller'].gsub(/^\//, '') == params[:controller]
+        entry['controller'].gsub(/\A\//, '') == params[:controller]
       end
 
       # Returns true if the given entry's action is current controllers action

data/app/helpers/alchemy/base_helper.rb

@@ -13,7 +13,7 @@ module Alchemy
 
     def parse_sitemap_name(page)
       if multi_language?
-        pathname = "/#{session[:language_code]}/#{page.urlname}"
+        pathname = "/#{Language.current.code}/#{page.urlname}"
       else
         pathname = "/#{page.urlname}"
       end
@@ -33,7 +33,7 @@ module Alchemy
 
     # Returns an icon
     def render_icon(icon_class)
-      content_tag('span', '', class: "icon #{icon_class}")
+      content_tag('span', '', :class => "icon #{icon_class}")
     end
 
     # Returns a div with an icon and the passed content
@@ -95,7 +95,7 @@ module Alchemy
     # Logs a warning if no page is given.
     def page_or_find(page)
       if page.is_a?(String)
-        page = Page.where(page_layout: page, language_id: session[:language_id]).first
+        page = Language.current.pages.find_by(page_layout: page)
       end
       if page.blank?
         warning("No Page found for #{page.inspect}")

data/app/helpers/alchemy/elements_helper.rb

@@ -74,54 +74,25 @@ module Alchemy
     #   A string that will be used to join the element partials. Default nil
     #
     def render_elements(options = {})
-      default_options = {
-        :except => [],
-        :only => [],
-        :from_page => @page,
-        :from_cell => nil,
-        :count => nil,
-        :offset => nil,
-        :locals => {},
-        :render_format => "html",
-        :fallback => nil
-      }
-      options = default_options.merge(options)
-      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
+      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
-      if page.blank?
-        warning('Page is nil')
-        return ""
-      else
-        if page.class == Array
-          all_elements = page.collect { |p| p.find_elements(options) }.flatten
-        else
-          all_elements = page.find_elements(options)
-        end
-        if options[:sort_by].present?
-          all_elements = all_elements.sort_by { |e| e.contents.detect { |c| c.name == options[:sort_by] }.ingredient }
-        end
-        element_string = ""
-        if options[:fallback]
-          if all_elements.detect { |e| e.name == options[:fallback][:for] }.blank?
-            if options[:fallback][:from].class.name == 'Alchemy::Page'
-              from = options[:fallback][:from]
-            else
-              from = Page.not_restricted.where(:page_layout => options[:fallback][:from]).with_language(session[:language_id]).first
-            end
-            if from
-              all_elements += from.elements.named(options[:fallback][:with].blank? ? options[:fallback][:for] : options[:fallback][:with])
-            end
-          end
-        end
-        element_string = []
-        all_elements.each_with_index do |element, i|
-          element_string << render_element(element, :view, options, i+1)
-        end
-        element_string.join(options[:separator]).html_safe
+
+      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.
@@ -171,103 +142,33 @@ module Alchemy
     # @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.
+    # @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)
-      begin
-        if element.blank?
-          warning('Element is nil')
-          render :partial => "alchemy/elements/#{part}_not_found", :locals => {:name => 'nil'}
-        else
-          element.store_page(@page) if part == :view
-          locals = options.delete(:locals)
-          render(
-            :partial => "alchemy/elements/#{element.name.underscore}_#{part}",
-            :locals => {
-              :element => element,
-              :counter => counter,
-              :options => options
-            }.merge(locals || {})
-          )
-        end
-      rescue ActionView::MissingTemplate => e
-        warning(%(
-          Element #{part} partial not found for #{element.name}.\n
-          #{e}
-        ))
-        render :partial => "alchemy/elements/#{part}_not_found", :locals => {:name => element.name, :error => "Element #{part} partial not found.<br>Use <code>rails generate alchemy:elements</code> to generate it."}
-      end
-    end
-
-    # This helper returns all published elements with the given name.
-    #
-    # @param [Hash] options
-    #   Additional options.
-    #
-    # @option options [Number] :count
-    #   The amount of elements to be returned.
-    #
-    # @option options [Alchemy::Page/String] :from_page
-    #   Only elements associated with this page are returned.
-    #
-    # @note When passing a String for options :from_page, it must be a page_layout name.
-    #
-    def all_elements_by_name(name, options = {})
-      ActiveSupport::Deprecation.warn("Used deprecated all_elements_by_name helper. It will be removed in Alchemy v3.0. Please build the relevant behavior on your own.")
-      warning('options[:language] option not allowed any more in all_elements_by_name helper') unless options[:language].blank?
-      options = {
-        count: :all,
-        from_page: :all
-      }.merge(options)
-
-      case options[:from_page]
-      when :all
-        return Element.published.where(name: name).limit(options[:count] == :all ? nil : options[:count])
-      when String
-        page = Page.with_language(session[:language_id]).find_by_page_layout(options[:from_page])
-      else
-        page = options[:from_page]
+      if element.nil?
+        warning('Element is nil')
+        render "alchemy/elements/#{part}_not_found", {name: 'nil'}
+        return
       end
 
-      return [] if page.blank?
-      page.elements.published.where(name: name).limit(options[:count] == :all ? nil : options[:count])
-    end
-
-    # This helper returns a published element found by the given name and the given published Page, either by Page.id or by Page.urlname
-    #
-    # @param [Hash] options
-    #   Additional options.
-    #
-    # @option options [String] :page_urlname
-    #   The urlname of the Page the element is associated with
-    #
-    # @option options [Integer] :page_id
-    #   The id of the Page the element is associated with
-    #
-    def element_from_page(options = {})
-      ActiveSupport::Deprecation.warn("Used deprecated element_from_page helper. It will be removed in Alchemy v3.0. Please build the relevant behavior on your own.")
-      default_options = {
-        page_urlname: "",
-        page_id: nil,
-        element_name: ""
-      }.merge(options)
-
-      page = case options[:page_id]
-      when nil
-        Page.published.find_by_urlname(options[:page_urlname])
-      else
-        Page.published.find_by_id(options[:page_id])
-      end
+      element.store_page(@page) if part.to_sym == :view
 
-      return "" if page.blank?
-      page.elements.published.find_by_name(options[:element_name])
-    end
+      render "alchemy/elements/#{element.name}_#{part}", {
+        element: element,
+        counter: counter,
+        options: options
+      }.merge(options.delete(:locals) || {})
 
-    # Renders all element partials from given cell.
-    def render_cell_elements(cell)
-      ActiveSupport::Deprecation.warn("Used deprecated render_cell_elements helper. It will be removed in Alchemy v3.0. You can use render_elements(from_cell: cell) instead.")
-      return warning("No cell given.") if cell.blank?
-      render_elements({:from_cell => cell})
+    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
@@ -287,11 +188,6 @@ module Alchemy
       { :'data-alchemy-element' => element.id }
     end
 
-    # Returns the full url containing host, page and anchor for the given element
-    def full_url_for_element(element)
-      "#{current_server}/#{element.page.urlname}##{element_dom_id(element)}"
-    end
-
     # Returns the element's tags information as a string. Parameters and options
     # are equivalent to {#element_tags_attributes}.
     #
@@ -324,5 +220,72 @@ module Alchemy
       { :'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