datastax_rails 1.0.5

data/lib/datastax_rails/associations/builder/singular_association.rb

@@ -0,0 +1,56 @@
+module DatastaxRails::Associations::Builder
+  class SingularAssociation < Association #:nodoc:
+    #self.valid_options += [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+    self.valid_options += [:dependent, :denorm]
+    
+    def constructable?
+      true
+    end
+
+    def define_accessors
+      super
+      define_constructors if constructable?
+    end
+    
+    def build
+      relation = super
+      configure_denorm
+      relation
+    end
+
+    private
+    
+      def configure_denorm
+        if options[:denorm]
+          unless options[:denorm].is_a?(Hash)
+            raise ArgumentError, "The :denorm option expects a hash in the form {:attr_on_other_model => :virtual_attr_on_this_model}"
+          end
+          
+          # options[:denorm].each do |remote, local|
+            # # Default everything to a string.  If it should be something different, the developer can declare the attribute manually.
+            # model.send(:string, local)
+            # model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+              # def #{local}
+              # eoruby
+          # end
+         
+        end
+      end
+
+      def define_constructors
+        name = self.name
+
+        model.redefine_method("build_#{name}") do |*params, &block|
+          association(name).build(*params, &block)
+        end
+
+        model.redefine_method("create_#{name}") do |*params, &block|
+          association(name).create(*params, &block)
+        end
+
+        model.redefine_method("create_#{name}!") do |*params, &block|
+          association(name).create!(*params, &block)
+        end
+      end
+  end
+end

data/lib/datastax_rails/associations/collection_association.rb

