Renamed Mixins to Acts to resemble the change from include ActiveRecord::Mixins::List to acts_as_list and renamed @@default_error_messagess to @@default_error_messages

git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@190 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

4 files changed, 293 insertions, 0 deletions

diff --git a/activerecord/lib/active_record/acts/list.rb b/activerecord/lib/active_record/acts/list.rb
new file mode 100644
index 0000000000..5d16f9a0c9
--- /dev/null
+++ b/activerecord/lib/active_record/acts/list.rb
@@ -0,0 +1,185 @@
+module ActiveRecord
+  # Mixins are a way of decorating existing Active Record models with additional behavior. If you for example
+  # want to keep a number of Documents in order, you can include Mixins::List, and all of the sudden be able to
+  # call <tt>document.move_to_bottom</tt>.
+  module Acts
+    # This mixin provides the capabilities for sorting and reordering a number of objects in list.
+    # The class that has this mixin included needs to have a "position" column defined as an integer on
+    # the mapped database table. Further more, you need to implement the <tt>scope_condition</tt> if you want
+    # to separate one list from another.
+    #
+    # Todo list example:
+    #
+    #   class TodoList < ActiveRecord::Base
+    #     has_many :todo_items, :order => "position"
+    #   end
+    #
+    #   class TodoItem < ActiveRecord::Base
+    #     include ActiveRecord::Mixins::List
+    #     belongs_to :todo_list
+    #  
+    #     private
+    #       def scope_condition
+    #         "todo_list_id = #{todo_list_id}"
+    #       end
+    #   end
+    #
+    #   todo_list.first.move_to_bottom
+    #   todo_list.last.move_higher
+    module List
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def acts_as_list(options = {})
+          configuration = { :column => "position", :scope => "1" }
+          configuration.update(options) if options.is_a?(Hash)
+
+          configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
+          
+          class_eval <<-EOV
+            include InstanceMethods
+
+            def position_column
+              '#{configuration[:column]}'
+            end
+
+            def scope_condition
+              "#{configuration[:scope].is_a?(Symbol) ? configuration[:scope].to_s + " = \#{" + configuration[:scope].to_s + "}" : configuration[:scope]}"
+            end
+            
+            before_destroy :remove_from_list
+            after_create   :add_to_list_bottom
+          EOV
+        end
+        
+        module InstanceMethods
+          def move_lower
+            return unless lower_item
+
+            self.class.transaction do
+              lower_item.decrement_position
+              increment_position
+            end
+          end
+
+          def move_higher
+            return unless higher_item
+
+            self.class.transaction do
+              higher_item.increment_position
+              decrement_position
+            end
+          end
+    
+          def move_to_bottom
+            self.class.transaction do
+              decrement_positions_on_lower_items
+              assume_bottom_position
+            end
+          end
+
+          def move_to_top
+            self.class.transaction do
+              increment_positions_on_higher_items
+              assume_top_position
+            end
+          end
+    
+
+          # Entering or existing the list
+    
+          def add_to_list_top
+            increment_positions_on_all_items
+          end
+
+          def add_to_list_bottom
+            assume_bottom_position
+          end
+
+          def remove_from_list
+            decrement_positions_on_lower_items
+          end
+
+
+          # Changing the position
+
+          def increment_position
+            update_attribute position_column, self.send(position_column).to_i + 1
+          end
+    
+          def decrement_position
+            update_attribute position_column, self.send(position_column).to_i - 1
+          end
+    
+    
+          # Querying the position
+    
+          def first?
+            self.send(position_column) == 1
+          end
+    
+          def last?
+            self.send(position_column) == bottom_position_in_list
+          end
+
+          private
+            # Overwrite this method to define the scope of the list changes
+            def scope_condition() "1" end
+    
+            def higher_item
+              self.class.find_first(
+                "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i - 1).to_s}"
+              )
+            end
+    
+            def lower_item
+              self.class.find_first(
+                "#{scope_condition} AND #{position_column} = #{(send(position_column).to_i + 1).to_s}"
+              )
+            end
+    
+            def bottom_position_in_list
+              item = bottom_item
+              item ? item.send(position_column) : 0
+            end
+    
+            def bottom_item
+              self.class.find_first(
+                "#{scope_condition} ",
+                "#{position_column} DESC"
+              )
+            end
+
+            def assume_bottom_position
+              update_attribute position_column, bottom_position_in_list.to_i + 1
+            end
+      
+            def assume_top_position
+              update_attribute position_column, 1
+            end
+      
+            def decrement_positions_on_lower_items
+              self.class.update_all(
+                "#{position_column} = (#{position_column} - 1)",  "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
+              )
+            end
+      
+            def increment_positions_on_higher_items
+              self.class.update_all(
+                "#{position_column} = (#{position_column} + 1)",  "#{scope_condition} AND #{position_column} < #{send(position_column)}"
+              )
+            end
+
+            def increment_positions_on_all_items
+              self.class.update_all(
+                "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
+              )
+            end
+        end     
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/activerecord/lib/active_record/acts/mixins/touch.rb b/activerecord/lib/active_record/acts/mixins/touch.rb
new file mode 100644
index 0000000000..baf217542a
--- /dev/null
+++ b/activerecord/lib/active_record/acts/mixins/touch.rb
@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Mixins
+    # Including this mixins will record when objects of the class are created in a datetime column called "created_at"
+    # and when its updated in another datetime column called "updated_at".
+    #
+    #   class Bill < ActiveRecord::Base
+    #     include ActiveRecord::Mixins::Touch
+    #   end
+    #
+    #   bill = Bill.create("amount" => 100)
+    #   bill.created_at # => Time.now at the moment of Bill.create
+    #   bill.updated_at # => Time.now at the moment of Bill.create
+    #
+    #   bill.update_attribute("amount", 150)
+    #   bill.created_at # => Time.now at the moment of Bill.create
+    #   bill.updated_at # => Time.now at the moment of bill.update_attribute
+    module Touch
+      def self.append_features(base)
+        super
+
+        base.before_create :touch_on_create
+        base.before_update :touch_on_update
+      end  
+
+      def touch_on_create
+        self.updated_at = (self.created_at ||= Time.now)
+      end
+
+      def touch_on_update
+        self.updated_at = Time.now
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/activerecord/lib/active_record/acts/touch.rb b/activerecord/lib/active_record/acts/touch.rb
new file mode 100644
index 0000000000..baf217542a
--- /dev/null
+++ b/activerecord/lib/active_record/acts/touch.rb
@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Mixins
+    # Including this mixins will record when objects of the class are created in a datetime column called "created_at"
+    # and when its updated in another datetime column called "updated_at".
+    #
+    #   class Bill < ActiveRecord::Base
+    #     include ActiveRecord::Mixins::Touch
+    #   end
+    #
+    #   bill = Bill.create("amount" => 100)
+    #   bill.created_at # => Time.now at the moment of Bill.create
+    #   bill.updated_at # => Time.now at the moment of Bill.create
+    #
+    #   bill.update_attribute("amount", 150)
+    #   bill.created_at # => Time.now at the moment of Bill.create
+    #   bill.updated_at # => Time.now at the moment of bill.update_attribute
+    module Touch
+      def self.append_features(base)
+        super
+
+        base.before_create :touch_on_create
+        base.before_update :touch_on_update
+      end  
+
+      def touch_on_create
+        self.updated_at = (self.created_at ||= Time.now)
+      end
+
+      def touch_on_update
+        self.updated_at = Time.now
+      end
+    end
+  end
+end
\ No newline at end of file
diff --git a/activerecord/lib/active_record/acts/tree.rb b/activerecord/lib/active_record/acts/tree.rb
new file mode 100644
index 0000000000..f05bbe9a78
--- /dev/null
+++ b/activerecord/lib/active_record/acts/tree.rb
@@ -0,0 +1,40 @@
+module ActiveRecord
+  module Acts
+    # Including this mixin if you want to model a tree structure by providing a parent association and an children 
+    # association. This mixin assumes that you have a column called parent_id
+    # 
+    #   class Category < ActiveRecord::Base
+    #     include ActiveRecord::Mixins::Tree
+    #   end
+    #   
+    #   Example : 
+    #   root
+    #    \_ child1 
+    #         \_ sub-child1
+    #
+    #   root      = Category.create("name" => "root")
+    #   child1      = root.children.create("name" => "child1")
+    #   subchild1   = child1.children.create("name" => "subchild1")
+    #
+    #   root.parent # => nil
+    #   child1.parent # => root
+    #   root.children # => [child1]
+    #   root.children.first.children.first # => subchild1
+    module Tree
+      def self.append_features(base)
+        super        
+        base.extend(ClassMethods)              
+      end  
+    end
+    
+    module ClassMethods
+      def acts_as_tree(options = {})
+        configuration = { :foreign_key => "parent_id", :order => nil }
+        configuration.update(options) if options.is_a?(Hash)
+        
+        belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key]
+        has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => true
+      end
+    end
+  end
+end
\ No newline at end of file