parse-stack 1.7.3 → 1.9.1

data/lib/parse/model/core/properties.rb

@@ -1,18 +1,17 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_model'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext'
-require 'active_support/core_ext/object'
-require 'active_support/inflector'
-require 'active_model_serializers'
-require 'active_support/inflector'
-require 'active_model_serializers'
-require 'active_support/hash_with_indifferent_access'
-require 'time'
-
+require "active_model"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext"
+require "active_support/core_ext/object"
+require "active_support/inflector"
+require "active_model_serializers"
+require "active_support/inflector"
+require "active_model_serializers"
+require "active_support/hash_with_indifferent_access"
+require "time"
 
 module Parse
 
@@ -22,15 +21,15 @@ module Parse
     # These are the base types supported by Parse.
     TYPES = [:string, :relation, :integer, :float, :boolean, :date, :array, :file, :geopoint, :bytes, :object, :acl, :timezone].freeze
     # These are the base mappings of the remote field name types.
-    BASE = {objectId: :string, createdAt: :date, updatedAt: :date, ACL: :acl}.freeze
+    BASE = { objectId: :string, createdAt: :date, updatedAt: :date, ACL: :acl }.freeze
     # The list of properties that are part of all objects
     BASE_KEYS = [:id, :created_at, :updated_at].freeze
     # Default hash map of local attribute name to remote column name
-    BASE_FIELD_MAP = {id: :objectId, created_at: :createdAt, updated_at: :updatedAt, acl: :ACL}.freeze
+    BASE_FIELD_MAP = { id: :objectId, created_at: :createdAt, updated_at: :updatedAt, acl: :ACL }.freeze
     # The delete operation hash.
-    CORE_FIELDS = {id: :string, created_at: :date, updated_at: :date, acl: :acl}.freeze
+    CORE_FIELDS = { id: :string, created_at: :date, updated_at: :date, acl: :acl }.freeze
     # The delete operation hash.
-    DELETE_OP = {"__op"=>"Delete"}.freeze
+    DELETE_OP = { "__op" => "Delete" }.freeze
     # @!visibility private
     def self.included(base)
       base.extend(ClassMethods)
@@ -49,7 +48,7 @@ module Parse
         @fields ||= (self == Parse::Object ? CORE_FIELDS : Parse::Object.fields).dup
         if type.present?
           type = type.to_sym
-          return @fields.select { |k,v| v == type }
+          return @fields.select { |k, v| v == type }
         end
         @fields
       end
@@ -101,7 +100,6 @@ module Parse
       # "myDate" (lower-first-camelcase) with a Parse data type of Date.
       # You can override the implicit naming behavior by passing the option :field to override.
       def property(key, data_type = :string, **opts)
-
         key = key.to_sym
         ivar = :"@#{key}"
         will_change_method = :"#{key}_will_change!"
@@ -125,25 +123,24 @@ module Parse
 
         # set defaults
         opts = { required: false,
-                 alias: true,
-                 symbolize: false,
-                 enum: nil,
-                 scopes: true,
-                 _prefix: nil,
-                 _suffix: false,
-                 field: key.to_s.camelize(:lower)
-               }.merge( opts )
+                alias: true,
+                symbolize: false,
+                enum: nil,
+                scopes: true,
+                _prefix: nil,
+                _suffix: false,
+                field: key.to_s.camelize(:lower) }.merge(opts)
         #By default, the remote field name is a lower-first-camelcase version of the key
         # it can be overriden by the :field parameter
         parse_field = opts[:field].to_sym
         # if this is a custom property that is already defined, OR it is a subclass trying to define a core property
         # then warn and exit.
-        if (self.fields[key].present? && BASE_FIELD_MAP[key].nil?) || ( self < Parse::Object && BASE_FIELD_MAP.has_key?(key) )
+        if (self.fields[key].present? && BASE_FIELD_MAP[key].nil?) || (self < Parse::Object && BASE_FIELD_MAP.has_key?(key))
           warn "Property #{self}##{key} already defined with data type :#{data_type}. Will be ignored."
           return false
         end
         # We keep the list of fields that are on the remote Parse store
-        if self.fields[parse_field].present? || ( self < Parse::Object && BASE.has_key?(parse_field) )
+        if self.fields[parse_field].present? || (self < Parse::Object && BASE.has_key?(parse_field))
           warn "Alias property #{self}##{parse_field} conflicts with previously defined property. Will be ignored."
           return false
           # raise ArgumentError
@@ -152,14 +149,14 @@ module Parse
         define_attribute_methods key
 
         # this hash keeps list of attributes (based on remote fields) and their data types
-        self.attributes.merge!( parse_field => data_type )
+        self.attributes.merge!(parse_field => data_type)
         # this maps all the possible attribute fields and their data types. We use both local
         # keys and remote keys because when we receive a remote object that has the remote field name
         # we need to know what the data type conversion should be.
