parse-stack 1.0.0

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

@@ -0,0 +1,92 @@
+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
+  module Schema
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      # returns the schema of the defined class in the Parse JSON format.
+      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".freeze
+          when :geopoint, :geo_point
+            result[:type] = "GeoPoint".freeze
+          when :pointer
+            result = { type: "Pointer".freeze, targetClass: references[k] }
+          when :acl
+            result[:type] = "ACL".freeze
+          else
+            result[:type] = v.to_s.camelize
+          end
+
+          sch[:fields][k] = result
+
+        end
+        #then add all the relational column attributes
+        relations.each do |k,v|
+          sch[:fields][k] = { type: "Relation".freeze, targetClass: relations[k] }
+        end
+        sch
+      end
+
+      # updates the remote schema using Parse::Client
+      def update_schema(schema_updates = nil)
+        schema_updates ||= schema
+        client.update_schema parse_class, schema_updates
+      end
+
+      def create_schema
+        client.create_schema parse_class, schema
+      end
+
+      # fetches the current schema of this table.
+      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. If the table doesn't exist, we create the schema
+      # from scratch - otherwise we fetched the current schema, calculate the differences
+      # and add the missing columns. WE DO NOT REMOVE any columns.
+      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 if current_schema[:fields].empty?
+          return update_schema( current_schema )
+        else
+          return create_schema
+        end
+        #fetch_schema.success? ? update_schema : create_schema
+      end
+    #def diff(h2);self.dup.delete_if { |k, v| h2[k] == v }.merge(h2.dup.delete_if { |k, v| self.has_key?(k) }); end;
+
+    end
+
+    def schema
+      self.class.schema
+    end
+
+  end
+end

data/lib/parse/model/date.rb

@@ -0,0 +1,50 @@
+require 'time'
+require 'active_model'
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext/object'
+require 'active_model_serializers'
+require_relative 'model'
+
+# Parse has a specific date format. One of the supported types is a date string in
+# ISO 8601 format (including milliseconds). The other is a hash object that contains
+# the similar information. When sending data to Parse, we need to use the hash object,
+# but when receiving data from Parse, we may either get the string version or the hash version.
+# To make things easier to use in ruby, th Parse::Date class inherits from the DateTime class.
+# This will allow us to use all the great ActiveSupport methods for date (ex. 3.days.ago) while
+# providing our own encoding for sending to Parse.
+module Parse
+  class Date < ::DateTime
+    include ::ActiveModel::Model
+    include ::ActiveModel::Serializers::JSON
+    def self.parse_class; Parse::Model::TYPE_DATE; end;
+    def parse_class; self.class.parse_class; end;
+    alias_method :__type, :parse_class
+
+    # called when encoding to JSON.
+    def attributes
+      {  __type: :string, iso: :string }.freeze
+    end
+
+    # this method is defined because it is used by JSON encoding
+    def iso
+      to_time.utc.iso8601(3) #include milliseconds
+    end
+
+  end
+end
+
+# To enable conversion of other date class objects, we will add a mixin to turn
+# Time and DateTime objects to Parse::Date objects
+class Time
+  def parse_date
+    Parse::Date.parse self.to_s
+  end
+
+end
+
+class DateTime
+  def parse_date
+    Parse::Date.parse self.to_s
+  end
+end

data/lib/parse/model/file.rb

