parse-stack 1.8.0 → 1.8.1

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

@@ -8,110 +8,107 @@ module Parse
     # 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] = 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
-            when :timezone, :time_zone
-              result[:type] = "String" # no TimeZone native in Parse
-            else
-              result[:type] = v.to_s.camelize
-            end
-
-            sch[:fields][k] = result
-
+      # 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
+          when :timezone, :time_zone
+            result[:type] = "String" # no TimeZone native in Parse
+          else
+            result[:type] = v.to_s.camelize
           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
 
-        # 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
+          sch[:fields][k] = result
         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
+        #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
 
-        # Fetche the current schema for this collection from Parse server.
-        # @return [Parse::Response]
-        def fetch_schema
-          client.schema parse_class
-        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
 
-        # 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 This feature requires use of the master_key. 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!
+      # 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
 
-          unless client.master_key.present?
-            warn "[Parse] Schema changes for #{parse_class} is only available with the master key!"
-            return false
-          end
-          # fetch the current schema (requires master key)
-          response = fetch_schema
+      # Fetche the current schema for this collection from Parse server.
+      # @return [Parse::Response]
+      def fetch_schema
+        client.schema parse_class
+      end
 
-          # if it's a core class that doesn't exist, then create the collection without any fields,
-          # since parse-server will automatically create the collection with the set of core fields.
-          # then fetch the schema again, to add the missing fields.
-          if response.error? && self.to_s.start_with?('Parse::') #is it a core class?
-            client.create_schema parse_class, {}
-            response = fetch_schema
-            # if it still wasn't able to be created, raise an error.
-            if response.error?
-              warn "[Parse] Schema error: unable to create class #{parse_class}"
-              return response
-            end
-          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 This feature requires use of the master_key. 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!
+        unless client.master_key.present?
+          warn "[Parse] Schema changes for #{parse_class} is only available with the master key!"
+          return false
+        end
+        # fetch the current schema (requires master key)
+        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 )
+        # if it's a core class that doesn't exist, then create the collection without any fields,
+        # since parse-server will automatically create the collection with the set of core fields.
+        # then fetch the schema again, to add the missing fields.
+        if response.error? && self.to_s.start_with?("Parse::") #is it a core class?
+          client.create_schema parse_class, {}
+          response = fetch_schema
+          # if it still wasn't able to be created, raise an error.
+          if response.error?
+            warn "[Parse] Schema error: unable to create class #{parse_class}"
+            return response
           end
-            create_schema
         end
 
+        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
+        create_schema
+      end
     end
   end
 end

data/lib/parse/model/date.rb

@@ -1,31 +1,32 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'time'
-require 'date'
-require 'active_model'
-require 'active_support'
-require 'active_support/inflector'
-require 'active_support/core_ext/object'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date_time/calculations'
-require 'active_support/core_ext/time/calculations'
-require 'active_model_serializers'
-require_relative 'model'
+require "time"
+require "date"
+require "active_model"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext/object"
+require "active_support/core_ext/date/calculations"
+require "active_support/core_ext/date_time/calculations"
+require "active_support/core_ext/time/calculations"
+require "active_model_serializers"
+require_relative "model"
 
 module Parse
   # This class manages dates in the special JSON format it requires for
-  # properties of type _:date_. 
+  # properties of type _:date_.
   class Date < ::DateTime
     # The default attributes in a Parse Date hash.
-    ATTRIBUTES = {  __type: :string, iso: :string }.freeze
+    ATTRIBUTES = { __type: :string, iso: :string }.freeze
     include ::ActiveModel::Model
     include ::ActiveModel::Serializers::JSON
 
     # @return [Parse::Model::TYPE_DATE]
-    def self.parse_class; Parse::Model::TYPE_DATE; end;
+    def self.parse_class; Parse::Model::TYPE_DATE; end
     # @return [Parse::Model::TYPE_DATE]
-    def parse_class; self.class.parse_class; end;
+    def parse_class; self.class.parse_class; end
+
     alias_method :__type, :parse_class
 
     # @return [Hash]
@@ -42,7 +43,6 @@ module Parse
     def to_s(*args)
       args.empty? ? iso : super(*args)
     end
-
   end
 end
 
@@ -52,7 +52,6 @@ class Time
   def parse_date
     Parse::Date.parse iso8601(3)
   end
-
 end
 
 # Adds extensions to DateTime class to be compatible with {Parse::Date}.

data/lib/parse/model/file.rb

@@ -1,204 +1,201 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-require 'active_support'
-require 'active_support/core_ext/object'
+require "active_support"
+require "active_support/core_ext/object"
 require_relative "model"
-require 'open-uri'
+require "open-uri"
 
 module Parse
