datastax_rails 1.0.5

data/config/stopwords.txt

@@ -0,0 +1,58 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+# a couple of test stopwords to test that the words are really being
+# configured from this file:
+stopworda
+stopwordb
+
+#Standard english stop words taken from Lucene's StopAnalyzer
+a
+an
+and
+are
+as
+at
+be
+but
+by
+for
+if
+in
+into
+is
+it
+no
+not
+of
+on
+or
+s
+such
+t
+that
+the
+their
+then
+there
+these
+they
+this
+to
+was
+will
+with
+

data/lib/datastax_rails/associations/association.rb

@@ -0,0 +1,224 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/inclusion'
+
+module DatastaxRails
+  module Associations
+    # = DatastaxRails Associations
+    #
+    # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+    #
+    #   Association
+    #     SingularAssociation
+    #       HasOneAssociation
+    #         HasOneThroughAssociation + ThroughAssociation (Not implemented)
+    #       BelongsToAssociation
+    #         BelongsToPolymorphicAssociation (Not implemented)
+    #     CollectionAssociation
+    #       HasAndBelongsToManyAssociation (Not implemented)
+    #       HasManyAssociation
+    #         HasManyThroughAssociation + ThroughAssociation (Not implemented)
+    class Association #:nodoc:
+      attr_reader :owner, :target, :reflection
+      
+      delegate :options, :to => :reflection
+      
+      def initialize(owner, reflection)
+        reflection.check_validity!
+
+        @target = nil
+        @owner, @reflection = owner, reflection
+        @updated = false
+
+        reset
+        reset_scope
+      end
+      
+      # Returns the name of the column family name of the related class:
+      #
+      #   post.comments.aliased_column_family # => "comments"
+      #
+      def aliased_column_family
+        reflection.klass.column_family
+      end
+      
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+      end
+      
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        reset_scope
+        load_target
+        self unless target.nil?
+      end
+      
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+      
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded!
+        @loaded = true
+        @stale_state = stale_state
+      end
+      
+      # The target is stale if the target no longer points to the record(s) that the
+      # relevant foreign_key(s) refers to. If stale, the association accessor method
+      # on the owner will reload the target. It's up to subclasses to implement the
+      # stale_state method if relevant.
+      #
+      # Note that if the target has not been loaded, it is not considered stale.
+      def stale_target?
+        loaded? && @stale_state != stale_state
+      end
+      
+      # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded!
+      end
+      
+      def scoped
+        target_scope.merge(association_scope)
+      end
+      
+      # The scope for this association.
+      #
+      # Note that the association_scope is merged into the target_scope only when the
+      # scoped method is called. This is because at that point the call may be surrounded
+      # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
+      # actually gets built.
+      def association_scope
+        if klass
+          @association_scope ||= AssociationScope.new(self).scope
+        end
+      end
+      
+      def reset_scope
+        @association_scope = nil
+      end
+      
+      # Set the inverse association, if possible
+      def set_inverse_instance(record)
+        if record && invertible_for?(record)
+          inverse = record.association(inverse_reflection_for(record).name)
+          inverse.target = owner
+        end
+      end
+      
+      # This class of the target. belongs_to polymorphic overrides this to look at the
+      # polymorphic_type field on the owner.
+      def klass
+        reflection.klass
+      end
+      
+      # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
+      # through association's scope)
+      def target_scope
+        klass.scoped
+      end
+      
+      # Loads the \target if needed and returns it.
+      #
+      # This method is abstract in the sense that it relies on +find_target+,
+      # which is expected to be provided by descendants.
+      #
+      # If the \target is already \loaded it is just returned. Thus, you can call
+      # +load_target+ unconditionally to get the \target.
+      #
+      # DatastaxRails::RecordNotFound is rescued within the method, and it is
+      # not reraised. The proxy is \reset and +nil+ is the return value.
+      def load_target
+        if find_target?
+          @target ||= find_target
+        end
+        loaded! unless loaded?
+        target
+      rescue DatastaxRails::RecordNotFound
+        reset
+      end
+
+      private
+        def find_target?
+          !loaded? && (!owner.new_record? || foreign_key_present?) && klass
+        end
+        
+        def creation_attributes
+          {}.tap do |attributes|
+            if reflection.macro.in?([:has_one, :has_many]) && !options[:through]
+              attributes[reflection.foreign_key] = owner.id
+
+              # Note, polymorphic relationships are not implemented yet
+              if reflection.options[:as]
+                attributes[reflection.type] = owner.class.base_class.name
+              end
+            end
+          end
+        end
+        
+        # Sets the owner attributes on the given record
+        def set_owner_attributes(record)
+          creation_attributes.each { |key, value| record[key] = value }
+        end
+        
+        # Should be true if there is a foreign key present on the owner which
+        # references the target. This is used to determine whether we can load
+        # the target if the owner is currently a new record (and therefore
+        # without a key).
+        #
+        # Currently implemented by belongs_to (vanilla and polymorphic) and
+        # has_one/has_many :through associations which go through a belongs_to
+        def foreign_key_present?
+          false
+        end
+        
+        # Raises DatastaxRails::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
+            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise DatastaxRails::AssociationTypeMismatch, message
+          end
+        end
+        
+        # Can be redefined by subclasses, notably polymorphic belongs_to
+        # The record parameter is necessary to support polymorphic inverses as we must check for
+        # the association in the specific class of the record.
+        def inverse_reflection_for(record)
+          reflection.inverse_of
+        end
+        
+        # Is this association invertible? Can be redefined by subclasses.
+        def invertible_for?(record)
+          inverse_reflection_for(record)
+        end
+        
+        # This should be implemented to return the values of the relevant key(s) on the owner,
+        # so that when state_state is different from the value stored on the last find_target,
+        # the target is stale.
+        #
+        # This is only relevant to certain associations, which is why it returns nil by default.
+        def stale_state
+          nil
+        end
+        
+        def association_class
+          @reflection.klass
+        end
+
+        def build_record(attributes, options)
+          reflection.build_association(attributes, options) do |r|
+            r.assign_attributes(
+              create_scope.except(*r.changed),
+              :without_protection => true
+            )
+          end
+        end
+    end
+  end
+end

