alchemy_cms 2.1.12 → 2.2.rc1

data/lib/alchemy/engine.rb

@@ -1,45 +1,45 @@
 require File.join(File.dirname(__FILE__), '../middleware/flash_session_cookie')
 
 module Alchemy
-	class Engine < Rails::Engine
-
-		isolate_namespace Alchemy
-
-		engine_name 'alchemy'
-
-		config.mount_at = '/'
-
-		# Enabling assets precompiling
-		initializer 'alchemy.assets' do |app|
-			app.config.assets.precompile += [
-				"alchemy/alchemy.js",
-				"alchemy/preview.js",
-				"alchemy/alchemy.css",
-				"alchemy/menubar.css",
-				"alchemy/menubar.js",
-				"alchemy/print.css",
-				"alchemy/tinymce_content.css",
-				"alchemy/tinymce_dialog.css",
-				"tiny_mce/*"
-			]
-		end
-
-		initializer 'alchemy.flash_cookie' do |config|
-			config.middleware.insert_after(
-				'ActionDispatch::Cookies',
-				Alchemy::Middleware::FlashSessionCookie,
-				::Rails.configuration.session_options[:key]
-			)
-		end
-
-		# filter sensitive information during logging
-		initializer "alchemy.params.filter" do |app|
-			app.config.filter_parameters += [:password, :password_confirmation]
-		end
-
-		initializer "alchemy.add_authorization_rules" do
-			Alchemy::AuthEngine.get_instance.load(File.join(File.dirname(__FILE__), '../..', 'config/authorization_rules.rb'))
-		end
-
-	end
+  class Engine < Rails::Engine
+
+    isolate_namespace Alchemy
+
+    engine_name 'alchemy'
+
+    config.mount_at = '/'
+
+    # Enabling assets precompiling
+    initializer 'alchemy.assets' do |app|
+      app.config.assets.precompile += [
+        "alchemy/alchemy.js",
+        "alchemy/preview.js",
+        "alchemy/alchemy.css",
+        "alchemy/menubar.css",
+        "alchemy/menubar.js",
+        "alchemy/print.css",
+        "alchemy/tinymce_content.css",
+        "alchemy/tinymce_dialog.css",
+        "tiny_mce/*"
+      ]
+    end
+
+    initializer 'alchemy.flash_cookie' do |config|
+      config.middleware.insert_after(
+        'ActionDispatch::Cookies',
+        Alchemy::Middleware::FlashSessionCookie,
+        ::Rails.configuration.session_options[:key]
+      )
+    end
+
+    # filter sensitive information during logging
+    initializer "alchemy.params.filter" do |app|
+      app.config.filter_parameters += [:password, :password_confirmation]
+    end
+
+    initializer "alchemy.add_authorization_rules" do
+      Alchemy::AuthEngine.get_instance.load(File.join(File.dirname(__FILE__), '../..', 'config/authorization_rules.rb'))
+    end
+
+  end
 end

data/lib/alchemy/essence.rb

@@ -30,28 +30,32 @@ module Alchemy #:nodoc:
           include Alchemy::Essence::InstanceMethods
           stampable
           validate :essence_validations, :on => :update
-					has_many :contents, :as => :essence
-
+          has_many :contents, :as => :essence
+          
           def acts_as_essence_class
             #{self.name}
           end
-
+          
           def validation_column
             '#{validate_column}'
           end
-
+          
           def ingredient_column
             '#{ingredient_column}'
           end
-
+          
+          def ingredient
+            send('#{ingredient_column}')
+          end
+          
           def preview_text_column
             '#{preview_text_column}'
           end
-
+          
           def preview_text_method
             '#{configuration[:preview_text_method]}'
           end
-
+          
         EOV
       end
 
@@ -60,24 +64,24 @@ module Alchemy #:nodoc:
     module InstanceMethods
 
       # Essence Validations:
-      #
+      # 
       # Essence validations can be set inside the config/elements.yml file.
       # Currently supported validations are:
       #   * presence
       #   * format
       #   * uniqueness
-      #
+      # 
       # If you want to validate the format you must additionally pass validate_format_as or validate_format_with:
