parse-stack 1.5.3 → 1.6.0

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

@@ -4,90 +4,92 @@
 require_relative "properties"
 
 module Parse
-  # Defines the Schema methods applied to a Parse::Object.
-  module Schema
+  module Core
+    # Defines the Schema methods applied to a Parse::Object.
+    module Schema
 
-      # Generate a Parse-server compatible schema hash for performing changes to the
-      # structure of the remote collection.
-      # @return [Hash] the schema for this Parse::Object subclass.
-      def schema
-        sch = { className: parse_class, fields: {} }
-        #first go through all the attributes
-        attributes.each do |k,v|
-          # don't include the base Parse fields
-          next if Parse::Properties::BASE.include?(k)
-          next if v.nil?
-          result = { type: v.to_s.camelize }
-          # if it is a basic column property, find the right datatype
-          case v
-          when :integer, :float
-            result[:type] = "Number"
-          when :geopoint, :geo_point
-            result[:type] = "GeoPoint"
-          when :pointer
-            result = { type: "Pointer", targetClass: references[k] }
-          when :acl
-            result[:type] = "ACL"
-          else
-            result[:type] = v.to_s.camelize
-          end
+        # Generate a Parse-server compatible schema hash for performing changes to the
+        # structure of the remote collection.
+        # @return [Hash] the schema for this Parse::Object subclass.
+        def schema
+          sch = { className: parse_class, fields: {} }
+          #first go through all the attributes
+          attributes.each do |k,v|
+            # don't include the base Parse fields
+            next if Parse::Properties::BASE.include?(k)
+            next if v.nil?
+            result = { type: v.to_s.camelize }
+            # if it is a basic column property, find the right datatype
+            case v
+            when :integer, :float
+              result[:type] = Parse::Model::TYPE_NUMBER
+            when :geopoint, :geo_point
+              result[:type] = Parse::Model::TYPE_GEOPOINT
+            when :pointer
+              result = { type: Parse::Model::TYPE_POINTER, targetClass: references[k] }
+            when :acl
+              result[:type] = Parse::Model::ACL
+            else
+              result[:type] = v.to_s.camelize
+            end
 
-          sch[:fields][k] = result
+            sch[:fields][k] = result
 
+          end
+          #then add all the relational column attributes
+          relations.each do |k,v|
+            sch[:fields][k] = { type: Parse::Model::TYPE_RELATION, targetClass: relations[k] }
+          end
+          sch
         end
-        #then add all the relational column attributes
-        relations.each do |k,v|
-          sch[:fields][k] = { type: "Relation", targetClass: relations[k] }
-        end
-        sch
-      end
 
-      # Update the remote schema for this Parse collection.
-      # @param schema_updates [Hash] the changes to be made to the schema.
-      # @return [Parse::Response]
-      def update_schema(schema_updates = nil)
-        schema_updates ||= schema
-        client.update_schema parse_class, schema_updates
-      end
+        # Update the remote schema for this Parse collection.
+        # @param schema_updates [Hash] the changes to be made to the schema.
+        # @return [Parse::Response]
+        def update_schema(schema_updates = nil)
+          schema_updates ||= schema
+          client.update_schema parse_class, schema_updates
+        end
 
-      # Create a new collection for this model with the schema defined by the local
-      # model.
-      # @return [Parse::Response]
-      # @see Schema.schema
-      def create_schema
-        client.create_schema parse_class, schema
-      end
+        # Create a new collection for this model with the schema defined by the local
+        # model.
+        # @return [Parse::Response]
+        # @see Schema.schema
+        def create_schema
+          client.create_schema parse_class, schema
+        end
 
-      # Fetche the current schema for this collection from Parse server.
-      # @return [Parse::Response]
-      def fetch_schema
-        client.schema parse_class
-      end
+        # Fetche the current schema for this collection from Parse server.
+        # @return [Parse::Response]
+        def fetch_schema
+          client.schema parse_class
+        end
 
