datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/attribute_assignment.rb

@@ -21,7 +21,7 @@ module DatastaxRails
 
       attributes.each do |k, v|
         if v.is_a?(Hash)
-          nested_parameter_attributes << [ k, v ]
+          nested_parameter_attributes << [k, v]
         else
           _assign_attribute(k, v)
         end
@@ -29,23 +29,23 @@ module DatastaxRails
 
       assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
     end
-    alias attributes= assign_attributes
-    
+    alias_method :attributes=, :assign_attributes
+
     private
-    
-      def _assign_attribute(k, v)
-        public_send("#{k}=", v)
-      rescue NoMethodError
-        if respond_to?("#{k}=")
-          raise
-        else
-          raise UnknownAttributeError, "unknown attribute: #{k}"
-        end
-      end
-  
-      # Assign any deferred nested attributes after the base attributes have been set.
-      def assign_nested_parameter_attributes(pairs)
-        pairs.each { |k, v| _assign_attribute(k, v) }
+
+    def _assign_attribute(k, v)
+      public_send("#{k}=", v)
+    rescue NoMethodError
+      if respond_to?("#{k}=")
+        raise
+      else
+        raise UnknownAttributeError, "unknown attribute: #{k}"
       end
+    end
+
+    # Assign any deferred nested attributes after the base attributes have been set.
+    def assign_nested_parameter_attributes(pairs)
+      pairs.each { |k, v| _assign_attribute(k, v) }
+    end
   end
 end

data/lib/datastax_rails/attribute_methods/definition.rb

@@ -12,19 +12,19 @@ module DatastaxRails
       def instantiate(record, value)
         value = coder.default if value.nil?
         return if value.nil?
-      
+
         value = coder.decode(value)
         coder.wrap(record, name, value)
       end
-      
+
       # Returns :solr, :cassandra, :both, or +false+
       def indexed
         coder.options[:indexed]
       end
-      
+
       def type
         coder.type
       end
     end
   end
-end
+end

data/lib/datastax_rails/attribute_methods/dirty.rb

@@ -3,16 +3,16 @@ module DatastaxRails
     module Dirty
       extend ActiveSupport::Concern
       include ActiveModel::Dirty
-      
+
       included do
         if self < ::DatastaxRails::Timestamps
-          raise "You cannot include Dirty after Timestamps"
+          fail 'You cannot include Dirty after Timestamps'
         end
       end
 
       # Attempts to +save+ the record and clears changed attributes if successful.
       def save(*) #:nodoc:
-        if status = super
+        if (status = super)
           @previously_changed = changes
           @changed_attributes.clear
         end
@@ -38,7 +38,7 @@ module DatastaxRails
       def write_attribute(attr, value)
         attr = attr.to_s
         loaded_attributes[attr] = true
-        
+
         # The attribute already has an unsaved change.
         if attribute_changed?(attr)
           old = @changed_attributes[attr]
@@ -47,39 +47,40 @@ module DatastaxRails
           old = clone_attribute_value(:read_attribute, attr)
           @changed_attributes[attr] = old if _field_changed?(attr, old, value)
         end
-        
+
         super
       end
-      
+
       private
-        def _field_changed?(attr, old, value)
-          if column = column_for_attribute(attr)
-            if column.number? && (changes_from_nil_to_empty_string?(column, old, value) ||
-                                  changes_from_zero_to_string?(old, value))
-              value = nil
-            else
-              value = column.type_cast(value, self)
-            end
+
+      def _field_changed?(attr, old, value)
+        if (column = column_for_attribute(attr))
+          if column.number? && (changes_from_nil_to_empty_string?(column, old, value) ||
+                                changes_from_zero_to_string?(old, value))
+            value = nil
+          else
+            value = column.type_cast(value, self)
           end
-  
-          old != value
-        end
-        
-        def changes_from_nil_to_empty_string?(column, old, value)
-          # We don't record it as a change if the value changes from nil to ''.
-          # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
-          # be typecast back to 0 (''.to_i => 0)
-          (old.nil? || old == 0) && value.blank?
-        end
-  
-        def changes_from_zero_to_string?(old, value)
-          # For columns with old 0 and value non-empty string
-          old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
-        end
-  
-        def non_zero?(value)
-          value !~ /\A0+(\.0+)?\z/
         end
+
+        old != value
+      end
+
+      def changes_from_nil_to_empty_string?(_column, old, value)
+        # We don't record it as a change if the value changes from nil to ''.
+        # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
+        # be typecast back to 0 (''.to_i => 0)
+        (old.nil? || old == 0) && value.blank?
+      end
+
+      def changes_from_zero_to_string?(old, value)
+        # For columns with old 0 and value non-empty string
+        old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
+      end
+
+      def non_zero?(value)
+        value !~ /\A0+(\.0+)?\z/
+      end
     end
   end
