alchemy_cms 2.6.3 → 2.7.0

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

@@ -19,7 +19,7 @@ module Alchemy
             :controller => :essence_pictures,
             :action => :assign,
             :picture_id => picture_to_assign.id,
-            :id => @content.id,
+            :content_id => @content.id,
             :options => options
           }
         end

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

@@ -2,6 +2,48 @@ module Alchemy
   module Admin
     module TagsHelper
 
+      # Renders tags list items for given class name
+      #
+      # @param class_name [String]
+      #   The class_name representing a tagged class
+      #
+      # @return [String]
+      #   A HTML string containing <tt><li></tt> tags
+      #
+      def render_tag_list(class_name, params)
+        raise ArgumentError.new('Please provide a String as class_name') if class_name.nil?
+        li_s = []
+        class_name.constantize.tag_counts.sort { |x, y| x.name.downcase <=> y.name.downcase }.each do |tag|
+          tags = filtered_by_tag?(tag) ? tag_filter(remove: tag) : tag_filter(add: tag)
+          li_s << content_tag('li', name: tag.name, class: tag_list_tag_active?(tag, params) ? 'active' : nil) do
+            link_to(
+              "#{tag.name} (#{tag.count})",
+              url_for(
+                params.delete_if { |k, v| k == "page" }.merge(
+                  action: 'index',
+                  tagged_with: tags
+                )
+              ),
+              remote: request.xhr?,
+              class: 'please_wait'
+            )
+          end
+        end
+        li_s.join.html_safe
+      end
+
+      # Returns true if the given tag is in +params[:tag_list]+
+      #
+      # @param tag [ActsAsTaggableOn::Tag]
+      #   the tag
+      # @param params [Hash]
+      #   url params
+      # @return [Boolean]
+      #
+      def tag_list_tag_active?(tag, params)
+        params[:tagged_with].to_s.split(',').include?(tag.name)
+      end
+
       # Checks if the tagged_with param contains the given tag
       def filtered_by_tag?(tag)
         if params[:tagged_with].present?

data/app/helpers/alchemy/base_helper.rb

@@ -11,17 +11,6 @@ module Alchemy
       text.truncate(:length => length)
     end
 
-    # Returns @language set in the action (e.g. Page.show)
-    def current_language
-      ActiveSupport::Deprecation.warn('This Proxy-method is deprecated. Please use @language directly.')
-      if @language.nil?
-        warning('@language is not set')
-        nil
-      else
-        @language
-      end
-    end
-
     def parse_sitemap_name(page)
       if multi_language?
         pathname = "/#{session[:language_code]}/#{page.urlname}"

data/app/helpers/alchemy/elements_helper.rb

@@ -196,42 +196,66 @@ module Alchemy
       end
     end
 
-    # Returns all public elements found by Element.name.
-    # Pass a count to return only an limited amount of elements.
+    # 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 = {})
       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.published.where(:name => name).limit(options[:count] == :all ? nil : options[:count])
-      elsif options[:from_page].class == String
+      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])
-        return [] if page.blank?
-        elements = page.elements.published.where(:name => name).limit(options[:count] == :all ? nil : options[:count])
       else
-        elements = options[:from_page].elements.published.where(:name => name).limit(options[:count] == :all ? nil : options[:count])
+        page = options[:from_page]
       end
+
+      return [] if page.blank?
+      page.elements.published.where(name: name).limit(options[:count] == :all ? nil : options[:count])
     end
 
-    # Returns the public element found by Element.name from the given public Page, either by Page.id or by Page.urlname
+    # 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 = {})
       default_options = {
-        :page_urlname => "",
-        :page_id => nil,
-        :element_name => ""
-      }
-      options = default_options.merge(options)
-      if options[:page_id].blank?
-        page = Page.published.find_by_urlname(options[:page_urlname])
+        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 = Page.published.find_by_id(options[:page_id])
+        Page.published.find_by_id(options[:page_id])
       end
+
       return "" if page.blank?
-      element = page.elements.published.find_by_name(options[:element_name])
-      return element
+      page.elements.published.find_by_name(options[:element_name])
     end
 
     # Renders all element partials from given cell.