@@ -0,0 +1,274 @@
+module DatastaxRails
+  module Associations
+    # = DatastaxRails Association Collection
+    #
+    # CollectionAssociation is an abstract class that provides common stuff to
+    # ease the implementation of association proxies that represent
+    # collections. See the class hierarchy in AssociationProxy.
+    #
+    # You need to be careful with assumptions regarding the target: The proxy
+    # does not fetch records from the database until it needs them, but new
+    # ones created with +build+ are added to the target. So, the target may be
+    # non-empty and still lack children waiting to be read from the database.
+    # If you look directly to the database you cannot assume that's the entire
+    # collection because new records may have been added to the target, etc.
+    #
+    # If you need to work on all current children, new and existing records,
+    # +load_target+ and the +loaded+ flag are your friends.
+    class CollectionAssociation < Association #:nodoc:
+      attr_reader :proxy
+      
+      delegate :count, :size, :empty?, :any?, :many?, :first, :last, :to => :scoped
+      
+      def initialize(owner, reflection)
+        super
+        @proxy = CollectionProxy.new(self)
+      end
+      
+      # Implements the reader method, e.g. foo.items for Foo.has_many :items
+      def reader(force_reload = false)
+        if force_reload || stale_target?
+          reload
+        end
+        
+        proxy
+      end
+      
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(records)
+        replace(records)
+      end
+      
+      # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
+      def ids_reader
+        if loaded?
+          load_target.map do |record|
+            record.send(reflection.association_primary_key)
+          end
+        else
+          scoped.map! do |record|
+            record.send(reflection.association_primary_key)
+          end
+        end
+      end
+      
+      # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
+      def ids_writer(ids)
+        ids = Array.wrap(ids).reject { |id| id.blank? }
+        replace(klass.find(ids).index_by { |r| r.id }.values_at(*ids))
+      end
+      
+      def reset
+        @loaded = false
+        @target = []
+      end
+      
+      def build(attributes = {}, options = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr, options, &block) }
+        else
+          add_to_target(build_record(attributes, options)) do |record|
+            yield(record) if block_given?
+          end
+        end
+      end
+
+      def create(attributes = {}, options = {}, &block)
+        create_record(attributes, options, &block)
+      end
+
+      def create!(attributes = {}, options = {}, &block)
+        create_record(attributes, options, true, &block)
+      end
+      
+      # Remove all records from this association
+      #
+      # See delete for more info.
+      def delete_all
+        delete(load_target).tap do
+          reset
+          loaded!
+        end
+      end
+
+      # Destroy all the records from this association.
+      #
+      # See destroy for more info.
+      def destroy_all
+        destroy(load_target).tap do
+          reset
+          loaded!
+        end
+      end
+      
+      # Removes +records+ from this association calling +before_remove+ and
+      # +after_remove+ callbacks.
+      #
+      # This method is abstract in the sense that +delete_records+ has to be
+      # provided by descendants. Note this method does not imply the records
+      # are actually removed from the database, that depends precisely on
+      # +delete_records+. They are in any case removed from the collection.
+      def delete(*records)
+        delete_or_destroy(records, options[:dependent])
+      end
+
+      # Destroy +records+ and remove them from this association calling
+      # +before_remove+ and +after_remove+ callbacks.
+      #
+      # Note that this method will _always_ remove records from the database
+      # ignoring the +:dependent+ option.
+      def destroy(*records)
+        records = find(records) if records.any? { |record| record.kind_of?(Fixnum) || record.kind_of?(String) }
+        delete_or_destroy(records, :destroy)
+      end
+      
+      def uniq(collection = load_target)
+        seen = {}
+        collection.find_all do |record|
+          seen[record.id] = true unless seen.key?(record.id)
+        end
+      end
+      
+      def load_target
+        if find_target?
+          @target = merge_target_lists(find_target, target)
+        end
+
+        loaded!
+        target
+      end
+      
+      def add_to_target(record)
+        callback(:before_add, record)
+        yield(record) if block_given?
+
+        if options[:uniq] && index = @target.index(record)
+          @target[index] = record
+        else
+          @target << record
+        end
+
+        callback(:after_add, record)
+        set_inverse_instance(record)
+
+        record
+      end
+      
+      private
+      
+        # We have some records loaded from the database (persisted) and some that are
+        # in-memory (memory). The same record may be represented in the persisted array
+        # and in the memory array.
+        #
+        # So the task of this method is to merge them according to the following rules:
+        #
+        #   * The final array must not have duplicates
+        #   * The order of the persisted array is to be preserved
+        #   * Any changes made to attributes on objects in the memory array are to be preserved
+        #   * Otherwise, attributes should have the value found in the database
+        def merge_target_lists(persisted, memory)
+          return persisted if memory.empty?
+          return memory if persisted.empty?
+
+          persisted.map! do |record|
+            # Unfortunately we cannot simply do memory.delete(record) since on 1.8 this returns
+            # record rather than memory.at(memory.index(record)). The behavior is fixed in 1.9.
+            mem_index = memory.index(record)
+
+            if mem_index
+              mem_record = memory.delete_at(mem_index)
+
+              (record.attribute_names - mem_record.changes.keys).each do |name|
+                mem_record[name] = record[name]
+              end
+
+              mem_record
+            else
+              record
+            end
+          end
+
+          persisted + memory
+        end
+        
+        def find_target
+          records = scoped.all
+          records = options[:uniq] ? uniq(records) : records
+          records.each { |record| set_inverse_instance(record) }
+          records
+        end
+        
+        def create_record(attributes, options, raise = false, &block)
+          unless owner.persisted?
+            raise DatastaxRails::RecordNotSaved, "You cannot call create unless the parent is saved"
+          end
+
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create_record(attr, options, raise, &block) }
+          else
+            add_to_target(build_record(attributes, options)) do |record|
+              yield(record) if block_given?
+              insert_record(record, true, raise)
+            end
+          end
+        end
+
+        # Do the relevant stuff to insert the given record into the association collection.
+        def insert_record(record, validate = true, raise = false)
+          raise NotImplementedError
+        end
+        
+        def create_scope
+          scoped.scope_for_create.stringify_keys
+        end
+
+        def delete_or_destroy(records, method)
+          records = records.flatten
+          records.each { |record| raise_on_type_mismatch(record) }
+          existing_records = records.reject { |r| r.new_record? }
+
+          records.each { |record| callback(:before_remove, record) }
+
+          delete_records(existing_records, method) if existing_records.any?
+          records.each { |record| target.delete(record) }
+
+          records.each { |record| callback(:after_remove, record) }
+        end
+        
+        # Delete the given records from the association, using one of the methods :destroy,
+        # :delete_all or :nullify (or nil, in which case a default is used).
+        def delete_records(records, method)
+          raise NotImplementedError
+        end
+
+        def callback(method, record)
+          callbacks_for(method).each do |callback|
+            case callback
+            when Symbol
+              owner.send(callback, record)
+            when Proc
+              callback.call(owner, record)
+            else
+              callback.send(method, owner, record)
+            end
+          end
+        end
+
+        def callbacks_for(callback_name)
+          full_callback_name = "#{callback_name}_for_#{reflection.name}"
+          owner.class.send(full_callback_name.to_sym) || []
+        end
+        
+        def include_in_memory?(record)
+          if reflection.is_a?(DatastaxRails::Reflection::ThroughReflection)
+            owner.send(reflection.through_reflection.name).any? { |source|
+              target = source.send(reflection.source_reflection.name)
+              target.respond_to?(:include?) ? target.include?(record) : target == record
+            } || target.include?(record)
+          else
+            target.include?(record)
+          end
+        end
+    end
+  end
+end

