alchemy_cms 2.5.3.1 → 2.6.0.rc5

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

@@ -64,12 +64,20 @@ module Alchemy
       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 are returned as an array to be used in alchemy_selectbox form builder.
+      # Returns a elements options string for select helper.
+      #
+      # @param [Array] elements descriptions
+      # @return [String]
+      #
       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)
+        options = elements.collect do |e|
+          [
+            _t(e['name'], scope: 'element_names', default: e['name'].to_s.humanize),
+            e['name']
+          ]
+        end
+        options_for_select(options)
       end
 
       # Returns all elements that could be placed on that page because of the pages layout.
@@ -106,7 +114,7 @@ module Alchemy
           ]
         else
           [
-            Alchemy::I18n.t(e['name'], :scope => :element_names),
+            _t(e['name'], scope: :element_names, default: e['name'].to_s.humanize),
             e[object_method] + (cell ? "##{cell['name']}" : "")
           ]
         end

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

@@ -22,7 +22,7 @@ module Alchemy
       #   * 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('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,
@@ -68,7 +68,7 @@ module Alchemy
       #
       def render_essence_editor_by_name(element, name, options = {}, html_options = {})
         if element.blank?
-          return warning('Element is nil', _t("no_element_given"))
+          return warning('Element is nil', _t(:no_element_given))
         end
         content = element.content_by_name(name)
         if content.nil?
@@ -141,9 +141,7 @@ module Alchemy
           }.merge(image_options)),
           :alt => content.ingredient.name,
           :class => 'img_paddingtop',
-          :title => _t("image_name") + ": #{content.ingredient.name}",
-          :onload => "Alchemy.fadeImage(this, '##{content_dom_id(content)} .picture_content_spinner');",
-          :style => "display: none;"
+          :title => _t(:image_name) + ": #{content.ingredient.name}"
         )
       end
 

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

