parse-stack 1.5.3 → 1.6.0

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

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext'
+require_relative '../object'
+
+module Parse
+  # Create all Parse::Object subclasses, including their properties and inferred
+  # associations by importing the schema for the remote collections in a Parse
+  # application. Uses the default configured client.
+  # @return [Array] an array of created Parse::Object subclasses.
+  # @see Parse::Model::Builder.build!
+  def self.auto_generate_models!
+    Parse.schemas.map do |schema|
+      Parse::Model::Builder.build!(schema)
+    end
+  end
+
+  class Model
+    # This class provides a method to automatically generate Parse::Object subclasses, including
+    # their properties and inferred associations by importing the schema for the remote collections
+    # in a Parse application.
+    class Builder
+
+      # Builds a ruby Parse::Object subclass with the provided schema information.
+      # @param schema [Hash] the Parse-formatted hash schema for a collection. This hash
+      #  should two keys:
+      #  * className: Contains the name of the collection.
+      #  * field: A hash containg the column fields and their type.
+      # @raise ArgumentError when the className could not be inferred from the schema.
+      # @return [Array] an array of Parse::Object subclass constants.
+      def self.build!(schema)
+        unless schema.is_a?(Hash)
+          raise ArgumentError, "Schema parameter should be a Parse schema hash object."
+        end
+        schema = schema.with_indifferent_access
+        fields = schema[:fields] || {}
+        className = schema[:className]
+
+        if className.blank?
+          raise ArgumentError, "No valid className provided for schema hash"
+        end
+
+        begin
+          klass = Parse::Model.find_class className
+          klass = ::Object.const_get(className.to_parse_class) if klass.nil?
+        rescue => e
+          klass = ::Class.new(Parse::Object)
+          ::Object.const_set(className, klass)
+        end
+
+        base_fields = Parse::Properties::BASE.keys
+        class_fields = klass.field_map.values + [:className]
+        fields.each do |field, type|
+          field = field.to_sym
+          key = field.to_s.underscore.to_sym
+          next if base_fields.include?(field) || class_fields.include?(field)
+
+          data_type = type[:type].downcase.to_sym
+          if data_type == :pointer
+            klass.belongs_to key, as: type[:targetClass],  field: field
+          elsif data_type == :relation
+            klass.has_many key, as: type[:targetClass],  field: field
+          else
+            klass.property key, data_type, field: field
+          end
+          class_fields.push(field)
+        end
+        klass
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# The set of all Parse errors.
+module Parse
+  # An abstract parent class for all Parse::Error types.
+  class Error < StandardError; end
+
+end

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

@@ -1,54 +1,58 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 require 'time'
 require 'parallel'
 
 module Parse
-  # Defines the record fetching interface for instances of Parse::Object.
-  module Fetching
+  # Combines a set of core functionality for {Parse::Object} and its subclasses.
+  module Core
+    # Defines the record fetching interface for instances of Parse::Object.
+    module Fetching
+
+      # Force fetches and updates the current object with the data contained in the Parse collection.
+      # The changes applied to the object are not dirty tracked.
+      # @param opts [Hash] a set of options to pass to the client request.
+      # @return [self] the current object, useful for chaining.
+      def fetch!(opts = {})
+        response = client.fetch_object(parse_class, id, opts)
+        if response.error?
+          puts "[Fetch Error] #{response.code}: #{response.error}"
+        end
+        # take the result hash and apply it to the attributes.
+        apply_attributes!(response.result, dirty_track: false)
+        clear_changes!
+        self
+      end
 
-    # Force fetches and updates the current object with the data contained in the Parse collection.
-    # The changes applied to the object are not dirty tracked.
-    # @param opts [Hash] a set of options to pass to the client request.
-    # @return [self] the current object, useful for chaining.
-    def fetch!(opts = {})
-      response = client.fetch_object(parse_class, id, opts)
-      if response.error?
-        puts "[Fetch Error] #{response.code}: #{response.error}"
+      # Fetches the object from the Parse data store if the object is in a Pointer
+      # state. This is similar to the `fetchIfNeeded` action in the standard Parse client SDK.
+      # @return [self] the current object.
+      def fetch
+        # if it is a pointer, then let's go fetch the rest of the content
+        pointer? ? fetch! : self
       end
