activerecord 1.14.4 → 1.15.0

data/Rakefile

@@ -27,10 +27,14 @@ task :default => [ :test_mysql, :test_sqlite, :test_postgresql ]
 
 # Run the unit tests
 
-for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase )
+for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase frontbase )
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" << "test/connections/native_#{adapter}"
-    t.pattern = "test/*_test{,_#{adapter}}.rb"
+    if adapter =~ /^sqlserver/
+      t.pattern = "test/**/*_test{,_sqlserver}.rb"
+    else
+      t.pattern = "test/**/*_test{,_#{adapter}}.rb"
+    end
     t.verbose = true
   }
 end
@@ -41,6 +45,8 @@ desc 'Build the MySQL test databases'
 task :build_mysql_databases do 
   %x( mysqladmin  create activerecord_unittest )
   %x( mysqladmin  create activerecord_unittest2 )
+  %x( mysql -e "grant all on activerecord_unittest.* to rails@localhost" )
+  %x( mysql -e "grant all on activerecord_unittest2.* to rails@localhost" )
   %x( mysql  activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql.sql')} )
   %x( mysql  activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql2.sql')} )
 end
@@ -56,21 +62,60 @@ task :rebuild_mysql_databases => [:drop_mysql_databases, :build_mysql_databases]
 
 desc 'Build the PostgreSQL test databases'
 task :build_postgresql_databases do 
-  %x( createdb activerecord_unittest )
-  %x( createdb activerecord_unittest2 )
-  %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} )
-  %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')} )
+  %x( createdb -U postgres activerecord_unittest )
+  %x( createdb -U postgres activerecord_unittest2 )
+  %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} postgres )
+  %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')}  postgres )
 end
 
 desc 'Drop the PostgreSQL test databases'
 task :drop_postgresql_databases do 
-  %x( dropdb   activerecord_unittest )
-  %x( dropdb   activerecord_unittest2 )
+  %x( dropdb -U postgres activerecord_unittest )
+  %x( dropdb -U postgres activerecord_unittest2 )
 end
 
 desc 'Rebuild the PostgreSQL test databases'
 task :rebuild_postgresql_databases => [:drop_postgresql_databases, :build_postgresql_databases]
 
+desc 'Build the FrontBase test databases'
+task :build_frontbase_databases => :rebuild_frontbase_databases 
+
+desc 'Rebuild the FrontBase test databases'
+task :rebuild_frontbase_databases do
+  build_frontbase_database = Proc.new do |db_name, sql_definition_file|
+    %(
+      STOP DATABASE #{db_name};
+      DELETE DATABASE #{db_name};
+      CREATE DATABASE #{db_name};
+
+      CONNECT TO #{db_name} AS SESSION_NAME USER _SYSTEM;
+      SET COMMIT FALSE;
+
+      CREATE USER RAILS;
+      CREATE SCHEMA RAILS AUTHORIZATION RAILS;
+      COMMIT;
+
+      SET SESSION AUTHORIZATION RAILS;
+      SCRIPT '#{sql_definition_file}';
+
+      COMMIT;
+
+      DISCONNECT ALL; 
+    )
+  end
+  create_activerecord_unittest  = build_frontbase_database['activerecord_unittest',  File.join(SCHEMA_PATH, 'frontbase.sql')]
+  create_activerecord_unittest2 = build_frontbase_database['activerecord_unittest2', File.join(SCHEMA_PATH, 'frontbase2.sql')]
+  execute_frontbase_sql = Proc.new do |sql| 
+    system(<<-SHELL)
+    /Library/FrontBase/bin/sql92 <<-SQL
+    #{sql}
+    SQL
+    SHELL
+  end
+  execute_frontbase_sql[create_activerecord_unittest]
+  execute_frontbase_sql[create_activerecord_unittest2]
+end
+
 # Generate the RDoc documentation
 
 Rake::RDocTask.new { |rdoc|
@@ -106,7 +151,7 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   
-  s.add_dependency('activesupport', '= 1.3.1' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.4.0' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"
@@ -178,4 +223,4 @@ task :release => [ :package ] do
     puts release_command
     system(release_command)
   end
-end
+end

data/lib/active_record.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004 David Heinemeier Hansson
+# Copyright (c) 2004-2006 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -46,14 +46,18 @@ require 'active_record/timestamp'
 require 'active_record/acts/list'
 require 'active_record/acts/tree'
 require 'active_record/acts/nested_set'
-require 'active_record/locking'
+require 'active_record/locking/optimistic'
+require 'active_record/locking/pessimistic'
 require 'active_record/migration'
 require 'active_record/schema'
 require 'active_record/calculations'
+require 'active_record/xml_serialization'
+require 'active_record/attribute_methods'
 
 ActiveRecord::Base.class_eval do
   include ActiveRecord::Validations
-  include ActiveRecord::Locking
+  include ActiveRecord::Locking::Optimistic
+  include ActiveRecord::Locking::Pessimistic
   include ActiveRecord::Callbacks
   include ActiveRecord::Observing
   include ActiveRecord::Timestamp
@@ -65,10 +69,12 @@ ActiveRecord::Base.class_eval do
   include ActiveRecord::Acts::List
   include ActiveRecord::Acts::NestedSet
   include ActiveRecord::Calculations
+  include ActiveRecord::XmlSerialization
+  include ActiveRecord::AttributeMethods
 end
 
 unless defined?(RAILS_CONNECTION_ADAPTERS)
-  RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase )
+  RAILS_CONNECTION_ADAPTERS = %w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase frontbase )
 end
 
 RAILS_CONNECTION_ADAPTERS.each do |adapter|

