ParseModel 0.0.3 → 0.0.4

data/README.md

@@ -4,10 +4,7 @@ ParseModel provides an Active Record pattern to your Parse models on RubyMotion.
 
 I'm using ParseModel internally for a project, slowly but surely making it much, much better. When the project is near completion, I'm going to extract additional functionality into the gem.
 
-Some features to expect:
-* Easier queries (`Post.where(:author => @author)`)
-* Associations (`class Post; include Parse::Model; has_one :author; end`)
-* Overall, a much more Ruby-esque API that still leaves full access to all of the features in the Parse iOS SDK
+Expect a much more Ruby-esque API that still leaves full access to all of the features in the Parse iOS SDK. I'm not trying to re-implement features from the Parse iOS SDK, I just want to make them easier to use. Moreover, you should be able to rely on [Parse's iOS docs](https://parse.com/docs/ios/api/) when using ParseModel.
 
 If you have any questions or suggestions, email me.
 
@@ -30,11 +27,29 @@ p = Post.new
 p.title = "Why RubyMotion Is Better Than Objective-C"
 p.author = "Josh Symonds"
 p.body = "trololol"
-p.saveEventually
 ```
 
 `ParseModel::Model` objects will `respond_to?` to all methods available to [`PFObject`](https://parse.com/docs/ios/api/Classes/PFObject.html) in the Parse iOS SDK. You can also access the `PFObject` instance directly with, you guessed it, `ParseModel::Model#PFObject`.
 
+### Saving objects
+
+```ruby
+p = Post.new
+p.author = "Alan"
+
+# save using main thread (blocking)
+p.save
+
+# save eventually (non-blocking)
+p.saveEventually
+
+# save in background with a block
+p.saveInBackgroundWithBlock(lambda do |success, error|
+  # do something...
+end)
+
+```
+
 ### Users
 
 ```ruby
@@ -54,22 +69,87 @@ users.map {|u| u.objectId}.include?(user.objectId) #=> true
 
 `ParseModel::User` delegates to `PFUser` in a very similar fashion as `ParseModel::Model` delegates to `PFOBject`.
 
-### Queries
-
-For now, just use Parse's native methods:
+#### Current User
 
 ```ruby
-query = PFQuery.queryWithClassName("Post")
-query.whereKey("title", equalTo:"Why RubyMotion Is Better Than Objective-C")
-results = query.findObjects
+if User.current_user
+  @user = User.current_user
+end
 ```
 
-Note that this will return an `Array` of `PFObjects`, not `ParseModel::Model` objects. To convert, just pass the `PFObject` instance into `ParseModel::Model#new`:
+### Queries
+
+Parse provides some great ways to query for objects: in the current blocking thread (`PFQuery#findObjects`, or in the background with a block (`PFQuery#findObjectsInBackGroundWithBlock()`).
+
+These method names are a little long and verbose for my taste, so I added a little but of syntactic sugar:
 
 ```ruby
-results.map! {|result| Post.new(result)}
+query = Post.query #=> <ParseModel::Query> ... this is a subclass of PFQuery
+query.whereKey("author", equalTo:"Alan")
+query.find # finds objects in the main thread, like PFQuery#findObjects
+
+# Or run the query in a background thread
+
+query.find do |objects, error|
+  puts "You have #{objects.length} objects of class #{objects.first.class}."
+end
 ```
 
+By passing a two-argument block to `ParseModel::Query#find(&block)`, the query will automatically run in the background, with the code from the given block executing on completion.
+
+Also note that `ParseModel::Query#find` and `ParseModel::Query#find(&block)` return `ParseModel::Model` objects, and not `PFObject`s.
+
+Because I want Parse's documentation to be as relevant as possible, here's how I'm matching up `ParseModel::Query`'s convenience methods to `PFQuery`:
+
+<table>
+  <tr>
+    <th>`ParseModel::Query` method</th>
+    <th>Equivalent `PFQuery` method</th>
+    <th>Parse Documentation</th>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#find`</td>
+    <td>`PFQuery#findObjects`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/findObjects'>here</a></td>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#find(&block)`</td>
+    <td>`PFQuery#findObjectsInBackgroundWithBlock`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/countObjectsInBackgroundWithBlock:'>here</a></td>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#getFirst`</td>
+    <td>`PFQuery#getFirstObject`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObject'>here</a></td>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#getFirst(&block)`</td>
+    <td>`PFQuery#getFirstObjectInBackgroundWithBlock`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObjectInBackgroundWithBlock:'>here</a></td>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#get(id)`</td>
+    <td>`PFQuery#getObjectWithId`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObject'>here</a></td>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#get(id, &block)`</td>
+    <td>`PFQuery#getObjectInBackgroundWithId:block:`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObjectInBackgroundWithBlock:'>here</a></td>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#count`</td>
+    <td>`PFQuery#countObjects`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/countObjects'>here</a></td>
+  </tr>
+  <tr>
+    <td>`ParseModel::Query#count(&block)`</td>
+    <td>`PFQuery#countObjectsInBackgroundWithBlock`</td>
+    <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/countObjectsInBackgroundWithBlock:'>here</a></td>
+  </tr>
+</table>
+
+Essentially, I'm omitting the words "object" and "InBackgroundWithBlock" from `ParseModel`'s method signatures. I think it's a reasonable assumption that it can simply be implied that we're dealing with "objects." If I'm passing a block, it's repetitive to declare that I'm passing a block.
 
 ## Installation
 

data/lib/ParseModel/Model.rb

@@ -1,6 +1,6 @@
 module ParseModel
 
-  module Model
+  class Model
     attr_accessor :PFObject
     
     def initialize(pf_object=nil)

data/lib/ParseModel/User.rb

@@ -37,17 +37,22 @@ module ParseModel
       def field(name)
         @fields
       end
+
+      def current_user
+        if PFUser.currentUser
+          u = new
+          u.PFUser = PFUser.currentUser
+          return u
+        else
+          return nil
+        end
+      end
       
       def get_fields
         @fields ||= []
         @fields
       end
-      
-      def all
-        query = PFQuery.queryForUser
-        users = query.findObjects
-        users
-      end
+
     end
     
     def self.included(base)

data/lib/ParseModel/query.rb

@@ -1,7 +1,7 @@
 module ParseModel
-	class Query < PFQuery
-		
-		def setClassObject(classObject)
+  class Query < PFQuery
+    
+    def setClassObject(classObject)
       @classObject = classObject
     end
 
@@ -15,10 +15,37 @@ module ParseModel
       return self.findObjects.map {|obj| @classObject.new(obj)} unless block_given?
        
       self.findObjectsInBackgroundWithBlock(lambda do |objects, error|
-      	objects = objects.map {|obj| @classObject.new(obj)} if objects
-      	block.call(objects, error)
+        objects = objects.map {|obj| @classObject.new(obj)} if objects
+        block.call(objects, error)
       end)
     end
-	
-	end
+
+    def getFirst(&block)
+      return @classObject.new(self.getFirstObject) unless block_given?
+
+      self.getFirstObjectInBackgroundWithBlock(lambda do |object, error|
+        obj = @classObject.new(object) if object
+        block.call(obj, error)
+      end)
+    end
+
+    def get(id, &block)
+      return @classObject.new(self.getObjectWithId(id)) unless block_given?
+
+      self.getObjectInBackgroundWithId(id, block:lambda do |object, error|
+        obj = @classObject.new(object) if object
+        block.call(obj, error)
+      end)
+    end
+
+    def count(&block)
+      return self.countObjects unless block_given?
+
+      self.countObjectsInBackgroundWithBlock(lambda do |count, error|
+        block.call(count, error)
+      end)
+    end
+
+  end
+
 end

data/lib/ParseModel/version.rb

@@ -1,3 +1,3 @@
 module ParseModel
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ParseModel
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors: