datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/base.rb

@@ -77,7 +77,7 @@ module DatastaxRails #:nodoc:
   #   sense to sort on anyways).
   #
   # EXAMPLE:
-  # 
+  #
   #   class Person < DatastaxRails::Base
   #     uuid    :id
   #     string  :first_name
@@ -233,15 +233,15 @@ module DatastaxRails #:nodoc:
   #   Company.where(name: 'All*').first #=> finds the first company whose name begins with All
   #
   # See DatastaxRails::FinderMethods for more information
-  # 
+  #
   # == Facets
   #
   # DSR support both field and range facets. For additional detail on facets, see the documentation
-  # available under the {DatastaxRails::FacetMethods} module. The result is available through the 
+  # available under the {DatastaxRails::FacetMethods} module. The result is available through the
   # facets accessor.
   #
   #   results = Article.field_facet(:author)
-  #   results.facets #=> {"author"=>["vonnegut", 2. "asimov", 3]} 
+  #   results.facets #=> {"author"=>["vonnegut", 2. "asimov", 3]}
   #
   #   Model.field_facet(:author)
   #   Model.field_facet(:author, sort: 'count', limit: 10, mincount: 1)
@@ -273,7 +273,7 @@ module DatastaxRails #:nodoc:
   # will lose data.
   #
   # === Set
-  # 
+  #
   # A set is an un-ordered collection of unique values. This collection is fully searchable in Solr.
   #
   #   class User < DatastaxRails::Base
@@ -296,7 +296,7 @@ module DatastaxRails #:nodoc:
   #   user.emails #=> ['jim@example.com']
   #
   # === List
-  # 
+  #
   # An ordered collection of values. They do not necessarily have to be unique. The collection
   # will be fully searchable in Solr.
   #
@@ -346,10 +346,9 @@ module DatastaxRails #:nodoc:
   #
   # See the documentation for {DatastaxRails::SearchMethods} for more examples of using the search API.
   class Base
-    extend ActiveModel::Naming
-    include ActiveModel::Conversion
+    include ActiveModel::Model
     extend ActiveSupport::DescendantsTracker
-    
+
     include Persistence
     include Connection
     include Inheritance
@@ -365,15 +364,15 @@ module DatastaxRails #:nodoc:
     include Timestamps
     include Serialization
     include SolrRepair
-    
+
     # Stores the default scope for the class
-    class_attribute :default_scopes, :instance_writer => false
+    class_attribute :default_scopes, instance_writer: false
     self.default_scopes = []
-    
+
     # Stores the connection configuration information
     class_attribute :config
-    
-    class_attribute :default_timezone, :instance_writer => false
+
+    class_attribute :default_timezone, instance_writer: false
     self.default_timezone = :utc
 
     # Stores the default consistency level (QUORUM by default)
@@ -383,45 +382,45 @@ module DatastaxRails #:nodoc:
     # Stores the method of saving data (CQL by default)
     class_attribute :storage_method
     self.storage_method = :cql
-    
+
     # Stores any additional information that should be used when creating the column family
     # See {DatastaxRails::WideStorageModel} or {DatastaxRails::Payload} model for an example
     class_attribute :create_options
-    
+
     # Stores the attribute that wide models should cluster on. Basically, this is the
     # attribute that CQL uses to "group" columns into logical records even though they
     # are stored on the same row.
     class_attribute :cluster_by
-    
+
     attr_reader :attributes
     attr_reader :loaded_attributes
     attr_accessor :key
-    
+
     # Returns a hash of all the attributes that have been specified for serialization as
     # keys and their class restriction as values.
     class_attribute :serialized_attributes
     self.serialized_attributes = {}
-    
+
     # Whether or not we are using solr legacy mappings
     class_attribute :legacy_mapping
-    
-    def initialize(attributes = {}, options = {})
+
+    def initialize(attributes = {}, _options = {})
       defaults = self.class.column_defaults.dup
-      defaults.each { |k, v| v.duplicable? ? v.dup : v }
-      
-      @attributes = self.initialize_attributes(defaults)
+      defaults.each { |_k, v| v.duplicable? ? v.dup : v }
+
+      @attributes = initialize_attributes(defaults)
       @column_types = self.class.columns_hash
 
       init_internals
-      init_changed_attributes      
+      init_changed_attributes
       populate_with_current_scope_attributes
-      
+
       assign_attributes(attributes) if attributes
-      
+
       yield self if block_given?
       run_callbacks :initialize unless _initialize_callbacks.empty?
     end
-    
+
     # Initialize an empty model object from +coder+. +coder+ must contain
     # the attributes necessary for initializing an empty model object. For
     # example:
@@ -434,35 +433,35 @@ module DatastaxRails #:nodoc:
     #   post.title # => 'hello world'
     def init_with(coder)
       Types::DirtyCollection.ignore_modifications do
