activerecord 1.12.2 → 1.13.0

data/lib/active_record/associations/association_collection.rb

@@ -124,14 +124,6 @@ module ActiveRecord
       end
 
       private
-        def method_missing(method, *args, &block)
-          if @target.respond_to?(method) or (not @association_class.respond_to?(method) and Class.respond_to?(method))
-            super
-          else
-            @association_class.constrain(:conditions => @finder_sql, :joins => @join_sql) { @association_class.send(method, *args, &block) }
-          end
-        end
-              
         def raise_on_type_mismatch(record)
           raise ActiveRecord::AssociationTypeMismatch, "#{@association_class} expected, got #{record.class}" unless record.is_a?(@association_class)
         end

data/lib/active_record/associations/association_proxy.rb

@@ -2,7 +2,8 @@ module ActiveRecord
   module Associations
     class AssociationProxy #:nodoc:
       alias_method :proxy_respond_to?, :respond_to?
-      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?|^proxy_respond_to\?|^send)/ }
+      alias_method :proxy_extend, :extend
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?|^proxy_respond_to\?|^proxy_extend|^send)/ }
 
       def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
         @owner = owner
@@ -11,6 +12,8 @@ module ActiveRecord
         @association_class = eval(association_class_name, nil, __FILE__, __LINE__)
         @association_class_primary_key_name = association_class_primary_key_name
 
+        proxy_extend(options[:extend]) if options[:extend]
+
         reset
       end
       
@@ -95,4 +98,4 @@ module ActiveRecord
         end
     end
   end
-end
+end

data/lib/active_record/associations/belongs_to_association.rb

@@ -49,9 +49,13 @@ module ActiveRecord
       private
         def find_target
           if @options[:conditions]
-            @association_class.find_on_conditions(@owner[@association_class_primary_key_name], interpolate_sql(@options[:conditions]))
+            @association_class.find(
+              @owner[@association_class_primary_key_name], 
+              :conditions => interpolate_sql(@options[:conditions]),
+              :include    => @options[:include]
+            )
           else
-            @association_class.find(@owner[@association_class_primary_key_name])
+            @association_class.find(@owner[@association_class_primary_key_name], :include => @options[:include])
           end
         end
 

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -76,11 +76,21 @@ module ActiveRecord
       end
       
       protected
+        def method_missing(method, *args, &block)
+          if @target.respond_to?(method) || (!@association_class.respond_to?(method) && Class.respond_to?(method))
+            super
+          else
+            @association_class.with_scope(:find => { :conditions => @finder_sql, :joins => @join_sql, :readonly => false }) do
+              @association_class.send(method, *args, &block)
+            end
+          end
+        end
+            
         def find_target
           if @options[:finder_sql]
             records = @association_class.find_by_sql(@finder_sql)
           else
-            records = find(:all)
+            records = find(:all, :include => @options[:include])
           end
           
           @options[:uniq] ? uniq(records) : records

data/lib/active_record/associations/has_many_association.rb

@@ -23,12 +23,12 @@ module ActiveRecord
       # DEPRECATED.
       def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
         if @options[:finder_sql]
-          records = @association_class.find_by_sql(@finder_sql)
+          @association_class.find_by_sql(@finder_sql)
         else
-          sql = @finder_sql
-          sql += " AND (#{sanitize_sql(runtime_conditions)})" if runtime_conditions
+          conditions = @finder_sql
+          conditions += " AND (#{sanitize_sql(runtime_conditions)})" if runtime_conditions
           orderings ||= @options[:order]
-          records = @association_class.find_all(sql, orderings, limit, joins)
+          @association_class.find_all(conditions, orderings, limit, joins)
         end
       end
 
@@ -85,8 +85,37 @@ module ActiveRecord
       end
       
       protected