-      # A class method for non-destructive auto upgrading a remote schema based
-      # on the properties and relations you have defined in your local model. If
-      # the collection doesn't exist, we create the schema. If the collection already
-      # exists, the current schema is fetched, and only add the additional fields
-      # that are missing.
-      # @note No columns or fields are removed, this is a safe non-destructive upgrade.
-      # @return [Parse::Response] if the remote schema was modified.
-      # @return [Boolean] if no changes were made to the schema, it returns true.
-      def auto_upgrade!
-        response = fetch_schema
-        if response.success?
-          #let's figure out the diff fields
-          remote_fields = response.result["fields"]
-          current_schema = schema
-          current_schema[:fields] = current_schema[:fields].reduce({}) do |h,(k,v)|
-            #if the field does not exist in Parse, then add it to the update list
-            h[k] = v if remote_fields[k.to_s].nil?
-            h
+        # A class method for non-destructive auto upgrading a remote schema based
+        # on the properties and relations you have defined in your local model. If
+        # the collection doesn't exist, we create the schema. If the collection already
+        # exists, the current schema is fetched, and only add the additional fields
+        # that are missing.
+        # @note No columns or fields are removed, this is a safe non-destructive upgrade.
+        # @return [Parse::Response] if the remote schema was modified.
+        # @return [Boolean] if no changes were made to the schema, it returns true.
+        def auto_upgrade!
+          response = fetch_schema
+          if response.success?
+            #let's figure out the diff fields
+            remote_fields = response.result["fields"]
+            current_schema = schema
+            current_schema[:fields] = current_schema[:fields].reduce({}) do |h,(k,v)|
+              #if the field does not exist in Parse, then add it to the update list
+              h[k] = v if remote_fields[k.to_s].nil?
+              h
+            end
+            return true if current_schema[:fields].empty?
+            return update_schema( current_schema )
           end
-          return true if current_schema[:fields].empty?
-          return update_schema( current_schema )
+          create_schema
         end
-        create_schema
-      end
 
+    end
   end
 end

data/lib/parse/model/date.rb

@@ -23,6 +23,7 @@ module Parse
   # the Parse ISO hash format for these fields instead, set
   # `Parse::Object.disable_serialized_string_date = true`.
   class Date < ::DateTime
+    # The default attributes in a Parse Date hash.
     ATTRIBUTES = {  __type: :string, iso: :string }.freeze
     include ::ActiveModel::Model
     include ::ActiveModel::Serializers::JSON
@@ -43,10 +44,15 @@ module Parse
       to_time.utc.iso8601(3)
     end
 
+    # @return (see #iso)
+    def to_s(*args)
+      args.empty? ? iso : super(*args)
+    end
+
   end
 end
 
-
+# Adds extensions to Time class to be compatible with {Parse::Date}.
 class Time
   # @return [Parse::Date] Converts object to Parse::Date
   def parse_date
@@ -54,7 +60,7 @@ class Time
   end
 
 end
-
+# Adds extensions to DateTime class to be compatible with {Parse::Date}.
 class DateTime
   # @return [Parse::Date] Converts object to Parse::Date
   def parse_date
@@ -62,7 +68,9 @@ class DateTime
   end
 end
 
+# Adds extensions to ActiveSupport class to be compatible with {Parse::Date}.
 module ActiveSupport
+  # Adds extensions to ActiveSupport::TimeWithZone class to be compatible with {Parse::Date}.
   class TimeWithZone
     # @return [Parse::Date] Converts object to Parse::Date
     def parse_date

data/lib/parse/model/file.rb

@@ -26,13 +26,16 @@ module Parse
     # @note The default MIME type for all files is _image/jpeg_. This can be default
     #       can be changed by setting a value to `Parse::File.default_mime_type`.
     class File < Model