@@ -274,7 +298,6 @@ module Alchemy
       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.

data/app/helpers/alchemy/essences_helper.rb

@@ -72,26 +72,6 @@ module Alchemy
       render_essence_view(content, options, html_options)
     end
 
-    # Renders the +Essence+ view partial from +Element+ by position.
-    #
-    # Pass the position of the +Content+ inside the Element as second argument.
-    #
-    # == Example:
-    #
-    # This renders the second +Content+ from element.
-    #
-    #   <%= render_essence_view_by_type(element, 2) %>
-    #
-    def render_essence_view_by_position(element, position, options = {}, html_options = {})
-      ActiveSupport::Deprecation.warn 'Alchemy CMS: render_essence_view_by_position is not supported anymore and will be removed.'
-      if element.blank?
-        warning('Element is nil')
-        return ""
-      end
-      content = element.contents.find_by_position(position)
-      render_essence_view(content, options, html_options)
-    end
-
     # Renders the +Esssence+ partial for given +Content+.
     #
     # The helper renders the view partial as default.

data/app/helpers/alchemy/pages_helper.rb

@@ -4,15 +4,8 @@ module Alchemy
     include Alchemy::BaseHelper
     include Alchemy::ElementsHelper
 
-    def render_classes(classes=[])
-      s = classes.uniq.delete_if { |x| x.blank? }.join(" ")
-      s.blank? ? "" : "class='#{s}'"
-    end
-
     def picture_essence_caption(content)
-      return "" if content.nil?
-      return "" if content.essence.nil?
-      content.essence.caption
+      content.try(:essence).try(:caption)
     end
 
     # Renders links to language root pages of all published languages.
@@ -57,12 +50,23 @@ module Alchemy
       render :partial => "alchemy/page_layouts/standard"
     end
 
-    def sitename_from_header_page
-      header_page = Page.find_by_page_layout_and_layoutpage('layout_header', true)
-      return "" if header_page.nil?
-      page_title = header_page.elements.find_by_name('sitename')
-      return "" if page_title.nil?
-      page_title.ingredient('name')
+    # 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_site
+    rescue ActionView::MissingTemplate
+      warning("Site layout for #{current_site.try(:name)} not found. Please run `rails g alchemy:site_layouts`")
+      return ""
     end
 
     # Renders the navigation.

data/app/helpers/alchemy/url_helper.rb

@@ -25,6 +25,7 @@ module Alchemy
     #   <%= link_to '&raquo order now', page_path_for(:page_layout => 'orderform', :product_id => element.id) %>
     #
     def page_path_for(options={})
+      ActiveSupport::Deprecation.warn("Used deprecated page_path_for helper. Please use show_alchemy_page_path instead.")
       return warning("No page_layout, or urlname given. I got #{options.inspect} ") if options[:page_layout].blank? && options[:urlname].blank?
       if options[:urlname].blank?
         page = Page.find_by_page_layout(options[:page_layout])

data/app/mailers/alchemy/messages.rb

@@ -1,15 +1,13 @@
 module Alchemy
   class Messages < ActionMailer::Base
 
-    default :from => Alchemy::Config.get(:mailer)['mail_from']
-
     def contact_form_mail(message, mail_to, mail_from, subject)
       @message = message
       mail(
-        :from => mail_from,
-        :to => mail_to,
-        :reply_to => message.email,
-        :subject => subject
+        from: mail_from,
+        to: mail_to,
+        reply_to: message.try(:email),
+        subject: subject
       )
     end
 

data/app/models/alchemy/attachment.rb

@@ -1,3 +1,6 @@
+require 'userstamp'
+require 'acts-as-taggable-on'
+
 module Alchemy
   class Attachment < ActiveRecord::Base
     include Filetypes

data/app/models/alchemy/cell.rb

@@ -20,58 +20,56 @@ module Alchemy
     validates_uniqueness_of :name, :scope => :page_id
     has_many :elements, :dependent => :destroy, :order => :position
 
-    def self.definitions
-      cell_yml = ::File.join(::Rails.root, 'config', 'alchemy', 'cells.yml')
-      ::YAML.load_file(cell_yml)
-    end
+    class << self
+      def definitions
+        @definitions ||= read_yml_file
+      end
 
