parse-stack 1.4.3 → 1.5.1

data/lib/parse/model/object.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -21,6 +24,7 @@ require_relative 'core/actions'
 require_relative 'core/querying'
 require_relative "core/schema"
 require_relative "core/properties"
+require_relative "associations/has_one"
 require_relative "associations/belongs_to"
 require_relative "associations/has_many"
 
@@ -87,16 +91,18 @@ module Parse
 
   class Object < Pointer
     include Properties
+    include Associations::HasOne
     include Associations::BelongsTo
     include Associations::HasMany
     include Querying
     include Fetching
     include Actions
     include Schema
+    BASE_OBJECT_CLASS = "Parse::Object".freeze # used for comparison
 
     def __type; Parse::Model::TYPE_OBJECT; end;
     # These define callbacks
-    define_model_callbacks :save, :destroy
+    define_model_callbacks :create, :save, :destroy, only: [:after, :before]
     #core attributes. In general these should be treated as read_only, but the
     # setters are available since we will be decoding objects from Parse. The :acl
     # type is documented in its own class file.
@@ -141,7 +147,7 @@ module Parse
       elsif opts.is_a?(Hash)
         #if the objectId is provided we will consider the object pristine
         #and not track dirty items
-        dirty_track = opts["objectId".freeze] || opts[:objectId] || opts[:id]
+        dirty_track = opts[Parse::Model::OBJECT_ID] || opts[:objectId] || opts[:id]
         apply_attributes!(opts, dirty_track: !dirty_track)
       end
 
@@ -211,6 +217,7 @@ module Parse
         remote_field = self.field_map[key.to_sym] || key
         h[remote_field] = send key
         # make an exception to Parse::Objects, we should return a pointer to them instead
+        h[remote_field] = h[remote_field].parse_pointers if h[remote_field].is_a?(Parse::PointerCollectionProxy)
         h[remote_field] = h[remote_field].pointer if h[remote_field].respond_to?(:pointer)
       end
       h
@@ -221,10 +228,18 @@ module Parse
       restore_attributes
     end
 
+    # overrides ActiveModel::Validations validate! instance method
+    # if it fails, it raises ActiveModel::ValidationError
+    # otherwise return self instead of true
+    def validate!
+      super
+      self
+    end
+
     # Returns a twin copy of the object without the objectId
     def twin
       h = self.as_json
-      h.delete("objectId")
+      h.delete(Parse::Model::OBJECT_ID)
       h.delete(:objectId)
       h.delete(:id)
       self.class.new h
@@ -246,10 +261,11 @@ module Parse
     # will be returned instead.
     def self.build(json, table = nil)
       className = table
-      className ||= (json["className"] || json[:className]) if json.is_a?(Hash)
+      className ||= (json[Parse::Model::KEY_CLASS_NAME] || json[:className]) if json.is_a?(Hash)
       if json.is_a?(Hash) && json["error"].present? && json["code"].present?
         warn "[Parse::Object] Detected object hash with 'error' and 'code' set. : #{json}"
       end
+      className = parse_class unless parse_class == BASE_OBJECT_CLASS
       return if className.nil?
       # we should do a reverse lookup on who is registered for a different class type
       # than their name with parse_class
@@ -260,7 +276,7 @@ module Parse
         # we are considering these objects as "pristine"
         o = klass.new(json)
       else
-        o = Parse::Pointer.new className, (json["objectId"] || json[:objectId])
+        o = Parse::Pointer.new className, (json[Parse::Model::OBJECT_ID] || json[:objectId])
       end
       return o
     # rescue NameError => e
@@ -287,86 +303,17 @@ module Parse
       @updated_at.to_time.utc.iso8601(3) if @updated_at.present?
     end
 
-
-
-  end
-
-  # The User class provided by Parse with the required fields. You may
-  # add mixings to this class to add the app specific properties
-  class User < Parse::Object
-    parse_class "_User".freeze
-    property :auth_data, :object
-    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 :gcm_sender_id, :string, field: :GCMSenderId
-    property :app_identifier
-    property :app_name
-    property :app_version
-    property :badge, :integer
-    property :channels, :array
-    property :device_token
-    property :device_token_last_modified, :integer
-    property :device_type
-    property :installation_id
-    property :locale_identifier
-    property :parse_version
-    property :push_type
-    property :time_zone
-
-  end
-
-  class Role < Parse::Object
-    parse_class "_Role".freeze
-    property :name
-
-    has_many :roles, through: :relation
-    has_many :users, through: :relation
-
-    def update_acl
-      acl.everyone true, false
-    end
-
-    before_save do
-      update_acl
-    end
-  end
-
-  class Session < Parse::Object
-    parse_class "_Session".freeze
-    property :created_with, :object
-    property :expires_at, :date
-    property :installation_id
-    property :restricted, :boolean
-    property :session_token
-
-    belongs_to :user
   end
 
 end
 
