parse-stack 1.5.1 → 1.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c177e1e9c6b4e9f8085501bbfd543e2ea3bb0ef7
-  data.tar.gz: 05c4e9ed7faed5a88fa1940ebfa8427ca48d757d
+  metadata.gz: 4da68d2d9e3ed4e2607a9fadaae3cd833755492d
+  data.tar.gz: a0ebd3622b1daedde1396993ad5f777522c3ecb1
 SHA512:
-  metadata.gz: e416f00adea0682bd133fb766d933f1b86cce8044a6e6656ff07bf1df32e53fc58892f3dc4b8d8981b8d39bf653324eecf6e66cdd314db4a289e794abb1b7fff
-  data.tar.gz: f0d090cb59fb13c03a64dabd57fdfc8d41f6d94db5edb590f4e6141753c975f7e54b2e9277f9c6ff246984e3a095225924bc3b05af64099e6e83f5a86f887fea
+  metadata.gz: ecf353df19d8b5c24acf57d472d9e1a166e055e1f8648f596b2d9b78e8755855fc623e4347ff656891a6ba64ad137a3e61bdb1be9435e9719ac4f833eb53d689
+  data.tar.gz: 06ba25aaa84702d56dc87a030aec5c99ea4858686b38ff9bfe261bc2128ca50dc6969652632033e5153e8eb6c906d8ccd9dc3023282fc4972af7206eaac86a92

data/Changes.md

@@ -1,5 +1,19 @@
 ## Parse-Stack Changelog
 
+### 1.5.2
+- FIXES #16: Constraints to `count` were not properly handled.
+- FIXES #15: Incorrect call to `request_password_reset`.
+- FIXES #14: Typos
+- FIXES: Issues when passing a block to chaining scope.
+- FIXES: Enums properly handle default values.
+- FIXES: Enums macro methods now are dirty tracked.
+- FIXES: #17: overloads inspect to show objects in a has_many scope.
+- `reload!` and session methods support client request options.
+- Proactively deletes possible matching cache keys on non GET requests.
+- Parse::File now has a `force_ssl` option that makes sure all urls returned are `https`.
+- Documentation
+- ParseConstraintError is now Parse::ConstraintError.
+
 ### 1.5.1
 - BREAKING CHANGE: The default `has_many` implementation is `:query` instead of `:array`.
 - NEW: Support for `has_one` type of associations.
@@ -52,7 +66,7 @@
 - Added new `ServiceUnavailableError` exception for Parse error code 2 and HTTP 503 errors.
 - Upon a `ServiceUnavailableError`, we will retry the request one more time after 2 seconds.
 - `:not_in` and `:contains_all` queries will format scalar values into an array.
-- `:exists` and `:null` will raise `ParseConstraintError` if non-boolean values are passed.
+- `:exists` and `:null` will raise `ConstraintError` if non-boolean values are passed.
 - NEW: `:id` constraint to allow passing an objectId to a query where we will infer the class.
 
 ### 1.3.7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    parse-stack (1.5.1)
+    parse-stack (1.5.2)
       active_model_serializers (>= 0.9, < 1)
       activemodel (>= 4.2.1, < 6)
       activesupport (>= 4.2.1, < 6)
@@ -42,7 +42,7 @@ GEM
     binding_of_caller (0.7.2)
       debug_inspector (>= 0.0.1)
     builder (3.2.2)
-    byebug (9.0.5)
+    byebug (9.0.6)
     coderay (1.1.1)
     concurrent-ruby (1.0.2)
     debug_inspector (0.0.2)
@@ -53,21 +53,21 @@ GEM
     faraday_middleware (0.10.0)
       faraday (>= 0.7.4, < 0.10)
     i18n (0.7.0)
-    json (1.8.3)
-    jsonapi (0.1.1.beta2)
-      json (~> 1.8)
+    jsonapi (0.1.1.beta6)
+      jsonapi-parser (= 0.1.1.beta3)
+      jsonapi-renderer (= 0.1.1.beta1)
+    jsonapi-parser (0.1.1.beta3)
+    jsonapi-renderer (0.1.1.beta1)
     loofah (2.0.3)
       nokogiri (>= 1.5.9)
     method_source (0.8.2)
     mini_portile2 (2.1.0)