-end
+end

data/lib/datastax_rails/attribute_methods/primary_key.rb

@@ -8,13 +8,13 @@ module DatastaxRails
       # Returns this record's primary key value wrapped in an Array if one is
       # available.
       def to_key
-        key = self.id
+        key = id
         [key] if key
       end
-      
+
       # Returns a primary key hash for updates. Wide models override this.
       def id_for_update
-        {self.class.primary_key.to_s => self.id}
+        { self.class.primary_key.to_s => id }
       end
 
       # Returns the primary key value.
@@ -32,11 +32,6 @@ module DatastaxRails
         query_attribute(self.class.primary_key)
       end
 
-      # Returns the primary key value before type cast.
-      def id_before_type_cast
-        read_attribute_before_type_cast(self.class.primary_key)
-      end
-
       protected
 
       def attribute_method?(attr_name)

data/lib/datastax_rails/attribute_methods/read.rb

@@ -67,7 +67,7 @@ module DatastaxRails
 
         def cacheable_column?(column)
           if attribute_types_cached_by_default == ATTRIBUTE_TYPES_CACHED_BY_DEFAULT
-            ! serialized_attributes.include? column.name
+            !serialized_attributes.include? column.name
           else
             attribute_types_cached_by_default.include?(column.type)
           end
@@ -79,35 +79,33 @@ module DatastaxRails
       # to a date object, like Date.new(2004, 12, 12)).
       def read_attribute(attr_name)
         name = attr_name.to_s
-        
+
         # If it's a lazily loaded attribute and hasn't been loaded yet, we need to do that now.
-        if(!loaded_attributes[name] && persisted? && !key.blank?)
-          @attributes[name.to_s] = self.class.select(name).with_cassandra.find(self.id).read_attribute(name)
+        if !loaded_attributes[name] && persisted? && !key.blank?
+          @attributes[name.to_s] = self.class.select(name).with_cassandra.find(id).read_attribute(name)
           loaded_attributes[name] = true
         end
-        
+
         # If it's cached, just return it
         # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
-        @attributes_cache[name] || @attributes_cache.fetch(name) {
+        @attributes_cache[name] || @attributes_cache.fetch(name) do
           column = @column_types_override[name] if @column_types_override
           column ||= self.class.attribute_definitions[name]
 
-          return @attributes.fetch(name) {
+          return @attributes.fetch(name) do
             if name == 'id' && self.class.primary_key != name
               read_attribute(self.class.primary_key)
             end
-          } unless column
+          end unless column
 
-         value = @attributes.fetch(name) {
-            nil
-          }
+          value = @attributes.fetch(name) { nil }
 
           if self.class.cache_attribute?(name)
             @attributes_cache[name] = column.type_cast(value, self)
           else
             column.type_cast value, self
           end
-        }
+        end
       end
 
       private

data/lib/datastax_rails/attribute_methods/typecasting.rb

@@ -1,5 +1,7 @@
 module DatastaxRails
   module AttributeMethods
+    # Handles the mapping of attributes to their appropriate DatastaxRails::Column so that they can
+    # be typecasted.
     module Typecasting
       extend ActiveSupport::Concern
 
@@ -11,27 +13,25 @@ module DatastaxRails
         self.lazy_attributes = []
         self.readonly_attributes = []
       end
-      
+
       # This is a hook for use by modules that need to do extra stuff to
       # attributes when they are initialized. (e.g. attribute
       # serialization)
       def initialize_attributes(attributes) #:nodoc:
         attrs = {}
-          Types::DirtyCollection.ignore_modifications do
-          attributes.each do |k,v|
-            if col = column_for_attribute(k)
-              if col.type == :map && k.to_s != col.name.to_s
-                # See if we have a matching dynamic attribute column
-                self.class.map_columns.each do |mcol|
-                  if k.to_s.starts_with?(mcol.name.to_s)
-                    attrs[mcol.name.to_s] ||= mcol.wrap_collection({}, self)
-                    attrs[mcol.name.to_s][k.to_s] = v
-                  end
-                end
-              else
-                attrs[k.to_s] = col.collection? ? col.wrap_collection(v, self) : v
+        attributes.each do |k, v|
+          col = column_for_attribute(k)
+          next unless col
+          if col.type == :map && k.to_s != col.name.to_s
+            # See if we have a matching dynamic attribute column
+            self.class.map_columns.each do |mcol|
+              if k.to_s.starts_with?(mcol.name.to_s)
+                attrs[mcol.name.to_s] ||= mcol.wrap_collection({}, self)
+                attrs[mcol.name.to_s][k.to_s] = v
               end
             end
