parsecom 0.1.0 → 0.2.0

data/README.md

@@ -2,6 +2,41 @@
 
 Yet-Another Parse.com Library written in Pure Ruby
 
+**Table of Contents**  *generated with [DocToc](http://doctoc.herokuapp.com/)*
+
+- [Parsecom](#parsecom)
+  - [Usage](#usage)
+    - [Preparing](#preparing)
+    - [Declaring Parse Classes](#declaring-parse-classes)
+    - [Objects](#objects)
+      - [Creating Objects](#creating-objects)
+      - [Retrieving Objects](#retrieving-objects)
+      - [Updating Objects](#updating-objects)
+        - [Counters](#counters)
+        - [Arrays](#arrays)
+        - [Relations](#relations)
+      - [Deleting Objects](#deleting-objects)
+      - [Batch Operations](#batch-operations)
+    - [Queries](#queries)
+      - [Basic Queries](#basic-queries)
+      - [Query Constraints](#query-constraints)
+      - [Queries on Array Values](#queries-on-array-values)
+      - [Relational Queries](#relational-queries)
+      - [Counting Objects](#counting-objects)
+      - [Compound Queries](#compound-queries)
+    - [Users](#users)
+      - [Sign up](#sign-up)
+      - [Log in](#log-in)
+      - [Requesting A Password Reset](#requesting-a-password-reset)
+      - [Retrieving Users](#retrieving-users)
+      - [Updating Users](#updating-users)
+      - [Querying](#querying)
+      - [Deleting Users](#deleting-users)
+      - [Linking Users](#linking-users)
+    - [Roles](#roles)
+      - [Creating Roles](#creating-roles)
+    - [Security](#security)
+
 ## Usage
 
 ### Preparing
@@ -63,9 +98,11 @@ Parse::Object.create :GameScore
 
 It may be suitable for writing code in declarative style.
 
-### Creating Objects
+### Objects
+
+#### Creating Objects
 
-To create new parse object, juse new and save the object.
+To create new parse object, just new and save the object.
 
 ```ruby
 game_score = GameScore.new
@@ -78,7 +115,7 @@ game_score.new? # => false
 game_score.parse_object_id # => 'Ed1nuqPvcm'
 ```
 
-### Retrieving Objects
+#### 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 a query object.
@@ -95,30 +132,15 @@ results = GameScore.find :where => {:objectId => 'Ed1nuqPvcm'}
 result = GameScore.find_by_id 'Ed1nuqPvcm'
 ```
 
-More complex query
+To fetch a child object, you can use the :include parameter.
 
 ```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)
-  }
+results = GameScore.find :where => {:objectId => 'Ed1nuqPvcm'}, :include => 'game'
 ```
 
 To know more about retrieving objects, see spec/parse_query_spec.rb
 
-### Updating Objects
+#### Updating Objects
 
 To update attributes, just update the attribute and save.
 
@@ -135,7 +157,7 @@ the Parse::Client object for it.
 Parse::Client.default.update :GaemScore, 'Ed1nuqPvcm', :score => 73453
 ```
 
-#### Counters
+##### Counters
 
 ```ruby
 game_score = GameScore.find_by_id 'Ed1nuqPvcm'
@@ -143,7 +165,7 @@ game_score.score = Parse::Op::Increment.new 1
 game_score.save
 ```
 
-#### Arrays
+##### Arrays
 
 ```ruby
 game_score = GameScore.find_by_id 'Ed1nuqPvcm'
@@ -151,7 +173,7 @@ game_score.skils = Parse::Op::AddUnique.new 'flying', 'kungfu'
 game_score.save
 ```
 
-#### Relations
+##### Relations
 
 ```ruby
 game_score = GameScore.find_by_id 'Ed1nuqPvcm'
@@ -165,7 +187,7 @@ game_score.opponents = Parse::Op::RemoveRelation.new player.pointer
 game_score.save
 ```
 
-### Deleting Objects
+#### Deleting Objects
 
 ```ruby
 game_score = GameScore.find_by_id 'Ed1nuqPvcm'
@@ -178,7 +200,7 @@ game_score.opponents = Parse::Op::Delete.new
 game_score.save
 ```
 
-### Batch Operations
+#### Batch Operations
 
 ```ruby
 seans_score = GameScore.new 'score' => 1337, 'playerName' => 'Sean Plott'
@@ -191,18 +213,236 @@ end
 result = batch.run
 ```
 
-### Sign up
+### Queries
+
+#### Basic Queries
+
+```ruby
+game_scores = GameScore.find :all
+```
+
+#### Query Constraints
+
+```ruby
+game_scores = GameScore.find :where => {"playerName" => "Sean Plott", "cheatMode" => false}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  column(:score).gte(1000).lte(3000)
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  column(:score).in(1, 3, 5, 7, 9)
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  column(:playerName).nin("Jonathan Walsh", "Dario Wunsch", "Shawn Simon")
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  column(:score).exists
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  column(:score).exists(false)
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  subquery = subquery_for :Team
+  subquery.where {column(:winPct).gt(0.5)}
+  subquery.key = 'city'
+  column(:hometown).select(subquery)
+}
+```
+
+```ruby
+game_scores = GameScore.find :order => 'score'
+```
+
+```ruby
+game_scores = GameScore.find :order => '-score'
+game_scores = GameScore.find :order_desc => 'score'
+```
+
+```ruby
+game_scores = GameScore.find :order => ['score', '-name']
+```
+
+```ruby
+game_scores = GameScore.find :limit => 200, :skip => 400
+```
+
+```ruby
+game_scores = GameScore.find :keys => ['score', 'playerName']
+```
+
+#### Queries on Array Values
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  column(:arrayKey).contains(2)
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  column(:arrayKey).all(2, 3, 4)
+}
+```
+
+#### Relational Queries
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  post = Parse::Object(:Post).new :objectId => '8TOXdXf3tz'
+  column(:post).eq(post)
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  subquery = subquery_for :Post
+  subquery.where do
+    column(:image).exists(true)
+  end
+  column(:post).in_query(subquery)
+}
+```
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  pointer = Parse::Pointer.new('className' => 'Post', 'objectId' => '8TOXdXf3tz')
+  related_to :likes, pointer
+}
+```
+
+#### Counting Objects
+
+TBD
+
+#### Compound Queries
+
+```ruby
+game_scores = GameScore.find :where => proc {
+  or_condition column(:wins).gt(150), column(:wins).lt(5)
+}
+```
+
+### Users
+
+#### Sign up
 
 ```ruby
 user = Parse::User.sign_up 'YOUR USERNAME', 'YOUR PASSWORD'
 ```
 
-### Log in
+#### Log in
 
 ```ruby
 user = Parse::User.log_in 'YOUR USERNAME', 'YOUR PASSWORD'
 ```
 
+#### Requesting A Password Reset
+
+```ruby
+Parse::User.request_password_reset 'your@email.address'
+```
+
+#### Retrieving Users
+
+```ruby
+user = Parse::User.find_by_id :g7y9tkhB7O
+```
+
+#### Updating Users
+
+```ruby
+user = Parse::User.find_by_id :g7y9tkhB7O
+user.phone = '415-369-6201'
+user.save
+```
+
+#### Querying
+
+```ruby
+users = Parse::User.find :all
+```
+
+#### Deleting Users
+
+```ruby
+user = Parse::User.find_by_id :g7y9tkhB7O
+user.delete
+```
+
+#### Linking Users
+
+TBD
+
+### Roles
+
+#### Creating Roles
+
+```ruby
+moderator = Parse::Role.new 'name' => 'Moderators', 'ACL' => Parse::ACL::PUBLIC_READ_ONLY
+moderator.save
+```
+
+```ruby
+moderator = Parse::Role.new 'name' => 'Moderators', 'ACL' => Parse::ACL::PUBLIC_READ_ONLY
+moderator.roles.add Parse::Role.new('objectId' => 'Ed1nuqPvc')
+moderator.users.add Parse::User.new('objectId' => '8TOXdXf3tz')
+moderator.save
+```
+
+#### Retrieving Roles
+
+```ruby
+role = Parse::Role.find_by_id 'mrmBZvsErB'
+role.name # => 'Moderators'
+role.ACL.readable? '*' # => true
+role.ACL.writable? 'role:Administrators' # => true
+```
+
+#### Updating Roles
+
+```ruby
+user1 = Parse::User.new 'objectId' => '8TOXdXf3tz'
+user2 = Parse::User.new 'objectId' => 'g7y9tkhB7O'
+role = Parse::Role.find_by_id 'mrmBZvsErB'
+role.users = Parse::Op::AddRelation.new user1.pointer, user2.pointer
+role.save
+```
+
+```ruby
+removed_role = Parse::Role.new 'objectId' => 'Ed1nuqPvc'
+role = Parse::Role.find_by_id 'mrmBZvsErB'
+role.roles = Parse::Op::RemoveRelation.new removed_role
+role.save
+```
+
+#### Deleting Roles
+
+```ruby
+role = Parse::Role.find_by_id 'mrmBZvsErB'
+role.delete
+```
+
+### Files
+
+TBD
+
 ### Security
 
 If you add an exclamation mark, "!" after the method name, the method is executed by using the master key.

data/lib/parse/acl.rb

@@ -0,0 +1,40 @@
+# coding:utf-8
+module Parse
+  class ACL
+    READ_ONLY = {'read' => true}
+    WRITE_ONLY = {'write' => true}
+    READ_WRITE = {'read' => true, 'write' => true}
+    NONE = {}
+    PUBLIC = '*'
+
+    def initialize hash={}, &block
+      @acl = hash.dup
+      tap &block if block
+    end
+
+    def readable user
+      (@acl[user] ||= {})['read'] = true
+    end
+
+    def readable? user
+      !!(@acl[user] ||= {})['read']
+    end
+
+    def writable user
+      (@acl[user] ||= {})['write'] = true
+    end
+
+    def writable? user
+      !!(@acl[user] ||= {})['write']
+    end
+
+    def to_json *args
+      @acl.to_json
+    end
+
+    PUBLIC_READ_ONLY = self.new PUBLIC => READ_ONLY
+    PUBLIC_WRITE_ONLY = self.new PUBLIC => WRITE_ONLY
+    PUBLIC_READ_WRITE = self.new PUBLIC => READ_WRITE
+    PUBLIC_NONE = self.new PUBLIC => NONE
+  end
+end

data/lib/parse/client.rb

@@ -28,8 +28,20 @@ module Parse
       @http_client = http_client || Parse::HttpClient.new(API_SERVER)
     end
 
+    def canonical_endpoint endpoint
+      case endpoint
+      when %r|/#{API_VERSION}/classes/_User|
+        endpoint.sub %r|/#{API_VERSION}/classes/_User|, "/#{API_VERSION}/users"
+      when %r|/#{API_VERSION}/classes/_Role|
+        endpoint.sub %r|/#{API_VERSION}/classes/_Role|, "/#{API_VERSION}/roles"
+      else
+        endpoint
+      end
+    end
+
     def call_api method, endpoint, body=nil, opt_headers={}, &block
       endpoint = "/#{API_VERSION}/#{endpoint}" unless endpoint[0] == '/'
+      endpoint = canonical_endpoint endpoint
       headers = build_headers opt_headers
       if body.is_a?(Hash)
         body = Hash[*(body.to_a.map{|k, v| [k, URI.encode(v)]}.flatten)].to_json 

data/lib/parse/object.rb

@@ -87,6 +87,8 @@ module Parse
         if v.is_a? Hash
           body_hash[k] = 
             case v['__type']
+            when nil
+              Parse::ACL.new v
             when 'Date'
               Date.parse v['iso']
             when 'File'
@@ -145,6 +147,9 @@ module Parse
       check_deleted!
       hash = string_keyed_hash hash
       @updated_hash.update hash
+      @updated_hash.reject! do |k, v|
+        v.is_a?(Parse::Relation) && !v.changed?
+      end
       method = use_master_key ? :create! : :create
       parse_client.send(method, self.parse_class_name, @updated_hash) do |response|
         @parse_object_id = response['objectId']

data/lib/parse/op/add_relation.rb

@@ -2,7 +2,13 @@ module Parse
   module Op
     class AddRelation
       def initialize *pointers
-        @pointers = pointers
+        @pointers = pointers.map do |p|
+          if p.is_a? Parse::Object
+            p.pointer
+          else
+            p
+          end
+        end
       end
 
       def to_json *args

data/lib/parse/pointer.rb

@@ -16,8 +16,16 @@ module Parse
       @object ||= pointed_parse_class.find_by_id @raw_hash['objectId']
     end
 
-    def to_json
-      %Q|{"__type":"Pointer","className":"#{@raw_hash['className']}","objectId":"#{@raw_hash['objectId']}"}|
+    def to_h
+      {
+        "__type" => "Pointer",
+        "className" => "#{@raw_hash['className']}",
+        "objectId" => "#{@raw_hash['objectId']}"
+      }
+    end
+
+    def to_json *args
+      to_h.to_json
     end
 
     private

data/lib/parse/relation.rb

@@ -5,6 +5,24 @@ module Parse
       @parent_object = parent
       @column_name = column_name
       @raw_hash = hash
+      @added_pointers = []
+      @removed_pointers = []
+    end
+
+    def add item
+      unless @removed_pointers.empty?
+        raise ArgumentError.new('Please save for removed items before adding')
+      end
+      item = item.pointer if item.is_a?(Parse::Object)
+      @added_pointers.push item
+    end
+
+    def remove item
+      unless @added_pointers.empty?
+        raise ArgumentError.new('Please save for added items before removing')
+      end
+      item = item.pointer if item.is_a?(Parse::Object)
+      @removed_pointers.push item
     end
 
     def load parse_client=Parse::Client.default
@@ -18,5 +36,33 @@ module Parse
       end
       @objects
     end
+
+    def changed?
+      (@added_pointers.size + @removed_pointers.size) != 0
+    end
+
+    def to_h
+      if not @added_pointers.empty?
+        {
+          "__op" => "AddRelation",
+          "objects" => @added_pointers.map(&:to_h)
+        }
+      elsif not @removed_pointers.empty?
+        {
+          "__op" => "RemoveRelation",
+          "objects" => @removed_pointers.map(&:to_h)
+        }
+      else
+        {
+          "__op" => "AddRelation",
+          "objects" => [nil]
+        }
+      end
+    end
+
+    def to_json *args
+p to_h
+      to_h.to_json
+    end
   end
 end

data/lib/parse/role.rb

@@ -1,6 +1,50 @@
 # coding:utf-8
 module Parse
   class Role < Object
-    # TODO
+    class << self
+      def parse_class_name
+        '_Role'
+      end
+    end
+
+    def initialize hash
+      super
+
+      #set_column 'roles', RoleItemArray.new(Parse::Role)
+      #set_column 'users', RoleItemArray.new(Parse::User)
+      set_column 'roles', Parse::Relation.new(self, 'roles', {'className' => '_Role'})
+      set_column 'users', Parse::Relation.new(self, 'users', {'className' => '_User'})
+    end
+
+    class RoleItemArray < Array
+      def initialize klass
+        @klass = klass
+      end
+
+      def add item
+        push \
+          case item
+          when String, Symbol
+            @klass.new('objectId' => item).pointer
+          when @klass
+            item.pointer
+          when Pointer
+            super
+          else
+            raise ArgumentError.new("wrong type: #{item.class.name}")
+          end
+      end
+
+      def to_h
+        {
+          "__op" => "AddRelation",
+          "objects" => map {|r| JSON.parse(r.to_json)}
+        }
+      end
+
+      def to_json *args
+        to_h.to_json
+      end
+    end
   end
 end

data/lib/parse/user.rb

@@ -14,6 +14,10 @@ module Parse
       def log_in username, password
         self.new(username, password).log_in
       end
+
+      def request_password_reset email
+        Parse::Client.default.call_api :post, 'requestPasswordReset', "email" => email
+      end
     end
 
     def initialize username=nil, password=nil, hash={}

data/lib/parse/version.rb

@@ -1,3 +1,3 @@
 module Parse
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/parsecom.rb

@@ -11,6 +11,7 @@ require 'parse/ext/string'
 require 'parse/http_client'
 require 'parse/client'
 require 'parse/query'
+require 'parse/acl'
 require 'parse/object'
 require 'parse/user'
 require 'parse/role'

data/spec/fixtures/vcr_cassettes/user_find.yml

@@ -59,7 +59,7 @@ http_interactions:
   recorded_at: Tue, 08 Oct 2013 13:18:37 GMT
 - request:
     method: get
-    uri: https://api.parse.com/1/classes/_User/5VuUwoEe0j
+    uri: https://api.parse.com/1/users/5VuUwoEe0j
     body:
       encoding: US-ASCII
       string: ''

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: parsecom
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-15 00:00:00.000000000 Z
+date: 2013-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -72,6 +72,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/parse/acl.rb
 - lib/parse/batch.rb
 - lib/parse/batch_http_client.rb
 - lib/parse/client.rb