datastax_rails 2.0.12 → 2.0.15

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

@@ -1,56 +1,57 @@
-module DatastaxRails::Associations::Builder
+module DatastaxRails::Associations::Builder # rubocop:disable Style/ClassAndModuleChildren
   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
+
+    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
-      
-      def define_writers
-        name = self.name
-        
-        model.redefine_method("#{name}=") do |value|
-          association(name).writer(value)
-        end
+    end
+
+    def define_writers
+      name = self.name
+
+      model.redefine_method("#{name}=") do |value|
+        association(name).writer(value)
       end
+    end
   end
-end
+end

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

@@ -1,30 +1,29 @@
-module DatastaxRails::Associations::Builder
+module DatastaxRails::Associations::Builder # rubocop:disable Style/ClassAndModuleChildren
   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
+
+    def configure_dependency
+      return unless options[:dependent]
+      unless options[:dependent].in?([:destroy, :delete])
+        fail 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

@@ -1,48 +1,48 @@
-module DatastaxRails::Associations::Builder #:nodoc:
+module DatastaxRails::Associations::Builder # rubocop:disable Style/ClassAndModuleChildren
   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
+      @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
+
+    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
-      
-      def define_writers
-        super
-        
-        name = self.name
-        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
-          association(name).ids_writer(ids)
-        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
+end

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

@@ -1,36 +1,36 @@
-module DatastaxRails::Associations::Builder #:nodoc:
+module DatastaxRails::Associations::Builder # rubocop:disable Style/ClassAndModuleChildren
   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 define_destroy_hook
+      name = self.name
+      model.send(:include, Module.new do
+        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
+
+    def check_for_join_column_family
+      return if DatastaxRails::Base.connection.column_families.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

@@ -1,54 +1,53 @@
-module DatastaxRails::Associations::Builder
+module DatastaxRails::Associations::Builder # rubocop:disable Style/ClassAndModuleChildren
   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
+
+    def configure_dependency
+      return unless options[:dependent]
+      unless options[:dependent].in?([:destroy])  # Only destroy and restrict supported for now
+        fail ArgumentError,
+             "The :dependent option only handles :destroy or :restrict for now (#{options[:dependent].inspect})"
       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?
+
+      send("define_#{options[:dependent]}_dependency_method")
+      model.before_destroy dependency_method_name
+    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
+          next unless o.respond_to?(counter_method)
+          class << o
+            self
+          end.send(:define_method, counter_method, proc {})
         end
+
+        send(name).destroy_all
       end
-      
-      def dependency_method_name
-        "has_many_dependent_for_#{name}"
+    end
+
+    def define_restrict_dependency_method
+      name = self.name
+      mixin.redefine_method(dependency_method_name) do
+        fail DatastaxRails::DeleteRestrictionError.new(name) unless send(name).empty?
       end
+    end
+
+    def dependency_method_name
+      "has_many_dependent_for_#{name}"
+    end
   end
-end
+end

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

@@ -1,4 +1,4 @@
-module DatastaxRails::Associations::Builder
+module DatastaxRails::Associations::Builder # rubocop:disable Style/ClassAndModuleChildren
   class HasOne < SingularAssociation #:nodoc:
     self.macro = :has_one
 
@@ -10,43 +10,42 @@ module DatastaxRails::Associations::Builder
 
     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
+    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
 
-          send("define_#{options[:dependent]}_dependency_method")
-          model.before_destroy dependency_method_name
-        end
+    def configure_dependency
+      return unless options[:dependent]
+      unless options[:dependent].in?([:destroy, :delete, :nullify, :restrict])
+        fail ArgumentError, 'The :dependent option expects either :destroy, :delete, ' \
+                             ":nullify or :restrict (#{options[:dependent].inspect})"
       end
 
-      def dependency_method_name
-        "has_one_dependent_#{options[:dependent]}_for_#{name}"
-      end
+      send("define_#{options[:dependent]}_dependency_method")
+      model.before_destroy dependency_method_name
+    end
 
-      def define_destroy_dependency_method
-        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
+    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_method :define_delete_dependency_method, :define_destroy_dependency_method
+    alias_method :define_nullify_dependency_method, :define_destroy_dependency_method
+
+    def define_restrict_dependency_method
+      name = self.name
+      model.redefine_method(dependency_method_name) do
+        fail DatastaxRails::DeleteRestrictionError.new(name) unless send(name).nil?
       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
-end
+end