datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/associations/collection_proxy.rb

@@ -34,32 +34,32 @@ module DatastaxRails
     # 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
+      attr_reader :association
+      alias_method :proxy_association, :association
+      alias_method :proxy_extend, :extend
+
+      instance_methods.each do |m|
+        undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/
+      end
+
+      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
-               
+               :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)
         if target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
           if load_target
@@ -78,28 +78,28 @@ module DatastaxRails
           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
+        other === load_target # rubocop:disable Style/CaseEquality
       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

data/lib/datastax_rails/associations/has_and_belongs_to_many_association.rb

@@ -3,42 +3,42 @@ module DatastaxRails
   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('_')
+        self.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)
+            record.save!(validate: validate)
           else
-            return unless record.save(:validate => validate)
+            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}"})
+
+        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
+
+      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
+end

data/lib/datastax_rails/associations/has_many_association.rb

@@ -10,50 +10,50 @@ module DatastaxRails
         set_inverse_instance(record)
 
         if raise
-          record.save!(:validate => validate)
+          record.save!(validate: validate)
         else
-          record.save(:validate => validate)
+          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 }
+
+      # 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 ||= [] && 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
-            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
+            # 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
+end

data/lib/datastax_rails/associations/has_one_association.rb

@@ -16,53 +16,52 @@ module DatastaxRails
           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}."
+            fail 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
+        return unless load_target
+        case method
+        when :delete
+          target.delete
+        when :destroy
+          target.destroy
+        when :nullify
+          target.update_attribute(reflection.foreign_key, nil)
         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
+      # 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) # rubocop:disable Style/AccessorMethodName
+        replace(record, false)
+      end
 
-        def remove_target!(method)
-          if method.in?([:delete, :destroy])
-            target.send(method)
-          else
-            nullify_owner_attributes(target)
+      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
+          if target.persisted? && owner.persisted? && !target.save
+            set_owner_attributes(target)
+            fail 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
+      def nullify_owner_attributes(record)
+        record[reflection.foreign_key] = nil
+      end
     end
   end
-end
+end

data/lib/datastax_rails/associations/singular_association.rb

@@ -6,16 +6,16 @@ module DatastaxRails
         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
@@ -26,33 +26,34 @@ module DatastaxRails
         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
+
+      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)
+        fail NotImplementedError, 'Subclasses must implement a replace(record) method'
+      end
+
+      def set_new_record(record) # rubocop:disable Style/AccessorMethodName
+        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)
+        fail RecordInvalid.new(record) if !saved && raise_error
+        record
+      end
     end
   end
-end
+end

data/lib/datastax_rails/associations.rb

@@ -1,8 +1,10 @@
+# rubocop:disable Style/PredicateName
 module DatastaxRails
+  # Associations holds all the functionality related to DSR associations
   module Associations
     extend ActiveSupport::Concern
     extend ActiveSupport::Autoload
-    
+
     autoload :Association
     autoload :AssociationScope
     autoload :SingularAssociation
@@ -11,19 +13,20 @@ module DatastaxRails
     autoload :BelongsToAssociation
     autoload :HasOneAssociation
     autoload :HasManyAssociation
-    
+
+    # Builder holds all the classes related to building the association
     module Builder
       extend ActiveSupport::Autoload
-      
+
       autoload :Association
       autoload :SingularAssociation
       autoload :CollectionAssociation
-      
+
       autoload :BelongsTo
       autoload :HasOne
       autoload :HasMany
     end
-    
+
     # Clears out the association cache.
     def clear_association_cache #:nodoc:
       @association_cache.clear if persisted?
@@ -44,25 +47,26 @@ module DatastaxRails
 
       association
     end
-    
+
     private
-      # Returns the specified association instance if it responds to :loaded?, nil otherwise.
-      def association_instance_get(name)
-        @association_cache ||= {}
-        @association_cache[name.to_sym]
-      end
 
-      # Set the specified association instance.
-      def association_instance_set(name, association)
-        @association_cache ||= {}
-        @association_cache[name] = association
-      end
-    
+    # Returns the specified association instance if it responds to :loaded?, nil otherwise.
+    def association_instance_get(name)
+      @association_cache ||= {}
+      @association_cache[name.to_sym]
+    end
+
+    # Set the specified association instance.
+    def association_instance_set(name, association)
+      @association_cache ||= {}
+      @association_cache[name] = association
+    end
+
     module ClassMethods
       def belongs_to(name, options = {})
         Builder::BelongsTo.build(self, name, options)
       end
-      
+
       def has_many(name, options = {})
         Builder::HasMany.build(self, name, options)
         # klass = options[:class_name]
@@ -70,17 +74,16 @@ module DatastaxRails
         # foreign_key = options[:foreign_key]
         # foreign_key ||= self.name.foreign_key
         # define_method name do
-          # klass.where(foreign_key)
+        # klass.where(foreign_key)
         # end
       end
-      
-      def has_and_belongs_to_many(name, options = {})
-        
+
+      def has_and_belongs_to_many(_name, _options = {})
       end
-      
+
       def has_one(name, options = {})
         Builder::HasOne.build(self, name, options)
       end
     end
   end
-end
+end