parsecom 0.0.1

data/lib/parse/query.rb

@@ -0,0 +1,286 @@
+module Parse
+  class Query
+    attr_reader :keys
+    attr_accessor :parse_class_name, :parse_client
+
+    def initialize parse_class_or_name=nil
+      @parse_class, @parse_class_name, @parse_client = 
+        parse_class_or_name === Parse::Object \
+          ? [parse_class_or_name, parse_class_or_name.parse_class_name, 
+              parse_class_or_name.parse_client]
+          : [nil, parse_class_or_name.to_s, Parse::Client.default_client]
+      @limit = nil
+      @skip = nil
+      @count = false
+      @where = []
+      @order = []
+      @include = []
+      @keys = []
+    end
+
+    def invoke &block
+      block = proc do |body| 
+        # TODO: should handle error
+        body['results']
+      end unless block
+      endpoint = %w(User).include?(@parse_class_name) \
+        ? "#{@parse_class_name.lowercase}s" 
+        : "classes/#{@parse_class_name}"
+      @parse_client.call_api :get, "#{endpoint}?#{to_params}", nil, &block
+    end
+
+    def limit val=nil
+      if val
+        @limit = val
+      else
+        @limit
+      end
+      self
+    end
+
+    def skip val=nil
+      if val
+        @skip = val
+      else
+        @skip
+      end
+      self
+    end
+
+    def count val=nil
+      if val
+        @count = val
+      else
+        @count
+      end
+      self
+    end
+
+    def where hash=nil, &block
+      return @where if hash.nil? && block.nil?
+
+      if hash.is_a? Hash
+        hash.each do |k, v|
+          @where << %Q|"#{k}":"#{v}"|
+        end
+      else
+        block = hash if hash.is_a?(Proc) && block.nil?
+        instance_eval &block if block
+      end
+      self
+    end
+
+    def order *vals
+      return @order if vals.empty?
+      @order += vals
+      self
+    end
+    alias order_asc order
+
+    def order_desc *vals
+      order *(vals.map do |val|
+        val[0] == '-' ? val[1..-1] : "-#{val}"
+      end)
+    end
+
+    def keys *vals
+      return @keys if vals.empty?
+      @keys += vals
+      self
+    end
+
+    def include *vals
+      return @include if vals.empty?
+      @include += vals
+    end
+
+    def to_params
+      params = []
+
+      where = @where.join ','
+      order = @order.join ','
+      keys = @keys.join ','
+      include = @include.join ','
+      params.push "where=#{URI.encode "{#{where}}"}" unless where.empty?
+      params.push "order=#{URI.encode order}" unless order.empty?
+      params.push "keys=#{URI.encode keys}" unless keys.empty?
+      params.push "include=#{URI.encode include}" unless include.empty?
+      params.push "skip=#{URI.encode @skip.to_s}" if @skip
+      params.push "limit=#{URI.encode @limit.to_s}" if @limit
+
+      params.join '&'
+    end
+
+    def inspect
+      "#{@parse_class_name}, #{to_params}"
+    end
+
+    private
+
+    def column name
+      Condition.new(self, name).tap do |condition|
+        @where.push condition
+      end
+    end
+    alias _ column
+
+    def subquery_for parse_class_name
+      Subquery.new parse_class_name
+    end
+
+    def or_condition *conds
+      conds.each do |cond|
+        @where.delete cond
+      end
+      OrCondition.new(conds).tap do |condition|
+        @where.push condition
+      end
+    end
+    alias _or_ or_condition
+
+    class Subquery < Query
+      attr_accessor :parent
+
+      def initialize parse_class_name=nil
+        super
+        @key = nil
+      end
+
+      def key= val
+        @key = val
+        self
+      end
+      alias key key=
+
+      def inspect
+        # TODO should be refactored
+        case @parent
+        when :select
+          %Q|{"query":{"className":#{parse_class_name.to_s.inspect},"where":{#{@where.join ','}}},"key":#{@key.inspect}}|
+        when :in_query, :not_in_query
+          %Q|{"where":{#{@where.join ','}},"className":#{parse_class_name.to_s.inspect}}|
+        end
+      end
+    end
+
+    class Condition
+      def initialize query, column_name
+        @query = query
+        @column_name = column_name
+        @conditions = []
+      end
+
+      # receive nop
+      %w(eq contains).each do |op|
+        eval %Q{
+          def #{op} val
+            @conditions.push val
+            self
+          end
+        }
+      end
+      alias equal_to eq
+
+      # receive single param
+      %w(lt lte gt gte ne).each do |op|
+        eval %Q{
+          def #{op} val
+            @conditions.push ['$#{op}', val]
+            self
+          end
+        }
+      end
+      alias less_than lt
+      alias less_that_or_equal_to lte
+      alias greater_than gt
+      alias greater_that_or_equal_to gte
+      alias not_equal_to ne
+
+      def exists val=true
+        @conditions.push ['$exists', val]
+        self
+      end
+
+      # receive multi params
+      %w(in nin all).each do |op|
+        eval %Q{
+          def #{op} *vals
+            @conditions.push ['$#{op}', vals]
+            self
+          end
+        }
+      end
+      alias not_in nin
+
+      # receive subquery
+      %w(select dont_select in_query not_in_query).each do |op|
+        eval %Q{
+          def #{op} subquery
+            subquery.parent = :#{op}
+            @conditions.push ['$#{op.camelize :lower}', subquery]
+            self
+          end
+        }
+      end
+
+      def or cond
+        # quite dirty!!
+        @query.where.delete self
+        @query.where.delete cond
+        or_cond = Condition.new @query, '$or'
+        or_cond.eq [self, cond]
+        @query.where.push or_cond
+      end
+
+      def to_s
+        if @conditions.size == 1 && !@conditions[0].is_a?(Array)
+          "#{@column_name.to_s.inspect}:#{condition_to_s @conditions[0]}"
+        elsif @conditions.size == 1 && @conditions[0][0].to_s[0] != '$'
+          # $or
+          "#{@column_name.to_s.inspect}:#{condition_to_s @conditions[0]}"
+        else
+          "#{@column_name.to_s.inspect}:{#{@conditions.map{|c| condition_to_s c}.join ','}}"
+        end
+      end
+
+      private
+
+      def condition_value_to_s val
+        case val
+        when Parse::Object
+          %Q|{"__type":"Pointer","className":"#{val.parse_class_name}","objectId":"#{val.obj_id}"}|
+        else
+          val.inspect
+        end
+      end
+
+      def condition_to_s condition
+        case condition
+        when Array
+          if condition[0].to_s[0] == '$'
+            "#{condition[0].inspect}:#{condition_value_to_s condition[1]}"
+          else
+            # $or
+            "[#{condition.map{|c| "{#{condition_value_to_s c}}"}.join ','}]"
+          end
+        else
+          condition_value_to_s condition
+        end
+      end
+    end
+
+    class OrCondition
+      def initialize conds
+        @conditions = conds
+      end
+
+      def to_s
+        %Q|"$or":[#{@conditions.map {|c| "{#{c.to_s}}"}.join ','}]|
+      end
+    end
+  end
+
+  def Query parse_class_name=nil
+    Query.new parse_class_name
+  end
+end

data/lib/parse/user.rb

@@ -0,0 +1,47 @@
+# coding:utf-8
+module Parse
+  class User < Object
+
+    class << self
+      def sign_up username, password, hash={}
+        self.new(username, password, hash).sign_up
+      end
+      
+      def log_in username, password
+        self.new(username, password).log_in
+      end
+    end
+
+    def initialize username, password, hash={}
+      super hash
+      @username = username
+      @password = password
+    end
+
+    def sign_up
+      parse_client.sign_up @username, @password, opts do |resp_body|
+        @obj_id = resp_body['objectId']
+        @created_at = resp_body['createdAt']
+        @raw_hash.update(@updated_hash).update resp_body
+        @updated_hash.clear
+        parse_client.session_token = resp_body['sessionToken']
+        self
+      end
+    end
+
+    def log_in
+      parse_client.log_in @username, @password do |resp_body|
+        @obj_id = resp_body['objectId']
+        @created_at = resp_body['createdAt']
+        @updated_at = resp_body['updatedAt']
+        @raw_hash.update(@updated_hash).update resp_body
+        @updated_hash.clear
+        parse_client.session_token = resp_body['sessionToken']
+        self
+      end
+    end
+
+    def log_out
+    end
+  end
+end

data/lib/parse/version.rb

@@ -0,0 +1,3 @@
+module Parse
+  VERSION = "0.0.1"
+end

data/lib/parsecom.rb

@@ -0,0 +1,58 @@
+# coding:utf-8
+require "parse/version"
+
+require 'open-uri'
+require 'fileutils'
+require 'json'
+require 'date'
+require 'net/https'
+require 'uri'
+require 'parse/ext/string'
+require 'parse/http_client'
+require 'parse/client'
+require 'parse/query'
+require 'parse/object'
+require 'parse/user'
+require 'parse/pointer'
+require 'parse/file'
+
+module Parse
+  @@application_id = nil
+  @@api_key = nil
+  @@auto_snake_case = false
+
+  module_function
+
+  def application_id
+    @@application_id
+  end
+
+  def application_id= application_id
+    @@application_id = application_id
+  end
+
+  def api_key
+    @@api_key
+  end
+
+  def api_key= api_key
+    @@api_key = api_key
+  end
+
+  def credentials hash
+    @@application_id = hash[:application_id]
+    @@api_key = hash[:api_key]
+  end
+
+  def credentials= hash
+    credentials hash
+  end
+
+  def auto_snake_case
+    @@auto_snake_case
+  end
+
+  def auto_snake_case= auto_snake_case
+    @@auto_snake_case = auto_snake_case
+  end
+end

data/parsecom.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'parse/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "parsecom"
+  gem.version       = Parse::VERSION
+  gem.authors       = ["Ando Yasushi"]
+  gem.email         = ["andyjpn@gmail.com"]
+  gem.description   = %q{Pure Ruby version of parse.com client. This library allow you to access straightforwardly to parse.com REST API.}
+  gem.summary       = %q{Pure Ruby version of parse.com client}
+  gem.homepage      = "https://github.com/technohippy/parsecom"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+ 
+  gem.add_development_dependency "rspec"
+end

data/spec/parse_object_spec.rb

@@ -0,0 +1,54 @@
+# coding:utf-8
+require 'spec_helper'
+
+# define a parse class
+class ClassA < Parse::Object; end
+# you can also write:
+#   Parse::Object(:ClassA)
+# or
+#   Parse::Object.create :ClassA
+
+describe Parse::Object, 'when it defines a parse class' do
+  it 'should return a new class' do
+    Parse::Object(:ClassB).should be_a_kind_of(Class)
+    ClassB.should be < Parse::Object
+  end
+
+  it 'should return the existing class' do
+    Parse::Object(:ClassA).should == ClassA
+  end
+
+  it 'should also return a new class' do
+    Parse::Object.create :ClassC
+    ClassC.should be_a_kind_of(Class)
+    ClassC.should be < Parse::Object
+  end
+
+  it 'should raise an error when creating an existing class' do
+    expect {
+      Parse::Object.create :ClassB
+    }.to raise_error 
+  end
+end
+
+describe Parse::Object, 'when it creates a new parse object' do
+  it 'should create a parse object' do
+    class_a = ClassA.new
+    class_a.columnA = 'Hello, parse.com'
+    class_a.new?.should be_true
+    class_a.save
+    class_a.new?.should be_false
+
+    class_a2 = ClassA.find class_a.obj_id
+    class_a2.columnA.should eql('Hello, parse.com')
+
+    class_as = ClassA.find :where => proc{column(:columnB).gt 5},
+      :order => 'createdAt', :keys => 'columnB', :limit => 3
+    class_as.size.should == 3
+
+    class_a = ClassA.find :where => {'objectId' => 'avp6UKaG1k'},
+      :order => 'createdAt', :keys => 'columnB', :limit => 3
+    class_a.size.should == 1
+  end
+end
+

data/spec/parse_query_spec.rb

@@ -0,0 +1,176 @@
+# coding:utf-8
+require 'spec_helper'
+require 'parsecom'
+
+describe Parse::Query, 'when it builds conditions' do
+  it 'should build a correct "where" parameter' do
+    query = Parse::Query.new ClassA
+    query.to_params.should be_empty
+
+    query.where :column1 => 'val1'
+    query.to_params.should have_params('where' => '{"column1":"val1"}')
+
+    query.where.clear
+    query.to_params.should be_empty
+
+    query.where :column1 => 'val1', :column2 => 'val2'
+    query.to_params.should have_params('where' => '{"column1":"val1","column2":"val2"}')
+
+    query.where :column3 => 'val3'
+    query.to_params.should have_params('where' => '{"column1":"val1","column2":"val2","column3":"val3"}')
+
+    query.where.clear
+
+    query.where do
+      column(:playerName).eq('Sean Plott')
+      column(:cheatMode).eq(false)
+    end
+    query.to_params.should have_params('where' => '{"playerName":"Sean Plott","cheatMode":false}')
+    query.where.clear
+
+    query.where do
+      column(:score).gte(1000).lte(3000)
+    end
+    query.to_params.should have_params('where' => '{"score":{"$gte":1000,"$lte":3000}}')
+    query.where.clear
+
+    query.where do
+      column(:score).in(1, 3 ,5, 7, 9)
+    end
+    query.to_params.should have_params('where' => '{"score":{"$in":[1, 3, 5, 7, 9]}}')
+    query.where.clear
+
+    query.where do
+      column(:playerName).nin("Jonathan Walsh","Dario Wunsch","Shawn Simon")
+    end
+    query.to_params.should have_params('where' => '{"playerName":{"$nin":["Jonathan Walsh", "Dario Wunsch", "Shawn Simon"]}}')
+    query.where.clear
+
+    query.where do
+      column(:score).exists(true)
+    end
+    query.to_params.should have_params('where' => '{"score":{"$exists":true}}')
+    query.where.clear
+
+    query.where do
+      column(:score).exists(false)
+    end
+    query.to_params.should have_params('where' => '{"score":{"$exists":false}}')
+    query.where.clear
+
+    query.where do
+      subquery = subquery_for :Team
+      subquery.where do
+        column(:winPct).gt(0.5)
+      end
+      subquery.key = 'city'
+      column(:hometown).select(subquery)
+    end
+    query.to_params.should have_params('where' => '{"hometown":{"$select":{"query":{"className":"Team","where":{"winPct":{"$gt":0.5}}},"key":"city"}}}')
+    query.where.clear
+
+    query.where do
+      column(:arrayKey).contains(2)
+    end
+    query.to_params.should have_params('where' => '{"arrayKey":2}')
+    query.where.clear
+
+    query.where do
+      column(:arrayKey).all(2,3,4)
+    end
+    query.to_params.should have_params('where' => '{"arrayKey":{"$all":[2, 3, 4]}}')
+    query.where.clear
+
+    query.where do
+      post = Parse::Object(:Post).new :objectId => '8TOXdXf3tz'
+      column(:post).eq(post)
+    end
+    query.to_params.should have_params('where' => '{"post":{"__type":"Pointer","className":"Post","objectId":"8TOXdXf3tz"}}')
+    query.where.clear
+
+    query.where do
+      subquery = subquery_for :Post
+      subquery.where do
+        column(:image).exists(true)
+      end
+      column(:post).in_query(subquery)
+    end
+    query.to_params.should have_params('where' => '{"post":{"$inQuery":{"where":{"image":{"$exists":true}},"className":"Post"}}}')
+    query.where.clear
+
+    query.where do
+      subquery = subquery_for :Post
+      subquery.where do
+        column(:image).exists(true)
+      end
+      column(:post).not_in_query(subquery)
+    end
+    query.to_params.should have_params('where' => '{"post":{"$notInQuery":{"where":{"image":{"$exists":true}},"className":"Post"}}}')
+    query.where.clear
+
+#    query.where do
+#      #{
+#      #  "$relatedTo":{
+#      #    "object":{
+#      #      "__type":"Pointer",
+#      #      "className":"Post",
+#      #      "objectId":"8TOXdXf3tz"
+#      #    },
+#      #    "key":"likes"
+#      #  }
+#      #}
+#      # TODO
+#    end
+#    query.to_params.should == 'where={}'
+#    query.where.clear
+
+    query.where do
+      column(:wins).gt(150).or column(:wins).lt(5)
+    end
+    query.to_params.should have_params('where' => '{"$or":[{"wins":{"$gt":150}},{"wins":{"$lt":5}}]}')
+    query.where.clear
+
+    query.where do
+      or_condition column(:wins).gt(150), column(:wins).lt(5)
+    end
+    query.to_params.should have_params('where' => '{"$or":[{"wins":{"$gt":150}},{"wins":{"$lt":5}}]}')
+    query.where.clear
+
+    query.where do
+      or_condition column(:wins).gt(150), column(:wins).lt(5), column(:loses).lt(5)
+    end
+    query.to_params.should have_params('where' => '{"$or":[{"wins":{"$gt":150}},{"wins":{"$lt":5}},{"loses":{"$lt":5}}]}')
+    query.where.clear
+  end
+  
+  it 'should build a correct "order" parameter' do
+    query = Parse::Query.new ClassA
+    query.order 'score', '-name'
+    query.to_params.should == 'order=score,-name'
+    query.order.clear
+
+    query.order_desc '-score', 'name'
+    query.to_params.should == 'order=score,-name'
+    query.order.clear
+
+    query.order 'score'
+    query.order_desc 'name'
+    query.to_params.should == 'order=score,-name'
+    query.order.clear
+  end
+
+  it 'should success request' do
+    query = Parse::Query.new(ClassA).
+      order('createdAt').
+      keys('columnB').
+      limit(3).
+      where {column(:columnB).gt 5}
+    # query.invoke
+    query.to_params.should have_params(
+      'order' => 'createdAt', 
+      'keys' => 'columnB', 
+      'limit' => 3, 
+      'where' => '{"columnB":{"$gt":5}}'
+    )
+  end
+end

data/spec/parse_user_spec.rb

@@ -0,0 +1,23 @@
+# coding:utf-8
+require 'spec_helper'
+
+describe Parse::User, 'when it signs up' do
+  it 'should create new user' do
+    user = Parse::User.sign_up "username#{rand 1000}", 'password'
+    user.obj_id.should be_an_instance_of String
+    user.parse_client.session_token.should be_an_instance_of String
+  end
+end
+
+describe Parse::User, 'when it logs in' do
+  it 'should get the session token' do
+    user = Parse::User.log_in 'username', 'password'
+    user.obj_id.should be_an_instance_of String
+    user.parse_client.session_token.should be_an_instance_of String
+  end
+end
+
+describe Parse::User, 'when it logs out' do
+  it 'should get the session token' do
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+
+RSpec::Matchers.define :have_params do |expected|
+  match do |actual|
+    expected.to_a.map do |k, v|
+      actual.include? "#{k}=#{URI.encode v.to_s}"
+    end.inject(true) {|s, v| s || v}
+  end
+end
+
+require 'parsecom'
+# setup Parse object
+Parse.credentials application_id: ENV['APPLICATION_ID'], api_key: ENV['API_KEY']
+#puts('set your credentials in spec/spec_helper.rb and remove this line') || exit