@@ -0,0 +1,127 @@
+require 'active_support'
+require 'active_support/core_ext/object'
+require_relative "model"
+require 'open-uri'
+# Parse File objects are the only non Parse::Object subclass that has a save method.
+# In general, a Parse File needs content and a specific mime-type to be created. When it is saved, it
+# is sent to AWS/S3 to be saved (by Parse), and the result is a new URL pointing to that file.
+# This however is return as a type of File pointer object (hash format)
+# It only has two fields, the absolute URL of the file and the basename of the file.
+# The contents and mime_type are only present when creating a new file locally and are not
+# stored as part of the parse pointer.
+module Parse
+
+    class File < Model
+
+      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
+
+      # 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
+      def initialize(name, contents = nil, mime_type = "application/octet-stream".freeze)
+
+        if name.is_a?(String) && name.start_with?("http".freeze) #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?(File)
+          @name = name.name
+          @url = name.url
+        else
+          @name = name
+          @contents = contents
+        end
+        if @name.blank?
+          raise "Invalid Parse::File initialization with name '#{@name}'"
+        end
+
+        @mime_type ||= mime_type
+
+      end
+
+      # This creates a new Parse File Object with from a URL, saves it and returns it
+      def self.create(url)
+        url = url.url if url.is_a?(Parse::File)
+        file = self.new(url)
+        file.save
+        file
+      end
+
+      # 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)
+      end
+
+      def attributes
+        {  __type: :string, name: :string, url: :string }.freeze
+      end
+
+      def ==(u)
+        return false unless u.is_a?(self.class)
+        @url == u.url
+      end
+
+      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
+
+      # This is a proxy to the ruby ::File.basename method
+      def self.basename(file_name, suffix = nil)
+       if suffix.nil?
+         ::File.basename(file_name)
+       else
+         ::File.basename(file_name, suffix)
+       end
+      end
+
+      # save (create) the file if it has all the proper fields. You cannot update Parse Files.
+      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
+
+    end
+
+end
+
+
+class Hash
+  # {"name"=>"tfss-cat.jpg", "url"=>"http://files.parsetfss.com/bcf638bb-3db0-4042-b846-7840b345b0d6/tfss-cat.jpg"}
+  # This is a helper method that determines whether a hash looks like a Parse::File 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) &&
+    url.present? && name.present? &&
+    name == ::File.basename(url) && name.start_with?("tfss".freeze)
+  end
+end

data/lib/parse/model/geopoint.rb

@@ -0,0 +1,98 @@
+
+require_relative "model"
+
+module Parse
+
+  # A basic geo location object in Parse. It represents a location on a map through a
+  # latitude and longitue.
+  class GeoPoint < Model
+
+    attr_accessor :latitude, :longitude
+    FIELD_LAT = "latitude".freeze
+    FIELD_LNG = "longitude".freeze
+    alias_method :lat, :latitude
+    alias_method :lng, :longitude
+    def self.parse_class; TYPE_GEOPOINT; end;
+    def parse_class; self.class.parse_class; end;
+    alias_method :__type, :parse_class
+    # TODO: Validate the ranges of the geo point for valid lat and lng numbers.
+    # To create a GeoPoint, you can either pass a hash (ex. {latitude: 32, longitue: -117})
+    # or an array (ex. [32,-117]) as the first parameter.
+    # You may also pass a GeoPoint object or both a lat/lng pair (Ex. GeoPoint.new(32, -117) )
+    def initialize(latitude = nil, longitude = nil)
+      @latitude = @longitude = 0.0
+      if latitude.is_a?(Hash) || latitude.is_a?(Array)
+        self.attributes = latitude
+      elsif latitude.is_a?(Numeric) && longitude.is_a?(Numeric)
+        @latitude = latitude
+        @longitude = longitude
+      elsif latitude.is_a?(GeoPoint)
+        @latitude = latitude.latitude
+        @longitude = latitude.longitude
+      end
+    end
+
+    def attributes
+      {  __type: :string, latitude: :float, longitude: :float }.freeze
+    end
+
+    def max_miles(m)
+      [@latitude,@longitude,m]
+    end
+
+    # Setting lat and lng for an GeoPoint can be done using a hash with the attributes set
+    # or with an array of two items where the first is the lat and the second is the lng (ex. [32.22,-118.81])
+    def attributes=(h)
+      if h.is_a?(Hash)
+        h.symbolize_keys!
+        @latitude = h[:latitude].to_f || h[:lat].to_f || @latitude
+        @longitude = h[:longitude].to_f || h[:lng].to_f ||  @longitude
+      elsif h.is_a?(Array) && h.count == 2
+        @latitude = h.first.to_f
+        @longitude = h.last.to_f
+      end
+    end
+
+    def ==(g)
+      return false unless g.is_a?(GeoPoint)
+      @latitude == g.latitude && @longitude == g.longitude
+    end
+
+    def to_a
+      [@latitude,@longitude]
+    end
+
+    def inspect
+      "#<GeoPoint [#{@latitude},#{@longitude}]>"
+    end
+
+    # either GeoPoint, array or lat,lng
+    def distance_in_miles(geopoint,lng = nil)
+      distance_in_km(geopoint, lng) * 0.621371
+    end
+
+    def distance_in_km(geopoint,lng = nil)
+      unless geopoint.is_a?(Parse::GeoPoint)
+        geopoint = Parse::GeoPoint.new(geopoint, lng)
+      end
+      
+      dtor = Math::PI/180
+      r = 6378.14
+      r_lat1 = self.latitude * dtor
+      r_lng1 = self.longitude * dtor
+      r_lat2 = geopoint.latitude * dtor
+      r_lng2 = geopoint.longitude * dtor
+
+      delta_lat = r_lat1 - r_lat2
+      delta_lng = r_lng1 - r_lng2
+
+      a = (Math::sin(delta_lat/2.0) ** 2).to_f + (Math::cos(r_lat1) * Math::cos(r_lat2) * ( Math::sin(delta_lng/2.0) ** 2 ) )
+      c = 2.0 * Math::atan2(Math::sqrt(a), Math::sqrt(1.0-a))
+      d = r * c
+      d
+    end
+
+
+  end
+
+end