data/lib/datastax_rails/associations/association_scope.rb

@@ -0,0 +1,25 @@
+module DatastaxRails
+  module Associations
+    class AssociationScope #:nodoc:
+      attr_reader :association
+      
+      delegate :klass, :owner, :reflection, :to => :association
+      delegate :chain, :options, :datastax_rails, :to => :reflection
+      
+      def initialize(association)
+        @association = association
+      end
+      
+      def scope
+        scope = klass.unscoped
+        scope = scope.extending(*Array.wrap(options[:extend]))
+        
+        if reflection.source_macro == :belongs_to
+          scope.where('id' => owner.send(reflection.foreign_key))
+        else
+          scope.where(reflection.foreign_key => owner.id)
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/associations/belongs_to_association.rb

@@ -0,0 +1,64 @@
+module DatastaxRails
+  module Associations
+    class BelongsToAssociation < SingularAssociation #:nodoc:
+      def replace(record)
+        raise_on_type_mismatch(record) if record
+        
+        replace_keys(record)
+        set_inverse_instance(record)
+        
+        @updated = true if record
+        
+        self.target = record
+      end
+      
+      def updated?
+        @updated
+      end
+      
+      private
+      
+        def find_target?
+          !loaded? && foreign_key_present? && klass
+        end
+        
+        # Checks whether record is different to the current target, without loading it
+        def different_target?(record)
+          record.nil? && owner[reflection.foreign_key] ||
+          record && record.id != owner[reflection.foreign_key]
+        end
+        
+        def replace_keys(record)
+          owner.send("#{reflection.foreign_key}_will_change!")
+          if record
+            owner[reflection.foreign_key] = record.id
+          else
+            owner[reflection.foreign_key] = nil
+          end
+        end
+        
+        def foreign_key_present?
+          owner[reflection.foreign_key]
+        end
+        
+        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+        # has_one associations.
+        def invertible_for?(record)
+          inverse = inverse_reflection_for(record)
+          inverse && inverse.macro == :has_one
+        end
+
+        def target_id
+          if options[:primary_key]
+            owner.send(reflection.name).try(:id)
+          else
+            owner[reflection.foreign_key]
+          end
+        end
+
+        def stale_state
+          owner[reflection.foreign_key].to_s
+        end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module DatastaxRails::Associations::Builder
+  class Association #:nodoc:
+    class_attribute :valid_options
+    self.valid_options = [:class_name, :foreign_key]
+    
+    # Set by subclasses
+    class_attribute :macro
+    
+    attr_reader :model, :name, :options, :reflection
+    
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+    
+    def initialize(model, name, options)
+      @model, @name, @options = model, name, options
+    end
+    
+    def build
+      validate_options
+      reflection = model.create_reflection(self.class.macro, name, options, model)
+      define_accessors
+      reflection
+    end
+    
+    def mixin
+      @model.generated_attribute_methods
+    end
+    
+    private
+      def validate_options
+        options.assert_valid_keys(self.class.valid_options)
+      end
+      
+      def define_accessors
+        define_readers
+        define_writers
+      end
+      
+      def define_readers
+        name = self.name
+        
+        model.redefine_method(name) do |*params|
+          association(name).reader(*params)
+        end
+      end
+      
+      def define_writers
+        name = self.name
+        
+        model.redefine_method("#{name}=") do |value|
+          association(name).writer(value)
+        end
+      end
+  end
+end

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

