Parsistence 0.2.0

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+# Specify your gem's dependencies in Parsistence.gemspec
+gemspec

data/Parsistence.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/Parsistence/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "Parsistence"
+  s.version     = Parsistence::VERSION
+  s.authors     = ["Jamon Holmgren", "Silas J. Matson", "Alan deLevie"]
+  s.email       = ["jamon@clearsightstudio.com", "silas@clearsightstudio.com", "adelevie@gmail.com"]
+  s.homepage    = "https://github.com/clearsightstudio/Parsistence"
+  s.summary     = %q{Your models on RubyMotion and Parse in a persistence.js style pattern.}
+  s.description = %q{Your models on RubyMotion and Parse in a persistence.js style pattern.}
+
+  s.rubyforge_project = "Parsistence"
+
+  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,124 @@
+# About
+
+Parsistence provides an Active Record pattern to your Parse models on RubyMotion. 
+It's an early fork from [ParseModel](https://github.com/adelevie/ParseModel) by
+Alan deLevie but goes a different direction with its implementation.
+
+## Usage
+
+Create a model:
+
+```ruby
+class Post
+  include Parsistence::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
+```
+
+`Parsistence::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, `Parsistence::Model#PFObject`.
+
+### Users
+
+```ruby
+class User
+  include Parsistence::User
+end
+
+user = User.new
+user.username = "adelevie"
+user.email = "adelevie@gmail.com"
+user.password = "foobar"
+user.signUp
+
+users = User.all
+users.map {|u| u.objectId}.include?(user.objectId) #=> true
+```
+
+`Parsistence::User` delegates to `PFUser` in a very similar fashion as `Parsistence::Model` delegates to `PFOBject`. `Parsistence::User` includes `Parsistence::Model`, in fact.
+
+### Queries
+
+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|
+  if cars
+    cars.each do |car|
+      # `car` is an instance of your `Car` model here.
+    end
+  end
+end
+```
+
+Chain multiple conditions together, even the same condition type multiple times, then run `fetch` to execute the query. Pass in a block with two fields to receive the data.
+
+####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).
+
+### Relationships
+
+Define your relationships in the Parse.com dashboard and also in your models.
+
+```ruby
+class Post
+  include Parsistence::Model
+
+  fields :title, :body, :author
+
+  relations :author
+end
+
+Author.where(name: "Jamon Holmgren").fetchOne do |fetchedAuthor, error|
+  p = Post.new
+  p.title = "Awesome Readme"
+  p.body = "Read this first!"
+  p.author = fetchedAuthor
+  p.save
+end
+```
+
+
+## Installation
+
+Either `gem install Parsistence` then `require 'Parsistence'` in your `Rakefile`, OR
+
+`gem "Parsistence"` 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,4 @@
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require 'bundler'
+Bundler.setup

data/lib/Parsistence/Model.rb

@@ -0,0 +1,172 @@
+module Parsistence
+  module Model
+    attr_accessor :PFObject, :errors
+    
+    RESERVED_KEYS = [:objectId]
+
+    def initialize(pf=nil)
+      if pf
+        self.PFObject = pf
+      else
+        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 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)
+      else
+        super
+      end
+    end
+    
+    def fields
+      self.class.send(:get_fields)
+    end
+
+    def relations
+      self.class.send(:get_relations)
+    end
+
+    def getField(field)
+      field = field.to_sym
+      return @PFObject.send(field) if RESERVED_KEYS.include?(field)
+      return @PFObject[field] if fields.include? field
+      raise "Parsistence Exception: Invalid field name #{field} for object #{self.class.to_s}"
+    end
+
+    def setField(field, value)
+      return @PFObject.send("#{field}=", value) if RESERVED_KEYS.include?(field)
+      return @PFObject[field] = value if fields.include? field.to_sym
+      raise "Parsistence Exception: Invalid field name #{field} for object #{self.class.to_s}" unless fields.include? field.to_sym
+    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}"
+    end
+
+    def setRelation(relation, value)
+      value = value.PFObject if value.respond_to? :PFObject # unwrap object
+      # return setRelation(relation, value) # This SHOULD work
+      
+      relation = @PFObject.relationforKey(relation)
+      
+      return relation.addObject(value) if relations.include? relation.to_sym
+      raise "Parsistence Exception: Invalid relation name #{relation} for object #{self.class.to_s}" unless relations.include? relation.to_sym
+    end
+
+    def attributes
+      attributes = {}
+      fields.each do |f|
+        attributes[f] = getField(f)
+      end
+      @attributes = attributes
+    end
+
+    def attributes=(hashValue)
+      hashValue.each do |k, v|
+        next if v.nil? # Protection
+        setField(k, v) unless k.nil?
+      end
+    end
+
+    def save
+      saved = false
+      unless before_save == false
+        self.attributes.each do |field, value|
+          validateField field, value
+        end
+
+        saved = @PFObject.save
+        after_save if saved
+      end
+      saved
+    end
+
+    def before_save; end
+    def after_save; end
+
+    # Validations
+    def presenceValidations
+      self.class.send(:get_presenceValidations)
+    end
+
+    def validateField(field, value)
+      @errors ||= {}
+      @errors[field] = "#{field} can't be blank" if presenceValidations.include?(field) && value.nil? || value == ""
+    end
+
+    def errorForField(field)
+      @errors[field] || false
+    end
+
+
+    module ClassMethods
+      def fields(*args)
+        args.each {|arg| field(arg)}
+      end
+    
+      def field(name)
+        @fields ||= [:objectId]
+        @fields << name.to_sym
+        @fields.uniq!
+      end
+      
+      def get_fields
+        @fields
+      end
+
+      def relations(*args)
+        args.each { |arg| relation(arg)}
+      end
+
+      def relation(name)
+        @relations ||= []
+        @relations << name.to_sym
+        @relations.uniq!
+      end
+
+      def get_relations
+        @relations ||= []
+      end
+
+      def validates_presence_of(*args)
+        args.each {|arg| validate_presence(arg)}
+      end
+
+      def get_presenceValidations
+        @presenceValidations ||= []
+      end
+
+      def validate_presence(field)
+        @presenceValidations ||= []
+        @presenceValidations << field
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+  end
+end

data/lib/Parsistence/Query.rb

@@ -0,0 +1,223 @@
+module Parsistence
+  module Model
+    module ClassMethods
+      QUERY_STUBS = [ :fetch, :where, :first, :limit, :order, :eq, :notEq, :lt, :gt, :lte, :gte ] # :limit is different
+
+      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)
+        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)
+        elsif method.start_with?("find_by_")
+          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
+          # return self.where(cond, block)
+        else
+        end
+      end
+    end
+  end
+
+  class Query
+    attr_accessor :klass
+
+    def initialize
+      @conditions = {}
+      @negativeConditions = {}
+      @ltConditions = {}
+      @gtConditions = {}
+      @lteConditions = {}
+      @gteConditions = {}
+      @order = {}
+      @limit = nil
+      @offset = nil
+      @includes = []
+    end
+
+    def createQuery
+      query = PFQuery.queryWithClassName(self.klass.to_s)
+      $stderr.puts @includes
+      @includes.each do |include|
+        query.includeKey(include)
+      end
+      
+      @conditions.each do |key, value|
+        value = value.PFObject if value.respond_to? :PFObject
+        query.whereKey(key, equalTo: value)
+      end
+      @negativeConditions.each do |key, value|
+        value = value.PFObject if value.respond_to? :PFObject
+        query.whereKey(key, notEqualTo: value)
+      end
+      @ltConditions.each do |key, value|
+        value = value.PFObject if value.respond_to? :PFObject
+        query.whereKey(key, lessThan: value)
+      end
+      @gtConditions.each do |key, value|
+        value = value.PFObject if value.respond_to? :PFObject
+        query.whereKey(key, greaterThan: value)
+      end
+      @lteConditions.each do |key, value|
+        value = value.PFObject if value.respond_to? :PFObject
+        query.whereKey(key, lessThanOrEqualTo: value)
+      end
+      @gteConditions.each do |key, value|
+        value = value.PFObject if value.respond_to? :PFObject
+        query.whereKey(key, greaterThanOrEqualTo: value)
+      end
+      first = true
+      @order.each do |field, direction|
+        if first
+          # $stderr.puts "Setting order first"
+          query.orderByAscending(field) if direction && direction == :asc
+          query.orderByDescending(field) if direction && direction == :desc
+          first = false
+        else
+          # $stderr.puts "Setting order again"
+          query.addAscendingOrder(field) if direction && direction == :asc
+          query.addDescendingOrder(field) if direction && direction == :desc
+        end
+      end
+
+      query.limit = @limit if @limit
+      query.skip = @offset if @offset
+
+      query
+    end
+
+    def fetch(&callback)
+      if @limit && @limit == 1
+        fetchOne(&callback) 
+      else
+        fetchAll(&callback)
+      end
+      
+      self
+    end
+
+    def fetchAll(&callback)
+      query = createQuery
+      
+      myKlass = self.klass
+      query.findObjectsInBackgroundWithBlock (lambda { |items, error|
+        modelItems = items.map! { |item| myKlass.new(item) } if items
+        callback.call modelItems, error
+      })
+    end
+
+    def fetchOne(&callback)
+      limit(0, 1)
+      query = createQuery
+      
+      myKlass = self.klass
+      query.getFirstObjectInBackgroundWithBlock (lambda { |item, error|
+        modelItem = myKlass.new(item) if item
+        callback.call modelItem, error
+      })
+    end
+
+    # Query methods
+    def where(*conditions, &callback)
+      eq(conditions.first)
+      fetch(&callback)
+      nil
+    end
+
+    def all(&callback)
+      fetch(&callback)
+      nil
+    end
+
+    def first(&callback)
+      limit(0, 1)
+      fetch(&callback)
+      nil
+    end
+    
+    def showQuery
+      $stderr.puts "Conditions: #{@conditions.to_s}"
+      $stderr.puts "negativeConditions: #{@negativeConditions.to_s}"
+      $stderr.puts "ltConditions: #{@ltConditions.to_s}"
+      $stderr.puts "gtConditions: #{@gtConditions.to_s}"
+      $stderr.puts "lteConditions: #{@lteConditions.to_s}"
+      $stderr.puts "gteConditions: #{@gteConditions.to_s}"
+      $stderr.puts "order: #{@order.to_s}"
+      $stderr.puts "limit: #{@limit.to_s}"
+      $stderr.puts "offset: #{@offset.to_s}"
+    end
+
+    # Query parameter methods
+    def limit(offset, number = nil)
+      if number.nil?
+        number = offset
+        offset = 0
+      end
+      @offset = offset
+      @limit = number
+      self
+    end
+
+    def order(*fields)
+      fields.each do |field|
+        @order.merge! field
+      end
+      self
+    end
+
+    def eq(*fields)
+      fields.each do |field|
+        @conditions.merge! field
+      end
+      self
+    end
+
+    def notEq(*fields)
+      fields.each do |field|
+        @negativeConditions.merge! field
+      end
+      self
+    end
+
+    def lt(*fields)
+      fields.each do |field|
+        @ltConditions.merge! field
+      end
+      self
+    end
+
+    def gt(*fields)
+      fields.each do |field|
+        @gtConditions.merge! field
+      end
+      self
+    end
+
+    def lte(*fields)
+      fields.each do |field|
+        @lteConditions.merge! field
+      end
+      self
+    end
+
+    def gte(*fields)
+      fields.each do |field|
+        @gteConditions.merge! field
+      end
+      self
+    end
+
+    def includes(*fields)
+      fields.each do |field|
+        @includes << field
+      end
+    end
+  end
+end

data/lib/Parsistence/User.rb

@@ -0,0 +1,34 @@
+module Parsistence
+  module User
+    include ::Parsistence::Model
+
+    attr_accessor :PFUser
+    
+    RESERVED_KEYS = [:objectId, :username, :password, :email]
+
+    def PFObject=(value)
+      @PFObject = value
+      @PFUser = @PFObject
+    end
+    
+    def PFUser=(value)
+      self.PFObject = value
+    end
+
+    module ClassMethods    
+      def all
+        query = PFQuery.queryForUser
+        users = query.findObjects
+        users
+      end
+
+      def currentUser
+        PFUser.currentUser
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/lib/Parsistence/version.rb

@@ -0,0 +1,3 @@
+module Parsistence
+  VERSION = "0.2.0"
+end

data/lib/Parsistence.rb

@@ -0,0 +1,8 @@
+require "Parsistence/version"
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), "Parsistence/*.rb")).each do |file|
+    app.files.unshift(file) unless file.include? "Model.rb"
+  end
+  app.files.unshift(File.join(File.dirname(__FILE__), "Parsistence/Model.rb"))
+end

metadata

@@ -0,0 +1,60 @@
+--- !ruby/object:Gem::Specification
+name: Parsistence
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
+platform: ruby
+authors:
+- Jamon Holmgren
+- Silas J. Matson
+- Alan deLevie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-05 00:00:00.000000000 Z
+dependencies: []
+description: Your models on RubyMotion and Parse in a persistence.js style pattern.
+email:
+- jamon@clearsightstudio.com
+- silas@clearsightstudio.com
+- adelevie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Parsistence.gemspec
+- README.md
+- Rakefile
+- lib/Parsistence.rb
+- lib/Parsistence/Model.rb
+- lib/Parsistence/Query.rb
+- lib/Parsistence/User.rb
+- lib/Parsistence/version.rb
+homepage: https://github.com/clearsightstudio/Parsistence
+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: Parsistence
+rubygems_version: 1.8.22
+signing_key: 
+specification_version: 3
+summary: Your models on RubyMotion and Parse in a persistence.js style pattern.
+test_files: []
+has_rdoc: