datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/errors.rb

@@ -1,19 +1,19 @@
 module DatastaxRails
   class DatastaxRailsError < StandardError #:nodoc:
   end
-  
+
   class AssociationTypeMismatch < DatastaxRailsError #:nodoc:
   end
-  
+
   class RecordNotSaved < DatastaxRailsError #:nodoc:
   end
-  
+
   class DeleteRestrictionError < DatastaxRailsError #:nodoc:
   end
-  
+
   class RecordNotFound < DatastaxRailsError #:nodoc:
   end
-  
+
   class UnknownAttributeError < DatastaxRailsError
   end
-end
+end

data/lib/datastax_rails/grouped_collection.rb

@@ -3,15 +3,15 @@ module DatastaxRails
   # for the thing that was grouped on.  The hash entries point to instances of DatastaxRails::Collection.
   class GroupedCollection < Hash
     # @!attribute [r] total_entries
-    #   @return [Fixnum] the total number of entries *in the largest group*.  This is to allow will_paginate to work properly.
+    #   @return [Fixnum] the total number of entries *in the largest group*. This is to allow will_paginate to work.
     # @!attribute [r] total_groups
     #   @return [Fixnum] the total number of groups if the groups were paginated (not supported yet)
     # @!attribute [r] total_for_all
     #   @return [Fixnum] the total number of entries across all groups that match this search
     attr_accessor :total_entries, :total_groups, :total_for_all
-    
+
     def inspect
       "<DatastaxRails::GroupedCollection##{object_id} contents: #{super} matching_records #{total_for_all}>"
     end
   end
-end
+end

data/lib/datastax_rails/inheritance.rb

@@ -1,24 +1,24 @@
 module DatastaxRails
   module Inheritance
     extend ActiveSupport::Concern
-    
+
     module ClassMethods
       # Determines if one of the attributes passed in is the inheritance column,
       # and if the inheritance column is attr accessible, it initializes an
       # instance of the given subclass instead of the base class.
       def new(*args, &block)
         if abstract_class? || self == Base
-          raise NotImplementedError, "#{self} is an abstract class and can not be instantiated."
+          fail NotImplementedError, "#{self} is an abstract class and can not be instantiated."
         end
         # if (attrs = args.first).is_a?(Hash)
-          # if subclass = subclass_from_attrs(attrs)
-            # return subclass.new(*args, &block)
-          # end
+        # if subclass = subclass_from_attrs(attrs)
+        # return subclass.new(*args, &block)
+        # end
         # end
         # Delegate to the original .new
         super
       end
-      
+
       # Returns the class descending directly from DatastaxRails::Base, or
       # an abstract class, if any, in the inheritance hierarchy.
       #
@@ -29,7 +29,7 @@ module DatastaxRails
       # and C.base_class would return B as the answer since A is an abstract_class.
       def base_class
         unless self < Base
-          raise DatastaxRailsError, "#{name} doesn't belong in a hierarchy descending from DatastaxRails"
+          fail DatastaxRailsError, "#{name} doesn't belong in a hierarchy descending from DatastaxRails"
         end
 
         if superclass == Base || superclass.abstract_class?
@@ -38,7 +38,7 @@ module DatastaxRails
           superclass.base_class
         end
       end
-      
+
       # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
       # If you are using inheritance with DatastaxRails and don't want child classes
       # to utilize the implied STI table name of the parent class, this will need to be true.
@@ -58,4 +58,4 @@ module DatastaxRails
       end
     end
   end
-end
+end

data/lib/datastax_rails/payload_model.rb

@@ -17,7 +17,7 @@ module DatastaxRails
   class PayloadModel < WideStorageModel
     include CassandraOnlyModel
     self.abstract_class = true
-    
+
     def self.inherited(child)
       super
       child.primary_key = 'digest'
@@ -26,14 +26,16 @@ module DatastaxRails
       child.string :digest
       child.binary :payload
       child.integer :chunk
-      child.validates :digest, :presence => true
+      child.validates :digest, presence: true
     end
-    
+
     def self.find(digest, options = {})
-      raise ArgumentError, "'#{options[:consistency]}' is not a valid Cassandra consistency level" unless valid_consistency?(options[:consistency].to_s.upcase) if options[:consistency]
-      c = cql.select.conditions(:digest => digest).order('chunk')
+      if options[:consistency] && !valid_consistency?(options[:consistency].to_s.upcase)
+        fail ArgumentError, "'#{options[:consistency]}' is not a valid Cassandra consistency level"
+      end
+      c = cql.select.conditions(digest: digest).order('chunk')
       c.using(options[:consistency]) if options[:consistency]
