leancloud-ruby-client 0.1.0

data/lib/leancloud/cloud.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+module AV
+  module Cloud
+
+    class Function
+      attr_accessor :function_name
+
+      def initialize(function_name)
+        @function_name = function_name
+      end
+
+      def uri
+        Protocol.cloud_function_uri(@function_name)
+      end
+
+      def call(params={})
+        response = AV.client.post(self.uri, params.to_json)
+        result = response["result"]
+        result
+      end
+    end
+
+    def self.request_sms(params)
+      response = AV.client.post("/#{Protocol::VERSION}/requestSmsCode", params.to_json)
+      return response == {}
+    end
+  end
+end

data/lib/leancloud/datatypes.rb

@@ -0,0 +1,355 @@
+# -*- encoding : utf-8 -*-
+require 'time'
+require 'date'
+require 'base64'
+
+module AV
+
+  # Pointer
+  # ------------------------------------------------------------
+
+  class Pointer
+    attr_accessor :parse_object_id
+    attr_accessor :class_name
+    alias :id :parse_object_id
+
+    def self.make(class_name, object_id)
+      Pointer.new(
+        Protocol::KEY_CLASS_NAME => class_name,
+        Protocol::KEY_OBJECT_ID => object_id
+      )
+    end
+
+    def initialize(data)
+      @class_name       = data[Protocol::KEY_CLASS_NAME]
+      @parse_object_id  = data[Protocol::KEY_OBJECT_ID]
+    end
+
+    # make it easier to deal with the ambiguity of whether you're passed a pointer or object
+    def pointer
+      self
+    end
+
+    def eql?(other)
+      AV.object_pointer_equality?(self, other)
+    end
+
+    alias == eql?
+
+    def hash
+      AV.object_pointer_hash(self)
+    end
+
+    def new?
+      false
+    end
+
+    def to_h(*a)
+      {
+          Protocol::KEY_TYPE        => Protocol::TYPE_POINTER,
+          Protocol::KEY_CLASS_NAME  => @class_name,
+          Protocol::KEY_OBJECT_ID   => @parse_object_id
+      }
+    end
+    alias :as_json :to_h
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+
+    # Retrieve the Parse object referenced by this pointer.
+    def get
+      AV.get @class_name, @parse_object_id if @parse_object_id
+    end
+
+    def to_s
+      "#{@class_name}:#{@parse_object_id}"
+    end
+  end
+
+  # Date
+  # ------------------------------------------------------------
+
+  class Date
+    attr_accessor :value
+
+    def initialize(data)
+      if data.respond_to?(:iso8601)
+        @value = data
+      elsif data.is_a? Hash
+        @value = DateTime.parse data["iso"]
+      elsif data.is_a? String
+        @value = DateTime.parse data
+      else
+        raise "data doesn't act like time #{data.inspect}"
+      end
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) &&
+        value == other.value
+    end
+
+    alias == eql?
+
+    def hash
+      value.hash
+    end
+
+    def <=>(other)
+      value <=> other.value
+    end
+
+    def method_missing(method, *args, &block)
+      if value.respond_to?(method)
+        value.send(method, *args, &block)
+      else
+        super(method)
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || value.respond_to?(method, include_private)
+    end
+
+    def to_h(*a)
+      {
+          Protocol::KEY_TYPE => Protocol::TYPE_DATE,
+          "iso"              => value.to_time.utc.iso8601(3)
+      }
+    end
+    alias :as_json :to_h
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+  end
+
+  # Bytes
+  # ------------------------------------------------------------
+
+  class Bytes
+    attr_accessor :value
+
+    def initialize(data)
+      bytes = data["base64"]
+      @value = Base64.decode64(bytes)
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) &&
+        value == other.value
+    end
+
+    alias == eql?
+
+    def hash
+      value.hash
+    end
+
+    def <=>(other)
+      value <=> other.value
+    end
+
+    def method_missing(method, *args, &block)
+      if value.respond_to?(method)
+        value.send(method, *args, &block)
+      else
+        super(method)
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      super || value.respond_to?(method, include_private)
+    end
+
+    def to_h(*a)
+      {
+          Protocol::KEY_TYPE => Protocol::TYPE_BYTES,
+          "base64" => Base64.encode64(@value)
+      }
+    end
+    alias :as_json :to_h
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+  end
+
+  # Increment and Decrement
+  # ------------------------------------------------------------
+
+  class Increment
+    # '{"score": {"__op": "Increment", "amount": 1 } }'
+    attr_accessor :amount
+
+    def initialize(amount)
+      @amount = amount
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) &&
+        amount == other.amount
+    end
+
+    alias == eql?
+
+    def hash
+      amount.hash
+    end
+
+    def to_h(*a)
+      {
+          Protocol::KEY_OP => Protocol::KEY_INCREMENT,
+          Protocol::KEY_AMOUNT => @amount
+      }
+    end
+    alias :as_json :to_h
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+  end
+
+  class ArrayOp
+    # '{"myArray": {"__op": "Add", "objects": ["something", "something else"] } }'
+    attr_accessor :operation
+    attr_accessor :objects
+
+    def initialize(operation, objects)
+      @operation = operation
+      @objects = objects
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) &&
+        operation == other.operation &&
+        objects == other.objects
+    end
+
+    alias == eql?
+
+    def hash
+      operation.hash ^ objects.hash
+    end
+
+    def to_h(*a)
+      {
+          Protocol::KEY_OP => operation,
+          Protocol::KEY_OBJECTS => @objects
+      }
+    end
+    alias :as_json :to_h
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+  end
+
+  # GeoPoint
+  # ------------------------------------------------------------
+
+  class GeoPoint
+    # '{"location": {"__type":"GeoPoint", "latitude":40.0, "longitude":-30.0}}'
+    attr_accessor :longitude, :latitude
+
+    def initialize(data)
+      @longitude = data["longitude"]
+      @latitude  = data["latitude"]
+
+      if !@longitude && !@latitude
+        @longitude = data[:longitude]
+        @latitude  = data[:latitude]
+      end
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) &&
+        longitude == other.longitude &&
+        latitude == other.latitude
+    end
+
+    alias == eql?
+
+    def hash
+      longitude.hash ^ latitude.hash
+    end
+
+    def to_h(*a)
+      {
+          Protocol::KEY_TYPE => Protocol::TYPE_GEOPOINT,
+          "latitude" => @latitude,
+          "longitude" => @longitude
+      }
+    end
+    alias :as_json :to_h
+
+    def to_json(*a)
+      to_h.to_json(*a)
+    end
+
+    def to_s
+      "(#{latitude}, #{longitude})"
+    end
+  end
+
+  # File
+  # ------------------------------------------------------------
+  # tf = AV::File.new(:body => "Hello World!", :local_filename => "hello.txt")
+  # tf.save
+  class File
+    # '{"avatar": {"__type":"File", "name":"profile.png", "url"=>"http://files.parse.com/blah/profile.png"}}'
+    attr_accessor :local_filename # eg "hello.txt"
+    attr_accessor :parse_filename # eg "12-4-532d-d-g3-3-hello.text"
+    attr_accessor :content_type
+    attr_accessor :body
+    attr_accessor :url
+    attr_accessor :id
+
+    def initialize(data)
+      data = Hash[data.map{ |k, v| [k.to_s, v] }] # convert hash keys to strings
+      @local_filename = data["local_filename"] if data["local_filename"]
+      @parse_filename = data["name"]           if data["name"]
+      @parse_filename = data["parse_filename"] if data["parse_filename"]
+      @content_type   = data["content_type"]   if data["content_type"]
+      @url            = data["url"]            if data["url"]
+      @body           = data["body"]           if data["body"]
+      @id             = data["id"]             if data["id"]
+    end
+
+    def eql?(other)
+      self.class.equal?(other.class) &&
+        url == other.url
+    end
+
+    alias == eql?
+
+    def hash
+      url.hash
+    end
+
+    def save
+      uri = AV::Protocol.file_uri(@local_filename)
+      resp = AV.client.request(uri, :post, @body, nil, @content_type)
+      @parse_filename = resp["name"]
+      @url = resp["url"]
+      @id = resp["id"]
+      resp
+    end
+
+    def to_h(*a)
+      {
+        Protocol::KEY_TYPE => Protocol::TYPE_FILE,
+        "name" => @parse_filename,
+        "url" => @url,
+        "id" => @id
+      }
+    end
+    alias :as_json :to_h
+
+    def to_json(*a)
+    to_h.to_json(*a)
+    end
+  end
+
+end

