parse-stack 1.7.1 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3557dd1c97f0f227d848732708916d3428563d22
-  data.tar.gz: b71256968073f1318cb5c88665c551e6e6f7381c
+  metadata.gz: '0267822a7e96425e847f7218ad98a11115b511b4'
+  data.tar.gz: 5f942b6458ba0f0de2f5e9657fe9e135ea46fcc7
 SHA512:
-  metadata.gz: 78d5ee17c4c2a9b8488ef6e37a8e6eeedf82e195b4369423e2694a784c4ff8cd41ba73d945cbdaa863ec094f6b1a1f4df5b26a6b8e28ae56401dfaf988b138d1
-  data.tar.gz: 86e596121613d31532aee9cd67fa8e5691ccbdcba7de01f11cfc0e3731b61e43cfde29a91137665e537aa448897af37dc21ea1b83bdc7908d7617065de1a8b93
+  metadata.gz: 7978c0a43c5f46217e7fcc3f0ff600c548571f9094f91b7716bf8ce8881e47edd49bc579d803853213c2890ee3e1f8aec6b23453f9f396b17bedfae7b173f9fa
+  data.tar.gz: 3a29aac5e5c251424023426498cd4e98a6751189e752a932f011becfb3f1f1806e1988088c97e4f21b7d1b2bd235d32e5bd912478da45919928439b20dd33c0e

data/Changes.md

@@ -1,5 +1,28 @@
 ## Parse-Stack Changelog
 