-        self.fields.merge!( key => data_type, parse_field => data_type )
+        self.fields.merge!(key => data_type, parse_field => data_type)
         # This creates a mapping between the local field and the remote field name.
-        self.field_map.merge!( key => parse_field )
-        #puts "Current Self: #{self} - #{key} = #{self.attributes}"
+        self.field_map.merge!(key => parse_field)
+
         # if the field is marked as required, then add validations
         if opts[:required]
           # if integer or float, validate that it's a number
@@ -183,7 +180,6 @@ module Parse
         is_enum_type = opts[:enum].nil? == false
 
         if is_enum_type
-
           unless data_type == :string
             raise ArgumentError, "Property #{self}##{parse_field} :enum option is only supported on :string data types."
           end
@@ -196,7 +192,7 @@ module Parse
 
           enum_values = enum_values.dup.map(&:to_sym).freeze
 
-          self.enums.merge!( key => enum_values )
+          self.enums.merge!(key => enum_values)
           allow_nil = opts[:required] == false
           validates key, inclusion: { in: enum_values }, allow_nil: allow_nil
 
@@ -217,9 +213,7 @@ module Parse
 
             class_method_name = prefix_or_key.to_s.pluralize.to_sym
             if singleton_class.method_defined?(class_method_name)
-              raise ArgumentError, "You tried to define an enum named `#{key}` for #{self} " + \
-              "but this will generate a method  `#{self}.#{class_method_name}` " + \
-              " which is already defined. Try using :_suffix or :_prefix options."
+              raise ArgumentError, "You tried to define an enum named `#{key}` for #{self} " + "but this will generate a method  `#{self}.#{class_method_name}` " + " which is already defined. Try using :_suffix or :_prefix options."
             end
 
             define_singleton_method(class_method_name) { enum_values }
@@ -239,18 +233,14 @@ module Parse
               elsif prefix.present?
                 method_name = :"#{prefix}_#{enum}"
               end
-              self.scope method_name, ->(ex = {}){ ex.merge!(key => enum); query( ex )  }
-
+              self.scope method_name, ->(ex = {}) { ex.merge!(key => enum); query(ex) }
 
               define_method("#{method_name}!") { send set_attribute_method, enum, true }
               define_method("#{method_name}?") { enum == send(key).to_s.to_sym }
             end
           end # unless scopes
-
         end # if is enum
 
-
-
         symbolize_value = opts[:symbolize]
 
         #only support symbolization of string data types
@@ -271,7 +261,6 @@ module Parse
             # we'll assume it's just a plain literal value
             default_value.is_a?(Proc) ? default_value.call(self) : default_value
           end
-
         end
 
         # We define a getter with the key
@@ -295,12 +284,11 @@ module Parse
           # if value is nil (even after fetching), then lets see if the developer
           # set a default value for this attribute.
           if value.nil? && respond_to?("#{key}_default")
-
-             value = send("#{key}_default")
-             value = format_value(key, value, data_type)
+            value = send("#{key}_default")
+            value = format_value(key, value, data_type)
             # lets set the variable with the updated value
-             instance_variable_set ivar, value
-             send will_change_method
+            instance_variable_set ivar, value
+            send will_change_method
           elsif value.nil? && data_type == :array
             value = Parse::CollectionProxy.new [], delegate: self, key: key
             instance_variable_set ivar, value
@@ -318,12 +306,12 @@ module Parse
           end
           # finally return the value
           if symbolize_value
-              if data_type == :string
-                return value.respond_to?(:to_sym) ? value.to_sym : value
-              elsif data_type == :array && value.is_a?(Array)
-                # value.map(&:to_sym)
-                return value.compact.map { |m| m.respond_to?(:to_sym) ? m.to_sym : m }
-              end
+            if data_type == :string
+              return value.respond_to?(:to_sym) ? value.to_sym : value
+            elsif data_type == :array && value.is_a?(Array)
+              # value.map(&:to_sym)
+              return value.compact.map { |m| m.respond_to?(:to_sym) ? m.to_sym : m }
+            end
           end
 
           value
@@ -338,7 +326,7 @@ module Parse
           # returns true if set to true, false otherwise
           define_method("#{key}?") { (send(key) == true) }
           unless opts[:scopes] == false
-            scope key, ->(opts = {}){ query( opts.merge(key => true) ) }
+            scope key, ->(opts = {}) { query(opts.merge(key => true)) }
           end
         elsif data_type == :integer || data_type == :float
           if self.method_defined?("#{key}_increment!")
@@ -359,7 +347,7 @@ module Parse
           end
 
           if self.method_defined?("#{key}_decrement!")
