parse-stack 1.7.0 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48e731586682a18f7800110c166f20536c46b717
-  data.tar.gz: e5cd663b12a7935acb772ff881ca471709de076b
+  metadata.gz: 3557dd1c97f0f227d848732708916d3428563d22
+  data.tar.gz: b71256968073f1318cb5c88665c551e6e6f7381c
 SHA512:
-  metadata.gz: 79a487df290f8e3f7efc843b8f7b079fccd5dee56e52f3821a20f75f3b391675da33ce03e23a01ed9c442305017d2cee5e1d6dcfb52074bca218ee5f8f986044
-  data.tar.gz: b54958ad9b82dd8fddc10b6c1701e20eea11701482d27403cc92c41e4db883573feb77a9ab17915738092b940ee319a6b6c394f7afa6d7360790d1b916d524b9
+  metadata.gz: 78d5ee17c4c2a9b8488ef6e37a8e6eeedf82e195b4369423e2694a784c4ff8cd41ba73d945cbdaa863ec094f6b1a1f4df5b26a6b8e28ae56401dfaf988b138d1
+  data.tar.gz: 86e596121613d31532aee9cd67fa8e5691ccbdcba7de01f11cfc0e3731b61e43cfde29a91137665e537aa448897af37dc21ea1b83bdc7908d7617065de1a8b93

data/Changes.md

@@ -1,5 +1,23 @@
 ## Parse-Stack Changelog
 
+### 1.7.1
+- NEW: `:timezone` datatype that maps to `Parse::TimeZone` (which mimics `ActiveSupport::TimeZone`)
+- NEW: Installation `:time_zone` field is now a `Parse::TimeZone` instance.
+- Any properties named `time_zone` or `timezone` with a string data type set will be converted to use `Parse::TimeZone` as the data class.
+- FIXED: Fixes issues with HTTP Method Override for long url queries.
+- FIXED: Fixes issue with Parse::Object.each method signature.
+- FIXED: Removed `:id` from the Parse::Properties::TYPES list.
+- FIXED: Parse::Object subclasses will not be allowed to redefine core properties.
+- Parse::Object save_all() and each() methods raise ArgumentError for
+  invalid constraint arguments.
+- Removes deprecated function `Role.apply_default_acls`. If you need the previous
+  behavior, you should set your own :before_save callback that modifies the role
+  object with the ACLs that you want or use the new `Role.set_default_acl`.
+- Parse::Object.property returns true/false whether creating the property was successful.
+- Parse::Session now has a `has_one` association to Installation through `:installation`
+- Parse::User now has a `has_many` association to Sessions through `:active_sessions`
+- Parse::Installation now has a `has_one` association to Session through `:session`
+
 ### 1.7.0
 - NEW: You can use `set_default_acl` to set default ACLs for your subclasses.
 - NEW: Support for `withinPolygon` query constraint.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parse-stack (1.7.0)
+    parse-stack (1.7.1)
       active_model_serializers (>= 0.9, < 1)
       activemodel (>= 4.2.1, < 6)
       activesupport (>= 4.2.1, < 6)
@@ -14,15 +14,15 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (5.1.1)
-      actionview (= 5.1.1)
-      activesupport (= 5.1.1)
+    actionpack (5.1.2)
+      actionview (= 5.1.2)
+      activesupport (= 5.1.2)
       rack (~> 2.0)
       rack-test (~> 0.6.3)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (5.1.1)
-      activesupport (= 5.1.1)
+    actionview (5.1.2)
+      activesupport (= 5.1.2)
       builder (~> 3.1)
       erubi (~> 1.4)
       rails-dom-testing (~> 2.0)
@@ -32,9 +32,9 @@ GEM
       activemodel (>= 4.1, < 6)
       case_transform (>= 0.2)
       jsonapi-renderer (>= 0.1.1.beta1, < 0.2)