data/lib/active_record/acts/list.rb

@@ -1,8 +1,7 @@
 module ActiveRecord
   module Acts #:nodoc:
     module List #:nodoc:
-      def self.append_features(base)
-        super
+      def self.included(base)
         base.extend(ClassMethods)
       end
       
@@ -78,7 +77,8 @@ module ActiveRecord
         def insert_at(position = 1)
           insert_at_position(position)
         end
-
+        
+        # Swap positions with the next lower item, if one exists.
         def move_lower
           return unless lower_item
 
@@ -88,6 +88,7 @@ module ActiveRecord
           end
         end
         
+        # Swap positions with the next higher item, if one exists.
         def move_higher
           return unless higher_item
 
@@ -97,6 +98,8 @@ module ActiveRecord
           end
         end
         
+        # Move to the bottom of the list. If the item is already in the list, the items below it have their
+        # position adjusted accordingly.
         def move_to_bottom
           return unless in_list?
           acts_as_list_class.transaction do
@@ -105,6 +108,8 @@ module ActiveRecord
           end
         end
         
+        # Move to the top of the list. If the item is already in the list, the items above it have their
+        # position adjusted accordingly.
         def move_to_top
           return unless in_list?
           acts_as_list_class.transaction do
@@ -112,31 +117,36 @@ module ActiveRecord
             assume_top_position
           end
         end
-  
+        
         def remove_from_list
           decrement_positions_on_lower_items if in_list?
         end
 
+        # Increase the position of this item without adjusting the rest of the list.
         def increment_position
           return unless in_list?
           update_attribute position_column, self.send(position_column).to_i + 1
         end
   
+        # Decrease the position of this item without adjusting the rest of the list.
         def decrement_position
           return unless in_list?
           update_attribute position_column, self.send(position_column).to_i - 1
         end
   
+        # Return true if this object is the first in the list.
         def first?
           return false unless in_list?
           self.send(position_column) == 1
         end
         
+        # Return true if this object is the last in the list.
         def last?
           return false unless in_list?
           self.send(position_column) == bottom_position_in_list
         end
         
+        # Return the next higher item in the list.
         def higher_item
           return nil unless in_list?
           acts_as_list_class.find(:first, :conditions =>
@@ -144,6 +154,7 @@ module ActiveRecord
           )
         end
 
+        # Return the next lower item in the list.
         def lower_item
           return nil unless in_list?
           acts_as_list_class.find(:first, :conditions =>

data/lib/active_record/acts/nested_set.rb

@@ -1,8 +1,7 @@
 module ActiveRecord
   module Acts #:nodoc:
     module NestedSet #:nodoc:
-      def self.append_features(base)
-        super        
+      def self.included(base)
         base.extend(ClassMethods)              
       end  
 
@@ -164,9 +163,9 @@ module ActiveRecord
               child[left_col_name] = right_bound
               child[right_col_name] = right_bound + 1
               self[right_col_name] += 2
-              self.class.transaction {
-                self.class.update_all( "#{left_col_name} = (#{left_col_name} + 2)",  "#{scope_condition} AND #{left_col_name} >= #{right_bound}" )
-                self.class.update_all( "#{right_col_name} = (#{right_col_name} + 2)",  "#{scope_condition} AND #{right_col_name} >= #{right_bound}" )
+              self.class.base_class.transaction {
+                self.class.base_class.update_all( "#{left_col_name} = (#{left_col_name} + 2)",  "#{scope_condition} AND #{left_col_name} >= #{right_bound}" )
+                self.class.base_class.update_all( "#{right_col_name} = (#{right_col_name} + 2)",  "#{scope_condition} AND #{right_col_name} >= #{right_bound}" )
                 self.save
                 child.save
               }
@@ -181,17 +180,17 @@ module ActiveRecord
                                                                
         # Returns a set of itself and all of its nested children
         def full_set
-          self.class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} BETWEEN #{self[left_col_name]} and #{self[right_col_name]})" )
+          self.class.base_class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} BETWEEN #{self[left_col_name]} and #{self[right_col_name]})" )
         end
                   
         # Returns a set of all of its children and nested children
         def all_children
