datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/callbacks.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 module DatastaxRails
   # = Datastax Rails Callbacks
   #
@@ -202,7 +204,8 @@ module DatastaxRails
   # == Ordering callbacks
   #
   # Sometimes the code needs that the callbacks execute in a specific order. For example, a +before_destroy+
-  # callback (+log_children+ in this case) should be executed before the children get destroyed by the +dependent: destroy+ option.
+  # callback (+log_children+ in this case) should be executed before the children get destroyed by the
+  # +dependent: destroy+ option.
   #
   # Let's look at the code below:
   #
@@ -218,7 +221,8 @@ module DatastaxRails
   #   end
   #
   # In this case, the problem is that when the +before_destroy+ callback is executed, the children are not available
-  # because the +destroy+ callback gets executed first. You can use the +prepend+ option on the +before_destroy+ callback to avoid this.
+  # because the +destroy+ callback gets executed first. You can use the +prepend+ option on the +before_destroy+
+  # callback to avoid this.
   #
   #   class Topic < DatastaxRails::Base
   #     has_many :children, dependent: destroy
@@ -231,13 +235,14 @@ module DatastaxRails
   #       end
   #   end
   #
-  # This way, the +before_destroy+ gets executed before the <tt>dependent: destroy</tt> is called, and the data is still available.
+  # This way, the +before_destroy+ gets executed before the <tt>dependent: destroy</tt> is called, and the data is
+  # still available.
   #
   # == Debugging callbacks
   #
   # The callback chain is accessible via the <tt>_*_callbacks</tt> method on an object. ActiveModel Callbacks support
-  # <tt>:before</tt>, <tt>:after</tt> and <tt>:around</tt> as values for the <tt>kind</tt> property. The <tt>kind</tt> property
-  # defines what part of the chain the callback runs in.
+  # <tt>:before</tt>, <tt>:after</tt> and <tt>:around</tt> as values for the <tt>kind</tt> property. The <tt>kind</tt>
+  # property defines what part of the chain the callback runs in.
   #
   # To find all callbacks in the before_save callback chain:
   #
@@ -245,7 +250,8 @@ module DatastaxRails
   #
   # Returns an array of callback objects that form the before_save chain.
   #
-  # To further check if the before_save chain contains a proc defined as <tt>rest_when_dead</tt> use the <tt>filter</tt> property of the callback object:
+  # To further check if the before_save chain contains a proc defined as <tt>rest_when_dead</tt> use the
+  # <tt>filter</tt> property of the callback object:
   #
   #   Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }.collect(&:filter).include?(:rest_when_dead)
   #
@@ -268,7 +274,7 @@ module DatastaxRails
     included do
       include ActiveModel::Validations::Callbacks
 
-      define_model_callbacks :initialize, :find, :touch, :only => :after
+      define_model_callbacks :initialize, :find, :touch, only: :after
       define_model_callbacks :save, :create, :update, :destroy
     end
 
@@ -277,10 +283,10 @@ module DatastaxRails
     end
 
     # def touch(*) #:nodoc:
-      # run_callbacks(:touch) { super }
+    # run_callbacks(:touch) { super }
     # end
 
-  private
+    private
 
     def _create_or_update(*) #:nodoc:
       run_callbacks(:save) { super }

data/lib/datastax_rails/cassandra_only_model.rb

@@ -17,17 +17,17 @@ module DatastaxRails
     extend ActiveSupport::Concern
 
     included do
-      default_scope -> {with_cassandra}
+      default_scope -> { with_cassandra }
       self.storage_method = :cql
     end
-    
+
     module ClassMethods
       def attribute(name, options)
-        opts = options.update(:solr_index => false,    :solr_store => false,
-                              :multi_valued => false,  :sortable => false,
-                              :tokenized => false,     :fulltext => false)
+        opts = options.update(solr_index: false,    solr_store: false,
+                              multi_valued: false,  sortable: false,
+                              tokenized: false,     fulltext: false)
         super(name, opts)
       end
     end
   end