-      # take the result hash and apply it to the attributes.
-      apply_attributes!(response.result, dirty_track: false)
-      clear_changes!
-      self
-    end
 
-    # Fetches the object from the Parse data store if the object is in a Pointer
-    # state. This is similar to the `fetchIfNeeded` action in the standard Parse client SDK.
-    # @return [self] the current object.
-    def fetch
-      # if it is a pointer, then let's go fetch the rest of the content
-      pointer? ? fetch! : self
-    end
+      # Autofetches the object based on a key that is not part {Parse::Properties::BASE_KEYS}.
+      # If the key is not a Parse standard key, and the current object is in a
+      # Pointer state, then fetch the data related to this record from the Parse
+      # data store.
+      # @param key [String] the name of the attribute being accessed.
+      # @return [Boolean]
+      def autofetch!(key)
+        key = key.to_sym
+        @fetch_lock ||= false
+        if @fetch_lock != true && pointer? && key != :acl && Parse::Properties::BASE_KEYS.include?(key) == false && respond_to?(:fetch)
+          #puts "AutoFetching Triggerd by: #{self.class}.#{key} (#{id})"
+          @fetch_lock = true
+          send :fetch
+          @fetch_lock = false
+        end
 
-    # Autofetches the object based on a key that is not part {Parse::Properties::BASE_KEYS}.
-    # If the key is not a Parse standard key, and the current object is in a
-    # Pointer state, then fetch the data related to this record from the Parse
-    # data store.
-    # @param key [String] the name of the attribute being accessed.
-    # @return [Boolean]
-    def autofetch!(key)
-      key = key.to_sym
-      @fetch_lock ||= false
-      if @fetch_lock != true && pointer? && key != :acl && Parse::Properties::BASE_KEYS.include?(key) == false && respond_to?(:fetch)
-        #puts "AutoFetching Triggerd by: #{self.class}.#{key} (#{id})"
-        @fetch_lock = true
-        send :fetch
-        @fetch_lock = false
       end
 
     end
-
   end
-
 end
 
 

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

@@ -19,10 +19,6 @@ module Parse
   # This module provides support for handling all the different types of column data types
   # supported in Parse and mapping them between their remote names with their local ruby named attributes.
   module Properties
-    # This is an exception that is thrown if there is an issue when creating a specific property for a class.
-    class DefinitionError < StandardError; end;
-    class ValueError < StandardError; end;
-
     # These are the base types supported by Parse.
     TYPES = [:id, :string, :relation, :integer, :float, :boolean, :date, :array, :file, :geopoint, :bytes, :object, :acl].freeze
     # These are the base mappings of the remote field name types.
@@ -31,13 +27,15 @@ module Parse
     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
-
+    # The delete operation hash.
     DELETE_OP = {"__op"=>"Delete"}.freeze
 
+    # @!visibility private
     def self.included(base)
       base.extend(ClassMethods)
     end
 
+    # The class methods added to Parse::Objects
     module ClassMethods
 
       # The fields method returns a mapping of all local attribute names and their data type.
@@ -64,7 +62,8 @@ module Parse
         @enums ||= {}
       end
 
-      # Keeps track of all the attributes supported by this class.
+      # Set the property fields for this class.
+      # @return [Hash]
       def attributes=(hash)
         @attributes = BASE.merge(hash)
       end
@@ -74,6 +73,7 @@ module Parse
         @attributes ||= BASE.dup
       end
 
+      # @return [Array] the list of fields that have defaults.
       def defaults_list
         @defaults_list ||= []
       end
@@ -111,7 +111,8 @@ module Parse
 
         # allow :bool for :boolean
         data_type = :boolean if data_type == :bool
