parse-stack 1.0.0

data/lib/parse/client/caching.rb

@@ -0,0 +1,103 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'moneta'
+require_relative 'protocol'
+# This is a caching middleware for Parse queries using Moneta.
+module Parse
+  module Middleware
+    class Caching < Faraday::Middleware
+      include Parse::Protocol
+      # Internal: List of status codes that can be cached:
+         # * 200 - 'OK'
+         # * 203 - 'Non-Authoritative Information'
+         # * 300 - 'Multiple Choices'
+         # * 301 - 'Moved Permanently'
+         # * 302 - 'Found'
+         # * 404 - 'Not Found'
+         # * 410 - 'Gone'
+      CACHEABLE_HTTP_CODES = [200, 203, 300, 301, 302, 404, 410].freeze
+
+      class << self
+        attr_accessor :enabled, :logging
+
+        def enabled
+           @enabled = true if @enabled.nil?
+           @enabled
+        end
+
+        def caching?
+          @enabled
+        end
+
+      end
+
+      attr_accessor :store, :expires
+
+      def initialize(app, store, opts = {})
+        super(app)
+        @store = store
+        @opts = {expires: 0}
+        @opts.merge!(opts) if opts.is_a?(Hash)
+        @expires = @opts[:expires]
+
+        unless @store.is_a?(Moneta::Transformer)
+          raise "Parse::Middleware::Caching store object must a Moneta key/value store."
+        end
+
+      end
+
+      def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
+
+        #unless caching is enabled and we have a valid cache duration
+        # then just work as a passthrough
+        return @app.call(env) unless @store.present? && @expires > 0 && self.class.enabled
+
+        cache_enabled = true
+
+        url = env.url
+        method = env.method
+        begin
+          if method == :get && url.present? && @store.key?(url)
+            puts("[Parse::Cache] >>> #{url}") if self.class.logging.present?
+            response = Faraday::Response.new
+            body = @store[url].body
+            if body.present?
+              response.finish({status: 200, response_headers: {}, body: body })
+              return response
+            else
+              @store.delete url
+            end
+          elsif url.present?
+            #non GET requets should clear the cache for that same resource path.
+            #ex. a POST to /1/classes/Artist/<objectId> should delete the cache for a GET
+            # request for the same '/1/classes/Artist/<objectId>' where objectId are equivalent
+            @store.delete url
+          end
+        rescue Exception => e
+          # if the cache store fails to connect, catch the exception but proceed
+          # with the regular request, but turn off caching for this request. It is possible
+          # that the cache connection resumes at a later point, so this is temporary.
+          cache_enabled = false
+          warn "[Parse::Cache Error] Cache store connection failed. #{e}"
+        end
+
+
+        @app.call(env).on_complete do |response_env|
+          # Only cache GET requests with valid HTTP status codes.
+          if cache_enabled && method == :get && CACHEABLE_HTTP_CODES.include?(response_env.status) && response_env.present?
+            @store.store(url, response_env, expires: @expires) # ||= response_env.body
+          end
+          # do something with the response
+          # response_env[:response_headers].merge!(...)
+        end
+      end
+
+    end #Caching
+
+  end #Middleware
+
+end

data/lib/parse/client/protocol.rb

@@ -0,0 +1,15 @@
+
+# A module to contain all the main constants.
+module Parse
+
+  module Protocol
+      HOST          = "api.parse.com".freeze
+      APP_ID        = 'X-Parse-Application-Id'.freeze
+      API_KEY       = 'X-Parse-REST-API-Key'.freeze
+      MASTER_KEY    = 'X-Parse-Master-Key'.freeze
+      SESSION_TOKEN = 'X-Parse-Session-Token'.freeze
+      CONTENT_TYPE = "Content-Type".freeze
+      CONTENT_TYPE_FORMAT = "application/json; charset=utf-8".freeze
+  end
+
+end

data/lib/parse/client/request.rb

@@ -0,0 +1,43 @@
+
+require 'active_support/json'
+
+module Parse
+ #This class is mainly to create a potential request - mainly for the batching API.
+
+  class Request
+      attr_accessor :method, :path, :body, :headers
+      attr_accessor :tag #for tracking in bulk requests
+      def initialize(method, uri, body: nil, headers: nil)
+        @tag = 0
+        method = method.downcase.to_sym
+        raise "Invalid Method type #{method} " unless [:get,:put,:delete,:post].include?(method)
+        self.method = method.downcase
+        self.path = uri
+        self.body = body
+        self.headers = headers || {}
+      end
+
+
+      def query
+        body if @method == :get
+      end
+
+      def as_json
+        signature.as_json
+      end
+
+      def ==(r)
+        return false unless r.is_a?(Request)
+        @method == r.method && @path == r.uri && @body == r.body && @headers == r.headers
+      end
+
+      # signature provies a way for us to compare different requests objects.
+      # Two requests objects are the same if they have the same signature.
+      # This also helps us serialize a request data into a hash.
+      def signature
+        {method: @method.upcase, path: @path, body: @body}
+      end
+
+  end
+
+end

