datastax_rails 2.0.12 → 2.0.15

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

@@ -1,8 +1,8 @@
-module DatastaxRails::Associations::Builder
+module DatastaxRails::Associations::Builder  # rubocop:disable Style/ClassAndModuleChildren
   class SingularAssociation < Association #:nodoc:
-    #self.valid_options += [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+    # self.valid_options += [:remote, :dependent, :counter_cache, :primary_key, :inverse_of]
     self.valid_options += [:dependent, :denorm]
-    
+
     def constructable?
       true
     end
@@ -11,7 +11,7 @@ module DatastaxRails::Associations::Builder
       super
       define_constructors if constructable?
     end
-    
+
     def build
       relation = super
       configure_denorm
@@ -19,38 +19,36 @@ module DatastaxRails::Associations::Builder
     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
+    def configure_denorm
+      return unless options[:denorm]
+      options[:denorm].is_a?(Hash) || fail(ArgumentError, 'The :denorm option expects a hash in the form ' \
+                                                          '{:attr_on_other_model => :virtual_attr_on_this_model}')
 
-        model.redefine_method("build_#{name}") do |*params, &block|
-          association(name).build(*params, &block)
-        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
 
-        model.redefine_method("create_#{name}") do |*params, &block|
-          association(name).create(*params, &block)
-        end
+    def define_constructors
+      name = self.name
 
-        model.redefine_method("create_#{name}!") do |*params, &block|
-          association(name).create!(*params, &block)
-        end
+      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
+end

data/lib/datastax_rails/associations/collection_association.rb

@@ -17,14 +17,14 @@ module DatastaxRails
     # +load_target+ and the +loaded+ flag are your friends.
     class CollectionAssociation < Association #:nodoc:
       attr_reader :proxy
-      
-      delegate :first, :last, :to => :scoped
-      
+
+      delegate :first, :last, to: :scoped
+
       def initialize(owner, reflection)
         super
         @proxy = CollectionProxy.new(self)
       end
-      
+
       def size
         if !find_target? || loaded?
           target.size
@@ -36,33 +36,30 @@ module DatastaxRails
         end
       end
       alias_method :count, :size
-      
+
       def empty?
         size == 0
       end
-      
+
       def any?
         size > 0
       end
-      
+
       def many?
         size > 1
       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
-        
+        reload if force_reload || stale_target?
         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?
@@ -75,21 +72,21 @@ module DatastaxRails
           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) }
+          attributes.map { |attr| build(attr, options, &block) }
         else
           add_to_target(build_record(attributes, options)) do |record|
             yield(record) if block_given?
@@ -104,7 +101,7 @@ module DatastaxRails
       def create!(attributes = {}, options = {}, &block)
         create_record(attributes, options, true, &block)
       end
-      
+
       # Remove all records from this association
       #
       # See delete for more info.
@@ -124,7 +121,7 @@ module DatastaxRails
           loaded!
         end
       end
-      
+
       # Removes +records+ from this association calling +before_remove+ and
       # +after_remove+ callbacks.
       #
@@ -142,31 +139,28 @@ module DatastaxRails
       # 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) }
+        records = find(records) if records.any? { |record| record.is_a?(Fixnum) || record.is_a?(String) }
         delete_or_destroy(records, :destroy)
       end
-      
+
       def uniq(collection = load_target)
         seen = {}
-        collection.find_all do |record|
+        collection.select 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
 
+      def load_target
+        @target = merge_target_lists(find_target, target) if find_target?
         loaded!
         target
       end
-      
+
       def add_to_target(record)
         callback(:before_add, record)
         yield(record) if block_given?
 
-        if options[:uniq] && index = @target.index(record)
+        if options[:uniq] && (index = @target.index(record))
           @target[index] = record
         else
           @target << record
@@ -177,7 +171,7 @@ module DatastaxRails
 
         record
       end
-      
+
       # Replace this collection with +other_array+
       # This will perform a diff and delete/add only records that have changed.
       def replace(other_array)
@@ -186,13 +180,13 @@ module DatastaxRails
 
         delete(target - other_array)
 
-        unless concat(other_array - target)
+        unless concat(other_array - target) # rubocop:disable Style/GuardClause
           @target = original_target
-          raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
-                                "new records could not be saved."
+          fail RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                'new records could not be saved.'
         end
       end
-      
+
       # Add +records+ to this association. Returns +self+ so method calls may be chained.
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
@@ -201,129 +195,129 @@ module DatastaxRails
 
         records.flatten.each do |record|
           raise_on_type_mismatch(record)
-          add_to_target(record) do |r|
+          add_to_target(record) do |_r|
             result &&= insert_record(record) unless owner.new_record?
           end
         end
 
         result && records
       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
+      # 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?
 
-          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)
+        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
 
-        # Do the relevant stuff to insert the given record into the association collection.
-        def insert_record(record, validate = true, raise = false)
-          raise NotImplementedError
+        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?
+          fail DatastaxRails::RecordNotSaved, 'You cannot call create unless the parent is saved'
         end
-        
-        def create_scope
-          scoped.scope_for_create.stringify_keys
+
+        if attributes.is_a?(Array)
+          attributes.map { |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
 
-        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? }
+      # Do the relevant stuff to insert the given record into the association collection.
+      def insert_record(_record, _validate = true, _raise = false)
+        fail NotImplementedError
+      end
 
-          records.each { |record| callback(:before_remove, record) }
+      def create_scope
+        scoped.scope_for_create.stringify_keys
+      end
 
-          delete_records(existing_records, method) if existing_records.any?
-          records.each { |record| target.delete(record) }
+      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(: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
+        records.each { |record| callback(:before_remove, record) }
 
-        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
+        delete_records(existing_records, method) if existing_records.any?
+        records.each { |record| target.delete(record) }
 
-        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)
+        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)
+        fail 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
-            target.include?(record)
+            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? do |source|
+            target = source.send(reflection.source_reflection.name)
+            target.respond_to?(:include?) ? target.include?(record) : target == record
+          end || target.include?(record)
+        else
+          target.include?(record)
+        end
+      end
     end
   end
-end
+end