@@ -19,12 +19,14 @@ module Alchemy
             Alchemy.Tinymce = {
               init : function(callback) {
                 var init = { #{init} };
+                var spinner = Alchemy.Spinner.small();
+                $('.tinymce_container').prepend(spinner.spin().el);
                 init.mode = 'specific_textareas';
                 init.editor_selector = 'default_tinymce';
                 init.plugins = '#{Alchemy::Tinymce.plugins.join(',')}';
                 init.language = '#{::I18n.locale.to_s.split('-')[0].downcase }';
                 init.init_instance_callback = function(inst) {
-                  $('#' + inst.editorId).prev('.essence_richtext_loader').hide();
+                  $('#' + inst.editorId).prev('.spinner').remove();
                 }
                 if (callback)
                   init.oninit = callback;
@@ -67,9 +69,10 @@ module Alchemy
                 init.language = '#{::I18n.locale.to_s.split('-')[0].downcase }';
                 init.init_instance_callback = function(inst) {
                   var $this = $('#' + inst.editorId);
-                  $this.prev('.essence_richtext_loader').hide();
+                  var parent = $this.parents('.element_editor');
+                  parent.find('.spinner').remove();
                   inst.onChange.add(function (ed, l) {
-                    Alchemy.setElementDirty($this.parents('.element_editor'));
+                    Alchemy.setElementDirty(parent);
                   });
                 }
                 tinymce.init(init);

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

@@ -0,0 +1,60 @@
+module Alchemy
+  module Admin
+    module TagsHelper
+
+      # Checks if the tagged_with param contains the given tag
+      def filtered_by_tag?(tag)
+        if params[:tagged_with].present?
+          tags = params[:tagged_with].split(',')
+          tags.include?(tag.name)
+        else
+          false
+        end
+      end
+
+      # Adds the given tag to the tag filter.
+      def add_to_tag_filter(tag)
+        if params[:tagged_with].present?
+          tags = params[:tagged_with].split(',')
+          tags << tag.name
+        else
+          [tag.name]
+        end
+      end
+
+      # Removes the given tag from the tag filter.
+      def remove_from_tag_filter(tag)
+        if params[:tagged_with].present?
+          tags = params[:tagged_with].split(',')
+          tags.delete_if { |t| t == tag.name }
+        else
+          []
+        end
+      end
+
+      # Returns the tag filter from params.
+      #
+      # A tag can be added to the filter.
+      # A tag can also be removed.
+      #
+      # Options are:
+      #   * options (Hash):
+      #   ** :add (ActsAsTaggableOn::Tag) - The tag that should be added to the tag-filter
+      #   ** :remove (ActsAsTaggableOn::Tag) - The tag that should be removed from the tag-filter
+      #
+      def tag_filter(options={})
+        case
+          when options[:add]
+            taglist = add_to_tag_filter(options[:add]) if options[:add]
+          when options[:remove]
+            taglist = remove_from_tag_filter(options[:remove]) if options[:remove]
+          else
+            return params[:tagged_with]
+        end
+        return nil if taglist.blank?
+        taglist.uniq.join(',')
+      end
+
+    end
+  end
+end

data/app/helpers/alchemy/base_helper.rb

@@ -69,26 +69,7 @@ module Alchemy
     # I.e. used to find the active page in navigation.
     def breadcrumb(current)
       return [] if current.nil?
-      result = Array.new
-      result << current
-      while current = current.parent
-        result << current
-      end
-      return result.reverse
-    end
-
-    # Returns a hash with urlname for each url level.
-    # I.e.: +{:level1 => 'company', :level2 => 'history'}+
-    def params_for_nested_url(page = nil)
-      page ||= @page
-      raise ArgumentError if page.nil?
-      nested_urL_params = {}
-      page_bread_crumb = breadcrumb(page)
-      urlnames = page_bread_crumb[2..page_bread_crumb.length-2].collect(&:urlname)
-      urlnames.each_with_index do |urlname, i|
-        nested_urL_params["level#{i+1}"] = urlname
-      end
-      nested_urL_params.symbolize_keys
+      current.self_and_ancestors.where("parent_id IS NOT NULL")
     end
 
     # Returns the Alchemy configuration.
@@ -120,5 +101,20 @@ module Alchemy
       render('alchemy/admin/partials/flash', flash_type: style, message: notice)
     end
 
+    # Checks if the given argument is a String or a Page object.
+    # If a String is given, it tries to find the page via page_layout
+    # 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
+      end
+      if page.blank?
+        warning("No Page found for #{page.inspect}")
+        return
+      else
+        page
+      end
+    end
+
   end
 end

data/app/helpers/alchemy/elements_helper.rb

@@ -11,9 +11,9 @@ module Alchemy
     #
     #   :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.
-    #   :from_cell                           # The Cell object from which the elements are rendered from.
-    #   :count                               # The amount of elements to be rendered (begins with first element found)
+    #   :from_page => @page                  # The Alchemy::Page.page_layout string from which the elements are rendered from, or you even pass a Page object.
+    #   :from_cell => nil                    # The Cell object from which the elements are rendered from.
+    #   :count => nil                        # The amount of elements to be rendered (begins with first element found)
     #   :fallback => {                       # You can use the fallback option as an override. So you can take elements from a glo´bal laout page and only if the user adds an element on current page the local one gets rendered.
     #     :for => 'ELEMENT_NAME',            # The name of the element the fallback is for
     #     :with => 'ELEMENT_NAME',           # (OPTIONAL) the name of element to fallback with
@@ -30,7 +30,7 @@ module Alchemy
       default_options = {
         :except => [],
         :only => [],
-        :from_page => "",
+        :from_page => @page,
         :from_cell => nil,
         :count => nil,
         :offset => nil,
@@ -39,14 +39,10 @@ module Alchemy
         :fallback => nil
       }
       options = default_options.merge(options)
-      if options[:from_page].blank?
-        page = @page
+      if options[:from_page].class == Page
+        page = options[:from_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
+        page = Page.where(:page_layout => options[:from_page]).with_language(session[:language_id]).all
       end
       if page.blank?
         warning('Page is nil')

data/app/helpers/alchemy/essences_helper.rb

@@ -110,9 +110,9 @@ module Alchemy
     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"))
+        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"))
+        return part == :view ? "" : warning('Essence is nil', _t(:content_essence_not_found))
       end
       render(
         :partial => "alchemy/essences/#{content.essence_partial_name}_#{part.to_s}",

data/app/helpers/alchemy/pages_helper.rb

@@ -131,57 +131,45 @@ module Alchemy
     #   :submenu => 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. E.g. for dropdown menues.
     #   :all_sub_menues => false                              # Renders the whole page tree.
     #   :from_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.
-    #   :spacer => ""                                         # Yeah even a spacer for the entries can be passed. Simple string, or even a complex html structure. E.g: "<span class='spacer'>|</spacer>". Only your imagination is the limit. And the W3C of course :)
-    #   :navigation_partial => "navigation/renderer"          # Pass a different partial to be taken for the navigation rendering. CAUTION: Only for the advanced Alchemy webdevelopers. The standard partial takes care of nearly everything. But maybe you are an adventures one ^_^
+    #   :spacer => nil                                        # A spacer for the entries can be passed. Simple string, or even a complex html structure. E.g: "<span class='spacer'>|</spacer>".
+    #   :navigation_partial => "navigation/renderer"          # Pass a different partial to be taken for the navigation rendering.
     #   :navigation_link_partial => "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.
     #   :show_nonactive => 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). E.g. for the popular css-driven dropdownmenues these days.
     #   :show_title => true                                   # For our beloved SEOs :). Appends a title attribute to all links and places the page.title content into it.
-    #   :restricted_only => nil                               # Render only restricted pages.
+    #   :restricted_only => false                             # Render only restricted pages. I.E for members only navigations.
     #   :show_title => true                                   # Show a title on navigation links. Title attribute from page.
     #   :reverse => false                                     # Reverse the navigation
     #   :reverse_children => false                            # Reverse the nested children
+    #   :deepness => nil                                      # Show only pages up to this depth.
     #
     # === Passing HTML classes and ids to the renderer
     #
-    # A second hash will be passed as html_options to the navigation renderer partial.
+    # A second hash can be passed as html_options to the navigation renderer partial.
     #
     # ==== Example:
     #
     #   <%= render_navigation({from_page => 'subnavi'}, {:class => 'navigation', :id => 'subnavigation'}) %>
     #
     def render_navigation(options = {}, html_options = {})
-      default_options = {
+      options = {
         :submenu => false,
         :all_sub_menues => false,
         :from_page => @root_page || Page.language_root_for(session[:language_id]),
-        :spacer => "",
+        :spacer => nil,
         :navigation_partial => "alchemy/navigation/renderer",
         :navigation_link_partial => "alchemy/navigation/link",
         :show_nonactive => false,
-        :restricted_only => nil,
+        :restricted_only => false,
         :show_title => true,
         :reverse => false,
         :reverse_children => false
-      }
-      options = default_options.merge(options)
-      if options[:from_page].is_a?(String)
-        page = Page.find_by_page_layout_and_language_id(options[:from_page], session[:language_id])
-      else
-        page = options[:from_page]
+      }.merge(options)
+      page = page_or_find(options[:from_page])
+      pages = page.children.visible.with_permissions_to(:show, :context => :alchemy_pages)
+      pages = pages.restricted if options.delete(:restricted_only)
+      if depth = options[:deepness]
+        pages = pages.where("#{Page.table_name}.depth <= #{depth}")
       end
-      if page.blank?
-        warning("No Page found for #{options[:from_page]}")
-        return ""
-      end
-      conditions = {
-        :parent_id => page.id,
-        :restricted => options[:restricted_only] || false,
-        :visible => true
-      }
-      if options[:restricted_only].nil?
-        conditions.delete(:restricted)
-      end
-      pages = Page.where(conditions).order("lft ASC")
       if options[:reverse]
         pages.reverse!
       end
@@ -240,60 +228,34 @@ module Alchemy
     #
     #   :seperator => %(<span class="seperator">></span>)      # Maybe you don't want this seperator. Pass another one.
     #   :page => @page                                         # Pass a different Page instead of the default (@page).
-    #   :without => nil                                        # Pass Pageobject or array of Pages that must not be displayed.
-    #   :public_only => false                                  # Pass boolean for displaying published pages only.
-    #   :visible_only => true                                  # Pass boolean for displaying (in navigation) visible pages only.
+    #   :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 reversed breadcrumb.
+    #   :reverse => false                                      # Pass boolean for displaying breadcrumb in reversed reversed.
     #
     def render_breadcrumb(options={})
-      default_options = {
+      options = {
         :seperator => %(<span class="seperator">&gt;</span>),
         :page => @page,
-        :without => nil,
-        :public_only => true,
-        :visible_only => true,
         :restricted_only => false,
         :reverse => false,
         :link_active_page => false
-      }
-      options = default_options.merge(options)
-      pages = breadcrumb(options[:page])
-      pages.delete(Page.root)
-      unless options[:without].nil?
-        unless options[:without].class == Array
-          pages.delete(options[:without])
+      }.merge(options)
+      pages = breadcrumb(options[:page]).published.visible.with_permissions_to(:show, :context => :alchemy_pages)
+      pages = pages.restricted if options.delete(:restricted_only)
+      pages.to_a.reverse! if options[:reverse]
+      if options[:without].present?
+        if options[:without].class == Array
+          pages = pages.to_a - options[:without]
         else
-          pages = pages - options[:without]
+          pages.to_a.delete(options[:without])
         end
       end
-      if options[:visible_only]
-        pages.reject! { |p| !p.visible? }
-      end
-      if options[:public_only]
-        pages.reject! { |p| !p.public? }
-      end
-      if options[:restricted_only]
-        pages.reject! { |p| !p.restricted? }
-      end
-      if options[:reverse]
-        pages.reverse!
-      end
-      bc = []
-      pages.each do |page|
-        css_class = page.name == @page.name ? "active" : nil
-        if page == pages.last
-          css_class = css_class.blank? ? "last" : [css_class, "last"].join(" ")
-        elsif page == pages.first
-          css_class = css_class.blank? ? "first" : [css_class, "first"].join(" ")
-        end
-        if !options[:link_active_page] && page.name == @page.name
-          bc << content_tag(:span, h(page.name), :class => css_class)
-        else
-          bc << link_to(h(page.name), show_alchemy_page_path(page), :class => css_class, :title => page.title)
-        end
-      end
-      bc.join(options[:seperator]).html_safe
+      render(
+        partial: 'alchemy/breadcrumb/page',
+        collection: pages,
+        spacer_template: 'alchemy/breadcrumb/spacer',
+        locals: {pages: pages, options: options}
+      )
     end
 
     # Returns current page title

data/app/helpers/alchemy/url_helper.rb

@@ -77,11 +77,19 @@ module Alchemy
     # Returns the correct params-hash for passing to show_page_path
     def show_page_path_params(page, optional_params={})
       raise ArgumentError, 'Page is nil' if page.nil?
-      url_params = {:level1 => nil, :level2 => nil, :level3 => nil, :urlname => page.urlname}
-      url_params.update(optional_params)
-      url_params.update(params_for_nested_url(page)) if configuration(:url_nesting)
+      url_params = {:urlname => page.urlname}.update(optional_params)
       multi_language? ? url_params.update(:lang => page.language_code) : url_params
     end
 
+    # Returns the path for downloading an alchemy attachment
+    def download_alchemy_attachment_path(attachment)
+      alchemy.download_attachment_path(attachment, attachment.urlname)
+    end
+
+    # Returns the url for downloading an alchemy attachment
+    def download_alchemy_attachment_url(attachment)
+      alchemy.download_attachment_url(attachment, attachment.urlname)
+    end
+
   end
 end

data/app/models/alchemy/attachment.rb

@@ -1,33 +1,52 @@
 module Alchemy
   class Attachment < ActiveRecord::Base
+    include Filetypes
+    include NameConversions
+
+    acts_as_taggable
+    file_accessor :file
+    stampable :stamper_class_name => 'Alchemy::User'
+
+    attr_accessible :file, :name, :file_name, :tag_list
 
     has_many :essence_files, :class_name => 'Alchemy::EssenceFile', :foreign_key => 'attachment_id'
     has_many :contents, :through => :essence_files
     has_many :elements, :through => :contents
     has_many :pages, :through => :elements
 
-    attr_accessible :uploaded_data, :name, :filename, :tag_list
+    validates_presence_of :file
+    validates_format_of :file_name, :with => /^[A-Za-z0-9\.\-_]+$/, :on => :update
+    validates_size_of :file, :maximum => Config.get(:uploader)['file_size_limit'].megabytes
+    validates_property(
+      :format,
+      :of => :file,
+      :in => Config.get(:uploader)['allowed_filetypes']['attachments'],
+      :case_sensitive => false,
+      :message => I18n.t("not a valid file"),
+      :unless => proc { Config.get(:uploader)['allowed_filetypes']['attachments'].include?('*') }
+    )
+
+    before_create do
+      write_attribute(:name, convert_to_humanized_name(self.file_name, self.file.ext))
+      write_attribute(:file_name, sanitized_filename)
+    end
 
-    stampable(:stamper_class_name => 'Alchemy::User')
+    # Class methods
 
-    acts_as_taggable
-    has_attachment(
-      :storage => :file_system,
-      :file_system_path => 'uploads/attachments',
-      :size => 0.kilobytes..1000.megabytes
-    )
-    validates_as_attachment
+    class << self
+
+      def find_paginated(params, per_page, order)
+        attachments = Attachment.arel_table
+        cond = attachments[:name].matches("%#{params[:query]}%").or(attachments[:file_name].matches("%#{params[:query]}%"))
+        self.where(cond).page(params[:page] || 1).per(per_page).order(order)
+      end
 
-    def self.find_paginated(params, per_page)
-      attachments = Attachment.arel_table
-      cond = attachments[:name].matches("%#{params[:query]}%").or(attachments[:filename].matches("%#{params[:query]}%"))
-      self.where(cond).page(params[:page] || 1).per(per_page).order(:name)
     end
 
+    # Instance methods
+
     def urlname
-      parts = filename.split('.')
-      sfx = parts.pop
-      "#{parts.join('-')}.#{sfx}"
+      read_attribute :file_name
     end
 
     # Checks if the attachment is restricted, because it is attached on restricted pages only
@@ -36,41 +55,50 @@ module Alchemy
     end
 
     def extension
-      filename.split(".").last
+      file_name.split(".").last
     end
     alias_method :suffix, :extension
 
+    # Returns a css class name for kind of file
+    #
     def icon_css_class
-      case content_type
-      when "application/x-flash-video" then "video"
-      when "video/x-flv" then "video"
-      when "video/mp4" then "video"
-      when "video/mpeg" then "video"
-      when "video/quicktime" then "video"
-      when "video/x-msvideo" then "video"
-      when "video/x-ms-wmv" then "video"
-      when "application/zip" then "archive"
-      when "application/x-rar" then "archive"
-      when "audio/mpeg" then "audio"
-      when "audio/mp4" then "audio"
-      when "audio/wav" then "audio"
-      when "audio/x-wav" then "audio"
-      when "application/x-shockwave-flash" then "flash"
-      when "image/gif" then "image"
-      when "image/jpeg" then "image"
-      when "image/png" then "image"
-      when "image/tiff" then "image"
-      when "image/x-psd" then "psd"
-      when "text/plain" then "text"
-      when "application/rtf" then "rtf"
-      when "application/pdf" then "pdf"
-      when "application/msword" then "word"
-      when "application/vnd.ms-excel" then "excel"
-      when "text/x-vcard" then "vcard"
-      when "application/vcard" then "vcard"
-      else "file"
+      case file_mime_type
+        when *ARCHIVE_FILE_TYPES
+          then "archive"
+        when *AUDIO_FILE_TYPES
+          then "audio"
+        when *IMAGE_FILE_TYPES
+          then "image"
+        when *VIDEO_FILE_TYPES
+          then "video"
+        when "application/x-shockwave-flash"
+          then "flash"
+        when "image/x-psd"
+          then "psd"
+        when "text/plain"
+          then "text"
+        when "application/rtf"
+          then "rtf"
+        when "application/pdf"
+          then "pdf"
+        when "application/msword"
+          then "word"
+        when "application/vnd.ms-excel"
+          then "excel"
+        when *VCARD_FILE_TYPES
+          then "vcard"
+        else "file"
       end
     end
 
+  private
+
+    def sanitized_filename
+      parts = self.file_name.split('.')
+      sfx = parts.pop
+      name = convert_to_urlname(parts.join('-'))
+      "#{name}.#{sfx}"
+    end
+
   end
 end