ParseModel 0.0.3 → 0.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/README.md CHANGED
@@ -4,10 +4,7 @@ ParseModel provides an Active Record pattern to your Parse models on RubyMotion.
4
4
 
5
5
  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.
6
6
 
7
- Some features to expect:
8
- * Easier queries (`Post.where(:author => @author)`)
9
- * Associations (`class Post; include Parse::Model; has_one :author; end`)
10
- * Overall, a much more Ruby-esque API that still leaves full access to all of the features in the Parse iOS SDK
7
+ 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.
11
8
 
12
9
  If you have any questions or suggestions, email me.
13
10
 
@@ -30,11 +27,29 @@ p = Post.new
30
27
  p.title = "Why RubyMotion Is Better Than Objective-C"
31
28
  p.author = "Josh Symonds"
32
29
  p.body = "trololol"
33
- p.saveEventually
34
30
  ```
35
31
 
36
32
  `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`.
37
33
 
34
+ ### Saving objects
35
+
36
+ ```ruby
37
+ p = Post.new
38
+ p.author = "Alan"
39
+
40
+ # save using main thread (blocking)
41
+ p.save
42
+
43
+ # save eventually (non-blocking)
44
+ p.saveEventually
45
+
46
+ # save in background with a block
47
+ p.saveInBackgroundWithBlock(lambda do |success, error|
48
+ # do something...
49
+ end)
50
+
51
+ ```
52
+
38
53
  ### Users
39
54
 
40
55
  ```ruby
@@ -54,22 +69,87 @@ users.map {|u| u.objectId}.include?(user.objectId) #=> true
54
69
 
55
70
  `ParseModel::User` delegates to `PFUser` in a very similar fashion as `ParseModel::Model` delegates to `PFOBject`.
56
71
 
57
- ### Queries
58
-
59
- For now, just use Parse's native methods:
72
+ #### Current User
60
73
 
61
74
  ```ruby
62
- query = PFQuery.queryWithClassName("Post")
63
- query.whereKey("title", equalTo:"Why RubyMotion Is Better Than Objective-C")
64
- results = query.findObjects
75
+ if User.current_user
76
+ @user = User.current_user
77
+ end
65
78
  ```
66
79
 
67
- Note that this will return an `Array` of `PFObjects`, not `ParseModel::Model` objects. To convert, just pass the `PFObject` instance into `ParseModel::Model#new`:
80
+ ### Queries
81
+
82
+ 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()`).
83
+
84
+ These method names are a little long and verbose for my taste, so I added a little but of syntactic sugar:
68
85
 
69
86
  ```ruby
70
- results.map! {|result| Post.new(result)}
87
+ query = Post.query #=> <ParseModel::Query> ... this is a subclass of PFQuery
88
+ query.whereKey("author", equalTo:"Alan")
89
+ query.find # finds objects in the main thread, like PFQuery#findObjects
90
+
91
+ # Or run the query in a background thread
92
+
93
+ query.find do |objects, error|
94
+ puts "You have #{objects.length} objects of class #{objects.first.class}."
95
+ end
71
96
  ```
72
97
 
98
+ 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.
99
+
100
+ Also note that `ParseModel::Query#find` and `ParseModel::Query#find(&block)` return `ParseModel::Model` objects, and not `PFObject`s.
101
+
102
+ 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`:
103
+
104
+ <table>
105
+ <tr>
106
+ <th>`ParseModel::Query` method</th>
107
+ <th>Equivalent `PFQuery` method</th>
108
+ <th>Parse Documentation</th>
109
+ </tr>
110
+ <tr>
111
+ <td>`ParseModel::Query#find`</td>
112
+ <td>`PFQuery#findObjects`</td>
113
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/findObjects'>here</a></td>
114
+ </tr>
115
+ <tr>
116
+ <td>`ParseModel::Query#find(&block)`</td>
117
+ <td>`PFQuery#findObjectsInBackgroundWithBlock`</td>
118
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/countObjectsInBackgroundWithBlock:'>here</a></td>
119
+ </tr>
120
+ <tr>
121
+ <td>`ParseModel::Query#getFirst`</td>
122
+ <td>`PFQuery#getFirstObject`</td>
123
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObject'>here</a></td>
124
+ </tr>
125
+ <tr>
126
+ <td>`ParseModel::Query#getFirst(&block)`</td>
127
+ <td>`PFQuery#getFirstObjectInBackgroundWithBlock`</td>
128
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObjectInBackgroundWithBlock:'>here</a></td>
129
+ </tr>
130
+ <tr>
131
+ <td>`ParseModel::Query#get(id)`</td>
132
+ <td>`PFQuery#getObjectWithId`</td>
133
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObject'>here</a></td>
134
+ </tr>
135
+ <tr>
136
+ <td>`ParseModel::Query#get(id, &block)`</td>
137
+ <td>`PFQuery#getObjectInBackgroundWithId:block:`</td>
138
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/getFirstObjectInBackgroundWithBlock:'>here</a></td>
139
+ </tr>
140
+ <tr>
141
+ <td>`ParseModel::Query#count`</td>
142
+ <td>`PFQuery#countObjects`</td>
143
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/countObjects'>here</a></td>
144
+ </tr>
145
+ <tr>
146
+ <td>`ParseModel::Query#count(&block)`</td>
147
+ <td>`PFQuery#countObjectsInBackgroundWithBlock`</td>
148
+ <td><a href='https://parse.com/docs/ios/api/Classes/PFQuery.html#//api/name/countObjectsInBackgroundWithBlock:'>here</a></td>
149
+ </tr>
150
+ </table>
151
+
152
+ 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.
73
153
 