-            puts "Creating decrement helper :#{key}_decrement!. Will overwrite existing method #{self}##{key}_decrement!."
+            warn "Creating decrement helper :#{key}_decrement!. Will overwrite existing method #{self}##{key}_decrement!."
           end
 
           define_method("#{key}_decrement!") do |amount = -1|
@@ -369,7 +357,6 @@ module Parse
             amount = -amount if amount > 0
             send("#{key}_increment!", amount)
           end
-
         end
 
         # The second method to be defined is a setter method. This is done by
@@ -393,7 +380,7 @@ module Parse
           # this will grab the current value and keep a copy of it - but we only do this if
           # the new value being set is different from the current value stored.
           if track == true
-            send will_change_method unless val == instance_variable_get( ivar )
+            send will_change_method unless val == instance_variable_get(ivar)
           end
 
           if symbolize_value
@@ -435,7 +422,6 @@ module Parse
         end
         true
       end # property
-
     end #ClassMethods
 
     # @return [Hash] a hash mapping of all property fields and their types.
@@ -451,7 +437,7 @@ module Parse
     # TODO: We can optimize
     # @return [Hash] returns the list of property attributes for this class.
     def attributes
-      {__type: :string, :className => :string}.merge!(self.class.attributes)
+      { __type: :string, :className => :string }.merge!(self.class.attributes)
     end
 
     # support for setting a hash of attributes on the object with a given dirty tracking value
@@ -466,7 +452,7 @@ module Parse
       @id ||= hash[Parse::Model::ID] || hash[Parse::Model::OBJECT_ID] || hash[:objectId]
       hash.each do |key, value|
         method = "#{key}_set_attribute!".freeze
-        send(method, value, dirty_track) if respond_to?( method )
+        send(method, value, dirty_track) if respond_to?(method)
       end
     end
 
@@ -494,7 +480,7 @@ module Parse
         next unless fields[key].present?
         remote_field = self.field_map[key] || key
         h[remote_field] = send key
-        h[remote_field] = {__op: :Delete} if h[remote_field].nil?
+        h[remote_field] = { __op: :Delete } if h[remote_field].nil?
         # in the case that the field is a Parse object, generate a pointer
         # if it is a Parse::PointerCollectionProxy, then make sure we get a list of pointers.
         h[remote_field] = h[remote_field].parse_pointers if h[remote_field].is_a?(Parse::PointerCollectionProxy)
@@ -509,6 +495,7 @@ module Parse
         fields[key.to_sym].present?
       end
     end
+
     # Returns a formatted value based on the operation hash and data_type of the property.
     # For some values in Parse, they are specified as operation hashes which could include
     # Add, Remove, Delete, AddUnique and Increment.
@@ -585,7 +572,7 @@ module Parse
         val = val.to_f unless val.blank?
       when :acl
         # ACL types go through a special conversion
-          val = ACL.typecast(val, self)
+        val = ACL.typecast(val, self)
       when :date
         # if it respond to parse_date, then use that as the conversion.
         if val.respond_to?(:parse_date) && val.is_a?(Parse::Date) == false
@@ -596,9 +583,9 @@ module Parse
         elsif val.is_a?(String)
           # if it's a string, try parsing the date
           val = Parse::Date.parse val
-        #elsif val.present?
-        #  pus "[Parse::Stack] Invalid date value '#{val}' assigned to #{self.class}##{key}, it should be a Parse::Date or DateTime."
-        #   raise ValueError, "Invalid date value '#{val}' assigned to #{self.class}##{key}, it should be a Parse::Date or DateTime."
+          #elsif val.present?
+          #  pus "[Parse::Stack] Invalid date value '#{val}' assigned to #{self.class}##{key}, it should be a Parse::Date or DateTime."
+          #   raise ValueError, "Invalid date value '#{val}' assigned to #{self.class}##{key}, it should be a Parse::Date or DateTime."
         end
       when :timezone
         val = Parse::TimeZone.new(val) if val.present?
@@ -613,7 +600,5 @@ module Parse
       end
       val
     end
-
   end # Properties
-
 end # Parse

data/lib/parse/model/core/querying.rb

@@ -1,320 +1,330 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require_relative '../../query'
+require_relative "../../query"
 
 module Parse
   module Core
     # Defines the querying methods applied to a Parse::Object.
     module Querying
 
