Rails 2.3.11

[redminele/redminele.git] / ruby / lib / ruby / gems / 1.8 / gems / activerecord-2.3.11 / lib / active_record / associations / belongs_to_association.rb

diff --git a/ruby/lib/ruby/gems/1.8/gems/activerecord-2.3.11/lib/active_record/associations/belongs_to_association.rb b/ruby/lib/ruby/gems/1.8/gems/activerecord-2.3.11/lib/active_record/associations/belongs_to_association.rb
new file mode 100644 (file)
index 0000000..3f8b9d2
--- /dev/null
+++ b/ruby/lib/ruby/gems/1.8/gems/activerecord-2.3.11/lib/active_record/associations/belongs_to_association.rb
@@ -0,0 +1,86 @@
+module ActiveRecord
+  module Associations
+    class BelongsToAssociation < AssociationProxy #:nodoc:
+      def create(attributes = {})
+        replace(@reflection.create_association(attributes))
+      end
+
+      def build(attributes = {})
+        replace(@reflection.build_association(attributes))
+      end
+
+      def replace(record)
+        counter_cache_name = @reflection.counter_cache_column
+
+        if record.nil?
+          if counter_cache_name && !@owner.new_record?
+            @reflection.klass.decrement_counter(counter_cache_name, previous_record_id) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = @owner[@reflection.primary_key_name] = nil
+        else
+          raise_on_type_mismatch(record)
+
+          if counter_cache_name && !@owner.new_record?
+            @reflection.klass.increment_counter(counter_cache_name, record.id)
+            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = (AssociationProxy === record ? record.target : record)
+          @owner[@reflection.primary_key_name] = record_id(record) unless record.new_record?
+          @updated = true
+        end
+
+        set_inverse_instance(record, @owner)
+
+        loaded
+        record
+      end
+      
+      def updated?
+        @updated
+      end
+      
+      private
+        def find_target
+          find_method = if @reflection.options[:primary_key]
+                          "find_by_#{@reflection.options[:primary_key]}"
+                        else
+                          "find"
+                        end
+          the_target = @reflection.klass.send(find_method,
+            @owner[@reflection.primary_key_name],
+            :select     => @reflection.options[:select],
+            :conditions => conditions,
+            :include    => @reflection.options[:include],
+            :readonly   => @reflection.options[:readonly]
+          ) if @owner[@reflection.primary_key_name]
+          set_inverse_instance(the_target, @owner)
+          the_target
+        end
+
+        def foreign_key_present
+          !@owner[@reflection.primary_key_name].nil?
+        end
+
+        def record_id(record)
+          record.send(@reflection.options[:primary_key] || :id)
+        end
+
+        def previous_record_id
+          @previous_record_id ||= if @reflection.options[:primary_key]
+                                    previous_record = @owner.send(@reflection.name)
+                                    previous_record.nil? ? nil : previous_record.id
+                                  else
+                                    @owner[@reflection.primary_key_name]
+                                  end
+        end
+
+        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+        # has_one associations.
+        def we_can_set_the_inverse_on_this?(record)
+          @reflection.has_inverse? && @reflection.inverse_of.macro == :has_one
+        end
+    end
+  end
+end