datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/relation/spawn_methods.rb

@@ -1,44 +1,44 @@
 module DatastaxRails
   module SpawnMethods
     # def scoped #:nodoc:
-      # self
+    # self
     # end
-    
+
     def merge(r) #:nodoc:
       return self unless r
       return to_a & r if r.is_a?(Array)
-      
+
       merged_relation = clone
-      
+
       r = r.with_default_scope if r.default_scoped? && r.klass != klass
-      
+
       (Relation::MULTI_VALUE_METHODS - [:where, :where_not]).each do |method|
         value = r.send(:"#{method}_values")
         merged_relation.send(:"#{method}_values=", merged_relation.send(:"#{method}_values") + value) if value.present?
       end
-      
+
       merged_wheres = {}
       # This will merge all the where clauses into a single hash.  If the same attribute is
       # specified multiple times, the last one will win.
-      (@where_values + r.where_values).each { |w| merged_wheres.merge!(w)}
-      
+      (@where_values + r.where_values).each { |w| merged_wheres.merge!(w) }
+
       merged_relation.where_values = [merged_wheres] unless merged_wheres.empty?
-      
+
       merged_where_nots = {}
       # This will merge all the where not clauses into a single hash.  If the same attribute is
       # specified multiple times, the last one will win.
-      (@where_not_values + r.where_not_values).each { |w| merged_where_nots.merge!(w)}
-      
+      (@where_not_values + r.where_not_values).each { |w| merged_where_nots.merge!(w) }
+
       merged_relation.where_not_values = [merged_where_nots] unless merged_where_nots.empty?
-      
+
       (Relation::SINGLE_VALUE_METHODS).each do |method|
         value = r.send(:"#{method}_value")
         merged_relation.send(:"#{method}_value=", value) unless value.nil? || value == :default
       end
-      
+
       merged_relation
     end
-    
+
     # Removes from the query the condition(s) specified in +skips+.
     #
     # Example:
@@ -62,7 +62,7 @@ module DatastaxRails
 
       result
     end
-    
+
     # Removes any condition from the query other than the one(s) specified in +onlies+.
     #
     # Example:
@@ -87,8 +87,9 @@ module DatastaxRails
 
       result
     end
-    
-    VALID_FIND_OPTIONS = [:conditions, :limit, :select, :offset, :order, :group, :page, :per_page, :fulltext, :consistency, :with_solr, :with_cassandra, :where, :where_not]
+
+    VALID_FIND_OPTIONS = %i(conditions limit select offset order group page per_page fulltext consistency with_solr
+                            with_cassandra where where_not)
     # Applies the passed in finder options and returns a new Relation.
     # Takes any of the options below and calls them on the relation as if they
     # were methods (+conditions+ is passed to +where+).
@@ -113,21 +114,21 @@ module DatastaxRails
     def apply_finder_options(options)
       relation = self
       return relation unless options
-      
+
       options.assert_valid_keys(VALID_FIND_OPTIONS)
       finders = options.dup
-      finders.delete_if { |key, value| value.nil? }
-      
+      finders.delete_if { |_key, value| value.nil? }
+
       ((VALID_FIND_OPTIONS - [:conditions]) & finders.keys).each do |finder|
-        if(finder.to_s =~ /(with_solr|with_cassandra)/)
+        if finder.to_s =~ /(with_solr|with_cassandra)/
           relation = relation.send(finder)
         else
           relation = relation.send(finder, finders[finder])
         end
       end
-      
-      relation = relation.where(finders[:conditions]) if finders.has_key?(:conditions)
+
+      relation = relation.where(finders[:conditions]) if finders.key?(:conditions)
       relation
     end
   end
-end
+end

data/lib/datastax_rails/relation/stats_methods.rb

@@ -1,7 +1,7 @@
 module DatastaxRails
   module StatsMethods
-    STATS_FIELDS={'sum' => 'sum', 'maximum' => 'max', 'minimum' => 'min', 'average' => 'mean', 'stddev' => 'stddev'}
-    
+    STATS_FIELDS = { 'sum' => 'sum', 'maximum' => 'max', 'minimum' => 'min', 'average' => 'mean', 'stddev' => 'stddev' }
+
     # @!method sum(field)
     #   Calculates the sum of the field listed. Field must be indexed as a number.
     #   @param [Symbol] field the field to calculate
