georgepalmer-couch_foo 0.7.1

data/lib/couch_foo/associations/belongs_to_association.rb

@@ -0,0 +1,57 @@
+module CouchFoo
+  module Associations
+    class BelongsToAssociation < AssociationProxy #:nodoc:
+      def create(attributes = {})
+        replace(@reflection.klass.create(attributes))
+      end
+
+      def build(attributes = {})
+        replace(@reflection.klass.new(attributes))
+      end
+
+      def replace(record)
+        counter_cache_name = @reflection.counter_cache_property
+
+        if record.nil?
+          if counter_cache_name && !@owner.new_record?
+            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) 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 unless record.new_record?
+          @updated = true
+        end
+
+        loaded
+        record
+      end
+      
+      def updated?
+        @updated
+      end
+      
+      private
+        def find_target
+          @reflection.klass.find(
+            @owner[@reflection.primary_key_name],
+            :conditions => conditions,
+            :include    => @reflection.options[:include],
+            :readonly   => @reflection.options[:readonly]
+          )
+        end
+
+        def foreign_key_present
+          !@owner[@reflection.primary_key_name].nil?
+        end
+    end
+  end
+end

data/lib/couch_foo/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,48 @@
+module CouchFoo
+  module Associations
+    class BelongsToPolymorphicAssociation < AssociationProxy #:nodoc:
+      def replace(record)
+        if record.nil?
+          @target = @owner[@reflection.primary_key_name] = @owner[@reflection.options[:foreign_type]] = nil
+        else
+          @target = (AssociationProxy === record ? record.target : record)
+
+          @owner[@reflection.primary_key_name] = record.id
+          @owner[@reflection.options[:foreign_type]] = record.class.name.to_s
+
+          @updated = true
+        end
+
+        loaded
+        record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+        def find_target
+          return nil if association_class.nil?
+
+          if @reflection.options[:conditions]
+            association_class.find(
+              @owner[@reflection.primary_key_name],
+              :conditions => conditions,
+              :include    => @reflection.options[:include]
+            )
+          else
+            association_class.find(@owner[@reflection.primary_key_name], :include => @reflection.options[:include])
+          end
+        end
+
+        def foreign_key_present
+          !@owner[@reflection.primary_key_name].nil?
+        end
+
+        def association_class
+          @owner[@reflection.options[:foreign_type]] ? @owner[@reflection.options[:foreign_type]].constantize : nil
+        end
+    end
+  end
+end

data/lib/couch_foo/associations/has_and_belongs_to_many_association.rb

