Parsistence 0.2.1 → 0.3.0

data/README.md

@@ -52,7 +52,7 @@ users.map {|u| u.objectId}.include?(user.objectId) #=> true
 Queries use a somewhat different pattern than ActiveRecord but are relatively familiar. They are most like persistence.js.
 
 ```ruby
-Car.eq(license: "ABC-123", model: "Camry").order(year: :desc).limit(25).fetch do |cars, error|
+Car.eq(license: "ABC-123", model: "Camry").order(year: :desc).limit(25).fetchAll do |cars, error|
   if cars
     cars.each do |car|
       # `car` is an instance of your `Car` model here.
@@ -66,21 +66,101 @@ Chain multiple conditions together, even the same condition type multiple times,
 ####Available Conditions
 (note: each condition can take multiple comma-separated fields and values)
 
-**eq:** Check if equal the passed in values.
-
-**notEq:** Check if NOT equal to the passed in values.
-
-**gt:** Check if greater than the passed in values.
-
-**lt:** Check if less than the passed in values.
-
-**gte:** Check if greater or equal to than the passed in values.
-
-**lte:** Check if less than or equal to the passed in values.
-
-**order:** Order by one or more fields. Specify :asc or :desc.
-
-**limit:** Limit is slightly different...it takes either one argument (limit) or two (offset, limit).
+<table>
+  <tr>
+    <th>Method</th>
+    <th>Effect</th>
+    <th>Example</th>
+  </tr>
+
+  <tr>
+    <td>eq</td>
+    <td>Equal to</td>
+    <td>
+      <pre>
+Tree.eq(name: "Fir").fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+
+  <tr>
+    <td>notEq</td>
+    <td>NOT equal to</td>
+    <td>
+      <pre>
+Tree.notEq(name: "Fir").fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+
+  <tr>
+    <td>gt</td>
+    <td>Greater than</td>
+    <td>
+      <pre>
+Tree.gt(height: 10).fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+
+  <tr>
+    <td>lt</td>
+    <td>Less than</td>
+    <td>
+      <pre>
+Tree.lt(height: 10).fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+
+  <tr>
+    <td>gte</td>
+    <td>Greater than or equal to</td>
+    <td>
+      <pre>
+Tree.gte(height: 10).fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+
+  <tr>
+    <td>lte</td>
+    <td>Less than or equal to</td>
+    <td>
+      <pre>
+Tree.lte(height: 10).fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+
+  <tr>
+    <td>order</td>
+    <td>Order by one or more fields (:asc/:desc).</td>
+    <td>
+      <pre>
+Tree.order(height: :asc).fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+
+  <tr>
+    <td>limit</td>
+    <td>Limit and offset.</td>
+    <td>
+      <pre>
+Tree.limit(25, 10).fetchAll do |trees|
+  ...
+end</pre>
+    </td>
+  </tr>
+</table>
 
 ### Relationships
 
@@ -92,7 +172,7 @@ class Post
 
   fields :title, :body, :author
 
-  relations :author
+  belongs_to :author # Must be a "pointer" object on Parse.com
 end
 
 Author.where(name: "Jamon Holmgren").fetchOne do |fetchedAuthor, error|

data/lib/Parsistence/Model.rb

@@ -11,32 +11,30 @@ module Parsistence
         self.PFObject = PFObject.objectWithClassName(self.class.to_s)
       end
 
-      # setupRelations unless pf
-
       self
     end
-
-    # This code is to correct for a bug where relations aren't initialized when creating a new instance
-    # def setupRelations
-    #   relations.each do |r|
-    #     self.send("#{r}=", @PFObject.relationforKey(r))
-    #   end
-    # end
     
     def method_missing(method, *args, &block)
       method = method.to_sym
-      if fields.include?(method)
-        return getField(method)
-      elsif fields.map { |f| "#{f}=".include?(method)} 
-        method = method.split("=")[0]
+      setter = false
+      
+      if method.to_s.include?("=")
+        setter = true
+        method = method.split("=")[0].to_sym
+      end
+
+      # Setters
+      if relations.include?(method) && setter
+        return setRelation(method, args.first)
+      elsif fields.include?(method) && setter
         return setField(method, args.first)
-      elsif relations.include?(method)
+      # Getters
+      elsif relations.include? method
         return getRelation(method)
-      elsif relations.map {|r| "#{r}=".include?(method)}
-        method = method.split("=")[0]
-        return setRelation(method, args.first)
-      elsif @PFObject.respond_to?(method)
-        return @PFObject.send(method, *args, &block)
+      elsif fields.include? method
+        return getField(method)
+      elsif self.PFObject.respond_to?(method)
+        return self.PFObject.send(method, *args, &block)
       else
         super
       end
@@ -64,18 +62,33 @@ module Parsistence
     end
 
     def getRelation(field)
-      return @PFObject.objectForKey(field) if relations.include? field.to_sym
-      raise "Parsistence Exception: Invalid relation name #{field} for object #{self.class.to_s}"
+      if has_many.include?(field.to_sym)
+        relation = @PFObject.objectForKey(field) if relations.include? field.to_sym
+        # This is not implemented yet
+        # return @relation[field] ||= begin
+        #   r = Relation.new(relation)
+        #   r.klass = self
+        #   r.belongs_to = true
+        #   r
+        # end
+        raise "Parsistence Exception: has_many relationships aren't implemented yet. Use a regular query instead."
+      elsif belongs_to.include?(field.to_sym)
+        return self.getField(field)
+      else
+        raise "Parsistence Exception: Invalid relation name #{field} for object #{self.class.to_s}"
+      end
     end
 
     def setRelation(field, value)
       value = value.PFObject if value.respond_to? :PFObject # unwrap object
-      # return setRelation(field, value) # This SHOULD work
-      
-      relation = @PFObject.relationforKey(field)
+      if has_many.include?(field.to_sym)
+        relation = @PFObject.relationforKey(field)
+        return relation.addObject(value) if relations.include? field.to_sym
+      elsif belongs_to.include?(field.to_sym)
+        return setField(field, value)
+      end
       
-      return relation.addObject(value) if relations.include? field.to_sym
-      raise "Parsistence Exception: Invalid relation name #{field} for object #{self.class.to_s}" unless relations.include? relation.to_sym
+      raise "Parsistence Exception: Invalid relation name #{field} for object #{self.class.to_s}"
     end
 
     def attributes
@@ -88,7 +101,9 @@ module Parsistence
 
     def attributes=(hashValue)
       hashValue.each do |k, v|
-        if self.respond_to? "#{k}="
+        if v.respond_to?(:each) && !v.is_a?(PFObject)
+          self.attributes = v
+        elsif self.respond_to? "#{k}="
           self.send("#{k}=", v) 
         else
           setField(k, v) unless k.nil?
@@ -99,11 +114,17 @@ module Parsistence
     def save
       saved = false
       unless before_save == false
+        reset_errors
         self.attributes.each do |field, value|
           validateField field, value
         end
 
-        saved = @PFObject.save
+        if @errors && @errors.length > 0
+          saved = false
+        else
+          saved = @PFObject.save
+        end
+
         after_save if saved
       end
       saved
@@ -114,18 +135,52 @@ module Parsistence
 
     # Validations
     def presenceValidations
-      self.class.send(:get_presenceValidations)
+      self.class.send(:get_presence_validations)
+    end
+
+    def presenceValidationMessages
+      self.class.send(:get_presence_validation_messages)
+    end
+
+    def has_many
+      self.class.send(:get_has_many)
+    end
+
+    def belongs_to
+      self.class.send(:get_belongs_to)
     end
 
     def validateField(field, value)
       @errors ||= {}
-      @errors[field] = "#{field} can't be blank" if presenceValidations.include?(field) && value.nil? || value == ""
+      if presenceValidations.include?(field) && value.nil? || value == ""
+        messages = presenceValidationMessages
+        if messages.include?(field) 
+          @errors[field] = messages[field]
+        else
+          @errors[field] = "#{field} can't be blank" 
+        end
+      end
     end
 
     def errorForField(field)
       @errors[field] || false
     end
 
+    def errors
+      @errors
+    end
+
+    def valid?
+      self.errors.nil? || self.errors.length == 0
+    end
+
+    def invalid?
+      !self.valid?
+    end
+
+    def reset_errors
+      @errors = nil
+    end
 
     module ClassMethods
       def fields(*args)
@@ -139,7 +194,7 @@ module Parsistence
       end
       
       def get_fields
-        @fields
+        @fields ||= []
       end
 
       def relations(*args)
@@ -156,12 +211,52 @@ module Parsistence
         @relations ||= []
       end
 
-      def validates_presence_of(*args)
-        args.each {|arg| validate_presence(arg)}
+      def has_many(field, args={})
+        relation(field)
+
+        @has_many ||= []
+        @has_many << field
+        @has_many.uniq!
+
+        @has_many_attributes ||= {}
+        @has_many_attributes[field] = args
+      end
+
+      def get_has_many
+        @has_many ||= []
       end
 
-      def get_presenceValidations
-        @presenceValidations ||= []
+      def belongs_to(field, args={})
+        relation(field)
+
+        @belongs_to ||= []
+        @belongs_to << field
+        @belongs_to.uniq!
+
+        @belongs_to_attributes ||= {}
+        @belongs_to_attributes[field] = args
+      end
+
+      def get_belongs_to
+        @belongs_to ||= []
+      end
+
+      def get_belongs_to_attributes(field)
+        @belongs_to_attributes[field] ||= { class_name: field }
+      end
+
+      def validates_presence_of(field, opts={})
+        @presenceValidationMessages ||= {}
+        @presenceValidationMessages[field] = opts[:message] if opts[:message]
+        validate_presence(field)
+      end
+
+      def get_presence_validations
+        @presenceValidations ||= {}
+      end
+      
+      def get_presence_validation_messages
+        @presenceValidationMessages ||= {}
       end
 
       def validate_presence(field)

data/lib/Parsistence/Query.rb

@@ -1,21 +1,43 @@
 module Parsistence
   module Model
     module ClassMethods
-      QUERY_STUBS = [ :fetch, :where, :first, :limit, :order, :eq, :notEq, :lt, :gt, :lte, :gte ] # :limit is different
+      QUERY_STUBS = [ :where, :first, :limit, :order, :eq, :notEq, :lt, :gt, :lte, :gte ] # :limit is different
+
+      def fetchAll(&block)
+        q = Parsistence::Query.new
+        q.klass = self
+        return q.fetchAll &block
+      end
+
+      def fetchOne(&block)
+        q = Parsistence::Query.new
+        q.klass = self
+        q.limit(1).fetchAll &block
+      end
+
+      def all(&block)
+        fetchAll(&block)
+      end
 
       def method_missing(method, *args, &block)
-        if method == :limit
-          return self.limit(args.first) if args.length == 1
-          return self.limit(args.first, args.last)
+        if method == :limit && args.length == 2
+          q = Parsistence::Query.new
+          q.klass = self
+          return q.send(method, args[0], args[1])
+        elsif QUERY_STUBS.include? method.to_sym && args.length == 0
+          q = Parsistence::Query.new
+          q.klass = self
+          return q.send(method, &block) if block_given?
+          return q.send(method)
         elsif QUERY_STUBS.include? method.to_sym
           q = Parsistence::Query.new
           q.klass = self
-          return q.send(method, args.first, &block) if block
+          return q.send(method, args.first, &block) if block_given?
           return q.send(method, args.first)
         elsif method.start_with?("find_by_")
-          attribute = method.gsub("find_by_", "")
-          cond[attribute] = args.first
-          return self.limit(1).where(cond, block)
+          # attribute = method.gsub("find_by_", "")
+          # cond[attribute] = args.first
+          # return self.limit(1).where(cond, block)
         elsif method.start_with?("find_all_by_")
           # attribute = method.gsub("find_all_by_", "")
           # cond[attribute] = args.first
@@ -218,6 +240,7 @@ module Parsistence
       fields.each do |field|
         @includes << field
       end
+      self
     end
   end
 end

data/lib/Parsistence/Relation.rb

@@ -0,0 +1,28 @@
+# module Parsistence
+#   class Relation
+#     attr_accessor :PFRelation, :belongs_to, :klass
+    
+#     def initialize(pf_relation)
+#       self.PFRelation = pf_relation
+
+#     end
+
+#     def fetch(&block)
+#       if self.belongs_to
+#         self.PFRelation.fetchIfNeededInBackgroundWithBlock do |result, error|
+#           if result
+#             result = self.klass.new(result)
+#           end
+
+#           block.call(result, error)
+#         end
+#       else
+#         self.PFRelation.
+#       end
+#     end
+
+#     def fetchAll(&block)
+#       self.fetch(block)
+#     end
+#   end
+# end

data/lib/Parsistence/User.rb

@@ -6,6 +6,16 @@ module Parsistence
     
     RESERVED_KEYS = [:objectId, :username, :password, :email]
 
+    def initialize(pf=nil)
+      if pf
+        self.PFObject = pf
+      else
+        self.PFObject = PFObject.objectWithClassName(self.class.to_s)
+      end
+
+      self
+    end
+    
     def PFObject=(value)
       @PFObject = value
       @PFUser = @PFObject
@@ -21,7 +31,7 @@ module Parsistence
         users = query.findObjects
         users
       end
-
+      
       def currentUser
         PFUser.currentUser
       end

data/lib/Parsistence/version.rb

@@ -1,3 +1,3 @@
 module Parsistence
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: Parsistence
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-05 00:00:00.000000000 Z
+date: 2012-09-12 00:00:00.000000000 Z
 dependencies: []
 description: Your models on RubyMotion and Parse in a persistence.js style pattern.
 email:
@@ -30,6 +30,7 @@ files:
 - lib/Parsistence.rb
 - lib/Parsistence/Model.rb
 - lib/Parsistence/Query.rb
+- lib/Parsistence/Relation.rb
 - lib/Parsistence/User.rb
 - lib/Parsistence/version.rb
 homepage: https://github.com/clearsightstudio/Parsistence