leancloud-ruby-client 0.1.0

data/lib/leancloud/model.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+module AV
+  class Model < AV::Object
+
+    def initialize(data=nil)
+      super(self.class.to_s,data)
+    end
+
+    def self.find(object_id)
+      self.new AV::Query.new(self.to_s).eq('objectId',object_id).first
+    end
+
+  end
+end

data/lib/leancloud/object.rb

@@ -0,0 +1,252 @@
+# -*- encoding : utf-8 -*-
+require 'leancloud/protocol'
+require 'leancloud/client'
+require 'leancloud/error'
+
+module AV
+
+  # Represents an individual Parse API object.
+  class Object < Hash
+    attr_reader :parse_object_id
+    attr_reader :class_name
+    attr_reader :created_at
+    attr_reader :updated_at
+    alias :id :parse_object_id
+
+    def initialize(class_name, data = nil)
+      @class_name = class_name
+      @op_fields = {}
+      if data
+        parse data
+      end
+    end
+
+    def eql?(other)
+      AV.object_pointer_equality?(self, other)
+    end
+
+    alias == eql?
+
+    def hash
+      AV.object_pointer_hash(self)
+    end
+
+    def uri
+      Protocol.class_uri @class_name, @parse_object_id
+    end
+
+    def pointer
+      AV::Pointer.new(rest_api_hash) unless new?
+    end
+
+    # make it easier to deal with the ambiguity of whether you're passed a pointer or object
+    def get
+      self
+    end
+
+    def new?
+      self["objectId"].nil?
+    end
+
+    def update_attributes(data={})
+      data.each_pair { |k,v| self[k] = v }
+      save
+    end
+
+    # Write the current state of the local object to the API.
+    # If the object has never been saved before, this will create
+    # a new object, otherwise it will update the existing stored object.
+    def save
+      if @parse_object_id
+        method = :put
+        self.merge!(@op_fields) # use operations instead of our own view of the columns
+      else
+        method = :post
+      end
+
+      body = safe_hash.to_json
+      uri = self.uri
+      uri = uri + '?new=true' if method == :put
+      data = AV.client.request(uri, method, body)
+
+      if data
+        # array operations can return mutated view of array which needs to be parsed
+        parse AV.parse_json(class_name, data)
+      end
+
+      if @class_name == AV::Protocol::CLASS_USER
+        self.delete("password")
+        self.delete(:username)
+        self.delete(:password)
+      end
+
+      self
+    end
+
+    # representation of object to send on saves
+    def safe_hash
+      Hash[self.map do |key, value|
+        if Protocol::RESERVED_KEYS.include?(key)
+          nil
+        elsif value.is_a?(Hash) && value[Protocol::KEY_TYPE] == Protocol::TYPE_RELATION
+          nil
+        elsif value.nil?
+          [key, Protocol::DELETE_OP]
+        else
+          [key, AV.pointerize_value(value)]
+        end
+      end.compact]
+    end
+
+    # full REST api representation of object
+    def rest_api_hash
+      self.merge(AV::Protocol::KEY_CLASS_NAME => class_name)
+    end
+
+    # Handle the addition of Array#to_h in Ruby 2.1
+    def should_call_to_h?(value)
+      value.respond_to?(:to_h) && !value.kind_of?(Array)
+    end
+
+    def to_h(*a)
+      Hash[rest_api_hash.map do |key, value|
+        [key, should_call_to_h?(value) ? value.to_h : value]
+      end]
+    end
+    alias :as_json :to_h
+    alias :to_hash :to_h
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+
+    def to_s
+      "#{@class_name}:#{@parse_object_id} #{super}"
+    end
+
+    def inspect
+      "#{@class_name}:#{@parse_object_id} #{super}"
+    end
+
+    # Update the fields of the local Parse object with the current
+    # values from the API.
+    def refresh
+      if @parse_object_id
+        data = AV.get @class_name, @parse_object_id
+        clear
+        if data
+          parse data
+        end
+      end
+
+      self
+    end
+
+    # Delete the remote Parse API object.
+    def parse_delete
+      if @parse_object_id
+        response = AV.client.delete self.uri
+      end
+
+      self.clear
+      self
+    end
+
+    def array_add(field, value)
+      array_op(field, Protocol::KEY_ADD, value)
+    end
+
+    def array_add_relation(field, value)
+      array_op(field, Protocol::KEY_ADD_RELATION, value)
+    end
+
+    def array_remove_relation(field, value)
+      array_op(field, Protocol::KEY_REMOVE_RELATION, value)
+    end
+
+    def array_add_unique(field, value)
+      array_op(field, Protocol::KEY_ADD_UNIQUE, value)
+    end
+
+    def array_remove(field, value)
+      array_op(field, Protocol::KEY_REMOVE, value)
+    end
+
+    # Increment the given field by an amount, which defaults to 1. Saves immediately to reflect incremented
+    def increment(field, amount = 1)
+      #value = (self[field] || 0) + amount
+      #self[field] = value
+      #if !@parse_object_id
+      #  # TODO - warn that the object must be stored first
+      #  return nil
+      #end
+
+      body = {field => AV::Increment.new(amount)}.to_json
+      data = AV.client.request(self.uri() + '?new=true', :put, body)
+      parse data
+      self
+    end
+
+    # Decrement the given field by an amount, which defaults to 1. Saves immediately to reflect decremented
+    # A synonym for increment(field, -amount).
+    def decrement(field, amount = 1)
+      increment(field, -amount)
+    end
+
+    private
+
+    # Merge a hash parsed from the JSON representation into
+    # this instance. This will extract the reserved fields,
+    # merge the hash keys, and then ensure that the reserved
+    # fields do not occur in the underlying hash storage.
+    def parse(data)
+      if !data
+        return
+      end
+
+      @parse_object_id ||= data[Protocol::KEY_OBJECT_ID]
+
+      if data.has_key? Protocol::KEY_CREATED_AT
+        @created_at = DateTime.parse data[Protocol::KEY_CREATED_AT]
+      end
+
+      if data.has_key? Protocol::KEY_UPDATED_AT
+        @updated_at = DateTime.parse data[Protocol::KEY_UPDATED_AT]
+      end
+
+      data.each do |k,v|
+        if k.is_a? Symbol
+          k = k.to_s
+        end
+
+        if k != AV::Protocol::KEY_TYPE
+          self[k] = v
+        end
+      end
+
+      self
+    end
+
+    def array_op(field, operation, value)
+      raise "field #{field} not an array" if self[field] && !self[field].is_a?(Array)
+
+      if @parse_object_id
+        @op_fields[field] ||= ArrayOp.new(operation, [])
+        raise "only one operation type allowed per array #{field}" if @op_fields[field].operation != operation
+        @op_fields[field].objects << AV.pointerize_value(value)
+      end
+
+      # parse doesn't return column values on initial POST creation so we must maintain them ourselves
+      case operation
+      when Protocol::KEY_ADD, Protocol::KEY_ADD_RELATION
+        self[field] ||= []
+        self[field] << value
+      when Protocol::KEY_ADD_UNIQUE
+        self[field] ||= []
+        self[field] << value unless self[field].include?(value)
+      when Protocol::KEY_REMOVE, Protocol::KEY_REMOVE_RELATION
+        self[field].delete(value) if self[field]
+      end
+    end
+  end
+end