-
 class Array
   # This helper method selects all objects in an array that are either inherit from
   # Parse::Pointer or are a hash. If it is a hash, a Pare::Object will be built from it
   # 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
+    f = Parse::Model::KEY_CLASS_NAME
     map do |m|
       next m if m.is_a?(Parse::Pointer)
       if m.is_a?(Hash) && (m[f] || m[:className] || table)
@@ -377,7 +324,13 @@ class Array
   end
 
   def parse_ids
-    parse_objects.map { |d| d.id }
+    parse_objects.map(&:id)
   end
 
 end
+
+# Load all the core classes.
+require_relative 'classes/installation'
+require_relative 'classes/role'
+require_relative 'classes/session'
+require_relative 'classes/user'

data/lib/parse/model/pointer.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -13,10 +16,10 @@ module Parse
     # based on your Parse application tables - however they are used for when a class is found that cannot be
     # associated with a defined ruby class or used when specifically saving Parse relation types.
     class Pointer < Model
-
+      ATTRIBUTES = { __type: :string, className: :string, objectId: :string}.freeze
       attr_accessor :parse_class, :id
 
-      def __type; "Pointer".freeze; end;
+      def __type; "Pointer"; end;
       alias_method :className, :parse_class
       # A Parse object as a className field and objectId. In ruby, we will use the
       # id attribute method, but for usability, we will also alias it to objectId
@@ -32,10 +35,9 @@ module Parse
       end
 
       def attributes
-        { __type: :string, className: :string, objectId: :string}.freeze
+        ATTRIBUTES
       end
 
-
       def json_hash
         JSON.parse to_json
       end
@@ -98,8 +100,8 @@ class Array
       #if its an exact Parse::Pointer
       if m.is_a?(Parse::Pointer) || m.respond_to?(:pointer)
         next m.pointer
-      elsif m.is_a?(Hash) && m["className"] && m["objectId"]
-        next Parse::Pointer.new m["className"], m["objectId"]
+      elsif m.is_a?(Hash) && m[Parse::Model::KEY_CLASS_NAME] && m[Parse::Model::OBJECT_ID]
+        next Parse::Pointer.new m[Parse::Model::KEY_CLASS_NAME], m[Parse::Model::OBJECT_ID]
       elsif m.is_a?(Hash) && m[:className] && m[:objectId]
         next Parse::Pointer.new m[:className], m[:objectId]
       end

data/lib/parse/model/push.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative '../query.rb'
 require_relative '../client.rb'
 require 'active_model_serializers'
@@ -57,7 +60,7 @@ module Parse
       msg = {
         data: {
           alert: alert,
-          badge: badge || "Increment".freeze
+          badge: badge || "Increment"
         }
       }
       msg[:data][:sound] = sound if sound.present?

data/lib/parse/query/constraint.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative 'operation'
 require 'time'
 # Constraints are the heart of the Parse::Query system.

data/lib/parse/query/constraints.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative 'constraint'
 
 # Eac constraint type is a subclass of Parse::Constraint
@@ -7,7 +10,7 @@ require_relative 'constraint'
 # For more information: https://parse.com/docs/rest/guide#queries
 # For more information about the query design pattern from DataMapper
 # that inspired this, see http://datamapper.org/docs/find.html
-class ParseConstraintError < Exception; end;
+class ParseConstraintError < StandardError; end;
 module Parse
 
   class ObjectIdConstraint < Constraint
@@ -184,14 +187,14 @@ module Parse
         remote_field_name = res[:key] || remote_field_name
         query = res[:query]
         unless query.is_a?(Parse::Query)
-          raise "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
+          raise ParseConstraintError, "Invalid Parse::Query object provided in :query field of value: #{@operation.operand}.#{$dontSelect} => #{@value}"
         end
         query = query.compile(encode: false, includeClassName: true)
       elsif @value.is_a?(Parse::Query)
         # if its a query, then assume dontSelect key is the same name as operand.
         query = @value.compile(encode: false, includeClassName: true)
       else
-        raise "Invalid `:select` query constraint. It should follow the format: :field.select => { key: 'key', query: '<Parse::Query>' }"
+        raise ParseConstraintError, "Invalid `:select` query constraint. It should follow the format: :field.select => { key: 'key', query: '<Parse::Query>' }"
       end
       { @operation.operand => { :$select => { key: remote_field_name, query: query } } }
     end

data/lib/parse/query/operation.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/inflector'
 

data/lib/parse/query/ordering.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 # Ordering is implemented similarly as constraints in which we add
 # special methods to the Symbol class. The developer can then pass one
 # or an array of fields (as symbols) and call the particular ordering

