datastax_rails 2.0.12 → 2.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98234dcb77c32791b630e27d4a9e4deb0be11068
-  data.tar.gz: 0faf451aa7dfb597651ef4195d0849731ac43b7e
+  metadata.gz: eca5b1ed0b44ff67dffbe1c313ec3327b7011ac0
+  data.tar.gz: db1abc9e2a7c2577d7d20c8edf2492a81f88a2e2
 SHA512:
-  metadata.gz: 6b0ca26bcaedfe88407c54badf618eb8968aa2cdbda4aac273c7d0422be89d79ce2b806af36d0bdebb41e8ad40a67a86c806065bec014ceb3d39ecf7a9ade7bf
-  data.tar.gz: 9a502e20649c2e627bf4256e4e175860ef3004cd3fe6d418a0506c343ca2c8cb6eee8702a19aeef75d1cd10a7ed6b616f48e138bc933c24bbb002890cce95d78
+  metadata.gz: 919cf9003af455d8c2311b82801a8b3b2f33ef5fb004721c24128c6d76671207adc8ef2e6e4ea7961f14370bcd16846a53dc669956910757c7fc3b65f534a251
+  data.tar.gz: 2237e860f52576b248028d589a30773453783ccdf3e7c4bcb5bd688ff2b23064a7eed327805d06067931ecde65e0c7b7381a49df955a2c21a34f52eb8a668d1c

data/Rakefile

@@ -22,15 +22,15 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
 load 'rails/tasks/engine.rake'
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  #spec.rcov = true
-  #spec.rcov_opts = %w{--rails --exclude osx\/objc,gems\/,spec\/,features\/,cassandra_object\/}
-  spec.rspec_opts = File.read(File.expand_path("../spec/spec.opts", __FILE__)).split("\n")
+  # spec.rcov = true
+  # spec.rcov_opts = %w{--rails --exclude osx\/objc,gems\/,spec\/,features\/,cassandra_object\/}
+  spec.rspec_opts = File.read(File.expand_path('../spec/spec.opts', __FILE__)).split("\n")
 end
-task :default => :spec
+task default: :spec
 
 Bundler::GemHelper.install_tasks

data/lib/blankslate.rb

@@ -15,17 +15,14 @@
 # depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
 class BlankSlate
   class << self
-    
     # Hide the method named +name+ in the BlankSlate class. Don't
     # hide +instance_eval+ or any method beginning with "__".
     def hide(name)
       methods = instance_methods.map(&:to_sym)
-      if methods.include?(name.to_sym) and
-        name !~ /^(__|instance_eval|object_id)/
-        @hidden_methods ||= {}
-        @hidden_methods[name.to_sym] = instance_method(name)
-        undef_method name
-      end
+      return unless  methods.include?(name.to_sym) && name !~ /^(__|instance_eval|object_id)/
+      @hidden_methods ||= {}
+      @hidden_methods[name.to_sym] = instance_method(name)
+      undef_method name
     end
 
     def find_hidden_method(name)
@@ -41,7 +38,7 @@ class BlankSlate
       define_method(name, hidden_method)
     end
   end
-  
+
   instance_methods.each { |m| hide(m) }
 end
 
@@ -81,7 +78,7 @@ class Object
       result
     end
 
-    def find_hidden_method(name)
+    def find_hidden_method(_name)
       nil
     end
   end
@@ -94,7 +91,7 @@ end
 # "feature" of Ruby prevents late includes into modules from being
 # exposed in the first place.
 class Module
-  alias blankslate_original_append_features append_features
+  alias_method :blankslate_original_append_features, :append_features
   def append_features(mod)
     result = blankslate_original_append_features(mod)
     return result if mod != Object
@@ -103,4 +100,4 @@ class Module
     end
     result
   end
-end
+end

data/lib/cql-rb_extensions.rb