-        # This feature is a small subset of the
-        # {http://guides.rubyonrails.org/active_record_querying.html#scopes
-        # ActiveRecord named scopes} feature. Scoping allows you to specify
-        # commonly-used queries which can be referenced as class method calls and
-        # are chainable with other scopes. You can use every {Parse::Query}
-        # method previously covered such as `where`, `includes` and `limit`.
-        #
-        #  class Article < Parse::Object
-        #    property :published, :boolean
-        #    scope :published, -> { query(published: true) }
-        #  end
-        #
-        # This is the same as defining your own class method for the query.
-        #
-        #  class Article < Parse::Object
-        #    def self.published
-        #      query(published: true)
-        #    end
-        #  end
-        #
-        # You can also chain scopes and pass parameters. In addition, boolean and
-        # enumerated properties have automatically generated scopes for you to use.
-        #
-        #  class Article < Parse::Object
-        #    scope :published, -> { query(published: true) }
-        #
-        #    property :comment_count, :integer
-        #    property :category
-        #    property :approved, :boolean
-        #
-        #    scope :published_and_commented, -> { published.where :comment_count.gt => 0 }
-        #    scope :popular_topics, ->(name) { published_and_commented.where category: name }
-        #  end
-        #
-        #  # simple scope
-        #  Article.published # => where published is true
-        #
-        #  # chained scope
-        #  Article.published_and_commented # published is true and comment_count > 0
-        #
-        #  # scope with parameters
-        #  Article.popular_topic("music") # => popular music articles
-        #  # equivalent: where(published: true, :comment_count.gt => 0, category: name)
-        #
-        #  # automatically generated scope
-        #  Article.approved(category: "tour") # => where approved: true, category: 'tour'
-        #
-        # If you would like to turn off automatic scope generation for property types,
-        # set the option `:scope` to false when declaring the property.
-        # @param name [Symbol] the name of the scope.
-        # @param body [Proc] the proc related to the scope.
-        # @raise ArgumentError if body parameter does not respond to `call`
-        # @return [Symbol] the name of the singleton method created.
-        def scope(name, body)
-          unless body.respond_to?(:call)
-            raise ArgumentError, 'The scope body needs to be callable.'
-          end
-
-          name = name.to_sym
-          if respond_to?(name, true)
-            puts "Creating scope :#{name}. Will overwrite existing method #{self}.#{name}."
-          end
+      # This feature is a small subset of the
+      # {http://guides.rubyonrails.org/active_record_querying.html#scopes
+      # ActiveRecord named scopes} feature. Scoping allows you to specify
+      # commonly-used queries which can be referenced as class method calls and
+      # are chainable with other scopes. You can use every {Parse::Query}
+      # method previously covered such as `where`, `includes` and `limit`.
+      #
+      #  class Article < Parse::Object
+      #    property :published, :boolean
+      #    scope :published, -> { query(published: true) }
+      #  end
+      #
+      # This is the same as defining your own class method for the query.
+      #
+      #  class Article < Parse::Object
+      #    def self.published
+      #      query(published: true)
+      #    end
+      #  end
+      #
+      # You can also chain scopes and pass parameters. In addition, boolean and
+      # enumerated properties have automatically generated scopes for you to use.
+      #
+      #  class Article < Parse::Object
+      #    scope :published, -> { query(published: true) }
+      #
+      #    property :comment_count, :integer
+      #    property :category
+      #    property :approved, :boolean
+      #
+      #    scope :published_and_commented, -> { published.where :comment_count.gt => 0 }
+      #    scope :popular_topics, ->(name) { published_and_commented.where category: name }
+      #  end
+      #
+      #  # simple scope
+      #  Article.published # => where published is true
+      #
+      #  # chained scope
+      #  Article.published_and_commented # published is true and comment_count > 0
+      #
+      #  # scope with parameters
+      #  Article.popular_topic("music") # => popular music articles
+      #  # equivalent: where(published: true, :comment_count.gt => 0, category: name)
+      #
+      #  # automatically generated scope
+      #  Article.approved(category: "tour") # => where approved: true, category: 'tour'
+      #
+      # If you would like to turn off automatic scope generation for property types,
+      # set the option `:scope` to false when declaring the property.
+      # @param name [Symbol] the name of the scope.
+      # @param body [Proc] the proc related to the scope.
+      # @raise ArgumentError if body parameter does not respond to `call`
+      # @return [Symbol] the name of the singleton method created.
+      def scope(name, body)
+        unless body.respond_to?(:call)
+          raise ArgumentError, "The scope body needs to be callable."
+        end
 
-          define_singleton_method(name) do |*args, &block|
+        name = name.to_sym
+        if respond_to?(name, true)
+          puts "Creating scope :#{name}. Will overwrite existing method #{self}.#{name}."
+        end
 
-            if body.arity.zero?
-              res = body.call
-              res.conditions(*args) if args.present?
-            else
-              res = body.call(*args)
-            end
+        define_singleton_method(name) do |*args, &block|
+          if body.arity.zero?
+            res = body.call
+            res.conditions(*args) if args.present?
+          else
+            res = body.call(*args)
+          end
 
-            _q = res || query
+          _q = res || query
 