-      io = StringIO.new("","w+")
+      io = StringIO.new('', 'w+')
       found = false
       chunk = 0
       c.execute.each do |row|
@@ -41,34 +43,36 @@ module DatastaxRails
         chunk = row['chunk']
         found = true
       end
-      raise DatastaxRails::RecordNotFound unless found
+      fail DatastaxRails::RecordNotFound unless found
       io.rewind
-      self.instantiate(digest, {:digest => digest, :payload => io.read, :chunk => chunk}, [:digest, :payload])
+      instantiate(digest, { digest: digest, payload: io.read, chunk: chunk }, [:digest, :payload])
     end
-    
+
     def self.write(record, options = {})
-      raise ArgumentError, "'#{options[:consistency]}' is not a valid Cassandra consistency level" unless valid_consistency?(options[:consistency].to_s.upcase) if options[:consistency]
-      c = self.cql.select("count(*)").conditions(:digest => record.id)
-      count = c.execute.first["count"]
-      
+      if options[:consistency] && !valid_consistency?(options[:consistency].to_s.upcase)
+        fail ArgumentError, "'#{options[:consistency]}' is not a valid Cassandra consistency level"
+      end
+      c = cql.select('count(*)').conditions(digest: record.id)
+      count = c.execute.first['count']
+
       i = 0
       io = StringIO.new(record.attributes['payload'])
-      while chunk = io.read(1.megabyte)
-        c = cql.insert.columns(:digest => record.id, :chunk => i, :payload => Base64.encode64(chunk))
+      while (chunk = io.read(1.megabyte))
+        c = cql.insert.columns(digest: record.id, chunk: i, payload: Base64.encode64(chunk))
         c.using(options[:consistency]) if options[:consistency]
         c.execute
         i += 1
       end
-      
-      if count and count > i
+
+      if count && count > i
         i.upto(count) do |j|
-          c = cql.delete(record.id).key_name('digest').conditions(:chunk => j)
+          c = cql.delete(digest: record.id, chunk: j)
           c.using(options[:consistency]) if options[:consistency]
           c.execute
         end
       end
-      
+
       record.id
     end
   end
-end
+end

data/lib/datastax_rails/persistence.rb

@@ -1,12 +1,21 @@
 module DatastaxRails
+  # Handles persisting data into Datastax
   module Persistence
     extend ActiveSupport::Concern
-    
+
+    included do
+      attr_reader :destroyed, :new_record
+      alias_method :destroyed?, :destroyed
+      alias_method :new_record?, :new_record
+    end
+
+    # rubocop:disable Style/Documentation
     module ClassMethods
-      # Removes one or more records with corresponding keys.  Last parameter can be a hash
-      # specifying the consistency level.
+      # Removes one or more records with corresponding keys. Last parameter can be a hash
+      # specifying the consistency level. The keys should be in the form returned by
+      # +#id_for_update+
       #
-      #   Model.remove('12345','67890', :consistency => 'LOCAL_QUORUM)
+      #   Model.remove({id: '12345'},{id: '67890'}, :consistency => 'LOCAL_QUORUM)
       #
       # @overload remove(*keys, options)
       #   Removes one or more keys with the given options
@@ -15,55 +24,60 @@ module DatastaxRails
       # @overload remove(*keys)
       #   Removes one or more keys with the default options
       #   @param [String] keys one or more keys to delete
+      # TODO: Submit multiple deletes as a batch
       def remove(*keys)
-        options = {}
-        if keys.last.is_a?(Hash)
-          options = keys.pop
-        end
-        keys = keys.flatten.collect {|k| self.attribute_definitions[self.primary_key].type_cast(k)}
-        ActiveSupport::Notifications.instrument("remove.datastax_rails", :column_family => column_family, :key => keys) do
-          c = cql.delete(keys)
-          if(options[:consistency])
-            level = options[:consistency].to_s.upcase
-            if(valid_consistency?(level))
-              c.using(level)
-            else
-              raise ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
+        options = keys.last.is_a?(Hash) ? keys.pop : {}
+        # keys = keys.flat_map { |k| attribute_definitions[primary_key].type_cast(k) }
+        keys.each do |key|
+          typecast_key = {}
+          key.each { |k, v| typecast_key[k] = attribute_definitions[k].type_cast(v) }
+
+          ActiveSupport::Notifications.instrument('remove.datastax_rails', column_family: column_family, key: key) do
+            c = cql.delete(typecast_key)
+            if options[:consistency]
+              level = options[:consistency].to_s.upcase
+              if valid_consistency?(level)
+                c.using(level)
+              else
+                fail ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
+              end
             end
+            c.execute
           end