-    def self.definition_for(cellname)
-      return nil if cellname.blank?
-      definitions.detect { |c| c['name'] == cellname }
-    end
+      def definition_for(cellname)
+        return nil if cellname.blank?
+        definitions.detect { |c| c['name'] == cellname }
+      end
 
-    def self.all_definitions_for(cellnames)
-      definitions.select { |c| cellnames.include? c['name'] }
-    end
+      def all_definitions_for(cellnames)
+        definitions.select { |c| cellnames.include? c['name'] }
+      end
 
-    def self.all_element_definitions_for(cellnames)
-      element_names = []
-      all_definitions_for(cellnames).each do |cell|
-        element_names += cell['elements']
+      def definitions_for_element(element_name)
+        return [] if definitions.blank?
+        definitions.select { |d| d['elements'].include?(element_name) }
       end
-      Element.all_definitions_for(element_names.uniq)
-    end
 
-    def self.definitions_for_element(element_name)
-      return [] if definitions.blank?
-      definitions.select { |d| d['elements'].include?(element_name) }
-    end
+      def translated_label_for(cell_name)
+        I18n.t(cell_name, scope: 'cell_names', default: cell_name.to_s.humanize)
+      end
 
-    def self.names_for_element(element_name)
-      definitions = definitions_for_element(element_name)
-      return nil if definitions.blank?
-      definitions.collect { |d| d['name'] }
-    end
+    private
 
-    def self.translated_label_for(cell_name)
-      I18n.t(cell_name, scope: 'cell_names', default: cell_name.to_s.humanize)
+      def read_yml_file
+        ::YAML.load_file(yml_file_path) || []
+      end
+
+      def yml_file_path
+        Rails.root.join('config', 'alchemy', 'cells.yml')
+      end
     end
 
     # Returns the cell definition defined in +config/alchemy/cells.yml+
-    def description
-      description = self.class.definition_for(self.name)
-      if description.blank?
-        warn "Could not find cell definition for #{self.name}. Please check your cells.yml!"
+    #
+    def definition
+      definition = self.class.definition_for(self.name)
+      if definition.blank?
+        log_warning "Could not find cell definition for #{self.name}. Please check your cells.yml!"
         return {}
       else
-        description
+        definition
       end
     end
-    alias_method :definition, :description
+    alias_method :description, :definition
 
     # Returns all elements that can be placed in this cell
     def available_elements
-      description['elements'] || []
+      definition['elements'] || []
     end
 
     def name_for_label

data/app/models/alchemy/content.rb

@@ -1,7 +1,13 @@
+require 'userstamp'
+require 'acts_as_list'
+
 module Alchemy
   class Content < ActiveRecord::Base
     include Logger
 