-            if _q.is_a?(Parse::Query)
-              klass = self
-              _q.define_singleton_method(:method_missing) do |m, *args, &chained_block|
-                if klass.respond_to?(m, true)
-                  # must be a scope
-                  klass_scope = klass.send(m, *args)
-                  if klass_scope.is_a?(Parse::Query)
-                    # merge constraints
-                    add_constraints( klass_scope.constraints )
-                    # if a block was passed, execute the query, otherwise return the query
-                    return chained_block.present? ? results(&chained_block) : self
-                  end # if
-                  klass = nil # help clean up ruby gc
-                  return klass_scope
-                end
+          if _q.is_a?(Parse::Query)
+            klass = self
+            _q.define_singleton_method(:method_missing) do |m, *args, &chained_block|
+              if klass.respond_to?(m, true)
+                # must be a scope
+                klass_scope = klass.send(m, *args)
+                if klass_scope.is_a?(Parse::Query)
+                  # merge constraints
+                  add_constraints(klass_scope.constraints)
+                  # if a block was passed, execute the query, otherwise return the query
+                  return chained_block.present? ? results(&chained_block) : self
+                end # if
                 klass = nil # help clean up ruby gc
-                return results.send(m, *args, &chained_block)
+                return klass_scope
               end
+              klass = nil # help clean up ruby gc
+              return results.send(m, *args, &chained_block)
             end
-
-            Parse::Query.apply_auto_introspection!(_q)
-
-            return _q if block.nil?
-            _q.results(&block)
           end
 
-        end
+          Parse::Query.apply_auto_introspection!(_q)
 
-
-        # Creates a new {Parse::Query} with the given constraints for this class.
-        # @example
-        #  # assume Post < Parse::Object
-        #  query = Post.query(:updated_at.before => DateTime.now)
-        # @return [Parse::Query] a new query with the given constraints for this
-        #  Parse::Object subclass.
-        def query(constraints = {})
-          Parse::Query.new self.parse_class, constraints
-        end; alias_method :where, :query
-
-        # @param conditions (see Parse::Query#where)
-        # @return (see Parse::Query#where)
-        # @see Parse::Query#where
-        def literal_where(conditions = {})
-          query.where(conditions)
+          return _q if block.nil?
+          _q.results(&block)
         end
+      end
 
-        # This methods allow you to efficiently iterate over all the records in the collection
-        # (lower memory cost) at a minor cost of performance. This method utilizes
-        # the `created_at` field of Parse records to order and iterate over *all* matching records,
-        # therefore you should not use this method if you want to perform a query
-        # with constraints against the `created_at` field or need specific type of ordering.
-        # If you need to use `:created_at` in your constraints, consider using {Parse::Core::Querying#all} or
-        # {Parse::Core::Actions::ClassMethods#save_all}
-        # @param constraints [Hash] a set of query constraints.
-        # @yield a block which will iterate through each matching record.
-        # @example
-        #
-        #  post = Post.first
-        #  # iterate over all comments matching conditions
-        #  Comment.each(post: post) do |comment|
-        #     # ...
-        #  end
-        # @return [Parse::Object] the last Parse::Object record processed.
-        # @note You cannot use *:created_at* as a constraint.
-        # @raise ArgumentError if :created_at is detected in the constraints argument.
-        # @see Parse::Core::Querying.all
-        # @see Parse::Core::Actions.save_all
-        def each(constraints = {}, &block)
-          # verify we don't hvae created at as a constraint, otherwise this will not work
-          invalid_constraints = constraints.keys.any? do |k|
-            (k == :created_at || k == :createdAt) ||
-            ( k.is_a?(Parse::Operation) && (k.operand == :created_at || k.operand == :createdAt) )
-          end
-          if invalid_constraints
-            raise ArgumentError, "[#{self.class}.each] Special method each()" \
-                                 "cannot be used with a :created_at constraint."
-          end
-          batch_size = 250
-          start_cursor = first( order: :created_at.asc, keys: :created_at )
-          constraints.merge! cache: false, limit: batch_size, order: :created_at.asc
-          all_query = query(constraints)
-          cursor = start_cursor
-          # the exclusion set is a set of ids not to include the next query.
-          exclusion_set = []
-          loop do
-            _q = query(constraints.dup)
-            _q.where(:created_at.on_or_after => cursor.created_at)
-            # set of ids not to include in the next query. non-performant, but accurate.
-            _q.where(:id.nin => exclusion_set) unless exclusion_set.empty?
-            results = _q.results # get results
+      # Creates a new {Parse::Query} with the given constraints for this class.
+      # @example
+      #  # assume Post < Parse::Object
+      #  query = Post.query(:updated_at.before => DateTime.now)
+      # @return [Parse::Query] a new query with the given constraints for this
+      #  Parse::Object subclass.
+      def query(constraints = {})
+        Parse::Query.new self.parse_class, constraints
+      end; 
+      alias_method :where, :query
 
