leancloud-ruby-client 0.1.1 → 0.2.0

data/lib/leancloud/model.rb

@@ -1,13 +1,13 @@
 # -*- encoding : utf-8 -*-
-module AV
-  class Model < AV::Object
+module LC
+  class Model < LC::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
+      self.new LC::Query.new(self.to_s).eq('objectId',object_id).first
     end
 
   end

data/lib/leancloud/object.rb

@@ -3,7 +3,7 @@ require 'leancloud/protocol'
 require 'leancloud/client'
 require 'leancloud/error'
 
-module AV
+module LC
 
   # Represents an individual Parse API object.
   class Object < Hash
@@ -22,13 +22,13 @@ module AV
     end
 
     def eql?(other)
-      AV.object_pointer_equality?(self, other)
+      LC.object_pointer_equality?(self, other)
     end
 
     alias == eql?
 
     def hash
-      AV.object_pointer_hash(self)
+      LC.object_pointer_hash(self)
     end
 
     def uri
@@ -36,7 +36,7 @@ module AV
     end
 
     def pointer
-      AV::Pointer.new(rest_api_hash) unless new?
+      LC::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
@@ -67,14 +67,14 @@ module AV
       body = safe_hash.to_json
       uri = self.uri
       uri = uri + '?new=true' if method == :put
-      data = AV.client.request(uri, method, body)
+      data = LC.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)
+        parse LC.parse_json(class_name, data)
       end
 
-      if @class_name == AV::Protocol::CLASS_USER
+      if @class_name == LC::Protocol::CLASS_USER
         self.delete("password")
         self.delete(:username)
         self.delete(:password)
@@ -93,14 +93,14 @@ module AV
         elsif value.nil?
           [key, Protocol::DELETE_OP]
         else
-          [key, AV.pointerize_value(value)]
+          [key, LC.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)
+      self.merge(LC::Protocol::KEY_CLASS_NAME => class_name)
     end
 
     # Handle the addition of Array#to_h in Ruby 2.1
@@ -132,7 +132,7 @@ module AV
     # values from the API.
     def refresh
       if @parse_object_id
-        data = AV.get @class_name, @parse_object_id
+        data = LC.get @class_name, @parse_object_id
         clear
         if data
           parse data
@@ -145,7 +145,7 @@ module AV
     # Delete the remote Parse API object.
     def parse_delete
       if @parse_object_id
-        response = AV.client.delete self.uri
+        response = LC.client.delete self.uri
       end
 
       self.clear
@@ -181,8 +181,8 @@ module AV
       #  return nil
       #end
 
-      body = {field => AV::Increment.new(amount)}.to_json
-      data = AV.client.request(self.uri() + '?new=true', :put, body)
+      body = {field => LC::Increment.new(amount)}.to_json
+      data = LC.client.request(self.uri() + '?new=true', :put, body)
       parse data
       self
     end
@@ -219,7 +219,7 @@ module AV
           k = k.to_s
         end
 
-        if k != AV::Protocol::KEY_TYPE
+        if k != LC::Protocol::KEY_TYPE
           self[k] = v
         end
       end
@@ -233,7 +233,7 @@ module AV
       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)
+        @op_fields[field].objects << LC.pointerize_value(value)
       end
 
       # parse doesn't return column values on initial POST creation so we must maintain them ourselves

data/lib/leancloud/protocol.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
-module AV
+module LC
   # A module which encapsulates the specifics of Parse's REST API.
   module Protocol
 
@@ -17,18 +17,22 @@ module AV
 
     # The HTTP header used for passing your application ID to the
     # Parse API.
-    HEADER_APP_ID   = "X-AVOSCloud-Application-Id"
+    HEADER_APP_ID   = "X-LC-Id"
+
+    # The HTTP header used for passing your API Sign to the
+    # Parse API.
+    HEADER_API_KEY  = "X-LC-Sign"
 
     # The HTTP header used for passing your API key to the
     # Parse API.
-    HEADER_API_KEY  = "X-AVOSCloud-Application-Key"
+    #HEADER_API_KEY  = "X-LC-Key"
 
     # The HTTP header used for passing your API Master key to the
     # Parse API.