data/lib/datastax_rails/associations/collection_proxy.rb

@@ -0,0 +1,118 @@
+module DatastaxRails
+  module Associations
+    # Association proxies in DatastaxRails are middlemen between the object that
+    # holds the association, known as the <tt>@owner</tt>, and the actual associated
+    # object, known as the <tt>@target</tt>. The kind of association any proxy is
+    # about is available in <tt>@reflection</tt>. That's an instance of the class
+    # DatastaxRails::Reflection::AssociationReflection.
+    #
+    # For example, given
+    #
+    #   class Blog < DatastaxRails::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.first
+    #
+    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
+    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
+    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    #
+    # This class has most of the basic instance methods removed, and delegates
+    # unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
+    # corner case, it even removes the +class+ method and that's why you get
+    #
+    #   blog.posts.class # => Array
+    #
+    # though the object behind <tt>blog.posts</tt> is not an Array, but an
+    # DatastaxRails::Associations::HasManyAssociation.
+    #
+    # The <tt>@target</tt> object is not \loaded until needed. For example,
+    #
+    #   blog.posts.count
+    #
+    # is computed directly through Solr and does not trigger by itself the
+    # instantiation of the actual post records.
+    class CollectionProxy #:nodoc:
+      alias :proxy_extend :extend
+      
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
+      
+      delegate :order, :limit, :where, :to => :scoped
+      delegate :target, :load_target, :loaded?, :scoped, :to => :@association
+      delegate :select, :find, :first, :last, :build, :create, :create!, :destroy_all, :destroy,
+               :delete, :delete_all, :count, :size, :length, :empty?, :any?, :many?, :to => :@association
+               
+      def initialize(association)
+        @association = association
+        Array.wrap(association.options[:extend]).each { |ext| proxy_extend(ext) }
+      end
+      
+      alias_method :new, :build
+      
+      def proxy_association
+        @association
+      end
+      
+      def respond_to?(name, include_private = false)
+        super ||
+        (load_target && target.respond_to?(name, include_private)) ||
+        proxy_association.klass.respond_to?(name, include_private)
+      end
+      
+      def method_missing(method, *args, &block)
+        match = ActiveRecord::DynamicFinderMatch.match(method)
+        if match && match.instantiator?
+          send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
+            proxy_association.send :set_owner_attributes, r
+            proxy_association.send :add_to_target, r
+            yield(r) if block_given?
+          end
+        end
+
+        if target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
+          if load_target
+            if target.respond_to?(method)
+              target.send(method, *args, &block)
+            else
+              begin
+                super
+              rescue NoMethodError => e
+                raise e, e.message.sub(/ for #<.*$/, " via proxy for #{target}")
+              end
+            end
+          end
+
+        else
+          scoped.send(method, *args, &block)
+        end
+      end
+      
+      # Forwards <tt>===</tt> explicitly to the \target because the instance method
+      # removal above doesn't catch it. Loads the \target if needed.
+      def ===(other)
+        other === load_target
+      end
+      
+      def to_ary
+        load_target.dup
+      end
+      alias_method :to_a, :to_ary
+      
+      def <<(*records)
+        proxy_association.concat(records) && self
+      end
+      alias_method :push, :<<
+      
+      def clear
+        destroy_all
+        self
+      end
+      
+      def reload
+        proxy_association.reload
+        self
+      end
+    end
+  end
+end

data/lib/datastax_rails/associations/has_and_belongs_to_many_association.rb

@@ -0,0 +1,44 @@
+module DatastaxRails
+  # = DatastaxRails Has And Belongs To Many Association
+  module Associations
+    class HasAndBelongsToManyAssociation < CollectionAssociation #:nodoc:
+      attr_reader :join_name
+      
+      def initialize(owner, reflection)
+        join_name = [owner.class.name.underscore, reflection.class_name.underscore].sort.join('_')
+        super
+      end
+      
+      def insert_record(record, validate = true, raise = false)
+        if record.new_record?
+          if raise
+            record.save!(:validate => validate)
+          else
+            return unless record.save(:validate => validate)
+          end
+        end
+        
+        left, right = [[record.class.name, record.id], [owner.class.name, owner.id]].sort {|a,b|b.first <=> a.first}
+        
+        DatastaxRails::Base.connection.insert(join_column_family, 
+                                               SimpleUUID::UUID.new.to_guid, 
+                                               {:left => "#{join_name}:#{left.last}", 
+                                                :right => "#{join_name}:#{right.last}"})
+      end
+      
+      
+      private
+        def join_column_family
+          "many_to_many_joins"
+        end
+      
+        def count_records
+          load_target.size
+        end
+        
+        def invertible_for?(record)
+          false
+        end
+    end
+  end
+end

data/lib/datastax_rails/associations/has_many_association.rb

@@ -0,0 +1,58 @@
+module DatastaxRails
+  module Associations
+    # This is the proxy that handles a has many association.
+    #
+    # If the association has a <tt>:through</tt> option further specialization
+    # is provided by its child HasManyThroughAssociation.
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+
+        if raise
+          record.save!(:validate => validate)
+        else
+          record.save(:validate => validate)
+        end
+      end
+      
+      private
+      
+        # Returns the number of records in this collection.
+        #
+        # This does not depend on whether the collection has already been loaded
+        # or not. The +size+ method is the one that takes the loaded flag into
+        # account and delegates to +count_records+ if needed.
+        #
+        # If the collection is empty the target is set to an empty array and
+        # the loaded flag is set to true as well.
+        def count_records
+          count = scoped.count
+          
+          # 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
+          
+          count
+        end
+        
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+          else
+            keys = records.map { |r| r[reflection.association_primary_key] }
+            scope = scoped.where(reflection.association_primary_key => keys)
+            
+            if method == :delete_all
+              scope.delete_all
+            else
+              # This is for :nullify which isn't actually supported yet,
+              # but this should work once it is
+              scope.update_all(reflection.foreign_key => nil)
+            end
+          end
+        end
+    end
+  end
+end

data/lib/datastax_rails/associations/has_one_association.rb

@@ -0,0 +1,68 @@
+module DatastaxRails
+  module Associations
+    class HasOneAssociation < SingularAssociation #:nodoc:
+      def replace(record, save = true)
+        raise_on_type_mismatch(record) if record
+        load_target
+
+        if target && target != record
+          remove_target!(options[:dependent]) unless target.destroyed?
+        end
+
+        if record
+          set_owner_attributes(record)
+          set_inverse_instance(record)
+
+          if owner.persisted? && save && !record.save
+            nullify_owner_attributes(record)
+            set_owner_attributes(target) if target
+            raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+          end
+        end
+
+        self.target = record
+      end
+      
+      def delete(method = options[:dependent])
+        if load_target
+          case method
+            when :delete
+              target.delete
+            when :destroy
+              target.destroy
+            when :nullify
+              target.update_attribute(reflection.foreign_key, nil)
+          end
+        end
+      end
+
+      private
+
+        # The reason that the save param for replace is false, if for create (not just build),
+        # is because the setting of the foreign keys is actually handled by the scoping when
+        # the record is instantiated, and so they are set straight away and do not need to be
+        # updated within replace.
+        def set_new_record(record)
+          replace(record, false)
+        end
+
+        def remove_target!(method)
+          if method.in?([:delete, :destroy])
+            target.send(method)
+          else
+            nullify_owner_attributes(target)
+
+            if target.persisted? && owner.persisted? && !target.save
+              set_owner_attributes(target)
+              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
+                                    "The record failed to save when after its foreign key was set to nil."
+            end
+          end
+        end
+
+        def nullify_owner_attributes(record)
+          record[reflection.foreign_key] = nil
+        end
+    end
+  end
+end

data/lib/datastax_rails/associations/singular_association.rb

@@ -0,0 +1,58 @@
+module DatastaxRails
+  module Associations
+    class SingularAssociation < Association #:nodoc:
+      # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
+      def reader(force_reload = false)
+        reload if force_reload || !loaded? || stale_target?
+        target
+      end
+      
+      # Implements the writer method, e.g. foo.items= for Foo.has_many :items
+      def writer(record)
+        replace(record)
+      end
+      
+      def create(attributes = {}, options = {}, &block)
+        create_record(attributes, options, &block)
+      end
+      
+      def create!(attributes = {}, options = {}, &block)
+        create_record(attributes, options, true, &block)
+      end
+
+      def build(attributes = {}, options = {})
+        record = build_record(attributes, options)
+        yield(record) if block_given?
+        set_new_record(record)
+        record
+      end
+      
+      private
+        def create_scope
+          scoped.scope_for_create.stringify_keys.except("id")
+        end
+
+        def find_target
+          scoped.first.tap { |record| set_inverse_instance(record) }
+        end
+
+        # Implemented by subclasses
+        def replace(record)
+          raise NotImplementedError, "Subclasses must implement a replace(record) method"
+        end
+
+        def set_new_record(record)
+          replace(record)
+        end
+
+        def create_record(attributes, options, raise_error = false)
+          record = build_record(attributes, options)
+          yield(record) if block_given?
+          saved = record.save
+          set_new_record(record)
+          raise RecordInvalid.new(record) if !saved && raise_error
+          record
+        end
+    end
+  end
+end