-            break cursor if results.empty? # break if no results
-            results.each(&block)
-            next_cursor = results.last
-            # break if we got less than the maximum requested
-            break next_cursor if results.count < batch_size
-            # break if the next object is the same as the current object.
-            break next_cursor if cursor.id == next_cursor.id
-            # The exclusion set is used in the case where multiple records have the exact
-            # same created_at date (down to the microsecond). This prevents getting the same
-            # record in the next query request.
-            exclusion_set = results.select { |r| r.created_at == next_cursor.created_at }.map(&:id)
-            results = nil
-            cursor = next_cursor
-          end
+      # @param conditions (see Parse::Query#where)
+      # @return (see Parse::Query#where)
+      # @see Parse::Query#where
+      def literal_where(conditions = {})
+        query.where(conditions)
+      end
 
+      # This methods allow you to efficiently iterate over all the records in the collection
+      # (lower memory cost) at a minor cost of performance. This method utilizes
+      # the `created_at` field of Parse records to order and iterate over *all* matching records,
+      # therefore you should not use this method if you want to perform a query
+      # with constraints against the `created_at` field or need specific type of ordering.
+      # If you need to use `:created_at` in your constraints, consider using {Parse::Core::Querying#all} or
+      # {Parse::Core::Actions::ClassMethods#save_all}
+      # @param constraints [Hash] a set of query constraints.
+      # @yield a block which will iterate through each matching record.
+      # @example
+      #
+      #  post = Post.first
+      #  # iterate over all comments matching conditions
+      #  Comment.each(post: post) do |comment|
+      #     # ...
+      #  end
+      # @return [Parse::Object] the last Parse::Object record processed.
+      # @note You cannot use *:created_at* as a constraint.
+      # @raise ArgumentError if :created_at is detected in the constraints argument.
+      # @see Parse::Core::Querying.all
+      # @see Parse::Core::Actions.save_all
+      def each(constraints = {}, &block)
+        # verify we don't hvae created at as a constraint, otherwise this will not work
+        invalid_constraints = constraints.keys.any? do |k|
+          (k == :created_at || k == :createdAt) ||
+          (k.is_a?(Parse::Operation) && (k.operand == :created_at || k.operand == :createdAt))
         end
-
-        # Fetch all matching objects in this collection matching the constraints.
-        # This will be the most common way when querying Parse objects for a subclass.
-        # When no block is passed, all objects are returned. Using a block is more memory
-        # efficient as matching objects are fetched in batches and discarded after the iteration
-        # is completed.
-        # @param constraints [Hash] a set of {Parse::Query} constraints.
-        # @yield a block to iterate with each matching object.
-        # @example
-        #
-        #  songs = Song.all( ... expressions ...) # => array of Parse::Objects
-        #  # memory efficient for large amounts of records.
-        #  Song.all( ... expressions ...) do |song|
-        #      # ... do something with song..
-        #  end
-        #
-        # @note This method will continually query for records by automatically
-        #   incrementing the *:skip* parameter until no more results are returned
-        #   by the server.
-        # @return [Array<Parse::Object>] an array of matching objects. If a block is passed,
-        #  an empty array is returned.
-        def all(constraints = {limit: :max})
-          constraints = constraints.reverse_merge({limit: :max})
-          prepared_query = query(constraints)
-          return prepared_query.results(&Proc.new) if block_given?
-          prepared_query.results
+        if invalid_constraints
+          raise ArgumentError, "[#{self.class}.each] Special method each()" \
+                               "cannot be used with a :created_at constraint."
         end
+        batch_size = 250
+        start_cursor = first(order: :created_at.asc, keys: :created_at)
+        constraints.merge! cache: false, limit: batch_size, order: :created_at.asc
+        all_query = query(constraints)
+        cursor = start_cursor
+        # the exclusion set is a set of ids not to include the next query.
+        exclusion_set = []
+        loop do
+          _q = query(constraints.dup)
+          _q.where(:created_at.on_or_after => cursor.created_at)
+          # set of ids not to include in the next query. non-performant, but accurate.
+          _q.where(:id.nin => exclusion_set) unless exclusion_set.empty?
+          results = _q.results # get results
 