+      # Regular expression that matches the old legacy Parse hosted file name
+      LEGACY_FILE_RX = /^tfss-[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}-/
+      # The default attributes in a Parse File hash.
       ATTRIBUTES = {  __type: :string, name: :string, url: :string }.freeze
       # @return [String] the name of the file including extension (if any)
       attr_accessor :name
       # @return [String] the url resource of the file.
       attr_accessor :url
 
-      # You may set the contents of the file.
+      # @return [Object] the contents of the file.
       attr_accessor :contents
 
       # @return [String] the mime-type of the file whe
@@ -42,12 +45,16 @@ module Parse
       # @return [Model::TYPE_FILE]
       def parse_class; self.class.parse_class; end;
       alias_method :__type, :parse_class
+      # @!visibility private
       FIELD_NAME = "name"
+      # @!visibility private
       FIELD_URL = "url"
       class << self
 
+        # @return [String] the default mime-type
         attr_accessor :default_mime_type
 
+        # @return [Boolean] whether to force all urls to be https.
         attr_accessor :force_ssl
 
         # @return [String] The default mime type for created instances. Default: _'image/jpeg'_
@@ -135,6 +142,7 @@ module Parse
         @url == u.url
       end
 
+      # Allows mass assignment from a Parse JSON hash.
       def attributes=(h)
         if h.is_a?(String)
           @url = h
@@ -172,6 +180,12 @@ module Parse
         saved?
       end
 
+      # @return [Boolean] true if this file is hosted by Parse's servers.
+      def parse_hosted_file?
+        return false if @url.blank?
+        ::File.basename(@url).starts_with?('tfss-') || @url.starts_with?('http://files.parsetfss.com')
+      end
+
       # @!visibility private
       def inspect
         "<Parse::File @name='#{@name}' @mime_type='#{@mime_type}' @contents=#{@contents.nil?} @url='#{@url}'>"
@@ -187,7 +201,7 @@ module Parse
 
 end
 
-
+# Adds extensions to Hash class.
 class Hash
   # Determines if the hash contains Parse File json metadata fields. This is determined whether
   # the key `__type` exists and is of type `__File` and whether the `name` field matches the File.basename

data/lib/parse/model/geopoint.rb

@@ -23,18 +23,25 @@ module Parse
   #   place.save
   #
   class GeoPoint < Model
+    # The default attributes in a Parse GeoPoint hash.
     ATTRIBUTES = {  __type: :string, latitude: :float, longitude: :float }.freeze
 
     # @return [Float] latitude value between -90.0 and 90.0
     attr_accessor :latitude
     # @return [Float] longitude value between -180.0 and 180.0
     attr_accessor :longitude
-    FIELD_LAT = "latitude"
-    FIELD_LNG = "longitude"
+    # The key field for latitude
+    FIELD_LAT = "latitude".freeze
+    # The key field for longitude
+    FIELD_LNG = "longitude".freeze
 
+    # The minimum latitude value.
     LAT_MIN = -90.0
+    # The maximum latitude value.
     LAT_MAX = 90.0
+    # The minimum longitude value.
     LNG_MIN = -180.0
+    # The maximum longitude value.
     LNG_MAX = 180.0
 
     alias_method :lat, :latitude

data/lib/parse/model/model.rb

@@ -30,24 +30,50 @@ module Parse
     extend  ::ActiveModel::Callbacks # callback support on save, update, delete, etc.
     extend  ::ActiveModel::Naming # provides the methods for getting class names from Model classes
 
-    ID = "id".freeze
+    # The name of the field in a hash that contains information about the type
+    # of data the hash represents.
+    TYPE_FIELD = '__type'.freeze
+
+    # The objectId field in Parse Objects.
     OBJECT_ID   = 'objectId'.freeze
+    # @see OBJECT_ID
+    ID = "id".freeze
+
+    # The key field for getting class information.
     KEY_CLASS_NAME  = 'className'.freeze