data/lib/leancloud/protocol.rb

@@ -0,0 +1,193 @@
+# -*- encoding : utf-8 -*-
+module AV
+  # A module which encapsulates the specifics of Parse's REST API.
+  module Protocol
+
+    # Basics
+    # ----------------------------------------
+
+    # The default hostname for communication with the Parse API.
+    HOST            = "api.leancloud.cn"
+
+    # The version of the REST API implemented by this module.
+    VERSION         = 1.1
+
+    # HTTP Headers
+    # ----------------------------------------
+
+    # The HTTP header used for passing your application ID to the
+    # Parse API.
+    HEADER_APP_ID   = "X-AVOSCloud-Application-Id"
+
+    # The HTTP header used for passing your API key to the
+    # Parse API.
+    HEADER_API_KEY  = "X-AVOSCloud-Application-Key"
+
+    # The HTTP header used for passing your API Master key to the
+    # Parse API.
+    HEADER_MASTER_KEY  = "X-AVOSCloud-Master-Key"
+
+    # The HTTP header used for passing your authenticated session
+    HEADER_SESSION_TOKEN = "X-AVOSCloud-Session-Token"
+
+    # JSON Keys
+    # ----------------------------------------
+
+    # The JSON key used to store the class name of an object
+    # in a Pointer datatype.
+    KEY_CLASS_NAME  = "className"
+
+    # The JSON key used to store the ID of Parse objects
+    # in their JSON representation.
+    KEY_OBJECT_ID   = "objectId"
+
+    # The JSON key used to store the creation timestamp of
+    # Parse objects in their JSON representation.
+    KEY_CREATED_AT  = "createdAt"
+
+    # The JSON key used to store the last modified timestamp
+    # of Parse objects in their JSON representation.
+    KEY_UPDATED_AT  = "updatedAt"
+
+    KEY_USER_SESSION_TOKEN = "sessionToken"
+
+    # The JSON key used in the top-level response object
+    # to indicate that the response contains an array of objects.
+    RESPONSE_KEY_RESULTS = "results"
+    KEY_RESULTS = RESPONSE_KEY_RESULTS
+
+    # The JSON key used to identify an operator
+    KEY_OP          = "__op"
+
+    KEY_INCREMENT   = "Increment"
+    KEY_DELETE      = "Delete"
+
+    # array ops
+    KEY_OBJECTS         = "objects"
+    KEY_ADD             = "Add"
+    KEY_ADD_RELATION    = "AddRelation"
+    KEY_REMOVE_RELATION = "RemoveRelation"
+    KEY_ADD_UNIQUE      = "AddUnique"
+    KEY_REMOVE          = "Remove"
+
+    DELETE_OP       = { KEY_OP => KEY_DELETE }
+
+    # The JSON key used to identify the datatype of a special value.
+    KEY_TYPE        = "__type"
+
+    # The JSON key used to specify the numerical value in the
+    # increment/decrement API call.
+    KEY_AMOUNT      = "amount"
+
+    RESERVED_KEYS = [ KEY_CLASS_NAME, KEY_CREATED_AT, KEY_OBJECT_ID, KEY_UPDATED_AT, KEY_USER_SESSION_TOKEN]
+
+    # Other Constants
+    # ----------------------------------------
+
+    # Operation name for incrementing an objects field value remotely
+    OP_INCREMENT    = "Increment"
+
+    # The data type name for special JSON objects representing a full object
+    TYPE_OBJECT     = "Object"
+
+    # The data type name for special JSON objects representing a reference
+    # to another Parse object.
+    TYPE_POINTER    = "Pointer"
+
+    # The data type name for special JSON objects containing an array of
+    # encoded bytes.
+    TYPE_BYTES      = "Bytes"
+
+    # The data type name for special JSON objects representing a date/time.
+    TYPE_DATE       = "Date"
+
+    # The data type name for special JSON objects representing a
+    # location specified as a latitude/longitude pair.
+    TYPE_GEOPOINT   = "GeoPoint"
+
+    # The data type name for special JSON objects representing
+    # a file.
+    TYPE_FILE       = "File"
+
+    # The data type name for special JSON objects representing
+    # a Relation.
+    TYPE_RELATION   = "Relation"
+
+    # The class name for User objects, when referenced by a Pointer.
+    CLASS_USER      = "_User"
+
+    CLASS_INSTALLATION = "_Installation"
+
+    USER_LOGIN_URI  = "/#{VERSION}/login"
+    PASSWORD_RESET_URI = "/#{VERSION}/requestPasswordReset"
+    SMS_URI = "/#{VERSION}/requestSmsCode"
+
+    CLOUD_FUNCTIONS_PATH = "functions"
+
+    BATCH_REQUEST_URI = "batch"
+
+    ERROR_INTERNAL = 1
+    ERROR_TIMEOUT = 124
+    ERROR_EXCEEDED_BURST_LIMIT = 155
+    ERROR_OBJECT_NOT_FOUND_FOR_GET = 101
+
+    # URI Helpers
+    # ----------------------------------------
+
+    def Protocol.config_uri
+      "/#{VERSION}/config"
+    end
+
+    # Construct a uri referencing a given Parse object
+    # class or instance (of object_id is non-nil).
+    def Protocol.class_uri(class_name, object_id = nil)
+      if object_id
+        "/#{VERSION}/classes/#{class_name}/#{object_id}"
+      else
+        "/#{VERSION}/classes/#{class_name}"
+      end
+    end
+
+    # Construct a uri referencing a given Parse installation
+    # class or instance (of object_id is non-nil).
+    def Protocol.installation_uri(object_id = nil)
+      if object_id
+        "/#{VERSION}/installations/#{object_id}"
+      else
+        "/#{VERSION}/installations"
+      end
+    end
+
+    # Construct a uri referencing a given Parse user
+    # instance or the users category.
+    def Protocol.user_uri(user_id = nil)
+      if user_id
+        "/#{VERSION}/users/#{user_id}"
+      else
+        "/#{VERSION}/users"
+      end
+    end
+
+    # Construct a uri referencing a file stored by the API.
+    def Protocol.file_uri(file_name)
+      "/#{VERSION}/files/#{file_name}"
+    end
+
+    # Construct a uri to send a push notification via the API.
+    def Protocol.push_uri
+      "/#{VERSION}/push"
+    end
+
+    def Protocol.cql_uri
+      "/#{VERSION}/cloudQuery"
+    end
+
+    def Protocol.cloud_function_uri(function_name)
+      "/#{VERSION}/#{CLOUD_FUNCTIONS_PATH}/#{function_name}"
+    end
+
+    def Protocol.batch_request_uri
+      "/#{VERSION}/#{BATCH_REQUEST_URI}"
+    end
+  end
+end