ParseModel 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ParseModel.gemspec
+gemspec

data/ParseModel.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ParseModel/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ParseModel"
+  s.version     = ParseModel::VERSION
+  s.authors     = ["Alan deLevie"]
+  s.email       = ["adelevie@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{An Active Record pattern for your Parse models on RubyMotion.}
+  s.description = %q{An Active Record pattern for your Parse models on RubyMotion.}
+
+  s.rubyforge_project = "ParseModel"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/README.md

@@ -0,0 +1,81 @@
+# About
+
+ParseModel provides an Active Record pattern to your Parse models on RubyMotion.
+
+## Usage
+
+Create a model:
+
+```ruby
+class Post
+  include Parse::Model
+
+  fields :title, :body, :author
+end
+```
+
+Create an instance:
+
+```ruby
+p = Post.new
+p.title = "Why RubyMotion Is Better Than Objective-C"
+p.author = "Josh Symonds"
+p.body = "trololol"
+p.saveEventually
+```
+
+`Parse::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, `Parse::Model#PFObject`.
+
+### Users
+
+```ruby
+class User
+  include Parse::User
+end
+
+user = User.new
+user.username = "adelevie"
+user.email = "adelevie@gmail.com"
+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
+```
+
+`Parse::User` delegates to `PFUser` in a very similar fashion as `Parse::Model` delegates to `PFOBject`.
+
+### Queries
+
+For now, just use Parse's native methods:
+
+```ruby
+query = PFQuery.queryWithClassName("Post")
+query.whereKey("title", equalTo:"Why RubyMotion Is Better Than Objective-C")
+results = query.findObjects
+```
+
+Note that this will return an `Array` of `PFObjects`, not `Parse::Model` objects. To convert, just pass the `PFObject` instance into `Parse::Model#new`:
+
+```ruby
+results.map! {|result| Post.new(result)}
+```
+
+
+## Installation
+
+Either `gem install parse-model` then `require 'parse-model'` in your `Rakefile`, OR
+
+`gem "parse-model"` in your Gemfile. ([Instructions for Bundler setup with Rubymotion)](http://thunderboltlabs.com/posts/using-bundler-with-rubymotion)
+
+Somewhere in your code, such as `app/app_delegate.rb` set your API keys:
+
+```ruby
+Parse.setApplicationId("1234567890", clientKey:"abcdefghijk")
+```
+
+To install the Parse iOS SDK in your RubyMotion project, read [this](http://www.rubymotion.com/developer-center/guides/project-management/#_using_3rd_party_libraries) and  [this](http://stackoverflow.com/a/10453895/94154).
+
+## License
+
+See LICENSE.txt

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/ParseModel.rb

@@ -0,0 +1,105 @@
+require "ParseModel/version"
+
+module Parse
+  module User
+    attr_accessor :PFUser
+    
+    RESERVED_KEYS = ['username', 'password', 'email']
+    
+    def initialize
+      @PFUser = PFUser.user
+    end
+    
+    def method_missing(method, *args, &block)
+      if RESERVED_KEYS.include?(method)
+        @PFUser.send(method)
+      elsif RESERVED_KEYS.map {|f| "#{f}="}.include?("#{method}")
+        @PFUser.send(method, args.first)
+      elsif fields.include?(method)
+        @PFUser.objectForKey(method)
+      elsif fields.map {|f| "#{f}="}.include?("#{method}")
+        method = method.split("=")[0]
+        @PFUser.setObject(args.first, forKey:method)
+      elsif @PFUser.respond_to?(method)
+        @PFUser.send(method, *args, &block)
+      else
+        super
+      end
+    end
+    
+    def fields
+      self.class.send(:get_fields)
+    end
+    
+    module ClassMethods      
+      def fields(*args)
+        args.each {|arg| field(arg)}
+      end
+    
+      def field(name)
+        @fields
+      end
+      
+      def get_fields
+        @fields ||= []
+        @fields
+      end
+      
+      def all
+        query = PFQuery.queryForUser
+        users = query.findObjects
+        users
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+  end
+
+  module Model
+    attr_accessor :PFObject
+    
+    def initialize
+      @PFObject = PFObject.objectWithClassName(self.class.to_s)
+    end
+    
+    def method_missing(method, *args, &block)
+      if fields.include?(method)
+        @PFObject.objectForKey(method)
+      elsif fields.map {|f| "#{f}="}.include?("#{method}")
+        method = method.split("=")[0]
+        @PFObject.setObject(args.first, forKey:method)
+      elsif @PFObject.respond_to?(method)
+        @PFObject.send(method, *args, &block)
+      else
+        super
+      end
+    end
+        
+    def fields
+      self.class.send(:get_fields)
+    end
+
+    module ClassMethods      
+      def fields(*args)
+        args.each {|arg| field(arg)}
+      end
+    
+      def field(name)
+        @fields ||= []
+        @fields << name
+      end
+      
+      def get_fields
+        @fields
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+end

data/lib/ParseModel/version.rb

@@ -0,0 +1,3 @@
+module ParseModel
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: ParseModel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alan deLevie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-01 00:00:00.000000000Z
+dependencies: []
+description: An Active Record pattern for your Parse models on RubyMotion.
+email:
+- adelevie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- ParseModel.gemspec
+- README.md
+- Rakefile
+- lib/ParseModel.rb
+- lib/ParseModel/version.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: ParseModel
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: An Active Record pattern for your Parse models on RubyMotion.
+test_files: []