-end
+end

data/lib/datastax_rails/collection.rb

@@ -2,23 +2,21 @@ module DatastaxRails
   class Collection < Array
     # @!attribute [r] total_entries
     #   @return [Fixnum] the total number of entries that match the search
-    # @!attribute [r] last_column_name
-    #   @return [Fixnum] the last column that was returned in the search in case you limited the number of columns (not supported)
     # @!attribute [r] per_page
     #   @return [Fixnum] the per page value of the search that produced these results (used by will_paginate)
     # @!attribute [r] current_page
     #   @return [Fixnum] the current page of the search that produced these results (used by will_paginate)
     # @!attribute [r] facets
-    #   @return [Hash] the facet(s) result (field and/or range) e.g. results.facets => {"author"=>["vonnegut", 2, "asimov", 4]} 
-    attr_accessor :last_column_name, :total_entries, :per_page, :current_page, :facets, :highlights
-    
+    #   @return [Hash] the facet results (field and/or range)
+    attr_accessor :total_entries, :per_page, :current_page, :facets, :highlights
+
     def inspect
       "<DatastaxRails::Collection##{object_id} contents: #{super} last_column_name: #{last_column_name.inspect}>"
     end
-    
+
     def total_pages
       return 1 unless per_page
       (total_entries / per_page.to_f).ceil
     end
   end
-end
+end

data/lib/datastax_rails/column.rb

@@ -1,20 +1,22 @@
 require 'set'
 
+# TODO: Break this up into manageable pieces
+# rubocop:disable Style/RescueModifier
 module DatastaxRails
-  class Column
+  class Column # rubocop:disable Style/ClassLength
     TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
     FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
-    
+
     module Format
       ISO_DATE = /\A(\d{4})-(\d\d)-(\d\d)\z/
       ISO_DATETIME = /\A(\d{4})-(\d\d)-(\d\d) (\d\d):(\d\d):(\d\d)(\.\d+)?\z/
-      SOLR_TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ".force_encoding('utf-8').freeze
+      SOLR_TIME_FORMAT = '%Y-%m-%dT%H:%M:%SZ'.force_encoding('utf-8').freeze
     end
 
     attr_reader :name, :type, :cql_type, :solr_type, :options
     attr_accessor :primary, :coder, :default
 
-    alias :encoded? :coder
+    alias_method :encoded?, :coder
 
     # Instantiates a new column in the table.
     #
@@ -30,7 +32,7 @@ module DatastaxRails
     def initialize(name, default, type, options = {})
       @name      = name
       @type      = type.to_sym
-      raise ArgumentError, "Unknown type #{type}" unless self.klass
+      fail ArgumentError, "Unknown type #{type}" unless klass
       options[:holds] = 'string' if collection? && options[:holds].blank?
       @options   = configure_options(@type, options).with_indifferent_access
       @cql_type  = compute_cql_type(@type, @options)
@@ -39,36 +41,36 @@ module DatastaxRails
       @primary   = nil
       @coder     = nil
     end
-    
+
     def configure_options(type, options)
       case type.to_sym
       when :set, :list, :map then
-        configure_options(options[:holds], options).merge(:multi_valued => true)
+        configure_options(options[:holds], options).merge(multi_valued: true)
       when :binary then
-        {:solr_index => false,   :solr_store => false, 
-         :multi_valued => false, :sortable => false, 
-         :tokenized => false,    :fulltext => false,
-         :cql_index => false}
+        { solr_index: false,   solr_store: false,
+          multi_valued: false, sortable: false,
+          tokenized: false,    fulltext: false,
+          cql_index: false }
       when :boolean, :date, :time, :timestamp, :datetime, :float, :integer, :uuid then
-        {:solr_index => true,    :solr_store => true,
-         :multi_valued => false, :sortable => true,
-         :tokenized => false,    :fulltext => false,
-         :cql_index => false}
+        { solr_index: true,    solr_store: true,
+          multi_valued: false, sortable: true,
+          tokenized: false,    fulltext: false,
+          cql_index: false }
       when :string then