-        @attributes   = self.initialize_attributes(coder['attributes'])
+        @attributes   = initialize_attributes(coder['attributes'])
         @column_types_override = coder['column_types']
         @column_types = self.class.columns_hash
-        
+
         init_internals
-  
+
         @new_record = false
         run_callbacks :find
         run_callbacks :initialize
       end
       self
     end
-    
+
     def init_internals
       pk = self.class.primary_key
       @attributes[pk] = nil unless @attributes.key?(pk)
 
       @association_cache = {}
       @attributes_cache = {}
-      @previously_changed = {}
-      @changed_attributes = {}
-      @loaded_attributes = Hash[@attributes.map{|k,v| [k,true]}].with_indifferent_access
+      @previously_changed = {}.with_indifferent_access
+      @changed_attributes = {}.with_indifferent_access
+      @loaded_attributes = Hash[@attributes.map { |k, _v| [k, true] }].with_indifferent_access
       @readonly = false
       @destroyed = false
       @marked_for_destruction = false
       @destroyed_by_association = nil
       @new_record = true
     end
-    
+
     def init_changed_attributes
       # Intentionally avoid using #column_defaults since overridden defaults
       # won't get written unless they get marked as changed
@@ -471,17 +470,18 @@ module DatastaxRails #:nodoc:
         @changed_attributes[attr] = orig_value if _field_changed?(attr, orig_value, @attributes[attr])
       end
     end
-    
+
     # Freeze the attributes hash such that associations are still accessible, even on destroyed records.
     def freeze
-      @attributes.freeze; self
+      @attributes.freeze
+      self
     end
 
     # Returns +true+ if the attributes hash has been frozen.
     def frozen?
       @attributes.frozen?
     end
-    
+
     def to_param
       id.to_s if persisted?
     end
@@ -490,52 +490,51 @@ module DatastaxRails #:nodoc:
       id.hash
     end
 
-    def ==(comparison_object)
+    def ==(other)
       super ||
-        comparison_object.instance_of?(self.class) &&
+        other.instance_of?(self.class) &&
         id.present? &&
-        comparison_object.id.eql?(id)
+        other.id.eql?(id)
     end
 
-    def eql?(comparison_object)
-      self == (comparison_object)
+    def eql?(other)
+      self == (other)
     end
-    
+
     def attribute_names
       self.class.attribute_names
     end
-    alias :column_names :attribute_names
-    
+    alias_method :column_names, :attribute_names
+
     def valid_consistency?(level) #:nodoc:
       self.class.validate_consistency(level.to_s.upcase)
     end
-    
+
     private
-      def populate_with_current_scope_attributes
-        return unless self.class.scope_attributes?
-        
-        self.class.scope_attributes.each do |att, value|
-          send("#{att}=", value) if respond_to?("#{att}=")
-        end
+
+    def populate_with_current_scope_attributes
+      return unless self.class.scope_attributes?
+
+      self.class.scope_attributes.each do |att, value|
+        send("#{att}=", value) if respond_to?("#{att}=")
       end
-      
+    end
+
     class << self
-      delegate :find, :find_by, :find_by!, :first, :all, :exists?, :any?, :many?, :to => :scoped
-      delegate :destroy, :destroy_all, :delete, :update, :update_all, :to => :scoped
-      delegate :order, :limit, :where, :where_not, :page, :paginate, :select, :slow_order, :to => :scoped
-      delegate :per_page, :each, :group, :total_pages, :search, :fulltext, :to => :scoped
-      delegate :count, :first, :first!, :last, :last!, :compute_stats, :to => :scoped
-      delegate :sum, :average, :minimum, :maximum, :stddev, :to => :scoped
-      delegate :cql, :with_cassandra, :with_solr, :commit_solr, :allow_filtering, :to => :scoped
-      delegate :find_each, :find_in_batches, :consistency, :to => :scoped
-      delegate :field_facet, :range_facet, :to => :scoped
+      delegate :find, :find_by, :find_by!, :first, :all, :exists?, :any?, :many?, to: :scoped
+      delegate :destroy, :destroy_all, :delete, :update, :update_all, to: :scoped
+      delegate :order, :limit, :where, :where_not, :page, :paginate, :select, :slow_order, to: :scoped
+      delegate :per_page, :each, :group, :total_pages, :search, :fulltext, to: :scoped
+      delegate :count, :first, :first!, :last, :last!, :compute_stats, to: :scoped
+      delegate :sum, :average, :minimum, :maximum, :stddev, to: :scoped
+      delegate :cql, :with_cassandra, :with_solr, :commit_solr, :allow_filtering, to: :scoped
+      delegate :find_each, :find_in_batches, :consistency, to: :scoped
+      delegate :field_facet, :range_facet, to: :scoped
 
       # Sets the column family name
       #
       # @param [String] column_family the name of the column family in cassandra
