alchemy_cms 2.6.3 → 2.7.0

data/lib/alchemy/auth/engine.rb

@@ -0,0 +1,9 @@
+module Alchemy
+  module Auth
+    module Engine
+      def self.get_instance
+        ::Authorization::Engine.instance
+      end
+    end
+  end
+end

data/lib/alchemy/capistrano.rb

@@ -83,9 +83,10 @@ EOF
         run "cd #{current_path} && #{rake} RAILS_ENV=#{fetch(:rails_env, 'production')} alchemy:db:seed"
       end
 
-      desc "Dumps the database into 'db/dumps'"
+      desc "Dumps the database into 'db/dumps' on the server."
       task :dump, :roles => :db do
-        run "cd #{current_path} && #{rake} RAILS_ENV=#{fetch(:rails_env, 'production')} alchemy:db:dump"
+        timestamp = Time.now.strftime('%Y-%m-%d-%H-%M')
+        run "cd #{current_path} && mkdir -p db/dumps && #{rake} RAILS_ENV=#{fetch(:rails_env, 'production')} DUMP_FILENAME=db/dumps/#{timestamp}.sql alchemy:db:dump"
       end
 
     end
@@ -101,17 +102,14 @@ EOF
 
       desc "Imports the database into your local development machine."
       task :database, :roles => [:db], :only => {:primary => true} do
+        require 'spinner'
         server = find_servers_for_task(current_task).first
-        dump_cmd = "cd #{current_path} && #{rake} RAILS_ENV=#{fetch(:rails_env, 'production')} alchemy:db:dump"
-        sql_stream = "ssh -p #{fetch(:port, 22)} #{user}@#{server} '#{dump_cmd}'"
-        mysql_credentials = ["--user='#{database_config['username']}'"]
-        if database_config['password']
-          mysql_credentials << "--password='#{database_config['password']}'"
-        end
-        if host = database_config['host'] && host != 'localhost'
-          mysql_credentials << "--host='#{host}'"
+        spinner = Spinner.new
+        print "\n"
+        spinner.task("Importing the database. Please wait...") do
+          system db_import_cmd(server)
         end
-        system "#{sql_stream} | mysql #{mysql_credentials.join(' ')} #{database_config['database']}"
+        spinner.spin!
       end
 
       desc "Imports attachments into your local machine using rsync."
@@ -136,7 +134,34 @@ EOF
 
       def database_config
         raise "database.yml not found!" if !File.exists?("./config/database.yml")
-        YAML.load_file("./config/database.yml").fetch(ENV['RAILS_ENV'] || 'development')
+        @database_config ||= begin
+          config_file = YAML.load_file("./config/database.yml")
+          if config = config_file.fetch(ENV['RAILS_ENV'] || 'development')
+            config
+          else
+            raise "Database configuration for #{ENV['RAILS_ENV'] || 'development'} not found!"
+          end
+        end
+      end
+
+      def db_import_cmd(server)
+        dump_cmd = "cd #{current_path} && #{rake} RAILS_ENV=#{fetch(:rails_env, 'production')} alchemy:db:dump"
+        sql_stream = "ssh -p #{fetch(:port, 22)} #{user}@#{server} '#{dump_cmd}'"
+        "#{sql_stream} | mysql #{mysql_credentials} #{database_config['database']}"
+      end
+
+      def mysql_credentials
+        mysql_credentials = []
+        if database_config['username']
+          mysql_credentials << "--user='#{database_config['username']}'"
+        end
+        if database_config['password']
+          mysql_credentials << "--password='#{database_config['password']}'"
+        end
+        if (host = database_config['host']) && (host != 'localhost')
+          mysql_credentials << "--host='#{host}'"
+        end
+        mysql_credentials.join(' ')
       end
 
     end

data/lib/alchemy/config.rb

@@ -1,51 +1,64 @@
+# encoding: utf-8
+
 module Alchemy
   class Config
 
     class << self
 
-      # Returns the configuration for given parameter name from +config/alchemy/config.yml+ file.
+      # Returns the configuration for given parameter name.
+      #
+      # @param name [String]
+      #
       def get(name)
         show[name.to_s]
       end
