parse-stack 1.4.3 → 1.5.1

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

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -7,6 +10,7 @@ require 'active_support/inflector'
 require 'active_model_serializers'
 require 'active_support/inflector'
 require 'active_model_serializers'
+require 'active_support/hash_with_indifferent_access'
 require 'time'
 
 =begin
@@ -25,8 +29,8 @@ module Parse
 
   module Properties
     # This is an exception that is thrown if there is an issue when creating a specific property for a class.
-    class DefinitionError < Exception; end;
-    class ValueError < Exception; end;
+    class DefinitionError < StandardError; end;
+    class ValueError < StandardError; end;
 
     # These are the base types supported by Parse.
     TYPES = [:id, :string, :relation, :integer, :float, :boolean, :date, :array, :file, :geopoint, :bytes, :object, :acl].freeze
@@ -61,6 +65,10 @@ module Parse
         @field_map ||= BASE_FIELD_MAP.dup
       end
 
+      def enums
+        @enums ||= {}
+      end
+
       # Keeps track of all the attributes supported by this class.
       def attributes=(hash)
         @attributes = BASE.merge(hash)
@@ -93,9 +101,12 @@ module Parse
       # for enum type fields that are string columns in Parse. Ex. a booking_status for a field
       # could be either "submitted" or "completed" in Parse, however with symbolize, these would
       # be available as :submitted or :completed.
-      def property(key, data_type = :string, opts = {})
+      def property(key, data_type = :string, **opts)
 
         key = key.to_sym
+        ivar = :"@#{key}"
+        will_change_method = :"#{key}_will_change!"
+        set_attribute_method = :"#{key}_set_attribute!"
 
         if data_type.is_a?(Hash)
           opts.merge!(data_type)
@@ -104,10 +115,16 @@ module Parse
 
         # allow :bool for :boolean
         data_type = :boolean if data_type == :bool
+        data_type = :integer if data_type == :int
+
         # set defaults
         opts = { required: false,
                  alias: true,
                  symbolize: false,
+                 enum: nil,
+                 scopes: true,
+                 _prefix: nil,
+                 _suffix: false,
                  field: key.to_s.camelize(:lower)
                }.merge( opts )
         #By default, the remote field name is a lower-first-camelcase version of the key
@@ -142,11 +159,79 @@ module Parse
           validates_presence_of key
         end
 
+
+        is_enum_type = opts[:enum].nil? == false
+
+        if is_enum_type
+
+          unless data_type == :string
+            raise DefinitionError, "Property #{self}##{parse_field} :enum option is only supported on :string data types."
+          end
+
+          enum_values = opts[:enum]
+          unless enum_values.is_a?(Array) && enum_values.empty? == false
+            raise DefinitionError, "Property #{self}##{parse_field} :enum option must be an Array type of symbols."
+          end
+          opts[:symbolize] = true
+
+          enum_values = enum_values.dup.map(&:to_sym).freeze
+
+          self.enums.merge!( key => enum_values )
+          allow_nil = opts[:required] == false
+          validates key, inclusion: { in: enum_values }, allow_nil: allow_nil
+
+          unless opts[:scopes] == false
+            # You can use the :_prefix or :_suffix options when you need to define multiple enums with same values.
+            # If the passed value is true, the methods are prefixed/suffixed with the name of the enum. It is also possible to supply a custom value:
+            prefix = opts[:_prefix]
+            unless opts[:_prefix].nil? || prefix.is_a?(Symbol) || prefix.is_a?(String)
+              raise DefinitionError, "Enumeration option :_prefix must either be a symbol or string for #{self}##{key}."
+            end
+
+            unless opts[:_suffix].is_a?(TrueClass) || opts[:_suffix].is_a?(FalseClass)
+              raise DefinitionError, "Enumeration option :_suffix must either be true or false for #{self}##{key}."
+            end
+
+            add_suffix = opts[:_suffix] == true
+            prefix_or_key = (prefix.blank? ? key : prefix).to_sym
+
+            class_method_name = prefix_or_key.to_s.pluralize.to_sym
+            if singleton_class.method_defined?(class_method_name)
+              raise DefinitionError, "You tried to define an enum named `#{key}` for #{self} " + \
+              "but this will generate a method  `#{self}.#{class_method_name}` " + \
+              " which is already defined. Try using :_suffix or :_prefix options."
+            end
+
+            define_singleton_method(class_method_name) { enum_values }
+
+            method_name = add_suffix ? :"valid_#{prefix_or_key}?" : :"#{prefix_or_key}_valid?"
+            define_method(method_name) do
+              value = instance_variable_get(ivar)
+              return true if allow_nil && value.nil?
+              enum_values.include?(value.to_s.to_sym)
+            end
+
+            enum_values.each do |enum|
+              method_name = enum # default
+              scope_name = enum
+              if add_suffix
+                method_name = :"#{enum}_#{prefix_or_key}"
+              elsif prefix.present?
+                method_name = :"#{prefix}_#{enum}"
+              end
+              self.scope method_name, ->(ex = {}){ ex.merge!(key => enum); query( ex )  }
+              define_method("#{method_name}!") { instance_variable_set(ivar, enum) }
+              define_method("#{method_name}?") { enum == instance_variable_get(ivar).to_s.to_sym }
+            end
+          end # unless scopes
+
+        end
+
         symbolize_value = opts[:symbolize]
 
         #only support symbolization of string data types
         if symbolize_value && (data_type == :string || data_type == :array) == false
