leancloud-ruby-client 0.1.0

data/lib/leancloud/push.rb

@@ -0,0 +1,48 @@
+# -*- encoding : utf-8 -*-
+require 'cgi'
+require 'leancloud/error'
+
+module AV
+  class Push
+    attr_accessor :channels
+    attr_accessor :channel
+    attr_accessor :where
+    attr_accessor :type
+    attr_accessor :expiration_time_interval
+    attr_accessor :expiration_time
+    attr_accessor :push_time
+    attr_accessor :data
+    attr_accessor :production
+
+    def initialize(data, channel = "")
+      @data = data
+      @channel = channel
+    end
+
+    def save
+      uri   = Protocol.push_uri
+
+      body = { :data => @data, :channel => @channel }
+
+      if @channels
+        body.merge!({ :channels => @channels })
+        body.delete :channel
+      end
+
+      if @where
+        body.merge!({ :where => @where })
+        body.delete :channel
+      end
+
+      body.merge!({ :expiration_interval => @expiration_time_interval }) if @expiration_time_interval
+      body.merge!({ :expiration_time => @expiration_time }) if @expiration_time
+      body.merge!({ :push_time => @push_time }) if @push_time
+      body.merge!({ :type => @type }) if @type
+      body.merge!({ :prod => 'dev' }) if not @production
+
+      response = AV.client.request uri, :post, body.to_json, nil
+    end
+
+  end
+
+end

data/lib/leancloud/query.rb

@@ -0,0 +1,194 @@
+# -*- encoding : utf-8 -*-
+require 'cgi'
+
+module AV
+
+  class Query
+    attr_accessor :where
+    attr_accessor :class_name
+    attr_accessor :order_by
+    attr_accessor :order
+    attr_accessor :limit
+    attr_accessor :skip
+    attr_accessor :count
+    attr_accessor :include
+
+    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
+
+      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)}
+        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}")
+      end
+    end
+
+    def initialize(cls_name)
+      @class_name = cls_name
+      @where = {}
+      @order = :ascending
+      @ors = []
+    end
+
+    def add_constraint(field, constraint)
+      raise ArgumentError, "cannot add constraint to an $or query" if @ors.size > 0
+      current = where[field]
+      if current && current.is_a?(Hash) && constraint.is_a?(Hash)
+        current.merge! constraint
+      else
+        where[field] = constraint
+      end
+    end
+    #private :add_constraint
+
+    def includes(class_name)
+      @includes = class_name
+      self
+    end
+
+    def or(query)
+      raise ArgumentError, "you must pass an entire #{self.class} to \#or" unless query.is_a?(self.class)
+      @ors << query
+      self
+    end
+
+    def eq(hash_or_field,value=nil)
+      return eq_pair(hash_or_field,value) unless hash_or_field.is_a?(Hash)
+      hash_or_field.each_pair { |k,v| eq_pair k, v }
+      self
+    end
+
+    def eq_pair(field, value)
+      add_constraint field, AV.pointerize_value(value)
+      self
+    end
+
+    def not_eq(field, value)
+      add_constraint field, { "$ne" => AV.pointerize_value(value) }
+      self
+    end
+
+    def regex(field, expression)
+      add_constraint field, { "$regex" => expression }
+      self
+    end
+
+    def less_than(field, value)
+      add_constraint field, { "$lt" => AV.pointerize_value(value) }
+      self
+    end
+
+    def less_eq(field, value)
+      add_constraint field, { "$lte" => AV.pointerize_value(value) }
+      self
+    end
+
+    def greater_than(field, value)
+      add_constraint field, { "$gt" => AV.pointerize_value(value) }
+      self
+    end
+
+    def greater_eq(field, value)
+      add_constraint field, { "$gte" => AV.pointerize_value(value) }
+      self
+    end
+
+    def value_in(field, values)
+      add_constraint field, { "$in" => values.map { |v| AV.pointerize_value(v) } }
+      self
+    end
+
+    def value_not_in(field, values)
+      add_constraint field, { "$nin" => values.map { |v| AV.pointerize_value(v) } }
+      self
+    end
+
+    def contains_all(field, values)
+      add_constraint field, { "$all" => values.map { |v| AV.pointerize_value(v) } }
+      self
+    end
+
+    def related_to(field,value)
+      h = {"object" => AV.pointerize_value(value), "key" => field}
+      add_constraint("$relatedTo", h )
+    end
+
+    def exists(field, value = true)
+      add_constraint field, { "$exists" => value }
+      self
+    end
+
+    def in_query(field, query=nil)
+      query_hash = {AV::Protocol::KEY_CLASS_NAME => query.class_name, "where" => query.where}
+      add_constraint(field, "$inQuery" => query_hash)
+      self
+    end
+
+    def count
+      @count = true
+      self
+    end
+
+    def where_as_json
+      if @ors.size > 0
+        {"$or" => [self.where] + @ors.map{|query| query.where_as_json}}
+      else
+        @where
+      end
+    end
+
+    def first
+      self.limit = 1
+      get.first
+    end
+
+    def get
+      uri   = Protocol.class_uri @class_name
+      if @class_name == AV::Protocol::CLASS_USER
+        uri = Protocol.user_uri
+      elsif @class_name == AV::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
+
+      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)}
+        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}")
+      end
+    end
+
+    private
+
+    def set_order(query)
+      return unless @order_by
+      order_string = @order_by
+      order_string = "-#{order_string}" if @order == :descending
+      query.merge!(:order => order_string)
+    end
+
+    def merge_attribute(attribute, query, query_field = nil)
+      value = self.instance_variable_get("@#{attribute.to_s}")
+      return if value.nil?
+      query.merge!((query_field || attribute) => value)
+    end
+  end
+
+end

