datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/railtie.rb

@@ -10,31 +10,31 @@ module DatastaxRails
       'DatastaxRails::RecordNotFound' => :not_found,
       'DatastaxRails::RecordInvalid'  => :unprocessable_entity,
       'DatastaxRails::RecordNotSaved' => :unprocessable_entity)
-    
+
     initializer 'datastax_rails.init' do
       ActiveSupport.on_load(:datastax_rails) do
       end
-      datastax_config = ERB.new(Rails.root.join('config',"datastax.yml").read).result(binding)
+      datastax_config = ERB.new(Rails.root.join('config', 'datastax.yml').read).result(binding)
       config = YAML.load(datastax_config)
       unless config[Rails.env]
-        raise "ERROR: datastax.yml does not define a configuration for #{Rails.env} environment"
+        fail "ERROR: datastax.yml does not define a configuration for #{Rails.env} environment"
       end
       DatastaxRails::Base.establish_connection(config[Rails.env].with_indifferent_access)
       if defined?(PhusionPassenger)
         PhusionPassenger.on_event(:starting_worker_process) do |forked|
           if forked
-             DatastaxRails::Base.establish_connection(config[Rails.env].with_indifferent_access)
+            DatastaxRails::Base.establish_connection(config[Rails.env].with_indifferent_access)
           end
         end
       end
     end
-    
+
     rake_tasks do
       load 'datastax_rails/tasks/ds.rake'
     end
-    
+
     # generators do
-      # require 'datastax_rails/generators/migration_generator'
+    # require 'datastax_rails/generators/migration_generator'
     # end
   end
 end

data/lib/datastax_rails/reflection.rb

@@ -21,7 +21,7 @@ module DatastaxRails
       def create_reflection(macro, name, options, datastax_rails)
         klass = options[:through] ? ThroughReflection : AssociationReflection
         reflection = klass.new(macro, name, options, datastax_rails)
-        self.reflections = self.reflections.merge(name => reflection)
+        self.reflections = reflections.merge(name => reflection)
         reflection
       end
 
@@ -55,7 +55,6 @@ module DatastaxRails
       end
     end
 
-
     # Abstract base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
     class MacroReflection
@@ -78,7 +77,7 @@ module DatastaxRails
       attr_reader :options
 
       attr_reader :datastax_rails
-      
+
       # Returns a hash of all the denormalizations for this relationship (if any)
       attr_reader :denorms
 
@@ -110,12 +109,12 @@ module DatastaxRails
 
       # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +datastax_rails+ attribute,
       # and +other_aggregation+ has an options hash assigned to it.
-      def ==(other_aggregation)
+      def ==(other)
         super ||
-          other_aggregation.kind_of?(self.class) &&
-          name == other_aggregation.name &&
-          other_aggregation.options &&
-          datastax_rails == other_aggregation.datastax_rails
+          other.is_a?(self.class) &&
+          name == other.name &&
+          other.options &&
+          datastax_rails == other.datastax_rails
       end
 
       # XXX: Do we need to sanitize our query?
@@ -124,14 +123,20 @@ module DatastaxRails
       end
 
       private
-        def derive_class_name
-          name.to_s.camelize
-        end
+
+      def derive_class_name
+        name.to_s.camelize
+      end
     end
 
     # Holds all the meta-data about an association as it was specified in the
     # DatastaxRails class.
     class AssociationReflection < MacroReflection
+      # Returns whether or not this association reflection is for a collection
+      # association. Returns +true+ if the +macro+ is either +has_many+ or
+      # +has_and_belongs_to_many+, +false+ otherwise.
+      attr_reader :collection
+      alias_method :collection?, :collection
       # Returns the target association's class.
       #
       #   class Author < DatastaxRails::Base
@@ -147,7 +152,7 @@ module DatastaxRails
       def klass
         @klass ||= datastax_rails.send(:compute_type, class_name)
       end
-      
+
       def initialize(macro, name, options, datastax_rails)
         super
         @collection = macro.in?([:has_many, :has_and_belongs_to_many])
@@ -185,11 +190,11 @@ module DatastaxRails
 
       # klass option is necessary to support loading polymorphic associations
       # def association_primary_key(klass = nil)
-        # options[:primary_key] || primary_key(klass || self.klass)
+      # options[:primary_key] || primary_key(klass || self.klass)
       # end
-# 
+      #
       # def datastax_rails_primary_key