-      def column_family=(column_family)
-        @column_family = column_family
-      end
+      attr_writer :column_family
 
       # Returns the column family name.  If it has been set manually, the set name is returned.
       # Otherwise returns the pluralized version of the class name.
@@ -544,51 +543,49 @@ module DatastaxRails #:nodoc:
       def column_family
         @column_family || name.underscore.pluralize
       end
-      
+
       def models
-        self.descendants.reject {|m|m.abstract_class?}
+        descendants.reject { |m|m.abstract_class? }
       end
-      
+
       def payload_model?
-        self.ancestors.include?(DatastaxRails::PayloadModel)
+        ancestors.include?(DatastaxRails::PayloadModel)
       end
-      
+
       def wide_storage_model?
-        self.ancestors.include?(DatastaxRails::WideStorageModel)
+        ancestors.include?(DatastaxRails::WideStorageModel)
       end
-      
+
       def legacy_mapping?
-        self.legacy_mapping
+        legacy_mapping
       end
-      
+
       def base_class
         klass = self
-        while klass.superclass != Base
-          klass = klass.superclass
-        end
+        klass = klass.superclass while klass.superclass != Base
         klass
       end
-      
+
       def find_by_id(id)
         scoped.with_cassandra.find(id)
       rescue RecordNotFound
         nil
       end
-      
+
       def logger
         Rails.logger
       end
-      
+
       # Returns an array of attribute names as strings
       def attribute_names
-        @attribute_names ||= attribute_definitions.keys.collect {|a|a.to_s}
+        @attribute_names ||= attribute_definitions.keys.map { |a|a.to_s }
       end
-      alias :column_names :attribute_names
-      
+      alias_method :column_names, :attribute_names
+
       def columns
         @columns ||= attribute_definitions.values
       end
-      
+
       # SOLR always paginates all requests.  There is no way to disable it, so we are
       # setting the default page size to an arbitrarily high number so that we effectively
       # remove pagination.  If you instead want a model set to something more sane, then
@@ -601,18 +598,18 @@ module DatastaxRails #:nodoc:
       #     end
       #   end
       def default_page_size
-        100000
+        100_000
       end
-      
+
       def search_ids(&block)
         search = solr_search(&block)
         search.raw_results.map { |result| result.primary_key }
       end
-      
+
       def valid_consistency?(level) #:nodoc:
         DatastaxRails::Cql::Consistency::VALID_CONSISTENCY_LEVELS.include?(level)
       end
-      
+
       # Returns a string like 'Post(id:integer, title:string, body:text)'
       def inspect
         if self == Base
@@ -622,45 +619,45 @@ module DatastaxRails #:nodoc:
           "#{super}(#{attr_list})"
         end
       end
-      
+
       private
-      
-        def construct_finder_relation(options = {}, scope = nil)
-          relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
-          relation = scope.merge(relation) if scope
-          relation
-        end
-      
-        def relation #:nodoc:
-          Relation.new(self, column_family)
-        end
-        
-        # Returns the class type of the record using the current module as a prefix. So descendants of
-        # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
-        def compute_type(type_name)
-          if type_name.match(/^::/)
-            # If the type is prefixed with a scope operator then we assume that
-            # the type_name is an absolute reference.
-            ActiveSupport::Dependencies.constantize(type_name)
-          else
-            # Build a list of candidates to search for
-            candidates = []
-            name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
-            candidates << type_name
-
-            candidates.each do |candidate|
-              begin
-                constant = ActiveSupport::Dependencies.constantize(candidate)
-                return constant if candidate == constant.to_s
-              rescue NameError => e
-                # We don't want to swallow NoMethodError < NameError errors
-                raise e unless e.instance_of?(NameError)
-              end
-            end
 
-            raise NameError, "uninitialized constant #{candidates.first}"
+      def construct_finder_relation(options = {}, scope = nil)
+        relation = options.is_a?(Hash) ? unscoped.apply_finder_options(options) : options
+        relation = scope.merge(relation) if scope
+        relation
+      end
+
+      def relation #:nodoc:
+        Relation.new(self, column_family)
+      end
+
+      # Returns the class type of the record using the current module as a prefix. So descendants of
+      # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
+      def compute_type(type_name)
+        if type_name.match(/^::/)
+          # If the type is prefixed with a scope operator then we assume that
+          # the type_name is an absolute reference.
+          ActiveSupport::Dependencies.constantize(type_name)
+        else
+          # Build a list of candidates to search for
+          candidates = []
+          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+          candidates << type_name
+
+          candidates.each do |candidate|
+            begin
+              constant = ActiveSupport::Dependencies.constantize(candidate)
+              return constant if candidate == constant.to_s
+            rescue NameError => e
+              # We don't want to swallow NoMethodError < NameError errors
+              raise e unless e.instance_of?(NameError)
+            end
           end
+
+          fail NameError, "uninitialized constant #{candidates.first}"
         end
+      end
     end
   end
 end