-    activemodel (5.1.1)
-      activesupport (= 5.1.1)
-    activesupport (5.1.1)
+    activemodel (5.1.2)
+      activesupport (= 5.1.2)
+    activesupport (5.1.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (~> 0.7)
       minitest (~> 5.1)
@@ -50,7 +50,7 @@ GEM
     daemons (1.2.4)
     debug_inspector (0.0.3)
     dotenv (2.2.1)
-    erubi (1.6.0)
+    erubi (1.6.1)
     eventmachine (1.2.3)
     faraday (0.12.1)
       multipart-post (>= 1.2, < 3)
@@ -89,7 +89,7 @@ GEM
     redcarpet (3.4.0)
     redis (3.3.3)
     slop (3.6.0)
-    thin (1.7.0)
+    thin (1.7.1)
       daemons (~> 1.0, >= 1.0.9)
       eventmachine (~> 1.0, >= 1.0.4)
       rack (>= 1, < 3)

data/README.md

@@ -153,6 +153,7 @@ result = Parse.call_function :myFunctionName, {param: value}
   - [Parse::GeoPoint](#parsegeopoint)
     - [Calculating Distances between locations](#calculating-distances-between-locations)
   - [Parse::Bytes](#parsebytes)
+  - [Parse::TimeZone](#parsetimezone)
   - [Parse::ACL](#parseacl)
   - [Parse::Session](#parsesession)
   - [Parse::Installation](#parseinstallation)
@@ -517,7 +518,7 @@ This class manages dates in the special JSON format it requires for properties o
 
 One important note with dates, is that `created_at` and `updated_at` columns do not follow this convention all the time. Depending on the Cloud Code SDK, they can be the Parse ISO hash date format or the `iso8601` string format. By default, these are serialized as `iso8601` when sent as responses to Parse for backwards compatibility with some clients. To use the Parse ISO hash format for these fields instead, set `Parse::Object.disable_serialized_string_date = true`.
 
-### Parse::GeoPoint
+### [Parse::GeoPoint](https://www.modernistik.com/gems/parse-stack/Parse/GeoPoint.html)
 This class manages the GeoPoint data type that Parse provides to support geo-queries. To define a GeoPoint property, use the `:geopoint` data type. Please note that latitudes should not be between -90.0 and 90.0, and longitudes should be between -180.0 and 180.0.
 
 ```ruby
@@ -561,6 +562,29 @@ The `Bytes` data type represents the storage format for binary content in a Pars
   decoded = bytes.decoded # same as Base64.decode64
 ```
 
+### [Parse::TimeZone](https://www.modernistik.com/gems/parse-stack/Parse/TimeZone.html)
+While Parse does not provide a native time zone data type, Parse-Stack provides a class to make it easier to manage time zone attributes, usually stored IANA string identifiers, with your ruby code. This is done by utilizing the features provided by [`ActiveSupport::TimeZone`](http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html). In addition to setting a column as a time zone field, we also add special validations to verify it is of the right IANA identifier.
+
+```ruby
+class Event < Parse::Object
+  # an event occurs in a time zone.
+  property :time_zone, :timezone, default: 'America/Los_Angeles'
+end
+
+event = Event.new
+event.time_zone.name # => 'America/Los_Angeles'
+event.time_zone.valid? # => true
+
+event.time_zone.zone # => ActiveSupport::TimeZone
+event.time_zone.formatted_offset # => "-08:00"
+
+event.time_zone = 'Europe/Paris'
+event.time_zone.formatted_offset # => +01:00"
+
+event.time_zone = 'Galaxy/Andromeda'
+event.time_zone.valid? # => false
+```
+
 ### [Parse::ACL](https://www.modernistik.com/gems/parse-stack/Parse/ACL.html)
 The `ACL` class represents the access control lists for each record. An ACL is represented by a JSON object with the keys being `Parse::User` object ids or the special key of `*`, which indicates the public access permissions.
 The value of each key in the hash is a `Parse::ACL::Permission` object which defines the boolean permission state for `read` and `write`.
@@ -771,6 +795,7 @@ Properties are considered a literal-type of association. This means that a defin
 - **:float** - a floating numeric value. Will also generate atomic `_increment!` helper method.
 - **:boolean** (alias **:bool**) - true/false value. This will also generate a class scope helper. See [Query Scopes](#query-scopes).
 - **:date** - a Parse date type. See [Parse::Date](#parsedate).
+- **:timezone** - a time zone object. See [Parse::TimeZone](#parsetimezone).
 - **:array** - a heterogeneous list with dirty tracking. See [Parse::CollectionProxy](https://github.com/modernistik/parse-stack/blob/master/lib/parse/model/associations/collection_proxy.rb).
 - **:file** - a Parse file type. See [Parse::File](#parsefile).
 - **:geopoint** - a GeoPoint type. See [Parse::GeoPoint](#parsegeopoint).
@@ -810,7 +835,7 @@ class Post < Parse::Object
   # a list using
   property :tags, :array
 
-  # string column as enummerated type. see :enum
+  # string column as enumerated type. see :enum
   property :status, enum: [:active, :archived]
 
   # Maps to "featuredImage" column representing a File.
@@ -821,6 +846,9 @@ class Post < Parse::Object
   # Support bytes
   property :data, :bytes
 
+  # A field that contains time zone information (ex. 'America/Los_Angeles')
+  property :time_zone, :timezone
+
   # store SEO information. Make sure we map it to the column
   # "SEO", otherwise it would have implicitly used "seo"
   # as the remote column name
@@ -1264,6 +1292,38 @@ band.op_destroy!("category") # { __op: :Delete }
 
 ```
 
+You can also perform queries against class entities to find related objects. Assume
+that users can like a band. The `Band` class can have a `likes` column that is
+a Parse relation to the `Parse::User` class containing the users who have liked a
+specific band.
+
+```ruby
+  # assume the schema
+  class Band < Parse::Object
+    # likes is a Parse relation column of user objects.
+    has_many :likes, through: :relation, as: :user
+  end
+```
+
+You can now find all `Parse::User` records who have liked a specific band. *In the
+example below, the `:likes` key refers to the `likes` column defined in the `Band`
+collection which contains the set of user records.*
+
+```ruby
+  band = Band.first # get a band
+  # find all users who have liked this band, where :likes is a column
+  # in the Band collection - NOT in the User collection.
+  users = Parse::User.all :likes.related_to => band
+```
+You can also find all bands that a specific user has liked.
+
+```ruby
+  user = Parse::User.first
+  # find all bands where this user is contained in the `likes` Parse relation column
+  # of the Band collection
+  bands_liked_by_user = Band.all :likes => user
+```
+
 ##### Options
 Options for `has_many` are the same as the `belongs_to` counterpart with support for `:required`, `:as` and `:field`. It has these additional options.
 
@@ -2044,11 +2104,28 @@ Equivalent to the `$relatedTo` Parse query operation. If you want to retrieve ob
 ```ruby
 q.where :field.related_to => pointer
 q.where :field.rel => pointer # alias
+```
+
+In the example below, imagine you have a `Post` collection that has a Parse relation column `likes`
+which has the set of users who have liked a certain post. You would use the `Parse::Users` class to query
+against the `post` record of interest against the `likes` column of the `Post` collection.
+
+```ruby
+# assume Post class definition
+class Post < Parse::Object
+  # Parse relation to Parse::User records who've liked a post
+  has_many :likes, through: :relation, as: :user
+end
 
-# example
-# find all Users who have liked this post object
 post = Post.first
+# find all Users who have liked this post object,
+# where likes is a column on the Post class.
 users = Parse::User.all :likes.rel => post
+
+# or find posts that a certain user has liked
+user = Parse::User.first
+# likes is a Parse relation in the Post collection that contains User records
+liked_posts_by_user = Post.all :likes => user
 ```
 
 ### Compound Queries

data/bin/console

@@ -1,9 +1,10 @@
 #!/usr/bin/env ruby
 
 require "bundler/setup"
-require "parse/stack"
-require 'dotenv'
 require 'byebug'
+require 'dotenv'
+require "parse/stack"
+
 Dotenv.load
 
 def setup

data/lib/parse/client/body_builder.rb

@@ -22,7 +22,7 @@ module Parse
   def self.logging=(value)
     Parse::Middleware::BodyBuilder.logging = value
   end
-  
+
   # Namespace for Parse-Stack related middleware.
   module Middleware
     # This middleware takes an incoming Parse response, after an outgoing request,
@@ -30,8 +30,9 @@ module Parse
     class BodyBuilder < Faraday::Middleware
       include Parse::Protocol
       # Header sent when a GET requests exceeds the limit.
-      HTTP_OVERRIDE = 'X-Http-Method-Override'
-
+      HTTP_METHOD_OVERRIDE = 'X-Http-Method-Override'
+      # Maximum url length for most server requests before HTTP Method Override is used.
+      MAX_URL_LENGTH = 2_000.freeze
       class << self
         # Allows logging. Set to `true` to enable logging, `false` to disable.
         # You may specify `:debug` for additional verbosity.
@@ -51,10 +52,12 @@ module Parse
         # (which is most likely a very complicated query), we need to override the request method
         # to be POST instead of GET and send the query parameters in the body of the POST request.
         # The standard maximum POST request (which is a server setting), is usually set to 20MBs
-        if env[:method] == :get && env[:url].to_s.length > 2_000
-          env[:request_headers][HTTP_OVERRIDE] = 'GET'
+        if env[:method] == :get && env[:url].to_s.length >= MAX_URL_LENGTH
+          env[:request_headers][HTTP_METHOD_OVERRIDE] = 'GET'
           env[:request_headers][CONTENT_TYPE] = 'application/x-www-form-urlencoded'
-          env[:body] = env[:url].query
+          # parse-sever looks for method overrides in the body under the `_method` param.
+          # so we will add it to the query string, which will now go into the body.
+          env[:body] = "_method=GET&" + env[:url].query
           env[:url].query = nil
           #override
           env[:method] = :post

data/lib/parse/model/associations/has_many.rb

@@ -95,7 +95,7 @@ module Parse
     #  # => [artist's songs created in the last 6 months]
     #
     # You may also call property methods in your scopes related to the instance.
-    # You also have access to the instance object for the local class
+    # *Note:* You also have access to the instance object for the local class
     # through a special "*i*" method in the scope.
     #
     #  class Concert
@@ -220,10 +220,9 @@ module Parse
     #  fans = band.fans.all :location.near => downtown
     #
     # You can perform atomic additions and removals of objects from `has_many`
-    # relations. Parse allows this by providing a specific atomic operation
-    # request. You can use the methods below to perform these types of atomic
-    # operations. The operation is performed directly on Parse server
-    # and not on your instance object.
+    # relations using the methods below. Parse allows this by providing a specific atomic operation
+    # request. The operation is performed directly on Parse server
+    # and *NOT* on your instance object.
     #
     #  # atomically add/remove
     #  band.artists.add! objects  # { __op: :AddUnique }
@@ -240,6 +239,35 @@ module Parse
     #  # this should set it as `undefined`.
     #  band.op_destroy!("category") # { __op: :Delete }
     #
+    # You can also perform queries against class entities to find related objects. Assume
+    # that users can like a band. The `Band` class can have a `likes` column that is
+    # a Parse relation to the {Parse::User} class containing the users who have liked a
+    # specific band.
+    #
+    #
+    #   class Band < Parse::Object
+    #     # likes is a Parse relation column of user objects.
+    #     has_many :likes, through: :relation, as: :user
+    #   end
+    #
+    # You can now find all {Parse::User} records who have liked a specific band. In the
+    # example below, the `:likes` key refers to the `likes` column defined in the `Band`
+    # collection which contains the set of user records.
+    #
+    #   band = Band.first # get a band
+    #
+    #   # find all users who have liked this band, where :likes is a column
+    #   # in the Band collection - NOT in the User collection.
+    #   users = Parse::User.all :likes.related_to => band
+    #
+    # You can also find all bands that a specific user has liked.
+    #
+    #   user = Parse::User.first
+    #
+    #   # find all bands where this user
+    #   # is in the `likes` column of the Band collection
+    #   bands_liked_by_user = Band.all :likes => user
+    #
     module HasMany
 
       # @!attribute [rw] self.relations
@@ -367,7 +395,7 @@ module Parse
             end
 
             Parse::Query.apply_auto_introspection!(query)
-            
+
             return query if block.nil?
             query.results(&block)
           end

data/lib/parse/model/classes/installation.rb

@@ -10,7 +10,31 @@ module Parse
   # An installation object represents an instance of your app being installed
   # on a device. These objects are used to store subscription data for
   # installations which have subscribed to one or more push notification channels.
+  #
+  # The default schema for {Installation} is as follows:
+  #
+  #   class Parse::Installation < Parse::Object
+  #      # See Parse::Object for inherited properties...
+  #
+  #     property :gcm_sender_id, field: :GCMSenderId
+  #     property :app_identifier
+  #     property :app_name
+  #     property :app_version
+  #     property :badge, :integer
+  #     property :channels, :array
+  #     property :device_token
+  #     property :device_token_last_modified, :integer
+  #     property :device_type, enum: [:ios, :android, :winrt, :winphone, :dotnet]
+  #     property :installation_id
+  #     property :locale_identifier
+  #     property :parse_version
+  #     property :push_type
+  #     property :time_zone, :timezone
+  #
+  #     has_one :session, ->{ where(installation_id: i.installation_id) }, scope_only: true
+  #   end
   # @see Push
+  # @see Parse::Object
   class Installation < Parse::Object
 
     parse_class Parse::Model::CLASS_INSTALLATION
@@ -22,7 +46,7 @@ module Parse
     # provider. If you set this field, then you must set the GCM API key
     # corresponding to this GCM sender ID in your Parse application’s push settings.
     # @return [String]
-    property :gcm_sender_id, :string, field: :GCMSenderId
+    property :gcm_sender_id, field: :GCMSenderId
 
     # @!attribute app_identifier
     # A unique identifier for this installation’s client application. In iOS, this is the Bundle Identifier.
@@ -92,10 +116,17 @@ module Parse
     property :push_type
 
     # @!attribute time_zone
-    # The current time zone where the target device is located. This should be an IANA time zone identifier.
-    # @return [String]
-    property :time_zone
-
+    # The current time zone where the target device is located. This should be an IANA time zone identifier
+    # or a {Parse::TimeZone} instance.
+    # @return [Parse::TimeZone]
+    property :time_zone, :timezone
+
+    # @!attribute session
+    # Returns the corresponding {Parse::Session} associated with this installation, if any exists.
+    # This is implemented as a has_one association to the Session class using the {installation_id}.
+    # @version 1.7.1
+    # @return [Parse::Session] The associated {Parse::Session} that might be tied to this installation
+    has_one :session, ->{ where(installation_id: i.installation_id) }, scope_only: true
   end
 
 end

data/lib/parse/model/classes/product.rb

@@ -6,6 +6,21 @@ require_relative 'user'
 module Parse
   # This class represents the data and columns contained in the standard Parse `_Product` collection.
   # These records are usually used when implementing in-app purchases in mobile applications.
+  #
+  # The default schema for {Product} is as follows:
+  #
+  #   class Parse::Product < Parse::Object
+  #      # See Parse::Object for inherited properties...
+  #
+  #      property :download, :file
+  #      property :icon,     :file,    required: true
+  #      property :order,    :integer, required: true
+  #      property :subtitle,           required: true
+  #      property :title,              required: true
+  #      property :product_identifier, required: true
+  #
+  #   end
+  # @see Parse::Object
   class Product < Parse::Object
 
     parse_class Parse::Model::CLASS_PRODUCT

data/lib/parse/model/classes/role.rb

@@ -7,6 +7,21 @@ module Parse
   # Roles allow the an application to group a set of {Parse::User} records with the same set of
   # permissions, so that specific records in the database can have {Parse::ACL}s related to a role
   # than trying to add all the users in a group.
+  #
+  # The default schema for {Role} is as follows:
+  #
+  #   class Parse::Role < Parse::Object
+  #      # See Parse::Object for inherited properties...
+  #
+  #      property :name
+  #
+  #      # A role may have child roles.
+  #      has_many :roles, through: :relation
+  #
+  #      # The set of users who belong to this role.
+  #      has_many :users, through: :relation
+  #   end
+  # @see Parse::Object
   class Role < Parse::Object
 
     parse_class Parse::Model::CLASS_ROLE
@@ -22,11 +37,6 @@ module Parse
     # This attribute is mapped as a `has_many` Parse relation association with the {Parse::User} class.
     # @return [RelationCollectionProxy<User>] a Parse relation of users belonging to this role.
     has_many :users, through: :relation
-    
-    # A method to set acls for Roles to public read, and deny public write.
-    def apply_default_acls
-      acl.everyone true, false
-    end
 
   end
 

data/lib/parse/model/classes/session.rb

@@ -9,6 +9,24 @@ module Parse
   # a session token is generated. You may use a known active session token to find the corresponding
   # user for that session. Deleting a Session record (and session token), effectively logs out the user, when making Parse requests
   # on behalf of the user using the session token.
+  #
+  # The default schema for the {Session} class is as follows:
+  #   class Parse::Session < Parse::Object
+  #      # See Parse::Object for inherited properties...
+  #
+  #      property :session_token
+  #      property :created_with, :object
+  #      property :expires_at, :date
+  #      property :installation_id
+  #      property :restricted, :boolean
+  #
+  #      belongs_to :user
+  #
+  #      # Installation where the installation_id matches.
+  #      has_one :installation, ->{ where(installation_id: i.installation_id) }, scope_only: true
+  #   end
+  #
+  # @see Parse::Object
   class Session < Parse::Object
 
     parse_class Parse::Model::CLASS_SESSION
@@ -40,6 +58,13 @@ module Parse
     #  @see User
     belongs_to :user
 
+    # @!attribute [r] installation
+    # Returns the {Parse::Installation} where the sessions installation_id field matches the installation_id field
+    # in the {Parse::Installation} collection. This is implemented as a has_one scope.
+    # @version 1.7.1
+    # @return [Parse::Installation] The associated {Parse::Installation} tied to this session
+    has_one :installation, ->{ where(installation_id: i.installation_id) }, scope_only: true
+
     # Return the Session record for this session token.
     # @param token [String] the session token
     # @return [Session] the session for this token, otherwise nil.

data/lib/parse/model/classes/user.rb

@@ -24,6 +24,19 @@ module Parse
   # All users need to have a username and a password, with email being optional but globally unique if set.
   # You may add additional properties by redeclaring the class to match your specific schema.
   #
+  # The default schema for the {User} class is as follows:
+  #
+  #   class Parse::User < Parse::Object
+  #      # See Parse::Object for inherited properties...
+  #
+  #      property :auth_data, :object
+  #      property :username
+  #      property :password
+  #      property :email
+  #
+  #      has_many :active_sessions, as: :session
+  #   end
+  #
   # *Signup*
   #
   # You can signup new users in two ways. You can either use a class method
@@ -122,6 +135,7 @@ module Parse
   #  # Unlinks this user's Facebook account from Parse
   #  user.unlink_auth_data! :facebook
   #
+  # @see Parse::Object
   class User < Parse::Object
 
     parse_class Parse::Model::CLASS_USER
@@ -153,6 +167,14 @@ module Parse
     # @return [String] The user's username.
     property :username
 
+    # @!attribute active_sessions
+    # A has_many relationship to all {Parse::Session} instances for this user. This
+    # will query the _Session collection for all sessions which have this user in it's `user`
+    # column.
+    # @version 1.7.1
+    # @return [Array<Parse::Session>] A list of active Parse::Session objects.
+    has_many :active_sessions, as: :session
+
     before_save do
       # You cannot specify user ACLs.
       self.clear_attribute_change!(:acl)

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

@@ -169,58 +169,12 @@ module Parse
           obj
         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 records,
-        # therefore you should not use this method if you want to perform a query
-        # with constraints against `created_at` field or need specific type of ordering.
-        # @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
-        #  Comments.each( post: post) do |comment|
-        #    # ...
-        #  end
-        # @return [Parse::Object] the last Parse::Object record processed.
-        def each(constraints = {}, **opts, &block)
-          #anchor_date = opts[:anchor_date] || Parse::Date.now
-          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
-
-            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
-
         # Auto save all objects matching the query constraints. This method is
         # meant to be used with a block. Any objects that are modified in the block
         # will be batched for a save operation. This uses the `updated_at` field to
         # continue to query for all matching objects that have not been updated.
+        # If you need to use `:updated_at` in your constraints, consider using {Parse::Core::Querying#all} or
+        # {Parse::Core::Querying#each}
         # @param constraints [Hash] a set of query constraints.
         # @yield a block which will iterate through each matching object.
         # @example
@@ -230,8 +184,18 @@ module Parse
         #    # .. modify comment ...
         #    # it will automatically be saved
         #  end
+        # @note You cannot use *:updated_at* as a constraint.
         # @return [Boolean] whether there were any errors.
         def save_all(constraints = {})
+          invalid_constraints = constraints.keys.any? do |k|
+            (k == :updated_at || k == :updatedAt) ||
+            ( k.is_a?(Parse::Operation) && (k.operand == :updated_at || k.operand == :updatedAt) )
+          end
+          if invalid_constraints
+            raise ArgumentError,
+              "[#{self}] Special method save_all() cannot be used with an :updated_at constraint."
+          end
+
           force = false
           batch_size = 250
           iterator_block = nil
@@ -262,7 +226,7 @@ module Parse
 
             # verify we didn't get duplicates fetches
             if cursor.is_a?(Parse::Object) && results.any? { |x| x.id == cursor.id }
-              warn "[Parse::SaveAll] Unbounded update detected with id #{cursor.id}."
+              warn "[#{self}.save_all] Unbounded update detected with id #{cursor.id}."
               has_errors = true
               break cursor
             end
@@ -284,7 +248,7 @@ module Parse
               update_query.where :updated_at.gte => cursor.updated_at
 
               if cursor.updated_at.present? && cursor.updated_at > anchor_date
-                warn "[Parse::SaveAll] Reached anchor date  #{anchor_date} < #{cursor.updated_at}"
+                warn "[#{self}.save_all] Reached anchor date  #{anchor_date} < #{cursor.updated_at}"
                 break cursor
               end
 

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

@@ -20,7 +20,7 @@ module Parse
   # supported in Parse and mapping them between their remote names with their local ruby named attributes.
   module Properties
     # These are the base types supported by Parse.
-    TYPES = [:id, :string, :relation, :integer, :float, :boolean, :date, :array, :file, :geopoint, :bytes, :object, :acl].freeze
+    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
     # The list of properties that are part of all objects
@@ -28,8 +28,9 @@ module Parse
     # 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.
+    CORE_FIELDS = {id: :string, created_at: :date, updated_at: :date, acl: :acl}.freeze
+    # The delete operation hash.
     DELETE_OP = {"__op"=>"Delete"}.freeze
-
     # @!visibility private
     def self.included(base)
       base.extend(ClassMethods)
@@ -44,7 +45,8 @@ module Parse
       # @param type [Symbol] a property type.
       # @return [Hash] the defined fields for this Parse collection with their data type.
       def fields(type = nil)
-        @fields ||= {id: :string, created_at: :date, updated_at: :date, acl: :acl}
+        # if it's Parse::Object, then only use the initial set, otherwise add the other base fields.
+        @fields ||= (self == Parse::Object ? CORE_FIELDS : Parse::Object.fields).dup
         if type.present?
           type = type.to_sym
           return @fields.select { |k,v| v == type }
@@ -107,10 +109,16 @@ module Parse
         if data_type.is_a?(Hash)
           opts.merge!(data_type)
           data_type = :string
+          # future: automatically use :timezone datatype for timezone-like fields.
+          # when the data_type was not specifically set.
+          # data_type = :timezone if key == :time_zone || key == :timezone
         end
 
+        data_type = :timezone if data_type == :string && (key == :time_zone || key == :timezone)
+
         # allow :bool for :boolean
         data_type = :boolean if data_type == :bool
+        data_type = :timezone if data_type == :time_zone
         data_type = :geopoint if data_type == :geo_point
         data_type = :integer if data_type == :int || data_type == :number
 
@@ -127,14 +135,16 @@ module Parse
         #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 self.fields[key].present? && BASE_FIELD_MAP[key].nil?
-          warn "Property #{self}##{key} already defined with data type #{data_type}. Will be ignored."
-          return
+        # 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) )
+          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?
+        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
+          return false
           # raise ArgumentError
         end
         #dirty tracking. It is declared to use with ActiveModel DirtyTracking
@@ -159,6 +169,15 @@ module Parse
           validates_presence_of key
         end
 
+        # timezone datatypes are basically enums based on IANA time zone identifiers.
+        if data_type == :timezone
+          validates_each key do |record, attribute, value|
+            # Parse::TimeZone objects have a `valid?` method to determine if the timezone is valid.
+            unless value.nil? || value.valid?
+              record.errors.add(attribute, "field :#{attribute} must be a valid IANA time zone identifier.")
+            end
+          end # validates_each
+        end # data_type == :timezone
 
         is_enum_type = opts[:enum].nil? == false
 
@@ -227,7 +246,9 @@ module Parse
             end
           end # unless scopes
 
-        end
+        end # if is enum
+
+
 
         symbolize_value = opts[:symbolize]
 
@@ -391,7 +412,7 @@ module Parse
         # if both the local name matches the calculated/provided remote column name, don't create
         # an alias method since it is the same thing. Ex. attribute 'username' would probably have the
         # remote column name also called 'username'.
-        return if parse_field == key
+        return true if parse_field == key
 
         # we will now create the aliases, however if the method is already defined
         # we warn the user unless the field is :objectId since we are in charge of that one.
@@ -405,7 +426,7 @@ module Parse
         elsif parse_field.to_sym != :objectId
           warn "Alias property method #{self}##{parse_field} already defined."
         end
-
+        true
       end # property
 
     end #ClassMethods
@@ -572,6 +593,8 @@ module Parse
         #  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?
       else
         # You can provide a specific class instead of a symbol format
         if data_type.respond_to?(:typecast)

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

@@ -128,6 +128,68 @@ module Parse
           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
+          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
+
+            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
+
         # 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
@@ -143,6 +205,9 @@ module Parse
         #      # ... 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})

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

@@ -29,6 +29,8 @@ module Parse
               result = { type: Parse::Model::TYPE_POINTER, targetClass: references[k] }
             when :acl
               result[:type] = Parse::Model::ACL
+            when :timezone, :time_zone
+              result[:type] = "String" # no TimeZone native in Parse
             else
               result[:type] = v.to_s.camelize
             end

data/lib/parse/model/geopoint.rb

@@ -90,7 +90,7 @@ module Parse
 
     end
 
-    # @return [Hash]
+    # @return [Hash] attributes for a Parse GeoPoint.
     def attributes
       ATTRIBUTES
     end

data/lib/parse/model/object.rb

@@ -18,6 +18,7 @@ require_relative 'geopoint'
 require_relative 'file'
 require_relative 'bytes'
 require_relative 'date'
+require_relative 'time_zone'
 require_relative 'acl'
 require_relative 'push'
 require_relative 'core/actions'
@@ -69,9 +70,27 @@ module Parse
 
   # This is the core class for all app specific Parse table subclasses. This class
   # in herits from Parse::Pointer since an Object is a Parse::Pointer with additional fields,
-  # at a minimum, created_at, updated_at and ACLs.
-  # This class also handles all the relational types of associations in a Parse application and
-  # handles the main CRUD operations.
+  # at a minimum, created_at, updated_at and ACLs. This class also handles all
+  # the relational types of associations in a Parse application and handles the main CRUD operations.
+  #
+  # As the parent class to all custom subclasses, this class provides the default property schema:
+  #
+  #   class Parse::Object
+  #      # All subclasses will inherit these properties by default.
+  #
+  #      # the objectId column of a record.
+  #      property :id, :string, field: :objectId
+  #
+  #      # The the last updated date for a record (Parse::Date)
+  #      property :updated_at, :date
+  #
+  #      # The original creation date of a record (Parse::Date)
+  #      property :created_at, :date
+  #
+  #      # The Parse::ACL field
+  #      property :acl, :acl, field: :ACL
+  #
+  #   end
   #
   # Most Pointers and Object subclasses are treated the same. Therefore, defining a class Artist < Parse::Object
   # that only has `id` set, will be treated as a pointer. Therefore a Parse::Object can be in a "pointer" state

data/lib/parse/model/time_zone.rb

@@ -0,0 +1,143 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/values/time_zone'
+require_relative "model"
+
+module Parse
+  # This class a wrapper around ActiveSupport::TimeZone when using Parse columns that
+  # store IANA time zone identifiers (ex. Installation collection). Parse does not have a
+  # native time zone data type, but this class is provided to manage and perform timezone-like
+  # operation on those properties which you have marked as type _:timezone_.
+  #
+  # When declaring a property of type :timezone, you may also define a default just like
+  # any other property. In addition, the framework will automatically add a validation
+  # to make sure that your property is either nil or one of the valid IANA time zone identifiers.
+  #
+  # Each instance of {Parse::TimeZone} has a {Parse::TimeZone#zone} attribute that provides access to
+  # the underlying {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+  # instance, which you can use to perform time zone operations.
+  # @example
+  #  class Event < Parse::Object
+  #    # an event occurs in a time zone.
+  #    property :time_zone, :timezone, default: 'America/Los_Angeles'
+  #  end
+  #
+  #  event = Event.new
+  #  event.time_zone.name # => 'America/Los_Angeles'
+  #  event.time_zone.valid? # => true
+  #
+  #  event.time_zone.zone # => ActiveSupport::TimeZone
+  #  event.time_zone.formatted_offset # => "-08:00"
+  #
+  #  event.time_zone = 'Europe/Paris'
+  #  event.time_zone.formatted_offset # => +01:00"
+  #
+  #  event.time_zone = 'Galaxy/Andromeda'
+  #  event.time_zone.valid? # => false
+  # @version 1.7.1
+  class TimeZone
+    # The mapping of TimeZones
+    MAPPING = ActiveSupport::TimeZone::MAPPING
+
+    # Create methods based on the allowable public methods on ActiveSupport::TimeZone.
+    # Basically sets up sending forwarding calls to the `zone` object for a Parse::TimeZone object.
+    (ActiveSupport::TimeZone.public_instance_methods(false) - [:to_s, :name, :as_json]).each do |meth|
+      Parse::TimeZone.class_eval do
+        define_method meth do |*args|
+          zone.send meth, *args
+        end
+      end
+    end
+
+    # Creates a new instance given the IANA identifier (ex. America/Los_Angeles)
+    # @overload new(iana)
+    #  @param iana [String] the IANA identifier (ex. America/Los_Angeles)
+    #  @return [Parse::TimeZone]
+    # @overload new(timezone)
+    #  You can instantiate a new instance with either a {Parse::TimeZone} or an {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+    #  object.
+    #  @param timezone [Parse::TimeZone|ActiveSupport::TimeZone] an instance of either timezone class.
+    #  @return [Parse::TimeZone]
+    def initialize(iana)
+      if iana.is_a?(String)
+        @name = iana
+        @zone = nil
+      elsif iana.is_a?(::Parse::TimeZone)
+        @zone = iana.zone
+        @name = nil
+      elsif iana.is_a?(::ActiveSupport::TimeZone)
+        @zone = iana
+        @name = nil
+      end
+    end
+
+    # @!attribute [rw] name
+    # @raise ArgumentError if value is not a string type.
+    # @return [String] the IANA identifier for this time zone.
+    def name
+      @zone.present? ? zone.name : @name
+    end
+
+    def name=(iana)
+      unless iana.nil? || iana.is_a?(String)
+        raise ArgumentError, "Parse::TimeZone#name should be an IANA time zone identifier."
+      end
+      @name = iana
+      @zone = nil
+    end
+
+    # @!attribute [rw] zone
+    # Returns an instance of {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+    # based on the IANA identifier. The setter may allow usign an IANA string identifier,
+    # a {Parse::TimeZone} or an
+    # {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone}
+    # object.
+    # @see #name
+    # @raise ArgumentError
+    # @return [ActiveSupport::TimeZone]
+    def zone
+      # lazy load the TimeZone object only when the user requests it, otherwise
+      # just keep the name of the string around. Makes encoding/decoding faster.
+      if @zone.nil? && @name.present?
+        @zone = ::ActiveSupport::TimeZone.new(@name)
+        @name = nil # clear out the cache
+      end
+      @zone
+    end
+
+    def zone=(timezone)
+      if timezone.is_a?(::ActiveSupport::TimeZone)
+        @zone = timezone
+        @name = nil
+      elsif timezone.is_a?(Parse::TimeZone)
+        @name = timezone.name
+        @zone = nil
+      elsif timezone.nil? || timezone.is_a?(String)
+        @name = timezone
+        @zone = nil
+      else
+        raise ArgumentError, 'Invalid value passed to Parse::TimeZone#zone.'
+      end
+    end
+
+    # (see #to_s)
+    def as_json(*args)
+      name
+    end
+
+    # @return [String] the IANA identifier for this timezone or nil.
+    def to_s
+      name
+    end
+
+    # Returns true or false whether the time zone exists in the {http://api.rubyonrails.org/classes/ActiveSupport/TimeZone.html ActiveSupport::TimeZone} mapping.
+    # @return [Bool] true if it contains a valid time zone
+    def valid?
+      ActiveSupport::TimeZone[to_s].present?
+    end
+
+  end
+
+end

data/lib/parse/stack.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-exit if ENV['MERCURY_URL'] # don't use master branch
 require_relative "stack/version"
 require_relative 'client'
 require_relative 'query'
@@ -13,7 +12,6 @@ module Parse
   class Error < StandardError; end;
   module Stack
 
-    # Your code goes here...
   end
 end
 

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "1.7.0"
+    VERSION = "1.7.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.1
 platform: ruby
 authors:
 - Anthony Persaud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-11 00:00:00.000000000 Z
+date: 2017-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -233,6 +233,7 @@ files:
 - lib/parse/model/pointer.rb
 - lib/parse/model/push.rb
 - lib/parse/model/shortnames.rb
+- lib/parse/model/time_zone.rb
 - lib/parse/query.rb
 - lib/parse/query/constraint.rb
 - lib/parse/query/constraints.rb