-          raise 'Symbolization is only supported on :string or :array data types.'
+          raise DefinitionError, "Tried to symbolize #{self}##{key}, but it is only supported on :string or :array data types."
         end
 
         # Here is the where the 'magic' begins. For each property defined, we will
@@ -166,11 +251,11 @@ module Parse
         end
 
         # We define a getter with the key
+
         define_method(key) do
 
           # we will get the value using the internal value of the instance variable
           # using the instance_variable_get
-          ivar = :"@#{key}"
           value = instance_variable_get ivar
 
           # If the value is nil and this current Parse::Object instance is a pointer?
@@ -191,7 +276,7 @@ module Parse
              value = format_value(key, value, data_type)
             # lets set the variable with the updated value
              instance_variable_set ivar, value
-             send "#{key}_will_change!"
+             send will_change_method
           end
 
           # if the value is a String (like an iso8601 date) and the data type of
@@ -199,7 +284,7 @@ module Parse
           if value.is_a?(String) && data_type == :date
             value = format_value(key, value, data_type)
             instance_variable_set ivar, value
-            send "#{key}_will_change!"
+            send will_change_method
           end
           # finally return the value
           if symbolize_value
@@ -214,6 +299,19 @@ module Parse
           value
         end
 
+        # support question mark methods for boolean
+        if data_type == :boolean
+          if self.method_defined?("#{key}?")
+            puts "Creating boolean helper :#{key}?. Will overwrite existing method #{self}##{key}?."
+          end
+
+          # returns true if set to true, false otherwise
+          define_method("#{key}?") { (send(key) == true) }
+          unless opts[:scopes] == false
+            scope key, ->(opts = {}){ query( opts.merge(key => true) ) }
+          end
+        end
+
         # The second method to be defined is a setter method. This is done by
         # defining :key with a '=' sign. However, to support setting the attribute
         # with and without dirty tracking, we really will just proxy it to another method
@@ -221,12 +319,12 @@ module Parse
         define_method("#{key}=") do |val|
           #we proxy the method passing the value and true. Passing true to the
           # method tells it to make sure dirty tracking is enabled.
-          self.send "#{key}_set_attribute!", val, true
+          self.send set_attribute_method, val, true
         end
 
         # This is the real setter method. Takes two arguments, the value to set
         # and whether to mark it as dirty tracked.
-        define_method("#{key}_set_attribute!") do |val, track = true|
+        define_method(set_attribute_method) do |val, track = true|
           # Each value has a data type, based on that we can treat the incoming
           # value as input, and format it to the correct storage format. This method is
           # defined in this file (instance method)