+### 1.7.2
+- NEW: `Parse::Model.autosave_on_create` has been removed in favor of `first_or_create!`.
+- NEW: Webhook Triggers and Functions now have a `wlog` method, similar to `puts`, but allows easier tracing of
+single requests in a multi-request threaded environment. (See Parse::Webhooks::Payload)
+- NEW: `:id` constraints also safely supports pointers by skipping class matching.
+- NEW: Support for `add_unique` and the set union operator `|` in collection proxies.
+- NEW: Support for `uniq` and `uniq!` in collection proxies.
+- NEW: `uniq` and `uniq!` for collection proxies utilize `eql?` for determining uniqueness.
+- NEW: Updated override behavior for the `hash` method in Parse::Pointer and subclasses.
+- NEW: Support for additional array methods in collection proxies (+,-,& and |)
+- NEW: Additional methods for Parse::ACL class for setting read/write privileges.
+- NEW: Expose the shared cache store through `Parse.cache`.
+- NEW: `User#any_session!` method, see documentation.
+- NEW: Extension to support `Date#parse_date`.
+- NEW: Added `Parse::Query#append` as alias to `Parse::Query#conditions`
+- CHANGED: `save_all` now returns true if there were no errors.
+- FIXED: first_or_create will now apply dirty tracking to newly created fields.
+- FIXED: Properties of :array type will always return a Parse::CollectionProxy if their internal value is nil. The object will not be marked dirty until something is added to the array.
+- FIXED: Encoding a Parse::Object into JSON will remove any values that are `nil`
+which were not explicitly changed to that value.
+- [PR#39](https://github.com/modernistik/parse-stack/pull/39): Allow Moneta::Expires as cache object to allow for non-native expiring caches by [GrahamW](https://github.com/GrahamW)
+
+
 ### 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.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parse-stack (1.7.1)
+    parse-stack (1.7.2)
       active_model_serializers (>= 0.9, < 1)
       activemodel (>= 4.2.1, < 6)
       activesupport (>= 4.2.1, < 6)
@@ -56,8 +56,8 @@ GEM
       multipart-post (>= 1.2, < 3)
     faraday_middleware (0.11.0.1)
       faraday (>= 0.7.4, < 1.0)
-    i18n (0.8.4)
-    jsonapi-renderer (0.1.2)
+    i18n (0.8.6)
+    jsonapi-renderer (0.1.3)
     loofah (2.0.3)
       nokogiri (>= 1.5.9)
     method_source (0.8.2)

data/README.md

@@ -587,14 +587,15 @@ 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`.
+The value of each key in the hash is a [`Parse::ACL::Permission`](https://www.modernistik.com/gems/parse-stack/Parse/ACL/Permission.html) object which defines the boolean permission state for `read` and `write`.
 
-The example below illustrates a Parse ACL JSON object where there is a public read permission, but public write is prevented. In addition, the user with id `3KmCvT7Zsb`, is allowed to both read and write this record.
+The example below illustrates a Parse ACL JSON object where there is a public read permission, but public write is prevented. In addition, the user with id `3KmCvT7Zsb` and the `Admins` role, are allowed to both read and write on this record.
 
 ```json
 {
   "*": { "read": true },
-  "3KmCvT7Zsb": {  "read": true, "write": true }
+  "3KmCvT7Zsb": {  "read": true, "write": true },
+  "role:Admins": {  "read": true, "write": true }
 }
 ```
 
@@ -609,7 +610,6 @@ All `Parse::Object` subclasses have an `acl` property by default. With this prop
   # apply public read, but no public write
   artist.acl.everyone true, false
 
-
   # allow user to have read and write access
   artist.acl.apply user.id, true, true
 
@@ -619,6 +619,12 @@ All `Parse::Object` subclasses have an `acl` property by default. With this prop
   # allow the 'Admins' role read and write
   artist.acl.apply_role "Admins", true, true
 
+  # remove write from all attached privileges
+  artist.acl.no_write!
+
+  # remove all attached privileges
+  artist.acl.master_key_only!
+
   artist.save
 ```
 You may also set default ACLs for newly created insatnces of your subclasses using `set_default_acl`:
@@ -1260,6 +1266,7 @@ fan = bands.fans.first # => Parse::User object
 
 # use `add` or `remove` to modify relations
 band.fans.add user
+band.fans.add_unique user # no op
 bands.fans.remove user
 
 # updates the relation as well as changes to `band`
@@ -1305,7 +1312,7 @@ specific band.
   end
 ```
 
-You can now find all `Parse::User` records who have liked a specific band. *In the
+You can now find all `Parse::User` records that 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.*
 
@@ -1314,6 +1321,10 @@ collection which contains the set of user records.*
   # 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
+
+  # or use the relation accessor in band. It is equivalent since Band is
+  # declared with a :has_many association.
+  band.likes.all # => array of Parse::Users who liked the band
 ```
 You can also find all bands that a specific user has liked.
 
@@ -1394,7 +1405,7 @@ song.changed # ['name']
 
 ```
 
-If you want to either find the first resource matching some given criteria or just create that resource if it can't be found, you can use `#first_or_create`. Note that if a match is not found, the object will not be saved to Parse automatically, since the framework provides support for heterogeneous object batch saving. This means you can group different object classes together and save them all at once through the `Array#save` method to reduce API requests. You may modify this behavior by setting `Parse::Model.autosave_on_create = true`.
+If you want to either find the first resource matching some given criteria or just create that resource if it can't be found, you can use `first_or_create`. Note that if a match is not found, the object will not be saved to Parse automatically, since the framework provides support for heterogeneous object batch saving. This means you can group different object classes together and save them all at once through the `Array#save` method to reduce API requests. If you want to truly want to find a first or create (save) the object, you may use `first_or_create!`.
 
 ```ruby
  # Finds matching song or creates a new unsaved object
@@ -1408,6 +1419,9 @@ song = Song.first_or_create(name: "Awesome Song", available: true)
 song.id # 'xyz1122df`
 song.save # noop since nothing changed
 
+# first_or_create! : Return an existing OR newly saved object
+song = Song.first_or_create!(name: "Awesome Song", available: true)
+
 ```
 
 If the constraints you use for the query differ from the attributes you want to set for the new object, you can pass the attributes for creating a new resource as the second parameter to `#first_or_create`, also in the form of a `#Hash`.
@@ -1801,6 +1815,23 @@ Song.all limit: 500, cache: false
 Song.all limit: 500, cache: 1.minute
 ```
 
+You may access the shared cache for the default client connection through `Parse.cache`. This is useful if you
+want to utilize the same cache store for other purposes.
+
+```ruby
+# Access the cache instance for other uses
+Parse.cache["key"] = "value"
+Parse.cache["key"] # => "value"
+
+# or with Parse queries and objects
+Parse.cache.fetch("all:song:records") do |key|
+  results = Song.all # or other complex query or operation
+  # store it in the cache, but expires in 30 seconds
+  Parse.cache.store(key, results, expires: 30)
+end
+
+```
+
 #### :use_master_key
 A true/false value. If you provided a master key as part of `Parse.setup()`, it will be sent on every request. However, if you wish to disable sending the master key on a particular request in order for the record ACLs to be enforced, you may pass `false`. If `false` is passed, caching will be disabled for this request.
 
@@ -2000,15 +2031,28 @@ q.where :field.not_in_query => query # alias
 ```
 
 #### Matches Object Id
-Sometimes you want to find rows where a particular Parse object exists. You can do so by passing a the Parse::Object subclass, a Parse::Pointer. You can also use the `id` constraint. This will assume that the name of the field matches a particular Parse class you have defined. Assume the following:
+Sometimes you want to find rows where a particular Parse object exists. You can do so by passing a the Parse::Object subclass or a Parse::Pointer. In some cases you may only have the "objectId" of the record you are looking for. For convenience, you can also use the `id` constraint. This will assume that the name of the field matches a particular Parse class you have defined. Assume the following:
 
 ```ruby
 # where this Parse object equals the object in the column `field`.
 q.where :field => Parse::Pointer("Field", "someObjectId")
+# => "field":{"__type":"Pointer","className":"Field","objectId":"someObjectId"}}
+
 # alias, shorthand when we infer `:field` maps to `Field` parse class.
 q.where :field.id => "someObjectId"
-# "field":{"__type":"Pointer","className":"Field","objectId":"someObjectId"}}
+# => "field":{"__type":"Pointer","className":"Field","objectId":"someObjectId"}}
 
+```
+It is always important to be thoughtful in naming column names in associations as
+close to their foreign Parse class names. This enables more expressive syntax while reducing
+code. The `id` also supports any object or pointer object. These are all equivalent:
+
+```ruby
+q.where :user    => User.pointer("xyx123")
+q.where :user.id => "xyx123"
+q.where :user.id => User.pointer("xyx123")
+# All produce
+# => "user":{"__type":"Pointer","className":"_User","objectId":"xyx123"}}
 ```
 
 ##### Additional Examples
@@ -2039,6 +2083,17 @@ Song.all :artist.id => artist_id
 # other approaches, same result
 Song.all :artist => Artist.pointer(artist_id)
 Song.all :artist => Parse::Pointer.new("Artist", artist_id)
+
+# "id" safely pointers and strings for supporting these types of API patterns
+def find_songs(artist)
+  Song.all :artist.id => artist
+end
+
+# all ok
+songs = find_songs artist_id # by a string ObjectId
+songs = find_songs artist # or by an object or pointer
+songs = find_songs Artist.pointer(artist_id)
+
 ```
 
 ### [Geo Queries](https://www.modernistik.com/gems/parse-stack/Parse/Constraint/NearSphereQueryConstraint.html)
@@ -2119,9 +2174,12 @@ end
 
 post = Post.first
 # find all Users who have liked this post object,
-# where likes is a column on the Post class.
+# where 'likes' is a column on the Post class.
 users = Parse::User.all :likes.rel => post
 
+# or use the relation accessor declared in Post
+users = post.likes.all # same result
+
 # 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
@@ -2236,7 +2294,7 @@ class Song < Parse::Object
 	# ex. before save callback
 	before_save do
 		self.name = self.name.titleize
-		# make sure global acls are set
+    # make sure global acls are set
 		acl.everyone(true, false) if new?
 	end
 
@@ -2336,15 +2394,31 @@ class Song < Parse::Object
 
   webhook :function, :mySongFunction do
     the_user = user # available if a Parse user made the call
-    params = params
-    # ... do stuff ...
-    some_result
+    str = params["str"]
+
+    # ... get the list of matching songs the user has access to.
+    results = Songs.all(:name.like => /#{str}/, :session => the_user)
+    # Helper method for logging
+    wlog "Found #{results.count} for #{the_user.username}"
+
+    results
   end
 
 end
 
 ```
 
+You may optionally, register these functions outside of classes (recommended).
+
+```ruby
+Parse::Webhooks.route :function, :mySongFunction do
+  # .. do stuff ..
+  str = params["str"]
+  results = Songs.all(:name.like => /#{str}/, :session => user)
+  results
+end
+```
+
 ### Cloud Code Triggers
 You can register webhooks to handle the different object triggers: `:before_save`, `:after_save`, `:before_delete` and `:after_delete`. The `payload` object, which is an instance of `Parse::Webhooks::Payload`, contains several properties that represent the payload. One of the most important ones is `parse_object`, which will provide you with the instance of your specific Parse object. In `:before_save` triggers, this object already contains dirty tracking information of what has been changed.
 
@@ -2363,7 +2437,7 @@ You can register webhooks to handle the different object triggers: `:before_save
   end
 
   # or the explicit way
-  Parse::Webhooks.route :after_save, "Artist" do
+  Parse::Webhooks.route :after_save, :Artist do
     puts "User: #{user.username}" if user.present? # Parse::User
     artist = parse_object # Artist
     # no need for return in after save
@@ -2395,6 +2469,7 @@ class Artist < Parse::Object
     error!("Name cannot be empty") if artist.name.blank?
 
     if artist.name_changed?
+      wlog "The artist name changed!"
       # .. do something if `name` has changed
     end
 
@@ -2519,6 +2594,22 @@ Parse::Client.client.clear_cache!
 
 # or through the client accessor of a model
 Song.client.clear_cache!
+```
+
+You can always access the default shared cache through `Parse.cache` and utilize it
+for other purposes in your application:
+
+```ruby
+# Access the cache instance for other uses
+Parse.cache["key"] = "value"
+Parse.cache["key"] # => "value"
+
+# or with Parse queries and objects
+Parse.cache.fetch("all:records") do |key|
+  results = Song.all # or other complex query or operation
+  # store it in the cache, but expires in 30 seconds
+  Parse.cache.store(key, results, expires: 30)
+end
 
 ```
 

data/lib/parse/api/hooks.rb

@@ -23,7 +23,8 @@ module Parse
       # Fetch all defined cloud code functions.
       # @return [Parse::Response]
       def functions
-        request :get, "#{HOOKS_PREFIX}functions"
+        opts = {cache: false}
+        request :get, "#{HOOKS_PREFIX}functions", opts: opts
       end
 
       # Fetch information about a specific registered cloud function.
@@ -61,7 +62,8 @@ module Parse
       # Get the set of registered triggers.
       # @return [Parse::Response]
       def triggers
-        request :get, "#{HOOKS_PREFIX}triggers"
+        opts = {cache: false}
+        request :get, "#{HOOKS_PREFIX}triggers", opts: opts
       end
 
       # Fetch information about a registered webhook trigger.

data/lib/parse/api/schema.rb

@@ -12,14 +12,16 @@ module Parse
       # Get all the schemas for the application.
       # @return [Parse::Response]
       def schemas
-        request :get, SCHEMAS_PATH
+        opts = {cache: false}
+        request :get, SCHEMAS_PATH, opts: opts
       end
 
       # Get the schema for a collection.
       # @param className [String] the name of the remote Parse collection.
       # @return [Parse::Response]
       def schema(className)
-        request :get, "#{SCHEMAS_PATH}/#{className}"
+        opts = {cache: false}
+        request :get, "#{SCHEMAS_PATH}/#{className}", opts: opts
       end
 
       # Create a new collection with the specific schema.

data/lib/parse/api/server.rb

@@ -29,7 +29,8 @@ module Parse
       # Fetches the status of the server based on the health check.
       # @return [Boolean] whether the server is 'OK'.
       def server_health
-        response = request :get, SERVER_HEALTH_PATH
+        opts = {cache: false}
+        response = request :get, SERVER_HEALTH_PATH, opts: opts
         response.success?
       end
 

data/lib/parse/client.rb

@@ -82,12 +82,22 @@ module Parse
   end
 
   # Helper method to get the default Parse client.
-  # @param conn [Symbol] the name of the client connection to use.
+  # @param conn [Symbol] the name of the client connection to use. Defaults to :default
   # @return [Parse::Client] a client object for the connection name.
   def self.client(conn = :default)
     Parse::Client.client(conn)
   end
 
+  # The shared cache for the default client connection. This is useful if you want to
+  # also utilize the same cache store for other purposes in your application.
+  # This should normally be a {https://github.com/minad/moneta Moneta} unified
+  # cache interface.
+  # @return [Moneta::Transformer,Moneta::Expires] the cache instance
+  # @see Parse::Client#cache
+  def self.cache
+    @shared_cache ||= Parse::Client.client(:default).cache
+  end
+
   # This class is the core and low level API for the Parse SDK REST interface that
   # is used by the other components. It can manage multiple sessions, which means
   # you can have multiple client instances pointing to different Parse Applications
@@ -122,7 +132,8 @@ module Parse
 
     # @!attribute cache
     #  The underlying cache store for caching API requests.
-    #  @return [Moneta::Transformer]
+    #  @see Parse.cache
+    #  @return [Moneta::Transformer,Moneta::Expires]
     # @!attribute [r] application_id
     #  The Parse application identifier to be sent in every API request.
     #  @return [String]
@@ -206,8 +217,9 @@ module Parse
     #    the logging performed by {Parse::Middleware::BodyBuilder}.
     # @option opts [Object] :adapter The connection adapter. By default it uses
     #    the `Faraday.default_adapter` which is Net/HTTP.
-    # @option opts [Moneta::Transformer] :cache A caching adapter of type
-    #    {https://github.com/minad/moneta Moneta::Transformer} that will be used
+    # @option opts [Moneta::Transformer,Moneta::Expires] :cache A caching adapter of type
+    #    {https://github.com/minad/moneta Moneta::Transformer} or
+    #    {https://github.com/minad/moneta Moneta::Expires} that will be used
     #    by the caching middleware {Parse::Middleware::Caching}.
     #    Caching queries and object fetches can help improve the performance of
     #    your application, even if it is for a few seconds. Only successful GET
@@ -223,7 +235,7 @@ module Parse
     # @option opts [Hash] :faraday You may pass a hash of options that will be
     #    passed to the Faraday constructor.
     # @raise Parse::Error::ConnectionError if the client was not properly configured with required keys or url.
-    # @raise ArgumentError if the cache instance passed to the :cache option is not of Moneta::Transformer.
+    # @raise ArgumentError if the cache instance passed to the :cache option is not of Moneta::Transformer or Moneta::Expires
     # @see Parse::Middleware::BodyBuilder
     # @see Parse::Middleware::Caching
     # @see Parse::Middleware::Authentication
@@ -277,8 +289,8 @@ module Parse
             end
           end
 
-          unless opts[:cache].is_a?(Moneta::Transformer)
-            raise ArgumentError, "Parse::Client option :cache needs to be a type of Moneta::Transformer store."
+          unless [:key?, :[], :delete, :store].all? { |method| opts[:cache].respond_to?(method) }
+            raise ArgumentError, "Parse::Client option :cache needs to be a type of Moneta store"
           end
           self.cache = opts[:cache]
           conn.use Parse::Middleware::Caching, self.cache, {expires: opts[:expires].to_i }

data/lib/parse/client/caching.rb

@@ -59,7 +59,7 @@ module Parse
 
       # @!attribute [rw] store
       # The internal moneta cache store instance.
-      # @return [Moneta::Transformer]
+      # @return [Moneta::Transformer,Moneta::Expires]
       attr_accessor :store
 
       # @!attribute [rw] expires
@@ -73,7 +73,7 @@ module Parse
       # @param store [Moneta] An instance of the Moneta cache store to use.
       # @param opts [Hash] additional options.
       # @option opts [Integer] :expires the default expiration for a cache entry.
-      # @raise ArgumentError, if `store` is not a Moneta::Transformer instance.
+      # @raise ArgumentError, if `store` is not a Moneta::Transformer or Moneta::Expires instance.
       def initialize(adapter, store, opts = {})
         super(adapter)
         @store = store
@@ -81,8 +81,8 @@ module Parse
         @opts.merge!(opts) if opts.is_a?(Hash)
         @expires = @opts[:expires]
 
-        unless @store.is_a?(Moneta::Transformer)
-          raise ArgumentError, "Caching store object must a Moneta key/value store (Moneta::Transformer)."
+        unless [:key?, :[], :delete, :store].all? { |method| @store.respond_to?(method) }
+          raise ArgumentError, "Caching store object must a Moneta key/value store."
         end
 
       end
@@ -115,7 +115,7 @@ module Parse
 
         # if caching is enabled and we have a valid cache duration, use cache
         # otherwise work as a passthrough.
-        return @app.call(env) unless @store.present? && @enabled && @expires > 0
+        return @app.call(env) unless @enabled && @store.present? && @expires > 0
 
         url = env.url
         method = env.method

data/lib/parse/model/acl.rb

@@ -49,15 +49,18 @@ module Parse
   # means denial.
   #
   # 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.
+  # 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.
-  # The example below illustrates a Parse ACL JSON object where there is a public
+  # The example below illustrates a Parse ACL JSON object where there is a *public*
   # read permission, but public write is prevented. In addition, the user with
-  # id "3KmCvT7Zsb", is allowed to both read and write this record.
+  # id "*3KmCvT7Zsb*" is allowed to both read and write this record, and the "*Admins*"
+  # role is also allowed write access.
+  #
   #  {
   #    "*": { "read": true },
-  #    "3KmCvT7Zsb": {  "read": true, "write": true }
+  #    "3KmCvT7Zsb": {  "read": true, "write": true },
+  #    "role:Admins": { "write": true }
   #  }
   #
   # All Parse::Object subclasses have an acl property by default. With this
@@ -81,6 +84,12 @@ module Parse
   #  # allow the 'Admins' role read and write
   #  artist.acl.apply_role "Admins", true, true
   #
+  #  # remove write from all attached privileges
+  #  artist.acl.no_write!
+  #
+  #  # remove all attached privileges
+  #  artist.acl.master_key_only!
+  #
   #  artist.save
   #
   # You may also set default ACLs for your subclasses by using {Parse::Object.set_default_acl}.
@@ -104,17 +113,21 @@ module Parse
   # {http://docs.parseplatform.org/rest/guide/#security Security}.
   class ACL < DataType
 
-    # @!attribute permissions
-    # Contains a hash structure of permissions, with keys mapping to either Public '*',
-    # a role name or an objectId for a user and values of type {ACL::Permission}.
-    # @return [Hash] a hash of permissions.
-
     # @!attribute delegate
-    # The instance object to be notified of changes. The delegate must support
-    # receiving a `acl_will_change!` method.
+    #  The instance object to be notified of changes. The delegate must support
+    #  receiving a {Parse::Object#acl_will_change!} method.
     # @return [Parse::Object]
     attr_accessor :permissions, :delegate
 
+    # @!attribute [rw] permissions
+    # Contains a hash structure of permissions, with keys mapping to either Public '*',
+    # a role name or an objectId for a user and values of type {ACL::Permission}. If you
+    # modify this attribute directly, you should call {Parse::Object#acl_will_change!}
+    # on the target object in order for dirty tracking to register changes.
+    # @example
+    #  object.acl.permissions
+    #  # => { "*": { "read": true }, "3KmCvT7Zsb": {  "read": true, "write": true } }
+    # @return [Hash] a hash of permissions.
     def permissions
       @permissions ||= {}
     end
@@ -301,16 +314,124 @@ module Parse
       permissions.values.any? { |v| v.present? }
     end
 
+    # Removes all ACLs, which only allows requests using the Parse Server master key
+    # to query and modify the object.
+    # @example
+    #  object.acl
+    #  #    { "*":          { "read" : true },
+    #  #      "3KmCvT7Zsb": { "read" : true, "write": true },
+    #  #      "role:Admins": { "write": true }
+    #  #     }
+    #  object.acl.master_key_only!
+    #  # Outcome:
+    #  #    { }
+    # @version 1.7.2
+    # @return [Hash] The cleared permissions hash
+    def master_key_only!
+      will_change!
+      @permissions = {}
+    end; alias_method :clear!, :master_key_only!
+
+    # Grants read permission on all existing users and roles attached to this object.
+    # @example
+    #  object.acl
+    #  #    { "*":          { "read" : true },
+    #  #      "3KmCvT7Zsb": { "read" : true, "write": true },
+    #  #      "role:Admins": { "write": true }
+    #  #     }
+    #  object.acl.all_read!
+    #  # Outcome:
+    #  #    { "*":          { "read" : true },
+    #  #      "3KmCvT7Zsb": { "read" : true, "write": true },
+    #  #      "role:Admins": { "read" : true, "write": true}
+    #  #     }
+    # @version 1.7.2
+    # @return [Array] list of ACL keys
+    def all_read!
+      will_change!
+      permissions.keys.each do |perm|
+        permissions[perm].read! true
+      end
+    end
+
+    # Grants write permission on all existing users and roles attached to this object.
+    # @example
+    #  object.acl
+    #  #    { "*":          { "read" : true },
+    #  #      "3KmCvT7Zsb": { "read" : true, "write": true },
+    #  #      "role:Admins": { "write": true }
+    #  #     }
+    #  object.acl.all_write!
+    #  # Outcome:
+    #  #    { "*":          { "read" : true, "write": true },
+    #  #      "3KmCvT7Zsb": { "read" : true, "write": true },
+    #  #      "role:Admins": { "write": true }
+    #  #     }
+    # @version 1.7.2
+    # @return [Array] list of ACL keys
+    def all_write!
+      will_change!
+      permissions.keys.each do |perm|
+        permissions[perm].write! true
+      end
+    end
+
+    # Denies read permission on all existing users and roles attached to this object.
+    # @example
+    #  object.acl
+    #  #    { "*":          { "read" : true },
+    #  #      "3KmCvT7Zsb": { "read" : true, "write": true },
+    #  #      "role:Admins": { "write": true }
+    #  #     }
+    #  object.acl.no_read!
+    #  # Outcome:
+    #  #    { "*":          nil,
+    #  #      "3KmCvT7Zsb": { "write": true },
+    #  #      "role:Admins": { "write": true }
+    #  #     }
+    # @version 1.7.2
+    # @return [Array] list of ACL keys
+    def no_read!
+      will_change!
+      permissions.keys.each do |perm|
+        permissions[perm].read! false
+      end
+    end
+
+    # Denies write permission on all existing users and roles attached to this object.
+    # @example
+    #  object.acl
+    #  #    { "*":          { "read" : true },
+    #  #      "3KmCvT7Zsb": { "read" : true, "write": true },
+    #  #      "role:Admins": { "write": true }
+    #  #     }
+    #  object.acl.no_write!
+    #  # Outcome:
+    #  #    { "*":          { "read" : true },
+    #  #      "3KmCvT7Zsb": { "read" : true },
+    #  #      "role:Admins": nil
+    #  #     }
+    # @version 1.7.2
+    # @return [Array] list of ACL keys
+    def no_write!
+      will_change!
+      permissions.keys.each do |perm|
+        permissions[perm].write! false
+      end
+    end
+
     # The Permission class tracks the read and write permissions for a specific
     # ACL entry. The value of an Parse-ACL hash only contains two keys: "read" and "write".
     #
     #  # Example of the ACL format
     #   { "*":          { "read": true },
-    #     "3KmCvT7Zsb": { "read": true, "write": true }
+    #     "3KmCvT7Zsb": { "read": true, "write": true },
+    #     "role:Admins": { "write": true }
     #   }
     # This would be managed as:
     #   { "*":          ACL::Permission.new(true),
     #     "3KmCvT7Zsb": ACL::Permission.new(true, true)
+    #     "role:Amdins": ACL::Permission.new(false,true)
     #   }
     #
     class Permission
@@ -380,6 +501,36 @@ module Parse
         @read.present? || @write.present?
       end
 
+      # Sets the *read* value of the permission. Defaults to true.
+      # @note Setting the value in this manner is not dirty tracked.
+      # @version 1.7.2
+      # @return [void]
+      def read!(value = true)
+        @read = value
+      end
+
+      # Sets the *write* value of the permission. Defaults to true.
+      # @note Setting the value in this manner is not dirty tracked.
+      # @version 1.7.2
+      # @return [void]
+      def write!(value = true)
+        @write = value
+      end
+
+      # Sets the *read* value of the permission to false.
+      # @version 1.7.2
+      # @return [void]
+      def no_read!
+        @write = false
+      end
+
+      # Sets the *write* value of the permission to false.
+      # @version 1.7.2
+      # @return [void]
+      def no_write!
+        @write = false
+      end
+
     end
   end
 end

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

@@ -19,14 +19,15 @@ module Parse
 
     # A CollectionProxy is a special type of array wrapper that notifies a delegate
     # object about changes to the array in order to perform dirty tracking. This is
-    # used for all Array properties in Parse::Objects.
+    # used for all Array properties in Parse::Objects. Subclasses of {CollectionProxy} are
+    # also available for supporting different association types such as an array of Parse pointers
+    # and Parse relations.
+    # @see PointerCollectionProxy
+    # @see RelationCollectionProxy
     class CollectionProxy
       include ::ActiveModel::Model
       include ::ActiveModel::Dirty
       include ::Enumerable
-      # @!attribute [rw] collection
-      #  The internal backing store of the collection.
-      #  @return [Array]
 
       # @!attribute [r] delegate
       #  The object to be notified of changes to the collection.
@@ -75,7 +76,7 @@ module Parse
       # @param params [Object] method parameters
       # @return [Object] the return value from the forwarded method.
       def forward(method, params = nil)
-        return unless @delegate.present? && @delegate.respond_to?(method)
+        return unless @delegate && @delegate.respond_to?(method)
         params.nil? ? @delegate.send(method) : @delegate.send(method, params)
       end
 
@@ -110,16 +111,18 @@ module Parse
         collection.to_a
       end; alias_method :to_ary, :to_a
 
-      # @!attribute [rw] collection
-      #  Set the internal collection of items without dirty tracking or
-      #  change notifications.
+      # Set the internal collection of items *without* dirty tracking or
+      # change notifications.
       # @return [Array] the collection
       def set_collection!(list)
         @collection = list
       end
 
       # @!attribute [rw] collection
-      #  The internal backing store of the collection.
+      #  The internal backing store of the collection containing the content. This value is lazily
+      #  loaded for some subclasses.
+      # @note If you modify this directly, it is highly recommended that you
+      #  call {CollectionProxy#notify_will_change!} to notify the dirty tracking system.
       # @return [Array] contents of the collection.
       def collection
         if @collection.empty? && @loaded == false
@@ -145,6 +148,72 @@ module Parse
         @collection
       end; alias_method :push, :add
 
+      # Add items to the collection if they don't already exist
+      # @param items [Array] items to uniquely add
+      # @return [Array] the collection.
+      def add_unique(*items)
+        return unless items.count > 0
+        notify_will_change!
+        @collection = collection | items.flatten
+        @collection
+      end; alias_method :push_unique, :add_unique
+
+      # Set Union - Returns a new array by joining two arrays, excluding
+      # any duplicates and preserving the order from the original array.
+      # It compares elements using their hash and eql? methods for efficiency.
+      # See {https://docs.ruby-lang.org/en/2.0.0/Array.html#method-i-hash Array#|}
+      # @example
+      #    [ "a", "b", "c" ] | [ "c", "d", "a" ] #=> [ "a", "b", "c", "d" ]
+      # @param items [Array] items to uniquely add
+      # @see #add_unique
+      # @return [Array] array with unique items
+      def |(items)
+        collection | [items].flatten
+      end
+
+      # Set Intersection - Returns a new array containing unique elements common
+      # to the two arrays. The order is preserved from the original array.
+      #
+      # It compares elements using their hash and eql? methods for efficiency.
+      # See {https://ruby-doc.org/core-2.4.1/Array.html#method-i-26 Array#&}
+      # @example
+      #   [ 1, 1, 3, 5 ] & [ 3, 2, 1 ]                 #=> [ 1, 3 ]
+      #   [ 'a', 'b', 'b', 'z' ] & [ 'a', 'b', 'c' ]   #=> [ 'a', 'b' ]
+      # @param other_ary [Array]
+      # @return [Array] intersection array
+      def &(other_ary)
+        collection & [other_ary].flatten
+      end
+
+      # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-2D Array Difference}.
+      # Returns a new array that is a copy of the original array, removing any
+      # items that also appear in other_ary. The order is preserved from the
+      # original array.
+      # @example
+      #   [ 1, 1, 2, 2, 3, 3, 4, 5 ] - [ 1, 2, 4 ]  #=>  [ 3, 3, 5 ]
+      # @param other_ary [Array]
+      # @return [Array] delta array
+      def -(other_ary)
+        collection - [other_ary].flatten
+      end
+
+      # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-2B Array Concatenation}.
+      # Returns a new array built by concatenating the two arrays together to
+      # produce a third array.
+      # @example
+      #   [ 1, 2, 3 ] + [ 4, 5 ] #=> [ 1, 2, 3, 4, 5 ]
+      # @param other_ary [Array]
+      # @return [Array] concatenated array
+      def +(other_ary)
+        collection + [other_ary].flatten.to_a
+      end
+
+      # Alias {https://ruby-doc.org/core-2.4.1/Array.html#method-i-flatten Array flattening}.
+      # @return [Array] a flattened one-dimensional array
+      def flatten
+        collection.flatten
+      end
+
       # Remove items from the collection
       # @param items [Array] items to remove
       def remove(*items)
@@ -232,8 +301,8 @@ module Parse
       end
 
       # @return [Hash] a JSON representation
-      def as_json(*args)
-        collection.as_json(args)
+      def as_json(opts = nil)
+        collection.as_json(opts)
       end
 
       # true if the collection is empty.
@@ -273,6 +342,19 @@ module Parse
         collection.select &Proc.new
       end
 
+      # Alias for Array#uniq
+      def uniq
+        return collection.uniq(&Proc.new) if block_given?
+        return collection.uniq
+      end
+
+      # Alias for Array#uniq!
+      def uniq!
+        notify_will_change!
+        return collection.uniq!(&Proc.new) if block_given?
+        return collection.uniq!
+      end
+
       # @!visibility private
       def inspect
         "#<#{self.class} changed?=#{changed?} @collection=#{@collection.inspect} >"

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

@@ -17,8 +17,10 @@ module Parse
 
     # @!attribute [rw] collection
     #  The internal backing store of the collection.
-    # @return [Array<Parse::Object>]
-    # @see CollectionProxy#collection
+    #  @note If you modify this directly, it is highly recommended that you
+    #   call {CollectionProxy#notify_will_change!} to notify the dirty tracking system.
+    #  @return [Array<Parse::Object>]
+    #  @see CollectionProxy#collection
     def collection=(c)
       notify_will_change!
       @collection = c
@@ -96,8 +98,8 @@ module Parse
     end
 
     # Encode the collection as a JSON object of Parse::Pointers.
-    def as_json(*args)
-      collection.parse_pointers.as_json
+    def as_json(opts = nil)
+      parse_pointers.as_json(opts)
     end
 
     # @return [Array<Parse::Pointer>] an array of pointers representing this collection.

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

@@ -415,6 +415,19 @@ module Parse
       response.success? ? Parse::User.build(response.result) : nil
     end
 
+    # If the current session token for this instance is nil, this method finds
+    # the most recent active Parse::Session token for this user and applies it to the instance.
+    # The user instance will now be authenticated and logged in with the selected session token.
+    # Useful if you need to call save or destroy methods on behalf of a logged in user.
+    # @return [String] The session token or nil if no session was found for this user.
+    def any_session!
+      unless @session_token.present?
+        _active_session = active_sessions(restricted: false, order: :updated_at.desc).first
+        self.session_token = _active_session.session_token if _active_session.present?
+      end
+      @session_token
+    end
+
   end
 
 end

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

@@ -149,12 +149,12 @@ module Parse
         # Finds the first object matching the query conditions, or creates a new
         # unsaved object with the attributes. This method takes the possibility of two hashes,
         # therefore make sure you properly wrap the contents of the input with `{}`.
+        # @example
         #   Parse::User.first_or_create({ ..query conditions..})
-        #   Parse::User.first_or_create({ ..query conditions..}, {.. resrouce_attrs ..})
+        #   Parse::User.first_or_create({ ..query conditions..}, {.. resource_attrs ..})
         # @param query_attrs [Hash] a set of query constraints that also are applied.
         # @param resource_attrs [Hash] a set of attribute values to be applied if an object was not found.
         # @return [Parse::Object] a Parse::Object, whether found by the query or newly created.
-        # @see Parse::Model.autosave_on_create
         def first_or_create(query_attrs = {}, resource_attrs = {})
 
           query_attrs = query_attrs.symbolize_keys
@@ -163,9 +163,25 @@ module Parse
 
           if obj.blank?
             obj = self.new query_attrs
-            obj.apply_attributes!(resource_attrs, dirty_track: false)
+            obj.apply_attributes!(resource_attrs, dirty_track: true)
           end
-          obj.save if obj.new? && Parse::Model.autosave_on_create
+          obj
+        end
+
+        # Finds the first object matching the query conditions, or creates a new
+        # *saved* object with the attributes. This method is similar to {first_or_create}
+        # but will also {save!} the object if it was newly created.
+        # @example
+        #   obj = Parse::User.first_or_create!({ ..query conditions..})
+        #   obj = Parse::User.first_or_create!({ ..query conditions..}, {.. resource_attrs ..})
+        # @param query_attrs [Hash] a set of query constraints that also are applied.
+        # @param resource_attrs [Hash] a set of attribute values to be applied if an object was not found.
+        # @return [Parse::Object] a Parse::Object, whether found by the query or newly created.
+        # @raise {Parse::RecordNotSaved} if the save fails
+        # @see #first_or_create
+        def first_or_create!(query_attrs = {}, resource_attrs = {})
+          obj = first_or_create(query_attrs, resource_attrs)
+          obj.save! if obj.new?
           obj
         end
 
@@ -185,7 +201,7 @@ module Parse
         #    # it will automatically be saved
         #  end
         # @note You cannot use *:updated_at* as a constraint.
-        # @return [Boolean] whether there were any errors.
+        # @return [Boolean] true if all saves succeeded and there were no errors.
         def save_all(constraints = {})
           invalid_constraints = constraints.keys.any? do |k|
             (k == :updated_at || k == :updatedAt) ||
@@ -256,7 +272,7 @@ module Parse
 
             has_errors ||= batch.error?
           end
-          has_errors
+          not has_errors
         end
 
       end # ClassMethods
@@ -479,7 +495,7 @@ module Parse
       #
       # You can define before and after :save callbacks
       # autoraise: set to true will automatically raise an exception if the save fails
-      # @raise Parse::RecordNotSaved if the save fails
+      # @raise {Parse::RecordNotSaved} if the save fails
       # @raise ArgumentError if a non-nil value is passed to `session` that doesn't provide a session token string.
       # @param session [String] a session token in order to apply ACLs to this operation.
       # @param autoraise [Boolean] whether to raise an exception if the save fails.
@@ -519,7 +535,7 @@ module Parse
       end
 
       # Save this object and raise an exception if it fails.
-      # @raise Parse::RecordNotSaved if the save fails
+      # @raise {Parse::RecordNotSaved} if the save fails
       # @raise ArgumentError if a non-nil value is passed to `session` that doesn't provide a session token string.
       # @param session (see #save)
       # @return (see #save)

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

@@ -88,17 +88,18 @@ module Parse
       # required: (data_type)
       # default: (value or Proc)
       # alias: Whether to create the remote field alias getter/setters for this attribute
+
+      # symbolize: Makes sure the saved and return value locally is in symbol format. useful
+      # for enum type fields that are string columns in Parse. Ex. a booking_status for a field
+      # could be either "submitted" or "completed" in Parse, however with symbolize, these would
+      # be available as :submitted or :completed.
+
       # This is the class level property method to be used when declaring properties. This helps builds specific methods, formatters
       # and conversion handlers for property storing and saving data for a particular parse class.
       # The first parameter is the name of the local attribute you want to declare with its corresponding data type.
       # Declaring a `property :my_date, :date`, would declare the attribute my_date with a corresponding remote column called
       # "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.
-
-      # symbolize: Makes sure the saved and return value locally is in symbol format. useful
-      # for enum type fields that are string columns in Parse. Ex. a booking_status for a field
-      # could be either "submitted" or "completed" in Parse, however with symbolize, these would
-      # be available as :submitted or :completed.
       def property(key, data_type = :string, **opts)
 
         key = key.to_sym
@@ -300,6 +301,12 @@ module Parse
             # lets set the variable with the updated value
              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
+            # don't send the notification yet until they actually add something
+            # which will be handled by the collection proxy.
+            # send will_change_method
           end
 
           # if the value is a String (like an iso8601 date) and the data type of

data/lib/parse/model/date.rb

@@ -60,6 +60,7 @@ class Time
   end
 
 end
+
 # Adds extensions to DateTime class to be compatible with {Parse::Date}.
 class DateTime
   # @return [Parse::Date] Converts object to Parse::Date
@@ -78,3 +79,11 @@ module ActiveSupport
     end
   end
 end
+
+# Adds extensions to Date class to be compatible with {Parse::Date}.
+class Date
+  # @return [Parse::Date] Converts object to Parse::Date
+  def parse_date
+    Parse::Date.parse iso8601
+  end
+end

data/lib/parse/model/model.rb

@@ -86,19 +86,6 @@ module Parse
     # @!visibility private
     @@model_cache = {}
 
-    # @!attribute self.autosave_on_create
-    # If set to true, a call to {Parse::Object.first_or_create} will automatically save the object.
-    # Default is false.
-    # @return [Boolean]
-    def self.autosave_on_create
-      @@autosave_on_create ||= false
-    end
-
-    # @!visibility private
-    def self.autosave_on_create=(bool)
-      @@autosave_on_create = bool
-    end
-
     class << self
       # @!attribute self.raise_on_save_failure
       # By default, we return `true` or `false` for save and destroy operations.

data/lib/parse/model/object.rb

@@ -274,8 +274,10 @@ module Parse
     end
 
     # @return [Hash] a json-hash representing this object.
-    def as_json(*args)
-      pointer? ? pointer : super(*args)
+    def as_json(opts = nil)
+      return pointer if pointer?
+      changed_fields = changed_attributes
+      super(opts).delete_if { |k, v| v.nil? && !changed_fields.has_key?(k) }
     end
 
     # The main constructor for subclasses. It can take different parameter types
@@ -366,13 +368,17 @@ module Parse
       @id.blank?
     end
 
-    # Existed returns true/false depending whether the object
-    # had existed before *its last save operation*. This implies
-    # that the created_at and updated_at dates are exactly the same. This
-    # is a helper method in a webhook afterSave to know if this object was recently
-    # saved in the beforeSave webhook.
+    # Existed returns true if the object had existed before *its last save
+    # operation*. This method returns false if the {Parse::Object#created_at}
+    # and {Parse::Object#updated_at} dates of an object are equal, implyiny this
+    # object has been newly created and saved (especially in an afterSave hook).
+    #
+    # This is a helper method in a webhook afterSave to know
+    # if this object was recently saved in the beforeSave webhook. Checking for
+    # {Parse::Object#existed?} == false in an afterSave hook, is equivalent to using
+    # {Parse::Object#new?} in a beforeSave hook.
     # @note You should not use this method inside a beforeSave webhook.
-    # @return [Boolean] true if the last beforeSave webhook successfully saved this object for the first time.
+    # @return [Boolean] true iff the last beforeSave successfully saved this object for the first time.
     def existed?
       if @id.blank? || @created_at.blank? || @updated_at.blank?
         return false
@@ -409,7 +415,7 @@ module Parse
     end
 
     # Overrides ActiveModel::Validations#validate! instance method.
-    # It runs all valudations for this object. If it validation fails,
+    # It runs all validations for this object. If validation fails,
     # it raises ActiveModel::ValidationError otherwise it returns the object.
     # @raise ActiveModel::ValidationError
     # @see ActiveModel::Validations#validate!

data/lib/parse/model/pointer.rb

@@ -156,6 +156,17 @@ module Parse
       end
       alias_method :eql?, :==
 
+      # Compute a hash-code for this object. It is calculated
+      # by combining the Parse class name, the {Parse::Object#id} field and
+      # any pending changes.
+      #
+      # Two objects with the same content will have the same hash code
+      # (and will compare using eql?).
+      # @return [Fixnum]
+      def hash
+        "#{parse_class}#{id}#{changes.to_s}".hash
+      end
+
       # @return [Boolean] true if instance has a Parse class and an id.
       def present?
         parse_class.present? && @id.present?

data/lib/parse/query.rb

@@ -333,7 +333,9 @@ module Parse
         end
       end # each
       self #chaining
-    end; alias_method :query, :conditions
+    end
+    alias_method :query, :conditions
+    alias_method :append, :conditions
 
     def table=(t)
       @table = t.to_s.camelize

data/lib/parse/query/constraint.rb

@@ -3,6 +3,7 @@
 
 require_relative 'operation'
 require 'time'
+require 'date'
 
 module Parse
   # Constraints are the heart of the Parse::Query system.
@@ -104,7 +105,12 @@ module Parse
       def formatted_value(value)
         d = value
         d = { __type: Parse::Model::TYPE_DATE, iso: d.utc.iso8601(3) } if d.respond_to?(:utc)
-        d = { __type: Parse::Model::TYPE_DATE, iso: d.iso8601(3) } if d.respond_to?(:iso8601)
+        # if it responds to parse_date (most likely a time/date object), then call the conversion
+        d = d.parse_date if d.respond_to?(:parse_date)
+        # if it's not a Parse::Date, but still responds to iso8601, then do it manually
+        if d.is_a?(Parse::Date) == false && d.respond_to?(:iso8601)
+          d = { __type: Parse::Model::TYPE_DATE, iso: d.iso8601(3) }
+        end
         d = d.pointer if d.respond_to?(:pointer) #simplified query object
         d = d.to_s if d.is_a?(Regexp)
         # d = d.pointer if d.is_a?(Parse::Object) #simplified query object

data/lib/parse/query/constraints.rb

@@ -33,6 +33,7 @@ module Parse
     #
     #  # find all songs for this artist object
     #  Song.all :artist => artist
+    #
     # In some cases, you do not have the Parse object, but you have its `objectId`.
     # You can use the objectId in the query as follows:
     #
@@ -40,6 +41,7 @@ module Parse
     #  Song.all :artist.id => artist_id
     #
     #  # other approaches, same result
+    #  Song.all :artist.id => artist # safely supported Parse::Pointer
     #  Song.all :artist => Artist.pointer(artist_id)
     #  Song.all :artist => Parse::Pointer.new("Artist", artist_id)
     #
@@ -48,6 +50,7 @@ module Parse
       # A registered method on a symbol to create the constraint.
       # @example
       #  q.where :field.id => "someObjectId"
+      #  q.where :field.id => pointer # safely supported
       # @return [ObjectIdConstraint]
       register :id
 
@@ -55,6 +58,10 @@ module Parse
       def build
         className = operand.to_parse_class
         value = formatted_value
+        # if it is already a pointer value, just return the constraint. Allows for
+        # supporting strings, symbols and pointers.
+        return { @operation.operand  => value } if value.is_a?(Parse::Pointer)
+
         begin
           klass = className.constantize
         rescue NameError => e

data/lib/parse/stack/generators/templates/model_installation.rb

@@ -1,5 +1,4 @@
 
-# The Parse _Installation collection
 class Parse::Installation < Parse::Object
   # See: https://github.com/modernistik/parse-stack#parseinstallation
   # add additional properties here

data/lib/parse/stack/generators/templates/model_role.rb

@@ -1,5 +1,4 @@
 
-# The Parse _Role collection
 class Parse::Role < Parse::Object
   # See: https://github.com/modernistik/parse-stack#parserole
   # add additional properties here

data/lib/parse/stack/generators/templates/model_session.rb

@@ -1,5 +1,4 @@
 
-# The Parse _Session collection
 class Parse::Session < Parse::Object
   # See: https://github.com/modernistik/parse-stack#parsesession
   # add additional properties here

data/lib/parse/stack/generators/templates/model_user.rb

@@ -1,5 +1,4 @@
 
-# The Parse _User collection
 class Parse::User < Parse::Object
   # add additional properties
 

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.1"
+    VERSION = "1.7.2"
   end
 end

data/lib/parse/webhooks/payload.rb

@@ -98,6 +98,17 @@ module Parse
         ATTRIBUTES
       end
 
+      # Method to print to standard that utilizes the an internal id to make it easier
+      # to trace incoming requests.
+      def wlog(s)
+        # generates a unique random number in order to be used in logging. This
+        # is useful when debugging issues in production where one server instance
+        # may be running multiple threads and you want to trace the incoming call.
+        @rid ||= rand(999).to_s.rjust(3)
+        puts "[> #{@rid}] #{s}"
+        @rid
+      end
+
       # true if this is a webhook function request.
       def function?
         @function_name.present?

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 1.7.2
 platform: ruby
 authors:
 - Anthony Persaud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-12 00:00:00.000000000 Z
+date: 2017-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -275,7 +275,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Parse Server Ruby Client SDK