@@ -0,0 +1,30 @@
+module DatastaxRails::Associations::Builder
+  class BelongsTo < SingularAssociation
+    self.macro = :belongs_to
+    
+    def build
+      reflection = super
+      configure_dependency
+      reflection
+    end
+    
+    private
+    
+      def configure_dependency
+        if options[:dependent]
+          unless options[:dependent].in?([:destroy, :delete])
+            raise ArgumentError, "The :dependent option expects either :destroy or :delete (#{options[:dependent].inspect})"
+          end
+    
+          method_name = "belongs_to_dependent_#{options[:dependent]}_for_#{name}"
+          model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+            def #{method_name}
+              association = #{name}
+              association.#{options[:dependent]} if association
+            end
+            eoruby
+          model.after_destroy method_name
+        end
+      end
+  end
+end

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

@@ -0,0 +1,48 @@
+module DatastaxRails::Associations::Builder #:nodoc:
+  class CollectionAssociation < Association #:nodoc:
+    CALLBACKS = [:before_add, :after_add, :before_remove, :after_remove]
+    
+    self.valid_options += [:columm_family, :order, :uniq, :before_add, :before_remove, :after_add, :after_remove]
+    
+    def self.build(model, name, options)
+      new(model, name, options).build
+    end
+    
+    def build
+      reflection = super
+      CALLBACKS.each { |callback_name| define_callback(callback_name) }
+    end
+    
+    def writable?
+      true
+    end
+    
+    protected
+    
+      def define_callback(callback_name)
+        full_callback_name = "#{callback_name}_for_#{name}"
+        
+        # XXX : why do i need method_defined? I think its because of the inheritance chain
+        model.class_attribute full_callback_name.to_sym unless model.method_defined?(full_callback_name)
+        model.send("#{full_callback_name}=", Array.wrap(options[callback_name.to_sym]))
+      end
+      
+      def define_readers
+        super
+        
+        name = self.name
+        mixin.redefine_method("#{name.to_s.singularize}_ids") do
+          association(name).ids_reader
+        end
+      end
+      
+      def define_writers
+        super
+        
+        name = self.name
+        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
+          association(name).ids_writer(ids)
+        end
+      end
+  end
+end

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