data/lib/leancloud/user.rb

@@ -0,0 +1,38 @@
+# -*- encoding : utf-8 -*-
+require 'leancloud/protocol'
+require 'leancloud/client'
+require 'leancloud/error'
+require 'leancloud/object'
+
+module AV
+  class User < AV::Object
+
+    def self.authenticate(username, password)
+      body = {
+        "username" => username,
+        "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]
+
+      new(response)
+    end
+
+    def self.reset_password(email)
+      body = {"email" => email}
+      AV.client.post(AV::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)
+    end
+
+    def uri
+      Protocol.user_uri @parse_object_id
+    end
+
+  end
+end

data/lib/leancloud/util.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+
+module AV
+
+  # 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)
+    if obj.nil?
+      nil
+
+    # Array
+    elsif obj.is_a? Array
+      obj.collect { |o| parse_json(class_name, o) }
+
+    # Hash
+    elsif obj.is_a? Hash
+
+      # If it's a datatype hash
+      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)]}]
+      else # plain old hash
+        obj
+      end
+
+    # primitive
+    else
+      obj
+    end
+  end
+
+  def AV.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)]}]
+        else
+          AV::Pointer.new obj
+        end
+      when Protocol::TYPE_BYTES
+        AV::Bytes.new obj
+      when Protocol::TYPE_DATE
+        AV::Date.new obj
+      when Protocol::TYPE_GEOPOINT
+        AV::GeoPoint.new obj
+      when Protocol::TYPE_FILE
+        AV::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)]}]
+    end
+  end
+
+  def AV.pointerize_value(obj)
+    if obj.kind_of?(AV::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)
+      end
+    elsif obj.is_a?(Hash)
+      Hash[obj.map do |k, v|
+        [k, AV.pointerize_value(v)]
+      end]
+    else
+      obj
+    end
+  end
+
+  def AV.object_pointer_equality?(a, b)
+    classes = [AV::Object, AV::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?
+
+    a.class_name == b.class_name && a.id == b.id
+  end
+
+  def AV.object_pointer_hash(v)
+    if v.new?
+      v.object_id
+    else
+      v.class_name.hash ^ v.id.hash
+    end
+  end
+end

data/test/cloud_functions/MyCloudCode/cloud/main.js

@@ -0,0 +1,4 @@
+Parse.Cloud.define('trivial', function(request, response) {
+	console.log(request);
+  response.success(request.params);
+});

data/test/config/global.json

@@ -0,0 +1,14 @@
+{
+    "applications": {
+        "_default": {
+            "link": "FakeApp"
+        }, 
+        "FakeApp": {
+            "applicationId": "fakeApplicationId", 
+            "masterKey": "fakeMasterKey"
+        }
+    }, 
+    "global": {
+        "parseVersion": "1.0.23"
+    }
+}

data/test/helper.rb

@@ -0,0 +1,108 @@
+# -*- encoding : utf-8 -*-
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/test/"
+end if ENV["COVERAGE"]
+
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'vcr'
+require 'webmock/test_unit'
+
+require 'simplecov'
+SimpleCov.start if ENV['COVERAGE']
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'leancloud-ruby-client'
+
+YAML::ENGINE.yamler='syck' # get ascii strings as strings in fixtures
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'fixtures/vcr_cassettes'
+  c.hook_into :webmock # or :fakeweb
+  c.allow_http_connections_when_no_cassette = true
+  c.filter_sensitive_data("<COOKIE-KEY>") { |i| [i.response.headers['Set-Cookie']].flatten.compact.first }
+
+  def filter_sensitive_header(c, header)
+    c.filter_sensitive_data("<#{header}>") do |interaction|
+      if v = interaction.request.headers.detect{|k,_| k.casecmp(header) == 0}
+        v.last.first
+      end
+    end
+  end
+
+  filter_sensitive_header(c, AV::Protocol::HEADER_APP_ID)
+  filter_sensitive_header(c, AV::Protocol::HEADER_API_KEY)
+  filter_sensitive_header(c, AV::Protocol::HEADER_MASTER_KEY)
+  filter_sensitive_header(c, AV::Protocol::HEADER_SESSION_TOKEN)
+end
+
+class AVTestCase < Test::Unit::TestCase
+  def setup
+    @client = AV.init(:logger => Logger.new(STDERR).tap{|l| l.level = Logger::ERROR})
+  end
+end
+
+module Faraday
+  module LiveServerConfig
+    def live_server=(value)
+      @@live_server = case value
+      when /^http/
+        URI(value)
+      when /./
+        URI('http://127.0.0.1:4567')
+      end
+    end
+
+    def live_server?
+      defined? @@live_server
+    end
+
+    # Returns an object that responds to `host` and `port`.
+    def live_server
+      live_server? and @@live_server
+    end
+  end
+  class TestCase < Test::Unit::TestCase
+    extend LiveServerConfig
+    self.live_server = ENV['LIVE']
+
+    def test_default
+      assert true
+    end unless defined? ::MiniTest
+
+    def capture_warnings
+      old, $stderr = $stderr, StringIO.new
+      begin
+        yield
+        $stderr.string
+      ensure
+        $stderr = old
+      end
+    end
+
+    def self.jruby?
+      defined? RUBY_ENGINE and 'jruby' == RUBY_ENGINE
+    end
+
+    def self.rbx?
+      defined? RUBY_ENGINE and 'rbx' == RUBY_ENGINE
+    end
+
+    def self.ssl_mode?
+      ENV['SSL'] == 'yes'
+    end
+  end
+end