74
154
  ## Installation
75
155
 
@@ -1,6 +1,6 @@
1
1
  module ParseModel
2
2
 
3
- module Model
3
+ class Model
4
4
  attr_accessor :PFObject
5
5
 
6
6
  def initialize(pf_object=nil)
@@ -37,17 +37,22 @@ module ParseModel
37
37
  def field(name)
38
38
  @fields
39
39
  end
40
+
41
+ def current_user
42
+ if PFUser.currentUser
43
+ u = new
44
+ u.PFUser = PFUser.currentUser
45
+ return u
46
+ else
47
+ return nil
48
+ end
49
+ end
40
50
 
41
51
  def get_fields
42
52
  @fields ||= []
43
53
  @fields
44
54
  end
45
-
46
- def all
47
- query = PFQuery.queryForUser
48
- users = query.findObjects
49
- users
50
- end
55
+
51
56
  end
52
57
 
53
58
  def self.included(base)
@@ -1,7 +1,7 @@
1
1
  module ParseModel
2
- class Query < PFQuery
3
-
4
- def setClassObject(classObject)
2
+ class Query < PFQuery
3
+
4
+ def setClassObject(classObject)
5
5
  @classObject = classObject
6
6
  end
7
7
 
@@ -15,10 +15,37 @@ module ParseModel
15
15
  return self.findObjects.map {|obj| @classObject.new(obj)} unless block_given?
16
16
 
17
17
  self.findObjectsInBackgroundWithBlock(lambda do |objects, error|
18
- objects = objects.map {|obj| @classObject.new(obj)} if objects
19
- block.call(objects, error)
18
+ objects = objects.map {|obj| @classObject.new(obj)} if objects
19
+ block.call(objects, error)
20
20
  end)
21
21
  end
22
-
23
- end
22
+
23
+ def getFirst(&block)
24
+ return @classObject.new(self.getFirstObject) unless block_given?
25
+
26
+ self.getFirstObjectInBackgroundWithBlock(lambda do |object, error|
27
+ obj = @classObject.new(object) if object
28
+ block.call(obj, error)
29
+ end)
30
+ end
31
+
32
+ def get(id, &block)
33
+ return @classObject.new(self.getObjectWithId(id)) unless block_given?
34
+
35
+ self.getObjectInBackgroundWithId(id, block:lambda do |object, error|
36
+ obj = @classObject.new(object) if object
37
+ block.call(obj, error)
38
+ end)
39
+ end
40
+
41
+ def count(&block)
42
+ return self.countObjects unless block_given?
43
+
44
+ self.countObjectsInBackgroundWithBlock(lambda do |count, error|
45
+ block.call(count, error)
46
+ end)
47
+ end
48
+
49
+ end
50
+
24
51
  end
@@ -1,3 +1,3 @@
1
1
  module ParseModel
2
- VERSION = "0.0.3"
2
+ VERSION = "0.0.4"
3
3
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: ParseModel
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.0.3
4
+ version: 0.0.4
5
5
  prerelease:
6
6
  platform: ruby
7
7
  authors: