parse_resource 1.5.11 → 1.6.0

data/README.md

@@ -1,16 +1,42 @@
 ParseResource
 =============
 
-ParseResource makes it easy to interact with Parse.com's REST API. It adheres to the ActiveRecord pattern. ParceResource is fully ActiveModel compliant, meaning you can use validations, callbacks, and Rails forms.
+ParseResource makes it easy to interact with Parse.com's REST API. It adheres to the ActiveRecord pattern. ParceResource is fully ActiveModel compliant, meaning you can use validations and Rails forms.
 
 Ruby/Rails developers should feel right at home.
 
+Features
+---------------
+*   ActiveRecord-like API, almost no learning curve
+*   Validations
+*   Rails forms and scaffolds **just work**
+
+Use cases
+-------------
+*   Build a custom admin dashboard for your Parse.com data
+*   Use the same database for your web and native apps
+*   Pre-collect data for use in iOS and Android apps
+
+To-do
+--------------
+*   User authentication
+*   Better documentation
+*   Associations
+*   Callbacks
+*   Push notifications
+*   Better type-casting
+
+User authentication is my top priority feature. Several people have specifically requested it, and Parse just began exposing [`User` objects in the REST API](https://www.parse.com/docs/rest#users).
+
+Let me know of any other features you want.
+
+
 Words of caution
 ---------------
 
-ParseResource is brand new and has no test coverage. You read that right. I figured I'd ship now and write tests later. We'll see how it goes.
+ParseResource is brand new. Test coverage is decent.
 
-This is also my first gem. Be afraid.
+This is my first gem. Be afraid.
 
 Installation
 ------------
@@ -18,7 +44,7 @@ Installation
 Include in your `Gemfile`:
 
 ```ruby
-gem "parse_resource"
+gem "parse_resource", "~> 1.5.11"
 ```
 
 Or just gem install:
@@ -59,13 +85,15 @@ Usage
 Create a model:
 
 ```ruby
-class Post < ParseResource
+class Post < ParseResource::Base
   fields :title, :author, :body
 
   validates_presence_of :title
 end
 ```
 
+If you are using version `1.5.11` or earlier, subclass to just `ParseResource`.
+
 Creating, updating, and deleting:
 
 ```ruby
@@ -124,13 +152,14 @@ p = Post.find(id)
 
 Contributing to ParseResource
 -----------------------------
- 
+
 *   Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 *   Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
 *   Fork the project
 *   Start a feature/bugfix branch
 *   Commit and push until you are happy with your contribution
-*   Make sure to add tests for it. This is important so I don't break it in a future version unintentionally. (A little hypocritical since I haven't written tests yet)
+*   Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+*   Create `parse_resource.yml` in the root of the gem folder. Using the same format as `parse_resource.yml` in the instructions (except only creating a `test` environment, add your own API keys.
 *   Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
 Copyright

data/VERSION

@@ -1 +1 @@
-1.5.11
+1.6.0

data/lib/base.rb

@@ -0,0 +1,289 @@
+require "rubygems"
+require "bundler/setup"
+require "active_model"
+require "erb"
+require "rest-client"
+require "json"
+require "active_support/hash_with_indifferent_access"
+
+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]
+    end
+    define_method("#{name}=") do |val|
+      @attributes[name] = val
+      @unsaved_attributes[name] = val
+      val
+    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
+
+  # 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
+  end
+
+  class << self
+  def has_one(child_name)
+    class_eval do
+
+      define_method("#{child_name}") do
+        child_name
+      end
+
+      define_method("#{child_name}=") do |child_object|
+        [child_object, child_name]
+      end
+
+    end
+  end
+
+  def belongs_to(name)
+    class_eval do
+
+      define_method("#{parent_name}") do
+        name
+      end
+
+      define_method("#{parent_name}=") do |parent_object|
+        [parent_name, parent_object]
+      end
+
+    end
+  end
+
+
+  @@settings ||= nil
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # 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
+
+  # Find the first object. Fairly random, not based on any specific condition.
+  #
+  def first
+    all.first
+  end
+
+  def class_attributes
+    @class_attributes ||= {}
+  end
+
+  end
+
+  def persisted?
+  if id
+    true
+  else
+    false
+  end
+  end
+
+  def new?
+  !persisted?
+  end
+
+  # delegate from Class method
+  def resource
+  self.class.resource
+  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
+
+  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 save
+  if valid?
+    run_callbacks :save do
+      new? ? create : update
+    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!
+
+  self
+  end
+
+  def update_attributes(attributes = {})
+  self.update(attributes)
+  end
+
+  def destroy
+  self.instance_resource.delete
+  @attributes = {}
+  @unsaved_attributes = {}
+  nil
+  end
+
+  # provides access to @attributes for getting and setting
+  def attributes
+  @attributes ||= self.class.class_attributes
+  @attributes
+  end
+
+  def attributes=(n)
+  @attributes = n
+  @attributes
+  end
+
+  # aliasing for idiomatic Ruby
+  def id; self.objectId rescue nil; end
+
+  def created_at; self.createdAt; end
+
+  def updated_at; self.updatedAt rescue nil; end
+
+  end
+end

data/lib/examples/post.rb

@@ -1,15 +1,11 @@
+require 'helper'
 require 'parse_resource'
-require 'pp'
 
+path = "parse_resource.yml"
+settings = YAML.load(ERB.new(File.new(path).read).result)['test']
 
-ParseResource.load!("FKEzdzDgEyghLDFgIVHYJehVlWpfVtUmEv4MUEkJ", "bOYO7usWbrcIbL5L5bPzlYrSonQRvwJecC1XLsuN")
+ParseResource.load!(settings['app_id'], settings['master_key'])
 
 class Post < ParseResource
   fields :title, :author, :body
-
-  after_save :add_author
-
-  def add_author
-    update(:author => "Alan")
-  end
 end

data/lib/parse_resource.rb

@@ -1,244 +1,4 @@
-require "rubygems"
-require "bundler/setup"
-require "active_model"
-require "erb"
-require "rest-client"
-require "json"
-require "active_support/hash_with_indifferent_access"
+require 'base'
 
-ActiveSupport
-
-class ParseResource
-  # ParseResource provides an easy way to use Ruby to interace with a Parse.com backend
-  # Usage:
-  #  class Post < ParseResource
-  #    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
-
-  # instantiation!
-  # p = Post.new(:title => "cool story")
-  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
-
-  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
-
-  def self.fields(*args)
-    args.each {|f| field(f)}
-  end
-
-  # a sprinkle of metaprogramming
-  # p = Post.new(:some_attr => "some value")
-  # p.some_attr = "new value"
-  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
-  end
-
-  class << self
-    @@settings ||= nil
-
-    def load!(app_id, master_key)
-      @@settings = {"app_id" => app_id, "master_key" => master_key}
-    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
-
-    # finders
-    # Post.find("abcdf")
-    def find(id)
-      where(:objectId => id).first
-    end
-
-    # Post.where(:author => "Alan", :title => "Ipso Lorem")
-    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
-
-    # Post.all
-    def all
-      resp = resource.get
-      results = JSON.parse(resp)['results']
-      results.map {|r| model_name.constantize.new(r, false)}
-    end
-
-    # Post.create(:title => "new post")
-    def create(attributes = {})
-      attributes = HashWithIndifferentAccess.new(attributes)
-      new(attributes).save
-    end
-
-    # Post.first
-    def first
-      all.first
-    end
-
-    def class_attributes
-      @class_attributes ||= {}
-    end
-
-  end
-
-  def persisted?
-    if id
-      true
-    else
-      false
-    end
-  end
-
-  def new?
-    !persisted?
-  end
-
-  # delegate from Class method
-  def resource
-    self.class.resource
-  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
-
-  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 save
-    if valid?
-      run_callbacks :save do
-        new? ? create : update
-      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!
-
-    self
-  end
-
-  def update_attributes(attributes = {})
-    self.update(attributes)
-  end
-
-  def destroy
-    self.instance_resource.delete
-    @attributes = {}
-    @unsaved_attributes = {}
-    nil
-  end
-
-  # provides access to @attributes for getting and setting
-  def attributes
-    @attributes ||= self.class.class_attributes
-    @attributes
-  end
-
-  def attributes=(n)
-    @attributes = n
-    @attributes
-  end
-
-  # aliasing for idiomatic Ruby
-  def id; self.objectId rescue nil; end
-
-  def created_at; self.createdAt; end
-
-  def updated_at; self.updatedAt rescue nil; end
-
-  # another sprinkle of metaprogramming
-  # p = Post.new(:some_attr => "some value")
-  # p.some_attr #=> "some value"
-  #def method_missing(meth, *args, &block)
-  #  if @attributes.has_key?(meth.to_s)
-  #    @attributes[meth.to_s]
-  #  else
-  #    super
-  #  end
-  #end
+module ParseResource
 end