@@ -235,7 +333,7 @@ module Parse
           # this will grab the current value and keep a copy of it - but we only do this if
           # the new value being set is different from the current value stored.
           if track == true
-            send :"#{key}_will_change!" unless val == instance_variable_get( :"@#{key}" )
+            send will_change_method unless val == instance_variable_get( ivar )
           end
 
           if symbolize_value
@@ -247,8 +345,12 @@ module Parse
               val.set_collection! items
             end
           end
+
+          # if is_enum_type
+          #
+          # end
           # now set the instance value
-          instance_variable_set :"@#{key}", val
+          instance_variable_set ivar, val
         end
 
         # The core methods above support all attributes with the base local :key parameter
@@ -267,7 +369,7 @@ module Parse
         if self.method_defined?(parse_field) == false && opts[:alias]
           alias_method parse_field, key
           alias_method "#{parse_field}=", "#{key}="
-          alias_method "#{parse_field}_set_attribute!", "#{key}_set_attribute!"
+          alias_method "#{parse_field}_set_attribute!", set_attribute_method
         elsif parse_field.to_sym != :objectId
           warn "Alias property method #{self}##{parse_field} already defined."
         end
@@ -286,6 +388,7 @@ module Parse
       self.class.fields(type)
     end
 
+    # TODO: We can optimize
     def attributes
       {__type: :string, :className => :string}.merge!(self.class.attributes)
     end
@@ -295,9 +398,9 @@ module Parse
     def apply_attributes!(hash, dirty_track: false)
       return unless hash.is_a?(Hash)
 
-      @id ||= hash["id"] || hash["objectId"] || hash[:objectId]
+      @id ||= hash[Parse::Model::ID] || hash[Parse::Model::OBJECT_ID] || hash[:objectId]
       hash.each do |key, value|
-        method = "#{key}_set_attribute!"
+        method = "#{key}_set_attribute!".freeze
         send(method, value, dirty_track) if respond_to?( method )
       end
     end
@@ -326,6 +429,8 @@ module Parse
         h[remote_field] = send key
         h[remote_field] = {__op: :Delete} if h[remote_field].nil?
         # in the case that the field is a Parse object, generate a pointer
+        # if it is a Parse::PointerCollectionProxy, then make sure we get a list of pointers.
+        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
@@ -341,21 +446,22 @@ module Parse
     def format_operation(key, val, data_type)
       return val unless val.is_a?(Hash) && val["__op"].present?
       op = val["__op"]
+      ivar = :"@#{key}"
       #handles delete case otherwise 'null' shows up in column
       if "Delete" == op
         val = nil
       elsif "Add" == op && data_type == :array
-        val = (instance_variable_get(:"@#{key}") || []).to_a + (val["objects"] || [])
+        val = (instance_variable_get(ivar) || []).to_a + (val["objects"] || [])
       elsif "Remove" == op && data_type == :array
-        val = (instance_variable_get(:"@#{key}") || []).to_a - (val["objects"] || [])
+        val = (instance_variable_get(ivar) || []).to_a - (val["objects"] || [])
       elsif "AddUnique" == op && data_type == :array
         objects = (val["objects"] || []).uniq
-        original_items = (instance_variable_get(:"@#{key}") || []).to_a
+        original_items = (instance_variable_get(ivar) || []).to_a
         objects.reject! { |r| original_items.include?(r) }
         val = original_items + objects
       elsif "Increment" == op && data_type == :integer || data_type == :integer
         # for operations that increment by a certain amount, they come as a hash
-        val = (instance_variable_get(:"@#{key}") || 0) + (val["amount"] || 0).to_i
+        val = (instance_variable_get(ivar) || 0) + (val["amount"] || 0).to_i
       end
       val
     end
@@ -370,7 +476,7 @@ module Parse
 
       case data_type
       when :object
