amalgam 2.1.1

data/lib/amalgam/globalize.rb

@@ -0,0 +1,6 @@
+module Amalgam::Globalize
+  extend ActiveSupport::Concern
+  included do
+    include Amalgam::Globalize::Helpers
+  end
+end

data/lib/amalgam/globalize/helpers.rb

@@ -0,0 +1,44 @@
+module Amalgam
+  module Globalize
+    module Helpers
+      extend ActiveSupport::Concern
+      included do
+        before_filter :set_locale
+      end
+
+      def set_locale
+        extracted_locale = ''
+        if can_edit?
+          extracted_locale = params[:locale] ||
+              extract_locale_from_subdomain ||
+              session[:locale]
+        else
+          extracted_locale = params[:locale] ||
+              extract_locale_from_subdomain
+        end
+
+        available_locales = ::I18n::available_locales.collect{|m| m.to_s}
+
+        ::I18n.locale = (available_locales.include? extracted_locale.to_s) ?
+            extracted_locale : ::I18n.default_locale
+
+        session[:locale] = extracted_locale if params[:locale] && can_edit?
+      end
+
+      def default_url_options(options={})
+        return {} if Amalgam.i18n == 'subdomain'
+        if Amalgam.i18n == 'param'
+          return !options[:locale] ? { :locale => ::I18n.locale.to_s } : {}
+        end
+        {}
+      end
+
+      protected
+
+      def extract_locale_from_subdomain
+        res = request.subdomains.first
+        res if !request.subdomains.empty? and res != request.host
+      end
+    end
+  end
+end

data/lib/amalgam/models/attachable.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+module Amalgam
+  module Models
+    module Attachable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessible :attachments_attributes
+        has_many :attachments, :as => :attachable, :class_name => Amalgam.attachment_class_name, :extend => ::Amalgam::Models::Attachable::AttachmentExtension
+        accepts_nested_attributes_for :attachments,
+          :allow_destroy => true,
+          :reject_if => proc {|attachment| attachment[:id].blank? && attachment[:file].blank?}
+      end
+
+      module AttachmentExtension
+        class DelegateArray < ::Array
+          def method_missing(*args)
+            first.send(*args)
+          end
+        end
+
+
+        # 返回一个 <tt>#HashWithIndifferentAccess</tt>
+        # 包含所有的附件,key为附件的name或者索引, value 为集合, 可直接作为第一个元素调用
+        # 举例:
+        #  page[:attachments]
+        #  # => [{:name => 'file' , :file => <FILE1> },
+        #  #     {:name => 'file} , :file => <FILE2> },
+        #  #     {:name => 'file2', :file => <FILE3>}
+        #  #     {:file => <FILE4>}]
+        #  page.attachments
+        #  #  => {0 => <FILE1> , 1 => <FILE2> , 2 => <FILE3> ,3 => <FILE4>
+        #         'file' => [<FILE1>,<FILE2>],
+        #         'file2' => [<FILE3>]
+        #        }
+        #  page.attachments['file'].name #=> page.attachments['file'].first.name
+        def [](key)
+          return @attachments_hash[key] if @attachments_hash
+          @attachments_hash = HashWithIndifferentAccess.new
+          each_with_index do |a,i|
+            @attachments_hash[i] = a
+            if a.name.present?
+              @attachments_hash[a.name] = (@attachments_hash[a.name] || DelegateArray.new) << a
+            end
+          end
+          @attachments_hash[key]
+        end
+      end
+    end
+  end
+end

data/lib/amalgam/models/base_group.rb

@@ -0,0 +1,14 @@
+module Amalgam
+  module Models
+    class BaseGroup < ::ActiveRecord::Base
+      set_table_name "base_groups"
+
+      attr_accessible :group_id,:groupable_type,:groupable_id
+
+      belongs_to :group, :class_name => '::Amalgam::Models::Group'
+      belongs_to :groupable, :polymorphic => true
+
+      validates_presence_of :group_id
+    end
+  end
+end

data/lib/amalgam/models/group.rb

@@ -0,0 +1,15 @@
+module Amalgam
+  module Models
+    class Group < ::ActiveRecord::Base
+      set_table_name "groups"
+
+      attr_accessible :name
+
+      has_many :base_groups, :dependent => :destroy, :class_name => '::Amalgam::Models::BaseGroup'
+
+      validates_presence_of :name
+      validates_uniqueness_of :name
+      validates_length_of :name, :maximum => 255
+    end
+  end
+end

data/lib/amalgam/models/groupable.rb

@@ -0,0 +1,16 @@
+# encoding: UTF-8
+module Amalgam
+  module Models
+    module Groupable
+      extend ActiveSupport::Concern
+
+      included do
+
+        attr_accessible :group_ids
+
+        has_many :base_groups, :as => :groupable, :dependent => :destroy, :include => :group, :class_name => "::Amalgam::Models::BaseGroup"
+        has_many :groups, :through => :base_groups, :class_name => "::Amalgam::Models::Group"
+      end
+    end
+  end
+end