-        data_type = :integer if data_type == :int
+        data_type = :geopoint if data_type == :geo_point
+        data_type = :integer if data_type == :int || data_type == :number
 
         # set defaults
         opts = { required: false,
@@ -127,11 +128,11 @@ module Parse
         # it can be overriden by the :field parameter
         parse_field = opts[:field].to_sym
         if self.fields[key].present? && BASE_FIELD_MAP[key].nil?
-          raise DefinitionError, "Property #{self}##{key} already defined with data type #{data_type}"
+          raise ArgumentError, "Property #{self}##{key} already defined with data type #{data_type}"
         end
         # We keep the list of fields that are on the remote Parse store
         if self.fields[parse_field].present?
-          raise DefinitionError, "Alias property #{self}##{parse_field} conflicts with previously defined property."
+          raise ArgumentError, "Alias property #{self}##{parse_field} conflicts with previously defined property."
         end
         #dirty tracking. It is declared to use with ActiveModel DirtyTracking
         define_attribute_methods key
@@ -161,12 +162,12 @@ module Parse
         if is_enum_type
 
           unless data_type == :string
-            raise DefinitionError, "Property #{self}##{parse_field} :enum option is only supported on :string data types."
+            raise ArgumentError, "Property #{self}##{parse_field} :enum option is only supported on :string data types."
           end
 
           enum_values = opts[:enum]
           unless enum_values.is_a?(Array) && enum_values.empty? == false
-            raise DefinitionError, "Property #{self}##{parse_field} :enum option must be an Array type of symbols."
+            raise ArgumentError, "Property #{self}##{parse_field} :enum option must be an Array type of symbols."
           end
           opts[:symbolize] = true
 
@@ -181,11 +182,11 @@ module Parse
             # If the passed value is true, the methods are prefixed/suffixed with the name of the enum. It is also possible to supply a custom value:
             prefix = opts[:_prefix]
             unless opts[:_prefix].nil? || prefix.is_a?(Symbol) || prefix.is_a?(String)
-              raise DefinitionError, "Enumeration option :_prefix must either be a symbol or string for #{self}##{key}."
+              raise ArgumentError, "Enumeration option :_prefix must either be a symbol or string for #{self}##{key}."
             end
 
             unless opts[:_suffix].is_a?(TrueClass) || opts[:_suffix].is_a?(FalseClass)
-              raise DefinitionError, "Enumeration option :_suffix must either be true or false for #{self}##{key}."
+              raise ArgumentError, "Enumeration option :_suffix must either be true or false for #{self}##{key}."
             end
 
             add_suffix = opts[:_suffix] == true
@@ -193,7 +194,7 @@ module Parse
 
             class_method_name = prefix_or_key.to_s.pluralize.to_sym
             if singleton_class.method_defined?(class_method_name)
-              raise DefinitionError, "You tried to define an enum named `#{key}` for #{self} " + \
+              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
@@ -229,7 +230,7 @@ module Parse
 
         #only support symbolization of string data types
         if symbolize_value && (data_type == :string || data_type == :array) == false
-          raise DefinitionError, "Tried to symbolize #{self}##{key}, but it is only supported on :string or :array data types."
+          raise ArgumentError, "Tried to symbolize #{self}##{key}, but it is only supported on :string or :array data types."
         end
 
         # Here is the where the 'magic' begins. For each property defined, we will
@@ -300,7 +301,7 @@ module Parse
         # support question mark methods for boolean
         if data_type == :boolean
           if self.method_defined?("#{key}?")
-            puts "Creating boolean helper :#{key}?. Will overwrite existing method #{self}##{key}_increment!."
+            puts "Creating boolean helper :#{key}?. Will overwrite existing method #{self}##{key}?."
           end
 
           # returns true if set to true, false otherwise
@@ -406,23 +407,28 @@ module Parse
 
     end #ClassMethods
 
-    # returns the class level stored field map
+    # @return [Hash] a hash mapping of all property fields and their types.
     def field_map
       self.class.field_map
     end
 
-    # returns the list of fields
+    # @return returns the list of fields
     def fields(type = nil)
       self.class.fields(type)
     end
 
     # 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)
     end
 
     # support for setting a hash of attributes on the object with a given dirty tracking value
     # if dirty_track: is set to false (default), attributes are set without dirty tracking.
+    # Allos mass assignment of properties with a provided hash.
+    # @param hash [Hash] the hash matching the property field names.
+    # @param dirty_track [Boolean] whether dirty tracking be enabled
+    # @return [Hash]
     def apply_attributes!(hash, dirty_track: false)
       return unless hash.is_a?(Hash)
 
@@ -433,8 +439,8 @@ module Parse
       end
     end
 
-    # applies a hash of attributes overriding any current value the object has for those
-    # attributes
+    # Supports mass assignment of attributes
+    # @return (see #apply_attributes!)
     def attributes=(hash)
       return unless hash.is_a?(Hash)
       # - [:id, :objectId]
@@ -442,12 +448,14 @@ module Parse
       apply_attributes!(hash, dirty_track: true)
     end
 
-    # returns a hash of attributes (and their new values) that had been changed.
-    # This will not include any of the base attributes (ex. id, created_at, etc)
-    # If true is passed as an argument, then all attributes will be included.
-    # This method is useful for generating an update hash for the Parse PUT API
-    # TODO: Replace this algorithm with reduce()
+    # Returns a hash of attributes for properties that have changed. This will
+    # not include any of the base attributes (ex. id, created_at, etc).
+    # This method helps generate the change payload that will be sent when saving
+    # objects to Parse.
+    # @param include_all [Boolean] whether to include all {Parse::Properties::BASE_KEYS} attributes.
+    # @return [Hash]
     def attribute_updates(include_all = false)
+      # TODO: Replace this algorithm with reduce()
       h = {}
       changed.each do |key|
         key = key.to_sym
@@ -464,13 +472,19 @@ module Parse
       h
     end
 
-    # determines if any of the attributes have changed.
+    # @return [Boolean] true if any of the attributes have changed.
     def attribute_changes?
       changed.any? do |key|
         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.
+    # @param key [Symbol] the name of the property
+    # @param val [Hash] the Parse operation hash value.
+    # @param data_type [Symbol] The data type of the property.
+    # @return [Object]
     def format_operation(key, val, data_type)
       return val unless val.is_a?(Hash) && val["__op"].present?
       op = val["__op"]
@@ -496,6 +510,11 @@ module Parse
 
     # this method takes an input value and transforms it to the proper local format
     # depending on the data type that was set for a particular property key.
+    # Return the internal representation of a property value for a given data type.
+    # @param key [Symbol] the name of the property
+    # @param val [Object] the value to format.
+    # @param data_type [Symbol] provide a hint to the data_type of this value.
+    # @return [Object]
     def format_value(key, val, data_type = nil)
       # if data_type wasn't passed, then get the data_type from the fields hash
       data_type ||= self.fields[key]

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

@@ -4,249 +4,252 @@
 require_relative '../../query'
 
 module Parse
-  # 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
+  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
+          name = name.to_sym
+          if respond_to?(name, true)
+            puts "Creating scope :#{name}. Will overwrite existing method #{self}.#{name}."
+          end
 
-        define_singleton_method(name) do |*args, &block|
+          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
+            if body.arity.zero?
+              res = body.call
+              res.conditions(*args) if args.present?
+            else
+              res = body.call(*args)
+            end
 
-          _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
+            _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
                 klass = nil # help clean up ruby gc
-                return klass_scope
+                return results.send(m, *args, &chained_block)
               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
-          return _q if block.nil?
-          _q.results(&block)
+
+        end
+
+
+        # 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)
         end
 
-      end
-
-
-      # 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)
-      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
-      #
-      # @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
-
-      # 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 = {}
+        # 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
+        #
+        # @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
-        constraints.merge!( {limit: fetch_count} )
-        res = query(constraints).results
-        return res.first if fetch_count == 1
-        return res.first fetch_count
-      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 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
-
-      # 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
+
+        # 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
-        # removes any nil items in the array
-        results.compact! if compact
 
-        as_array ? results : results.first
-      end; alias_method :get, :find
+        # 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 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
 
-  end # Querying
+        # 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
+
+        # 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