+        def method_missing(method, *args, &block)
+          if @target.respond_to?(method) || (!@association_class.respond_to?(method) && Class.respond_to?(method))
+            super
+          else
+            @association_class.with_scope(
+              :find => {
+                :conditions => @finder_sql, 
+                :joins      => @join_sql, 
+                :readonly   => false
+              },
+              :create => {
+                @association_class_primary_key_name => @owner.id
+              }
+            ) do
+              @association_class.send(method, *args, &block)
+            end
+          end
+        end
+            
         def find_target
-          find_all
+          if @options[:finder_sql]
+            @association_class.find_by_sql(@finder_sql)
+          else
+            @association_class.find(:all, 
+              :conditions => @finder_sql,
+              :order      => @options[:order], 
+              :limit      => @options[:limit],
+              :joins      => @options[:joins],
+              :include    => @options[:include]
+            )
+          end
         end
 
         def count_records

data/lib/active_record/associations/has_one_association.rb

@@ -57,7 +57,7 @@ module ActiveRecord
             
       private
         def find_target
-          @association_class.find(:first, :conditions => @finder_sql, :order => @options[:order])
+          @association_class.find(:first, :conditions => @finder_sql, :order => @options[:order], :include => @options[:include])
         end
 
         def target_obsolete?

data/lib/active_record/base.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'set'
 require 'active_record/deprecated_finders'
 
 module ActiveRecord #:nodoc:
@@ -139,7 +140,7 @@ module ActiveRecord #:nodoc:
   #
   # == Dynamic attribute-based finders
   #
-  # Dynamic attribute-based finders are a cleaner way of getting objects by simple queries without turning to SQL. They work by
+  # Dynamic attribute-based finders are a cleaner way of getting (and/or creating) objects by simple queries without turning to SQL. They work by
   # appending the name of an attribute to <tt>find_by_</tt> or <tt>find_all_by_</tt>, so you get finders like Person.find_by_user_name,
   # Person.find_all_by_last_name, Payment.find_by_transaction_id. So instead of writing
   # <tt>Person.find(:first, ["user_name = ?", user_name])</tt>, you just do <tt>Person.find_by_user_name(user_name)</tt>.
@@ -154,6 +155,15 @@ module ActiveRecord #:nodoc:
   # is actually Payment.find_all_by_amount(amount, options). And the full interface to Person.find_by_user_name is
   # actually Person.find_by_user_name(user_name, options). So you could call <tt>Payment.find_all_by_amount(50, :order => "created_on")</tt>.
   #
+  # The same dynamic finder style can be used to create the object if it doesn't already exist. This dynamic finder is called with
+  # <tt>find_or_create_by_</tt> and will return the object if it already exists and otherwise creates it, then returns it. Example:
+  #
+  #   # No 'Summer' tag exists
+  #   Tag.find_or_create_by_name("Summer") # equal to Tag.create(:name => "Summer")
+  #   
+  #   # Now the 'Summer' tag does exist
+  #   Tag.find_or_create_by_name("Summer") # equal to Tag.find_by_name("Summer")
+  #
   # == Saving arrays, hashes, and other non-mappable objects in text columns
   #
   # Active Record can serialize any object in text columns using YAML. To do so, you must specify this with a call to the class method +serialize+.
@@ -384,9 +394,14 @@ module ActiveRecord #:nodoc:
       def find(*args)
         options = extract_options_from_args!(args)
 
-        # :joins implies :readonly => true if unset.
-        if options[:joins] and !options.has_key?(:readonly)
-          options[:readonly] = true
+        # Inherit :readonly from finder scope if set.  Otherwise,
+        # if :joins is not blank then :readonly defaults to true.
+        unless options.has_key?(:readonly)
+          if scoped?(:find, :readonly)
+            options[:readonly] = scope(:find, :readonly)
+          elsif !options[:joins].blank?
+            options[:readonly] = true
+          end
         end
 
         case args.first
