parse-stack 1.0.0

data/lib/parse/model/object.rb

@@ -0,0 +1,347 @@
+require 'active_model'
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext/object'
+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 'core/actions'
+require_relative 'core/querying'
+require_relative "core/schema"
+require_relative "core/properties"
+require_relative "associations/belongs_to"
+require_relative "associations/has_many"
+
+
+module Parse
+=begin
+  This is the core class for all app specific Parse table subclasses. This class
+  in herits from Parse::Pointer since an Object is a Parse::Pointer with additional fields,
+  at a minimum, created_at, updated_at and ACLs.
+  This class also handles all the relational types of associations in a Parse application and
+  handles the main CRUD operations.
+
+  Most Pointers and Object subclasses are treated the same. Therefore, defining a class Artist < Parse::Object
+  that only has `id` set, will be treated as a pointer. Therefore a Parse::Object can be in a "pointer" state
+  based on the data that it contains. Becasue of this, it is possible to take a Artist instance
+  (in this example), that is in a pointer state, and fetch the rest of the data for that particular
+  record without having to create a new object. Doing so would now mark it as not being a pointer anymore.
+  This is important to the understanding on how relations and properties are handled.
+
+  The implementation of this class is large and has been broken up into several modules.
+
+  Properties:
+  All columns in a Parse object are considered a type of property (ex. string, numbers, arrays, etc)
+  except in two cases - Pointers and Relations. For the list of basic supported data types, please see the
+  Properties module variable Parse::Properties::TYPES . When defining a property,
+  dynamic methods are created that take advantage of all the ActiveModel
+  plugins (dirty tracking, callbacks, json, etc).
+
+  Associations (BelongsTo):
+  This module adds support for creating an association between one object to another using a
+  Parse object pointer. By defining a belongs_to relationship in a specific class, it implies
+  that the remote Parse table contains a local column, which has a pointer, referring to another
+  Parse table.
+
+  Associations (HasMany):
+  In Parse there are two ways to deal with one-to-many and many-to-many relationships
+  One is through an array of pointers (which is recommended to be less than 100) and
+  through an intermediary table called a Relation (or a Join table in other languages.)
+  The way Parse::Objects treat these associations different from defining a :property of array type, is
+  by making sure items in the array as of a particular class cast type.
+
+  Querying:
+  The querying module provides all the general methods to be able to find and query a specific
+  Parse table.
+
+  Fetching:
+  The fetching modules supports fetching data from Parse (depending on the state of the object),
+  and providing some autofetching features when traversing relational objects and properties.
+
+  Schema:
+  The schema module provides methods to modify the Parse table remotely to either add or create
+  any locally define properties in ruby and have those be reflected in the Parse application.
+
+=end
+
+  def self.registered_classes
+      Parse::Object.descendants.map { |m| m.parse_class }.uniq
+  end
+
+  class Object < Pointer
+    include Properties
+    include Associations::BelongsTo
+    include Associations::HasMany
+    include Querying
+    include Fetching
+    include Actions
+    include Schema
+
+    def __type; Parse::Model::TYPE_OBJECT; end;
+    # These define callbacks
+    define_model_callbacks :save, :destroy
+    #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.
+    attr_accessor :created_at, :updated_at, :acl
+
+    # All Parse Objects have a class-level and instance level `parse_class` method, in which the
+    # instance method is a convenience one for the class one. The default value for the parse_class is
+    # the name of the ruby class name. Therefore if you have an 'Artist' ruby class, then by default we will assume
+    # the remote Parse table is named 'Artist'. You may override this behavior by utilizing the `parse_class(<className>)` method
+    # to set it to something different.
+    class << self
+      attr_accessor :disable_serialized_string_date
+      attr_accessor :parse_class, :acl
+      def parse_class(c = nil)
+        @parse_class ||= model_name.name
+        unless c.nil?
+          @parse_class = c.to_s
+        end
+        @parse_class
+      end
+       #this provides basic ACLs for the specific class. Each class can change the default
+       # ACLs set on their instance objects.
+      def acl(acls = {}, owner: nil)
+        acls = {"*" => {read: true, write: false} }.merge( acls ).symbolize_keys
+        @acl ||= Parse::ACL.new(acls, owner: owner)
+      end
+
+    end
+
+    def parse_class
+      self.class.parse_class
+    end
+    alias_method :className, :parse_class
+
+    def as_json(*args)
+      pointer? ? pointer : super(*args)
+    end
+
+    def initialize(opts = {})
+      if opts.is_a?(String) #then it's the objectId
+        @id = opts.to_s
+      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]
+        apply_attributes!(opts, dirty_track: !dirty_track)
+      end
+
+      if self.acl.blank?
+        self.acl = self.class.acl({}, owner: self) || Parse::ACL.new(owner: self)
+      end
+      clear_changes! if @id.present? #then it was an import
+      # do not call super since it is Pointer subclass
+    end
+
+    def self.pointer(id)
+      return nil if id.nil?
+      Parse::Pointer.new self.parse_class, id
+    end
+
+    # determines if this object has been saved to parse. If an object has
+    # pending changes, then it is considered to not yet be persisted. This is true of
+    # new objects as well.
+    def persisted?
+      changed? == false && !(@id.nil? || @created_at.nil? || @updated_at.nil? || @acl.nil?)
+    end
+
+    # force reload and replace any local fields with data from the persistent store
+    def reload!
+    # get the values from the persistence layer
+      fetch!
+      clear_changes!
+    end
+
+    # clears all dirty tracking information
+    def clear_changes!
+      clear_changes_information
+    end
+
+    # an object is considered new if it has no id
+    def new?
+      @id.blank?
+    end
+
+    # Existed returns true/false depending whether the object
+    # had existed before its last save operation.
+    def existed?
+      if @id.blank? || @created_at.blank? || @updated_at.blank?
+        return false
+      end
+      created_at != updated_at
+    end
+
+    # returns a hash of all the changes that have been made to the object. By default
+    # changes to the Parse::Properties::BASE_KEYS are ignored unless you pass true as
+    # an argument.
+    def updates(include_all = false)
+      h = {}
+      changed.each do |key|
+        next if include_all == false && Parse::Properties::BASE_KEYS.include?(key.to_sym)
+        # lookup the remote Parse field name incase it is different from the local attribute name
+        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].pointer if h[remote_field].respond_to?(:pointer)
+      end
+      h
+    end
+
+    # restores the previous state of the object (discards changes, but not from the persistent store)
+    def rollback!
+      restore_attributes
+    end
+
+    # Returns a twin copy of the object without the objectId
+    def twin
+      h = self.as_json
+      h.delete("objectId")
+      h.delete(:objectId)
+      h.delete(:id)
+      self.class.new h
+    end
+
+    def clear_attribute_change!(atts)
+      clear_attribute_changes(atts)
+    end
+
+    # Method used for decoding JSON objects into their corresponding Object subclasses.
+    # The first parameter is a hash containing the object data and the second parameter is the
+    # name of the table / class if it is known. If it is not known, we we try and determine it
+    # by checking the "className" or :className entries in the hash. If an Parse class object hash
+    # is encoutered for which we don't have a corresponding Parse::Object subclass for, a Parse::Pointer
+    # will be returned instead.
+    def self.build(json, table = nil)
+      className = table
+      className ||= (json["className"] || 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
+      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
+      klass = Parse::Model.find_class className
+      o = nil
+      if klass.present?
+        o = klass.new
+        # when creating objects from Parse JSON data, don't use dirty tracking since
+        # we are considering these objects as "pristine"
+        o.apply_attributes!(json, dirty_track: false)
+        o.clear_changes!
+      else
+        o = Parse::Pointer.new className, (json["objectId"] || json[:objectId])
+      end
+      return o
+    # rescue NameError => e
+    #   puts "Parse::Object.build constant class error: #{e}"
+    # rescue Exception => e
+    #   puts "Parse::Object.build error: #{e}"
+    end
+
+    # Set default base properties of any Parse::Object
+    property :id, field: :objectId
+    property :created_at, :date
+    property :updated_at, :date
+    property :acl, :acl, field: :ACL
+
+    # TODO: Hack since Parse createdAt and updatedAt dates have to be returned as strings
+    # in UTC Zulu iso 8601 with 3 millisecond format.
+    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
+
+    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
+
+
+
+  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
+  end
+
+  class Installation < Parse::Object
+    parse_class "_Installation".freeze
+    property :channels, :array
+    property :gcm_sender_id, :string, field: :GCMSenderId
+    property :badge, :integer
+    property :installation_id
+    property :device_token
+    property :device_type
+    property :locale_identifier
+    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)
+    map do |m|
+      next m if m.is_a?(Parse::Pointer)
+      if m.is_a?(Hash) && (m["className"] || m[:className] || table)
+        next Parse::Object.build m, (m["className"] || m[:className] || table)
+      end
+      nil
+    end.compact
+  end
+
+  def parse_ids
+    parse_objects.map { |d| d.id }
+  end
+
+end