-        # @datastax_rails_primary_key ||= options[:primary_key] || primary_key(solandra_object)
+      # @datastax_rails_primary_key ||= options[:primary_key] || primary_key(solandra_object)
       # end
 
       def check_validity!
@@ -197,10 +202,9 @@ module DatastaxRails
       end
 
       def check_validity_of_inverse!
-        unless options[:polymorphic]
-          if has_inverse? && inverse_of.nil?
-            raise InverseOfAssociationNotFoundError.new(self)
-          end
+        return if options[:polymorphic]
+        if inverse? && inverse_of.nil?
+          fail InverseOfAssociationNotFoundError.new(self)
         end
       end
 
@@ -225,25 +229,18 @@ module DatastaxRails
         [[options[:conditions]].compact]
       end
 
-      alias :source_macro :macro
+      alias_method :source_macro, :macro
 
-      def has_inverse?
+      def inverse?
         @options[:inverse_of]
       end
 
       def inverse_of
-        if has_inverse?
+        if inverse?
           @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
         end
       end
 
-      # Returns whether or not this association reflection is for a collection
-      # association. Returns +true+ if the +macro+ is either +has_many+ or
-      # +has_and_belongs_to_many+, +false+ otherwise.
-      def collection?
-        @collection
-      end
-
       # Returns whether or not the association should be validated as part of
       # the parent's validation.
       #
@@ -284,32 +281,33 @@ module DatastaxRails
       end
 
       private
-        def derive_class_name
-          class_name = name.to_s.camelize
-          class_name = class_name.singularize if collection?
-          class_name
-        end
 
-        def derive_foreign_key
-          if belongs_to?
-            "#{name}_id"
-          elsif options[:as]
-            "#{options[:as]}_id"
-          else
-            datastax_rails.name.foreign_key
-          end
+      def derive_class_name
+        class_name = name.to_s.camelize
+        class_name = class_name.singularize if collection?
+        class_name
+      end
+
+      def derive_foreign_key
+        if belongs_to?
+          "#{name}_id"
+        elsif options[:as]
+          "#{options[:as]}_id"
+        else
+          datastax_rails.name.foreign_key
         end
+      end
 
-        # def primary_key(klass)
-          # klass.key || raise(UnknownPrimaryKey.new(klass))
-        # end
+      # def primary_key(klass)
+      # klass.key || raise(UnknownPrimaryKey.new(klass))
+      # end
     end
-    
+
     # Holds all the meta-data about a :through association as it was specified
     # in the DatastaxRails class.
     class ThroughReflection < AssociationReflection #:nodoc:
       delegate :foreign_key, :foreign_type, :association_foreign_key,
-               :datastax_rails_primary_key, :type, :to => :source_reflection
+               :datastax_rails_primary_key, :type, to: :source_reflection
 
       # Gets the source of the through reflection.  It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
@@ -320,7 +318,9 @@ module DatastaxRails
       #   end
       #
       def source_reflection
-        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+        @source_reflection ||= source_reflection_names.map do |name|
+          through_reflection.klass.reflect_on_association(name)
+        end.compact.first
       end
 
       # Returns the AssociationReflection object specified in the <tt>:through</tt> option
@@ -423,7 +423,8 @@ module DatastaxRails
       #   [:singularized, :pluralized]
       #
       def source_reflection_names
-        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+        @source_reflection_names ||=
+          (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).map { |n| n.to_sym }
       end
 
       def source_options
@@ -436,37 +437,38 @@ module DatastaxRails
 
       def check_validity!
         if through_reflection.nil?
-          raise HasManyThroughAssociationNotFoundError.new(datastax_rails.name, self)
+          fail HasManyThroughAssociationNotFoundError.new(datastax_rails.name, self)
         end
 
         if through_reflection.options[:polymorphic]
-          raise HasManyThroughAssociationPolymorphicThroughError.new(datastax_rails.name, self)
+          fail HasManyThroughAssociationPolymorphicThroughError.new(datastax_rails.name, self)
         end
 
         if source_reflection.nil?
-          raise HasManyThroughSourceAssociationNotFoundError.new(self)
+          fail HasManyThroughSourceAssociationNotFoundError.new(self)
         end
 
         if options[:source_type] && source_reflection.options[:polymorphic].nil?
-          raise HasManyThroughAssociationPointlessSourceTypeError.new(datastax_rails.name, self, source_reflection)
+          fail HasManyThroughAssociationPointlessSourceTypeError.new(datastax_rails.name, self, source_reflection)
         end
 
         if source_reflection.options[:polymorphic] && options[:source_type].nil?