-      #
+      # 
       # * validate_format_with has to be regex
       # * validate_format_as can be one of:
       # ** url
       # ** email
-      #
+      # 
       # Example:
-      #
+      # 
       #   - name: person
-      #     contents:
+      #     contents:  
       #     - name: name
       #       type: EssenceText
       #       validate: [presence]
@@ -89,44 +93,39 @@ module Alchemy #:nodoc:
       #       type: EssenceText
       #       validate: [format]
       #       validate_format_with: '^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$'
-      #
-			def essence_validations
+      # 
+      def essence_validations
         self.validation_errors ||= []
-				return true if description.blank? || description['validate'].blank?
-				description['validate'].each do |validation|
-					if validation == 'presence' && ingredient.blank?
-						self.validation_errors << :blank
-					elsif validation == 'format'
-						if description['validate_format_as'].blank? && !description['validate_format_with'].blank?
-							matcher = Regexp.new(description['validate_format_with'])
-						elsif !description['validate_format_as'].blank? && description['validate_format_with'].blank?
-							case description['validate_format_as']
-							when 'email'
-								then matcher = Authlogic::Regex.email
-							when 'url'
-								then matcher = /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix
-							else
-								raise "No validation format matcher found for #{description['validate_format_as']}"
-							end
-						else
-							raise 'No validation format matcher given'
-						end
-						if ingredient.match(matcher).nil?
-							self.validation_errors << :invalid
-						end
-					elsif validation == 'uniqueness' && !acts_as_essence_class.send("find_by_#{ingredient_column}", ingredient).blank?
-						self.validation_errors << :taken
-					end
-				end
+        return true if description.blank? || description['validate'].blank?
+        description['validate'].each do |validation|
+          if validation == 'presence' && ingredient.blank?
+            self.validation_errors << :blank
+          elsif validation == 'format'
+            if description['validate_format_as'].blank? && !description['validate_format_with'].blank?
+              matcher = Regexp.new(description['validate_format_with'])
+            elsif !description['validate_format_as'].blank? && description['validate_format_with'].blank?
+              case description['validate_format_as']
+              when 'email'
+              then
+                matcher = Authlogic::Regex.email
+              when 'url'
+              then
+                matcher = /^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/ix
+              else
+                raise "No validation format matcher found for #{description['validate_format_as']}"
+              end
+            else
+              raise 'No validation format matcher given'
+            end
+            if ingredient.match(matcher).nil?
+              self.validation_errors << :invalid
+            end
+          elsif validation == 'uniqueness' && !acts_as_essence_class.send("find_by_#{ingredient_column}", ingredient).blank?
+            self.validation_errors << :taken
+          end
+        end
         self.validation_errors.each do |validation_error|
           self.errors.add(self.ingredient_column, validation_error)
-        end
-			end
-
-      # Returns the value stored from the database column that is configured as ingredient column.
-      def ingredient
-        if self.respond_to?(ingredient_column)
-          self.send(ingredient_column)
         end
       end
 
@@ -167,9 +166,9 @@ module Alchemy #:nodoc:
         respond_to?(:link_target) && link_target == 'blank'
       end
 
-			def partial_name
-				self.class.name.split('::').last.underscore
-			end
+      def partial_name
+        self.class.name.split('::').last.underscore
+      end
 
     end
 

data/lib/alchemy/i18n.rb

@@ -1,54 +1,54 @@
 module Alchemy
-	class I18n
+  class I18n
 