-          self.class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} > #{self[left_col_name]}) and (#{right_col_name} < #{self[right_col_name]})" )
+          self.class.base_class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} > #{self[left_col_name]}) and (#{right_col_name} < #{self[right_col_name]})" )
         end
                                   
         # Returns a set of only this entry's immediate children
         def direct_children
-          self.class.find(:all, :conditions => "#{scope_condition} and #{parent_column} = #{self.id}")
+          self.class.base_class.find(:all, :conditions => "#{scope_condition} and #{parent_column} = #{self.id}")
         end
                                       
         # Prunes a branch off of the tree, shifting all of the elements on the right
@@ -200,10 +199,10 @@ module ActiveRecord
           return if self[right_col_name].nil? || self[left_col_name].nil?
           dif = self[right_col_name] - self[left_col_name] + 1
 
-          self.class.transaction {
-            self.class.delete_all( "#{scope_condition} and #{left_col_name} > #{self[left_col_name]} and #{right_col_name} < #{self[right_col_name]}" )
-            self.class.update_all( "#{left_col_name} = (#{left_col_name} - #{dif})",  "#{scope_condition} AND #{left_col_name} >= #{self[right_col_name]}" )
-            self.class.update_all( "#{right_col_name} = (#{right_col_name} - #{dif} )",  "#{scope_condition} AND #{right_col_name} >= #{self[right_col_name]}" )
+          self.class.base_class.transaction {
+            self.class.base_class.delete_all( "#{scope_condition} and #{left_col_name} > #{self[left_col_name]} and #{right_col_name} < #{self[right_col_name]}" )
+            self.class.base_class.update_all( "#{left_col_name} = (#{left_col_name} - #{dif})",  "#{scope_condition} AND #{left_col_name} >= #{self[right_col_name]}" )
+            self.class.base_class.update_all( "#{right_col_name} = (#{right_col_name} - #{dif} )",  "#{scope_condition} AND #{right_col_name} >= #{self[right_col_name]}" )
           }
         end
       end

data/lib/active_record/acts/tree.rb

@@ -1,21 +1,20 @@
 module ActiveRecord
   module Acts #:nodoc:
     module Tree #:nodoc:
-      def self.append_features(base)
-        super        
-        base.extend(ClassMethods)              
-      end  
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
 
-      # Specify this act if you want to model a tree structure by providing a parent association and a children 
+      # Specify this act if you want to model a tree structure by providing a parent association and a children
       # association. This act requires that you have a foreign key column, which by default is called parent_id.
-      # 
+      #
       #   class Category < ActiveRecord::Base
       #     acts_as_tree :order => "name"
       #   end
-      #   
-      #   Example : 
+      #
+      #   Example:
       #   root
-      #    \_ child1 
+      #    \_ child1
       #         \_ subchild1
       #         \_ subchild2
       #
@@ -28,7 +27,7 @@ module ActiveRecord
       #   root.children # => [child1]
       #   root.children.first.children.first # => subchild1
       #
-      # In addition to the parent and children associations, the following instance methods are added to the class 
+      # In addition to the parent and children associations, the following instance methods are added to the class
       # after specifying the act:
       # * siblings          : Returns all the children of the parent, excluding the current node ([ subchild2 ] when called from subchild1)
       # * self_and_siblings : Returns all the children of the parent, including the current node ([ subchild1, subchild2 ] when called from subchild1)
@@ -49,7 +48,7 @@ module ActiveRecord
 
           class_eval <<-EOV
             include ActiveRecord::Acts::Tree::InstanceMethods
-            
+
             def self.roots
               find(:all, :conditions => "#{configuration[:foreign_key]} IS NULL", :order => #{configuration[:order].nil? ? "nil" : %Q{"#{configuration[:order]}"}})
             end
@@ -67,13 +66,13 @@ module ActiveRecord
         #   subchild1.ancestors # => [child1, root]
         def ancestors
           node, nodes = self, []
-          nodes << node = node.parent until not node.has_parent?
+          nodes << node = node.parent while node.parent
           nodes
         end
 
         def root
           node = self
-          node = node.parent until not node.has_parent?
+          node = node.parent while node.parent
           node
         end
 
@@ -82,7 +81,7 @@ module ActiveRecord
         end
 
         def self_and_siblings
-          has_parent? ? parent.children : self.class.roots
+          parent ? parent.children : self.class.roots
         end
       end
     end

data/lib/active_record/aggregations.rb

@@ -109,8 +109,8 @@ module ActiveRecord
     # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not keeping value objects
     # immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable
     module ClassMethods
-      # Adds the a reader and writer method for manipulating a value object, so
-      # <tt>composed_of :address</tt> would add <tt>address</tt> and <tt>address=(new_address)</tt>.
+      # Adds reader and writer methods for manipulating a value object:
+      # <tt>composed_of :address</tt> adds <tt>address</tt> and <tt>address=(new_address)</tt> methods.
       #
       # Options are:
       # * <tt>:class_name</tt>  - specify the class name of the association. Use it only if that name can't be inferred
@@ -118,49 +118,73 @@ module ActiveRecord
       #   if the real class name is +CompanyAddress+, you'll have to specify it with this option.
       # * <tt>:mapping</tt> - specifies a number of mapping arrays (attribute, parameter) that bind an attribute name
       #   to a constructor parameter on the value class.
+      # * <tt>:allow_nil</tt> - specifies that the aggregate object will not be instantiated when all mapped
+      #   attributes are nil.  Setting the aggregate class to nil has the effect of writing nil to all mapped attributes.
+      #   This defaults to false.
       #
       # Option examples:
       #   composed_of :temperature, :mapping => %w(reading celsius)
       #   composed_of :balance, :class_name => "Money", :mapping => %w(balance amount)
       #   composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
       #   composed_of :gps_location
+      #   composed_of :gps_location, :allow_nil => true
+      #
       def composed_of(part_id, options = {})
-        options.assert_valid_keys(:class_name, :mapping)
+        options.assert_valid_keys(:class_name, :mapping, :allow_nil)
 
         name        = part_id.id2name
-        class_name  = options[:class_name] || name_to_class_name(name)
-        mapping     = options[:mapping] || [ name, name ]
+        class_name  = options[:class_name] || name.camelize
+        mapping     = options[:mapping]    || [ name, name ]
+        allow_nil   = options[:allow_nil]  || false
 
-        reader_method(name, class_name, mapping)
-        writer_method(name, class_name, mapping)
+        reader_method(name, class_name, mapping, allow_nil)
+        writer_method(name, class_name, mapping, allow_nil)
         
         create_reflection(:composed_of, part_id, options, self)
       end
 
       private
-        def name_to_class_name(name)
-          name.capitalize.gsub(/_(.)/) { |s| $1.capitalize }
-        end
-        
-        def reader_method(name, class_name, mapping)
+        def reader_method(name, class_name, mapping, allow_nil)
+          mapping = (Array === mapping.first ? mapping : [ mapping ])
+
+          allow_nil_condition = if allow_nil
+            mapping.collect { |pair| "!read_attribute(\"#{pair.first}\").nil?"}.join(" && ")
+          else
+            "true"
+          end
+
           module_eval <<-end_eval
             def #{name}(force_reload = false)
-              if @#{name}.nil? || force_reload
-                @#{name} = #{class_name}.new(#{(Array === mapping.first ? mapping : [ mapping ]).collect{ |pair| "read_attribute(\"#{pair.first}\")"}.join(", ")})
+              if (@#{name}.nil? || force_reload) && #{allow_nil_condition}
+                @#{name} = #{class_name}.new(#{mapping.collect { |pair| "read_attribute(\"#{pair.first}\")"}.join(", ")})
               end
-              
               return @#{name}
             end
           end_eval
         end        
         
-        def writer_method(name, class_name, mapping)
-          module_eval <<-end_eval
-            def #{name}=(part)
-              @#{name} = part.freeze
-              #{(Array === mapping.first ? mapping : [ mapping ]).collect{ |pair| "@attributes[\"#{pair.first}\"] = part.#{pair.last}" }.join("\n")}
-            end
-          end_eval
+        def writer_method(name, class_name, mapping, allow_nil)
+          mapping = (Array === mapping.first ? mapping : [ mapping ])
+
+          if allow_nil
+            module_eval <<-end_eval
+              def #{name}=(part)
+                if part.nil?
+                  #{mapping.collect { |pair| "@attributes[\"#{pair.first}\"] = nil" }.join("\n")}
+                else
+                  @#{name} = part.freeze
+                  #{mapping.collect { |pair| "@attributes[\"#{pair.first}\"] = part.#{pair.last}" }.join("\n")}
+                end
+              end
+            end_eval
+          else
+            module_eval <<-end_eval
+              def #{name}=(part)
+                @#{name} = part.freeze
+                #{mapping.collect{ |pair| "@attributes[\"#{pair.first}\"] = part.#{pair.last}" }.join("\n")}
+              end
+            end_eval
+          end
         end
     end
   end