-          raise HasManyThroughAssociationPolymorphicSourceError.new(datastax_rails.name, self, source_reflection)
+          fail HasManyThroughAssociationPolymorphicSourceError.new(datastax_rails.name, self, source_reflection)
         end
 
         if macro == :has_one && through_reflection.collection?
-          raise HasOneThroughCantAssociateThroughCollection.new(datastax_rails.name, self, through_reflection)
+          fail HasOneThroughCantAssociateThroughCollection.new(datastax_rails.name, self, through_reflection)
         end
 
         check_validity_of_inverse!
       end
 
       private
-        def derive_class_name
-          # get the class_name of the belongs_to association of the through reflection
-          options[:source_type] || source_reflection.class_name
-        end
+
+      def derive_class_name
+        # get the class_name of the belongs_to association of the through reflection
+        options[:source_type] || source_reflection.class_name
+      end
     end
   end
 end

data/lib/datastax_rails/relation/batches.rb

@@ -25,12 +25,12 @@ module DatastaxRails
         records.each { |record| yield record }
       end
     end
-    
+
     # Same as {find_each} but yields the index as a second parameter.
     def find_each_with_index(options = {})
       idx = 0
       find_in_batches(options) do |records|
-        records.each do |record| 
+        records.each do |record|
           yield record, idx
           idx += 1
         end
@@ -50,7 +50,7 @@ module DatastaxRails
     #
     # It's not possible to set the order. For Cassandra based batching, the
     # order is set according to Cassandra's key placement strategy. For Solr
-    # based batching, the order is ascending order of the primary key. 
+    # based batching, the order is ascending order of the primary key.
     # You can't set the limit either. That's used to control the batch sizes.
     #
     # Example:
@@ -65,20 +65,21 @@ module DatastaxRails
     def find_in_batches(options = {})
       relation = self
 
-      unless (@order_values.empty?)
-        DatastaxRails::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+      unless @order_values.empty?
+        DatastaxRails::Base.logger.warn('Scoped order and limit are ignored, ' \
+                                        "it's forced to be batch order and batch size")
       end
 
       if (finder_options = options.except(:start, :batch_size)).present?
-        raise "You can't specify an order, it's forced to be #{@klass.primary_key}" if options[:order].present?
-        raise "You can't specify a limit, it's forced to be the batch_size" if options[:limit].present?
+        fail "You can't specify an order, it's forced to be #{@klass.primary_key}" if options[:order].present?
+        fail "You can't specify a limit, it's forced to be the batch_size" if options[:limit].present?
 
         relation = apply_finder_options(finder_options)
       end
 
       start = options.delete(:start)
       batch_size = options.delete(:batch_size) || 1000
-      
+
       relation = relation.limit(batch_size)
       relation = relation.order(@klass.primary_key) if relation.use_solr_value
       records = start ? relation.where(@klass.primary_key).greater_than(start).to_a : relation.to_a
@@ -89,14 +90,12 @@ module DatastaxRails
 
         break if records_size < batch_size
         if offset
-          if relation.use_solr_value
-            offset = ::Cql::Uuid.new(offset.value+1)
-          end
+          offset = ::Cql::Uuid.new(offset.value + 1) if relation.use_solr_value
           records = relation.where(@klass.primary_key).greater_than(offset).to_a
         else
-          raise "Batch order not included in the custom select clause"
+          fail 'Batch order not included in the custom select clause'
         end
       end
     end
   end
-end
+end

data/lib/datastax_rails/relation/facet_methods.rb

@@ -3,24 +3,27 @@ module DatastaxRails
     # Instructs SOLR to get facet counts on the passed in field.  Results are available in the facets accessor.
     # Facets include Field and Range (Date is not supported as it is depricated in Solr - use a range instead).
     #
-    # results = Article.field_facet(:author)
-    # results.facets => {"author"=>["vonnegut", 2. "asimov", 3]} 
+    #   results = Article.field_facet(:author)
+    #   results.facets => {"author"=>["vonnegut", 2. "asimov", 3]}
     #
-    # Model.field_facet(:author)
-    # Model.field_facet(:author, :sort => 'count', :limit => 10, :mincount => 1)
-    # Model.range_facet(:price, 500, 1000, 10)
-    # Model.range_facet(:price, 500, 1000, 10, :include => 'all')
-    # Model.range_facet(:publication_date, "1968-01-01T00:00:00Z", "2000-01-01T00:00:00Z", "+1YEAR")
+    #   Model.field_facet(:author)
+    #   Model.field_facet(:author, :sort => 'count', :limit => 10, :mincount => 1)
+    #   Model.range_facet(:price, 500, 1000, 10)
+    #   Model.range_facet(:price, 500, 1000, 10, :include => 'all')
+    #   Model.range_facet(:publication_date, "1968-01-01T00:00:00Z", "2000-01-01T00:00:00Z", "+1YEAR")
     #
     # Range Gap syntax for dates: +1YEAR, +5YEAR, +5YEARS, +1MONTH, +1DAY
     #
     # Useful constants:
     #