-    HEADER_MASTER_KEY  = "X-AVOSCloud-Master-Key"
+    #HEADER_MASTER_KEY  = "X-LC-Master"
 
     # The HTTP header used for passing your authenticated session
-    HEADER_SESSION_TOKEN = "X-AVOSCloud-Session-Token"
+    HEADER_SESSION_TOKEN = "X-LC-Session"
 
     # JSON Keys
     # ----------------------------------------
@@ -119,6 +123,7 @@ module AV
     CLASS_INSTALLATION = "_Installation"
 
     USER_LOGIN_URI  = "/#{VERSION}/login"
+    USER_CURRENT_URI  = "/#{VERSION}/users/me"
     PASSWORD_RESET_URI = "/#{VERSION}/requestPasswordReset"
     SMS_URI = "/#{VERSION}/requestSmsCode"
 

data/lib/leancloud/push.rb

@@ -2,7 +2,7 @@
 require 'cgi'
 require 'leancloud/error'
 
-module AV
+module LC
   class Push
     attr_accessor :channels
     attr_accessor :channel
@@ -40,7 +40,7 @@ module AV
       body.merge!({ :type => @type }) if @type
       body.merge!({ :prod => 'dev' }) if not @production
 
-      response = AV.client.request uri, :post, body.to_json, nil
+      response = LC.client.request uri, :post, body.to_json, nil
     end
 
   end

data/lib/leancloud/query.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 require 'cgi'
 
-module AV
+module LC
 
   class Query
     attr_accessor :where
@@ -16,18 +16,18 @@ module AV
     def self.do_cloud_query(cql, pvalues=[])
       uri   = Protocol.cql_uri
       query = { "cql" => cql,"pvalues"=> pvalues.to_json }
-      AV.client.logger.info{"Leancloud query for #{uri} #{query.inspect}"} unless AV.client.quiet
-      response = AV.client.request uri, :get, nil, query
+      LC.client.logger.info{"Leancloud query for #{uri} #{query.inspect}"} unless LC.client.quiet
+      response = LC.client.request uri, :get, nil, query
 
       if response.is_a?(Hash) && response.has_key?(Protocol::KEY_RESULTS) && response[Protocol::KEY_RESULTS].is_a?(Array)
         class_name = response[Protocol::KEY_CLASS_NAME]
-        parsed_results = response[Protocol::KEY_RESULTS].map{|o| AV.parse_json(class_name, o)}
+        parsed_results = response[Protocol::KEY_RESULTS].map{|o| LC.parse_json(class_name, o)}
         return {
             count: response['count'],
             results: parsed_results
         }
       else
-        raise AVError.new("query response not a Hash with #{Protocol::KEY_RESULTS} key: #{response.class} #{response.inspect}")
+        raise LCError.new("query response not a Hash with #{Protocol::KEY_RESULTS} key: #{response.class} #{response.inspect}")
       end
     end
 
@@ -67,12 +67,12 @@ module AV
     end
 
     def eq_pair(field, value)
-      add_constraint field, AV.pointerize_value(value)
+      add_constraint field, LC.pointerize_value(value)
       self
     end
 
     def not_eq(field, value)
-      add_constraint field, { "$ne" => AV.pointerize_value(value) }
+      add_constraint field, { "$ne" => LC.pointerize_value(value) }
       self
     end
 
@@ -82,42 +82,42 @@ module AV
     end
 
     def less_than(field, value)
-      add_constraint field, { "$lt" => AV.pointerize_value(value) }
+      add_constraint field, { "$lt" => LC.pointerize_value(value) }
       self
     end
 
     def less_eq(field, value)
-      add_constraint field, { "$lte" => AV.pointerize_value(value) }
+      add_constraint field, { "$lte" => LC.pointerize_value(value) }
       self
     end
 
     def greater_than(field, value)
-      add_constraint field, { "$gt" => AV.pointerize_value(value) }
+      add_constraint field, { "$gt" => LC.pointerize_value(value) }
       self
     end
 
     def greater_eq(field, value)
-      add_constraint field, { "$gte" => AV.pointerize_value(value) }
+      add_constraint field, { "$gte" => LC.pointerize_value(value) }
       self
     end
 
     def value_in(field, values)
