parse_resource 1.6.0 → 1.6.1

data/README.md

@@ -44,7 +44,7 @@ Installation
 Include in your `Gemfile`:
 
 ```ruby
-gem "parse_resource", "~> 1.5.11"
+gem "parse_resource", "~> 1.6.0"
 ```
 
 Or just gem install:
@@ -75,7 +75,7 @@ In a non-Rails app, include this somewhere (preferable in an initializer):
 
 
 ```ruby
-ParseResource.load!("your_app_id", "your_master_key")
+ParseResource::Base.load!("your_app_id", "your_master_key")
 ```
 
 

data/VERSION

@@ -1 +1 @@
-1.6.0
+1.6.1

data/lib/base.rb

@@ -5,285 +5,276 @@ require "erb"
 require "rest-client"
 require "json"
 require "active_support/hash_with_indifferent_access"
+require "criteria"
 
 module ParseResource
 
   class Base
-  # ParseResource::Base provides an easy way to use Ruby to interace with a Parse.com backend
-  # Usage:
-  #  class Post < ParseResource::Base
-  #    fields :title, :author, :body
-  #  end
-
-  include ActiveModel::Validations
-  include ActiveModel::Conversion
-  include ActiveModel::AttributeMethods
-  extend ActiveModel::Naming
-  extend ActiveModel::Callbacks
-  HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
-
-  # define_model_callbacks :initialize, :find, :only => :after
-  define_model_callbacks :save, :create, :update, :destroy
-
-
-  # Instantiates a ParseResource::Base object
-  #
-  # @params [Hash], [Boolean] a `Hash` of attributes and a `Boolean` that should be false only if the object already exists
-  # @return [ParseResource::Base] an object that subclasses `Parseresource::Base`
-  def initialize(attributes = {}, new=true)
-  attributes = HashWithIndifferentAccess.new(attributes)
-  if new
-    @unsaved_attributes = attributes
-  else
-    @unsaved_attributes = {}
-  end
-  self.attributes = {}
-  self.attributes.merge!(attributes)
-  self.attributes unless self.attributes.empty?
-  create_setters!
-  end
-
-  # Explicitly adds a field to the model.
-  #
-  # @param [Symbol] name the name of the field, eg `:author`.
-  # @param [Boolean] val the return value of the field. Only use this within the class.
-  def self.field(name, val=nil)
-  class_eval do
-    define_method(name) do
-      @attributes[name] ? @attributes[name] : @unsaved_attributes[name]
+    # ParseResource::Base provides an easy way to use Ruby to interace with a Parse.com backend
+    # Usage:
+    #  class Post < ParseResource::Base
+    #    fields :title, :author, :body
+    #  end
+
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    include ActiveModel::AttributeMethods
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess
+
+    define_model_callbacks :save, :create, :update, :destroy
+
+
+    # Instantiates a ParseResource::Base object
+    #
+    # @params [Hash], [Boolean] a `Hash` of attributes and a `Boolean` that should be false only if the object already exists
+    # @return [ParseResource::Base] an object that subclasses `Parseresource::Base`
+    def initialize(attributes = {}, new=true)
+      attributes = HashWithIndifferentAccess.new(attributes)
+      if new
+        @unsaved_attributes = attributes
+      else
+        @unsaved_attributes = {}
+      end
+      self.attributes = {}
+      self.attributes.merge!(attributes)
+      self.attributes unless self.attributes.empty?
+      create_setters!
     end
-    define_method("#{name}=") do |val|
-      @attributes[name] = val
-      @unsaved_attributes[name] = val
-      val
+
+    # Explicitly adds a field to the model.
+    #
+    # @param [Symbol] name the name of the field, eg `:author`.
+    # @param [Boolean] val the return value of the field. Only use this within the class.
+    def self.field(name, val=nil)
+      class_eval do
+        define_method(name) do
+          @attributes[name] ? @attributes[name] : @unsaved_attributes[name]
+        end
+        define_method("#{name}=") do |val|
+          @attributes[name] = val
+          @unsaved_attributes[name] = val
+          val
+        end
+      end
     end
-  end
-  end
 
-  # Add multiple fields in one line. Same as `#field`, but accepts multiple args.
-  #
-  # @param [Array] *args an array of `Symbol`s, `eg :author, :body, :title`.
-  def self.fields(*args)
-  args.each {|f| field(f)}
-  end
+    # Add multiple fields in one line. Same as `#field`, but accepts multiple args.
+    #
+    # @param [Array] *args an array of `Symbol`s, `eg :author, :body, :title`.
+    def self.fields(*args)
+      args.each {|f| field(f)}
+    end
 