-        val = val #should be regular hash, maybe in the future we return hashie?
+        val = val.with_indifferent_access if val.is_a?(Hash)
       when :array
         # All "array" types use a collection proxy
         val = val.to_a if val.is_a?(Parse::CollectionProxy) #all objects must be in array form
@@ -408,7 +514,7 @@ module Parse
           val = val.parse_date
           # if the value is a hash, then it may be the Parse hash format for an iso date.
         elsif val.is_a?(Hash) # val.respond_to?(:iso8601)
-          val = Parse::Date.parse(val["iso".freeze] || val[:iso])
+          val = Parse::Date.parse(val["iso"] || val[:iso])
         elsif val.is_a?(String)
           # if it's a string, try parsing the date
           val = Parse::Date.parse val

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

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative '../../query'
 
 # This module provides most of the querying methods for Parse Objects.
@@ -12,14 +15,57 @@ module Parse
 
     module ClassMethods
 
+      def scope(name, body)
+        unless body.respond_to?(:call)
+          raise ArgumentError, 'The scope body needs to be callable.'
+        end
+
+        name = name.to_sym
+        if respond_to?(name, true)
+          puts "Creating scope :#{name}. Will overwrite existing method #{self}.#{name}."
+        end
+
+        define_singleton_method(name) do |*args, &block|
+
+          if body.arity.zero?
+            res = body.call
+            res.conditions(*args) if args.present?
+          else
+            res = body.call(*args)
+          end
+
+          _q = res || query
+
+          if _q.is_a?(Parse::Query)
+            klass = self
+            _q.define_singleton_method(:method_missing) do |m, *args, &block|
+              if klass.respond_to?(m, true)
+                klass_scope = klass.send(m, *args, &block)
+                if klass_scope.is_a?(Parse::Query)
+                  return self.add_constraints( klass_scope.constraints )
+                end
+                klass = nil # help clean up ruby gc
+                return klass_scope
+              end
+              klass = nil # help clean up ruby gc
+              return self.results.send(m, *args, &block)
+            end
+          end
+          return _q if block.nil?
+          _q.results(&block)
+        end
+
+      end
+
+
       # This query method helper returns a Query object tied to a parse class.
       # The parse class should be the name of the one that will be sent in the query
       # request pointing to the remote table.
       def query(constraints = {})
         Parse::Query.new self.parse_class, constraints
-      end
+      end; alias_method :where, :query
 
-      def where(clauses = {})
+      def literal_where(clauses = {})
         query.where(clauses)
       end
 
@@ -49,10 +95,24 @@ module Parse
       end
 
       # creates a count request (which is more performant when counting objects)
-      def count(constraints = {})
+      def count(**constraints)
         query(constraints).count
       end
 
+      def newest(**constraints)
+        constraints.merge!(order: :created_at.desc)
+        _q = query(constraints)
+        _q.define_singleton_method(:method_missing) { |m, *args, &block| self.results.send(m, *args, &block) }
+        _q
+      end
+
+      def oldest(**constraints)
+        constraints.merge!(order: :created_at.asc)
+        _q = query(constraints)
+        _q.define_singleton_method(:method_missing) { |m, *args, &block| self.results.send(m, *args, &block) }
+        _q
+      end
+
       # Find objects based on objectIds. The result is a list (or single item) of the
       # objects that were successfully found.
       # Example:

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

@@ -1,10 +1,13 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require_relative "properties"
 # This class adds methods to Parse::Objects in order to create a JSON Parse schema
 # in order to support table creation and table alterations.
 module Parse
 
   def self.auto_upgrade!
-    klassModels = Parse::Object.descendants - [Parse::User, Parse::Installation, Parse::Role, Parse::Session]
+    klassModels = Parse::Object.descendants
     klassModels.sort_by { |c| c.parse_class }.each do |klass|
       yield(klass) if block_given?
       klass.auto_upgrade!
@@ -31,13 +34,13 @@ module Parse
           # if it is a basic column property, find the right datatype
           case v
           when :integer, :float
-            result[:type] = "Number".freeze
+            result[:type] = "Number"
           when :geopoint, :geo_point