-
       alias_method :parameter, :get
 
-      # Returns the complete configuration from +config/alchemy/config.yml+ file.
+      # Returns a merged configuration of the following files
+      # 
+      # Alchemy´s default config: +gems/../alchemy_cms/config/alchemy/config.yml+
+      # Your apps default config: +your_app/config/alchemy/config.yml+
+      # Environment specific config: +your_app/config/alchemy/development.config.yml+
+      #
+      # An environment specific config overwrites the settings of your apps default config, 
+      # while your apps default config has precedence over Alchemy´s default config.
+      #
       def show
-        @@config ||= read_files
+        @config ||= merge_configs!(alchemy_config, main_app_config, env_specific_config)
+      end
+
+    private
+
+      # Alchemy default configuration
+      def alchemy_config
+        read_file(File.join(File.dirname(__FILE__), '..', '..', 'config/alchemy/config.yml'))
+      end
+
+      # Application specific configuration
+      def main_app_config
+        read_file("#{Rails.root}/config/alchemy/config.yml")
+      end
+
+      # Rails Environment specific configuration
+      def env_specific_config
+        read_file("#{Rails.root}/config/alchemy/#{Rails.env}.config.yml")
+      end
+
+      # Tries to load yaml file from given path.
+      # If it does not exist, or its empty, it returns an empty Hash.
+      #
+      def read_file(file)
+        return YAML.load_file(file) || {} if File.exists?(file) # YAML.load_file returns false if file is empty.
+        {}
       end
 
-      private
-
-      def read_files
-        # Looking for any Rails Environment specific configuration
-        if File.exists? "#{Rails.root.to_s}/config/alchemy/config_#{Rails.env}.yml"
-          config_1 = YAML.load_file("#{Rails.root.to_s}/config/alchemy/config_#{Rails.env}.yml")
-        else
-          config_1 = {}
-        end
-
-        # Looking for Application specific configuration
-        if File.exists? "#{Rails.root.to_s}/config/alchemy/config.yml"
-          config_2 = YAML.load_file("#{Rails.root.to_s}/config/alchemy/config.yml")
-        else
-          config_2 = {}
-        end
-
-        # Reading Alchemy standard configuration
-        if File.exists? File.join(File.dirname(__FILE__), '..', '..', 'config/alchemy/config.yml')
-          config_3 = YAML.load_file(File.join(File.dirname(__FILE__), '..', '..', 'config/alchemy/config.yml'))
-        else
-          config_3 = {}
-        end
-
-        # Mergin all together
-        if config_1.blank? && config_3.blank? && config_3.blank?
-          raise LoadError, 'No Alchemy config file found!'
-        else
-          [config_1, config_2, config_3].map(&:stringify_keys!)
-          return config_3.merge(config_2.merge(config_1))
-        end
+      # Merges all given configs together
+      # 
+      def merge_configs!(*config_files)
+        raise LoadError, 'No Alchemy config file found!' if config_files.map(&:blank?).all?
+        config = {}
+        config_files.each {|h| config.merge!(h.stringify_keys!) }
+        config
       end
 
     end

data/lib/alchemy/engine.rb

@@ -1,5 +1,38 @@
+# Require globally used external libraries
+require 'coffee-rails'
+require 'compass-rails'
+require 'declarative_authorization'
+require 'devise'
+require 'dynamic_form'
+require 'jquery-rails'
+require 'jquery-ui-rails'
+require 'kaminari'
+require 'rails3-jquery-autocomplete'
+require 'sass-rails'
+require 'sassy-buttons'
+
+# Require globally used Alchemy mixins
+require 'alchemy/auth/engine'
+require 'alchemy/config'
+require 'alchemy/errors'
+require 'alchemy/essence'
+require 'alchemy/ferret/search'
+require 'alchemy/filetypes'
+require 'alchemy/i18n'
+require 'alchemy/logger'
+require 'alchemy/modules'
+require 'alchemy/mount_point'
+require 'alchemy/name_conversions'
+require 'alchemy/page_layout'
+require 'alchemy/picture_attributes'
+require 'alchemy/tinymce'
+
+# Require hacks
+require 'alchemy/kaminari/scoped_pagination_url_helper'
+require File.join(File.dirname(__FILE__), '../extensions/action_view')
+
+# Require middleware
 require File.join(File.dirname(__FILE__), '../middleware/flash_session_cookie')
