parse-stack 1.3.8 → 1.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 18eab2bb5c64686e9b7713d4083db00fd5b7d026
-  data.tar.gz: 21cc6c542518c284edcd90c8ff8c09df4883dd30
+  metadata.gz: ba96b9a68cd8bee15dfcd3f63b00fe7b3ce66a79
+  data.tar.gz: 627c40c21e1866fd1473171cc5794f48becd2d0e
 SHA512:
-  metadata.gz: 38a5decb6fbbb89caa454ac583ea9cfbad0929a59bbfa78b86befc00bb53a861f040951ce9bb6013a6b03bb0fb086bd98438c00927da2030a66cb57798159858
-  data.tar.gz: 8c16ed21c5c450270382d8223d010978de8950cbd9cfaf3172d2915f1e81d73a151b55176b61e41f1fbd662fa6a8c1554e620650c9a92aec84cdb26446fd26b3
+  metadata.gz: ad583e23a9af975fef0dd3e3a5badfe4a494a1754778d7f14c48b0aecd26863cd915994a1609a07824bfadb39ddb298dd69d83cb6ec23a1089d81e3c2be782c7
+  data.tar.gz: 59cc21ab26200badfd575729a9ee47b239374b948b6715fdc36418a8077edf4f86d035904e84c675996a1d0cb21b9ea0832364f2b64ef819d32471129b44a944

data/Changes.md

@@ -1,5 +1,17 @@
 # Parse-Stack Changes
 
+1.4.2
+-----------
+- NEW: Support for rails generators: `parse_stack:install` and `parse_stack:model`.
+- Support Parse::Date with ActiveSupport::TimeWithZone.
+- :date properties will now raise an error if value was not converted to a Parse::Date.
+- Support for calling `before_save` and `before_destroy` callbacks in your model when a Parse::Object is returned by your `before_save` or `before_delete` webhook respectively.
+- Parse::Query `:cache` expression now allows integer values to define the specific cache duration for this specific query request. If `false` is passed, will ignore the cache and make the request regardless if a cache response is available. If `true` is passed (default), it will use the value configured when setting up when calling `Parse.setup`.
+- Fixes the use of `:use_master_key` in Parse::Query.
+- Fixes to the cache key used in middleware.
+- Parse::User before_save callback clears the record ACLs.
+- Added `anonymous?` instance method to `Parse::User` class.
+
 1.3.8
 -----------
 - Support for reloading the Parse config data with `Parse.config!`.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parse-stack (1.3.8)
+    parse-stack (1.4.3)
       active_model_serializers (>= 0.9, < 1)
       activemodel (>= 4.2.1, < 6)
       activesupport (>= 4.2.1, < 6)

data/README.md