-    minitest (5.9.0)
+    minitest (5.9.1)
     moneta (0.8.0)
     multipart-post (2.0.0)
-    nokogiri (1.6.8)
+    nokogiri (1.6.8.1)
       mini_portile2 (~> 2.1.0)
-      pkg-config (~> 1.1.7)
     parallel (1.9.0)
-    pkg-config (1.1.7)
     pry (0.10.4)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
@@ -112,4 +112,4 @@ DEPENDENCIES
   rake
 
 BUNDLED WITH
-   1.12.5
+   1.13.3

data/README.md

@@ -1,4 +1,4 @@
-# Parse-Stack - A Parse-Server Ruby Client and ORM
+# Parse-Stack - The Parse Server Ruby Client and ORM
 Parse-Stack is a [Parse Server](https://github.com/ParsePlatform/parse-server) REST API Client and ORM framework for ruby. It provides a client adapter, a query engine, an object relational mapper (ORM) and a Cloud Code Webhooks rack application.
 
 ### Code Status
@@ -226,7 +226,7 @@ The architecture of `Parse::Stack` is broken into four main components.
 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 at the same time. It handles sending raw requests as well as providing Request/Response objects for all API handlers. The connection engine is Faraday, which means it is open to add any additional middleware for features you'd like to implement.
 
 ### Parse::Query
-This class implements the [Parse REST Querying](https://parse.com/docs/rest/guide#queries) interface in the [DataMapper finder syntax style](http://datamapper.org/docs/find.html). It compiles a set of query constraints and utilizes `Parse::Client` to send the request and provide the raw results. This class can be used without the need to define models.
+This class implements the [Parse REST Querying](http://parseplatform.github.io/docs/rest/guide/#queries) interface in the [DataMapper finder syntax style](http://datamapper.org/docs/find.html). It compiles a set of query constraints and utilizes `Parse::Client` to send the request and provide the raw results. This class can be used without the need to define models.
 
 ### Parse::Object
 This component is main class for all object relational mapping subclasses for your application. It provides features in order to map your remote Parse records to a local ruby object. It implements the Active::Model interface to provide a lot of additional features, CRUD operations, querying, including dirty tracking, JSON serialization, save/destroy callbacks and others. While we are overlooking some functionality, for simplicity, you will mainly be working with Parse::Object as your superclass. While not required, it is highly recommended that you define a model (Parse::Object subclass) for all the Parse classes in your application.
@@ -286,7 +286,7 @@ Calling `setup` will create the default `Parse::Client` session object that will
 There are additional connection options that you may pass the setup method when creating a `Parse::Client`.
 
 #### `:server_url`
-The server url of your Parse-Server if you are not using the hosted Parse.com service. By default it will use `PARSE_SERVER_URL` environment variable available or fall back to `https://api.parse.com/1/` if not specified.
+The server url of your Parse Server if you are not using the hosted Parse.com service. By default it will use `PARSE_SERVER_URL` environment variable available or fall back to `https://api.parse.com/1/` if not specified.
 
 #### `:app_id`
 The Parse application id. By default it will use `PARSE_APP_ID` environment variable if not specified.
@@ -313,7 +313,7 @@ Sets the default cache expiration time (in seconds) for successful non-empty `GE
 You may pass a hash of options that will be passed to the `Faraday` constructor.
 
 ## Parse Config
-Getting your configuration variables once you have a default client setup can be done with `Parse.config`. The first time this method is called, Parse-Stack will get the configuration from Parse-Server, and cache it. To force a reload of the config, use `config!`. You
+Getting your configuration variables once you have a default client setup can be done with `Parse.config`. The first time this method is called, Parse-Stack will get the configuration from Parse Server, and cache it. To force a reload of the config, use `config!`. You
 
 ```ruby
   Parse.setup( ... )
@@ -412,6 +412,19 @@ The default MIME type for all files is `image/jpeg`. This can be default can be
   file = Parse::File.new parse_file
 ```
 
+If you are using displaying these files on a secure site and want to make sure that urls returned by a call to `url` are `https`, you can set `Parse::File.force_ssl` to true.
+
+```ruby
+# Assume file is a Parse::File
+
+file.url # => http://www.example.com/file.png
+
+Parse::File.force_ssl = true # make all urls be https
+
+file.url # => https://www.example.com/file.png
+
+```
+
 ### Parse::Date
 This class manages dates in the special JSON format it requires for properties of type `:date`. `Parse::Date` subclasses `DateTime`, which allows you to use any features or methods available to `DateTime` with `Parse::Date`. While the conversion between `Time` and `DateTime` objects to a `Parse::Date` object is done implicitly for you, you can use the added special methods, `DateTime#parse_date` and `Time#parse_date`, for special occasions.
 
@@ -1016,7 +1029,8 @@ user.band_by_status(false)
 #### Has Many
 Parse has many ways to implement one-to-many and many-to-many associations: `Array`, `Parse Relation` or through a `Query`. How you decide to implement your associations, will affect how `has_many` works in Parse-Stack. Parse natively supports one-to-many and many-to-many relationships using `Array` and `Relations`, as described in [Relational Data](https://parseplatform.github.io/docs/js/guide/#relational-data). Both of these methods require you define a specific column type in your Parse table that will be used to store information about the association.
 
-In addition to `Array` and `Relation`, Parse-Stack also implements the standard `has_many` behavior prevalent in other frameworks through a query where the associated class contains a foreign pointer to the local class, usually the inverse of a `belongs_to`. This requires that the associated class
+In addition to `Array` and `Relation`, Parse-Stack also implements the standard `has_many` behavior prevalent in other frameworks through a query where the associated class contains a foreign pointer to the local class, usually the inverse of a `belongs_to`. This requires that the associated class has a defined column
+that contains a pointer the refers to the defining class.
 
 ##### Query
 In this implementation, a `has_many` association for a Parse class requires that another Parse class will have a foreign pointer that refers to instances of this class. This is the standard way that `has_many` relationships work in most databases systems. This is usually the case when you have a class that has a `belongs_to` relationship to instances of the local class.
@@ -1134,7 +1148,7 @@ Other than the use of arrays, Parse supports native one-to-many and many-to-many
 2. Querying the relation is actually performed against the implicit join table, not the local one.
 3. Applying query constraints for a set of records within a relation is performed against the foreign table class, not the class having the relational column.
 
-The Parse documentation provides more details on associations, see [Parse Relations Guide](https://parse.com/docs/ios/guide#relations). Parse-Stack will handle the work for (2) and (3) automatically.
+The Parse documentation provides more details on associations, see [Parse Relations Guide](http://parseplatform.github.io/docs/ios/guide/#relations). Parse-Stack will handle the work for (2) and (3) automatically.
 
 In the example below, a `Band` can have thousands of `Fans`. We setup a `Relation<Fan>` column in the `Band` class that references the `Fan` class. Parse-Stack provides methods to manage the relationship under the [Parse::RelationCollectionProxy](https://github.com/modernistik/parse-stack/blob/master/lib/parse/model/associations/relation_collection_proxy.rb) class.
 
@@ -1321,7 +1335,7 @@ To commit a new record or changes to an existing record to Parse, use the `#save
  songs.save # save the rest of the items
 ```
 
-The save operation can handle both creating and updating existing objects. If you do not want to update the association data of a changed object, you may use the `#update` method to only save the changed property values. In the case where you want to force update an object even though it has not changed, to possibly trigger your `before_save` hooks, you can use the `#update!` method.
+The save operation can handle both creating and updating existing objects. If you do not want to update the association data of a changed object, you may use the `#update` method to only save the changed property values. In the case where you want to force update an object even though it has not changed, to possibly trigger your `before_save` hooks, you can use the `#update!` method. In addition, just like with other ActiveModel objects, you may call `reload!` to fetch the current record again from the data store.
 
 #### Raising an exception when save fails
 By default, we return `true` or `false` for save and destroy operations. If you prefer to have `Parse::Object` raise an exception instead, you can tell to do so either globally or on a per-model basis. When a save fails, it will raise a `Parse::SaveFailureError`.
@@ -1568,7 +1582,7 @@ When a query API is made, the results are cached in the query object in case you
 ```
 
 ### Counting
-If you only need to know the result count for a query, provide count a non-zero value. However, if you need to perform a count query, use `count()` method instead. As a reminder, there are a few [caveats to counting records as detailed by Parse](https://parse.com/docs/rest/guide#queries-counting-objects).
+If you only need to know the result count for a query, provide count a non-zero value. However, if you need to perform a count query, use `count()` method instead.
 
 ```ruby
  # get number of songs with a play_count > 10
@@ -1659,7 +1673,7 @@ Song.all limit: 3, use_master_key: false
 ```
 
 #### :session_token
-A Parse session token string. If you would like to perform a query as a particular user, you may pass their session token in the query. This will make sure that the query is performed on behalf (and with the priviledges) of that user which will cause record ACLs to be enforced. If a session token is provided, caching will be disabled for this request.
+A Parse session token string. If you would like to perform a query as a particular user, you may pass their session token in the query. This will make sure that the query is performed on behalf (and with the privileges) of that user which will cause record ACLs to be enforced. If a session token is provided, caching will be disabled for this request.
 
 ```ruby
 # disable sending the master key in the request if configured

data/bin/console

@@ -8,6 +8,9 @@ Dotenv.load
 
 Parse.setup
 
+puts "[ParseServerURL] #{Parse.client.server_url}"
+puts "[ParseAppID]     #{Parse.client.app_id}"
+
 # 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/analytics.rb

@@ -5,7 +5,7 @@ module Parse
 
   module API
     module Analytics
-
+      # Sends analytics data
       def send_analytics(event_name, data = {})
         request :post, "events/#{event_name}", body: data
       end

data/lib/parse/api/objects.rb

@@ -7,7 +7,7 @@ require 'active_support/core_ext'
 module Parse
 
   module API
-    #object fetch methods
+    # REST API methods for fetching CRUD operations on Parse objects.
     module Objects
 
       CLASS_PATH_PREFIX = "classes/"

data/lib/parse/api/users.rb

@@ -78,7 +78,7 @@ module Parse
         request :post, LOGOUT_PATH, headers: headers, opts: opts
       end
 
-      # {username: "", password: "", email: nil} # minimum
+      # Signup a user given a username, password and, optionally, their email.
       def signup(username, password, email = nil, body: {}, **opts)
         body = body.merge({ username: username, password: password })
         body[:email] = email || body[:email]

data/lib/parse/client.rb

@@ -18,7 +18,6 @@ require_relative "api/all"
 
 module Parse
 
-  # This is an exception that is thrown if there is a client connectivity issue
   class ConnectionError < StandardError; end;
   class TimeoutError < StandardError; end;
   class ProtocolError < StandardError; end;
@@ -28,31 +27,54 @@ module Parse
   class RequestLimitExceededError < StandardError; end;
   class InvalidSessionTokenError < StandardError; end;
 
-  # helper method to get the config variables.
-  def self.config(s = :default)
-    Parse::Client.client(s).config
+  # Retrieve the App specific Parse configuration parameters. The configuration
+  # for a connection is cached after the first request. Use the bang version to
+  # force update from the Parse backend.
+  # @see Parse.config!
+  # @param conn [Symbol] the name of the client connection to use.
+  # @return [Hash] the Parse config hash for the session.
+  def self.config(conn = :default)
+    Parse::Client.client(conn).config
   end
 
-  def self.set_config(field, value, s = :default)
-    Parse::Client.client(s).update_config({ field => value })
+  # Set a parameter in the Parse configuration for an application.
+  # @param field [String] the name configuration variable.
+  # @param value [Object] the value configuration variable. Only Parse types are supported.
+  # @param conn [Symbol] the name of the client connection to use.
+  # @return [Hash] the Parse config hash for the session.
+  def self.set_config(field, value, conn = :default)
+    Parse::Client.client(conn).update_config({ field => value })
   end
 
-  def self.update_config(params, s = :default)
-    Parse::Client.client(s).update_config(params)
+  # Set a key value pairs in the Parse configuration for an application.
+  # @param params [Hash] a set of key value pairs to set in the Parse configuration.
+  # @param conn [Symbol] the name of the client connection to use.
+  # @return [Hash] the Parse config hash for the session.
+  def self.update_config(params, conn = :default)
+    Parse::Client.client(conn).update_config(params)
   end
 
-  def self.config!(s = :default)
-    Parse::Client.client(s).config!
+  # Force fetch updated Parse configuration
+  # @param conn [Symbol] the name of the client connection to use.
+  # @return [Hash] the Parse configuration
+  def self.config!(conn = :default)
+    Parse::Client.client(conn).config!
   end
 
+  # Helper method to get the default Parse client.
+  # @param conn [Symbol] the name of the client connection to use.
+  # @return [Parse::Client] a client object for the connection name.
   def self.client(conn = :default)
     Parse::Client.client(conn)
   end
 
-  # Main class for the client. The client class is based on a Faraday stack.
-  # The Faraday stack is similar to a Rack-style application in which you can define middlewares
-  # that will be called for each request going out and coming back in. We use this in order to setup
-  # some helper middlewares such as encoding to JSON, handling Parse authentication and caching.
+  # 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
+  # at the same time. It handles sending raw requests as well as providing
+  # Request/Response objects for all API handlers. The connection engine is
+  # Faraday, which means it is open to add any additional middleware for
+  # features you'd like to implement.
   class Client
     include Parse::API::Objects
     include Parse::API::Config
@@ -68,39 +90,56 @@ module Parse
     RETRY_COUNT = 2
     RETRY_DELAY = 2 #seconds
 
-    attr_accessor :session, :cache
+    # @!attribute cache
+    #  The underlying cache store for caching API requests.
+    #  @return [Moneta::Transformer]
+    # @!attribute [r] application_id
+    #  The Parse application identifier to be sent in every API request.
+    #  @return [String]
+    # @!attribute [r] api_key
+    #  The Parse API key to be sent in every API request.
+    #  @return [String]
+    # @!attribute [r] master_key
+    #  The Parse master key for this application, which when set, will be sent
+    #  in every API request. (There is a way to prevent this on a per request basis.)
+    #  @return [String]
+    # @!attribute [r] server_url
+    #  The Parse server url that will be receiving these API requests. By default
+    #  this will be {Parse::Protocol::SERVER_URL}.
+    #  @return [String]
+    attr_accessor :cache
     attr_reader :application_id, :api_key, :master_key, :server_url
+    alias_method :app_id, :application_id
     # The client can support multiple sessions. The first session created, will be placed
     # under the default session tag. The :default session will be the default client to be used
     # by the other classes including Parse::Query and Parse::Objects
     @clients = { default: nil }
     class << self
+      # @!attribute [r] clients
+      #  A hash of Parse::Client instances.
+      #  @return [Hash<Parse::Client>]
       attr_reader :clients
-      def session?(v = :default)
-          puts '[Warning] Parse::Client#session is DEPRECATED. Please use Parse::Client#client instead.'
-          self.client? v
-      end
-
-      # DEPRECATED
-      # get a session for a given tag. This will also create a new one for the tag if not specified.
-      def session(connection = :default)
-        puts '[Warning] Parse::Client#session is DEPRECATED. Please use Parse::Client#client instead.'
-        self.client(connection)
-      end
 
-      def client?(v = :default)
-        @clients[v].present?
+      # @param conn [Symbol] the name of the connection.
+      # @return [Boolean] true if a Parse::Client has been configured.
+      def client?(conn = :default)
+        @clients[conn].present?
       end
 
-      def client(connection = :default)
-        @clients[connection] ||= self.new
+      # Returns or create a new Parse::Client connection for the given connection
+      # name.
+      # @param conn [Symbol] the name of the connection.
+      # @return [Parse::Client]
+      def client(conn = :default)
+        @clients[conn] ||= self.new
       end
 
+      # Setup the Parse-Stack framework with the appropriate Parse app keys and middleware.
+      # @yield a block for additional configuration
+      # @param opts [Hash] the set of options to configure the :default Parse::Client connection.
+      # @return [Parse::Client]
+      # @see Parse::Client#initialize
       def setup(opts = {})
-        # If Proc.new is called from inside a method without any arguments of
-        # its own, it will return a new Proc containing the block given to
-        # its surrounding method.
-        # http://mudge.name/2011/01/26/passing-blocks-in-ruby-without-block.html
         @clients[:default] = self.new(opts, &Proc.new)
       end
 
@@ -128,7 +167,7 @@ module Parse
       opts[:adapter] ||= Faraday.default_adapter
       opts[:expires] ||= 3
       if @application_id.nil? || ( @api_key.nil? && @master_key.nil? )
-        raise "Please call Parse.setup(application_id:, api_key:) to setup a session"
+        raise "Please call Parse.setup(application_id:, api_key:) to setup a client"
       end
       @server_url += '/' unless @server_url.ends_with?('/')
       #Configure Faraday
@@ -175,14 +214,12 @@ module Parse
       self
     end
 
-    def app_id
-      @application_id
-    end
-
+    # @return [String] the url prefix of the Parse Server url.
     def url_prefix
       @conn.url_prefix
     end
 
+    # Clear the client cache
     def clear_cache!
       self.cache.clear if self.cache.present?
     end
@@ -318,7 +355,7 @@ module Parse
       request :put, uri, body: body, headers: headers
     end
 
-    # shorthand for request(:delete, uri, body: {})
+    # shorthand for request(:delete, uri, body: {}, headers: {})
     def delete(uri, body = nil, headers = {})
       request :delete, uri, body: body, headers: headers
     end

data/lib/parse/client/caching.rb

@@ -22,6 +22,8 @@ module Parse
          # * 410 - 'Gone' - removed
       CACHEABLE_HTTP_CODES = [200, 203, 300, 301, 302]
       CACHE_CONTROL = 'Cache-Control'
+      CONTENT_LENGTH_KEY = "content-length"
+      CACHE_RESPONSE_HEADER = "X-Cache-Response"
       CACHE_EXPIRES_DURATION = 'X-Parse-Stack-Cache-Expires'
 
       class << self
@@ -85,8 +87,8 @@ module Parse
         @cache_key = url.to_s
 
         if @request_headers.key?(SESSION_TOKEN)
-          session_token = @request_headers[SESSION_TOKEN]
-          @cache_key = "#{session_token}#{@cache_key}" # prefix tokens
+          @session_token = @request_headers[SESSION_TOKEN]
+          @cache_key = "#{@session_token}:#{@cache_key}" # prefix tokens
         elsif @request_headers.key?(MASTER_KEY)
           @cache_key = "mk:#{@cache_key}" # prefix for master key requests
         end
@@ -98,7 +100,7 @@ module Parse
             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 })
+              response.finish({status: 200, response_headers: { CACHE_RESPONSE_HEADER => true }, body: body })
               return response
             else
               @store.delete @cache_key
@@ -107,7 +109,9 @@ module Parse
             #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 @cache_key
+            @store.delete url.to_s # regular
+            @store.delete "mk:#{url.to_s}" # master key cache-key
+            @store.delete @cache_key # final key
           end
         rescue Errno::EINVAL, Redis::CannotConnectError => e
           # if the cache store fails to connect, catch the exception but proceed
@@ -122,7 +126,7 @@ module Parse
           # 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 @enabled && method == :get &&  CACHEABLE_HTTP_CODES.include?(response_env.status) &&
-             response_env.present? && response_env.response_headers["content-length"].to_i > 20
+             response_env.present? && response_env.response_headers[CONTENT_LENGTH_KEY].to_i > 20
                 @store.store(@cache_key, response_env, expires: @expires) # ||= response_env.body
           end # if
           # do something with the response