@@ -0,0 +1,111 @@
+#TODO column, sql, record and table search
+module CouchFoo
+  module Associations
+    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+      def create(attributes = {})
+        create_record(attributes) { |record| insert_record(record, true) }
+      end
+
+      def create!(attributes = {})
+        create_record(attributes) { |record| insert_record(record, true) }
+      end
+
+      protected
+        def construct_find_options!(options)
+          options[:joins]      = @join_sql
+          options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
+        end
+        
+        def count_records
+          load_target.size
+        end
+
+        def insert_record(record, force=true)
+          if record.new_record?
+            if force
+              record.save!
+            else
+              return false unless record.save
+            end
+          end
+
+          if @reflection.options[:insert_sql]
+            @owner.connection.insert(interpolate_sql(@reflection.options[:insert_sql], record))
+          else
+            columns = @owner.connection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
+
+            attributes = columns.inject({}) do |attrs, column|
+              case column.name.to_s
+                when @reflection.primary_key_name.to_s
+                  attrs[column.name] = @owner.quoted_id
+                when @reflection.association_foreign_key.to_s
+                  attrs[column.name] = record.quoted_id
+                else
+                  if record.has_attribute?(column.name)
+                    value = @owner.send(:quote_value, record[column.name], column)
+                    attrs[column.name] = value unless value.nil?
+                  end
+              end
+              attrs
+            end
+
+            sql =
+              "INSERT INTO #{@owner.connection.quote_table_name @reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+              "VALUES (#{attributes.values.join(', ')})"
+
+            @owner.connection.insert(sql)
+          end
+
+          return true
+        end
+
+        def delete_records(records)
+          if sql = @reflection.options[:delete_sql]
+            records.each { |record| @owner.connection.delete(interpolate_sql(sql, record)) }
+          else
+            ids = quoted_record_ids(records)
+            sql = "DELETE FROM #{@owner.connection.quote_table_name @reflection.options[:join_table]} WHERE #{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.association_foreign_key} IN (#{ids})"
+            @owner.connection.delete(sql)
+          end
+        end
+
+        def construct_sql
+          if @reflection.options[:finder_sql]
+            @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+          else
+            @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{@owner.quoted_id} "
+            @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          @join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
+        end
+
+        def construct_scope
+          { :find => {  :conditions => @finder_sql,
+                        :joins => @join_sql,
+                        :readonly => false,
+                        :order => @reflection.options[:order],
+                        :include => @reflection.options[:include],
+                        :limit => @reflection.options[:limit] } }
+        end
+
+        # Join tables with additional columns on top of the two foreign keys must be considered ambiguous unless a select
+        # clause has been explicitly defined. Otherwise you can get broken records back, if, for example, the join column also has
+        # an id column. This will then overwrite the id column of the records coming back.
+        def finding_with_ambiguous_select?(select_clause)
+          !select_clause && @owner.connection.columns(@reflection.options[:join_table], "Join Table Columns").size != 2
+        end
+
+      private
+        def create_record(attributes, &block)
+          # Can't use Base.create because the foreign key may be a protected attribute.
+          ensure_owner_is_not_new
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create(attr) }
+          else
+            build_record(attributes, &block)
+          end
+        end
+    end
+  end
+end

data/lib/couch_foo/associations/has_many_association.rb

@@ -0,0 +1,97 @@
+module CouchFoo
+  module Associations
+    class HasManyAssociation < AssociationCollection #:nodoc:
+      # Count the number of associated records.
+      # With CouchDB it does not make sense to have a second view for this count as it is likely
+      # that at some point the developer will access the objects themselves via find and thus create
+      # a suitable view.  With CouchDB > 0.8 we can use the reduce function but for earlier
+      # versions we just do a find and count the results  
+      def count(*args)
+        options = args.extract_options!
+        options[:conditions] = @association_conditions.merge(options[:conditions] || {})
+        if database.version > 0.8
+          value = count_view(options)
+        else
+          value = find(:all, options).size
+        end
+
+        limit  = @reflection.options[:limit]
+        offset = @reflection.options[:offset]
+
+        if limit || offset
+          [ [value - offset.to_i, 0].max, limit.to_i ].min
+        else
+          value
+        end
+      end
+
+      protected
+        def count_records
+          count = if has_cached_counter?
+            @owner.send(:read_attribute, cached_counter_attribute_name)
+          else
+            @reflection.klass.count(:conditions => @association_conditions, :include => @reflection.options[:include])
+          end
+
+          # If there's nothing in the database and @target has no new records
+          # we are certain the current target is an empty array. This is a
+          # documented side-effect of the method that may avoid an extra SELECT.
+          @target ||= [] and loaded if count == 0
+          
+          if @reflection.options[:limit]
+            count = [ @reflection.options[:limit], count ].min
+          end
+
+          return count
+        end
+
+        def has_cached_counter?
+          @owner.attribute_present?(cached_counter_attribute_name)
+        end
+
+        def cached_counter_attribute_name
+          "#{@reflection.name}_count"
+        end
+
+        def insert_record(record)
+          set_belongs_to_association_for(record)
+          record.save
+        end
+
+        def delete_records(documents)
+          case @reflection.options[:dependent]
+            when :destroy
+              documents.each(&:destroy)
+            when :delete_all
+              @reflection.klass.delete(documents.map(&:id))
+            else
+              find(documents.map{|d| d.id }, :conditions => @association_conditions).each {|doc| doc.update_attributes({@reflection.primary_key_name => nil}, true)}
+              database.commit
+          end
+        end
+
+        def target_obsolete?
+          false
+        end
+
+        def construct_conditions
+          if @reflection.options[:as]
+            @association_conditions = {"#{@reflection.options[:as]}_id".to_sym => @owner.id,
+              "#{@reflection.options[:as]}_type".to_sym => @owner.class.name.to_s}
+          else
+            @association_conditions = {@reflection.primary_key_name => @owner.id}
+          end
+          @association_conditions.merge!(conditions) if conditions
+        end
+
+        def construct_scope
+          create_scoping = {}
+          set_belongs_to_association_for(create_scoping)
+          {
+            :find => { :conditions => @association_conditions, :readonly => false, :order => @reflection.options[:order], :offset => @reflection.options[:offset], :limit => @reflection.options[:limit], :include => @reflection.options[:include]},
+            :create => create_scoping
+          }
+        end
+    end
+  end
+end