-		# A I18n Proxy for Alchemy translations
-		# 
-		# Instead of having to translate strings and defining a default value:
-		# 
-		#     Alchemy::I18n.t("Hello World!", :default => 'Hello World!')
-		# 
-		# We define this method to define the value only once:
-		# 
-		#     Alchemy::I18n.t("Hello World!")
-		# 
-		# Note that interpolation still works:
-		# 
-		#     Alchemy::I18n.t("Hello %{world}!", :world => @world)
-		# 
-		# === Notes
-		# 
-		# All translations are scoped into the +alchemy+ namespace.
-		# Even scopes are scoped into the +alchemy+ namespace.
-		# 
-		# So a call for t('hello', :scope => :world) has to be translated like this:
-		# 
-		#   de:
-		#     alchemy:
-		#       world:
-		#         hello: Hallo
-		# 
-		def self.t(msg, *args)
-			options = args.extract_options!
-			options[:default] = options[:default] ? options[:default] : msg.to_s.humanize
-			scope = ['alchemy']
-			case options[:scope].class.name
-				when "Array"
-					scope += options[:scope]
-				when "String"
-					scope << options[:scope]
-				when "Symbol"
-					scope << options[:scope] unless options[:scope] == :alchemy
-			end
-			::I18n.t(msg, options.merge(:scope => scope))
-		end
+    # A I18n Proxy for Alchemy translations
+    #
+    # Instead of having to translate strings and defining a default value:
+    #
+    #     Alchemy::I18n.t("Hello World!", :default => 'Hello World!')
+    #
+    # We define this method to define the value only once:
+    #
+    #     Alchemy::I18n.t("Hello World!")
+    #
+    # Note that interpolation still works:
+    #
+    #     Alchemy::I18n.t("Hello %{world}!", :world => @world)
+    #
+    # === Notes
+    #
+    # All translations are scoped into the +alchemy+ namespace.
+    # Even scopes are scoped into the +alchemy+ namespace.
+    #
+    # So a call for t('hello', :scope => :world) has to be translated like this:
+    #
+    #   de:
+    #     alchemy:
+    #       world:
+    #         hello: Hallo
+    #
+    def self.t(msg, *args)
+      options = args.extract_options!
+      options[:default] = options[:default] ? options[:default] : msg.to_s.humanize
+      scope = ['alchemy']
+      case options[:scope].class.name
+      when "Array"
+        scope += options[:scope]
+      when "String"
+        scope << options[:scope]
+      when "Symbol"
+        scope << options[:scope] unless options[:scope] == :alchemy
+      end
+      ::I18n.t(msg, options.merge(:scope => scope))
+    end
 
-		def self.available_locales
-			translation_files.collect { |f| f.match(/.{2}\.yml$/).to_s.gsub(/\.yml/, '') }.uniq
-		end
+    def self.available_locales
+      translation_files.collect { |f| f.match(/.{2}\.yml$/).to_s.gsub(/\.yml/, '') }.uniq
+    end
 
-		def self.translation_files
-			Rails.application.config.i18n.load_path.select { |p| p.split('/').last.match(/alchemy/) }
-		end
+    def self.translation_files
+      Rails.application.config.i18n.load_path.select { |p| p.split('/').last.match(/alchemy/) }
+    end
 
-	end
+  end
 end

data/lib/alchemy/modules.rb

@@ -1,38 +1,38 @@
 module Alchemy
-	module Modules
+  module Modules
 
-		@@alchemy_modules = YAML.load_file(File.join(File.dirname(__FILE__), '../..', 'config/alchemy', 'modules.yml'))
+    @@alchemy_modules = YAML.load_file(File.join(File.dirname(__FILE__), '../..', 'config/alchemy', 'modules.yml'))
 
-		def self.included(base)
-			base.send :helper_method, :alchemy_modules, :module_definition_for
-		end
+    def self.included(base)
+      base.send :helper_method, :alchemy_modules, :module_definition_for
+    end
 
-		def alchemy_modules
-			@@alchemy_modules
-		end
+    def alchemy_modules
+      @@alchemy_modules
+    end
 