@@ -42,28 +42,29 @@ module DatastaxRails
     #   Calculates the standard deviation of the field listed for a grouped query.
     #   @param [Symbol] field the field to calculate
     #   @return [Hash] the standard deviation of the columns that match the query by group. Group name is the key.
-    %w[sum maximum minimum average stddev].each do |op|
+    %w(sum maximum minimum average stddev).each do |op|
       define_method(op) do |field|
         calculate_stats(field)
         @stats[field] ? @stats[field][STATS_FIELDS[op]] : 0
       end
-      
+
       define_method("grouped_#{op}") do |field|
         self.op unless @group_value
         calculate_stats(field)
         values = {}
-        @stats[field]["facets"][@group_value].each do |k,v|
+        @stats[field]['facets'][@group_value].each do |k, v|
           values[k] = v[STATS_FIELDS[op]]
         end
         values
       end
     end
-    
+
     private
+
     def calculate_stats(field)
       unless @stats[field]
         @stats[field] = limit(1).compute_stats(field).stats[field]
       end
     end
-  end 
-end
+  end
+end

data/lib/datastax_rails/relation.rb

@@ -1,13 +1,15 @@
 require 'rsolr'
 require 'pp' if ENV['DEBUG_SOLR'] == 'true'
-
+# TODO: Move functionality into modules
 module DatastaxRails