data/lib/parse/query.rb

@@ -1,7 +1,11 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative "client"
 require_relative "query/operation"
 require_relative "query/constraints"
 require_relative "query/ordering"
+require 'active_model'
 require 'active_model_serializers'
 require 'active_support'
 require 'active_support/inflector'
@@ -20,7 +24,10 @@ module Parse
   # constraints - as Parse::Constraint
 
   class Query
+    extend  ::ActiveModel::Callbacks
     include Parse::Client::Connectable
+    include Enumerable
+    define_model_callbacks :prepare, only: [:after, :before]
     # A query needs to be tied to a Parse table name (Parse class)
     # The client object is of type Parse::Client in order to send query requests.
     # You can modify the default client being used by all Parse::Query objects by setting
@@ -87,7 +94,9 @@ module Parse
     end
 
     def initialize(table, constraints = {})
-      raise "First parameter should be the name of the Parse class (table)" unless table.is_a?(String)
+      table = table.to_s.to_parse_class if table.is_a?(Symbol)
+      table = table.parse_class if table.respond_to?(:parse_class)
+      raise ArgumentError, "First parameter should be the name of the Parse class (table)" unless table.is_a?(String)
       @count = 0 #non-zero/1 implies a count query request
       @where = []
       @order = []
@@ -122,13 +131,14 @@ module Parse
           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
+          value = value.respond_to?(:session_token) ? value.session_token : value
           self.session_token = value
         else
           add_constraint(expression, value)
         end
       end # each
-    end
+      self #chaining
+    end; alias_method :query, :conditions
 
     def table=(t)
       @table = t.to_s.camelize
@@ -186,9 +196,9 @@ module Parse
     end
 
     def related_to(field, pointer)
-      raise "Object value must be a Parse::Pointer type" unless pointer.is_a?(Parse::Pointer)
+      raise ArgumentError, "Object value must be a Parse::Pointer type" unless pointer.is_a?(Parse::Pointer)
       add_constraint field.to_sym.related_to, pointer
-      self
+      self #chaining
     end
 
     def includes(*fields)
@@ -204,9 +214,18 @@ module Parse
     end
     alias_method :include, :includes
 
-    def add_constraint(operator, value, opts = {})
+    def add_constraints(list)
+      list = Array.wrap(list).select { |m| m.is_a?(Parse::Constraint) }
+      @where = @where + list
+      self
+    end
+
+    def add_constraint(operator, value = nil, **opts)
       @where ||= []
-      constraint = Parse::Constraint.create operator, value
+      constraint = operator # assume Parse::Constraint
+      unless constraint.is_a?(Parse::Constraint)
+        constraint = Parse::Constraint.create(operator, value)
+      end
       return unless constraint.is_a?(Parse::Constraint)
       # to support select queries where you have to pass a `key` parameter for matching
       # different tables.
@@ -222,7 +241,10 @@ module Parse
       @results = nil
       self #chaining
     end
-    def constraints; @where; end;
+
+    def constraints
+      @where
+    end
 
     def where(conditions = nil, opts = {})
       return @where if conditions.nil?
@@ -231,7 +253,7 @@ module Parse
           add_constraint(operator, value, opts)
         end
       end
-      self  #chaining
+      self #chaining
     end
 
     def or_where(where_clauses = [])
@@ -256,17 +278,16 @@ module Parse
     end
 
     def |(other_query)
-        raise "Parse queries must be of the same class #{@table}." unless @table == other_query.table
+        raise ArgumentError, "Parse queries must be of the same class #{@table}." unless @table == other_query.table
         copy_query = self.clone
         copy_query.or_where other_query.where
         copy_query
     end
 
     def count
-      @results = nil
       old_value = @count
       @count = 1
-      res = client.find_objects(@table, compile.as_json ).count
+      res = client.find_objects(@table, compile.as_json, _opts ).count
       @count = old_value
       res
     end
@@ -276,8 +297,27 @@ module Parse
        results.each(&Proc.new)
     end
 
+    def map
+      return results.enum_for(:map) unless block_given? # Sparkling magic!
+      results.map(&Proc.new)
+    end
+
+    def select
+      return results.enum_for(:select) unless block_given? # Sparkling magic!
+      results.select(&Proc.new)
+    end
+
+    def to_a
+      results.to_a
+    end
+
+    def select
+      return results.enum_for(:select) unless block_given? # Sparkling magic!
+      results.select(&Proc.new)
+    end
+
     def first(limit = 1)
-      @results = nil
+      @results = nil if @limit != limit
       @limit = limit
       limit == 1 ? results.first : results.first(limit)
     end
@@ -313,22 +353,27 @@ module Parse
       results
     end
 