@@ -5,6 +5,35 @@ Parse-Stack is a [Parse Server](https://github.com/ParsePlatform/parse-server) R
 [![Gem Version](https://badge.fury.io/rb/parse-stack.svg)](https://badge.fury.io/rb/parse-stack)
 [![Build Status](https://travis-ci.org/modernistik/parse-stack.svg?branch=master)](https://travis-ci.org/modernistik/parse-stack)
 
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'parse-stack'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install parse-stack
+
+### Rails
+Parse-Stack comes with support for Rails by adding additional rake tasks and generators. After adding `parse-stack` as a gem dependency in your Gemfile and running `bundle`, you should run the install script:
+
+    $ rails g parse_stack:install
+
+This will create a configuration file (`config/initializers/parse.rb`) and a set of sample models and hooks under `app/models` directory. Modify `config/initializers/parse.rb` file with your Parse-Server API keys. You can then generate models with the `parse_stack:model` generator.
+
+    $ rails g parse_stack:model Song name:string released:date genres:array
+
+This would create a `song.rb` file in `app/models` with the provided properties. Once you are ready to update your schema, you can run the `parse:upgrade` task to upgrade the remote Parse-Server schema to match your new models.
+
+    $ rails parse:upgrade
+
+That should create the new collection `Song` in your Parse-Server backend. For a more full featured example, see [Parse-Server-Rails-Example](https://github.com/modernistik/parse-server-rails-example).
+
 ## Table Of Contents
 <!-- START doctoc generated TOC please keep comment here to allow auto update -->
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
@@ -85,18 +114,17 @@ Parse-Stack is a [Parse Server](https://github.com/ParsePlatform/parse-server) R
     - [Bounding Box Constraint](#bounding-box-constraint)
   - [Relational Queries](#relational-queries)
   - [Compound Queries](#compound-queries)
-- [Cloud Code Functions](#cloud-code-functions)
-- [Cloud Code Background Jobs](#cloud-code-background-jobs)
-- [Hooks and Callbacks](#hooks-and-callbacks)
+- [Calling Cloud Code Functions](#calling-cloud-code-functions)
+- [Calling Background Jobs](#calling-background-jobs)
+- [Model Callbacks](#model-callbacks)
 - [Schema Upgrades and Migrations](#schema-upgrades-and-migrations)
 - [Push Notifications](#push-notifications)
 - [Cloud Code Webhooks](#cloud-code-webhooks)
-  - [Cloud Code functions](#cloud-code-functions)
+  - [Cloud Code Functions](#cloud-code-functions)
   - [Cloud Code Triggers](#cloud-code-triggers)
   - [Mounting Webhooks Application](#mounting-webhooks-application)
   - [Register Webhooks](#register-webhooks)
 - [Parse REST API Client](#parse-rest-api-client)
-      - [Options](#options-2)
   - [Request Caching](#request-caching)
 - [Installation](#installation)
 - [Development](#development)
@@ -104,7 +132,7 @@ Parse-Stack is a [Parse Server](https://github.com/ParsePlatform/parse-server) R
 <!-- END doctoc generated TOC please keep comment here to allow auto update -->
 
 ## Overview
-Parse::Stack is a full stack framework that utilizes several ideas behind [DataMapper](http://datamapper.org/docs/find.html) and [ActiveModel](https://github.com/rails/rails/tree/master/activemodel) to manage and maintain larger scale ruby applications and tools that utilize the Parse Platform. If you are familiar with these technologies, the framework should feel familiar to you.
+Parse-Stack is a full stack framework that utilizes several ideas behind [DataMapper](http://datamapper.org/docs/find.html) and [ActiveModel](https://github.com/rails/rails/tree/master/activemodel) to manage and maintain larger scale ruby applications and tools that utilize the Parse Platform. If you are familiar with these technologies, the framework should feel familiar to you.
 
 ```ruby
 
@@ -430,13 +458,18 @@ This class represents the data and columns contained in the standard Parse `_Ins
 
 ```ruby
 class Parse::Installation < Parse::Object
-  property :channels, :array
   property :gcm_sender_id, :string, field: :GCMSenderId
+  property :app_identifier
+  property :app_name
+  property :app_version
   property :badge, :integer
-  property :installation_id
+  property :channels, :array
   property :device_token
+  property :device_token_last_modified, :integer
   property :device_type
+  property :installation_id
   property :locale_identifier
+  property :parse_version
   property :push_type
   property :time_zone
 end
@@ -508,39 +541,39 @@ Using the example above, we can add the base properties to our classes.
 
 ```ruby
 class Post < Parse::Object
-	property :title
-	property :content, :string # explicit
+  property :title
+  property :content, :string # explicit
 
-	# treat the values of this field as symbols instead of strings.
-	property :category, :string, symbolize: true
+  # treat the values of this field as symbols instead of strings.
+  property :category, :string, symbolize: true
 
-	# maybe a count of comments.
-	property :comment_count, :integer, default: 0
+  # maybe a count of comments.
+  property :comment_count, :integer, default: 0
 
   # use lambda to access the instance object.
   # Set draft_date to the created_at date if empty.
   property :draft_date, :date, default: lambda { |x| x.created_at }
   # the published date. Maps to "publishDate"
-	property :publish_date, :date, default: lambda { |x| DateTime.now }
+  property :publish_date, :date, default: lambda { |x| DateTime.now }
 
-	# maybe whether it is currently visible
-	property :visible, :boolean
+  # maybe whether it is currently visible
+  property :visible, :boolean
 
-	# a list using
-	property :tags, :array
+  # a list using
+  property :tags, :array
 
-	# Maps to "featuredImage" column representing a File.
-	property :featured_image, :file
+  # Maps to "featuredImage" column representing a File.
+  property :featured_image, :file
 
-	property :location, :geopoint
+  property :location, :geopoint
 
   # Support bytes
   property :data, :bytes
 
-	# store SEO information. Make sure we map it to the column
-	# "SEO", otherwise it would have implicitly used "seo"
-	# as the remote column name
-	property :seo, :object, field: "SEO"
+  # store SEO information. Make sure we map it to the column
+  # "SEO", otherwise it would have implicitly used "seo"
+  # as the remote column name
+  property :seo, :object, field: "SEO"
 end
 ```
 
@@ -953,7 +986,7 @@ songs.save
 ```
 
 ### Magic `save_all`
-By default, all Parse queries have a maximum fetch limit of 1000. While using the `:max` option, `Parse::Stack` can increase this up to 11,000. In the cases where you need to update a large number of objects, you can utilize the `Parse::Object#save_all` method
+By default, all Parse queries have a maximum fetch limit of 1000. While using the `:max` option, Parse-Stack can increase this up to 11,000. In the cases where you need to update a large number of objects, you can utilize the `Parse::Object#save_all` method
 to fetch, modify and save objects.
 
 This methodology works by continually fetching and saving older records related to the time you begin a `save_all` request (called an "anchor date"), until there are no records left to update. To enable this to work, you must have confidence that any modifications you make to the records will successfully save through you validations that may be present in your `before_save`. This is important, as saving a record will set its `updated_at` date to one newer than the "anchor date" of when the `save_all` started. This `save_all` process will stop whenever no more records match the provided constraints that are older than the "anchor date", or when an object that was previously updated, is seen again in a future fetch (_which means the object failed to save_). Note that `save_all` will automatically manage the correct `updated_at` constraints in the query, so it is recommended that you do not use it as part of the initial constraints.
@@ -1004,7 +1037,7 @@ You can destroy a Parse record, just call the `#destroy` method. It will return
 ```
 
 ### Auto-Fetching Associations
-All associations in `Parse::Stack` are fetched lazily by default. If you wish to include objects as part of your query results you can use the `:includes` expression.
+All associations in are fetched lazily by default. If you wish to include objects as part of your query results you can use the `:includes` expression.
 
 ```ruby
   song = Song.first
@@ -1016,7 +1049,7 @@ All associations in `Parse::Stack` are fetched lazily by default. If you wish to
 
 ```
 
-However, `Parse::Stack` performs automatic fetching of associations when the associated classes and their properties are locally defined. Using our Artist and Song examples. In this example, the Song object fetched only has a pointer object in its `#artist` field. However, because the framework knows there is a `Artist#name` property, calling `#name` on the artist pointer will automatically go to Parse to fetch the associated object and provide you with the value.
+However, Parse-Stack performs automatic fetching of associations when the associated classes and their properties are locally defined. Using our Artist and Song examples. In this example, the Song object fetched only has a pointer object in its `#artist` field. However, because the framework knows there is a `Artist#name` property, calling `#name` on the artist pointer will automatically go to Parse to fetch the associated object and provide you with the value.
 
 ```ruby
   song = Song.first
@@ -1181,11 +1214,14 @@ Use with limit to paginate through results. Default is 0 with maximum value bein
 ```
 
 #### :cache
-A true/false value. If you are using the built-in caching middleware, `Parse::Middleware::Caching`, it will prevent it from using a previously cached result if available. The default value is `true`.
+A `true`, `false` or integer value. If you are using the built-in caching middleware, `Parse::Middleware::Caching`, setting this to `false` will prevent it from using a previously cached result if available. You may pass an integer value, which will allow this request to be cached for the specified number of seconds. The default value is `true`, which uses the [`:expires`](#expires) value that was passed when [configuring the client](#connection-setup).
 
 ```ruby
 # don't use a cached result if available
-Song.all limit: 3, cache: false
+Song.all limit: 500, cache: false
+
+# cache this particular request for 60 seconds
+Song.all limit: 500, cache: 1.minute
 ```
 
 #### :use_master_key
@@ -1201,6 +1237,7 @@ A Parse session token string. If you would like to perform a query as a particul
 
 ```ruby
 # disable sending the master key in the request if configured
+# and perform this request as a Parse user represented by this token
 Song.all limit: 3, session_token: "<session_token>"
 ```
 
@@ -1499,7 +1536,7 @@ query.or_where(:wins.lt => 5)
 results = query.results
 ```
 
-## Cloud Code Functions
+## Calling Cloud Code Functions
 You can call on your defined Cloud Code functions using the `call_function()` method. The result will be `nil` in case of errors or the value of the `result` field in the Parse response.
 
 ```ruby
@@ -1512,7 +1549,7 @@ You can call on your defined Cloud Code functions using the `call_function()` me
  response.result unless response.error?
 ```
 
-## Cloud Code Background Jobs
+## Calling Background Jobs
 You can trigger background jobs that you have configured in your Parse application as follows.
 
 ```ruby
@@ -1525,7 +1562,7 @@ You can trigger background jobs that you have configured in your Parse applicati
  response.result unless response.error?
 ```
 
-## Hooks and Callbacks
+## Model Callbacks
 All `Parse::Object` subclasses extend [`ActiveModel::Callbacks`](http://api.rubyonrails.org/classes/ActiveModel/Callbacks.html) for `#save` and `#destroy` operations. You can setup internal hooks for `before`, `during` and `after`. See
 
 ```ruby
@@ -1542,7 +1579,7 @@ end
 
 song = Song.new name: "my title"
 puts song.name # 'my title'
-song.save
+song.save # runs :save callbacks
 puts song.name # 'My Title'
 
 ```
@@ -1590,24 +1627,34 @@ Push notifications are implemented through the `Parse::Push` class. To send push
 ## Cloud Code Webhooks
 Parse Parse allows you to receive Cloud Code webhooks on your own hosted server. The `Parse::Webhooks` class is a lightweight Rack application that routes incoming Cloud Code webhook requests and payloads to locally registered handlers. The payloads are `Parse::Payload` type of objects that represent that data that Parse sends webhook handlers. You can register any of the Cloud Code webhook trigger hooks (`beforeSave`, `afterSave`, `beforeDelete`, `afterDelete`) and function hooks.
 
-### Cloud Code functions
+### Cloud Code Functions
 You can use the `route()` method to register handler blocks. The last value returned by the block will be returned back to the client in a success response. If `error!(value)` is called inside the block, we will return the correct Parse error response with the value you provided.
 
 ```ruby
 # Register handling the 'helloWorld' function.
 Parse::Webhooks.route(:function, :helloWorld) do
   #  use the Parse::Payload instance methods in this block
-  incoming_params = params #function params
-  name = params['name'].to_s
-
+  name = params['name'].to_s #function params
+  puts "CloudCode Webhook helloWorld called in Ruby!"
   # will return proper error response
-  error!("Missing argument 'name'.") unless name.present?
-  # return early
-  "Hello #{name}!"
+  # error!("Missing argument 'name'.") unless name.present?
+
+  name.present? ? "Hello #{name}!" : "Hello World!"
 end
 
 # Advanced: you can register handlers through classes if you prefer
-Parse::Webhooks.route :function, :myFunc, MyClass.method(:my_func)
+# Parse::Webhooks.route :function, :myFunc, MyClass.method(:my_func)
+```
+
+If you have registered this webhook (see instructions below), you should be able to test it out by running curl using the command below. For a more in-depth example, see [Parse-Server-Rails-Example](https://github.com/modernistik/parse-server-rails-example).
+
+```bash
+curl -X POST \
+  -H "X-Parse-Application-Id: ${APPLICATION_ID}" \
+  -H "X-Parse-REST-API-Key: ${REST_API_KEY}" \
+  -H "Content-Type: application/json" \
+  -d '{}' \
+  https://api.parse.com/1/functions/helloWorld
 ```
 
 If you are creating `Parse::Object` subclasses, you may also register them there to keep common code and functionality centralized.
@@ -1619,7 +1666,7 @@ class Song < Parse::Object
     the_user = user # available if a Parse user made the call
     params = params
     # ... do stuff ...
-    true
+    some_result
   end
 
 end
@@ -1653,7 +1700,7 @@ You can register webhooks to handle the different object triggers: `:before_save
 
 For any `after_*` hook, return values are not needed since Parse does not utilize them. You may also register as many `after_save` or `after_delete` handlers as you prefer, all of them will be called.
 
-`before_save` and `before_delete` hooks have special functionality. When the `error!` method is called by the provided block, the framework will return the correct error response to Parse with value provided. Returning an error will prevent Parse from saving the object in the case of `before_save` and will prevent Parse from deleting the object when in a `before_delete`. In addition, for a `before_save`, the last value returned by the block will be the value returned in the success response. If the block returns nil or an `empty?` value, it will return `true` as the default response. You can also return a JSON object in a hash format to override the values that will be saved for the object. For this, we recommend using the `payload_update` method. For more details, see [Cloud Code BeforeSave Webhooks](https://parse.com/docs/cloudcode/guide#cloud-code-advanced-beforesave-webhooks)
+`before_save` and `before_delete` hooks have special functionality. When the `error!` method is called by the provided block, the framework will return the correct error response to Parse with value provided. Returning an error will prevent Parse from saving the object in the case of `before_save` and will prevent Parse from deleting the object when in a `before_delete`. In addition, for a `before_save`, the last value returned by the block will be the value returned in the success response. If the block returns nil or an `empty?` value, it will return `true` as the default response. You can also return a JSON object in a hash format to override the values that will be saved. However, we recommend modifying the `parse_object` provided since it has dirty tracking, and then returning that same object. This will automatically call your model specific `before_save` callbacks and send the proper payload back to Parse. For more details, see [Cloud Code BeforeSave Webhooks](https://parse.com/docs/cloudcode/guide#cloud-code-advanced-beforesave-webhooks)
 
 ```ruby
 # recommended way
@@ -1680,7 +1727,7 @@ class Artist < Parse::Object
     end
 
     # *important* returns a special hash of changed values
-    artist.payload_update
+    artist
   end
 
   webhook :before_delete do
@@ -1696,16 +1743,16 @@ end
 The app can be mounted like any regular Rack-based application.
 
 ```ruby
-  # Rack in config.ru
+  # Rack (add this to config.ru)
   map "/webhooks" do
     run Parse::Webhooks
   end
 
-  # Padrino (in apps.rb)
+  # or in Padrino (add this to apps.rb)
   Padrino.mount('Parse::Webhooks', :cascade => true).to('/webhooks')
 
-  # Rails
-  RailsApp::Application.routes.draw do
+  # or in Rails (add this in routes.rb)
+  Rails.application.routes.draw do
     mount Parse::Webhooks, :at => '/webhooks'
   end
 ```
@@ -1733,16 +1780,12 @@ end
 
 ```
 
-However, we have predefined a few rake tasks you can use in your application. Just require `parse/stack/tasks` in your `Rakefile` and call `Parse::Stack.load_tasks`. This is useful for web frameworks like `Padrino` and `Rails`.
+However, we have predefined a few rake tasks you can use in your application. Just require `parse/stack/tasks` in your `Rakefile` and call `Parse::Stack.load_tasks`. This is useful for web frameworks like `Padrino`. Note that if you are using Parse-Stack with Rails, this is automatically done for you through the Railtie.
 
 ```ruby
-  # Rails Rakefile example
-  require_relative 'config/application'
+  # Add to your Rakefile (if not using Rails)
   require 'parse/stack/tasks' # add this line
-
-  Rails.application.load_tasks
   Parse::Stack.load_tasks # add this line
-
 ```
 
 Then you can see the tasks available by typing `rake -T`.

data/bin/console

@@ -11,6 +11,11 @@ Parse.setup
 
 class Song < Parse::Object
   property :name
+
+  before_save do
+    self.name = self.name.truncate(60)
+  end
+
 end
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.

data/lib/parse/api/batch.rb

@@ -48,7 +48,6 @@ module Parse
   end
 
   class BatchOperation
-    MAX_REQ_SEC = 30
 
     attr_accessor :requests, :responses
     include Enumerable
@@ -120,7 +119,7 @@ module Parse
       @requests.each_slice(segment) do |slice|
         @responses << client.batch_request( BatchOperation.new(slice) )
         #throttle
-        sleep (slice.count.to_f / MAX_REQ_SEC.to_f )
+        # sleep (slice.count.to_f / MAX_REQ_SEC.to_f )
       end
       @responses.flatten!
       #puts "Requests: #{@requests.count} == Response: #{@responses.count}"

data/lib/parse/client.rb

@@ -54,7 +54,7 @@ module Parse
     include Parse::API::Push
     include Parse::API::Schema
     RETRY_COUNT = 2
-    RETRY_DELAY = 3 #seconds
+    RETRY_DELAY = 2 #seconds
 
     attr_accessor :session, :cache
     attr_reader :application_id, :api_key, :master_key, :server_url
@@ -189,13 +189,13 @@ module Parse
       # http method
       method = method.downcase.to_sym
       # set the User-Agent
-      headers["User-Agent".freeze] = "Parse-Stack Ruby Client v#{Parse::Stack::VERSION}".freeze
+      headers["User-Agent".freeze] = "Parse-Server Ruby Client v#{Parse::Stack::VERSION}".freeze
 
       if opts[:cache] == false
-        headers[Parse::Middleware::Caching::CACHE_CONTROL] = "no-cache"
+        headers[Parse::Middleware::Caching::CACHE_CONTROL] = "no-cache".freeze
       elsif opts[:cache].is_a?(Numeric)
-        # future feature
-        # headers[Parse::Middleware::Caching::CACHE_CONTROL] = "max-age: #{opts[:cache].to_i}"
+        # specify the cache duration of this request
+        headers[Parse::Middleware::Caching::CACHE_EXPIRES_DURATION] = opts[:cache].to_i
       end
 
       if opts[:use_master_key] == false
@@ -259,15 +259,20 @@ module Parse
       response
     rescue Parse::ServiceUnavailableError => e
       if retry_count > 0
-        puts "[Parse:ServiceUnavailableError] Retries remaining #{retry_count} : #{response.request}"
+        puts "[Parse:Retry] Retries remaining #{retry_count} : #{response.request}"
         sleep RETRY_DELAY
         retry_count -= 1
         retry
       end
       raise e
     rescue Faraday::Error::ClientError, Net::OpenTimeout => e
-      puts "[Parse:ConnectionError] Faraday/Net:OpenTimeout : #{e.message}"
-      raise Parse::ConnectionError, e.message
+      if retry_count > 0
+        puts "[Parse:Retry] Retries remaining #{retry_count} : #{_request}"
+        sleep RETRY_DELAY
+        retry_count -= 1
+        retry
+      end
+      raise Parse::ConnectionError, "#{_request} : #{e.class} - #{e.message}"
     end
 
     # shorthand for request(:get, uri, query: {})

data/lib/parse/client/caching.rb

@@ -5,6 +5,7 @@ require_relative 'protocol'
 # This is a caching middleware for Parse queries using Moneta.
 module Parse
   module Middleware
+    class CachingError < Exception; end;
     class Caching < Faraday::Middleware
       include Parse::Protocol
       # Cache-Control: no-cache
@@ -18,6 +19,7 @@ module Parse
          # * 410 - 'Gone' - removed
       CACHEABLE_HTTP_CODES = [200, 203, 300, 301, 302].freeze
       CACHE_CONTROL = 'Cache-Control'.freeze
+      CACHE_EXPIRES_DURATION = 'X-Parse-Stack-Cache-Expires'.freeze
 
       class << self
         attr_accessor :enabled, :logging
@@ -43,7 +45,7 @@ module Parse
         @expires = @opts[:expires]
 
         unless @store.is_a?(Moneta::Transformer)
-          raise "Parse::Middleware::Caching store object must a Moneta key/value store."
+          raise Parse::Middleware::CachingError, "Caching store object must a Moneta key/value store (Moneta::Transformer)."
         end
 
       end
@@ -53,54 +55,64 @@ module Parse
       end
 
       def call!(env)
+        @request_headers =  env[:request_headers]
 
-        #unless caching is enabled and we have a valid cache duration
-        # then just work as a passthrough
-        return @app.call(env) unless @store.present? && @expires > 0 && self.class.enabled
-
-        cache_enabled = true
+        # get default caching state
+        @enabled = self.class.enabled
+        # disable cache for this request if "no-cache" was passed
+        if @request_headers[CACHE_CONTROL] == "no-cache".freeze
+          @enabled = false
+        end
 
-        if env[:request_headers][CACHE_CONTROL] == "no-cache".freeze
-          cache_enabled = false
+        # get the expires information from header (per-request) or instance default
+        if @request_headers[CACHE_EXPIRES_DURATION].to_i > 0
+          @expires = @request_headers[CACHE_EXPIRES_DURATION].to_i
         end
 
+        # cleanup
+        @request_headers.delete(CACHE_CONTROL)
+        @request_headers.delete(CACHE_EXPIRES_DURATION)
+
+        # 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
+
         url = env.url
         method = env.method
+        @cache_key = url.to_s
         begin
-          if cache_enabled && method == :get && url.present? && @store.key?(url)
-            puts("[Parse::Cache] >>> #{url}") if self.class.logging.present?
+          if method == :get && @cache_key.present? && @store.key?(@cache_key)
+            puts("[Parse::Cache::Hit] >> #{url}") if self.class.logging.present?
             response = Faraday::Response.new
-            res_env = @store[url] # previous cached response
+            res_env = @store[@cache_key] # previous cached response
             body = res_env.respond_to?(:body) ? res_env.body : nil
             if body.present?
               response.finish({status: 200, response_headers: { "X-Cache-Response" => true }, body: body })
               return response
             else
-              @store.delete url
+              @store.delete @cache_key
             end
-          elsif cache_enabled && url.present?
+          elsif @cache_key.present?
             #non GET requets should clear the cache for that same resource path.
             #ex. a POST to /1/classes/Artist/<objectId> should delete the cache for a GET
             # request for the same '/1/classes/Artist/<objectId>' where objectId are equivalent
-            @store.delete url
+            @store.delete @cache_key
           end
         rescue Errno::EINVAL, Redis::CannotConnectError => e
           # if the cache store fails to connect, catch the exception but proceed
           # with the regular request, but turn off caching for this request. It is possible
           # that the cache connection resumes at a later point, so this is temporary.
-          cache_enabled = false
-          warn "[Parse::Cache Error] #{e}"
+          @enabled = false
+          puts "[Parse::Cache] Error: #{e}"
         end
 
-
+        puts("[Parse::Cache::Miss] !! #{url}") if self.class.logging.present?
         @app.call(env).on_complete do |response_env|
           # Only cache GET requests with valid HTTP status codes whose content-length
           # is greater than 20. Otherwise they could be errors, successes and empty result sets.
-          if cache_enabled && method == :get &&  CACHEABLE_HTTP_CODES.include?(response_env.status) &&
+          if @enabled && method == :get &&  CACHEABLE_HTTP_CODES.include?(response_env.status) &&
              response_env.present? && response_env.response_headers["content-length".freeze].to_i > 20
-
-                @store.store(url, response_env, expires: @expires) # ||= response_env.body
-
+                @store.store(@cache_key, response_env, expires: @expires) # ||= response_env.body
           end # if
           # do something with the response
           # response_env[:response_headers].merge!(...)

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

@@ -96,6 +96,7 @@ module Parse
 
         anchor_date = Parse::Date.now
         constraints.merge! :updated_at.on_or_before => anchor_date
+        constraints.merge! cache: false
         # oldest first, so we create a reduction-cycle
         constraints.merge! order: :updated_at.asc, limit: 100
         update_query = query(constraints)
@@ -337,6 +338,22 @@ module Parse
       success
     end
 
+    def prepare_save!
+      run_callbacks(:save) { false }
+    end
+
+    def changes_payload
+      h = attribute_updates
+      if relation_changes?
+        r =  relation_change_operations.select { |s| s.present? }.first
+        h.merge!(r) if r.present?
+      end
+      h.merge!(className: parse_class) unless h.empty?
+      h.as_json
+    end
+
+    alias_method :update_payload, :changes_payload
+
     # this method is useful to generate an array of additions and removals to a relational
     # column.
     def relation_change_operations

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

@@ -26,6 +26,7 @@ module Parse
   module Properties
     # This is an exception that is thrown if there is an issue when creating a specific property for a class.
     class DefinitionError < Exception; end;
+    class ValueError < Exception; end;
 
     # These are the base types supported by Parse.
     TYPES = [:id, :string, :relation, :integer, :float, :boolean, :date, :array, :file, :geopoint, :bytes, :object, :acl].freeze
@@ -411,13 +412,16 @@ module Parse
         elsif val.is_a?(String)
           # if it's a string, try parsing the date
           val = Parse::Date.parse val
+        #elsif val.present?
+        #  pus "[Parse::Stack] Invalid date value '#{val}' assigned to #{self.class}##{key}, it should be a Parse::Date or DateTime."
+        #   raise ValueError, "Invalid date value '#{val}' assigned to #{self.class}##{key}, it should be a Parse::Date or DateTime."
         end
       else
         # You can provide a specific class instead of a symbol format
         if data_type.respond_to?(:typecast)
           val = data_type.typecast(val)
         else
-          warn "Property :#{key}: :#{data_type} has not valid data type"
+          warn "Property :#{key}: :#{data_type} has no valid data type"
           val = val #default
         end
       end

data/lib/parse/model/date.rb

@@ -52,3 +52,11 @@ class DateTime
     Parse::Date.parse iso8601(3)
   end
 end
+
+module ActiveSupport
+  class TimeWithZone
+    def parse_date
+      Parse::Date.parse iso8601(3)
+    end
+  end
+end

data/lib/parse/model/model.rb

@@ -66,9 +66,10 @@ module Parse
       return Parse::File if str == TYPE_FILE.freeze
       return Parse::GeoPoint if str == TYPE_GEOPOINT.freeze
       return Parse::Date if str == TYPE_DATE.freeze
+      return Parse::Bytes if str == TYPE_BYTES.freeze
       # return Parse::User if str == "User".freeze
       # return Parse::Installation if str == "Installation".freeze
-      
+
       str = str.to_s
       # Basically go through all Parse::Object subclasses and see who is has a parse_class
       # set to this string. We will cache the results for future use.
@@ -86,7 +87,7 @@ end
 class String
   # short helper method to provide lower-first-camelcase
   def columnize
-     return "objectId" if self == "id"
+     return "objectId".freeze if self == "id".freeze
      camelize(:lower)
    end;
 

data/lib/parse/model/object.rb

@@ -230,6 +230,10 @@ module Parse
       self.class.new h
     end
 
+    def pretty
+      JSON.pretty_generate( as_json )
+    end
+
     def clear_attribute_change!(atts)
       clear_attribute_changes(atts)
     end
@@ -295,19 +299,35 @@ module Parse
     property :email
     property :password
     property :username
+
+    before_save do
+      # You cannot specify user ACLs.
+      self.clear_attribute_change!(:acl)
+    end
+
+    def anonymous?
+      auth_data.present? && auth_data["anonymous"].present?
+    end
   end
 
   class Installation < Parse::Object
     parse_class "_Installation".freeze
-    property :channels, :array
+
     property :gcm_sender_id, :string, field: :GCMSenderId
+    property :app_identifier
+    property :app_name
+    property :app_version
     property :badge, :integer
-    property :installation_id
+    property :channels, :array
     property :device_token
+    property :device_token_last_modified, :integer
     property :device_type
+    property :installation_id
     property :locale_identifier
+    property :parse_version
     property :push_type
     property :time_zone
+
   end
 
   class Role < Parse::Object
@@ -346,10 +366,11 @@ class Array
   # if it constains the proper fields. Non convertible objects will be removed
   # If the className is not contained or known, you can pass a table name as an argument
   def parse_objects(table = nil)
+    f = "className".freeze
     map do |m|
       next m if m.is_a?(Parse::Pointer)
-      if m.is_a?(Hash) && (m["className"] || m[:className] || table)
-        next Parse::Object.build m, (m["className"] || m[:className] || table)
+      if m.is_a?(Hash) && (m[f] || m[:className] || table)
+        next Parse::Object.build m, (m[f] || m[:className] || table)
       end
       nil
     end.compact

data/lib/parse/query.rb

@@ -119,7 +119,7 @@ module Parse
         elsif expression == :cache
           self.cache = value
         elsif expression == :use_master_key
-          self.cache = value
+          self.use_master_key = value
         elsif expression == :session
           # you can pass a session token or a Parse::Session
           value = value.is_a?(Parse::Session) ? value.session_token : value
@@ -315,11 +315,11 @@ module Parse
 
     def fetch!(compiled_query)
       opts = {}
-      opts[:cache] = false unless self.cache
-      opts[:use_mster_key] = self.use_master_key
+      opts[:cache] = self.cache || false
+      opts[:use_master_key] = self.use_master_key
       opts[:session_token] = self.session_token
       # for now, don't cache requests where we disable master_key or provide session token
-      if opts[:use_mster_key] == false || opts[:session_token].present?
+      if opts[:use_master_key] == false || opts[:session_token].present?
         opts[:cache] = false
       end
 

data/lib/parse/stack.rb

@@ -10,3 +10,5 @@ module Parse
     # Your code goes here...
   end
 end
+
+require_relative 'stack/railtie' if defined?(::Rails)

data/lib/parse/stack/generators/rails.rb

@@ -0,0 +1,35 @@
+require 'parse/stack'
+require 'parse/stack/tasks'
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module ParseStack
+
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "This generator creates an initializer file at config/initializers"
+      def generate_initializer
+        copy_file "parse.rb", "config/initializers/parse.rb"
+        copy_file "model_user.rb", File.join("app/models", "user.rb")
+        copy_file "model_role.rb", File.join("app/models", "role.rb")
+        copy_file "model_session.rb", File.join("app/models", "session.rb")
+        copy_file "model_installation.rb", File.join("app/models", "installation.rb")
+        copy_file "webhooks.rb", File.join("app/models", "webhooks.rb")
+      end
+    end
+
+    class ModelGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path(__dir__ + "/templates")
+      desc "Creates a Parse::Object model subclass."
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+      check_class_collision
+
+      def create_model_file
+        @allowed_types = Parse::Properties::TYPES - [:acl, :id, :relation]
+        template "model.erb", File.join("app/models", class_path, "#{file_name}.rb")
+      end
+
+    end
+
+end

data/lib/parse/stack/generators/templates/model.erb

@@ -0,0 +1,52 @@
+
+class <%= class_name %> < Parse::Object
+  # See: https://github.com/modernistik/parse-stack#defining-properties
+
+  # You can change the inferred Parse table/collection name below
+  # parse_class "<%= class_name.to_s.to_parse_class %>"
+<% attributes.each do |attr|
+  parse_type = attr.type.to_s.downcase.to_sym
+  unless @allowed_types.include?(parse_type)
+    puts "\n[Warning] Skipping property `#{attr.name}` with type `#{parse_type}`. Type should be one of #{@allowed_types}."
+    next
+  end
+%>
+  property :<%= attr.name %>, :<%= parse_type -%>
+<% end %>
+
+  # See: https://github.com/modernistik/parse-stack#cloud-code-webhooks
+  # define a before save webhook for <%= class_name %>
+  webhook :before_save do
+    <%= class_name.to_s.underscore %> = parse_object
+    # perform any validations with <%= class_name.to_s.underscore %>
+    # use `error!(msg)` to fail the save
+    # ...
+    <%= class_name.to_s.underscore %>
+  end
+
+  ## define an after save webhook for <%= class_name %>
+  #
+  # webhook :after_save do
+  #   <%= class_name.to_s.underscore %> = parse_object
+  #
+  # end
+
+  ## define a before delete webhook for <%= class_name %>
+  # webhook :before_delete do
+  #   <%= class_name.to_s.underscore %> = parse_object
+  #   # use `error!(msg)` to fail the delete
+  #   true # allow the deletion
+  # end
+
+  ## define an after delete webhook for <%= class_name %>
+  # webhook :after_delete do
+  #   <%= class_name.to_s.underscore %> = parse_object
+  # end
+
+  ## Example of a CloudCode Webhook function
+  ## define a `helloWorld` Parse CloudCode function
+  # webhook :function, :helloWorld do
+  #   "Hello!"
+  # end
+
+end

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

@@ -0,0 +1,6 @@
+
+
+class Parse::Installation < Parse::Object
+  # See: https://github.com/modernistik/parse-stack#parseinstallation
+  # add additional properties here
+end

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

@@ -0,0 +1,6 @@
+
+
+class Parse::Role < Parse::Object
+  # See: https://github.com/modernistik/parse-stack#parserole
+  # add additional properties here
+end

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

@@ -0,0 +1,6 @@
+
+
+class Parse::Role < Parse::Object
+  # See: https://github.com/modernistik/parse-stack#parsesession
+  # add additional properties here
+end

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

@@ -0,0 +1,13 @@
+
+# See: https://github.com/modernistik/parse-stack#parseuser
+class Parse::User < Parse::Object
+  # add additional properties
+
+  # define a before save webhook for Parse::User
+  # webhook :before_save do
+  #   obj = parse_object # Parse::User
+  #   # make changes to record....
+  #   obj # will send the proper changelist back to Parse-Server
+  # end
+
+end

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

@@ -0,0 +1,13 @@
+require 'parse/stack'
+
+# Set your specific Parse keys in your ENV. For all connection options, see
+# https://github.com/modernistik/parse-stack#connection-setup
+
+Parse.setup app_id: ENV['PARSE_APP_ID'],
+           api_key: ENV['PARSE_API_KEY'],
+        master_key: ENV['PARSE_MASTER_KEY'],
+        server_url: 'https://api.parse.com/1/'
+        # optional
+        #    logging: false,
+        #      cache: Moneta.new(:File, dir: 'tmp/cache'),
+        #    expires: 1 # cache ttl 1 second

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

@@ -0,0 +1,11 @@
+
+# See: https://github.com/modernistik/parse-stack#cloud-code-webhooks
+Parse::Webhooks.route(:function, :helloWorld) do
+  #  use the Parse::Payload instance methods in this block
+  name = params['name'].to_s #function params
+
+  # will return proper error response
+  # error!("Missing argument 'name'.") unless name.present?
+
+  name.present? ? "Hello #{name}!" : "Hello World!"
+end

data/lib/parse/stack/railtie.rb

@@ -0,0 +1,17 @@
+
+module Parse
+  module Stack
+    class Railtie < ::Rails::Railtie
+
+      rake_tasks do
+        require_relative 'tasks'
+        Parse::Stack.load_tasks
+      end
+
+      generators do
+        require_relative 'generators/rails'
+      end
+
+    end
+  end
+end

data/lib/parse/stack/tasks.rb

@@ -18,11 +18,27 @@ module Parse
 
       def install_tasks
 
+        if defined?(::Rails)
+          unless Rake::Task.task_defined?('db:seed') || Rails.root.blank?
+            namespace :db do
+              desc "Seeds your database with by loading db/seeds.rb"
+              task :seed => 'parse:env' do
+                load Rails.root.join("db","seeds.rb")
+              end
+            end
+          end
+        end
+
         namespace :parse do
 
           task :env do
+
             if Rake::Task.task_defined?('environment')
               Rake::Task['environment'].invoke
+              if defined?(::Rails)
+                Rails.application.eager_load! if Rails.application.present?
+              end
+
             end
           end
 
@@ -32,7 +48,7 @@ module Parse
               raise "Please make sure you have setup the Parse.setup configuration before invoking task. Usually done in the :environment task."
             end
 
-            endpoint = ENV['HOOKS_URL']
+            endpoint = ENV['HOOKS_URL'] || ''
             unless endpoint.empty? || endpoint.starts_with?('https://')
               raise "The ENV variable HOOKS_URL must be a <https> url : '#{endpoint}'. Ex. https://12345678.ngrok.io/webhooks"
             end

data/lib/parse/stack/version.rb

@@ -1,5 +1,5 @@
 module Parse
   module Stack
-    VERSION = "1.3.8"
+    VERSION = "1.4.3"
   end
 end

data/lib/parse/webhooks.rb

@@ -68,16 +68,6 @@ module Parse
 
     end
 
-    def update_payload
-      h = attribute_updates
-      if relation_changes?
-        r =  relation_change_operations.select { |s| s.present? }.first
-        h.merge!(r) if r.present?
-      end
-      h.merge!(className: parse_class) unless h.empty?
-      h.as_json
-    end
-
   end
 
   class Payload
@@ -147,10 +137,26 @@ module Parse
         return unless routes[type].present? && routes[type][className].present?
         registry = routes[type][className]
 
-        return payload.instance_exec(payload, &registry) unless registry.is_a?(Array)
-        results = registry.map { |hook| payload.instance_exec(payload, &hook) }
-        return results.last
+        if registry.is_a?(Array)
+          result = registry.map { |hook| payload.instance_exec(payload, &hook) }.last
+        else
+          result = payload.instance_exec(payload, &registry)
+        end
+
+        if result.is_a?(Parse::Object)
+          # if it is a Parse::Object, we will call the registered ActiveModel callbacks
+          # and then send the proper changes payload
+          if type == :before_save
+            # returning false from the callback block only runs the before_* callback
+            result.prepare_save!
+            result = result.changes_payload
+          elsif type == :before_delete
+            result.run_callbacks(:destroy) { false }
+            result = true
+          end
+        end
 
+        result
       end
 
       def success(data = true)

data/lib/parse/webhooks/registration.rb

@@ -36,7 +36,7 @@ module Parse
 
       def register_functions!(endpoint)
 
-        unless endpoint.starts_with?('https://')
+        unless endpoint.present? && endpoint.starts_with?('https://')
           raise "The HOOKS_URL must be https: '#{endpoint}''"
         end
         endpoint += '/' unless endpoint.ends_with?('/')
@@ -61,7 +61,7 @@ module Parse
 
       def register_triggers!(endpoint, include_wildcard: false)
 
-        unless endpoint.starts_with?('https://')
+        unless endpoint.present? && endpoint.starts_with?('https://')
           raise "The HOOKS_URL must be https: '#{endpoint}''"
         end
         endpoint += '/' unless endpoint.ends_with?('/')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: parse-stack
 version: !ruby/object:Gem::Version
-  version: 1.3.8
+  version: 1.4.3
 platform: ruby
 authors:
 - Anthony Persaud
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-23 00:00:00.000000000 Z
+date: 2016-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -228,6 +228,15 @@ files:
 - lib/parse/query/operation.rb
 - lib/parse/query/ordering.rb
 - lib/parse/stack.rb
+- lib/parse/stack/generators/rails.rb
+- lib/parse/stack/generators/templates/model.erb
+- lib/parse/stack/generators/templates/model_installation.rb
+- lib/parse/stack/generators/templates/model_role.rb
+- lib/parse/stack/generators/templates/model_session.rb
+- lib/parse/stack/generators/templates/model_user.rb
+- lib/parse/stack/generators/templates/parse.rb
+- lib/parse/stack/generators/templates/webhooks.rb
+- lib/parse/stack/railtie.rb
 - lib/parse/stack/tasks.rb
 - lib/parse/stack/version.rb
 - lib/parse/webhooks.rb
@@ -254,7 +263,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.6
 signing_key: 
 specification_version: 4
 summary: Parse-Server Ruby Client and Active Model Object Relational Mapping