data/lib/parse/client/response.rb

@@ -0,0 +1,116 @@
+require 'active_support/json'
+# This is the model that represents a response from Parse. A Response can also
+# be a set of responses (from a Batch response).
+module Parse
+
+  class Response
+    include Enumerable
+
+    ERROR_INTERNAL = 1
+    ERROR_TIMEOUT = 124
+    ERROR_EXCEEDED_BURST_LIMIT = 155
+    ERROR_OBJECT_NOT_FOUND_FOR_GET = 101
+
+    ERROR = "error".freeze
+    CODE = "code".freeze
+    RESULTS = "results".freeze
+    COUNT = "count".freeze
+    # A response has a result or (a code and an error)
+    attr_accessor :parse_class, :code, :error, :result
+    # You can query Parse for counting objects, which may not actually have
+    # results.
+    attr_reader :count
+
+    def initialize(res = {})
+      @count = 0
+      @batch_response = false # by default, not a batch response
+      @result = nil
+      # If a string is used for initializing, treat it as JSON
+      res = JSON.parse(res) if res.is_a?(String)
+      # If it is a hash (or parsed JSON), then parse the result.
+      parse_result(res) if res.is_a?(Hash)
+      # if the result is an Array, then most likely it is a set of responses
+      # from using a Batch API.
+      if res.is_a?(Array)
+        @batch_response = true
+        @result = res || []
+        @count = @result.count
+      end
+      #if none match, set pure result
+      @result = res if @result.nil?
+
+    end
+
+    def batch?
+      @batch_response
+    end
+    #batch response
+    #
+    # [
+    #   {
+    #     "success":{"createdAt":"2015-11-22T19:04:16.104Z","objectId":"s4tEzOVQFc"}
+    #   },
+    #  {
+    #  "error":{"code":101,"error":"object not found for update"}
+    #  }
+    # ]
+    # If it is a batch respnose, we'll create an array of Response objects for each
+    # of the ones in the batch.
+    def batch_responses
+
+      return [@result] unless @batch_response
+      # if batch response, generate array based on the response hash.
+      @result.map do |r|
+        next r unless r.is_a?(Hash)
+        hash = r["success".freeze] || r["error".freeze]
+        Parse::Response.new hash
+      end
+    end
+
+    # This method takes the result hash and determines if it is a regular
+    # parse query result, object result or a count result. The response should
+    # be a hash either containing the result data or the error.
+
+    def parse_result(h)
+      @result = {}
+      return unless h.is_a?(Hash)
+      @code = h[CODE]
+      @error = h[ERROR]
+      if h[RESULTS].is_a?(Array)
+        @result = h[RESULTS]
+        @count = h[COUNT] || @result.count
+      else
+        @result = h
+        @count = 1
+      end
+
+    end
+
+    # determines if the response is successful.
+    def success?
+      @code.nil? && @error.nil?
+    end
+
+    def error?
+      ! success?
+    end
+
+    # returns the result data from the response. Always returns an array.
+    def results
+      return [] if @result.nil?
+      @result.is_a?(Array) ? @result : [@result]
+    end
+
+    # returns the first thing in the array.
+    def first
+      @result.is_a?(Array) ? @result.first : @result
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      results.each(&Proc.new)
+      self
+    end
+
+  end
+end

data/lib/parse/model/acl.rb

