parse-stack 1.0.0

data/Rakefile

@@ -0,0 +1,12 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib/parse/stack'
+  t.test_files = FileList['test/lib/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "parse/stack"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+ENV["PARSE_APP_ID"] ||= "vesNFfsUUjbiWtbFljEV41RwXVJ2vw7HPFwLdisL".freeze
+ENV["PARSE_API_KEY"] ||=  "FndxgK7oGnjsRznFbMs8r7TG5WHwFSOmgWQr6Qui".freeze
+ENV["PARSE_MASTER_KEY"] ||= "oZs3AlBMKg6JDe82XVm7NJpO5GmvibiXbpMtwEHi".freeze
+
+require "pry"
+Pry.start
+
+#
+# require "irb"
+# IRB.start
+#Rack::Server.start :app => HelloWorldApp

data/bin/server

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "parse/stack"
+
+require "rack"
+require "rack/server"
+require "puma"
+Rack::Handler::WEBrick = Rack::Handler.get(:puma)
+Rack::Server.start :app => Parse::Webhooks

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/parse/api/all.rb

@@ -0,0 +1,13 @@
+require_relative '../client'
+require_relative "analytics"
+require_relative "apps"
+require_relative "batch"
+require_relative "config"
+require_relative "files"
+require_relative "cloud_functions"
+require_relative "hooks"
+require_relative "objects"
+require_relative "push"
+require_relative "schemas"
+require_relative "sessions"
+require_relative "users"

data/lib/parse/api/analytics.rb

@@ -0,0 +1,16 @@
+
+
+
+module Parse
+
+  module API
+    module Analytics
+
+      def send_analytics(event_name, data = {})
+        request :post, "/1/events/#{event_name}", body: data
+      end
+
+    end
+  end
+
+end

data/lib/parse/api/apps.rb

@@ -0,0 +1,37 @@
+
+module Parse
+
+  module API
+
+    module Apps
+
+
+      def fetch_app_keys(appid, email, password)
+        headers = {}
+        headers.merge!( { 'X-Parse-Email' => email, 'X-Parse-Password' => password } )
+        request :get, "/1/apps/#{appid}", headers: headers
+      end
+
+      def fetch_apps(email, password)
+        headers = {}
+        headers.merge!( { 'X-Parse-Email' => email, 'X-Parse-Password' => password } )
+        request :get, "/1/apps", headers: headers
+      end
+
+      def create_app(opts, email, password)
+        headers = {}
+        headers.merge!( { 'X-Parse-Email' => email, 'X-Parse-Password' => password } )
+        request :post, "/1/apps", body: opts, headers: headers
+      end
+
+      def update_app(appid, opts, email, password)
+        headers = {}
+        headers.merge!( { 'X-Parse-Email' => email, 'X-Parse-Password' => password } )
+        request :put, "/1/apps/#{appid}", body: opts, headers: headers
+      end
+
+
+    end
+  end
+
+end

data/lib/parse/api/batch.rb

@@ -0,0 +1,148 @@
+require 'parallel'
+
+class Array
+
+  def destroy
+    batch = Parse::BatchOperation.new
+    each do |o|
+      next unless o.respond_to?(:destroy_request)
+      r = o.destroy_request
+      batch.add(r) unless r.nil?
+    end
+    batch.submit
+    batch
+  end
+
+  def save(merge: true, force: false)
+    batch = Parse::BatchOperation.new
+    objects = {}
+    each do |o|
+      next unless o.is_a?(Parse::Object)
+      objects[o.object_id] = o
+      batch.add o.change_requests(force)
+    end
+    if merge == false
+      batch.submit
+      return batch
+    end
+    #rebind updates
+    batch.submit do |request, response|
+      next unless request.tag.present? && response.present? && response.success?
+      o = objects[request.tag]
+      next unless o.is_a?(Parse::Object)
+      result = response.result
+      o.id = result['objectId'] if o.id.blank?
+      o.set_attributes!(result)
+      o.clear_changes!
+    end
+    batch
+  end #save!
+
+end
+
+module Parse
+
+  def self.batch(reqs = nil)
+    BatchOperation.new(reqs)
+  end
+
+  class BatchOperation
+    MAX_REQ_SEC = 30
+
+    attr_accessor :requests, :responses
+    include Enumerable
+
+    def client
+      @client ||= Parse::Client.session
+    end
+
+    def initialize(reqs = nil)
+      @requests = []
+      @responses = []
+      reqs = [reqs] unless reqs.is_a?(Enumerable)
+      reqs.each { |r| add(r) } if reqs.is_a?(Enumerable)
+    end
+
+    def add(req)
+      if req.respond_to?(:change_requests)
+        requests = req.change_requests.select { |r| r.is_a?(Parse::Request) }
+        @requests += requests
+      elsif req.is_a?(Array)
+        requests = req.select { |r| r.is_a?(Parse::Request) }
+        @requests += requests
+      elsif req.is_a?(BatchOperation)
+        @requests += req.requests if req.is_a?(BatchOperation)
+      else
+        @requests.push(req) if req.is_a?(Parse::Request)
+      end
+      @requests
+    end
+
+    # make Batching interoperable with object methods. This allows adding a batch
+    # to another batch.
+    def change_requests
+      @requests
+    end
+
+    def each
+      return enum_for(:each) unless block_given?
+      @requests.each(&Proc.new)
+      self
+    end
+
+    def as_json(*args)
+      { requests:  requests }.as_json
+    end
+
+    def count
+      @requests.count
+    end
+
+    def clear!
+      @requests.clear
+    end
+
+    def success?
+      return false if @responses.empty?
+      @responses.compact.all?(&:success?)
+    end
+
+    def error?
+      return false if @responses.empty?
+      ! success?
+    end
+    # Note that N requests sent in a batch will still count toward
+    # your request limit as N requests.
+    def submit(segment = 50)
+      @responses = []
+      @requests.uniq!(&:signature)
+      @requests.each_slice(segment) do |slice|
+        @responses << client.batch_request( BatchOperation.new(slice) )
+        #throttle
+        sleep (slice.count.to_f / MAX_REQ_SEC.to_f )
+      end
+      @responses.flatten!
+      #puts "Requests: #{@requests.count} == Response: #{@responses.count}"
+      @requests.zip(@responses).each(&Proc.new) if block_given?
+      @responses
+    end
+    alias_method :save, :submit
+
+
+  end
+
+  module API
+    #object fetch methods
+
+    module Batch
+      def batch_request(batch_operations)
+        unless batch_operations.is_a?(Parse::BatchOperation)
+          batch_operations = Parse::BatchOperation.new batch_operations
+        end
+        response = request(:post, "/1/batch", body: batch_operations.as_json)
+        response.success? && response.batch? ? response.batch_responses : response
+      end
+
+    end
+  end
+end

data/lib/parse/api/cloud_functions.rb

@@ -0,0 +1,18 @@
+
+module Parse
+
+  module API
+    module CloudFunctions
+
+      def call_function(name, body = {})
+        request :post, "/1/functions/#{name}", body: body
+      end
+
+      def trigger_job(name, body = {})
+        request :post, "/1/jobs/#{name}", body: body
+      end
+
+    end
+  end
+
+end

data/lib/parse/api/config.rb

@@ -0,0 +1,22 @@
+
+module Parse
+
+  module API
+    #object fetch methods
+    module Config
+      attr_accessor :config
+
+      def config
+        if @config.nil?
+          response = request :get, "/1/config".freeze
+          unless response.error?
+            @config = response.result["params"]
+          end
+        end
+        @config
+      end
+    end
+
+  end
+
+end

data/lib/parse/api/files.rb

@@ -0,0 +1,21 @@
+
+module Parse
+
+  module API
+    #object fetch methods
+    module Files
+
+      # /1/classes/<className>	POST	Creating Objects
+      def create_file(fileName, data = {}, content_type = nil)
+        headers = {}
+        headers.merge!( { Parse::Protocol::CONTENT_TYPE => content_type.to_s } ) if content_type.present?
+        response = request :post, "/1/files/#{fileName}", body: data, headers: headers
+        response.parse_class = "_File".freeze
+        response
+      end
+
+    end
+
+  end
+
+end

data/lib/parse/api/hooks.rb

@@ -0,0 +1,68 @@
+
+
+
+module Parse
+
+
+  module API
+    module Hooks
+      HOOKS_PREFIX = "/1/hooks/".freeze
+      TRIGGER_NAMES = [:beforeSave, :afterSave, :beforeDelete, :afterDelete].freeze
+      def _verify_trigger(triggerName)
+        triggerName = triggerName.to_s.camelize(:lower).to_sym
+        raise "Invalid trigger name #{triggerName}" unless TRIGGER_NAMES.include?(triggerName)
+        triggerName
+      end
+
+      def functions
+        request :get, "#{HOOKS_PREFIX}functions"
+      end
+
+      def fetch_function(functionName)
+        request :get, "#{HOOKS_PREFIX}functions/#{functionName}"
+      end
+
+      def create_function(functionName, url)
+        request :post, "#{HOOKS_PREFIX}functions", body: {functionName: functionName, url: url}
+      end
+
+      def update_function(functionName, url)
+        # interesting trick. If you add _method => "PUT" to the JSON body,
+        # and send it as a POST request and parse will accept it as a PUT.
+        # They must do this because it is easier to send POST with Ajax.
+        request :put, "#{HOOKS_PREFIX}functions/#{functionName}", body: { url: url }
+      end
+
+      def delete_function(functionName)
+        request :put, "#{HOOKS_PREFIX}functions/#{functionName}", body: { __op: "Delete" }
+      end
+
+      def triggers
+        request :get, "#{HOOKS_PREFIX}triggers"
+      end
+
+      def fetch_trigger(triggerName, className)
+        triggerName = _verify_trigger(triggerName)
+        request :get, "#{HOOKS_PREFIX}triggers/#{className}/#{triggerName}"
+      end
+
+      def create_trigger(triggerName, className, url)
+        triggerName = _verify_trigger(triggerName)
+        body = {className: className, triggerName: triggerName, url: url }
+        request :post, "#{HOOKS_PREFIX}triggers", body: body
+      end
+
+      def update_trigger(triggerName, className, url)
+        triggerName = _verify_trigger(triggerName)
+        request :put, "#{HOOKS_PREFIX}triggers/#{className}/#{triggerName}", body: { url: url }
+      end
+
+      def delete_trigger(triggerName, className)
+        triggerName = _verify_trigger(triggerName)
+        request :put, "#{HOOKS_PREFIX}triggers/#{className}/#{triggerName}", body: { __op: "Delete" }
+      end
+
+    end
+  end
+
+end

data/lib/parse/api/objects.rb

@@ -0,0 +1,77 @@
+
+module Parse
+
+  module API
+    #object fetch methods
+    module Objects
+
+      CLASS_PATH_PREFIX = "/1/classes/".freeze
+      PREFIX_MAP = { installation: "installations", _installation: "installations",
+        user: "users", _user: "users",
+        role: "roles", _role: "roles",
+        session: "sessions", _session: "sessions"
+      }.freeze
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def uri_path(className, id = nil)
+          if className.is_a?(Parse::Pointer)
+            id = className.id
+            className = className.parse_class
+          end
+          uri = "#{CLASS_PATH_PREFIX}#{className}"
+          class_prefix = className.downcase.to_sym
+          if PREFIX_MAP.has_key?(class_prefix)
+            uri = "/1/#{PREFIX_MAP[class_prefix]}/"
+          end
+          id.present? ? "#{uri}/#{id}" : uri
+        end
+
+      end
+
+      def uri_path(className, id = nil)
+        self.class.uri_path(className, id)
+      end
+
+      # /1/classes/<className>	POST	Creating Objects
+      def create_object(className, data = {})
+        response = request :post, uri_path(className) , body: data
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # /1/classes/<className>/<objectId>	DELETE	Deleting Objects
+      def delete_object(className, id)
+        response = request :delete, uri_path(className, id)
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # /1/classes/<className>/<objectId>	GET	Retrieving Objects
+      def fetch_object(className, id)
+        response = request :get, uri_path(className, id)
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # /1/classes/<className>	GET	Queries
+      def find_objects(className, query = {})
+        response = request :get, uri_path(className), query: query
+        response.parse_class = className if response.present?
+        response
+      end
+
+      # /1/classes/<className>/<objectId>	PUT	Updating Objects
+      def update_object(className, id, data = {})
+        response = request :put, uri_path(className,id) , body: data
+        response.parse_class = className if response.present?
+        response
+      end
+
+    end #Objects
+  end #API
+
+end