-          c.execute
         end
       end
 
       # Truncates the column_family associated with this class
       def truncate
-        ActiveSupport::Notifications.instrument("truncate.datastax_rails", :column_family => column_family) do
+        ActiveSupport::Notifications.instrument('truncate.datastax_rails', column_family: column_family) do
           cql.truncate.execute
         end
       end
-      alias :delete_all :truncate
+      alias_method :delete_all, :truncate
 
       def create(attributes = {}, options = {}, &block)
         new(attributes, &block).tap do |object|
           object.save(options)
         end
       end
-      
+
       # Write a record to cassandra.  Can be either an insert or an update (they are exactly the same to cassandra)
       #
       # @param [DatastaxRails::Base] record the record that we are writing
       # @param [Hash] options a hash containing various options
       # @option options [Symbol] :consistency the consistency to set for the Cassandra operation (e.g., ALL)
       def write(record, options = {})
-        level = (options[:consistency] || self.default_consistency).to_s.upcase
-        if(valid_consistency?(level))
+        level = (options[:consistency] || default_consistency).to_s.upcase
+        if valid_consistency?(level)
           options[:consistency] = level
         else
-          raise ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
+          fail ArgumentError, "'#{level}' is not a valid Cassandra consistency level"
         end
         record.id.tap do |key|
-          ActiveSupport::Notifications.instrument("insert.datastax_rails", :column_family => column_family, :key => key.to_s, :attributes => record.attributes) do
-            if(self.storage_method == :solr)
+          ActiveSupport::Notifications.instrument('insert.datastax_rails', column_family: column_family,
+                                                                           key:           key.to_s,
+                                                                           attributes:    record.attributes) do
+            if (storage_method == :solr)
               write_with_solr(record, options)
             else
               write_with_cql(record, options)
@@ -71,18 +85,18 @@ module DatastaxRails
           end
         end
       end
-      
+
       # Instantiates a new object without calling +initialize+.
       #
       # @param [String] key the primary key for the record
       # @param [Hash] attributes a hash containing the columns to set on the record
-      # @param [Array] selected_attributes an array containing the attributes that were originally selected from cassandra
-      #   to build this object.  Used so that we can avoid lazy-loading attributes that don't exist.
+      # @param [Array] selected_attributes an array containing the attributes that were originally selected from
+      #   cassandra to build this object.  Used so that we can avoid lazy-loading attributes that don't exist.
       # @return [DatastaxRails::Base] a model with the given attributes
-      def instantiate(key, attributes, selected_attributes = [])
+      def instantiate(_key, attributes, _selected_attributes = [])
         allocate.init_with('attributes' => attributes)
       end
-      
+
       # Encodes the attributes in preparation for storing in cassandra. Calls the coders on the various type classes
       # to do the heavy lifting.
       #
@@ -100,30 +114,23 @@ module DatastaxRails
         end
         encoded
       end
-      
+
       private
-        def write_with_cql(record, options)
-          encoded = encode_attributes(record, true)
-          if options[:new_record]
-            cql.insert.columns(encoded).using(options[:consistency]).execute
-          else
-            cql.update(record.id_for_update).columns(encoded).using(options[:consistency]).execute
-          end
-        end
-        
-        def write_with_solr(record, options)
-          encoded = encode_attributes(record, false)
-          xml_doc = RSolr::Xml::Generator.new.add(encoded.merge(self.primary_key => record.id.to_s))
-          self.solr_connection.update(:data => xml_doc, :params => {:replacefields => false, :cl => options[:consistency]})
-        end
-    end
 
-    def new_record?
-      @new_record
-    end
+      def write_with_cql(record, options)
+        encoded = encode_attributes(record, true)
+        if options[:new_record]
+          cql.insert.columns(encoded).using(options[:consistency]).execute
+        else
+          cql.update(record.id_for_update).columns(encoded).using(options[:consistency]).execute
+        end
+      end
 
-    def destroyed?
-      @destroyed
+      def write_with_solr(record, options)
+        encoded = encode_attributes(record, false)
+        xml_doc = RSolr::Xml::Generator.new.add(encoded.merge(primary_key => record.id.to_s))
+        solr_connection.update(data: xml_doc, params: { replacefields: false, cl: options[:consistency] })
+      end
     end
 
     def persisted?
@@ -131,45 +138,43 @@ module DatastaxRails
     end
 
     def save(options = {})
-      begin
-        _create_or_update(options)
-      rescue DatastaxRails::RecordInvalid
-        false
-      end
+      _create_or_update(options)
+    rescue DatastaxRails::RecordInvalid
+      false
     end
 
     def save!(options = {})