@@ -0,0 +1,36 @@
+module DatastaxRails::Associations::Builder #:nodoc:
+  class HasAndBelongsToMany < CollectionAssociation #:nodoc:
+    self.macro = :has_and_belongs_to_many
+    
+    def build
+      reflection = super
+      define_destroy_hook
+      check_for_join_column_family
+      reflection
+    end
+    
+    private
+      def define_destroy_hook
+        name = self.name
+        model.send(:include, Module.new {
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def destroy_associations
+              association(#{name.to_sym.inspect}).delete_all_on_destroy
+              super
+            end
+          RUBY
+        })
+      end
+      
+      def check_for_join_column_family
+        unless DatastaxRails::Base.connection.column_families.has_key?("many_to_many_joins")
+          cf = Cassandra::ColumnFamily.new
+          cf.name = "many_to_many_joins"
+          cf.keyspace = DatastaxRails::Base.connection.keyspace
+          cf.comparator_type = 'BytesType'
+          cf.column_type = 'Standard'
+          DatastaxRails::Base.connection.add_column_family(cf)
+        end
+      end
+  end
+end

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

@@ -0,0 +1,54 @@
+module DatastaxRails::Associations::Builder
+  class HasMany < CollectionAssociation #:nodoc:
+    self.macro = :has_many
+    
+    self.valid_options += [:primary_key, :dependent, :source_type]
+    
+    def build
+      reflection = super
+      configure_dependency
+      reflection
+    end
+    
+    private
+      
+      def configure_dependency
+        if options[:dependent]
+          unless options[:dependent].in?([:destroy])  # Only destroy and restrict supported for now
+            raise ArgumentError, "The :dependent option only handles :destroy or :restrict for now (#{options[:dependent].inspect})"
+          end
+
+          send("define_#{options[:dependent]}_dependency_method")
+          model.before_destroy dependency_method_name
+        end
+      end
+      
+      def define_destroy_dependency_method
+        name = self.name
+        mixin.redefine_method(dependency_method_name) do
+          send(name).each do |o|
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
+            if o.respond_to?(counter_method)
+              class << o
+                self
+              end.send(:define_method, counter_method, Proc.new {})
+            end
+          end
+
+          send(name).destroy_all
+        end
+      end
+      
+      def define_restrict_dependency_method
+        name = self.name
+        mixin.redefine_method(dependency_method_name) do
+          raise DatastaxRails::DeleteRestrictionError.new(name) unless send(name).empty?
+        end
+      end
+      
+      def dependency_method_name
+        "has_many_dependent_for_#{name}"
+      end
+  end
+end

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

@@ -0,0 +1,52 @@
+module DatastaxRails::Associations::Builder
+  class HasOne < SingularAssociation #:nodoc:
+    self.macro = :has_one
+
+    def build
+      reflection = super
+      configure_dependency
+      reflection
+    end
+
+    private
+
+      def validate_options
+        valid_options = self.class.valid_options
+        valid_options += self.class.through_options if options[:through]
+        options.assert_valid_keys(valid_options)
+      end
+
+      def configure_dependency
+        if options[:dependent]
+          unless options[:dependent].in?([:destroy, :delete, :nullify, :restrict])
+            raise ArgumentError, "The :dependent option expects either :destroy, :delete, " \
+                                 ":nullify or :restrict (#{options[:dependent].inspect})"
+          end
+
+          send("define_#{options[:dependent]}_dependency_method")
+          model.before_destroy dependency_method_name
+        end
+      end
+
+      def dependency_method_name
+        "has_one_dependent_#{options[:dependent]}_for_#{name}"
+      end
+
+      def define_destroy_dependency_method
+        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+          def #{dependency_method_name}
+            association(#{name.to_sym.inspect}).delete
+          end
+        eoruby
+      end
+      alias :define_delete_dependency_method :define_destroy_dependency_method
+      alias :define_nullify_dependency_method :define_destroy_dependency_method
+
+      def define_restrict_dependency_method
+        name = self.name
+        model.redefine_method(dependency_method_name) do
+          raise DatastaxRails::DeleteRestrictionError.new(name) unless send(name).nil?
+        end
+      end
+  end
+end