-require File.join(File.dirname(__FILE__), 'authentication_helpers')
 
 module Alchemy
   class Engine < Rails::Engine
@@ -37,11 +70,7 @@ module Alchemy
     end
 
     initializer "alchemy.add_authorization_rules" do
-      Alchemy::AuthEngine.get_instance.load(File.join(File.dirname(__FILE__), '../..', 'config/authorization_rules.rb'))
-    end
-
-    config.after_initialize do
-      #ApplicationController.send :include, Alchemy::AuthenticationHelpers
+      Alchemy::Auth::Engine.get_instance.load(File.join(File.dirname(__FILE__), '../..', 'config/authorization_rules.rb'))
     end
 
   end

data/lib/alchemy/essence.rb

@@ -7,23 +7,26 @@ module Alchemy #:nodoc:
     end
 
     # Delivers various methods we need for Essences in Alchemy.
+    #
     # To turn a model into an essence call acts_as_essence inside your model and you will get:
     #   * validations
     #   * several getters (ie: page, element, content, ingredient, preview_text)
+    #
     module ClassMethods
 
-      # Configuration options are:
+      # Turn any active record model into an essence by calling this class method
+      #
+      # @option options [String || Symbol] ingredient_column ('body')
+      #   specifies the column name you use for storing the content in the database (default: +body+)
+      # @option options [String || Symbol] validate_column (ingredient_column)
+      #   The column the the validations run against.
+      # @option options [String || Symbol] preview_text_column (ingredient_column)
+      #   Specify the column for the preview_text method.
       #
-      # * +ingredient_column+ - specifies the column name you use for storing the content in the database (default: +body+)
-      # * +validate_column+ - which column should be validated. (default: ingredient_column)
-      # * +preview_text_column+ - specifies the column for the preview_text method. (default: ingredient_column)
-      # * +preview_text_method+ - a method called on ingredient to get the preview text. (default: ingredient_column)
       def acts_as_essence(options={})
-        configuration = {}
-        configuration.update(options) if options.is_a?(Hash)
-        ingredient_column = configuration[:ingredient_column].blank? ? 'body' : configuration[:ingredient_column]
-        preview_text_column = configuration[:preview_text_column].blank? ? ingredient_column : configuration[:preview_text_column]
-        validate_column = configuration[:validate_column].blank? ? ingredient_column : configuration[:validate_column]
+        configuration = {
+          ingredient_column: 'body'
+        }.update(options)
 
         class_eval <<-EOV
           attr_accessor :validation_errors
@@ -39,22 +42,17 @@ module Alchemy #:nodoc:
             #{self.name}
           end
 
-          def validation_column
-            '#{validate_column}'
-          end
-
           def ingredient_column
-            '#{ingredient_column}'
+            '#{configuration[:ingredient_column]}'
           end
 
-          def preview_text_column
-            '#{preview_text_column}'
+          def validation_column
+            '#{configuration[:validate_column] || configuration[:ingredient_column]}'
           end
 
-          def preview_text_method
-            '#{configuration[:preview_text_method]}'
+          def preview_text_column
+            '#{configuration[:preview_text_column] || configuration[:ingredient_column]}'
           end
-
         EOV
       end
 
@@ -65,10 +63,12 @@ module Alchemy #:nodoc:
       # Essence Validations:
       #
       # Essence validations can be set inside the config/elements.yml file.
+      #
       # Currently supported validations are:
-      #   * presence
-      #   * format
-      #   * uniqueness
+      #
+      # * presence
+      # * format
+      # * uniqueness
       #
       # If you want to validate the format you must additionally pass validate_format_as or validate_format_with:
       #