data/lib/parse/model/pointer.rb

@@ -0,0 +1,106 @@
+require 'active_model'
+require 'active_support/inflector'
+require 'active_model_serializers'
+require_relative 'model'
+module Parse
+
+    # A Parse Pointer is the superclass of Parse::Object types. A pointer can be considered
+    # a type of Parse::Object in which only the class name and id is known. In most cases,
+    # you may not see Parse::Pointer object be used if you have defined all your Parse::Object subclasses
+    # 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
+
+      attr_accessor :parse_class, :id
+
+      def __type; "Pointer".freeze; 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
+      alias_method :objectId, :id
+
+      def initialize(table, oid)
+        @parse_class = table.to_s
+        @id = oid.to_s
+      end
+
+      def parse_class
+        @parse_class
+      end
+
+      def attributes
+        { __type: :string, className: :string, objectId: :string}.freeze
+      end
+
+
+      def json_hash
+        JSON.parse to_json
+      end
+
+      # Create a new pointer with the current class name and id. While this may not make sense
+      # for a pointer instance, Parse::Object subclasses use this inherited method to turn themselves into
+      # pointer objects.
+      def pointer
+        Pointer.new parse_class, @id
+      end
+
+      # determines if an object (or subclass) is a pointer type. A pointer is determined
+      # if we have a parse class and an id, but no timestamps, then we probably are a pointer.
+      def pointer?
+        present? && @created_at.blank? && @updated_at.blank?
+      end
+
+      # boolean whether this object has data and is not a pointer. Because of some autofetching
+      # mechanisms, this is useful to know whether the object already has data without actually causing
+      # a fetch of the data.
+      def fetched?
+        present? && pointer? == false
+      end
+
+      # This method is a general implementation that gets overriden by Parse::Object subclass.
+      # Given the class name and the id, we will go to Parse and fetch the actual record, returning the
+      # JSON object. Note that the subclass implementation does something a bit different.
+      def fetch
+        response = client.fetch_object(parse_class, id)
+        return nil if response.error?
+        response.result
+      end
+
+      def ==(o)
+        return false unless o.is_a?(Pointer)
+        #only equal if the Parse class and object ID are the same.
+        self.parse_class == o.parse_class && id == o.id
+      end
+      alias_method :eql?, :==
+
+      def present?
+        parse_class.present? && @id.present?
+      end
+    end
+
+end
+
+# extensions
+class Array
+  def objectIds
+    map { |m| m.is_?(Parse::Pointer) ? m.id : nil }.reject { |r| r.nil? }
+  end
+
+  def valid_parse_objects
+    select { |s| s.is_a?(Parse::Pointer) }
+  end
+
+  def parse_pointers(table = nil)
+    self.map do |m|
+      #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[:className] && m[:objectId]
+        next Parse::Pointer.new m[:className], m[:objectId]
+      end
+      nil
+    end.compact
+  end
+end