parsecom 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+.parse_credentials
+*.swp
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in parsecom.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ando Yasushi
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,139 @@
+# Parsecom
+
+Yet-Another Parse.com Library written in Pure Ruby
+
+## Usage
+
+### Preparing
+
+Before using the library, you should import this and set your credentials on 
+the library.
+
+```ruby
+require 'parsecom'
+Parse.credentials application_id:'YOUR APPID', api_key:'YOUR APIKEY'
+```
+
+### Declaring Parse Classes
+
+There are three ways to declare a parse class.
+
+First, you can declare a ruby class inherited from Parse::Object. By using
+this way, you can add your own properties and methods to the class.
+
+```ruby
+class GameScore < Parse::Object
+  # ..snip..
+end
+```
+
+Secondly, you can also declare your parse class by calling the Parse::Object 
+method. 
+
+```ruby
+Parse::Object(:GameScore)
+```
+
+It returns a parse class, so that you can call its class methods directly.
+
+```ruby
+Parse::Object(:GameScore).find :limit => 3
+```
+
+Lastly, Parse::Object class provides create method for you to declare new
+class.
+
+```ruby
+Parse::Object.create :GameScore
+```
+
+It may suitable for writing code in declarative style.
+
+### Creating Objects
+
+To create new parse object, juse new and save the object.
+
+```ruby
+game_score = GameScore.new
+game_score.score = 1337
+game_score.playerName = 'Sean Plott'
+game_score.cheatMode = false
+game_score.new? # => true
+game_score.save
+game_score.new? # => false
+game_score.obj_id # => 'Ed1nuqPvcm'
+```
+
+### Retrieving Objects
+
+There are two ways to retrieve objects. One is using Query objects directly and
+another is using Parse::Object as a facade of query objects.
+
+```ruby
+# useing Query object directly
+query = Parse::Query.new GameScore
+query.where :objectId => 'Ed1nuqPvcm'
+results = query.invoke
+
+# using Query object through Parse::Object
+results = GameScore.find :where => {:objectId => 'Ed1nuqPvcm'}
+# if you would like to find by objectId, you can easily pass it directly
+result = GameScore.find 'Ed1nuqPvcm'
+```
+
+More complex search
+
+```ruby
+# useing Query object directly
+results = Parse::Query.new(GameScore).
+  limit(10).
+  order(score).
+  where do
+    column(:score).gte(1000).lte(3000)
+    column(:cheatMode).eq(false)
+  end.
+  invoke
+
+# using Query object through Parse::Object
+results = GameScore.find :limit => 10, :order => 'score', 
+  :where => proc{
+    column(:score).gte(1000).lte(3000)
+    column(:cheatMode).eq(false)
+  }
+```
+
+To know more about retrieving objects, see spec/parse_query_spec.rb
+
+### Updating Objects
+
+To update attributes, just update the attribute and save.
+
+```ruby
+result = GameScore.find 'Ed1nuqPvcm'
+result.score = 73453
+result.save
+```
+
+If you want to update attributes without retrieving the object, you can use
+the Parse::Client object for it.
+
+```ruby
+score = GameScore.new :objectId => 'Ed1nuqPvcm'
+Parse::Client.default_client.update score, :score => 73453
+```
+
+### Deleting Objects
+
+TBD
+
+### Sign up
+
+```ruby
+user = Parse::User.sign_up 'YOUR USERNAME', 'YOUR PASSWORD'
+```
+
+### Log in
+
+```ruby
+user = Parse::User.log_in 'YOUR USERNAME', 'YOUR PASSWORD'
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/parse/client.rb

@@ -0,0 +1,161 @@
+# coding:utf-8
+module Parse
+  class Client
+    API_SERVER = 'api.parse.com'
+    API_VERSION = 1
+    @@default_client = nil
+
+    attr_accessor :http_client, :session_token
+
+    def self.default_client
+      @@default_client ||= new
+    end
+
+    def initialize application_id=nil, api_key=nil, http_client=nil
+      @application_id = application_id || Parse.application_id
+      @api_key = api_key || Parse.api_key
+      if @application_id.nil? || @api_key.nil?
+        raise ArgumentError.new <<-EOS
+Both Application ID and API Key must be set.
+ex. Parse.credentials application_id: APPLICATION_ID, api_key: API_KEY
+        EOS
+      end
+      @http_client = http_client || Parse::HttpClient.new(API_SERVER)
+    end
+
+    def call_api method, endpoint, body=nil, opt_headers={}, &block
+      endpoint = "/#{API_VERSION}/#{endpoint}" unless endpoint[0] == '/'
+      headers = {
+        'X-Parse-Application-Id' => @application_id,
+        'X-Parse-REST-API-Key' => @api_key,
+        'Content-Type' => 'application/json'
+      }
+      headers.update('X-Parse-Session-Token' => @session_token) if @session_token
+      headers.update opt_headers
+      if body.is_a?(Hash)
+        body = Hash[*(body.to_a.map{|k, v| [k, URI.encode(v)]}.flatten)].to_json 
+      end
+      @http_client.request method, endpoint, headers, body, &block
+    end
+
+    def sign_up username, password, opts={}, &block
+      call_api :post, 'users', {'username' => username, 'password' => password}.update(opts || {}), &block
+    end
+
+    def log_in username, password, &block
+      call_api :get, "login?username=#{URI.encode username}&password=#{
+        URI.encode password}", nil, &block
+    end
+
+    def find parse_class, object_id_or_conditions, opts={}
+      if object_id_or_conditions.is_a? String
+        find_by_id parse_class, object_id_or_conditions, opts
+      elsif object_id_or_conditions.is_a? Hash
+        find_by_query parse_class, object_id_or_conditions
+      end
+    end
+
+    def find_by_id parse_class, object_id, opts={}
+      call_api :get, "classes/#{parse_class.parse_class_name}/#{object_id}" do |resp_body|
+        convert parse_class, resp_body
+
+        if opts.has_key? :include
+          included_keys = opts[:include]
+          included_keys = [included_keys] unless included_keys.is_a? Enumerable
+          included_keys.each do |included_key|
+            pointer = resp_body[included_key]
+            pointer.load
+          end
+        end
+
+        parse_class.new resp_body
+      end
+    end
+
+    def find_by_query parse_class, conditions
+      query = Query.new parse_class
+      query.limit conditions[:limit] if conditions.has_key? :limit
+      query.skip conditions[:skip] if conditions.has_key? :skip
+      query.count conditions[:count] if conditions.has_key? :count
+      if conditions.has_key? :order
+        order = conditions[:order]
+        order = [order] unless order.is_a? Array
+        query.order order
+      end
+      if conditions.has_key? :keys
+        keys = conditions[:keys]
+        keys = [keys] unless keys.is_a? Array
+        query.keys keys
+      end
+      if conditions.has_key? :include
+        include = conditions[:include]
+        include = [include] unless include.is_a? Array
+        query.include include
+      end
+      if conditions.has_key? :where
+        case condition = conditions[:where]
+        when Hash
+          query.where condition
+        when Proc
+          query.where condition
+        else
+          raise 'wrong condition'
+        end
+      end
+      query.invoke
+    end
+
+    def create parse_object, values
+      call_api :post, "classes/#{parse_object.parse_class_name}", values.to_json do |resp_body|
+        resp_body
+      end
+    end
+
+    def update parse_object, values
+      call_api :put, "classes/#{parse_object.parse_class_name}/#{parse_object.object_id}", values.to_json do |resp_body|
+        resp_body
+      end
+    end
+
+    def delete parse_object
+      call_api :delete, "classes/#{parse_object.parse_class_name}/#{parse_object.object_id}" do |resp_body|
+        resp_body
+      end
+    end
+
+    def call_function name, param
+      func_name = Parse.auto_snake_case ? name.to_s.gsub(/_([a-z])/) {$1.upcase} : name
+      call_api :post, "functions/#{func_name}", param.to_json do |resp_body|
+        if resp_body.has_key? 'result'
+          resp_body['result']
+        else
+          raise StandartError.new 'unknown error'
+        end
+      end
+    end
+
+    def method_missing name, *args, &block
+      call_function name, args.first
+    end
+
+    private
+
+    def convert parse_class, resp_body
+      resp_body.each do |k, v|
+        if v.is_a?(Hash) && v.has_key?('__type')
+          resp_body[k] = case v['__type']
+            when 'Date'
+              Date.parse v['iso']
+            when 'File'
+              Parse::File.new v
+            when 'Pointer'
+              # TODO: too many arguments
+              Parse::Pointer.new self, parse_class, resp_body, k, v
+            else
+              v
+            end
+        end
+      end
+    end
+  end
+end

data/lib/parse/cloud_code.rb

@@ -0,0 +1,2 @@
+module Parse
+end

data/lib/parse/ext/string.rb

@@ -0,0 +1,11 @@
+unless String.methods.include? :camelize
+  class String
+    def camelize uppercase_first_letter=true
+      ret = self.gsub(/_(\w)/) do $1.upcase end
+      unless uppercase_first_letter == :lower
+        ret = ret.capitalize
+      end
+      ret
+    end
+  end
+end

data/lib/parse/file.rb

@@ -0,0 +1,36 @@
+# encoding:utf-8
+module Parse
+  class File
+    attr_accessor :name, :url
+
+    def initialize hash
+      @raw_hash = hash
+      @name = hash['name']
+      @url = hash['url']
+    end
+
+    def load &block
+      open @url do |data| @data = data.read end unless @data
+      block.call @data
+    end
+
+    def store filepath=nil
+      filepath ||= @name
+      raise 'filepath is mandatory' unless filepath
+
+      FileUtils.mkdir_p ::File.dirname(filepath)
+      load do |data|
+        open filepath, 'wb' do |file|
+          file.write data
+        end
+      end
+    end
+
+    def inspect
+      data, @data = @data, '..snip..'
+      ret = super
+      @data = data
+      ret
+    end
+  end
+end

data/lib/parse/http_client.rb

@@ -0,0 +1,23 @@
+# coding:utf-8
+module Parse
+  class HttpClient
+    def initialize host
+      @host = host
+    end
+
+    def request method, endpoint, headers={}, body=nil, &block
+      req = eval("Net::HTTP::#{method.to_s.capitalize}").new endpoint, headers
+      req.body = body if body
+      client = Net::HTTP.new @host, 443
+      #client.set_debug_output $stderr
+      client.use_ssl = true
+      client.start do
+        resp = client.request req
+        resp_body = JSON.parse resp.body
+        raise StandardError.new "error calling #{endpoint}: #{
+          resp_body['error']}" if resp_body.has_key? 'error'
+        block.call resp_body if block
+      end
+    end
+  end
+end

data/lib/parse/object.rb

@@ -0,0 +1,176 @@
+# coding:utf-8
+module Parse
+  class Object
+    class << self
+      attr_accessor :parse_class_name, :parse_client, :auto_camel_case
+
+      def create parse_class_name, mod=::Object
+        raise 'already defined' if mod.const_defined? parse_class_name
+
+        klass = Class.new(Parse::Object)
+        klass.parse_class_name = parse_class_name.to_sym
+        klass.auto_camel_case = true
+        mod.const_set parse_class_name, klass
+      end
+
+      def parse_class_name
+        @parse_class_name || name.split('::').last
+      end
+
+      def parse_client
+        @parse_client ||= Parse::Client.default_client
+      end
+
+      def find object_id_or_conditions, opts={}
+        parse_client.find self, object_id_or_conditions, opts
+      end
+    end
+
+    attr_accessor :obj_id, :created_at, :updated_at, :acl
+
+    def initialize hash={}
+      hash = string_keyed_hash hash
+      if hash.has_key? 'objectId'
+        @obj_id = hash['objectId']
+        @raw_hash = hash
+        @updated_hash = {}
+      else
+        @raw_hash = {}
+        @updated_hash = hash
+      end
+      @deleted = false
+    end
+
+    def new?
+      !@deleted && @raw_hash.empty?
+    end
+
+    def updated?
+      !@deleted && !@updated_hash.empty?
+    end
+
+    def deleted?
+      @deleted
+    end
+
+    def parse_client
+      self.class.parse_client
+    end
+
+    def parse_class_name
+      self.class.parse_class_name
+    end
+
+    def save hash=@updated_hash
+      check_deleted!
+      hash = string_keyed_hash hash
+      if new?
+        create hash
+      else
+        update hash
+      end
+    end
+
+    def create hash
+      check_deleted!
+      hash = string_keyed_hash hash
+      @updated_hash.update hash
+      parse_client.create(self, @updated_hash).tap do |response|
+        @obj_id = response['objectId']
+        @created_at = Date.parse response['createdAt']
+        @updated_at = @created_at
+        @raw_hash.update @updated_hash
+        @raw_hash.update response
+        @updated_hash.clear
+      end
+    end
+
+    def update hash
+      check_deleted!
+      hash = string_keyed_hash hash
+      parse_client.update(self, hash).tap do |response|
+        @updated_at = Date.parse response['updatedAt']
+        @raw_hash.update @updated_hash
+        @updated_hash.clear
+      end
+    end
+
+    def delete
+      raise 'You cannot delete new object' if new?
+      check_deleted!
+      parse_client.delete(self).tap do |response|
+        @deleted = true
+      end
+    end
+
+    def obj_id
+      @obj_id || @raw_hash['objectId']
+    end
+
+    def get_column name
+      name = name.to_s
+      ret = @updated_hash[name]
+      if ret.nil? && self.class.auto_camel_case
+        ret = @updated_hash[name.camelize :lower]
+      end
+      if ret.nil?
+        ret = @raw_hash[name]
+        if ret.nil? && self.class.auto_camel_case
+          ret = @raw_hash[name.camelize :lower]
+        end
+      end
+      ret
+    end
+
+    def set_column name, value
+      check_deleted!
+      @updated_hash[name] = value
+    end
+
+    def to_s
+      "<#{parse_class_name}: #{{}.update(@raw_hash).update(@updated_hash).to_s}>"
+    end
+
+    def method_missing name, *args, &block
+      if name =~ /^\w+$/ && args.empty? && block.nil?
+        get_column name
+      elsif name[-1] == '=' && args.size == 1 && block.nil?
+        set_column name[0..-2], args.first
+      else
+        super
+      end
+    end
+
+    private
+
+    def string_keyed_hash hash
+      new_hash = {}
+      hash.each do |k, v|
+        new_hash[k.to_s] = v
+      end
+      new_hash
+    end
+
+    def check_deleted!
+      raise 'This object has already been deleted.' if deleted?
+    end
+  end
+
+  #
+  # create or get ParseObject class in the given module
+  #
+  # == Parameters:
+  # parse_class_name::
+  #   Parse class name
+  # mod::
+  #   module where ParseObject is populated
+  #
+  # == Returns:
+  # subclass of ParseObject for the given parse_class_name
+  #
+  def self.Object parse_class_name, mod=::Object
+    Parse::Object.create parse_class_name, mod \
+      unless mod.const_defined? parse_class_name
+    mod.const_get parse_class_name
+  end
+end

data/lib/parse/pointer.rb

@@ -0,0 +1,25 @@
+# coding:utf-8
+module Parse
+  class Pointer
+    def initialize parse_client, parent_parse_class, parent_hash, parent_key, hash
+      @parse_client = parse_client
+      @parent_parse_class = parent_parse_class
+      @parent_hash = parent_hash
+      @parent_key = parent_key
+      @raw_hash = hash
+    end
+
+    def load &block
+      included_parse_class_name = @raw_hash['className']
+      mod = @parent_parse_class.name.include?('::') ? \
+        eval(@perent_parse_class.name.split('::')[0..-2]) : ::Object
+      included_parse_class = Parse::Object included_parse_class_name, mod
+      @parent_hash[@parent_key] = @parse_client.find(
+        included_parse_class, @raw_hash['objectId']).tap do |real_value|
+        if block
+          block.call real_value
+        end
+      end
+    end
+  end
+end