data/lib/leancloud/error.rb

@@ -0,0 +1,42 @@
+# -*- encoding : utf-8 -*-
+module AV
+
+  # Base exception class for errors thrown by the Parse
+  # client library. AVError will be raised by any
+  # network operation if AV.init() has not been called.
+  class AVError < StandardError #Exception ... why? A:http://www.skorks.com/2009/09/ruby-exceptions-and-exception-handling/
+  end
+
+  # An exception class raised when the REST API returns an error.
+  # The error code and message will be parsed out of the HTTP response,
+  # which is also included in the response attribute.
+  class AVProtocolError < AVError
+    attr_accessor :code
+    attr_accessor :error
+    attr_accessor :response
+    attr_accessor :http_status_code
+
+    def initialize(response)
+      @response = response
+      if response
+        @code   = response["code"]
+        @error  = response["error"]
+        @http_status_code = response["http_status_code"]
+      end
+
+      super("#{@code}: #{@error}")
+    end
+
+    def to_s
+      @message || super
+    end
+
+    def message=(msg)
+      @message = msg
+    end
+  end
+
+  class AVProtocolRetry < AVProtocolError
+  end
+
+end

data/lib/leancloud/installation.rb

@@ -0,0 +1,57 @@
+require 'leancloud/protocol'
+require 'leancloud/client'
+require 'leancloud/error'
+require 'leancloud/object'
+
+module AV
+  class Installation < AV::Object
+    UPDATABLE_FIELDS = {
+      badge: 'badge',
+      channels: 'channels',
+      time_zone: 'timeZone',
+      device_token: 'deviceToken',
+      channel_uris: 'channelUris',
+      app_name: 'appName',
+      app_version: 'appVersion',
+      parse_version: 'parseVersion',
+      app_identifier: 'appIdentifier'
+    }
+
+    def initialize(parse_object_id)
+      @parse_object_id = parse_object_id
+    end
+
+    def self.get(parse_object_id)
+      new(parse_object_id).get
+    end
+
+    def get
+      if response = AV.client.request(uri, :get, nil, nil)
+        parse AV.parse_json(nil, response)
+      end
+    end
+
+    UPDATABLE_FIELDS.each do |method_name, key|
+      define_method "#{method_name}=" do |value|
+        self[key] = value
+      end
+    end
+
+    def uri
+      Protocol.installation_uri @parse_object_id
+    end
+
+    def save
+      AV.client.request uri, method, self.to_json, nil
+    end
+
+    def rest_api_hash
+      self
+    end
+
+    def method
+      @parse_object_id ? :put : :post
+    end
+
+  end
+end