-    # This class represents a Parse file pointer. `Parse::File` has helper
-    # methods to upload Parse files directly to Parse and manage file
-    # associations with your classes.
-    # @example
-    #  file = File.open("file_path.jpg")
-    #  contents = file.read
-    #  file = Parse::File.new("myimage.jpg", contents , "image/jpeg")
-    #  file.saved? # => false
-    #  file.save
-    #
-    #  file.url # https://files.parsetfss.com/....
-    #
-    #  # or create and upload a remote file (auto-detected mime type)
-    #  file = Parse::File.create(some_url)
-    #
-    #
-    # @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
-
-      # @return [Object] the contents of the file.
-      attr_accessor :contents
-
-      # @return [String] the mime-type of the file whe
-      attr_accessor :mime_type
-      # @return [Model::TYPE_FILE]
-      def self.parse_class; TYPE_FILE; end;
-      # @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'_
-        def default_mime_type
-          @default_mime_type ||= "image/jpeg"
-        end
-
-        # @return [Boolean] When set to true, it will make all calls to File#url
-        def force_ssl
-          @force_ssl ||= false
-        end
-
+  # This class represents a Parse file pointer. `Parse::File` has helper
+  # methods to upload Parse files directly to Parse and manage file
+  # associations with your classes.
+  # @example
+  #  file = File.open("file_path.jpg")
+  #  contents = file.read
+  #  file = Parse::File.new("myimage.jpg", contents , "image/jpeg")
+  #  file.saved? # => false
+  #  file.save
+  #
+  #  file.url # https://files.parsetfss.com/....
+  #
+  #  # or create and upload a remote file (auto-detected mime type)
+  #  file = Parse::File.create(some_url)
+  #
+  #
+  # @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
+
+    # @return [Object] the contents of the file.
+    attr_accessor :contents
+
+    # @return [String] the mime-type of the file whe
+    attr_accessor :mime_type
+    # @return [Model::TYPE_FILE]
+    def self.parse_class; TYPE_FILE; end
+    # @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'_
+      def default_mime_type
+        @default_mime_type ||= "image/jpeg"
       end
-      # The initializer to create a new file supports different inputs.
-      # If the first paramter is a string which starts with 'http', we then download
-      # the content of the file (and use the detected mime-type) to set the content and mime_type fields.
-      # If the first parameter is a hash, we assume it might be the Parse File hash format which contains url and name fields only.
-      # If the first paramter is a Parse::File, then we copy fields over
-      # Otherwise, creating a new file requires a name, the actual contents (usually from a File.open("local.jpg").read ) and the mime-type
-      # @param name [String]
-      # @param contents [Object]
-      # @param mime_type [String] Default see default_mime_type
-      def initialize(name, contents = nil, mime_type = nil)
-        mime_type ||= Parse::File.default_mime_type
-
-        if name.is_a?(String) && name.start_with?('http') #could be url string
-          file = open( name )
-          @contents =  file.read
-          @name = File.basename file.base_uri.to_s
-          @mime_type = file.content_type
-        elsif name.is_a?(Hash)
-          self.attributes = name
-        elsif name.is_a?(::File)
-          @contents =  contents || name.read
-          @name = File.basename name.to_path
-        elsif name.is_a?(Parse::File)
-          @name = name.name
-          @url = name.url
-        else
-          @name = name
-          @contents = contents
-        end
-        if @name.blank?
-          raise ArgumentError, "Invalid Parse::File initialization with name '#{@name}'"
-        end
-
-        @mime_type ||= mime_type
 
+      # @return [Boolean] When set to true, it will make all calls to File#url
+      def force_ssl
+        @force_ssl ||= false
       end
-
-      # This creates a new Parse File Object with from a URL, saves it and returns it
-      # @param url [String] A url which will be used to create the file and automatically save it.
-      # @return [Parse::File] A newly saved file based on contents of _url_
-      def self.create(url)
-        url = url.url if url.is_a?(Parse::File)
-        file = self.new(url)
-        file.save
-        file
+    end
+    # The initializer to create a new file supports different inputs.
+    # If the first paramter is a string which starts with 'http', we then download
+    # the content of the file (and use the detected mime-type) to set the content and mime_type fields.
+    # If the first parameter is a hash, we assume it might be the Parse File hash format which contains url and name fields only.
+    # If the first paramter is a Parse::File, then we copy fields over
+    # Otherwise, creating a new file requires a name, the actual contents (usually from a File.open("local.jpg").read ) and the mime-type
+    # @param name [String]
+    # @param contents [Object]
+    # @param mime_type [String] Default see default_mime_type
+    def initialize(name, contents = nil, mime_type = nil)
+      mime_type ||= Parse::File.default_mime_type
+
+      if name.is_a?(String) && name.start_with?("http") #could be url string
+        file = open(name)
+        @contents = file.read
+        @name = File.basename file.base_uri.to_s
+        @mime_type = file.content_type
+      elsif name.is_a?(Hash)
+        self.attributes = name
+      elsif name.is_a?(::File)
+        @contents = contents || name.read
+        @name = File.basename name.to_path
+      elsif name.is_a?(Parse::File)
+        @name = name.name
+        @url = name.url
+      else
+        @name = name
+        @contents = contents
       end
