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.
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 when using ParseModel.
If you have any questions or suggestions, email me.
Create a model:
class Post
include ParseModel::Model
fields :title, :body, :author
end
Create an instance:
p = Post.new
p.title = "Why RubyMotion Is Better Than Objective-C"
p.author = "Josh Symonds"
p.body = "trololol"
ParseModel::Model
objects will respond_to?
to all methods available to PFObject
in the Parse iOS SDK. You can also access the PFObject
instance directly with, you guessed it, ParseModel::Model#PFObject
.
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)
# with block:
ParseModel::Cloud.callFunction("myFunction", {"myParam" => "myValue"}) do |result, error|
# do something...
end
# without block:
ParseModel::Cloud.callFunction("myFunction", {"myParam" => "myValue"})
Parse.Cloud.define('trivial', function(request, response) {
response.success(request.params);
});
ParseModel::Cloud.callFunction("trivial", {"foo" => "bar"})
#=> {"foo"=>"bar"}
// implementation of random queries using Parse Cloud Code
// see https://parse.com/questions/random-search-its-possibile for setup details
Parse.Cloud.define('randomNouns', function(request, response) {
var NounMaster = Parse.Object.extend("NounMaster");
var maxQuery = new Parse.Query(NounMaster);
maxQuery.first({
success: function(object) {
var max = object.get("nextWordIndex");
var n = 10;
if(request.params.count) { n = request.params.count; }
var arr = [];
while (arr.length < n) {
arr.push(Math.ceil(Math.random() * max));
}
var indexes = arr;
var Noun = Parse.Object.extend("Noun");
var nounQuery = new Parse.Query(Noun);
nounQuery.containedIn("index", indexes);
nounQuery.find({
success: function(results) {
response.success(results);
}
});
}
});
});
ParseModel::Cloud.callFunction("randomNouns", {"count" => 3})
#=> [#<PFObject:0x9620ee0>, #<PFObject:0x9629430>, #<PFObject:0x9629cd0>]
class User
include ParseModel::User
end
user = User.new
user.username = "adelevie"
user.email = "[email protected]"
user.password = "foobar"
user.signUp
users = User.all # for more User query methods, see: https://parse.com/questions/why-does-querying-for-a-user-create-a-second-user-class
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
.
if User.current_user
@user = User.current_user
end
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:
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
:
`ParseModel::Query` method | Equivalent `PFQuery` method | Parse Documentation |
---|---|---|
`ParseModel::Query#find` | `PFQuery#findObjects` | here |
`ParseModel::Query#find(&block)` | `PFQuery#findObjectsInBackgroundWithBlock` | here |
`ParseModel::Query#getFirst` | `PFQuery#getFirstObject` | here |
`ParseModel::Query#getFirst(&block)` | `PFQuery#getFirstObjectInBackgroundWithBlock` | here |
`ParseModel::Query#get(id)` | `PFQuery#getObjectWithId` | here |
`ParseModel::Query#get(id, &block)` | `PFQuery#getObjectInBackgroundWithId:block:` | here |
`ParseModel::Query#count` | `PFQuery#countObjects` | here |
`ParseModel::Query#count(&block)` | `PFQuery#countObjectsInBackgroundWithBlock` | here |
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.
Either gem install ParseModel
then require 'ParseModel'
in your Rakefile
, OR
gem "ParseModel"
in your Gemfile. (Instructions for Bundler setup with Rubymotion)
Somewhere in your code, such as app/app_delegate.rb
set your API keys:
Parse.setApplicationId("1234567890", clientKey:"abcdefghijk")
To install the Parse iOS SDK in your RubyMotion project, read this and this.
See LICENSE.txt