-        # Returns the first item matching the constraint.
-        # @overload first(count = 1)
-        #  @param count [Interger] The number of items to return.
-        #  @example
-        #   Object.first(2) # => an array of the first 2 objects in the collection.
-        #  @return [Parse::Object] if count == 1
-        #  @return [Array<Parse::Object>] if count > 1
-        # @overload first(constraints = {})
-        #  @param constraints [Hash] a set of {Parse::Query} constraints.
-        #  @example
-        #   Object.first( :name => "Anthony" )
-        #  @return [Parse::Object] the first matching object.
-        def first(constraints = {})
-          fetch_count = 1
-          if constraints.is_a?(Numeric)
-            fetch_count = constraints.to_i
-            constraints = {}
-          end
-          constraints.merge!( {limit: fetch_count} )
-          res = query(constraints).results
-          return res.first if fetch_count == 1
-          return res.first fetch_count
+          break cursor if results.empty? # break if no results
+          results.each(&block)
+          next_cursor = results.last
+          # break if we got less than the maximum requested
+          break next_cursor if results.count < batch_size
+          # break if the next object is the same as the current object.
+          break next_cursor if cursor.id == next_cursor.id
+          # The exclusion set is used in the case where multiple records have the exact
+          # same created_at date (down to the microsecond). This prevents getting the same
+          # record in the next query request.
+          exclusion_set = results.select { |r| r.created_at == next_cursor.created_at }.map(&:id)
+          results = nil
+          cursor = next_cursor
         end
+      end
 
-        # Creates a count request which is more performant when counting objects.
-        # @example
-        #  # number of songs with a like count greater than 20.
-        #  count = Song.count( :like_count.gt => 20 )
-        # @param constraints (see #all)
-        # @return [Interger] the number of records matching the query.
-        # @see Parse::Query#count
-        def count(constraints = {})
-          query(constraints).count
-        end
+      # Fetch all matching objects in this collection matching the constraints.
+      # This will be the most common way when querying Parse objects for a subclass.
+      # When no block is passed, all objects are returned. Using a block is more memory
+      # efficient as matching objects are fetched in batches and discarded after the iteration
+      # is completed.
+      # @param constraints [Hash] a set of {Parse::Query} constraints.
+      # @yield a block to iterate with each matching object.
+      # @example
+      #
+      #  songs = Song.all( ... expressions ...) # => array of Parse::Objects
+      #  # memory efficient for large amounts of records.
+      #  Song.all( ... expressions ...) do |song|
+      #      # ... do something with song..
+      #  end
+      #
+      # @note This method will continually query for records by automatically
+      #   incrementing the *:skip* parameter until no more results are returned
+      #   by the server.
+      # @return [Array<Parse::Object>] an array of matching objects. If a block is passed,
+      #  an empty array is returned.
+      def all(constraints = { limit: :max })
+        constraints = constraints.reverse_merge({ limit: :max })
+        prepared_query = query(constraints)
+        return prepared_query.results(&Proc.new) if block_given?
+        prepared_query.results
+      end
 
-        # Find objects matching the constraint ordered by the descending created_at date.
-        # @param constraints (see #all)
-        # @return [Array<Parse::Object>]
-        def newest(constraints = {})
-          constraints.merge!(order: :created_at.desc)
-          _q = query(constraints)
-          _q.define_singleton_method(:method_missing) { |m, *args, &block| self.results.send(m, *args, &block) }
-          _q
+      # Returns the first item matching the constraint.
+      # @overload first(count = 1)
+      #  @param count [Interger] The number of items to return.
+      #  @example
+      #   Object.first(2) # => an array of the first 2 objects in the collection.
+      #  @return [Parse::Object] if count == 1
+      #  @return [Array<Parse::Object>] if count > 1
+      # @overload first(constraints = {})
+      #  @param constraints [Hash] a set of {Parse::Query} constraints.
+      #  @example
+      #   Object.first( :name => "Anthony" )
+      #  @return [Parse::Object] the first matching object.
+      def first(constraints = {})
+        fetch_count = 1
+        if constraints.is_a?(Numeric)
+          fetch_count = constraints.to_i
+          constraints = {}
         end
+        constraints.merge!({ limit: fetch_count })
+        res = query(constraints).results
+        return res.first if fetch_count == 1
+        return res.first fetch_count
+      end
 
-        # Find objects matching the constraint ordered by the ascending created_at date.
-        # @param constraints (see #all)
-        # @return [Array<Parse::Object>]
-        def oldest(constraints = {})
-          constraints.merge!(order: :created_at.asc)
-          _q = query(constraints)
-          _q.define_singleton_method(:method_missing) { |m, *args, &block| self.results.send(m, *args, &block) }
-          _q
-        end
+      # Creates a count request which is more performant when counting objects.
+      # @example
+      #  # number of songs with a like count greater than 20.
+      #  count = Song.count( :like_count.gt => 20 )
+      # @param constraints (see #all)
+      # @return [Interger] the number of records matching the query.
+      # @see Parse::Query#count
+      def count(constraints = {})
+        query(constraints).count
+      end
 