-
-      # A File object is considered saved if the basename of the URL and the name parameters are equal
-      # @return [Boolean] true if this file has already been saved.
-      def saved?
-        @url.present? && @name.present? && @name == File.basename(@url)
+      if @name.blank?
+        raise ArgumentError, "Invalid Parse::File initialization with name '#{@name}'"
       end
 
-      # Returns the url string for this Parse::File pointer. If the *force_ssl* option is
-      # set to true, it will make sure it returns a secure url.
-      # @return [String] the url string for the file.
-      def url
-        if @url.present? && Parse::File.force_ssl && @url.starts_with?('http://')
-          return @url.sub('http://', 'https://')
-        end
-        @url
-      end
+      @mime_type ||= mime_type
+    end
 
-      # @return [Hash]
-      def attributes
-        ATTRIBUTES
-      end
+    # This creates a new Parse File Object with from a URL, saves it and returns it
+    # @param url [String] A url which will be used to create the file and automatically save it.
+    # @return [Parse::File] A newly saved file based on contents of _url_
+    def self.create(url)
+      url = url.url if url.is_a?(Parse::File)
+      file = self.new(url)
+      file.save
+      file
+    end
 
-      # @return [Boolean] Two files are equal if they have the same url
-      def ==(u)
-        return false unless u.is_a?(self.class)
-        @url == u.url
-      end
+    # A File object is considered saved if the basename of the URL and the name parameters are equal
+    # @return [Boolean] true if this file has already been saved.
+    def saved?
+      @url.present? && @name.present? && @name == File.basename(@url)
+    end
 
-      # Allows mass assignment from a Parse JSON hash.
-      def attributes=(h)
-        if h.is_a?(String)
-          @url = h
-          @name = File.basename(h)
-        elsif h.is_a?(Hash)
-          @url = h[FIELD_URL] || h[:url] || @url
-          @name = h[FIELD_NAME] || h[:name] || @name
-        end
+    # Returns the url string for this Parse::File pointer. If the *force_ssl* option is
+    # set to true, it will make sure it returns a secure url.
+    # @return [String] the url string for the file.
+    def url
+      if @url.present? && Parse::File.force_ssl && @url.starts_with?("http://")
+        return @url.sub("http://", "https://")
       end
+      @url
+    end
 
-      # A proxy method for ::File.basename
-      # @param file_name [String]
-      # @param suffix [String]
-      # @return [String] File.basename(file_name)
-      # @see ::File.basename
-      def self.basename(file_name, suffix = nil)
-       if suffix.nil?
-         ::File.basename(file_name)
-       else
-         ::File.basename(file_name, suffix)
-       end
-      end
+    # @return [Hash]
+    def attributes
+      ATTRIBUTES
+    end
 
-      # Save the file by uploading it to Parse and creating a file pointer.
-      # @return [Boolean] true if successfully uploaded and saved.
-      def save
-        unless saved? || @contents.nil? || @name.nil?
-          response = client.create_file(@name, @contents, @mime_type)
-          unless response.error?
-            result = response.result
-            @name = result[FIELD_NAME] || File.basename(result[FIELD_URL])
-            @url = result[FIELD_URL]
-          end
-        end
-        saved?
-      end
+    # @return [Boolean] Two files are equal if they have the same url
+    def ==(u)
+      return false unless u.is_a?(self.class)
+      @url == u.url
+    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')
+    # Allows mass assignment from a Parse JSON hash.
+    def attributes=(h)
+      if h.is_a?(String)
+        @url = h
+        @name = File.basename(h)
+      elsif h.is_a?(Hash)
+        @url = h[FIELD_URL] || h[:url] || @url
+        @name = h[FIELD_NAME] || h[:name] || @name
       end
+    end
 
-      # @!visibility private
-      def inspect
-        "<Parse::File @name='#{@name}' @mime_type='#{@mime_type}' @contents=#{@contents.nil?} @url='#{@url}'>"
+    # A proxy method for ::File.basename
+    # @param file_name [String]
+    # @param suffix [String]
+    # @return [String] File.basename(file_name)
+    # @see ::File.basename
+    def self.basename(file_name, suffix = nil)
+      if suffix.nil?
+        ::File.basename(file_name)
+      else
+        ::File.basename(file_name, suffix)
       end
+    end
 
-      # @return [String] the url
-      # @see #url
-      def to_s
-        @url
+    # Save the file by uploading it to Parse and creating a file pointer.
+    # @return [Boolean] true if successfully uploaded and saved.
+    def save
+      unless saved? || @contents.nil? || @name.nil?
+        response = client.create_file(@name, @contents, @mime_type)
+        unless response.error?
+          result = response.result
+          @name = result[FIELD_NAME] || File.basename(result[FIELD_URL])
+          @url = result[FIELD_URL]
+        end
       end
+      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}'>"
+    end
+
+    # @return [String] the url
+    # @see #url
+    def to_s
+      @url
+    end
+  end
 end
 
 # Adds extensions to Hash class.