+    # @deprecated Use OBJECT_ID instead.
     KEY_OBJECT_ID   = 'objectId'.freeze
+    # The key field for getting the created at date of an object hash.
     KEY_CREATED_AT  = 'createdAt'
+    # The key field for getting the updated at date of an object hash.
     KEY_UPDATED_AT  = 'updatedAt'
+    # The collection for Users in Parse. Used by Parse::User.
     CLASS_USER      = '_User'
+    # The collection for Installations in Parse. Used by Parse::Installation.
     CLASS_INSTALLATION = '_Installation'
+    # The collection for revocable Sessions in Parse. Used by Parse::Session.
     CLASS_SESSION = '_Session'
+    # The collection for revocable Roles in Parse. Used by Parse::Role.
     CLASS_ROLE = '_Role'
+    # The type label for hashes containing file data. Used by Parse::File.
     TYPE_FILE = 'File'
+    # The type label for hashes containing geopoints. Used by Parse::GeoPoint.
     TYPE_GEOPOINT = 'GeoPoint'
+    # The type label for hashes containing a Parse object. Used by Parse::Object and subclasses.
     TYPE_OBJECT = 'Object'
+    # The type label for hashes containing a Parse date object. Used by Parse::Date.
     TYPE_DATE = 'Date'
+    # The type label for hashes containing 'byte' data. Used by Parse::Bytes.
     TYPE_BYTES = 'Bytes'
+    # The type label for hashes containing ACL data. Used by Parse::ACL
+    TYPE_ACL = 'ACL'
+    # The type label for hashes storing numeric data.
+    TYPE_NUMBER = 'Number'
+    # The type label for hashes containing a Parse pointer.
     TYPE_POINTER = 'Pointer'
+    # The type label for hashes representing relational data.
     TYPE_RELATION = 'Relation'
-    TYPE_FIELD = '__type'
+
 
     # To support being able to have different ruby class names from the 'table'
     # names used in Parse, we will need to have a dynamic lookup system where
@@ -58,21 +84,25 @@ module Parse
     # @!visibility private
     @@model_cache = {}
 
-    # If set to true, a call to first_or_create will automatically save the object.
+    # @!attribute self.autosave_on_create
+    # If set to true, a call to {Parse::Object.first_or_create} will automatically save the object.
+    # Default is false.
     # @return [Boolean]
     def self.autosave_on_create
       @@autosave_on_create ||= false
     end
 
+    # @!visibility private
     def self.autosave_on_create=(bool)
       @@autosave_on_create = bool
     end
 
     class << self
+      # @!attribute self.raise_on_save_failure
       # By default, we return `true` or `false` for save and destroy operations.
       # 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`.
+      # fails, it will raise a `Parse::RecordNotSaved`.
       #
       # @example
       #   Parse::Model.raise_on_save_failure = true # globally across all models
@@ -84,15 +114,15 @@ module Parse
       # When enabled, if an error is returned by Parse due to saving or
       # destroying a record, due to your `before_save` or `before_delete`
       # validation cloud code triggers, `Parse::Object` will return the a
-      # `Parse::SaveFailureError` exception type. This exception has an
+      # `Parse::RecordNotSaved` exception type. This exception has an
       # instance method of `#object` which contains the object that failed to save.
       #
       # @return [Boolean]
-      attr_accessor :raise_on_save_failure
 
       def raise_on_save_failure
         @global_raise_on_save_failure ||= false
       end
+
       def raise_on_save_failure=(bool)
         @global_raise_on_save_failure = bool
       end
@@ -137,7 +167,7 @@ module Parse
 
 end
 
-
+# Add extensions to the String class.
 class String
   # This method returns a camel-cased version of the string with the first letter
   # of the string in lower case. This is the standard naming convention for Parse columns
@@ -181,6 +211,7 @@ class String
   end
 end
 
+# Add extensions to the Symbol class.
 class Symbol
   # @return [String] a lower-first-camelcased version of the symbol
   # @see String#columnize