-      add_constraint field, { "$in" => values.map { |v| AV.pointerize_value(v) } }
+      add_constraint field, { "$in" => values.map { |v| LC.pointerize_value(v) } }
       self
     end
 
     def value_not_in(field, values)
-      add_constraint field, { "$nin" => values.map { |v| AV.pointerize_value(v) } }
+      add_constraint field, { "$nin" => values.map { |v| LC.pointerize_value(v) } }
       self
     end
 
     def contains_all(field, values)
-      add_constraint field, { "$all" => values.map { |v| AV.pointerize_value(v) } }
+      add_constraint field, { "$all" => values.map { |v| LC.pointerize_value(v) } }
       self
     end
 
     def related_to(field,value)
-      h = {"object" => AV.pointerize_value(value), "key" => field}
+      h = {"object" => LC.pointerize_value(value), "key" => field}
       add_constraint("$relatedTo", h )
     end
 
@@ -127,7 +127,7 @@ module AV
     end
 
     def in_query(field, query=nil)
-      query_hash = {AV::Protocol::KEY_CLASS_NAME => query.class_name, "where" => query.where}
+      query_hash = {LC::Protocol::KEY_CLASS_NAME => query.class_name, "where" => query.where}
       add_constraint(field, "$inQuery" => query_hash)
       self
     end
@@ -152,26 +152,26 @@ module AV
 
     def get
       uri   = Protocol.class_uri @class_name
-      if @class_name == AV::Protocol::CLASS_USER
+      if @class_name == LC::Protocol::CLASS_USER
         uri = Protocol.user_uri
-      elsif @class_name == AV::Protocol::CLASS_INSTALLATION
+      elsif @class_name == LC::Protocol::CLASS_INSTALLATION
         uri = Protocol.installation_uri
       end
       query = { "where" => where_as_json.to_json }
       set_order(query)
       [:count, :limit, :skip, :include].each {|a| merge_attribute(a, query)}
-      AV.client.logger.info{"Parse query for #{uri} #{query.inspect}"} unless AV.client.quiet
-      response = AV.client.request uri, :get, nil, query
+      LC.client.logger.info{"Parse query for #{uri} #{query.inspect}"} unless LC.client.quiet
+      response = LC.client.request uri, :get, nil, query
 
       if response.is_a?(Hash) && response.has_key?(Protocol::KEY_RESULTS) && response[Protocol::KEY_RESULTS].is_a?(Array)
-        parsed_results = response[Protocol::KEY_RESULTS].map{|o| AV.parse_json(class_name, o)}
+        parsed_results = response[Protocol::KEY_RESULTS].map{|o| LC.parse_json(class_name, o)}
         if response.keys.size == 1
           parsed_results
         else
           response.dup.merge(Protocol::KEY_RESULTS => parsed_results)
         end
       else
-        raise AVError.new("query response not a Hash with #{Protocol::KEY_RESULTS} key: #{response.class} #{response.inspect}")
+        raise LCError.new("query response not a Hash with #{Protocol::KEY_RESULTS} key: #{response.class} #{response.inspect}")
       end
     end
 

data/lib/leancloud/user.rb

@@ -4,8 +4,14 @@ require 'leancloud/client'
 require 'leancloud/error'
 require 'leancloud/object'
 
-module AV
-  class User < AV::Object
+module LC
+  class User < LC::Object
+
+    def self.become(token)
+      response = LC.client._request(uri: LC::Protocol::USER_CURRENT_URI, session_token: token)
+      LC.client.session_token = response[LC::Protocol::KEY_USER_SESSION_TOKEN]
+      new(response)
+    end
 
     def self.authenticate(username, password)
       body = {
@@ -13,21 +19,21 @@ module AV
         "password" => password
       }
 
-      response = AV.client.request(AV::Protocol::USER_LOGIN_URI, :get, nil, body)
-      AV.client.session_token = response[AV::Protocol::KEY_USER_SESSION_TOKEN]
+      response = LC.client.request(LC::Protocol::USER_LOGIN_URI, :get, nil, body)
+      LC.client.session_token = response[LC::Protocol::KEY_USER_SESSION_TOKEN]
 
       new(response)
     end
 
     def self.reset_password(email)
       body = {"email" => email}