+          else
+            attrs[k.to_s] = col.collection? ? col.wrap_collection(v, self) : v
           end
         end
         attrs
@@ -40,47 +40,47 @@ module DatastaxRails
       module ClassMethods
         # Provide some measure of compatibility with things that expect this from ActiveRecord.
         def columns_hash
-          self.attribute_definitions
+          attribute_definitions
         end
-        
+
         # Gives you all of the map columns (useful for detecting dynamic columns)
         def map_columns
-          @map_columns ||= self.attribute_definitions.values.select {|c| c.type == :map}
+          @map_columns ||= attribute_definitions.values.select { |c| c.type == :map }
         end
-        
+
         # Returns a hash where the keys are column names and the values are
         # default values when instantiating the DSR object for this table.
         def column_defaults
           @column_defaults ||= Hash[columns.map { |c| [c.name.to_s, c.default] }]
         end
-        
+
         # We need to ensure that inherited classes get their own attribute definitions.
         def inherited(child)
           super
           child.attribute_definitions = attribute_definitions.dup
         end
-        
+
         # @!group Attribute Types
-        
+
         # @!macro [new] attr_doc
         #   Declare an attribute of the given type
-        #   
+        #
         #   @param [Symbol] name the name of the attribute to create
         #   @param [Hash] options the options to use in setting up the attribute
         def binary(name, options = {})
-          options.reverse_merge!(:lazy => true)
-          attribute(name, options.update(:type => :binary))
+          options.reverse_merge!(lazy: true)
+          attribute(name, options.update(type: :binary))
         end
-        
+
         # Declare the timestamps attribute type method.
         # Creates both the created_at and updated_at attributes with type +time+.
-        # 
+        #
         # @param [Hash] options the options to use in setting up the attribute
         def timestamps(options = {})
-          attribute(:created_at, options.update(:type => :timestamp))
-          attribute(:updated_at, options.update(:type => :timestamp))
+          attribute(:created_at, options.update(type: :timestamp))
+          attribute(:updated_at, options.update(type: :timestamp))
         end
-        
+
         # @!method array(name, options = {})
         #   @macro attr_doc
         # @!method boolean(name, options = {})
@@ -113,16 +113,17 @@ module DatastaxRails
         #   @macro attr_doc
         # @!method set(name, options = {})
         #   @macro attr_doc
-        
+
         # The following sets up a bunch of nearly identical attribute methods
-        %w(array boolean date datetime float integer json string text time timestamp time_with_zone uuid map set list).each do |type|
+        %w(array boolean date datetime float integer json string text time timestamp time_with_zone
+           uuid map set list).each do |type|
           class_eval <<-EOV, __FILE__, __LINE__ + 1