-    def fetch!(compiled_query)
+    def _opts
       opts = {}
       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_master_key] == false || opts[:session_token].present?
-        opts[:cache] = false
-      end
+      # if opts[:use_master_key] == false || opts[:session_token].present?
+      #   opts[:cache] = false
+      # end
+      opts
+    end
+
+    def fetch!(compiled_query)
 
-      response = client.find_objects(@table, compiled_query.as_json, opts )
+      response = client.find_objects(@table, compiled_query.as_json, _opts )
       if response.error?
         puts "[ParseQuery] #{response.error}"
       end
       response
     end
+    alias_method :execute!, :fetch!
 
     def results(raw: false)
       if @results.nil?
@@ -361,28 +406,30 @@ module Parse
     end
 
     def compile(encode: true, includeClassName: false)
-      q = {} #query
-      q[:limit] = 11_000 if @limit == :max || @limit == :all
-      q[:limit] = @limit if @limit.is_a?(Numeric) && @limit > 0
-      q[:skip] = @skip if @skip > 0
-
-      q[:include] = @includes.join(',') unless @includes.empty?
-      q[:keys] = @keys.join(',')  unless @keys.empty?
-      q[:order] = @order.join(',') unless @order.empty?
-      unless @where.empty?
-        q[:where] = Parse::Query.compile_where(@where)
-        q[:where] = q[:where].to_json if encode
-      end
+      run_callbacks :prepare do
+        q = {} #query
+        q[:limit] = 11_000 if @limit == :max || @limit == :all
+        q[:limit] = @limit if @limit.is_a?(Numeric) && @limit > 0
+        q[:skip] = @skip if @skip > 0
+
+        q[:include] = @includes.join(',') unless @includes.empty?
+        q[:keys] = @keys.join(',')  unless @keys.empty?
+        q[:order] = @order.join(',') unless @order.empty?
+        unless @where.empty?
+          q[:where] = Parse::Query.compile_where(@where)
+          q[:where] = q[:where].to_json if encode
+        end
 
-      if @count && @count > 0
-        # if count is requested
-        q[:limit] = 0
-        q[:count] = 1
-      end
-      if includeClassName
-        q[:className] = @table
+        if @count && @count > 0
+          # if count is requested
+          q[:limit] = 0
+          q[:count] = 1
+        end
+        if includeClassName
+          q[:className] = @table
+        end
+        q
       end
-      q
     end
 
     def compile_where

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

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'parse/stack'
 require 'parse/stack/tasks'
 require 'rails/generators'

data/lib/parse/stack/railtie.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 module Parse
   module Stack

data/lib/parse/stack/tasks.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative '../stack.rb'
 require 'active_support'
 require 'active_support/inflector'
@@ -44,7 +47,7 @@ module Parse
 
           task :verify_env => :env do
 
-            unless Parse::Client.session?
+            unless Parse::Client.client?
               raise "Please make sure you have setup the Parse.setup configuration before invoking task. Usually done in the :environment task."
             end
 

data/lib/parse/stack/version.rb

@@ -1,5 +1,8 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 module Parse
   module Stack
-    VERSION = "1.4.3"
+    VERSION = "1.5.1"
   end
 end

data/lib/parse/stack.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative "stack/version"
 require_relative 'client'
 require_relative 'query'

data/lib/parse/webhooks/payload.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -9,6 +12,11 @@ require 'active_model_serializers'
 module Parse
 
     class Payload
+    ATTRIBUTES = { master: nil, user: nil,
+           installationId: nil, params: nil,
+             functionName: nil, object: nil,
+                 original: nil, update: nil,
+                 triggerName: nil }.freeze
     include ::ActiveModel::Serializers::JSON
     attr_accessor :master, :user, :installation_id, :params, :function_name, :object, :trigger_name
 
@@ -32,18 +40,22 @@ module Parse
       @update = hash[:update] || {} #it comes as an update hash
     end
 
+    def attributes
+      ATTRIBUTES
+    end
+
     def function?
       @function_name.present?
     end
 
     def parse_class
       return nil unless @object.present?
-      @object["className".freeze] || @object[:className]
+      @object[Parse::Model::KEY_CLASS_NAME] || @object[:className]
     end
 
     def parse_id
       return nil unless @object.present?
-      @object["objectId".freeze] || @object[:objectId]
+      @object[Parse::Model::OBJECT_ID] || @object[:objectId]
     end; alias_method :objectId, :parse_id
 
     def trigger?
@@ -117,12 +129,6 @@ module Parse
       Parse::Object.build(@object)
     end
 
-
-    def attributes
-      { master: nil, user: nil, installationId: nil, params: nil,
-        functionName: nil, object: nil, original: nil, update: nil, triggerName: nil }.freeze
-    end
-
     end # Payload
 
 end