data/lib/couch_foo/associations/has_one_association.rb

@@ -0,0 +1,95 @@
+module CouchFoo
+  module Associations
+    class HasOneAssociation < BelongsToAssociation #:nodoc:
+      def initialize(owner, reflection)
+        super
+        construct_conditions
+      end
+
+      def create(attrs = {}, replace_existing = true)
+        new_record(replace_existing) { |klass| klass.create(attrs) }
+      end
+
+      def create!(attrs = {}, replace_existing = true)
+        new_record(replace_existing) { |klass| klass.create!(attrs) }
+      end
+
+      def build(attrs = {}, replace_existing = true)
+        new_record(replace_existing) { |klass| klass.new(attrs) }
+      end
+
+      def replace(obj, dont_save = false)
+        load_target
+
+        unless @target.nil? || @target == obj
+          if dependent? && !dont_save
+            @target.destroy unless @target.new_record?
+            @owner.clear_association_cache
+          else
+            @target[@reflection.primary_key_name] = nil
+            @target.save unless @owner.new_record? || @target.new_record?
+          end
+        end
+
+        if obj.nil?
+          @target = nil
+        else
+          raise_on_type_mismatch(obj)
+          set_belongs_to_association_for(obj)
+          @target = (AssociationProxy === obj ? obj.target : obj)
+        end
+
+        @loaded = true
+
+        unless @owner.new_record? or obj.nil? or dont_save
+          return (obj.save ? self : false)
+        else
+          return (obj.nil? ? nil : self)
+        end
+      end
+            
+      private
+        def find_target
+          @reflection.klass.find(:first, 
+            :conditions => @association_conditions,
+            :order      => @reflection.options[:order], 
+            :include    => @reflection.options[:include],
+            :readonly   => @reflection.options[:readonly]
+          )
+        end
+
+        def construct_conditions
+          if @reflection.options[:as]
+            @association_conditions = {"#{@reflection.options[:as]}_id".to_sym => @owner.id,
+              "#{@reflection.options[:as]}_type".to_sym => @owner.class.name.to_s}
+          else
+            @association_conditions = {@reflection.primary_key_name => @owner.id}
+          end
+          @association_conditions.merge!(conditions) if conditions
+        end
+        
+        def construct_scope
+          create_scoping = {}
+          set_belongs_to_association_for(create_scoping)
+          { :create => create_scoping }
+        end
+
+        def new_record(replace_existing)
+          # Make sure we load the target first, if we plan on replacing the existing
+          # instance. Otherwise, if the target has not previously been loaded
+          # elsewhere, the instance we create will get orphaned.
+          load_target if replace_existing
+          record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) { yield @reflection.klass }
+
+          if replace_existing
+            replace(record, true) 
+          else
+            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+            self.target = record
+          end
+
+          record
+        end
+    end
+  end
+end