@@ -445,6 +460,8 @@ module ActiveRecord #:nodoc:
         if attributes.is_a?(Array)
           attributes.collect { |attr| create(attr) }
         else
+          attributes.reverse_merge!(scope(:create)) if scoped?(:create)
+
           object = new(attributes)
           object.save
           object
@@ -702,6 +719,22 @@ module ActiveRecord #:nodoc:
         class_name
       end
 
+      # Indicates whether the table associated with this class exists
+      def table_exists?
+        if connection.respond_to?(:tables)
+          connection.tables.include? table_name
+        else
+          # if the connection adapter hasn't implemented tables, there are two crude tests that can be
+          # used - see if getting column info raises an error, or if the number of columns returned is zero
+          begin
+            reset_column_information
+            columns.size > 0
+          rescue ActiveRecord::StatementInvalid
+            false
+          end          
+        end
+      end
+
       # Returns an array of column objects for the table associated with this class.
       def columns
         unless @columns
@@ -740,15 +773,14 @@ module ActiveRecord #:nodoc:
         end
       end
 
-    
       # Contains the names of the generated reader methods.
       def read_methods
-        @read_methods ||= {}
+        @read_methods ||= Set.new
       end
-      
+
       # Resets all the cached information about columns, which will cause them to be reloaded on the next request.
       def reset_column_information
-        read_methods.each_key {|name| undef_method(name)}
+        read_methods.each { |name| undef_method(name) }
         @column_names = @columns = @columns_hash = @content_columns = @dynamic_methods_hash = @read_methods = nil
       end
 
@@ -807,20 +839,37 @@ module ActiveRecord #:nodoc:
       ensure
         logger.level = old_logger_level if logger
       end
-      
-      # Add constraints to all queries to the same model in the given block.
-      # Currently supported constraints are <tt>:conditions</tt> and <tt>:joins</tt> 
+
+      # Scope parameters to method calls within the block.  Takes a hash of method_name => parameters hash.
+      # method_name may be :find or :create.
+      # :find parameters may include the <tt>:conditions</tt>, <tt>:joins</tt>,
+      # <tt>:offset</tt>, <tt>:limit</tt>, and <tt>:readonly</tt> options.
+      # :create parameters are an attributes hash.
       #
-      #   Article.constrain(:conditions => "blog_id = 1") do
+      #   Article.with_scope(:find => { :conditions => "blog_id = 1" }, :create => { :blog_id => 1 }) do
       #     Article.find(1) # => SELECT * from articles WHERE blog_id = 1 AND id = 1
+      #     a = Article.create(1)
+      #     a.blog_id == 1
       #   end
-      def constrain(options = {}, &block)
-        begin
-          self.scope_constraints = options
-          block.call if block_given?
-        ensure 
-          self.scope_constraints = nil
+      def with_scope(method_scoping = {})
+        # Dup first and second level of hash (method and params).
+        method_scoping = method_scoping.inject({}) do |hash, (method, params)|
+          hash[method] = params.dup
+          hash
+        end
+
+        method_scoping.assert_valid_keys [:find, :create]
+        if f = method_scoping[:find]
+          f.assert_valid_keys [:conditions, :joins, :offset, :limit, :readonly]
+          f[:readonly] = true if !f[:joins].blank? && !f.has_key?(:readonly)
         end
+
+        raise ArgumentError, "Nested scopes are not yet supported: #{scoped_methods.inspect}" unless scoped_methods.nil?
+
+        self.scoped_methods = method_scoping
+        yield
+      ensure 
+        self.scoped_methods = nil
       end
 
       # Overwrite the default class equality method to provide support for association proxies.
@@ -883,21 +932,23 @@ module ActiveRecord #:nodoc:
         end
 
         def add_limit!(sql, options)
+          options[:limit]  ||= scope(:find, :limit)
+          options[:offset] ||= scope(:find, :offset)
           connection.add_limit_offset!(sql, options)
         end
-        
+
         def add_joins!(sql, options)