@@ -1,3 +1,5 @@
+# rubocop:disable Style/FileName
+
 # By default, cql-rb grabs a random connection for each request. This is great for
 # keeping load distributed across the cluster. Unfortunately, it plays havoc with
 # the Solr integration where we often need to ensure that we're talking to the
@@ -8,9 +10,9 @@ require 'cql/client/connection_manager'
 
 Cql::Client::ConnectionManager.class_eval do
   attr_reader :current_connection
-  
+
   def random_connection
-    raise NotConnectedError unless connected?
+    fail NotConnectedError unless connected?
     @lock.synchronize do
       @count ||= 0
       @count += 1
@@ -29,4 +31,4 @@ Cql::Client::SynchronousClient.class_eval do
   def current_connection
     async.instance_variable_get(:@connection_manager).current_connection
   end
-end
+end

data/lib/datastax_rails/associations/association.rb

@@ -18,10 +18,11 @@ module DatastaxRails
     #       HasManyAssociation
     #         HasManyThroughAssociation + ThroughAssociation (Not implemented)
     class Association #:nodoc:
-      attr_reader :owner, :target, :reflection
-      
-      delegate :options, :to => :reflection
-      
+      attr_reader :owner, :target, :reflection, :loaded
+      alias_method :loaded?, :loaded
+
+      delegate :options, to: :reflection
+
       def initialize(owner, reflection)
         reflection.check_validity!
 
@@ -32,7 +33,7 @@ module DatastaxRails
         reset
         reset_scope
       end
-      
+
       # Returns the name of the column family name of the related class:
       #
       #   post.comments.aliased_column_family # => "comments"
@@ -40,13 +41,13 @@ module DatastaxRails
       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
@@ -54,18 +55,13 @@ module DatastaxRails
         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
@@ -75,17 +71,17 @@ module DatastaxRails
       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
@@ -93,35 +89,32 @@ module DatastaxRails
       # 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
+        @association_scope ||= AssociationScope.new(self).scope if klass
       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
+      def set_inverse_instance(record) # rubocop:disable Style/AccessorMethodName
+        return unless record && invertible_for?(record)
+        inverse = record.association(inverse_reflection_for(record).name)
+        inverse.target = owner
       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+,
@@ -133,9 +126,7 @@ module DatastaxRails
       # 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
+        @target ||= find_target if find_target?
         loaded! unless loaded?
         target
       rescue DatastaxRails::RecordNotFound
@@ -143,79 +134,80 @@ module DatastaxRails
       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
+
+      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
-        
-        # 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
+      end
 
-        def build_record(attributes, options)
-          reflection.build_association(attributes, options) do |r|
-            r.assign_attributes(create_scope.except(*r.changed))
-          end
+      # Sets the owner attributes on the given record
+      def set_owner_attributes(record) # rubocop:disable Style/AccessorMethodName
+        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)
+        return if 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})"
+        fail DatastaxRails::AssociationTypeMismatch, message
+      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))
         end
+      end
     end
   end
 end

data/lib/datastax_rails/associations/association_scope.rb

@@ -2,18 +2,18 @@ module DatastaxRails
   module Associations
     class AssociationScope #:nodoc:
       attr_reader :association
-      
-      delegate :klass, :owner, :reflection, :to => :association
-      delegate :chain, :options, :datastax_rails, :to => :reflection
-      
+
+      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
@@ -22,4 +22,4 @@ module DatastaxRails
       end
     end
   end
-end
+end

data/lib/datastax_rails/associations/belongs_to_association.rb

@@ -1,65 +1,63 @@
 module DatastaxRails
   module Associations
     class BelongsToAssociation < SingularAssociation #:nodoc:
+      attr_reader :updated
+      alias_method :updated?, :updated
       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.loaded_attributes[reflection.foreign_key] = true
-          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
+      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.loaded_attributes[reflection.foreign_key] = true
+        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
 
-        def stale_state
-          owner[reflection.foreign_key].to_s
+      # 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
+end