-  # Creates getter and setter methods for model fields
-  # 
-  def create_setters!
-  @attributes.each_pair do |k,v|
-    self.class.send(:define_method, "#{k}=") do |val|
-      if k.is_a?(Symbol)
-        k = k.to_s
+    # Creates getter and setter methods for model fields
+    # 
+    def create_setters!
+      @attributes.each_pair do |k,v|
+        self.class.send(:define_method, "#{k}=") do |val|
+          if k.is_a?(Symbol)
+            k = k.to_s
+          end
+          @attributes[k.to_s] = val
+          @unsaved_attributes[k.to_s] = val
+          val
+        end
+        self.class.send(:define_method, "#{k}") do
+          if k.is_a?(Symbol)
+            k = k.to_s
+          end
+
+          @attributes[k.to_s]
+        end
       end
-      @attributes[k.to_s] = val
-      @unsaved_attributes[k.to_s] = val
-      val
     end
-    self.class.send(:define_method, "#{k}") do
-      if k.is_a?(Symbol)
-        k = k.to_s
-      end
 
-      @attributes[k.to_s]
-    end
-  end
-  end
+    class << self
 
-  class << self
-  def has_one(child_name)
-    class_eval do
+      @@settings ||= nil
 
-      define_method("#{child_name}") do
-        child_name
+      # Explicitly set Parse.com API keys.
+      #
+      # @param [String] app_id the Application ID of your Parse database
+      # @param [String] master_key the Master Key of your Parse database
+      def load!(app_id, master_key)
+        @@settings = {"app_id" => app_id, "master_key" => master_key}
       end
 
-      define_method("#{child_name}=") do |child_object|
-        [child_object, child_name]
+      # Creates a RESTful resource
+      # sends requests to [base_uri]/[classname]
+      #
+      def resource
+        if @@settings.nil?
+          path = "config/parse_resource.yml"
+          environment = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : ENV["RACK_ENV"]
+          @@settings = YAML.load(ERB.new(File.new(path).read).result)[environment]
+        end
+        base_uri   = "https://api.parse.com/1/classes/#{model_name}"
+        app_id     = @@settings['app_id']
+        master_key = @@settings['master_key']
+        RestClient::Resource.new(base_uri, app_id, master_key)
       end
 
-    end
-  end
-
-  def belongs_to(name)
-    class_eval do
+      # Find a ParseResource::Base object by ID
+      #
+      # @param [String] id the ID of the Parse object you want to find.
+      # @return [ParseResource] an object that subclasses ParseResource.
+      def find(id)
+        where(:objectId => id).first
+      end
 
-      define_method("#{parent_name}") do
-        name
+      # Find a ParseResource::Base object by chaining #where method calls.
+      #
+      def where(*args)
+        Criteria.new(self).where(*args)
       end
 
-      define_method("#{parent_name}=") do |parent_object|
-        [parent_name, parent_object]
+      # Add this at the end of a method chain to get the count of objects, instead of an Array of objects
+      def count
+        #https://www.parse.com/docs/rest#queries-counting
+        Criteria.new(self).count(1)
       end
 
-    end
-  end
+      # Find all ParseResource::Base objects for that model.
+      #
+      # @return [Array] an `Array` of objects that subclass `ParseResource`.
+      def all
+        Criteria.new(self).all
+      end
 
+      # Find the first object. Fairly random, not based on any specific condition.
+      #
+      def first
+        Criteria.new(self).limit(1).first
+      end
 
-  @@settings ||= nil
+      # Limits the number of objects returned
+      #
+      def limit(n)
+        Criteria.new(self).limit(n)
+      end
 
-  # Explicitly set Parse.com API keys.
-  #
-  # @param [String] app_id the Application ID of your Parse database
-  # @param [String] master_key the Master Key of your Parse database
-  def load!(app_id, master_key)
-    @@settings = {"app_id" => app_id, "master_key" => master_key}
-  end
+      # Create a ParseResource::Base object.
+      #
+      # @param [Hash] attributes a `Hash` of attributes
+      # @return [ParseResource] an object that subclasses `ParseResource`. Or returns `false` if object fails to save.
+      def create(attributes = {})
+        attributes = HashWithIndifferentAccess.new(attributes)
+        new(attributes).save
+      end
 
-  # Creates a RESTful resource
-  # sends requests to [base_uri]/[classname]
-  #
-  def resource
-    if @@settings.nil?
-      path = "config/parse_resource.yml"
-      environment = defined?(Rails) && Rails.respond_to?(:env) ? Rails.env : ENV["RACK_ENV"]
-      @@settings = YAML.load(ERB.new(File.new(path).read).result)[environment]
-    end
-    base_uri   = "https://api.parse.com/1/classes/#{model_name}"
-    app_id     = @@settings['app_id']
-    master_key = @@settings['master_key']
-    RestClient::Resource.new(base_uri, app_id, master_key)
-  end
+      def destroy_all
+        all.each do |object|
+          object.destroy
+        end
+      end
 
