alchemy_cms 2.0.pre2

data/lib/alchemy/essence.rb

@@ -0,0 +1,178 @@
+require 'active_record'
+
+module Alchemy #:nodoc:
+  module Essence #:nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+    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:
+      #
+      # * +ingredient_column+ - specifies the column name you use for storing the content in the database (default: +body+)
+      # * +validate_column+ - which column should be validated. Takes the ingredient column if not present
+      # * +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
+      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]
+        
+        class_eval <<-EOV
+          include Alchemy::Essence::InstanceMethods
+          stampable
+          validate :essence_validations, :on => :update
+          
+          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
+      
+    end
+    
+    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:  
+      #     - name: name
+      #       type: EssenceText
+      #       validate: [presence]
+      #     - name: email
+      #       type: EssenceText
+      #       validate: [format]
+      #       validate_format_as: 'email'
+      #     - name: homepage
+      #       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
+        return true if description.blank? || description['validate'].blank?
+        description['validate'].each do |validation|
+          if validation == 'presence' && ingredient.blank?
+            add_essence_error "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?
+              add_essence_error "wrong_format"
+            end
+          elsif validation == 'uniqueness' && !acts_as_essence_class.send("find_by_#{ingredient_column}", ingredient).blank?
+            add_essence_error "taken"
+          end
+        end
+      end
+      
+      def essence_errors
+        @essence_errors ||= []
+      end
+      
+      def essence_errors=(errors)
+        @essence_errors ||= errors
+      end
+      
+      def add_essence_error(error)
+        essence_errors << error
+        errors.add(:base, :essence_validation_failed)
+      end
+      
+      # Essence description from config/elements.yml
+      def description
+        return {} if element.nil? or element.content_descriptions.nil?
+        element.content_descriptions.detect { |c| c['name'] == self.content.name }
+      end
+      
+      # Returns the Content Essence is in
+      def content
+        Content.find_by_essence_type_and_essence_id(acts_as_essence_class.to_s, self.id)
+      end
+      
+      # Returns the Element Essence is in
+      def element
+        return nil if content.nil?
+        content.element
+      end
+      
+      # Returns the Page Essence is on
+      def page
+        return nil if element.nil?
+        element.page
+      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
+      end
+      
+      def open_link_in_new_window?
+        respond_to?(:link_target) && link_target == 'blank'
+      end
+      
+    end
+    
+  end
+end
+ActiveRecord::Base.class_eval { include Alchemy::Essence } if defined?(Alchemy::Essence)

data/lib/alchemy/file_utilz.rb

@@ -0,0 +1,73 @@
+require 'fileutils'
+
+module Alchemy
+  class FileUtilz
+    # A general purpose method to mirror a directory (+source+) into a destination
+    # directory, including all files and subdirectories. Files will not be mirrored
+    # if they are identical already (checked via FileUtils#identical?).
+    #
+    # Copyright (c) 2008 James Adam (The MIT License)
+
+    # added: do mirroring with backup saving turned on
+    def self.mirror_with_backup(source, destination)
+      self.mirror_files(source, destination, true)
+    end
+
+    def self.mirror_files(source, destination, create_backups = false)
+      # TODO: use Rake::FileList#pathmap?
+      if File.directory?(source)
+        source_files  = Dir[source + "/**/*"]
+        source_dirs   = source_files.select { |d| File.directory?(d) }
+        source_files -= source_dirs
+      elsif File.exist? source
+        source_dirs   = []
+        source_files  = [source]
+        source        = File.dirname source
+      else
+        puts "Could not mirror #{source} - entity does not exist"
+        return
+      end
+
+      unless source_files.empty?
+        base_target_dir = File.join(destination)
+        base_target_dir = File.dirname base_target_dir unless File.directory? base_target_dir
+        FileUtils.mkdir_p(base_target_dir)
+      end
+
+      base_target_dir ||= File.join(destination)
+
+      source_dirs.each do |dir|
+        # strip down these paths so we have simple, relative paths we can
+        # add to the destination
+        target_dir = File.join(base_target_dir, dir.gsub(source, ''))
+        begin
+          FileUtils.mkdir_p(target_dir)
+        rescue Exception => e
+          raise "Could not create directory #{target_dir}: \n" + e
+        end
+      end
+
+      source_files.each do |file|
+        begin
+          target = File.join(base_target_dir, file.gsub(source, ''))
+          unless File.exist?(target) && self.same_contents(file, target)
+            # WAS FileUtils.identical?(file, target), but we want to test contents too
+            if create_backups && File.exist?(target)
+              File.rename(target, target + '~')
+            end
+            FileUtils.cp(file, target)
+          end
+        rescue Exception => e
+          raise "Could not copy #{file} to #{target}: \n" + e
+        end
+      end
+    end
+
+    # for windows users...
+    def self.same_contents(source,destination)
+      File.read(source) == File.read(destination)
+    end
+
+  end
+end
+

data/lib/alchemy/page_layout.rb