-            result[:type] = "GeoPoint".freeze
+            result[:type] = "GeoPoint"
           when :pointer
-            result = { type: "Pointer".freeze, targetClass: references[k] }
+            result = { type: "Pointer", targetClass: references[k] }
           when :acl
-            result[:type] = "ACL".freeze
+            result[:type] = "ACL"
           else
             result[:type] = v.to_s.camelize
           end
@@ -47,7 +50,7 @@ module Parse
         end
         #then add all the relational column attributes
         relations.each do |k,v|
-          sch[:fields][k] = { type: "Relation".freeze, targetClass: relations[k] }
+          sch[:fields][k] = { type: "Relation", targetClass: relations[k] }
         end
         sch
       end

data/lib/parse/model/date.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'time'
 require 'date'
 require 'active_model'
@@ -19,6 +22,7 @@ require_relative 'model'
 # providing our own encoding for sending to Parse.
 module Parse
   class Date < ::DateTime
+    ATTRIBUTES = {  __type: :string, iso: :string }.freeze
     include ::ActiveModel::Model
     include ::ActiveModel::Serializers::JSON
     def self.parse_class; Parse::Model::TYPE_DATE; end;
@@ -27,7 +31,7 @@ module Parse
 
     # called when encoding to JSON.
     def attributes
-      {  __type: :string, iso: :string }.freeze
+      ATTRIBUTES
     end
 
     # this method is defined because it is used by JSON encoding

data/lib/parse/model/file.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/core_ext/object'
 require_relative "model"
@@ -12,14 +15,14 @@ require 'open-uri'
 module Parse
 
     class File < Model
-
+      ATTRIBUTES = {  __type: :string, name: :string, url: :string }.freeze
       attr_accessor :name, :url
       attr_accessor :contents, :mime_type
       def self.parse_class; TYPE_FILE; end;
       def parse_class; self.class.parse_class; end;
       alias_method :__type, :parse_class
-      FIELD_NAME = "name".freeze
-      FIELD_URL = "url".freeze
+      FIELD_NAME = "name"
+      FIELD_URL = "url"
       class << self
         attr_accessor :default_mime_type
 
@@ -36,7 +39,7 @@ module Parse
       def initialize(name, contents = nil, mime_type = nil)
         mime_type ||= Parse::File.default_mime_type
 
-        if name.is_a?(String) && name.start_with?("http".freeze) #could be url string
+        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
@@ -54,7 +57,7 @@ module Parse
           @contents = contents
         end
         if @name.blank?
-          raise "Invalid Parse::File initialization with name '#{@name}'"
+          raise ArgumentError, "Invalid Parse::File initialization with name '#{@name}'"
         end
 
         @mime_type ||= mime_type
@@ -72,11 +75,11 @@ module Parse
       # A File object is considered saved if the basename of the URL and the name parameters are equal and
       # the name of the file begins with 'tfss'
       def saved?
-        @url.present? && @name.present? && @name == File.basename(@url) && @name.start_with?("tfss".freeze)
+        @url.present? && @name.present? && @name == File.basename(@url) && @name.start_with?("tfss")
       end
 
       def attributes
-        {  __type: :string, name: :string, url: :string }.freeze
+        ATTRIBUTES
       end
 
       def ==(u)
@@ -135,8 +138,8 @@ class Hash
   def parse_file?
     url = self[Parse::File::FIELD_URL]
     name = self[Parse::File::FIELD_NAME]
-    (count == 2 || self["__type".freeze] == Parse::File.parse_class) &&
+    (count == 2 || self["__type"] == Parse::File.parse_class) &&
     url.present? && name.present? &&
-    name == ::File.basename(url) && name.start_with?("tfss".freeze)
+    name == ::File.basename(url) && name.start_with?("tfss")
   end
 end

data/lib/parse/model/geopoint.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+# frozen_string_literal: true
 
 require_relative "model"
 