@@ -171,13 +171,9 @@ module Alchemy #:nodoc:
       end
 
       # Returns the first x (default 30) characters of ingredient for the Element#preview_text method.
+      #
       def preview_text(maxlength = 30)
-        if preview_text_method.blank?
-          self.send(preview_text_column).to_s[0..maxlength]
-        else
-          return "" if ingredient.blank?
-          ingredient.send(preview_text_method).to_s[0..maxlength]
-        end
+        self.send(preview_text_column).to_s[0..maxlength-1]
       end
 
       def open_link_in_new_window?

data/lib/alchemy/ferret/search.rb

@@ -0,0 +1,86 @@
+module Alchemy
+  # Provides full text search methods in your controller
+  #
+  # === Usage
+  #
+  #   include Alchemy::Ferret::Search
+  #
+  module Ferret
+    module Search
+
+      # Adds a +before_filter+ to your controller
+      #
+      def self.included(controller)
+        controller.send(:before_filter, :perform_search, :only => :show)
+        controller.send(:helper_method, :find_search_result_page)
+      end
+
+      # Performs a full text search with +Ferret+.
+      #
+      # Gets invoked everytime 'query' is given in params.
+      #
+      # This method only sets the +@search_results+ instance variable.
+      #
+      # You have to redirect to the search result page within a search form.
+      #
+      # === Alchemy provides a handy helper for rendering the search form:
+      #
+      #  render_search_form
+      #
+      # === Note
+      #
+      # If in preview mode a fake search value "lorem" will be set.
+      #
+      # @see Alchemy::PagesHelper#render_search_form
+      #
+      def perform_search
+        if @preview_mode && params[:query].blank?
+          params[:query] = 'lorem'
+        end
+        return if params[:query].blank?
+        @search_results = get_search_results
+      end
+
+      # Finds what is provided in "query" param with Ferret on EssenceText and EssenceRichtext
+      #
+      # @return [Array]
+      #
+      def get_search_results
+        search_results = []
+        %w(Alchemy::EssenceText Alchemy::EssenceRichtext).each do |e|
+          search_results += e.constantize.includes(:contents => {:element => :page}).find_with_ferret(
+            "*#{params[:query]}*",
+            {:limit => :all},
+            {:conditions => [
+              'alchemy_pages.public = ? AND alchemy_pages.layoutpage = ? AND alchemy_pages.restricted = ? AND alchemy_pages.language_id = ?',
+              true, false, false, session[:language_id]
+            ]}
+          )
+        end
+        if search_results.any?
+          search_results.sort { |y, x| x.ferret_score <=> y.ferret_score }
+        end
+      end
+
+      # A view helper that loads the search result page.
+      #
+      # === Raises a ActiveRecord::RecordNotFound error, if the page could not be found or is not published.
+      #
+      # @return [Alchemy::Page]
+      #
+      def find_search_result_page
+        if searchresult_page_layout = PageLayout.get_all_by_attributes(:searchresults => true).first
+          search_result_page = Page.published.where(
+            :page_layout => searchresult_page_layout["name"],
+            :language_id => session[:language_id]
+          ).limit(1).first
+        end
+        if search_result_page.nil?
+          logger.warn "\n++++++\nNo published search result page found. Please create one or publish your search result page.\n++++++\n"
+        end
+        search_result_page
+      end
+
+    end
+  end
+end

data/lib/alchemy/logger.rb

@@ -1,16 +1,15 @@
 module Alchemy
   module Logger
 
-    # Logs a warning to the Rails standard logger and adds some nicer formatting
+    # Logs a debug message to the Rails standard logger and adds some nicer formatting
     def self.warn(message, caller_string)