-		def module_definition_for(name)
-			if name.is_a? String
-				alchemy_modules.detect{ |p| p["name"] == name }
-			elsif name.is_a? Hash
-				alchemy_modules.detect do |alchemy_module|
-					alchemy_module.stringify_keys!
-					name.symbolize_keys!
-					module_navi = alchemy_module["navigation"].stringify_keys
-					if module_navi["sub_navigation"]
-						module_navi["sub_navigation"].map(&:stringify_keys).detect do |subnavi|
-							subnavi["controller"].gsub(/^\//, '') == name[:controller] && subnavi["action"] == name[:action]
-						end
-					end
-				end
-			else
-				raise "Could not find module definition for #{name}"
-			end
-		end
+    def module_definition_for(name)
+      if name.is_a? String
+        alchemy_modules.detect { |p| p["name"] == name }
+      elsif name.is_a? Hash
+        alchemy_modules.detect do |alchemy_module|
+          alchemy_module.stringify_keys!
+          name.symbolize_keys!
+          module_navi = alchemy_module["navigation"].stringify_keys
+          if module_navi["sub_navigation"]
+            module_navi["sub_navigation"].map(&:stringify_keys).detect do |subnavi|
+              subnavi["controller"].gsub(/^\//, '') == name[:controller] && subnavi["action"] == name[:action]
+            end
+          end
+        end
+      else
+        raise "Could not find module definition for #{name}"
+      end
+    end
 
-		def self.register_module(module_definition)
-			@@alchemy_modules << module_definition.stringify_keys
-		end
+    def self.register_module(module_definition)
+      @@alchemy_modules << module_definition.stringify_keys
+    end
 
-	end
+  end
 end

data/lib/alchemy/mount_point.rb

@@ -1,10 +1,10 @@
 module Alchemy
 
-	# Returns alchemys mount point in current rails app.
-	def self.mount_point
-		alchemy_routes = Rails.application.routes.named_routes[:alchemy]
-		raise "Alchemy not mounted! Please mount Alchemy::Engine in your config/routes.rb file." if alchemy_routes.nil?
-		alchemy_routes.path.gsub(/^\/$/, '')
-	end
+  # Returns alchemys mount point in current rails app.
+  def self.mount_point
+    alchemy_routes = Rails.application.routes.named_routes[:alchemy]
+    raise "Alchemy not mounted! Please mount Alchemy::Engine in your config/routes.rb file." if alchemy_routes.nil?
+    alchemy_routes.path.spec.to_s.gsub(/^\/$/, '')
+  end
 
 end

data/lib/alchemy/page_layout.rb

@@ -1,107 +1,108 @@
 module Alchemy
-	class PageLayout
+  class PageLayout
 
-		def self.included(base)
-			get_layouts
-		end
+    def self.included(base)
+      get_layouts
+    end
 
-		def self.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
+    def self.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 the page_layout.yml file. Tries to first load from config/alchemy and if not found from vendor/plugins/alchemy/config/alchemy.
-		def self.get_layouts
-			@@definitions ||= read_layouts_file
-		end
+    # Returns the page_layout.yml file. Tries to first load from config/alchemy and if not found from vendor/plugins/alchemy/config/alchemy.
+    def self.get_layouts
+      @@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.
-		def self.add(page_layout)
-			get_layouts
-			if page_layout.is_a?(Array)
-				@@definitions += page_layout
-			elsif page_layout.is_a?(Hash)
-				@@definitions << page_layout
-			else
-				raise TypeError
-			end
-		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.
+    def self.add(page_layout)
+      get_layouts
+      if page_layout.is_a?(Array)
+        @@definitions += page_layout
+      elsif page_layout.is_a?(Hash)
+        @@definitions << page_layout
+      else
+        raise TypeError
+      end
+    end
 
-		# Returns the page_layout description found by name in page_layouts.yml
-		def self.get(name)
-			return {} if name.blank?
-			get_layouts.detect{ |a| a["name"].downcase == name.downcase }
-		end
+    # Returns the page_layout description found by name in page_layouts.yml
+    def self.get(name)
+      return {} if name.blank?
+      get_layouts.detect { |a| a["name"].downcase == name.downcase }
+    end
 
-		def self.get_all_by_attributes(attributes)
-			return [] if attributes.blank?
-			if attributes.class.name == 'Hash'
-				layouts = []
-				attributes.stringify_keys.each do |key, value|
-					result = get_layouts.select{ |a| a[key].to_s.downcase == value.to_s.downcase if a.has_key?(key) }
-					layouts += result unless result.empty?
-				end
-				return layouts
-			else
-				return []
-			end
-		end
+    def self.get_all_by_attributes(attributes)
+      return [] if attributes.blank?
+      if attributes.class.name == 'Hash'
+        layouts = []
+        attributes.stringify_keys.each do |key, value|
+          result = get_layouts.select { |a| a[key].to_s.downcase == value.to_s.downcase if a.has_key?(key) }
+          layouts += result unless result.empty?
+        end
+        return layouts
+      else
+        return []
+      end
+    end
 
-		# Returns page layouts ready for Rails' select form helper.
-		def self.get_layouts_for_select(language_id, layoutpage = false)
-			layouts_for_select = [ [ Alchemy::I18n.t("Please choose"), "" ] ]
-			selectable_layouts(language_id, layoutpage).each do |layout|
-				display_name = Alchemy::I18n.t("page_layout_names.#{layout['name']}", :default => layout['name'].camelize)
-				layouts_for_select << [display_name, layout["name"]]
-			end
-			layouts_for_select
-		end
+    # Returns page layouts ready for Rails' select form helper.
+    def self.get_layouts_for_select(language_id, layoutpage = false)
+      layouts_for_select = [[Alchemy::I18n.t("Please choose"), ""]]
+      selectable_layouts(language_id, layoutpage).each do |layout|
+        display_name = Alchemy::I18n.t("page_layout_names.#{layout['name']}", :default => layout['name'].camelize)
+        layouts_for_select << [display_name, layout["name"]]
+      end
+      layouts_for_select
+    end
 
-		def self.selectable_layouts(language_id, layoutpage = false)
-			get_layouts.select do |layout|
-				used = layout["unique"] && has_a_page_this_layout?(layout["name"], language_id)
-				if layoutpage
-					layout["layoutpage"] == true && !used
-				else
-					layout["layoutpage"] != true && !used
-				end
-			end
-		end
+    def self.selectable_layouts(language_id, layoutpage = false)
+      get_layouts.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
+        else
+          layout["layoutpage"] != true && !used
+        end
+      end
+    end
 
-		def self.get_page_layout_names
-			a = []
-			get_layouts.each{ |l| a << l.keys.first }
-			a
-		end
+    def self.get_page_layout_names
+      a = []
+      get_layouts.each { |l| a << l.keys.first }
+      a
+    end
 
-		def self.has_a_page_this_layout?(layout, language_id)
-			Page.where({:page_layout => layout, :language_id => language_id}).any?
-		end
+    def self.has_a_page_this_layout?(layout, language_id)
+      Page.where({:page_layout => layout, :language_id => language_id}).any?
+    end
 
-		# Reads the layout definitions from +config/alchemy/page_layouts.yml+.
-		# If this can not be found, it takes the default one from Alchemys standard set.
-		def self.read_layouts_file
-			if File.exists? "#{Rails.root}/config/alchemy/page_layouts.yml"
-				layouts = YAML.load_file "#{Rails.root}/config/alchemy/page_layouts.yml"
-			end
-			if !layouts
-				if File.exists? File.join(File.dirname(__FILE__), "../../config/alchemy/page_layouts.yml")
-					layouts = YAML.load_file File.join(File.dirname(__FILE__), "../../config/alchemy/page_layouts.yml")
-				end
-			end
-			if !layouts
-				raise LoadError, "Could not find page_layouts.yml file! Please run: rails generate alchemy:scaffold"
-			end
-			layouts
-		end
+    # Reads the layout definitions from +config/alchemy/page_layouts.yml+.
+    # If this can not be found, it takes the default one from Alchemys standard set.
+    def self.read_layouts_file
+      if File.exists? "#{Rails.root}/config/alchemy/page_layouts.yml"
+        layouts = YAML.load_file "#{Rails.root}/config/alchemy/page_layouts.yml"
+      end
+      if !layouts
+        if File.exists? File.join(File.dirname(__FILE__), "../../config/alchemy/page_layouts.yml")
+          layouts = YAML.load_file File.join(File.dirname(__FILE__), "../../config/alchemy/page_layouts.yml")
+        end
+      end
+      if !layouts
+        raise LoadError, "Could not find page_layouts.yml file! Please run: rails generate alchemy:scaffold"
+      end
+      layouts
+    end
 
-	end
+  end
 end