@@ -6,10 +8,10 @@ module Parse
   # A basic geo location object in Parse. It represents a location on a map through a
   # latitude and longitue.
   class GeoPoint < Model
-
+    ATTRIBUTES = {  __type: :string, latitude: :float, longitude: :float }.freeze
     attr_accessor :latitude, :longitude
-    FIELD_LAT = "latitude".freeze
-    FIELD_LNG = "longitude".freeze
+    FIELD_LAT = "latitude"
+    FIELD_LNG = "longitude"
     # Latitude should not be -90.0 or 90.0.
     # Longitude should not be -180.0 or 180.0.
     LAT_MIN = -90.0
@@ -58,7 +60,7 @@ module Parse
     end
 
     def attributes
-      {  __type: :string, latitude: :float, longitude: :float }.freeze
+      ATTRIBUTES
     end
 
     def max_miles(m)

data/lib/parse/model/model.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -20,20 +23,24 @@ module Parse
     extend  ::ActiveModel::Naming # provides the methods for getting class names from Model classes
 
     # General Parse constants
+    ID = "id".freeze
+    OBJECT_ID   = 'objectId'.freeze
     KEY_CLASS_NAME  = 'className'.freeze
     KEY_OBJECT_ID   = 'objectId'.freeze
-    KEY_CREATED_AT  = 'createdAt'.freeze
-    KEY_UPDATED_AT  = 'updatedAt'.freeze
-    CLASS_USER      = '_User'.freeze
-    CLASS_INSTALLATION = '_Installation'.freeze
-    TYPE_FILE = "File".freeze
-    TYPE_GEOPOINT = "GeoPoint".freeze
-    TYPE_OBJECT = "Object".freeze
-    TYPE_DATE = "Date".freeze
-    TYPE_BYTES = "Bytes".freeze
-    TYPE_POINTER = "Pointer".freeze
-    TYPE_RELATION = "Relation".freeze
-    TYPE_FIELD = "__type".freeze
+    KEY_CREATED_AT  = 'createdAt'
+    KEY_UPDATED_AT  = 'updatedAt'
+    CLASS_USER      = '_User'
+    CLASS_INSTALLATION = '_Installation'
+    CLASS_SESSION = '_Session'
+    CLASS_ROLE = '_Role'
+    TYPE_FILE = 'File'
+    TYPE_GEOPOINT = 'GeoPoint'
+    TYPE_OBJECT = 'Object'
+    TYPE_DATE = 'Date'
+    TYPE_BYTES = 'Bytes'
+    TYPE_POINTER = 'Pointer'
+    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
@@ -63,12 +70,12 @@ module Parse
     # class method to find the responsible ruby Parse::Object subclass that handles
     # the provided parse class (str).
     def self.find_class(str)
-      return Parse::File if str == TYPE_FILE.freeze
-      return Parse::GeoPoint if str == TYPE_GEOPOINT.freeze
-      return Parse::Date if str == TYPE_DATE.freeze
-      return Parse::Bytes if str == TYPE_BYTES.freeze
-      # return Parse::User if str == "User".freeze
-      # return Parse::Installation if str == "Installation".freeze
+      return Parse::File if str == TYPE_FILE
+      return Parse::GeoPoint if str == TYPE_GEOPOINT
+      return Parse::Date if str == TYPE_DATE
+      return Parse::Bytes if str == TYPE_BYTES
+      # return Parse::User if str == "User"
+      # return Parse::Installation if str == "Installation"
 
       str = str.to_s
       # Basically go through all Parse::Object subclasses and see who is has a parse_class
@@ -87,9 +94,10 @@ end
 class String
   # short helper method to provide lower-first-camelcase
   def columnize
-     return "objectId".freeze if self == "id".freeze
-     camelize(:lower)
-   end;
+     return Parse::Model::OBJECT_ID if self == Parse::Model::ID
+     u = '_'.freeze
+     (first == u ? sub(u,'') : self).camelize(:lower)
+  end
 
   #users for properties: ex. :users -> "_User" or :songs -> Song
   def to_parse_class(singularize: false)