data/lib/parse/model/model.rb

@@ -0,0 +1,120 @@
+require 'active_model'
+require 'active_support'
+require 'active_support/inflector'
+require 'active_support/core_ext/object'
+require 'active_model_serializers'
+require_relative '../client'
+
+# This is the base model for all Parse object-type classes.
+
+module Parse
+
+  class Model
+
+    include Client::Connectable # allows easy default Parse::Client access
+    include ::ActiveModel::Model
+    include ::ActiveModel::Serializers::JSON # support for JSON Serializers
+    include ::ActiveModel::Dirty # adds dirty tracking support
+    include ::ActiveModel::Conversion
+    extend  ::ActiveModel::Callbacks # callback support on save, update, delete, etc.
+    extend  ::ActiveModel::Naming # provides the methods for getting class names from Model classes
+
+    # General Parse constants
+    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
+
+    # 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
+    # when a parse class name received, we go through all of our subclasses to determine
+    # which Parse::Object subclass is responsible for handling this Parse table class.
+    # we use @@model_cache to cache the results of the algorithm since we do this frequently
+    # when encoding and decoding objects.
+    @@model_cache = {}
+    def self.autosave_on_create
+      @@autosave_on_create ||= false
+    end
+    def self.autosave_on_create=(bool)
+      @@autosave_on_create = bool
+    end
+
+    class << self
+
+      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
+
+    end
+
+    # 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::User if str == "User".freeze
+      # return Parse::Installation if str == "Installation".freeze
+
+      str = str.to_s
+      # Basically go through all Parse::Object subclasses and see who is has a parse_class
+      # set to this string. We will cache the results for future use.
+      @@model_cache[str] ||= Parse::Object.descendants.find do |f|
+        f.parse_class == str || f.parse_class == "_#{str}"
+      end
+
+    end
+
+  end
+
+end
+
+
+class String
+  # short helper method to provide lower-first-camelcase
+  def columnize
+     return "objectId" if self == "id"
+     camelize(:lower)
+   end;
+
+  #users for properties: ex. :users -> "_User" or :songs -> Song
+  def to_parse_class
+    final_class = self.singularize.camelize
+    klass = Parse::Model.find_class(final_class) || Parse::Model.find_class(self)
+    #handles the case that a class has a custom parse table
+    final_class = klass.parse_class if klass.present?
+    final_class
+  end
+end
+
+class Symbol
+  # for compatibility
+  def columnize
+    to_s.columnize.to_sym
+  end
+
+  def singularize
+    to_s.singularize
+  end
+
+  def camelize
+    to_s.camelize
+  end
+
+  def to_parse_class
+    to_s.to_parse_class
+  end
+end