-      Rails.logger.warn %(\n++++ WARNING: #{message}\nCalled from: #{caller_string}\n)
+      Rails.logger.debug %(\n++++ WARNING: #{message}\nCalled from: #{caller_string}\n)
       return nil
     end
 
-    def warn(message)
+    def log_warning(message)
       Alchemy::Logger.warn(message, caller.first)
     end
-    alias_method :warning, :warn
 
   end
 end

data/lib/alchemy/page_layout.rb

@@ -2,40 +2,41 @@ module Alchemy
   class PageLayout
     class << self
 
-      def element_names_for(page_layout)
-        layout_description = get(page_layout)
-        if layout_description.blank?
-          puts "\n+++ Warning: No Layout Description for #{page_layout} found! in page_layouts.yml\n"
-          return []
-        else
-          layout_description["elements"] || []
-        end
-      end
-
-      # Returns all layouts defined in +config/alchemy/page_layout.yml+.
+      # Returns all page layouts.
+      #
+      # They are defined in +config/alchemy/page_layout.yml+ file.
+      #
       def all
-        @@definitions = read_layouts_file
+        @definitions ||= read_layouts_file
       end
 
-      # Add additional pagelayout definitions. I.E. from your module.
-      # Call +Alchemy::PageLayout.add(your_layout_definition)+ in your engine.rb file.
-      # You can pass a single layout definition as Hash, or a collection of pagelayouts as Array.
-      # Example Pagelayout definitions can be found in the +page_layouts.yml+ from the standard set.
+      # Add additional page layout definitions to collection.
+      #
+      # Useful for extending the page layouts from an Alchemy module.
+      #
+      # === Usage Example
+      #
+      #   Call +Alchemy::PageLayout.add(your_layout_definition)+ in your engine.rb file.
+      #
+      # @param [Array || Hash]
+      #   You can pass a single layout definition as Hash, or a collection of page layouts as Array.
+      #
       def add(page_layout)
         all
         if page_layout.is_a?(Array)
-          @@definitions += page_layout
+          @definitions += page_layout
         elsif page_layout.is_a?(Hash)
-          @@definitions << page_layout
+          @definitions << page_layout
         else
           raise TypeError
         end
       end
 
-      # Returns the page_layout description found by name in page_layouts.yml
+      # Returns one page layout description by given name.
+      #
       def get(name)
         return {} if name.blank?
-        all.detect { |a| a["name"].downcase == name.downcase }
+        all.detect { |a| a['name'].downcase == name.downcase }
       end
 
       def get_all_by_attributes(attributes)
@@ -53,60 +54,128 @@ module Alchemy
       end
 
       # Returns page layouts ready for Rails' select form helper.
-      def layouts_for_select(language_id, layoutpage = false)
-        map_layouts(selectable_layouts(language_id, layoutpage), [[I18n.t('Please choose'), '']])
+      #
+      def layouts_for_select(language_id, only_layoutpages = false)
+        @map_array = [[I18n.t('Please choose'), '']]
+        mapped_layouts_for_select(selectable_layouts(language_id, only_layoutpages))
       end
 
-      def layouts_with_own_for_select(own_layout, language_id, layoutpage)
-        layouts = selectable_layouts(language_id, layoutpage)
-        if layouts.detect { |l| l['name'] == own_layout } == nil
-          map_array = [
-            [I18n.t(own_layout, scope: 'page_layout_names', default: own_layout.to_s.humanize), own_layout]
-          ]
+      # Returns page layouts including given layout ready for Rails' select form helper.
+      #
+      def layouts_with_own_for_select(page_layout_name, language_id, only_layoutpages = false)
+        layouts = selectable_layouts(language_id, only_layoutpages)
+        if layouts.detect { |l| l['name'] == page_layout_name }.nil?
+          @map_array = [[human_layout_name(page_layout_name), page_layout_name]]
         else
-          map_array = []
-        end
-        map_layouts(layouts, map_array)
-      end
-
-      # Maps given layouts for Rails select form helper.
-      def map_layouts(layouts, map_array = [])
-        layouts.each do |layout|
-          map_array << [
-            I18n.t(layout['name'], scope: 'page_layout_names', default: layout['name'].to_s.humanize),
-            layout["name"]
-          ]
+          @map_array = []
         end
-        map_array
+        mapped_layouts_for_select(layouts)
       end
 
-      def selectable_layouts(language_id, layoutpage = false)
-        all.select do |layout|
-          next if layout["hide"]
-          used = layout["unique"] && has_a_page_this_layout?(layout["name"], language_id)
-          if layoutpage
-            layout["layoutpage"] == true && !used
+      # Returns all layouts that can be used for creating a new page.
+      #
+      # It removes all layouts from available layouts that are unique and already taken and that are marked as hide.
+      #
+      # @param [Fixnum]
+      #   language_id of current used Language.
+      # @param [Boolean] (false)
+      #   Pass true to only select layouts for global/layout pages.
+      #
+      def selectable_layouts(language_id, only_layoutpages = false)
+        @language_id = language_id
+        all.select { |layout|
+          if only_layoutpages
+            layout['layoutpage'] && layout_available?(layout)
           else
-            layout["layoutpage"] != true && !used
+            !layout['layoutpage'] && layout_available?(layout)
           end
+        }
+      end
+
+      # Returns all names of elements defined in given page layout.
+      #
+      def element_names_for(page_layout)
+        if layout_description = get(page_layout)
+          layout_description.fetch('elements', [])
+        else
+          Rails.logger.warn "\n+++ Warning: No Layout Description for #{page_layout} found! in page_layouts.yml\n"
+          return []
         end
       end
 
-      def has_a_page_this_layout?(layout, language_id)
-        Page.where({:page_layout => layout, :language_id => language_id}).any?
+      # Translates name for given layout
+      #
+      # === Translation example
+      #
+      #   de:
+      #     alchemy:
+      #       page_layout_names:
+      #         products_overview: Produktübersicht
+      #
+      # @param [String]
+      #   The layout name
+      #
+      def human_layout_name(layout)
+        I18n.t(layout, scope: 'page_layout_names', default: layout.to_s.humanize)
       end
 
     private
 
+      # Returns true if the given layout is unique and not already taken or it should be hidden.
+      #
+      def layout_available?(layout)
+        !layout['hide'] && !already_taken?(layout) && available_on_site?(layout)
+      end
+
+      # Returns true if this layout is unique and already taken by another page.
+      #
+      def already_taken?(layout)
+        layout['unique'] && page_with_layout_existing?(layout['name'])
+      end
+
+      # Returns true if one page already has the given layout
+      #
+      def page_with_layout_existing?(layout)
+        Page.where(page_layout: layout, language_id: @language_id).pluck(:id).any?
+      end
+
+      # Returns true if given layout is available for current site.
+      #
+      # If no site layouts are defined it always returns true.
+      #
+      # == Example
+      #
+      #   # config/alchemy/site_layouts.yml
+      #   - name: default_site
+      #     page_layouts: [default_intro]
+      #
+      def available_on_site?(layout)
+        Site.current.layout_definition.blank? || Site.current.layout_definition.fetch('page_layouts', []).include?(layout['name'])
+      end
+
       # Reads the layout definitions from +config/alchemy/page_layouts.yml+.
+      #
       def read_layouts_file
-        if File.exists? "#{Rails.root}/config/alchemy/page_layouts.yml"
-          layouts = YAML.load_file "#{Rails.root}/config/alchemy/page_layouts.yml"
-          # Since YAML returns false for an empty file, we have to normalize it here.
-          layouts || []
+        if File.exists?(layouts_file_path)
+          YAML.load_file(layouts_file_path) || []
         else
-          raise LoadError, "Could not find page_layouts.yml file! Please run: rails generate alchemy:scaffold"
+          raise LoadError, "Could not find page_layouts.yml file! Please run `rails generate alchemy:scaffold`"
+        end
+      end
+
+      # Returns the page_layouts.yml file path
+      #
+      def layouts_file_path
+        Rails.root.join 'config/alchemy/page_layouts.yml'
+      end
+
+      # Maps given layouts for Rails select form helper.
+      #
+      def mapped_layouts_for_select(layouts)
+        layouts.each do |layout|
+          @map_array << [human_layout_name(layout['name']), layout["name"]]
         end
+        @map_array
       end
 
     end