@@ -0,0 +1,66 @@
+module Alchemy
+  class PageLayout
+    
+    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
+      if File.exists? "#{Rails.root}/config/alchemy/page_layouts.yml"
+        layouts = YAML.load_file( "#{Rails.root}/config/alchemy/page_layouts.yml" )
+      elsif File.exists? "#{Rails.root}/vendor/plugins/alchemy/config/alchemy/page_layouts.yml"
+        layouts = YAML.load_file( "#{Rails.root}/vendor/plugins/alchemy/config/alchemy/page_layouts.yml" )
+      else
+        raise LoadError, "Could not find page_layouts.yml file! Please run: rails generate alchemy:scaffold"
+      end
+      layouts
+    end
+   
+    # Returns the page_layout description found by name in page_layouts.yml
+    def self.get(name = "")
+      self.get_layouts.detect{ |a| a["name"].downcase == name.downcase }
+    rescue Exception => e
+      Rails.logger.error("++++++ ERROR\n#{e}")
+      return nil
+    end
+    
+    # Returns page layouts ready for Rails' select form helper.
+    def self.get_layouts_for_select(language_id, layoutpage = false)
+      layouts_for_select = [ [ _("Please choose"), "" ] ]
+      self.selectable_layouts(language_id, layoutpage).each do |layout|
+        display_name = I18n.t("alchemy.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)
+      self.get_layouts.select do |layout|
+        used = layout["unique"] && self.has_another_page_this_layout?(layout["name"], language_id)
+        if layoutpage
+          layout["layoutpage"] == true && !used && layout["newsletter"] != true
+        else
+          layout["layoutpage"] != true && !used && layout["newsletter"] != true
+        end
+      end
+    end
+    
+    def self.get_page_layout_names
+      a = []
+      self.get_layouts.each{ |l| a << l.keys.first }
+      a
+    end
+    
+    def self.has_another_page_this_layout?(layout, language_id)
+      Page.where({:page_layout => layout, :language_id => language_id}).any?
+    end
+    
+  end
+end

data/lib/alchemy/remote_pagination_link_renderer.rb

@@ -0,0 +1,17 @@
+# This is for will_paginate
+module Alchemy
+  class RemotePaginationLinkRenderer < WillPaginate::LinkRenderer
+    
+    def prepare(collection, options, template)
+      @remote = options.delete(:remote) || {}
+      super
+    end
+    
+  protected
+    
+    def page_link(page, text, attributes = {})
+      @template.link_to(text, url_for(page), {:remote => true, :method => :get}.merge(@remote).merge(attributes))
+    end
+    
+  end
+end

data/lib/alchemy/seeder.rb

@@ -0,0 +1,112 @@
+module Alchemy
+  class Seeder
+    require 'yaml'
+    
+    # This seed builds the necessary page structure for alchemy in your db.
+    # Put Alchemy::Seeder.seed! inside your db/seeds.rb file and run it with rake db:seed.
+    def self.seed!
+      FastGettext.add_text_domain 'alchemy', :path => File.join(File.dirname(__FILE__), '../../locale')
+      FastGettext.text_domain = 'alchemy'
+      FastGettext.available_locales = ['de', 'en']
+      FastGettext.locale = Alchemy::Config.get(:default_translation)
+      
+      errors = []
+      notices = []
+      
+      default_language = Alchemy::Config.get(:default_language)
+      
+      lang = Language.find_or_initialize_by_code(
+        :name => default_language['name'],
+        :code => default_language['code'],
+        :frontpage_name => default_language['frontpage_name'],
+        :page_layout => default_language['page_layout'],
+        :public => true,
+        :default => true
+      )
+      if lang.new_record?
+        if lang.save
+          puts "== Created language #{lang.name}"
+        else
+          errors << "Errors creating language #{lang.name}: #{lang.errors.full_messages}"
+        end
+      else
+        notices << "== Skipping! Language #{lang.name} was already present"
+      end
+      
+      root = Page.find_or_initialize_by_name(
+        :name => 'Root',
+        :page_layout => "rootpage",
+        :do_not_autogenerate => true,
+        :do_not_sweep => true,
+        :language => lang
+      )
+      if root.new_record?
+        if root.save
+          # We have to remove the language, because active record validates its presence on create.
+          root.language = nil
+          root.save
+          puts "== Created page #{root.name}"
+        else
+          errors << "Errors creating page #{root.name}: #{root.errors.full_messages}"
+        end
+      else
+        notices << "== Skipping! Page #{root.name} was already present"
+      end
+      
+      if errors.blank?
+        puts "Success!"
+        notices.map{ |note| puts note }
+      else
+        puts "WARNING! Some pages could not be created:"
+        errors.map{ |error| puts error }
+      end
+    end
+    
+    # This method is for running after upgrading an old Alchemy version without Language Model (pre v1.5).
+    # Put Alchemy::Seeder.upgrade! inside your db/seeds.rb file and run it with rake db:seed.
+    def self.upgrade!
+      seed!
+      Page.all.each do |page|
+        if !page.language_code.blank? && page.language.nil?
+          root = page.get_language_root
+          lang = Language.find_or_create_by_code(
+            :name => page.language_code.capitalize,
+            :code => page.language_code,
+            :frontpage_name => root.name,
+            :page_layout => root.page_layout,
+            :public => true
+          )
+          page.language = lang
+          if page.save(false)
+            puts "== Set language for page #{page.name} to #{lang.name}"
+          end
+        else
+          puts "== Skipping! Language for page #{page.name} already set."
+        end
+      end
+      default_language = Language.get_default
+      Page.layoutpages.each do |page|
+        if page.language.class == String || page.language.nil?
+          page.language = default_language
+          if page.save(false)
+            puts "== Set language for page #{page.name} to #{default_language.name}"
+          end
+        else
+          puts "== Skipping! Language for page #{page.name} already set."
+        end
+      end
+      (EssencePicture.all + EssenceText.all).each do |essence|
+        case essence.link_target
+        when '1'
+          if essence.update_attribute(:link_target, 'blank')
+            puts "== Updated #{essence.preview_text} link target to #{essence.link_target}."
+          end
+        when '0'
+          essence.update_attribute(:link_target, nil)
+          puts "== Updated #{essence.preview_text} link target to #{essence.link_target.inspect}."
+        end
+      end
+    end
+    
+  end
+end