data/lib/parse/model/object.rb

@@ -11,23 +11,25 @@ require 'active_model_serializers'
 require 'time'
 require 'open-uri'
 
-require_relative "../client"
-require_relative "model"
-require_relative "pointer"
-require_relative "geopoint"
-require_relative "file"
-require_relative "bytes"
-require_relative "date"
-require_relative "acl"
-require_relative "push"
+require_relative '../client'
+require_relative 'model'
+require_relative 'pointer'
+require_relative 'geopoint'
+require_relative 'file'
+require_relative 'bytes'
+require_relative 'date'
+require_relative 'acl'
+require_relative 'push'
 require_relative 'core/actions'
 require_relative 'core/fetching'
 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"
+require_relative 'core/schema'
+require_relative 'core/properties'
+require_relative 'core/errors'
+require_relative 'core/builder'
+require_relative 'associations/has_one'
+require_relative 'associations/belongs_to'
+require_relative 'associations/has_many'
 
 
 module Parse
@@ -36,6 +38,19 @@ module Parse
       Parse::Object.descendants.map(&:parse_class).uniq
   end
 
+  # @return [Array<Hash>] the list of all schemas for this application.
+  def self.schemas
+    client.schemas.results
+  end
+
+  # Fetch the schema for a specific collection name.
+  # @param className [String] the name collection
+  # @return [Hash] the schema document of this collection.
+  # @see Parse::Core::ClassBuilder.build!
+  def self.schema(className)
+    client.schema(className).result
+  end
+
   # Perform a non-destructive upgrade of all your Parse schemas in the backend
   # based on the property definitions of your local {Parse::Object} subclasses.
   def self.auto_upgrade!
@@ -91,10 +106,11 @@ module Parse
     include Associations::HasOne
     include Associations::BelongsTo
     include Associations::HasMany
-    extend Querying
-    extend Schema
-    include Fetching
-    include Actions
+    extend Core::Querying
+    extend Core::Schema
+    include Core::Fetching
+    include Core::Actions
+    # @!visibility private
     BASE_OBJECT_CLASS = "Parse::Object".freeze
 
     # @return [Model::TYPE_OBJECT]
@@ -192,7 +208,7 @@ module Parse
     alias_method :className, :parse_class
 
     # @return [Hash] the schema structure for this Parse collection from the server.
-    # @see Parse::Schema
+    # @see Parse::Core::Schema
     def schema
       self.class.schema
     end
@@ -426,16 +442,41 @@ module Parse
     property :updated_at, :date
     property :acl, :acl, field: :ACL
 
+    # Alias to {created_at}
+    # @return (see #created_at)
     def createdAt
       return @created_at if Parse::Object.disable_serialized_string_date.present?
       @created_at.to_time.utc.iso8601(3) if @created_at.present?
     end
 
+    # Alias to {updated_at}
+    # @return (see #updated_at)
     def updatedAt
       return @updated_at if Parse::Object.disable_serialized_string_date.present?
       @updated_at.to_time.utc.iso8601(3) if @updated_at.present?
     end
 
+    # Access the value for a defined property through hash accessor. This method
+    # returns nil if the key is not one of the defined properties for this Parse::Object
+    # subclass.
+    # @param key [String] the name of the property. This key must be in the {fields} hash.
+    # @return [Object] the value for this key.
+    def [](key)
+      return nil unless self.class.fields[key.to_sym].present?
+      send(key)
+    end
+
+    # Set the value for a specific property through a hash accessor. This method
+    # does nothing if key is not one of the defined properties for this Parse::Object
+    # subclass.
+    # @param key (see Parse::Object#[])
+    # @param value [Object] the value to set this property.
+    # @return [Object] the value passed in.
+    def []=(key,value)
+      return unless self.class.fields[key.to_sym].present?
+      send("#{key}=",value)
+    end
+
   end