data/lib/amalgam/models/hierarchical.rb

@@ -0,0 +1,71 @@
+module Amalgam
+  module Models
+    module Hierachical
+      extend ActiveSupport::Concern
+
+      included do
+        acts_as_nested_set :dependent => :destroy
+        self.reflect_on_association(:children).options[:extend] << ChildrenExtension
+
+        attr_accessor :prev_id,:next_id
+
+        validates :title, :slug, :presence => true
+        validates_uniqueness_of :slug, :scope => :parent_id
+        validates_with Amalgam::Validator::Slug
+
+        default_scope order('lft ASC')
+
+        before_save :update_hierarchy
+        before_save :update_path , :if => :slug_changed?
+        after_save :update_descendants_path
+      end
+
+      protected
+      def update_hierarchy
+        old_parent_id = parent_id_changed? ? parent_id_was : parent_id
+        # TODO: When hierarchy changed , all field changed state will lost.
+        #       So moving or data updating can't be done at same time.
+        if prev_id.present?
+          self.move_to_right_of(target = self.class.find(prev_id))
+          @move_to_new_parent_id = false
+        elsif next_id.present?
+          self.move_to_left_of(target = self.class.find(next_id))
+          @move_to_new_parent_id = false
+        end
+        update_path if old_parent_id != parent_id
+        true
+      end
+
+      def update_path
+        @old_path = self.path
+        self.path = parent_id.present? ? "#{parent.path}/#{self.slug}" : self.slug
+        true
+      end
+
+      def update_descendants_path
+        if @old_path
+          self.class.transaction do
+            self.descendants.find_each do |child|
+              child.update_attribute(:path, child.path.gsub(/^#{@old_path}/, self.path))
+            end
+          end
+        end
+        @old_path = nil
+      end
+    end
+
+    module ChildrenExtension
+      def [](slug)
+        return @children_hash[slug] if @children_hash
+        @children_hash = HashWithIndifferentAccess.new
+        each_with_index do |c,i|
+          @children_hash[i] = c
+          if c.slug.present?
+            @children_hash[c.slug] = c
+          end
+        end
+        @children_hash[slug]
+      end
+    end
+  end
+end

data/lib/amalgam/models/page.rb

@@ -0,0 +1,13 @@
+module Amalgam
+	module Models
+		module Page
+		  extend ActiveSupport::Concern
+		  included do
+		    include Amalgam::Models::Hierachical
+        include Amalgam::Models::Attachable
+        include Amalgam::Models::Templatable
+        include Amalgam::Models::Groupable
+		  end
+		end
+	end
+end

data/lib/amalgam/models/templatable.rb

@@ -0,0 +1,16 @@
+module Amalgam
+  module Models
+    module Templatable
+      extend ActiveSupport::Concern
+
+      def template_keys
+        keys = []
+        keys << self.slug
+        self.groups.each do |g|
+          keys << '@' + g.name
+        end
+        keys
+      end
+    end
+  end
+end

data/lib/amalgam/template_finder.rb

@@ -0,0 +1,122 @@
+require 'find'
+module Amalgam
+  module TemplateFinder
+    @@cache = (Rails.env == 'production')
+    mattr_accessor :cache
+
+    class Rule
+      @@rules = {}
+
+      def self.load(root,model)
+        @@rules[model] = []
+        path = "#{root}/app/views/#{model.tableize}/"
+        Find.find(path).each do |p|
+          if File.file?(p)
+            p.slice!(path)
+            list = p.split('/')
+            list[list.length-1] = list.last.split('.').first
+            @@rules[model] << Rule.new(list)
+          end
+        end
+        @@rules[model].sort{|x,y| y.list.length<=>x.list.length}
+      end
+
+      def initialize(list)
+        @list = list
+        @result = 0
+      end
+
+      def self.rules
+        @@rules
+      end
+
+      def list
+        @list
+      end
+
+      def self.look_up(pages,options = {})
+        list = []
+        @@rules[options[:path] || pages.first.class.model_name.tableize].clone.each{|rule| list << rule.look_up_single(pages.clone)}
+        result1 = list.max{|x,y| x[1] <=> y[1]}
+        result2 = list.select{|x| x[0].first != 'default' && x[0].first != 'show'}.max{|x,y| x[1] <=> y[1]}
+        return result1[0] unless result2
+        result = result1[1]>result2[1] ? result1[0] : result2[0]
+      end
+
+      def look_up_single(pages)
+        result = 0
+        is_self = true
+        list = @list.clone.reverse<<nil
+        pages<<nil
+        level = false
+        rule = list.shift
+        while list.present? && pages.present?
+          page = pages.shift
+          break unless page
+          check_result = check(rule,page,is_self)
+          is_self = false if is_self
+          #puts check_result.to_s + ':'+rule+":"+page.template_keys.to_s
+          if check_result>0 || rule.match(/^&?(\d+)/)
+            result += check_result*(level&&rule!='default' ? 10 : 1) unless rule=='default'&&pages.length>1&&list.length<=1
+            rule = list.shift unless rule.match(/^&?(\d+)/)
+            if rule && rule.match(/^&?(\d+)/)
+              position = rule.match(/^&?(\d+)/)[1].to_i-1
+              if pages.length > position+1
+                rule = list.shift
+                position.times{pages.shift}
+                level = true
+              else
+                break
+              end
+            end
+          else
+            if level == true
+              return [@list,0]
+            end
+          end
+        end
+        if list.present?
+          return [@list,0]
+        else
+          return [@list,result]
+        end
+      end
+
+      private
+
+      def check(rule,page,is_self)
+        return 1 if rule=='default' || rule=='show'
+        keys = rule.split('@')
+        (1..keys.length-1).each do |i|
+          keys[i] = '@' + keys[i]
+        end
+        keys.shift unless keys.first.present?
+        if keys & page.template_keys == keys
+          result = keys.first.include?('@') ? keys.length*100 : (keys.length-1)*100+10000
+          result = keys.length unless is_self
+          result
+        else
+          return 0
+        end
+      end
+    end
+
+    def self.included(base)
+       class << base
+        attr_accessor :slug_template_cache
+       end
+       base.slug_template_cache = Hash.new
+    end
+
+    protected
+
+    def template_for(page,options={})
+      if Rails.application.config.consider_all_requests_local
+        Amalgam.load_templates
+      end
+      options[:path] ||= controller_name
+      rule = Amalgam::TemplateFinder::Rule.look_up(page.ancestors.reverse.unshift(page),options)
+      options[:path]+'/'+rule.join('/')
+    end
+  end
+end

data/lib/amalgam/tree/exportable.rb

@@ -0,0 +1,46 @@
+module Amalgam
+  module Tree
+    class Exportable
+      def self.export(attributes = [])
+        tmp_hash = []
+        @pages = Page.all
+        children_nodes.each do |node|
+          render_tree node, tmp_hash, attributes
+        end
+        tmp_hash
+      end
+
+      protected
+
+      def self.render_tree node,hash,attributes
+        self_hash = self.create_item(node,attributes)
+        hash << self_hash
+        if children_nodes(node).present?
+          self_hash[node.slug]['children'] = []
+          children_nodes(node).each do |child|
+            render_tree child, self_hash[node.slug]['children'], attributes
+          end
+        end
+      end
+
+      def self.children_nodes(node=nil)
+        node ? @pages.select{ |x| x.parent_id == node.id} : @pages.select{ |x| x.parent_id == nil}
+      end
+
+      def self.create_item(node,attributes)
+        hash = {node.slug => {}}
+        unless attributes.empty?
+          attributes.each do |attribute|
+            hash[node.slug][attribute] = node.send attribute if node.respond_to?(attribute) and node.send attribute
+          end
+        else
+          Page.column_names.each do |column|
+            hash[node.slug][column] = node.send column if node.respond_to?(column) and node.send column
+          end
+        end
+        hash
+      end
+
+    end
+  end
+end

data/lib/amalgam/tree/importable.rb

@@ -0,0 +1,46 @@
+module Amalgam
+  module Tree
+    class Importable
+      def self.import(yaml,force,attributes=[])
+        Page.delete_all if force == true
+        pages = YAML.load(yaml)
+        create_tree(pages) do |slug,attrs,parent_id|
+          page = ::Page.new
+          unless attributes.empty?
+            columns = Page.column_names & attributes
+            columns.each do |column|
+              page.send("#{column}=",attrs[column])if attrs[column] && !['lft','rgt'].include?(column)
+            end
+          else
+            Page.column_names.each do |column|
+              page.send("#{column}=",attrs[column])if attrs[column] && !['lft','rgt'].include?(column)
+            end
+          end
+          if page.save
+            page
+          else
+            if parent_id
+              page = Page.where("parent_id = ? and slug = ?", parent_id, page.slug).first
+            else
+              page = Page.where("parent_id is ? and slug = ?", parent_id, page.slug).first
+            end
+          end
+          page
+        end
+      end
+
+      private
+
+      def self.create_tree(object, parent_id = nil, &block)
+        case object
+          when Array then object.each { |tree| create_tree(tree, parent_id, &block) }
+          when Hash then
+            name, attrs = object.first
+            node = yield(name,attrs,parent_id)
+            (attrs['children']||[]).each { |c| node.children << create_tree(c, node.id, &block) }
+            return node
+        end
+      end
+    end
+  end
+end