-  class Relation
-    MULTI_VALUE_METHODS = [:order, :where, :where_not, :fulltext, :greater_than, :less_than, :select, :stats, :field_facet, :range_facet, :slow_order]
-    SINGLE_VALUE_METHODS = [:page, :per_page, :reverse_order, :query_parser, :consistency, :ttl, :use_solr, :escape, :group, :allow_filtering]
-    
+  class Relation # rubocop:disable Style/ClassLength
+    MULTI_VALUE_METHODS = %i(order where where_not fulltext greater_than less_than select stats field_facet
+                             range_facet slow_order)
+    SINGLE_VALUE_METHODS = %i(page per_page reverse_order query_parser consistency ttl use_solr escape group
+                              allow_filtering)
+
     SOLR_CHAR_RX = /([\+\!\(\)\[\]\^\"\~\:\'\=\/]+)/
-    
+
     Relation::MULTI_VALUE_METHODS.each do |m|
       attr_accessor :"#{m}_values"
     end
@@ -16,7 +18,7 @@ module DatastaxRails
     end
     attr_accessor :create_with_value, :default_scoped
     attr_accessor :highlight_options
-    
+
     include SearchMethods
     include ModificationMethods
     include FinderMethods
@@ -24,11 +26,11 @@ module DatastaxRails
     include StatsMethods
     include Batches
     include FacetMethods
-    
+
     attr_reader :klass, :column_family, :loaded, :cql
-    alias :loaded? :loaded
-    alias :default_scoped? :default_scoped
-    
+    alias_method :loaded?, :loaded
+    alias_method :default_scoped?, :default_scoped
+
     # Initializes the Relation.  Defaults page value to 1, per_page to the class
     # default, and solr use to true.  Everything else gets defaulted to nil or
     # empty.
@@ -41,9 +43,9 @@ module DatastaxRails
       @results = []
       @default_scoped = false
       @cql = DatastaxRails::Cql.for_class(klass)
-      
-      SINGLE_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_value", nil)}
-      MULTI_VALUE_METHODS.each {|v| instance_variable_set(:"@#{v}_values", [])}
+
+      SINGLE_VALUE_METHODS.each { |v| instance_variable_set(:"@#{v}_value", nil) }
+      MULTI_VALUE_METHODS.each { |v| instance_variable_set(:"@#{v}_values", []) }
       @highlight_options = {}
       @per_page_value = @klass.default_page_size
       @page_value = 1
@@ -53,24 +55,24 @@ module DatastaxRails
       @escape_value = :default
       @stats = {}
     end
-    
+
     # Returns true if the two relations have the same query parameters
     def ==(other)
       case other
       when Relation
         # This is not a valid implementation.  It's a placeholder till I figure out the right way.
         MULTI_VALUE_METHODS.each do |m|
-          return false unless other.send("#{m}_values") == self.send("#{m}_values")
+          return false unless other.send("#{m}_values") == send("#{m}_values")
         end
         SINGLE_VALUE_METHODS.each do |m|
-          return false unless other.send("#{m}_value") == self.send("#{m}_value")
+          return false unless other.send("#{m}_value") == send("#{m}_value")
         end
         return true
       when Array
         to_a == other
       end
     end
-    
+
     # Returns true if there are any results given the current criteria
     def any?
       if block_given?
@@ -79,33 +81,35 @@ module DatastaxRails
         !empty?
       end
     end
-    alias :exists? :any?
-    
+    alias_method :exists?, :any?
+
     # Returns the total number of entries that match the given search.
     # This means the total number of matches regardless of page size.
     # If the relation has not been populated yet, a limit of 1 will be
     # placed on the query before it is executed.
     #
-    # For a grouped query, this still returns the total number of 
+    # For a grouped query, this still returns the total number of
     # matching documents
     #
     # Compare with #size.
     def count
-      @count ||= (with_default_scope.path_decision == :solr) ? with_default_scope.count_via_solr : with_default_scope.count_via_cql
+      @count ||= if with_default_scope.path_decision == :solr
+                   with_default_scope.count_via_solr
+                 else
+                   with_default_scope.count_via_cql
+                 end
     end
-    
+
     def stats
-      unless(loaded?)
-        to_a
-      end
+      loaded? || to_a
       @stats
     end
-    
+
     # Returns the current page for will_paginate compatibility
     def current_page
-      self.page_value.try(:to_i)
+      page_value.try(:to_i)
     end
-    
+
     # current_page - 1 or nil if there is no previous page
     def previous_page
       current_page > 1 ? (current_page - 1) : nil
@@ -115,14 +119,14 @@ module DatastaxRails
     def next_page
       current_page < total_pages ? (current_page + 1) : nil
     end
-    
+
     # Gets a default scope with no conditions or search attributes set.
     def default_scope
       klass.scoped.with_default_scope
     end
-    
+
     def with_default_scope #:nodoc:
-      if default_scoped? && default_scope = klass.send(:build_default_scope)
+      if default_scoped? && (default_scope = klass.send(:build_default_scope))
         default_scope = default_scope.merge(self)
         default_scope.default_scoped = false
         default_scope
@@ -130,15 +134,15 @@ module DatastaxRails
         self
       end
     end
-    
+
     # Returns true if there are no results given the current criteria
     def empty?
       return @results.empty? if loaded?
-      
+
       c = count
       c.respond_to?(:zero?) ? c.zero? : c.empty?
     end
-    
+
     # Returns true if there are multiple results given the current criteria
     def many?
       if block_given?
@@ -147,20 +151,20 @@ module DatastaxRails
         count > 1
       end
     end
-    
+
     # Constructs a new instance of the class this relation points to with
     # any criteria from this relation applied
     def new(*args, &block)
       scoping { @klass.new(*args, &block) }
     end
-    
+
     # Reloads the results from cassandra or solr as appropriate
     def reload
       reset
       to_a
       self
     end
-    
+
     # Empties out the current results.  The next call to to_a
     # will re-run the query.
     def reset
@@ -168,25 +172,25 @@ module DatastaxRails
       @stats = {}
       @results = []
     end
-    
+
     # Copies will have changes made to the criteria and so need to be reset.
-    def initialize_copy(other)
+    def initialize_copy(_other)
       reset
       @search = nil
     end
-    
+
     # Performs a deep copy using Marshal when cloning.
     def clone
       dup.tap do |r|
         MULTI_VALUE_METHODS.each do |m|
-          r.send("#{m}_values=", Marshal.load(Marshal.dump(self.send("#{m}_values"))))
+          r.send("#{m}_values=", Marshal.load(Marshal.dump(send("#{m}_values"))))
         end
         SINGLE_VALUE_METHODS.each do |m|
-          r.send("#{m}_value=", Marshal.load(Marshal.dump(self.send("#{m}_value")))) if self.send("#{m}_value")
+          r.send("#{m}_value=", Marshal.load(Marshal.dump(send("#{m}_value")))) if send("#{m}_value")
         end
       end
     end
-    
+
     # Returns the size of the total result set for the given criteria
     # NOTE that this takes pagination into account so will only return
     # the number of results in the current page.  DatastaxRails models
@@ -201,14 +205,14 @@ module DatastaxRails
       total_entries = count
       (per_page_value && total_entries > per_page_value) ? per_page_value : total_entries
     end
-    
+
     # Returns the total number of pages required to display the results
     # given the current page size.  Used by will_paginate.
     def total_pages
       return 1 unless @per_page_value
       (count / @per_page_value.to_f).ceil
     end
-    
+
     # Actually executes the query if not already executed.
     # Returns a standard array thus no more methods may be chained.
     def to_a
@@ -222,9 +226,9 @@ module DatastaxRails
       @loaded = true
       @results
     end
-    alias :all :to_a
-    alias :results :to_a
-    
+    alias_method :all, :to_a
+    alias_method :results, :to_a
+
     # Create a new object with all of the criteria from this relation applied
     def create(*args, &block)
       scoping { @klass.create(*args, &block) }
@@ -234,14 +238,14 @@ module DatastaxRails
     def create!(*args, &block)
       scoping { @klass.create!(*args, &block) }
     end
-    
+
     # Override respond_to? so that it matches method_missing
     def respond_to?(method, include_private = false)
       Array.method_defined?(method)                       ||
       @klass.respond_to?(method, include_private)         ||
       super
     end
-    
+
     def path_decision
       return :cassandra if klass <= DatastaxRails::CassandraOnlyModel
       case use_solr_value
@@ -252,28 +256,27 @@ module DatastaxRails
       else
         [order_values, where_not_values, fulltext_values, greater_than_values, less_than_values, field_facet_values,
          range_facet_values, group_value].each do |solr_only_stuff|
-           return :solr unless solr_only_stuff.blank? 
+           return :solr unless solr_only_stuff.blank?
          end
         return :solr unless group_value.blank?
         return :solr unless page_value == 1
         @where_values.each do |wv|
-          wv.each do |k,v|
-            unless klass.column_for_attribute(k).options[:cql_index]
-              return :solr
-            end
+          wv.each do |k, _v|
+            next if klass.column_for_attribute(k).options[:cql_index]
+            return :solr
           end
         end
         # If we get here, we can safely run this query via Cassandra
         return :cassandra
       end
     end
-    
+
     # If we index something into both cassandra and solr, we rename the cassandra
     # column.  This method maps the column names as necessary
     def map_cassandra_columns(conditions)
       {}.tap do |mapped|
-        conditions.each do |k,v|
-          if(klass.attribute_definitions[k].indexed == :both)
+        conditions.each do |k, v|
+          if (klass.attribute_definitions[k].indexed == :both)
             mapped["__#{k}"] = v
           else
             mapped[k] = v
@@ -281,7 +284,7 @@ module DatastaxRails
         end
       end
     end
-    
+
     def count_via_cql
       cql = @cql.select(['count(*)'])
       cql.using(@consistency_value) if @consistency_value
@@ -291,28 +294,25 @@ module DatastaxRails
       cql.allow_filtering if @allow_filtering_value
       cql.execute.first['count']
     end
-    
+
     # Constructs a CQL query and runs it against Cassandra directly.  For this to
     # work, you need to run against either the primary key or a secondary index.
     # For ad-hoc queries, you will have to use Solr.
     def query_via_cql
-      select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
+      select_columns =
+        select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
       cql = @cql.select((select_columns + [@klass.primary_key]).uniq)
       cql.using(@consistency_value) if @consistency_value
       @where_values.each do |wv|
-        cql.conditions(Hash[wv.map {|k,v| [(k.to_s == 'id' ? @klass.primary_key : k), v]}])
+        cql.conditions(Hash[wv.map { |k, v| [(k.to_s == 'id' ? @klass.primary_key : k), v] }])
       end
       @greater_than_values.each do |gtv|
-        gtv.each do |k,v|
+        gtv.each do |k, v|
           # Special case if inequality is equal to the primary key (we're paginating)
-          if(k.to_s == @klass.primary_key)
-            cql.paginate(v)
-          end
+          cql.paginate(v) if (k.to_s == @klass.primary_key)
         end
       end
-      if(@per_page_value)
-        cql.limit(@per_page_value)
-      end
+      cql.limit(@per_page_value) if @per_page_value
       cql.allow_filtering if @allow_filtering_value
       results = []
       begin
@@ -327,20 +327,20 @@ module DatastaxRails
           raise
         end
       end
-      if(@slow_order_values.any?)
-        results.sort! do |a,b| 
-          values = slow_ordering(a,b)
+      if @slow_order_values.any?
+        results.sort! do |a, b|
+          values = slow_ordering(a, b)
           values[0] <=> values[1]
         end
       end
       results
     end
-    
+
     def slow_ordering(obj1, obj2)
-      [[],[]].tap do |values|
-        i=0
+      [[], []].tap do |values|
+        i = 0
         @slow_order_values.each do |ordering|
-          ordering.each do |k,v|
+          ordering.each do |k, v|
             if v == :asc
               values[0][i] = obj1.send(k)
               values[1][i] = obj2.send(k)
@@ -353,14 +353,14 @@ module DatastaxRails
         end
       end
     end
-    
+
     # Runs the query with a limit of 1 just to grab the total results attribute off
-    # the result set. 
+    # the result set.
     def count_via_solr
       results = limit(1).select(:id).to_a
       @group_value ? results.total_for_all : results.total_entries
     end
-    
+
     # Escapes values that might otherwise mess up the URL or confuse SOLR.
     # If you want to handle escaping yourself for a particular query then
     # SearchMethods#dont_escape is what you're looking for.
@@ -371,82 +371,74 @@ module DatastaxRails
         str
       end
     end
-    
+
     def full_solr_range(attr)
-      if(self.klass.attribute_definitions[attr])
-        self.klass.attribute_definitions[attr].full_solr_range
+      if klass.attribute_definitions[attr]
+        klass.attribute_definitions[attr].full_solr_range
       else
         '[\"\" TO *]'
       end
     end
-    
-    # Constructs a solr query to run against SOLR. At this point, only where, where_not, 
+
+    # Constructs a solr query to run against SOLR. At this point, only where, where_not,
     # fulltext, order and pagination are supported.  More will be added.
     #
     # It's also worth noting that where and where_not make use of individual filter_queries.
     # If that's not what you want, you might be better off constructing your own fulltext
     # query and sending that in.
-    def query_via_solr
+    #
+    # TODO: break this apart into multiple methods
+    def query_via_solr # rubocop:disable all
       filter_queries = []
       orders = []
       @where_values.each do |wv|
-        wv.each do |k,v|
+        wv.each do |k, v|
           # If v is blank, check that there is no value for the field in the document
           filter_queries << (v.blank? ? "-#{k}:#{full_solr_range(k)}" : "#{k}:(#{v})")
         end
       end
-      
+
       @where_not_values.each do |wnv|
-        wnv.each do |k,v|
+        wnv.each do |k, v|
           # If v is blank, check for any value for the field in document
           filter_queries << (v.blank? ? "#{k}:#{full_solr_range(k)}" : "-#{k}:(#{v})")
         end
       end
-      
+
       @greater_than_values.each do |gtv|
-        gtv.each do |k,v|
+        gtv.each do |k, v|
           filter_queries << "#{k}:[#{v} TO *]"
         end
       end
-      
+
       @less_than_values.each do |ltv|
-        ltv.each do |k,v|
+        ltv.each do |k, v|
           filter_queries << "#{k}:[* TO #{v}]"
         end
       end
-      
+
       @order_values.each do |ov|
-        ov.each do |k,v|
-          if(@reverse_order_value)
+        ov.each do |k, v|
+          if @reverse_order_value
             orders << "#{k} #{v == :asc ? 'desc' : 'asc'}"
           else
             orders << "#{k} #{v == :asc ? 'asc' : 'desc'}"
           end
         end
       end
-      
-      sort = orders.join(",")
-      
-      if @fulltext_values.empty?
-        q = "*:*"
-      else
-        q = @fulltext_values.collect {|ftv| "(" + ftv[:query] + ")"}.join(' AND ')
-        hl_fields = @fulltext_values.collect { |ftv| ftv[:highlight].join(",") if ftv[:highlight].present? }.join(",")
-      end
-      
-      params = {:q => q}
-      unless sort.empty?
-        params[:sort] = sort
-      end
-      
-      unless filter_queries.empty?
-        params[:fq] = filter_queries
-      end
+
+      sort = orders.join(',')
+
+      q = @fulltext_values.empty? ? '*:*' : @fulltext_values.map { |ftv| '(' + ftv[:query] + ')' }.join(' AND ')
+
+      params = { q: q }
+      params[:sort] = sort
+      params[:fq] = filter_queries unless filter_queries.empty?
 
       # Facets
       # facet=true to enable faceting,  facet.field=<field_name> (can appear more than once for multiple fields)
       # Additional options: f.<field_name>.facet.<option> [e.g. f.author.facet.sort=index]
-      
+
       # Facet Fields
       unless field_facet_values.empty?
         params['facet'] = 'true'
@@ -454,7 +446,7 @@ module DatastaxRails
         field_facet_values.each do |facet|
           facet_field = facet[:field]
           facet_fields << facet_field
-          facet[:options].each do |key,value|
+          facet[:options].each do |key, value|
             params["f.#{facet_field}.facet.#{key}"] = value.to_s
           end
         end
@@ -468,13 +460,13 @@ module DatastaxRails
         range_facet_values.each do |facet|
           facet_field = facet[:field]
           facet_fields << facet_field
-          facet[:options].each do |key,value|
+          facet[:options].each do |key, value|
             params["f.#{facet_field}.facet.range.#{key}"] = value.to_s
           end
         end
         params['facet.range'] = facet_fields
       end
-      
+
       if @highlight_options[:fields].present?
         params[:hl] = true
         params['hl.fl'] = @highlight_options[:fields]
@@ -485,52 +477,53 @@ module DatastaxRails
           params['hl.tag.pre'] = @highlight_options[:pre_tag] if @highlight_options[:pre_tag].present?
           params['hl.tag.post'] = @highlight_options[:post_tag] if @highlight_options[:post_tag].present?
         else
-          params['hl.mergeContiguous'] = !!@highlight_options[:merge_contiguous]
+          params['hl.mergeContiguous'] = @highlight_options[:merge_contiguous].present?
           params['hl.simple.pre'] = @highlight_options[:pre_tag] if @highlight_options[:pre_tag].present?
           params['hl.simple.post'] = @highlight_options[:post_tag] if @highlight_options[:post_tag].present?
         end
       end
-      
-      select_columns = select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
+
+      select_columns =
+        select_values.empty? ? (@klass.attribute_definitions.keys - @klass.lazy_attributes) : select_values.flatten
       select_columns << @klass.primary_key
-      select_columns.collect! {|c| @klass.column_for_attribute(c).try(:type) == :map ? "#{c.to_s}*" : c.to_s}
-      params[:fl] = select_columns.uniq.join(",")
-      unless(@stats_values.empty?)
+      select_columns.map! { |c| @klass.column_for_attribute(c).try(:type) == :map ? "#{c}*" : c.to_s }
+      params[:fl] = select_columns.uniq.join(',')
+      unless @stats_values.empty?
         params[:stats] = 'true'
         @stats_values.flatten.each do |sv|
           params['stats.field'] = sv
         end
-        if(@group_value)
-          params['stats.facet'] = @group_value
-        end
+        @params['stats.facet'] = @group_value
       end
       solr_response = nil
-      if(@group_value)
+      if @group_value
         results = DatastaxRails::GroupedCollection.new
         params[:group] = 'true'
-        params[:rows] = 10000
+        params[:rows] = 10_000
         params['group.field'] = @group_value
         params['group.limit'] = @per_page_value
         params['group.offset'] = (@page_value - 1) * @per_page_value
         params['group.ngroups'] = 'false' # must be false due to issues with solr sharding
-        solr_response = rsolr.post('select', :data => params)
-        response = solr_response["grouped"][@group_value.to_s]
+        solr_response = rsolr.post('select', data: params)
+        response = solr_response['grouped'][@group_value.to_s]
         results.total_groups = response['groups'].size
         results.total_for_all = response['matches'].to_i
         results.total_entries = 0
         response['groups'].each do |group|
           results[group['groupValue']] = parse_docs(group['doclist'], select_columns)
-          results.total_entries = results[group['groupValue']].total_entries if results[group['groupValue']].total_entries > results.total_entries
+          if results[group['groupValue']].total_entries > results.total_entries
+            results.total_entries = results[group['groupValue']].total_entries
+          end
         end
       else
-        solr_response = rsolr.paginate(@page_value, @per_page_value, 'select', :data => params, :method => :post)
-        response = solr_response["response"]
+        solr_response = rsolr.paginate(@page_value, @per_page_value, 'select', data: params, method: :post)
+        response = solr_response['response']
         pp solr_response if ENV['DEBUG_SOLR'] == 'true'
         results = parse_docs(response, select_columns)
         results.highlights = solr_response['highlighting']
       end
-      if solr_response["stats"]
-        @stats = solr_response["stats"]["stats_fields"].with_indifferent_access
+      if solr_response['stats']
+        @stats = solr_response['stats']['stats_fields'].with_indifferent_access
       end
       # Apply Facets if they exist
       if solr_response['facet_counts']
@@ -541,7 +534,7 @@ module DatastaxRails
       pp params if ENV['DEBUG_SOLR'] == 'true'
       results
     end
-    
+
     # Parse out a set of documents and return the results
     #
     # @param response [Hash] the response hash from SOLR with a set of documents
@@ -555,7 +548,7 @@ module DatastaxRails
       results.total_entries = response['numFound'].to_i
       response['docs'].each do |doc|
         id = @klass.attribute_definitions[@klass.primary_key].type_cast(doc[@klass.primary_key])
-        if(@consistency_value)
+        if @consistency_value
           obj = @klass.with_cassandra.consistency(@consistency_value).find_by_id(id)
           results << obj if obj
         else
@@ -565,7 +558,7 @@ module DatastaxRails
       results
     end
     protected(:parse_docs)
-    
+
     # Inspects the results of the search instead of the Relation itself.
     # Passing true causes the Relation to be inspected.
     #
@@ -573,7 +566,7 @@ module DatastaxRails
     def inspect(just_me = false)
       just_me ? super() : to_a.inspect
     end
-    
+
     # Scope all queries to the current scope.
     #
     # ==== Example
@@ -587,10 +580,10 @@ module DatastaxRails
     def scoping
       @klass.send(:with_scope, self, :overwrite) { yield }
     end
-    
+
     # Merges all of the where values together into a single hash
     def where_values_hash
-      where_values.inject({}) { |values,v| values.merge(v) }
+      where_values.reduce({}) { |a, e| a.merge(e) }
     end
 
     # Creates a scope that includes all of the where values plus anything
@@ -598,12 +591,12 @@ module DatastaxRails
     def scope_for_create
       @scope_for_create ||= where_values_hash.merge(create_with_value)
     end
-    
+
     # Sends a commit message to SOLR
     def commit_solr
-      rsolr.commit :commit_attributes => {}
+      rsolr.commit commit_attributes: {}
     end
-    
+
     SOLR_DATE_REGEX = /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)/i
     # Everything that gets indexed into solr is downcased as part of the analysis phase.
     # Normally, this is done to the query as well, but if your query includes wildcards
@@ -611,36 +604,38 @@ module DatastaxRails
     # We therefore need to perform the downcasing ourselves.  This does it while still
     # leaving boolean operations (AND, OR, NOT, TO) and dates upcased.
     def downcase_query(value)
-      if(value.is_a?(String))
-        value.split(/\bAND\b/).collect do |a|
-          a.split(/\bOR\b/).collect do |o| 
-            o.split(/\bNOT\b/).collect do |n|
-              n.split(/\bTO\b/).collect do |t|
+      # rubocop:disable Style/MultilineBlockChain
+      if value.is_a?(String)
+        value.split(/\bAND\b/).map do |a|
+          a.split(/\bOR\b/).map do |o|
+            o.split(/\bNOT\b/).map do |n|
+              n.split(/\bTO\b/).map do |t|
                 t.downcase
-              end.join("TO")
-            end.join("NOT")
-          end.join("OR")
-        end.join("AND").gsub(SOLR_DATE_REGEX) { $1.upcase }
+              end.join('TO')
+            end.join('NOT')
+          end.join('OR')
+        end.join('AND').gsub(SOLR_DATE_REGEX) { Regexp.last_match[1].upcase }
       else
         value
       end
+      # rubocop:enable Style/MultilineBlockChain
     end
-    
+
     protected
-      
-      def method_missing(method, *args, &block) #:nodoc:
-        if DatastaxRails::Collection.method_defined?(method)
-          to_a.send(method, *args, &block)
-        elsif @klass.respond_to?(method, true)
-          scoping { @klass.send(method, *args, &block) }
-        else
-          super
-        end
-      end
-      
-      # Calculates the solr URL and sets up an RSolr connection
-      def rsolr
-        @klass.solr_connection
+
+    def method_missing(method, *args, &block) #:nodoc:
+      if DatastaxRails::Collection.method_defined?(method)
+        to_a.send(method, *args, &block)
+      elsif @klass.respond_to?(method, true)
+        scoping { @klass.send(method, *args, &block) }
+      else
+        super
       end
+    end
+
+    # Calculates the solr URL and sets up an RSolr connection
+    def rsolr
+      @klass.solr_connection
+    end
   end
-end
+end