-            def #{type}(name, options = {})                               # def string(name, options = {})
-              attribute(name, options.update(:type => :#{type}))             #   attribute(name, options.update(type: :string))
-            end                                                           # end
+            def #{type}(name, options = {})                        # def string(name, options = {})
+              attribute(name, options.update(:type => :#{type}))   #   attribute(name, options.update(type: :string))
+            end                                                    # end
           EOV
         end
-        
+
         # @!endgroup
       end
     end

data/lib/datastax_rails/attribute_methods/write.rb

@@ -4,7 +4,7 @@ module DatastaxRails
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix "="
+        attribute_method_suffix '='
       end
 
       module ClassMethods
@@ -37,19 +37,18 @@ module DatastaxRails
 
         # If we're dealing with a binary column, write the data to the cache
         # so we don't attempt to typecast multiple times.
-        if column && column.binary?
-          @attributes_cache[attr_name] = value
-        end
+        @attributes_cache[attr_name] = value if column && column.binary?
 
-        if column || @attributes.has_key?(attr_name)
+        if column || @attributes.key?(attr_name)
           @attributes[attr_name] = value
         else
-          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
+          fail ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attr_name}'"
         end
       end
       alias_method :raw_write_attribute, :write_attribute
 
       private
+
       # Handle *= for method_missing.
       def attribute=(attribute_name, value)
         write_attribute(attribute_name, value)

data/lib/datastax_rails/attribute_methods.rb

@@ -4,7 +4,7 @@ module DatastaxRails
   module AttributeMethods
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
-    
+
     included do
       initialize_generated_modules
 
@@ -13,20 +13,20 @@ module DatastaxRails
       include Read
       include PrimaryKey
       include Typecasting
-      
-      alias :[] :read_attribute
-      alias :[]= :write_attribute
-      alias has_attribute? attribute_exists?
+
+      alias_method :[], :read_attribute
+      alias_method :[]=, :write_attribute
+      alias_method :has_attribute?, :attribute_exists?
     end
-    
+
     module ClassMethods
       def inherited(child_class)
         child_class.initialize_generated_modules
         super
       end
-      
+
       def initialize_generated_modules
-        @generated_attribute_methods = Module.new {
+        @generated_attribute_methods = Module.new do
           extend Mutex_m
 
           const_set :AttrNames, Module.new {
@@ -37,11 +37,11 @@ module DatastaxRails
               end
             end
           }
-        }
+        end
         @attribute_methods_generated = false
         include @generated_attribute_methods
       end
-      
+
       def define_attribute_methods
         # Use a mutex; we don't want two thread simultaneously trying to define
         # attribute methods.
@@ -56,7 +56,7 @@ module DatastaxRails
         end
         true
       end
-      
+
       def undefine_attribute_methods
         generated_attribute_methods.synchronize do
           super if attribute_methods_generated?
@@ -67,37 +67,32 @@ module DatastaxRails
       def attribute_methods_generated?
         @attribute_methods_generated ||= false
       end
-      
-      # 
+
+      #
       # attribute :name, :type => :string
       # attribute :ammo, :type => Ammo, :coder => AmmoCodec
-      # 
+      #
       def attribute(name, options)
         type  = options.delete :type
         coder = options.delete :coder
         default = options.delete :default
 
-        if(options[:lazy])
-          lazy_attributes << name.to_sym
-        end
-        
-        if(options[:readonly])
-          readonly_attributes << name.to_sym
-        end
-        
+        lazy_attributes << name.to_sym if options[:lazy]
+        readonly_attributes << name.to_sym if options[:readonly]
+
         column = Column.new(name, default, type, options)
         column.primary = (name.to_s == primary_key.to_s)
         if coder
-          coder = coder.constantize rescue nil
+          coder = coder.constantize rescue nil # rubocop:disable Style/RescueModifier
           if coder.class == Class && (coder.instance_methods & [:dump, :load]).size == 2
             column.coder = coder.new(self)
           else
-            raise ArgumentError, "Coder must be a class that responds the dump and load instance variables"
+            fail ArgumentError, 'Coder must be a class that responds the dump and load instance variables'
           end
         end
         attribute_definitions[name.to_sym] = column
       end
-      
+
       # Returns the column object for the named attribute. Returns +nil+ if the
       # named attribute not exists.
       #
@@ -112,20 +107,19 @@ module DatastaxRails
       # # => nil
       def column_for_attribute(name)
         # FIXME: should this return a null object for columns that don't exist?
-        column = self.columns_hash[name.to_s]
+        column = columns_hash[name.to_s]
         unless column
           # Check for a dynamic column
           columns_hash.values.each do |col|
-            if col.type == :map && name.to_s.starts_with?("#{col.name}")
-              column = col
-              break
-            end
+            next unless col.type == :map && name.to_s.starts_with?("#{col.name}")
+            column = col
+            break
           end
         end
         column
       end
     end
-    
+
     def attribute_exists?(name)
       @attributes.key?(name.to_s)
     end
@@ -143,37 +137,39 @@ module DatastaxRails
       self.class.define_attribute_methods unless self.class.attribute_methods_generated?
       super
     end
-    
+
     def column_for_attribute(name)
       self.class.column_for_attribute(name)
     end
 
     protected
-      def attribute_method?(name)
-        !!attribute_definitions[name.to_sym]
-      end
-      
-      def clone_attributes(reader_method = :read_attribute, attributes = {}) # :nodoc:
-        attribute_names.each do |name|
-          attributes[name] = clone_attribute_value(reader_method, name)
-        end
-        attributes
-      end
-  
-      def clone_attribute_value(reader_method, attribute_name) # :nodoc:
-        value = send(reader_method, attribute_name)
-        value.duplicable? ? value.clone : value
-      rescue TypeError, NoMethodError
-        value
+
+    def attribute_method?(name)
+      attribute_definitions.key?(name.to_sym)
+    end
+
+    def clone_attributes(reader_method = :read_attribute, attributes = {}) # :nodoc:
+      attribute_names.each do |name|
+        attributes[name] = clone_attribute_value(reader_method, name)
       end
+      attributes
+    end
+
+    def clone_attribute_value(reader_method, attribute_name) # :nodoc:
+      value = send(reader_method, attribute_name)
+      value.duplicable? ? value.clone : value
+    rescue TypeError, NoMethodError
+      value
+    end
 
     private
-      def attribute(name)
-        read_attribute(name)
-      end
-    
-      def attribute=(name, value)
-        write_attribute(name, value)
-      end
+
+    def attribute(name)
+      read_attribute(name)
+    end
+
+    def attribute=(name, value)
+      write_attribute(name, value)
+    end
   end
-end
+end