-          join = scope_constraints[:joins] || options[:joins]
+          join = scope(:find, :joins) || options[:joins]
           sql << " #{join} " if join
         end
-        
+
         # Adds a sanitized version of +conditions+ to the +sql+ string. Note that the passed-in +sql+ string is changed.
         def add_conditions!(sql, conditions)          
-          condition_segments = [scope_constraints[:conditions]]
-          condition_segments << sanitize_sql(conditions) unless conditions.nil?
-          condition_segments << type_condition unless descends_from_active_record?        
-          condition_segments.compact!
-          sql << "WHERE (#{condition_segments.join(") AND (")}) " unless condition_segments.empty?
+          segments = [scope(:find, :conditions)]
+          segments << sanitize_sql(conditions) unless conditions.nil?
+          segments << type_condition unless descends_from_active_record?        
+          segments.compact!
+          sql << "WHERE (#{segments.join(") AND (")}) " unless segments.empty?
         end
 
         def type_condition
@@ -922,27 +973,54 @@ module ActiveRecord #:nodoc:
         # It's even possible to use all the additional parameters to find. For example, the full interface for find_all_by_amount
         # is actually find_all_by_amount(amount, options).
         def method_missing(method_id, *arguments)
-          method_name = method_id.id2name
+          if match = /find_(all_by|by)_([_a-zA-Z]\w*)/.match(method_id.to_s)
+            finder = determine_finder(match)
 
-          if md = /find_(all_by|by)_([_a-zA-Z]\w*)/.match(method_id.to_s)
-            finder = md.captures.first == 'all_by' ? :all : :first
-            attributes = md.captures.last.split('_and_')
-            attributes.each { |attr_name| super unless column_methods_hash.include?(attr_name.to_sym) }
+            attribute_names = extract_attribute_names_from_match(match)
+            super unless all_attributes_exists?(attribute_names)
 
-            attr_index = -1
-            conditions = attributes.collect { |attr_name| attr_index += 1; "#{table_name}.#{attr_name} #{attribute_condition(arguments[attr_index])} " }.join(" AND ")
+            conditions = construct_conditions_from_arguments(attribute_names, arguments)
 
-            if arguments[attributes.length].is_a?(Hash)
-              find(finder, { :conditions => [conditions, *arguments[0...attributes.length]] }.update(arguments[attributes.length]))
+            if arguments[attribute_names.length].is_a?(Hash)
+              find(finder, { :conditions => conditions }.update(arguments[attribute_names.length]))
             else
-              # deprecated API
-              send("find_#{finder}", [conditions, *arguments[0...attributes.length]], *arguments[attributes.length..-1])
+              send("find_#{finder}", conditions, *arguments[attribute_names.length..-1]) # deprecated API
             end
+          elsif match = /find_or_create_by_([_a-zA-Z]\w*)/.match(method_id.to_s)
+            attribute_names = extract_attribute_names_from_match(match)
+            super unless all_attributes_exists?(attribute_names)
+
+            find(:first, :conditions => construct_conditions_from_arguments(attribute_names, arguments)) || 
+              create(construct_attributes_from_arguments(attribute_names, arguments))
           else
             super
           end
         end
 
+        def determine_finder(match)
+          match.captures.first == 'all_by' ? :all : :first
+        end
+
+        def extract_attribute_names_from_match(match)
+          match.captures.last.split('_and_')
+        end
+
+        def construct_conditions_from_arguments(attribute_names, arguments)
+          conditions = []
+          attribute_names.each_with_index { |name, idx| conditions << "#{table_name}.#{name} #{attribute_condition(arguments[idx])} " }
+          [ conditions.join(" AND "), *arguments[0...attribute_names.length] ]
+        end
+        
+        def construct_attributes_from_arguments(attribute_names, arguments)
+          attributes = {}
+          attribute_names.each_with_index { |name, idx| attributes[name] = arguments[idx] }
+          attributes
+        end
+
+        def all_attributes_exists?(attribute_names)
+          attribute_names.all? { |name| column_methods_hash.include?(name.to_sym) }
+        end
+
         def attribute_condition(argument)
           case argument
             when nil   then "IS ?"
@@ -986,29 +1064,37 @@ module ActiveRecord #:nodoc:
           @@subclasses[self] ||= []
           @@subclasses[self] + extra = @@subclasses[self].inject([]) {|list, subclass| list + subclass.subclasses }
         end
-        
-        def scope_constraints
+
+        # Test whether the given method and optional key are scoped.
+        def scoped?(method, key = nil)
+          scoped_methods and scoped_methods.has_key?(method) and (key.nil? or scope(method).has_key?(key))
+        end
+
+        # Retrieve the scope for the given method and optional key.
+        def scope(method, key = nil)
+          if scoped_methods and scope = scoped_methods[method]
+            key ? scope[key] : scope
+          end
+        end
+
+        def scoped_methods
           if allow_concurrency
-            Thread.current[:constraints] ||= {}
-            Thread.current[:constraints][self] ||= {}
+            Thread.current[:scoped_methods] ||= {}
+            Thread.current[:scoped_methods][self] ||= nil
           else
-            @scope_constraints ||= {}
+            @scoped_methods ||= nil
           end
         end
-        # backwards compatibility
-        alias_method :scope_constrains, :scope_constraints 
 
-        def scope_constraints=(value)
+        def scoped_methods=(value)
           if allow_concurrency
-            Thread.current[:constraints] ||= {}
-            Thread.current[:constraints][self] = value
+            Thread.current[:scoped_methods] ||= {}
+            Thread.current[:scoped_methods][self] = value
           else
-            @scope_constraints = value
+            @scoped_methods = value
           end
         end
-        # backwards compatibility
-        alias_method :scope_constrains=, :scope_constraints=
-        
+
         # Returns the class type of the record using the current module as a prefix. So descendents of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)
@@ -1108,14 +1194,13 @@ module ActiveRecord #:nodoc:
         yield self if block_given?
       end
 
-      # Every Active Record class must use "id" as their primary ID. This getter overwrites the native
-      # id method, which isn't being used in this context.
+      # A model instance's primary key is always available as model.id
+      # whether you name it the default 'id' or set it to something else.
       def id
         attr_name = self.class.primary_key
-        column    = column_for_attribute(attr_name)
-        raise ActiveRecordError, "No such primary key column #{attr_name} for table #{table_name}" if column.nil?
+        column = column_for_attribute(attr_name)
         define_read_method(:id, attr_name, column) if self.class.generate_read_methods
-        (value = @attributes[attr_name]) && column.type_cast(value)
+        read_attribute(attr_name)
       end
 
       # Enables Active Record objects to be used as URL parameters in Action Pack automatically.
@@ -1447,17 +1532,17 @@ module ActiveRecord #:nodoc:
         end
       end
 
-      # Define a column type specific reader method.
+      # Define an attribute reader method.  Cope with nil column.
       def define_read_method(symbol, attr_name, column)
-        cast_code = column.type_cast_code('v')
+        cast_code = column.type_cast_code('v') if column
         access_code = cast_code ? "(v=@attributes['#{attr_name}']) && #{cast_code}" : "@attributes['#{attr_name}']"
 
         unless attr_name.to_s == self.class.primary_key.to_s
           access_code = access_code.insert(0, "raise NoMethodError, 'missing attribute: #{attr_name}', caller unless @attributes.has_key?('#{attr_name}'); ")
+          self.class.read_methods << attr_name
         end
 
         self.class.class_eval("def #{symbol}; #{access_code}; end")
-        self.class.read_methods[attr_name] = true unless symbol == :id
       end
 
       # Returns true if the attribute is of a text column and marked for serialization.