-        {:solr_index => true,    :solr_store => true,
-         :multi_valued => false, :sortable => true,
-         :tokenized => false,    :fulltext => true,
-         :cql_index => false}
+        { solr_index: true,    solr_store: true,
+          multi_valued: false, sortable: true,
+          tokenized: false,    fulltext: true,
+          cql_index: false }
       when :text then
-        {:solr_index => true,    :solr_store => true,
-         :multi_valued => false, :sortable => false,
-         :tokenized => true,     :fulltext => true,
-         :cql_index => false}
+        { solr_index: true,    solr_store: true,
+          multi_valued: false, sortable: false,
+          tokenized: true,     fulltext: true,
+          cql_index: false }
       else
-        raise ArgumentError, "Unknown Type: #{type.to_s}"
+        fail ArgumentError, "Unknown Type: #{type}"
       end.merge(options)
     end
-    
+
     # Returns +true+ if the column is either of type ascii or text.
     def text?
       [:ascii, :text].include?(type)
@@ -78,18 +80,18 @@ module DatastaxRails
     def number?
       [:decimal, :double, :float, :integer].include?(type)
     end
-    
+
     # Returns +true+ if the column is of type binary
     def binary?
       [:binary].include?(type)
     end
-    
+
     def collection?
       [:set, :list, :map].include?(type)
     end
 
-    def has_default?
-      !default.nil?
+    def default?
+      default.present?
     end
 
     # Returns the Ruby class that corresponds to the abstract data type.
@@ -110,7 +112,7 @@ module DatastaxRails
     end
 
     # Casts value (which can be a String) to an appropriate instance.
-    def type_cast(value, record = nil, dest_type = nil)
+    def type_cast(value, record = nil, dest_type = nil) # rubocop:disable Style/CyclomaticComplexity
       return nil if value.nil?
       return coder.load(value) if encoded?
 
@@ -128,23 +130,26 @@ module DatastaxRails
       when :binary               then klass.binary_to_string(value)
       when :boolean              then klass.value_to_boolean(value)
       when :uuid, :timeuuid      then klass.value_to_uuid(value)
-      when :list, :set           then wrap_collection(value.collect {|v| type_cast(v, record, @options[:holds])}, record)
-      when :map                  then wrap_collection(value.each {|k,v| value[k] = type_cast(v, record, @options[:holds])}.stringify_keys, record)
+      when :list, :set           then wrap_collection(value.map { |v| type_cast(v, record, @options[:holds]) }, record)
+      when :map
+        wrap_collection(value.each { |k, v| value[k] = type_cast(v, record, @options[:holds]) }.stringify_keys, record)
       else value
       end
     end
-    
+
     def wrap_collection(collection, record)
-      klass.new(record, name, collection)
+      Types::DirtyCollection.ignore_modifications do
+        klass.new(record, name, collection)
+      end
     end
-    
+
     # Cql-rb does a really good job of typecasting, so for the most part we
     # just pass in the native types.  The only exceptions are for UUIDs that
     # are passed in as strings and dates.
     def type_cast_for_cql3(value, dest_type = nil)
       return nil if value.nil?
       return coder.dump(value) if encoded?
-      
+
       case (dest_type || type)
       when :uuid                        then value.is_a?(::Cql::Uuid) ? value : self.class.value_to_uuid(value)
       when :time, :datetime, :timestamp then value.to_time.utc
@@ -154,37 +159,37 @@ module DatastaxRails
       else value
       end
     end
-    
+
     # By contrast, since Solr isn't doing things like prepared statements
     # it doesn't know what the types are so we have to handle any casting
     # or encoding ourselves.
     def type_cast_for_solr(value, dest_type = nil)
       return nil if value.nil?
       return coder.dump(value) if encoded?
-      
+
       case (dest_type || type)
       when :boolean                            then value ? 'true' : 'false'
       when :date, :time, :datetime, :timestamp then value.to_time.utc.strftime(Format::SOLR_TIME_FORMAT)