@@ -0,0 +1,182 @@
+
+# An ACL represents the Parse Permissions object used for each record. In Parse,
+# it is composed a hash-like object that represent Parse::User objectIds and/or Parse::Role
+# names. For each entity (ex. User/Role/Public), you can define read/write priviledges on a particular record.
+# The way they are implemented here is through an internal hash, with each value being of type Parse::ACL::Permission object.
+# A Permission object contains two accessors - read and write - and knows how to generate its JSON
+# structure. In Parse, if you want to give priviledges for an action (ex. read/write), then you set it to true.
+# If you want to deny a priviledge, then you set it to false. One important thing is that when
+# being converted to the Parse format, removing a priviledge means omiting it from the final
+# JSON structure.
+# The class below also implements a type of delegate pattern in order to inform the main Parse::Object
+# of dirty tracking.
+module Parse
+
+  class ACL
+    # The internal permissions hash and delegate accessors
+    attr_accessor :permissions, :delegate
+    include ::ActiveModel::Model
+    include ::ActiveModel::Serializers::JSON
+    PUBLIC = "*".freeze # Public priviledges are '*' key in Parse
+
+    # provide a set of acls and the delegate (for dirty tracking)
+    # { '*' => { "read": true, "write": true } }
+    def initialize(acls = {}, owner: nil)
+      everyone(true, true) # sets Public read/write
+      @delegate = owner
+      if acls.is_a?(Hash)
+        self.attributes = acls
+      end
+
+    end
+
+    # helper
+    def self.permission(read, write = nil)
+        ACL::Permission.new(read, write)
+    end
+
+    def permissions
+      @permissions ||= {}
+    end
+
+    def ==(other_acl)
+      return false unless other_acl.is_a?(self.class)
+      return false if permissions.keys != other_acl.permissions.keys
+      permissions.keys.all? { |per| permissions[per] == other_acl.permissions[per] }
+    end
+
+    # method to set the Public read/write priviledges ('*'). Alias is 'world'
+    def everyone(read, write)
+      apply(PUBLIC, read, write)
+      permissions[PUBLIC]
+    end
+    alias_method :world, :everyone
+
+    # dirty tracking. We will tell the delegate through the acl_will_change!
+    # method
+    def will_change!
+      @delegate.acl_will_change! if @delegate.respond_to?(:acl_will_change!)
+    end
+
+    # removes a permission
+    def delete(id)
+      id = id.id if id.is_a?(Parse::Pointer)
+      if id.present? && permissions.has_key?(id)
+        will_change!
+        permissions.delete(id)
+      end
+    end
+
+    # apply a new permission with a given objectId (or tag)
+    def apply(id, read = nil, write = nil)
+      id = id.id if id.is_a?(Parse::Pointer)
+      return unless id.present?
+      # create a new Permissions
+      permission = ACL.permission(read, write)
+      # if the input is already an Permission object, then set it directly
+      permission = read if read.is_a?(Parse::ACL::Permission)
+
+      if permission.is_a?(ACL::Permission)
+        if permissions[id.to_s] != permission
+          will_change! # dirty track
+          permissions[id.to_s] = permission
+        end
+      end
+
+      permissions
+    end; alias_method :add, :apply
+
+    # You can apply a Role as a permission ex. "Admin". This will add the
+    # ACL of 'role:Admin' as the key in the permissions hash.
+    def apply_role(name, read = nil, write = nil)
+      apply("role:#{name}", read, write)
+    end; alias_method :add_role, :apply_role
+    # Used for object conversion when formatting the input/output value in Parse::Object properties
+    def self.typecast(value, delegate = nil)
+      ACL.new(value, owner: delegate)
+    end
+
+    # Used for JSON serialization. Only if an attribute is non-nil, do we allow it
+    # in the Permissions hash, since omission means denial of priviledge. If the
+    # permission value has neither read or write, then the entire record has been denied
+    # all priviledges
+    def attributes
+      permissions.select {|k,v| v.present? }.as_json
+    end
+
+    def attributes=(h)
+      return unless h.is_a?(Hash)
+      will_change!
+      @permissions ||= {}
+      h.each do |k,v|
+        apply(k,v)
+      end
+    end
+
+    def inspect
+      "ACL(#{as_json.inspect})"
+    end
+
+    def as_json(*args)
+      permissions.select {|k,v| v.present? }.as_json
+    end
+
+    def present?
+      permissions.values.any? { |v| v.present? }
+    end
+
+    # Permission class
+    class Permission
+      include ::ActiveModel::Model
+      include ::ActiveModel::Serializers::JSON
+      # we don't support changing priviledges directly since it would become
+      # crazy to track for dirty tracking
+      attr_reader :read, :write
+
+      # initialize with read and write priviledge
+      def initialize(r = nil, w = nil)
+        if r.is_a?(Hash)
+          r.symbolize_keys!
+          # @read = true if r[:read].nil? || r[:read].present?
+          # @write = true if r[:write].nil? || r[:write].present?
+          @read = r[:read].present?
+          @write = r[:write].present?
+        else
+          # @read = true if r.nil? || r.present?
+          # @write = true if w.nil? || w.present?
+          @read = r.present?
+          @write = w.present?
+        end
+      end
+
+      def ==(per)
+        return false unless per.is_a?(self.class)
+        @read == per.read && @write == per.write
+      end
+
+      # omission or false on a priviledge means don't include it
+      def as_json(*args)
+        h = {}
+        h[:read] = true if @read
+        h[:write] = true if @write
+        h.empty? ? nil : h.as_json
+      end
+
+      def attributes
+        h = {}
+        h.merge!(read: :boolean) if @read
+        h.merge!(write: :boolean) if @write
+        h
+      end
+
+      def inspect
+        as_json.inspect
+      end
+
+      def present?
+        @read.present? || @write.present?
+      end
+
+    end
+  end
+end