-    # DatastaxRails::FacetMethods::BY_YEAR  (+1YEAR)
-    # DatastaxRails::FacetMethods::BY_MONTH (+1MONTH)
-    # DatastaxRails::FacetMethods::BY_DAY   (+1DAY)
+    #   DatastaxRails::FacetMethods::BY_YEAR  (+1YEAR)
+    #   DatastaxRails::FacetMethods::BY_MONTH (+1MONTH)
+    #   DatastaxRails::FacetMethods::BY_DAY   (+1DAY)
     #
-    # Model.range_facet(:publication_date, "1968-01-01T00:00:00Z", "2000-01-01T00:00:00Z", DatastaxRails::FacetMethods::BY_YEAR)
+    #   Model.range_facet(:publication_date,
+    #                     "1968-01-01T00:00:00Z",
+    #                     "2000-01-01T00:00:00Z",
+    #                     DatastaxRails::FacetMethods::BY_YEAR)
     #
     # These method can be called multiple times to facet on different fields
     #
@@ -29,40 +32,48 @@ module DatastaxRails
     # @return [DatastaxRails::Relation] a new Relation object
     #
     # Field Facet Option Values:
-    # prefix: [String] Facet prefix
-    # limit: [Number] Facet result limit (Solr defaults to 100)
-    # sort: [String: count | index] Sort Order (Solr defaults to index, unless a limit is specified, then defaults to index)
-    # offset: [Number] Facet result offset (Solr defaults to 0)
-    # mincount [Number] Facet minimum number of occurances before including in the result set (Solr defaults to 0)
+    # * prefix: [String] Facet prefix
+    # * limit: [Number] Facet result limit (Solr defaults to 100)
+    # * sort: [String: count | index] Sort Order (Solr defaults to index, unless a limit is specified,
+    #   then defaults to index)
+    # * offset: [Number] Facet result offset (Solr defaults to 0)
+    # * mincount [Number] Facet minimum number of occurances before including in the result set (Solr defaults to 0)
+    #
     # Note: You can pass any valid facet option value, and it will be passed to Solr
-    # 
+    #
     # Range Facet Option Values:
-    # start [String] Range start
-    # end: [String] Range end value
-    # gap: [String] Range gap (see examples above)
-    # include [String: lower | upper | edge | outer | all] (Solr defaults to lower) include / exclude upper and lower range values
-    # other [String: before | after | between | none | all] include / exclude counts
+    # * start [String] Range start
+    # * end: [String] Range end value
+    # * gap: [String] Range gap (see examples above)
+    # * include: [String: lower | upper | edge | outer | all] (Solr defaults to lower)
+    # include / exclude upper and lower range values
+    # * other: [String: before | after | between | none | all] include / exclude counts
+    #
     # Note: You can pass any valid facet option value, and it will be passed to Solr
-    #    
+    #
     # Date Facet? - use Range Facet! They were depricated in Solr 3
-    
-    BY_YEAR = "+1YEAR"
-    BY_MONTH = "+1MONTH"
-    BY_DAY = "+1DAY"
-    
+
+    BY_YEAR = '+1YEAR'
+    BY_MONTH = '+1MONTH'
+    BY_DAY = '+1DAY'
+
     def field_facet(field, options = {})
       return self if field.blank?
       clone.tap do |r|
-        r.field_facet_values << {:field => field.to_s, :options => options}
+        r.field_facet_values << { field: field.to_s, options: options }
       end
     end
-    
+
     def range_facet(field, start_range, end_range, gap, options = {})
       return self if field.blank?
       clone.tap do |r|
-        r.range_facet_values << {:field => field.to_s, :options => options.merge(:start => start_range.to_s, :end => end_range.to_s, :gap => gap.to_s)}
+        r.range_facet_values << { field:   field.to_s,
+                                  options: options.merge(start: start_range.to_s,
+                                                         end:   end_range.to_s,
+                                                         gap:   gap.to_s
+                                                         )
+                                }
       end
     end
-  
   end
-end
+end