-      when :list, :set                         then self.list_to_solr_value(value)
-      when :map                                then self.map_to_solr_value(value)
+      when :list, :set                         then list_to_solr_value(value)
+      when :map                                then map_to_solr_value(value)
       else value
       end
     end
-    
+
     def list_to_solr_value(value)
-      value.map {|v| type_cast_for_solr(v, @options[:holds].to_sym)}
+      value.map { |v| type_cast_for_solr(v, @options[:holds].to_sym) }
     end
-    
+
     def map_to_solr_value(value)
-      value.each {|k,v| value[k] = type_cast_for_solr(v, @options[:holds].to_sym)}
+      value.each { |k, v| value[k] = type_cast_for_solr(v, @options[:holds].to_sym) }
     end
-    
+
     def list_to_cql3_value(value)
-      value.map {|v| type_cast_for_cql3(v, @options[:holds].to_sym)}
+      value.map { |v| type_cast_for_cql3(v, @options[:holds].to_sym) }
     end
-    
+
     def map_to_cql3_value(value)
-      value.dup.each {|k,v| value[k] = type_cast_for_cql3(v, @options[:holds].to_sym)}
+      value.dup.each { |k, v| value[k] = type_cast_for_cql3(v, @options[:holds].to_sym) }
       value
     end
 
@@ -198,9 +203,9 @@ module DatastaxRails
 
     def extract_default(default)
       case type
-      when :map      then {}#lambda {|rec| DatastaxRails::Types::DynamicMap.new(rec, self.name.to_s, {})}
-      when :list     then []#lambda {|rec| DatastaxRails::Types::DynamicList.new(rec, self.name.to_s, [])}
-      when :set      then Set.new#lambda {|set| DatastaxRails::Types::DynamicSet.new(rec, self.name.to_s, Set.new)}
+      when :map      then {} # lambda {|rec| DatastaxRails::Types::DynamicMap.new(rec, self.name.to_s, {})}
+      when :list     then [] # lambda {|rec| DatastaxRails::Types::DynamicList.new(rec, self.name.to_s, [])}
+      when :set      then Set.new # lambda {|set| DatastaxRails::Types::DynamicSet.new(rec, self.name.to_s, Set.new)}
       else default
       end
     end
@@ -209,9 +214,9 @@ module DatastaxRails
     def string_to_binary(value)
       self.class.string_to_binary(value)
     end
-    
+
     def full_solr_range
-      if %w[date uuid].include? solr_type
+      if %w(date uuid).include? solr_type
         '[* TO *]'
       else
         '[\"\" TO *]'
@@ -248,7 +253,7 @@ module DatastaxRails
 
         fast_string_to_time(string) || fallback_string_to_time(string)
       end
-      
+
       def string_to_dummy_time(string)
         return string unless string.is_a?(String)
         return nil if string.empty?
@@ -294,7 +299,7 @@ module DatastaxRails
           value.to_s.to_d
         end
       end
-      
+
       # convert something to a TimeUuid
       def value_to_uuid(value)
         if value.is_a?(::Cql::Uuid)
@@ -303,84 +308,91 @@ module DatastaxRails
           ::Cql::TimeUuid.new(value) rescue nil
         end
       end
-      
+
       protected
-        # '0.123456' -> 123456
-        # '1.123456' -> 123456
-        def microseconds(time)
-          time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
-        end
 
-        def new_date(year, mon, mday)
-          if year && year != 0
-            Date.new(year, mon, mday) rescue nil
-          end
-        end
+      # '0.123456' -> 123456
+      # '1.123456' -> 123456
+      def microseconds(time)
+        time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+      end
 
-        def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
-          # Treat 0000-00-00 00:00:00 as nil.
-          return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
+      def new_date(year, mon, mday)
+        year && year != 0 && Date.new(year, mon, mday) rescue nil
+      end
 
-          if offset
-            time = Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
-            return nil unless time
+      def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil) # rubocop:disable Style/ParameterLists
+        # Treat 0000-00-00 00:00:00 as nil.
+        return nil if year.nil? || (year == 0 && mon == 0 && mday == 0)
 