-  # Find a ParseResource::Baseobject by ID
-  #
-  # @param [String] id the ID of the Parse object you want to find.
-  # @return [ParseResource] an object that subclasses ParseResource.
-  def find(id)
-    where(:objectId => id).first
-  end
+      def class_attributes
+        @class_attributes ||= {}
+      end
 
-  # Find a ParseResource::Baseobject by a `Hash` of conditions.
-  #
-  # @param [Hash] parameters a `Hash` of conditions.
-  # @return [Array] an `Array` of objects that subclass `ParseResource`.
-  def where(parameters)
-    resp = resource.get(:params => {:where => parameters.to_json})
-    results = JSON.parse(resp)['results']
-    results.map {|r| model_name.constantize.new(r, false)}
-  end
+    end
 
-  # Find all ParseResource::Baseobjects for that model.
-  #
-  # @return [Array] an `Array` of objects that subclass `ParseResource`.
-  def all
-    resp = resource.get
-    results = JSON.parse(resp)['results']
-    results.map {|r| model_name.constantize.new(r, false)}
-  end
+    def persisted?
+      if id
+        true
+      else
+        false
+      end
+    end
 
-  # Create a ParseResource::Baseobject.
-  #
-  # @param [Hash] attributes a `Hash` of attributes
-  # @return [ParseResource] an object that subclasses `ParseResource`. Or returns `false` if object fails to save.
-  def create(attributes = {})
-    attributes = HashWithIndifferentAccess.new(attributes)
-    new(attributes).save
-  end
+    def new?
+      !persisted?
+    end
 
-  # Find the first object. Fairly random, not based on any specific condition.
-  #
-  def first
-    all.first
-  end
+    # delegate from Class method
+    def resource
+      self.class.resource
+    end
 
-  def class_attributes
-    @class_attributes ||= {}
-  end
+    # create RESTful resource for the specific Parse object
+    # sends requests to [base_uri]/[classname]/[objectId]
+    def instance_resource
+      self.class.resource["#{self.id}"]
+    end
 
-  end
+    def create
+      resp = self.resource.post(@unsaved_attributes.to_json, :content_type => "application/json")
+      @attributes.merge!(JSON.parse(resp))
+      @attributes.merge!(@unsaved_attributes)
+      attributes = HashWithIndifferentAccess.new(attributes)
+      @unsaved_attributes = {}
+      create_setters!
+      self
+    end
 
-  def persisted?
-  if id
-    true
-  else
-    false
-  end
-  end
+    def save
+      if valid?
+        run_callbacks :save do
+          new? ? create : update
+        end
+      else
+        false
+      end
+      rescue false
+    end
 
-  def new?
-  !persisted?
-  end
+    def update(attributes = {})
+      attributes = HashWithIndifferentAccess.new(attributes)
+      @unsaved_attributes.merge!(attributes)
 
-  # delegate from Class method
-  def resource
-  self.class.resource
-  end
+      put_attrs = @unsaved_attributes
+      put_attrs.delete('objectId')
+      put_attrs.delete('createdAt')
+      put_attrs.delete('updatedAt')
+      put_attrs = put_attrs.to_json
 
-  # create RESTful resource for the specific Parse object
-  # sends requests to [base_uri]/[classname]/[objectId]
-  def instance_resource
-  self.class.resource["#{self.id}"]
-  end
+      resp = self.instance_resource.put(put_attrs, :content_type => "application/json")
 
-  def create
-  resp = self.resource.post(@unsaved_attributes.to_json, :content_type => "application/json")
-  @attributes.merge!(JSON.parse(resp))
-  @attributes.merge!(@unsaved_attributes)
-  attributes = HashWithIndifferentAccess.new(attributes)
-  @unsaved_attributes = {}
-  create_setters!
-  self
-  end
+      @attributes.merge!(JSON.parse(resp))
+      @attributes.merge!(@unsaved_attributes)
+      @unsaved_attributes = {}
+      create_setters!
 
-  def save
-  if valid?
-    run_callbacks :save do
-      new? ? create : update
+      self
     end
-  else
-    false
-  end
-  rescue false
-  end
-
-  def update(attributes = {})
-  attributes = HashWithIndifferentAccess.new(attributes)
-  @unsaved_attributes.merge!(attributes)
-
-  put_attrs = @unsaved_attributes
-  put_attrs.delete('objectId')
-  put_attrs.delete('createdAt')
-  put_attrs.delete('updatedAt')
-  put_attrs = put_attrs.to_json
 