-      _create_or_update(options) || raise(RecordNotSaved)
+      _create_or_update(options) || fail(RecordNotSaved)
     end
 
     def destroy(options = {})
-      self.class.remove(id, options)
+      self.class.remove(id_for_update, options)
       @destroyed = true
       freeze
     end
-    
+
     # TODO: Make this work
     # def touch(name = nil)
-      # raise ActiveRecordError, "can not touch on a new record object" unless persisted?
-# 
-      # attributes = timestamp_attributes_for_update_in_model
-      # attributes << name if name
-# 
-      # unless attributes.empty?
-        # current_time = current_time_from_proper_timezone
-        # changes = {}
-# 
-        # attributes.each do |column|
-          # column = column.to_s
-          # changes[column] = write_attribute(column, current_time)
-        # end
-# 
-        # @changed_attributes.except!(*changes.keys)
-        # primary_key = self.class.primary_key
-        # self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
-      # else
-        # true
-      # end
+    # raise ActiveRecordError, "can not touch on a new record object" unless persisted?
+    #
+    # attributes = timestamp_attributes_for_update_in_model
+    # attributes << name if name
+    #
+    # unless attributes.empty?
+    # current_time = current_time_from_proper_timezone
+    # changes = {}
+    #
+    # attributes.each do |column|
+    # column = column.to_s
+    # changes[column] = write_attribute(column, current_time)
+    # end
+    #
+    # @changed_attributes.except!(*changes.keys)
+    # primary_key = self.class.primary_key
+    # self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
+    # else
+    # true
+    # end
     # end
 
     # Updates a single attribute and saves the record.
@@ -181,24 +186,24 @@ module DatastaxRails
     # * Updates all the attributes that are dirty in this object.
     #
     def update_attribute(name, value)
-      send("#{name.to_s}=", value)
-      save(:validate => false)
+      send("#{name}=", value)
+      save(validate: false)
     end
 
     # Updates the attributes of the model from the passed-in hash and saves the
     # record If the object is invalid, the saving will fail and false will be returned.
-    def update_attributes(attributes, options = {})
-      self.assign_attributes(attributes)
+    def update_attributes(attributes, _options = {})
+      assign_attributes(attributes)
       save
     end
 
     # Updates its receiver just like +update_attributes+ but calls <tt>save!</tt> instead
     # of +save+, so an exception is raised if the record is invalid.
-    def update_attributes!(attributes, options = {})
-      self.assign_attributes(attributes)
+    def update_attributes!(attributes, _options = {})
+      assign_attributes(attributes)
       save!
     end
-    
+
     # Assigns to +attribute+ the boolean opposite of <tt>attribute?</tt>. So
     # if the predicate returns +true+ the attribute will become +false+. This
     # method toggles directly the underlying value without calling any setter.
@@ -215,7 +220,7 @@ module DatastaxRails
     def toggle!(attribute)
       toggle(attribute).update_attribute(attribute, self[attribute])
     end
-    
+
     # Reloads the attributes of this object from the database.
     # The optional options argument is passed to find when reloading so you
     # may do e.g. record.reload(:lock => true) to reload the same record with
@@ -223,7 +228,7 @@ module DatastaxRails
     def reload(options = nil)
       clear_association_cache
 
-      fresh_object = self.class.unscoped { self.class.find(self.id, options) }
+      fresh_object = self.class.unscoped { self.class.find(id, options) }
       @attributes.update(fresh_object.instance_variable_get('@attributes'))
 
       @attributes_cache = {}
@@ -231,27 +236,28 @@ module DatastaxRails
     end
 
     private
-      def _create_or_update(options)
-        result = new_record? ? _create_record(options) : _update_record(options)
-        result != false
-      end
 
-      def _create_record(options)
-        # TODO: handle the non-UUID case
-        self.id ||= ::Cql::TimeUuid::Generator.new.next
-        _write(options)
-        @new_record = false
-        self.id
-      end
-    
-      def _update_record(options)
-        _write(options)
-      end
-      
-      def _write(options) #:nodoc:
-        options[:new_record] = new_record?
-        return true if changed_attributes.empty?
-        self.class.write(self, options)
-      end
+    def _create_or_update(options)
+      result = new_record? ? _create_record(options) : _update_record(options)
+      result != false
+    end
+
+    def _create_record(options)
+      # TODO: handle the non-UUID case
+      self.id ||= ::Cql::TimeUuid::Generator.new.next
+      _write(options)
+      @new_record = false
+      self.id
+    end
+
+    def _update_record(options)
+      _write(options)
+    end
+
+    def _write(options) #:nodoc:
+      options[:new_record] = new_record?
+      return true if changed_attributes.empty?
+      self.class.write(self, options)
+    end
   end
 end