-            time -= offset
-            Base.default_timezone == :utc ? time : time.getlocal
-          else
-            Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
-          end
-        end
+        if offset
+          time = Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+          return nil unless time
 
-        def fast_string_to_date(string)
-          if string =~ Format::ISO_DATE
-            new_date $1.to_i, $2.to_i, $3.to_i
-          end
+          time -= offset
+          Base.default_timezone == :utc ? time : time.getlocal
+        else
+          Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
         end
+      end
 
-        # Doesn't handle time zones.
-        def fast_string_to_time(string)
-          if string =~ Format::ISO_DATETIME
-            microsec = ($7.to_r * 1_000_000).to_i
-            new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
-          end
+      def fast_string_to_date(string)
+        if string =~ Format::ISO_DATE
+          new_date Regexp.last_match[1].to_i, Regexp.last_match[2].to_i, Regexp.last_match[3].to_i
         end
+      end
 
-        def fallback_string_to_date(string)
-          new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
-        end
+      # Doesn't handle time zones.
+      def fast_string_to_time(string)
+        return unless string =~ Format::ISO_DATETIME
+        microsec = (Regexp.last_match[7].to_r * 1_000_000).to_i
+        new_time(Regexp.last_match[1].to_i,
+                 Regexp.last_match[2].to_i,
+                 Regexp.last_match[3].to_i,
+                 Regexp.last_match[4].to_i,
+                 Regexp.last_match[5].to_i,
+                 Regexp.last_match[6].to_i,
+                 microsec
+                )
+      end
 
-        def fallback_string_to_time(string)
-          time_hash = Date._parse(string)
-          time_hash[:sec_fraction] = microseconds(time_hash)
+      def fallback_string_to_date(string)
+        new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+      end
 
-          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
-        end
+      def fallback_string_to_time(string)
+        time_hash = Date._parse(string)
+        time_hash[:sec_fraction] = microseconds(time_hash)
+
+        new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+      end
     end
-    
+
     private
-              
-      def compute_cql_type(field_type, options)
-        options[:cql_type] || case field_type.to_sym
-        when :integer                            then 'int'
-        when :time, :date, :timestamp, :datetime then 'timestamp' 
-        when :binary                             then 'blob'
-        when :list                               then "list<#{compute_cql_type(options[:holds], options)}>"
-        when :set                                then "set<#{compute_cql_type(options[:holds], options)}>"
-        when :map                                then "map<text, #{compute_cql_type(options[:holds], options)}>"
-        when :string                             then 'text'
-        else field_type.to_s
-        end
+
+    def compute_cql_type(field_type, options)
+      options[:cql_type] ||
+      case field_type.to_sym
+      when :integer                            then 'int'
+      when :time, :date, :timestamp, :datetime then 'timestamp'
+      when :binary                             then 'blob'
+      when :list                               then "list<#{compute_cql_type(options[:holds], options)}>"
+      when :set                                then "set<#{compute_cql_type(options[:holds], options)}>"
+      when :map                                then "map<text, #{compute_cql_type(options[:holds], options)}>"
+      when :string                             then 'text'
+      else field_type.to_s
       end
-      
-      def compute_solr_type(field_type, options)
-        options[:solr_type] || case field_type.to_sym
-        when :integer                            then 'int'
-        when :decimal                            then 'double'
-        when :timestamp, :time, :datetime        then 'date'
-        when :list, :set, :map                   then compute_solr_type(options[:holds], options)
-        else field_type.to_s
-        end
+    end
+
+    def compute_solr_type(field_type, options)
+      options[:solr_type] ||
+      case field_type.to_sym
+      when :integer                            then 'int'
+      when :decimal                            then 'double'
+      when :timestamp, :time, :datetime        then 'date'
+      when :list, :set, :map                   then compute_solr_type(options[:holds], options)
+      else field_type.to_s
       end
+    end
   end
 end