-  resp = self.instance_resource.put(put_attrs, :content_type => "application/json")
-
-  @attributes.merge!(JSON.parse(resp))
-  @attributes.merge!(@unsaved_attributes)
-  @unsaved_attributes = {}
-  create_setters!
+    def update_attributes(attributes = {})
+      self.update(attributes)
+    end
 
-  self
-  end
+    def destroy
+      self.instance_resource.delete
+      @attributes = {}
+      @unsaved_attributes = {}
+      nil
+    end
 
-  def update_attributes(attributes = {})
-  self.update(attributes)
-  end
+    # provides access to @attributes for getting and setting
+    def attributes
+      @attributes ||= self.class.class_attributes
+      @attributes
+    end
 
-  def destroy
-  self.instance_resource.delete
-  @attributes = {}
-  @unsaved_attributes = {}
-  nil
-  end
+    def attributes=(n)
+      @attributes = n
+      @attributes
+    end
 
-  # provides access to @attributes for getting and setting
-  def attributes
-  @attributes ||= self.class.class_attributes
-  @attributes
-  end
+    # aliasing for idiomatic Ruby
+    def id; self.objectId rescue nil; end
 
-  def attributes=(n)
-  @attributes = n
-  @attributes
-  end
+    def created_at; self.createdAt; end
 
-  # aliasing for idiomatic Ruby
-  def id; self.objectId rescue nil; end
+    def updated_at; self.updatedAt rescue nil; end
 
-  def created_at; self.createdAt; end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-  def updated_at; self.updatedAt rescue nil; end
+    module ClassMethods
+    end
 
   end
 end

data/lib/criteria.rb

@@ -0,0 +1,79 @@
+class Criteria
+
+  def initialize(klass)
+    @klass = klass
+  end
+
+  def criteria
+    @criteria ||= { :conditions => {} }
+  end
+
+  def where(args)
+    criteria[:conditions].merge!(args)
+    self
+  end
+
+  def limit(limit)
+    criteria[:limit] = limit
+    self
+  end
+
+  #TODO: make this work
+  #def skip(skip)
+  #  criteria[:skip] = skip
+  #  self
+  #end
+
+  def count(count)
+    criteria[:count] = count
+    #self
+    all
+  end
+
+  #def each(&block)
+  #  resp = @klass.resource.get(:params => {:where => criteria[:conditions].to_json})
+  #  results = JSON.parse(resp)['results']
+  #  results.map {|r| @klass.model_name.constantize.new(r, false)}.each(&block)
+  #end
+
+  #def first
+  #  resp = @klass.resource.get(:params => {:where => criteria[:conditions].to_json})
+  #  results = JSON.parse(resp)['results']
+  #  results.map {|r| @klass.model_name.constantize.new(r, false)}.first
+  #end
+
+  #def length
+  #  resp = @klass.resource.get(:params => {:where => criteria[:conditions].to_json})
+  #  results = JSON.parse(resp)['results']
+  #  results.length
+  #end
+
+  def all
+    params = {}
+    params.merge!({:where => criteria[:conditions].to_json}) if criteria[:conditions]
+    params.merge!({:limit => criteria[:limit].to_json}) if criteria[:limit]
+    params.merge!({:skip => criteria[:skip].to_json}) if criteria[:skip]
+    params.merge!({:count => criteria[:count].to_json}) if criteria[:count]
+
+    resp = @klass.resource.get(:params => params)
+
+    if criteria[:count] == 1
+      results = JSON.parse(resp)['count']
+      return results.to_i
+    else
+      results = JSON.parse(resp)['results']
+      return results.map {|r| @klass.model_name.constantize.new(r, false)}
+    end
+  end
+
+  def method_missing(meth)
+    if Array.method_defined?(meth)
+      all.send(meth)
+    else
+      super
+    end
+  end
+
+
+
+end

data/lib/parse_resource.rb

@@ -1,4 +1,5 @@
 require 'base'
+require 'criteria'
 
 module ParseResource
 end

data/parse_resource.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "parse_resource"
-  s.version = "1.6.0"
+  s.version = "1.6.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alan deLevie"]
-  s.date = "2011-12-07"
+  s.date = "2011-12-09"
   s.description = ""
   s.email = "adelevie@gmail.com"
   s.extra_rdoc_files = [
@@ -25,9 +25,9 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "lib/base.rb",
+    "lib/criteria.rb",
     "lib/examples/post.rb",
     "lib/parse_resource.rb",
-    "lib/parse_resource_old.rb",
     "parse_resource.gemspec",
     "rdoc/ParseResource.html",
     "rdoc/created.rid",