-      AV.client.post(AV::Protocol::PASSWORD_RESET_URI, body.to_json)
+      LC.client.post(LC::Protocol::PASSWORD_RESET_URI, body.to_json)
     end
 
     def initialize(data = nil)
       data["username"] = data[:username] if data[:username]
       data["password"] = data[:password] if data[:password]
-      super(AV::Protocol::CLASS_USER, data)
+      super(LC::Protocol::CLASS_USER, data)
     end
 
     def uri

data/lib/leancloud/util.rb

@@ -1,13 +1,13 @@
 # -*- encoding : utf-8 -*-
 
-module AV
+module LC
 
   # Parse a JSON representation into a fully instantiated
   # class. obj can be either a primitive or a Hash of primitives as parsed
   # by JSON.parse
   # @param class_name [Object]
   # @param obj [Object]
-  def AV.parse_json(class_name, obj)
+  def LC.parse_json(class_name, obj)
     if obj.nil?
       nil
 
@@ -22,7 +22,7 @@ module AV
       if obj.has_key?(Protocol::KEY_TYPE)
         parse_datatype obj
       elsif class_name # otherwise it must be a regular object, so deep parse it avoiding re-JSON.parsing raw Strings
-        AV::Object.new class_name, Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
+        LC::Object.new class_name, Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
       else # plain old hash
         obj
       end
@@ -33,49 +33,49 @@ module AV
     end
   end
 
-  def AV.parse_datatype(obj)
+  def LC.parse_datatype(obj)
     type = obj[Protocol::KEY_TYPE]
 
     case type
       when Protocol::TYPE_POINTER
         if obj[Protocol::KEY_CREATED_AT]
-          AV::Object.new obj[Protocol::KEY_CLASS_NAME], Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
+          LC::Object.new obj[Protocol::KEY_CLASS_NAME], Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
         else
-          AV::Pointer.new obj
+          LC::Pointer.new obj
         end
       when Protocol::TYPE_BYTES
-        AV::Bytes.new obj
+        LC::Bytes.new obj
       when Protocol::TYPE_DATE
-        AV::Date.new obj
+        LC::Date.new obj
       when Protocol::TYPE_GEOPOINT
-        AV::GeoPoint.new obj
+        LC::GeoPoint.new obj
       when Protocol::TYPE_FILE
-        AV::File.new obj
+        LC::File.new obj
       when Protocol::TYPE_OBJECT # used for relation queries, e.g. "?include=post"
-        AV::Object.new obj[Protocol::KEY_CLASS_NAME], Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
+        LC::Object.new obj[Protocol::KEY_CLASS_NAME], Hash[obj.map{|k,v| [k, parse_json(nil, v)]}]
     end
   end
 
-  def AV.pointerize_value(obj)
-    if obj.kind_of?(AV::Object)
+  def LC.pointerize_value(obj)
+    if obj.kind_of?(LC::Object)
       p = obj.pointer
       raise ArgumentError.new("new object used in context requiring pointer #{obj}") unless p
       p
     elsif obj.is_a?(Array)
       obj.map do |v|
-        AV.pointerize_value(v)
+        LC.pointerize_value(v)
       end
     elsif obj.is_a?(Hash)
       Hash[obj.map do |k, v|
-        [k, AV.pointerize_value(v)]
+        [k, LC.pointerize_value(v)]
       end]
     else
       obj
     end
   end
 
-  def AV.object_pointer_equality?(a, b)
-    classes = [AV::Object, AV::Pointer]
+  def LC.object_pointer_equality?(a, b)
+    classes = [LC::Object, LC::Pointer]
     return false unless classes.any? { |c| a.kind_of?(c) } && classes.any? { |c| b.kind_of?(c) }
     return true if a.equal?(b)
     return false if a.new? || b.new?
@@ -83,7 +83,7 @@ module AV
     a.class_name == b.class_name && a.id == b.id
   end
 
-  def AV.object_pointer_hash(v)
+  def LC.object_pointer_hash(v)
     if v.new?
       v.object_id
     else