+    # Concerns
+    include Factory
+
     attr_accessible(
       :do_not_index,
       :element_id,
@@ -14,7 +20,7 @@ module Alchemy
     belongs_to :essence, :polymorphic => true, :dependent => :destroy
     belongs_to :element
 
-    stampable(:stamper_class_name => 'Alchemy::User')
+    stampable stamper_class_name: 'Alchemy::User'
 
     acts_as_list
 
@@ -38,64 +44,6 @@ module Alchemy
     scope :essence_texts, where(:essence_type => "Alchemy::EssenceText")
 
     class << self
-
-      # Creates a new Content as descriped in the elements.yml file
-      def create_from_scratch(element, essences_hash)
-        # If no name given, we can create the content from essence type.
-        # Used in picture gallery
-        if essences_hash[:name].blank? && !essences_hash[:essence_type].blank?
-          essences_of_same_type = element.contents.where(
-            :essence_type => Content.normalize_essence_type(essences_hash[:essence_type])
-          )
-          description = {
-            'type' => essences_hash[:essence_type],
-            'name' => "#{essences_hash[:essence_type].classify.demodulize.underscore}_#{essences_of_same_type.count + 1}"
-          }
-        # Normal way to create
-        else
-          description = element.content_description_for(essences_hash[:name])
-          description = element.available_content_description_for(essences_hash[:name]) if description.blank?
-        end
-        if description.blank?
-          raise ContentDefinitionError, "No description found in elements.yml for #{essences_hash.inspect} and #{element.inspect}"
-        end
-        content = new(:name => description['name'], :element_id => element.id)
-        content.create_essence!(description)
-        content
-      end
-
-      # Makes a copy of source and also copies the associated essence.
-      #
-      # You can pass a differences hash to update the attributes of the copy.
-      #
-      # === Example
-      #
-      #   @copy = Alchemy::Content.copy(@content, {:element_id => 3})
-      #   @copy.element_id # => 3
-      #
-      def copy(source, differences = {})
-        attributes = source.attributes.except(
-          "position",
-          "created_at",
-          "updated_at",
-          "creator_id",
-          "updater_id",
-          "id"
-        ).merge(differences.stringify_keys)
-        content = self.create!(attributes)
-        new_essence = content.essence.class.new(content.essence.attributes.except(
-          "id",
-          "creator_id",
-          "updater_id",
-          "created_at",
-          "updated_at"
-        ))
-        new_essence.save!
-        raise "Essence not cloned" if new_essence.id == content.essence_id
-        content.update_attributes(:essence_id => new_essence.id)
-        content
-      end
-
       # Returns the translated label for a content name.
       #
       # Translate it in your locale yml file:
@@ -118,21 +66,6 @@ module Alchemy
           default: I18n.t("content_names.#{content_name}", default: content_name.humanize)
         )
       end
-
-      # Returns all content descriptions from elements.yml
-      def descriptions
-        Element.descriptions.collect { |e| e['contents'] }.flatten.compact
-      end
-
-      def normalize_essence_type(essence_type)
-        essence_type = essence_type.classify
-        if not essence_type.match(/^Alchemy::/)
-          essence_type.gsub!(/^Essence/, 'Alchemy::Essence')
-        else
-          essence_type
-        end
-      end
-
     end
 
     # Settings from the elements.yml definition
@@ -148,21 +81,6 @@ module Alchemy
       self.element.contents
     end
 
-    # Returns my description hash from elements.yml
-    # Returns the description from available_contents if my own description is blank
-    def description
-      if element.blank?
-        warn "Content with id #{self.id} is missing its Element."
-        return {}
-      end
-      desc = self.element.content_description_for(self.name)
-      if desc.blank?
-        self.element.available_content_description_for(self.name)
-      end
-      desc || {}
-    end
-    alias_method :definition, :description
-
     # Gets the ingredient from essence
     def ingredient
       return nil if essence.nil?
@@ -230,6 +148,17 @@ module Alchemy
       essence && !essence.link.blank?
     end
 
+    # Returns true if this content should be taken for element preview.
+    def preview_content?
+      !!description['take_me_for_preview']
+    end
+
+    # Proxy method that returns the preview text from essence.
+    #
+    def preview_text(maxlength = 30)
+      essence.preview_text(maxlength)
+    end
+
     def essence_partial_name
       essence.partial_name
     end
@@ -239,37 +168,17 @@ module Alchemy
     end
 
     def has_custom_tinymce_config?
-      !settings[:tinymce].nil?
+      settings[:tinymce].present?
     end
 
     def tinymce_class_name
       if has_custom_tinymce_config?
-        if settings[:tinymce]
-          "custom_tinymce #{name}"
-        end
+        "custom_tinymce #{element.name}_#{name}"
       else
         "default_tinymce"
       end
     end
 
-    # Creates self.essence from description.
-    def create_essence!(description)
-      essence_class = self.class.normalize_essence_type(description['type']).constantize
-      attributes = {
-        :ingredient => default_text(description['default'])
-      }
-      if description['type'] == "EssenceRichtext" || description['type'] == "EssenceText"
-        attributes.merge!(:do_not_index => !description['do_not_index'].nil?)
-      end
-      essence = essence_class.create(attributes)
-      if essence
-        self.essence = essence
-        save!
-      else
-        false
-      end
-    end
-
     # Returns the default value from content description
     # If the value is a symbol it gets passed through i18n inside the +alchemy.default_content_texts+ scope
     def default_text(default)