-        # Find objects for a given objectId in this collection.The result is a list
-        # (or single item) of the objects that were successfully found.
-        # @example
-        #  Object.find "<objectId>"
-        #  Object.find "<objectId>", "<objectId>"....
-        #  Object.find ["<objectId>", "<objectId>"]
-        # @param parse_ids [String] the objectId to find.
-        # @param type [Symbol] the fetching methodology to use if more than one id was passed.
-        #  - *:parallel* : Utilizes parrallel HTTP requests to fetch all objects requested.
-        #  - *:batch* : This uses a batch fetch request using a contained_in clause.
-        # @param compact [Boolean] whether to remove nil items from the returned array for objects
-        #  that were not found.
-        # @return [Parse::Object] if only one id was provided as a parameter.
-        # @return [Array<Parse::Object>] if more than one id was provided as a parameter.
-        def find(*parse_ids, type: :parallel, compact: true)
-          # flatten the list of Object ids.
-          parse_ids.flatten!
-          parse_ids.compact!
-          # determines if the result back to the call site is an array or a single result
-          as_array = parse_ids.count > 1
-          results = []
+      # Finds the distinct values for a specified field across a single
+      # collection or view and returns the results in an array.
+      # @example
+      #  # get a list of unique city names for users who are older than 21.
+      #  cities = User.distinct(:city, :age.gt => 21 )
+      # @param field The name of the field to use for unique aggregation.
+      # @param constraints (see #all)
+      # @return [Array] a list of distinct values
+      # @see Parse::Query#distinct
+      def distinct(field, constraints = {})
+        query(constraints).distinct(field)
+      end
 
-          if type == :batch
-            # use a .in query with the given id as a list
-            results = self.class.all(:id.in => parse_ids)
-          else
-            # use Parallel to make multiple threaded requests for finding these objects.
-            # The benefit of using this as default is that each request goes to a specific URL
-            # which is better than Query request (table scan). This in turn allows for caching of
-            # individual objects.
-            results = parse_ids.threaded_map do |parse_id|
-              next nil unless parse_id.present?
-              response = client.fetch_object(parse_class, parse_id)
-              next nil if response.error?
-              Parse::Object.build response.result, parse_class
-            end
-          end
-          # removes any nil items in the array
-          results.compact! if compact
+      # Find objects matching the constraint ordered by the descending created_at date.
+      # @param constraints (see #all)
+      # @return [Array<Parse::Object>]
+      def newest(constraints = {})
+        constraints.merge!(order: :created_at.desc)
+        _q = query(constraints)
+        _q.define_singleton_method(:method_missing) { |m, *args, &block| self.results.send(m, *args, &block) }
+        _q
+      end
+
+      # Find objects matching the constraint ordered by the ascending created_at date.
+      # @param constraints (see #all)
+      # @return [Array<Parse::Object>]
+      def oldest(constraints = {})
+        constraints.merge!(order: :created_at.asc)
+        _q = query(constraints)
+        _q.define_singleton_method(:method_missing) { |m, *args, &block| self.results.send(m, *args, &block) }
+        _q
+      end
 
-          as_array ? results : results.first
-        end; alias_method :get, :find
+      # Find objects for a given objectId in this collection.The result is a list
+      # (or single item) of the objects that were successfully found.
+      # @example
+      #  Object.find "<objectId>"
+      #  Object.find "<objectId>", "<objectId>"....
+      #  Object.find ["<objectId>", "<objectId>"]
+      # @param parse_ids [String] the objectId to find.
+      # @param type [Symbol] the fetching methodology to use if more than one id was passed.
+      #  - *:parallel* : Utilizes parrallel HTTP requests to fetch all objects requested.
+      #  - *:batch* : This uses a batch fetch request using a contained_in clause.
+      # @param compact [Boolean] whether to remove nil items from the returned array for objects
+      #  that were not found.
+      # @return [Parse::Object] if only one id was provided as a parameter.
+      # @return [Array<Parse::Object>] if more than one id was provided as a parameter.
+      def find(*parse_ids, type: :parallel, compact: true)
+        # flatten the list of Object ids.
+        parse_ids.flatten!
+        parse_ids.compact!
+        # determines if the result back to the call site is an array or a single result
+        as_array = parse_ids.count > 1
+        results = []
+
+        if type == :batch
+          # use a .in query with the given id as a list
+          results = self.class.all(:id.in => parse_ids)
+        else
+          # use Parallel to make multiple threaded requests for finding these objects.
+          # The benefit of using this as default is that each request goes to a specific URL
+          # which is better than Query request (table scan). This in turn allows for caching of
+          # individual objects.
+          results = parse_ids.threaded_map do |parse_id|
+            next nil unless parse_id.present?
+            response = client.fetch_object(parse_class, parse_id)
+            next nil if response.error?
+            Parse::Object.build response.result, parse_class
+          end
+        end
+        # removes any nil items in the array
+        results.compact! if compact
 
+        as_array ? results : results.first
+      end; 
+      alias_method :get, :find
     end # Querying
   end
 end