remote_model 0.0.1

data/.gitignore

@@ -0,0 +1,11 @@
+.repl_history
+build
+examples/FacebookGraph/build
+examples/FacebookGraph/vendor
+resources/*.nib
+resources/*.momd
+resources/*.storyboardc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,142 @@
+# RemoteModel
+
+
+JSON API <-> NSObject in one line. Powered by RubyMotion and [BubbleWrap](https://github.com/mattetti/BubbleWrap/).
+
+## Example
+
+Let's say we have some User and Question objects retrievable via our API. We can do fun stuff like:
+
+```ruby
+# GET http://ourapi.com/users/1.json -> {:user => {id: 1}}
+user = User.find(1) do |user|
+  # async
+  # GET http://ourapi.com/users/1/questions.json -> {:questions => [...]}
+  Question.find_all(user_id: user.id) do |questions|
+    # async
+    puts questions
+  end
+end
+
+# Later...
+=> [#<Question @user=#<User>, 
+    #<Question @user=#<User>]
+```
+
+Here's what our files look like:
+
+#### ./app/models/user
+```ruby
+class User < RemoteModule::RemoteModel
+  attr_accessor :id
+
+  has_many :questions
+
+  collection_url "users"
+  member_url "users/:id"
+end
+```
+
+#### ./app/models/question.rb
+```ruby
+class Question < RemoteModule::RemoteModel
+  attr_accessor :id, :question, :is_active
+
+  belongs_to :user
+
+  collection_url "users/:user_id/questions"
+  member_url "users/:user_id/questions/:id"
+
+  custom_urls :active_url => member_url + "/make_active"
+
+  # The urls substitute params based on a passed hash and/or object's methods,
+  # so we define user_id to use for the collection/member urls
+  def user_id
+    user && user.id
+  end
+
+  # An example of how we can use custom URLs to make custom nice(r) methods
+  # EX
+  # a_question.make_active(false) do |question|
+  #   p question.is_active
+  # end
+  def make_active(active)
+    post(self.active_url, payload: {active: active}) do |response, json|
+      self.is_active = json[:question][:is_active]
+      if block_given?
+        yield self
+      end
+    end
+  end
+end
+```
+
+## Installation
+
+```ruby
+gem install remote_model
+```
+
+And now in your Rakefile, require `remote_model`:
+
+```ruby
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require 'remote_model'
+
+Motion::Project::App.setup do |app|
+  ...
+end
+```
+
+## Setup
+
+Add an initialization file somewhere, like ./app/initializers/remote_model.rb. This is where we put the API specifications:
+
+```ruby
+module RemoteModule
+  class RemoteModel
+    # The default URL for our requests.
+    # Overrideable per model subclass
+    self.root_url = "http://localhost:5000/"
+
+    # Options attached to every request
+    # Appendable per model subclass
+    # See BubbleWrap docs on what can be passed in BubbleWrap::HTTP.<method>(url, options)
+    self.default_url_options = {
+        :headers => {
+          "x-api-token" => "some_token",
+          "Accept" => "application/json"
+        }
+      }
+  end
+end
+```
+
+## How?
+
+RemoteModel is designed for JSON APIs which return structures with "nice" properties.
+
+When you make a request with a RemoteModel (self.get/put/post/delete), the result is always parsed as JSON. The ActiveRecord-esque methods take this JSON and create objects out of it. It's clever and creates the proper associations (belongs_to/has_one/has_many) within the objects, as defined in the models.
+
+#### FormatableString
+
+The AR methods also use the member/collection defined URLs to make requests. These URLs are a string which you can use :symbols to input dynamic values. These strings can be formatted using a hash and/or using an object (it will look to see if the object responds to these symbols and call the method if applicable):
+
+```ruby
+>> s = RemoteModule::FormatableString.new("url/:param")
+=> "url/:param"
+>> s.format({param: 6})
+=> "url/6"
+>> obj = Struct.new("Paramer", :param).new(param: 100)
+=> ...
+>> s.format({}, obj)
+=>  "url/100"
+```
+
+RemoteModels can define custom urls and call those as methods (see question.rb above).
+
+## Todo
+
+- More tests
+- CoreData integration

data/Rakefile

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

data/app/app_delegate.rb

@@ -0,0 +1,7 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    @window.rootViewController = UIViewController.alloc.init
+    true
+  end
+end

data/examples/FacebookGraph/.gitignore

@@ -0,0 +1,2 @@
+.repl_history
+build

data/examples/FacebookGraph/README.md

@@ -0,0 +1,34 @@
+# Facebook Graph Example
+
+The Facebook Graph API is a great example of how powerful RemoteModel is. Facebook auth code adapted from [facebook-auth-ruby-motion-example](https://github.com/aaronfeng/facebook-auth-ruby-motion-example)
+
+![Facebook Example Pic](http://i.imgur.com/BAwTK.png)
+
+## Running
+
+You need [motion-cocoapods](https://github.com/HipByte/motion-cocoapods) installed to load the Facebook iOS SDK. 
+
+It also appears that (as of May 9 2011), motion-cocoapods doesn't play nice with the FB SDK and you need to use `rake --trace` to get it to load correctly.
+
+You need to specify an FB app ID, which you can create [in FB's Developer app](https://www.facebook.com/developers):
+
+###### app_delegate.rb
+
+```ruby
+def application(application, didFinishLaunchingWithOptions:launchOptions)
+  ...
+  @facebook = Facebook.alloc.initWithAppId("YOUR-APP-ID", andDelegate:self)
+  ...
+end
+```
+
+###### Rakefile
+
+```ruby
+Motion::Project::App.setup do |app|
+  ...
+  fb_app_id = "YOUR-APP-ID"
+  app.info_plist['CFBundleURLTypes'] = [{'CFBundleURLSchemes' => ["fb#{fb_app_id}"]}]
+  ...
+end
+```

data/examples/FacebookGraph/Rakefile

@@ -0,0 +1,19 @@
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require 'motion-cocoapods'
+require 'remote_model'
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = 'FacebookGraph'
+  app.files_dependencies 'app/controllers/facebook_login_controller.rb' => 'app/initializers/remote_model.rb'
+  fb_app_id = "YOUR-APP-ID"
+  if fb_app_id == "YOUR-APP-ID"
+    raise "You need to specify a Facebook App ID in ./Rakefile"
+  end
+  app.info_plist['CFBundleURLTypes'] = [{'CFBundleURLSchemes' => ["fb#{fb_app_id}"]}]
+
+  app.pods do
+    dependency 'Facebook-iOS-SDK'
+  end
+end

data/examples/FacebookGraph/app/app_delegate.rb

@@ -0,0 +1,52 @@
+class AppDelegate
+  attr_accessor :facebook
+  attr_accessor :navigationController
+
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    @navigationController = UINavigationController.alloc.init
+    @window.rootViewController = @navigationController
+
+    fb_app_id = "YOUR-APP-ID"
+    if fb_app_id == "YOUR-APP-ID"
+      raise "You need to specify a Facebook App ID in ./app/app_delegate.rb"
+    end
+    @facebook = Facebook.alloc.initWithAppId(fb_app_id, andDelegate:self)
+
+    defaults = NSUserDefaults.standardUserDefaults
+
+    if defaults["FBAccessTokenKey"] && defaults["FBExpirationDateKey"]
+      @facebook.accessToken = defaults["FBAccessTokenKey"]
+      @facebook.expirationDate = defaults["FBExpirationDateKey"]
+    end
+
+    if facebook.isSessionValid
+      openFriendsContorller
+    else
+      @navigationController.pushViewController(FacebookLoginController.alloc.init, animated: false)
+    end
+
+    @window.rootViewController.wantsFullScreenLayout = true
+    @window.makeKeyAndVisible
+    true
+  end
+
+  def openFriendsContorller
+    @navigationController.setViewControllers([FriendsController.alloc.initWithUserId], animated: false)
+  end
+
+  def fbDidLogin
+    defaults = NSUserDefaults.standardUserDefaults
+    defaults["FBAccessTokenKey"] = @facebook.accessToken
+    defaults["FBExpirationDateKey"] = @facebook.expirationDate
+    defaults.synchronize
+    openFriendsContorller
+  end
+
+  def application(application,
+                  openURL:url,
+                  sourceApplication:sourceApplication,
+                  annotation:annotation)
+    @facebook.handleOpenURL(url)
+  end
+end

data/examples/FacebookGraph/app/controllers/facebook_login_controller.rb

@@ -0,0 +1,21 @@
+class FacebookLoginController < UIViewController
+  def viewDidLoad
+    self.title = "Login"
+    self.view.backgroundColor = UIColor.whiteColor
+
+    button = UIButton.buttonWithType UIButtonTypeRoundedRect
+    button.when(UIControlEventTouchUpInside) do
+      UIApplication.sharedApplication.delegate.facebook.authorize nil
+    end
+    button.setTitle("FB Login", forState: UIControlStateNormal)
+    button.sizeToFit
+
+    # ugly, dont really do this.
+    width, height = button.frame.size.width, button.frame.size.height
+    button.frame = CGRectMake(((self.view.frame.size.width - width) / 2).round, 
+                              ((self.view.frame.size.height - height) / 2).round, 
+                              width, 
+                              height)
+    self.view.addSubview button
+  end
+end

data/examples/FacebookGraph/app/controllers/friends_controller.rb

@@ -0,0 +1,82 @@
+class FriendsController < UITableViewController
+  attr_reader :user
+
+  def initWithUserId(id = "me")
+    @user = User.new(id: id)
+    self
+  end
+
+  def initWithUser(user)
+    raise "User cannot be nil" if user.nil?
+    @user = user
+    self
+  end
+
+  def viewDidLoad
+    super
+    self.title = "About #{@user.name || @user.id}"
+
+    defaults = NSUserDefaults.standardUserDefaults
+    RemoteModule::RemoteModel.set_access_token(defaults["FBAccessTokenKey"])
+    
+    @activity = UIActivityIndicatorView.alloc.initWithActivityIndicatorStyle(UIActivityIndicatorViewStyleGray)
+    self.view.addSubview @activity
+    @activity.center = CGPointMake(self.view.frame.size.width/2, self.view.frame.size.height/2)
+    @activity.startAnimating
+
+    @user.find_friends do |user|
+      @activity.stopAnimating
+      @activity.removeFromSuperview
+      self.tableView.reloadData
+    end
+  end
+
+  def numberOfSectionsInTableView(tableView)
+    return 2
+  end
+
+  def tableView(tableView, titleForHeaderInSection:section)
+    return ["Wall Posts", "Friends"][section]
+  end
+
+  def tableView(tableView, numberOfRowsInSection:section)
+    return [1, @user.friends.count][section]
+  end
+
+  def layout_friend_in_cell(friend, cell)
+    cell.textLabel.text = friend.name
+    cell.detailTextLabel.text = friend.id
+  end
+
+  def tableView(tableView, cellForRowAtIndexPath:indexPath)
+    reuseIdentifier = ["WallPostsCell","FriendCell"][indexPath.section]
+
+    cell = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier) || begin
+      cell = UITableViewCell.alloc.initWithStyle(UITableViewCellStyleSubtitle, reuseIdentifier:reuseIdentifier)
+      cell
+    end
+
+    cell.accessoryType = [UITableViewCellAccessoryDisclosureIndicator, UITableViewCellAccessoryNone][indexPath.section]
+
+    if indexPath.section == 0
+      cell.textLabel.text = "Wall Posts"
+      cell.detailTextLabel.text = ""
+    else
+      friend = @user.friends[indexPath.row]
+      layout_friend_in_cell(friend, cell)
+    end
+
+    cell
+  end
+
+  def tableView(tableView, didSelectRowAtIndexPath:indexPath)
+    tableView.deselectRowAtIndexPath(indexPath, animated:true)
+
+    if indexPath.section == 0
+      UIApplication.sharedApplication.delegate.navigationController.pushViewController(WallPostsController.alloc.initWithUser(user), animated: true)
+    else
+      friend = @user.friends[indexPath.row]
+      UIApplication.sharedApplication.delegate.navigationController.pushViewController(FriendsController.alloc.initWithUser(friend), animated: true)
+    end
+  end
+end

data/examples/FacebookGraph/app/controllers/wall_posts_controller.rb

@@ -0,0 +1,51 @@
+class WallPostsController < UITableViewController
+  attr_reader :user
+
+  def initWithUser(user)
+    raise "User cannot be nil" if user.nil?
+    @user = user
+    self
+  end
+
+  def viewDidLoad
+    super
+    self.title = "Wall Posts for #{@user.name || @user.id}"
+
+    defaults = NSUserDefaults.standardUserDefaults
+    RemoteModule::RemoteModel.set_access_token(defaults["FBAccessTokenKey"])
+    
+    @activity = UIActivityIndicatorView.alloc.initWithActivityIndicatorStyle(UIActivityIndicatorViewStyleGray)
+    self.view.addSubview @activity
+    @activity.center = CGPointMake(self.view.frame.size.width/2, self.view.frame.size.height/2)
+    @activity.startAnimating
+
+    @user.find_wall_posts do |user|
+      @activity.stopAnimating
+      @activity.removeFromSuperview
+      self.tableView.reloadData
+    end
+  end
+
+  def tableView(tableView, numberOfRowsInSection:section)
+    return @user.wall_posts.count
+  end
+
+  def tableView(tableView, cellForRowAtIndexPath:indexPath)
+    reuseIdentifier = "WallPostCell"
+
+    cell = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier) || begin
+      cell = UITableViewCell.alloc.initWithStyle(UITableViewCellStyleSubtitle, reuseIdentifier:reuseIdentifier)
+      cell
+    end
+
+    wall_post = @user.wall_posts[indexPath.row]
+    cell.textLabel.text = wall_post.message
+    cell.detailTextLabel.text = wall_post.created_time_string
+
+    cell
+  end
+
+  def tableView(tableView, didSelectRowAtIndexPath:indexPath)
+    tableView.deselectRowAtIndexPath(indexPath, animated:true)
+  end
+end

data/examples/FacebookGraph/app/initializers/remote_model.rb

@@ -0,0 +1,14 @@
+module RemoteModule
+  class RemoteModel
+    self.root_url = "https://graph.facebook.com/"
+    self.extension = ""
+
+    def self.set_access_token(token)
+      self.default_url_options = {
+        :query => {
+            "access_token" => token
+        }
+      }
+    end
+  end
+end

data/examples/FacebookGraph/app/models/User.rb

@@ -0,0 +1,49 @@
+class User < RemoteModule::RemoteModel
+  attr_accessor :id, :name, :bio
+
+  has_many :wall_posts
+  has_many :friends => :user
+
+  collection_url ""
+  member_url ":id"
+
+  custom_urls :friends_url => member_url + "/friends",
+              :wall_posts_url => member_url + "/feed"
+
+  # EX
+  # user.find_friends do |user|
+  #   p user.friends[0]
+  # end
+  def find_friends(&block)
+    get(self.friends_url) do |response, json|
+      self.friends = (json && json[:data]) || []
+      if json.nil?
+        show_privacy_alert("Friends")
+      end
+      if block
+        block.call self
+      end
+    end
+  end
+
+  def find_wall_posts(&block)
+    get(self.wall_posts_url) do |response, json|
+      self.wall_posts = (json && json[:data]) || []
+      if json.nil?
+        show_privacy_alert("Wall Posts")
+      end
+      if block
+        block.call self
+      end
+    end
+  end
+
+  private
+  def show_privacy_alert(entity)
+    alert = UIAlertView.new
+    alert.title = "#{entity} not given"
+    alert.message = "Denied privacy permissions."
+    alert.addButtonWithTitle "OK"
+    alert.show
+  end
+end

data/examples/FacebookGraph/app/models/wall_post.rb

@@ -0,0 +1,43 @@
+class WallPost < RemoteModule::RemoteModel
+  attr_accessor :id, :message
+  attr_accessor :created_time
+
+  # if we encounter "from" in the JSON return,
+  # use the User class.
+  has_one :from => :user
+
+  collection_url ""
+  member_url ":id"
+
+  def self.from_string_date_formatter
+    @from_string_date_formatter ||= begin
+      dateFormat = NSDateFormatter.alloc.init
+      dateFormat.dateFormat = "yyyy-MM-dd'T'HH:mm:ssZ"
+      dateFormat
+    end
+  end
+
+  def self.to_string_date_formatter
+    @to_string_date_formatter ||= begin
+      dateFormat = NSDateFormatter.alloc.init
+      dateFormat.dateFormat = "yyyy'-'MM'-'dd"
+      dateFormat
+    end
+  end
+
+  # EX 2012-05-09T21:57:42+0000
+  def created_time=(created_time)
+    if created_time.class == String
+      @created_time = WallPost.from_string_date_formatter.dateFromString(created_time)
+    elsif created_time.class == NSDate
+      @created_time = created_time
+    else
+      raise "Incorrect class for created_time: #{created_time.class.to_s}"
+    end
+    @created_time
+  end
+
+  def created_time_string
+    @created_time.nil? ? "" : WallPost.to_string_date_formatter.stringFromDate(@created_time)
+  end
+end

data/examples/FacebookGraph/spec/main_spec.rb

@@ -0,0 +1,9 @@
+describe "Application 'FacebookGraph'" do
+  before do
+    @app = UIApplication.sharedApplication
+  end
+
+  it "has one window" do
+    @app.windows.size.should == 1
+  end
+end

data/lib/remote_model.rb

@@ -0,0 +1,12 @@
+require "remote_model/version"
+require "bubble-wrap"
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'remote_model/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/lib/remote_model/formatable_string.rb

@@ -0,0 +1,25 @@
+module RemoteModule
+  class FormatableString < String
+    # Takes in a hash and spits out the formatted string
+    # Checks the delegate first
+    def format(params = {}, delegate = nil)
+      params ||= {}
+      split = self.split '/'
+      split.collect { |path|
+        ret = path
+        if path[0] == ':'
+          path_sym = path[1..-1].to_sym
+
+          curr = nil
+          if delegate && delegate.respond_to?(path_sym)
+            curr = delegate.send(path_sym)
+          end
+
+          ret = (curr || params[path_sym] || path).to_s
+        end
+
+        ret
+      }.join '/'
+    end
+  end
+end

data/lib/remote_model/record.rb

@@ -0,0 +1,63 @@
+module RemoteModule
+  #################################
+  # ActiveRecord-esque methods
+  class RemoteModel
+    class << self
+      def find(id, params = {}, &block)
+        get(member_url.format(params.merge(id: id))) do |response, json|
+          obj = self.new(json)
+          request_block_call(block, obj, response)
+        end
+      end
+
+      def find_all(params = {}, &block)
+        get(collection_url.format(params)) do |response, json|
+          objs = []
+          arr_rep = nil
+          if json.class == Array
+            arr_rep = json
+          elsif json.class == Hash
+            plural_sym = self.pluralize.to_sym
+            if json.has_key? plural_sym
+              arr_rep = json[plural_sym]
+            end
+          end
+          arr_rep.each { |one_obj_hash|
+            objs << self.new(one_obj_hash)
+          }
+          request_block_call(block, objs, response)
+        end
+      end
+
+      # Enables the find
+      private
+      def request_block_call(block, default_arg, extra_arg)
+        if block
+          if block.arity == 1
+            block.call default_arg
+          elsif block.arity == 2
+            block.call default_arg, extra_arg
+          else
+            raise "Not enough arguments to block"
+          end
+        else
+          raise "No block given"
+        end
+      end
+    end
+
+    # EX
+    # a_model.destroy do |response, json|
+    #   if json[:success]
+    #     p "success!"
+    #   end
+    # end
+    def destroy(&block)
+      delete(member_url) do |response, json|
+        if block
+          block.call response, json
+        end
+      end
+    end
+  end
+end

data/lib/remote_model/remote_model.rb

@@ -0,0 +1,218 @@
+module RemoteModule
+  class RemoteModel
+    HTTP_METHODS = [:get, :post, :put, :delete]
+
+    class << self
+      # These three methods (has_one/many/ + belongs_to)
+      # map a symbol to a class for method_missing lookup 
+      # for each :symbol in params.
+      # Can also be used to view the current mappings:
+      # EX
+      # Question.has_one
+      # => {:user => User}
+
+      # EX 
+      # self.has_one :question, :answer, :camel_case
+      # => {:question => Question, :answer => Answer, :camel_case => CamelCase}
+      def has_one(params = [])
+        make_fn_lookup "has_one", params, singular_klass_str_lambda
+      end
+
+      # EX 
+      # self.has_many :questions, :answers, :camel_cases
+      # => {:questions => Question, :answers => Answer, :camel_cases => CamelCase}
+      def has_many(params = [])
+        make_fn_lookup "has_many", params, lambda { |sym| sym.to_s.singularize.split("_").collect {|s| s.capitalize}.join }
+      end
+
+      # EX 
+      # self.belongs_to :question, :answer, :camel_case
+      # => {:question => Question, :answer => Answer, :camel_case => CamelCase}
+      def belongs_to(params = [])
+        make_fn_lookup "belongs_to", params, singular_klass_str_lambda
+      end
+
+      def pluralize
+        self.to_s.downcase + "s"
+      end
+
+      def method_missing(method, *args, &block)
+        if self.custom_urls.has_key? method
+          return self.custom_urls[method].format(args && args[0], self)
+        end
+
+        super
+      end
+
+      private
+      # This is kind of neat.
+      # Because models can be mutually dependent (User has a Question, Question has a User),
+      # sometimes RubyMotion hasn't loaded the classes when this is run.
+      # SO we check to see if the class is loaded; if not, then we just add it to the
+      # namespace to make everything run smoothly and assume that by the time the app is running,
+      # all the classes have been loaded.
+      def make_klass(klass_str)
+        begin
+          klass = Object.const_get(klass_str)
+        rescue NameError => e
+          klass = Object.const_set(klass_str, Class.new(RemoteModule::RemoteModel))
+        end
+      end
+
+      def singular_klass_str_lambda
+        lambda { |sym| sym.to_s.split("_").collect {|s| s.capitalize}.join }
+      end
+
+      # How we fake define_method, essentially.
+      # ivar_suffix -> what is the new @ivar called
+      # params -> the :symbols to map to classes
+      # transform -> how we transform the :symbol into a class name
+      def make_fn_lookup(ivar_suffix, params, transform)
+        ivar = "@" + ivar_suffix
+        if !instance_variable_defined? ivar
+          instance_variable_set(ivar, {})
+        end
+        
+        sym_to_klass_sym = {}
+        if params.class == Symbol
+          sym_to_klass_sym[params] = transform.call(params)
+        elsif params.class == Array
+          params.each {|klass_sym|
+            sym_to_klass_sym[klass_sym] = transform.call(klass_sym)
+          }
+        else
+          params.each { |fn_sym, klass_sym| params[fn_sym] = singular_klass_str_lambda.call(klass_sym) }
+          sym_to_klass_sym = params
+        end
+
+        sym_to_klass_sym.each do |relation_sym, klass_sym|
+            klass_str = klass_sym.to_s
+            instance_variable_get(ivar)[relation_sym] = make_klass(klass_str)
+          end
+
+        instance_variable_get(ivar)
+      end
+    end
+
+    def initialize(params = {})
+      update_attributes(params)
+    end
+
+    def update_attributes(params = {})
+      attributes = self.methods - Object.methods
+      params.each do |key, value|
+        if attributes.member?((key.to_s + "=:").to_sym)
+          self.send((key.to_s + "=:").to_sym, value)
+        end
+      end
+    end
+
+    def remote_model_methods
+      methods = []
+      [self.class.has_one, self.class.has_many, self.class.belongs_to].each {|fn_hash|
+        methods += fn_hash.collect {|sym, klass|
+          [sym, (sym.to_s + "=:").to_sym, ("set" + sym.to_s.capitalize).to_sym]
+        }.flatten
+      }
+      methods + RemoteModule::RemoteModel::HTTP_METHODS
+    end
+
+    def methods
+      super + remote_model_methods
+    end
+
+    def respond_to?(symbol, include_private = false)
+      if remote_model_methods.include? symbol
+        return true
+      end
+
+      super
+    end
+
+    def method_missing(method, *args, &block)
+      # Check for custom URLs
+      if self.class.custom_urls.has_key? method
+        return self.class.custom_urls[method].format(args && args[0], self)
+      end
+
+      # has_one relationships
+      if self.class.has_one.has_key?(method) || self.class.belongs_to.has_key?(method)
+        return instance_variable_get("@" + method.to_s)
+      elsif (setter_vals = setter_klass(self.class.has_one, method) || setter_vals = setter_klass(self.class.belongs_to, method))
+        klass, hash_symbol = setter_vals
+        obj = args[0]
+        if obj.class != klass
+          obj = klass.new(obj)
+        end
+        return instance_variable_set("@" + hash_symbol.to_s, obj)
+      end
+
+      # has_many relationships
+      if self.class.has_many.has_key?(method)
+        ivar = "@" + method.to_s
+        if !instance_variable_defined? ivar
+          instance_variable_set(ivar, [])
+        end
+        return instance_variable_get ivar
+      elsif (setter_vals = setter_klass(self.class.has_many, method))
+        klass, hash_symbol = setter_vals
+        ivar = "@" + hash_symbol.to_s
+
+        tmp = []
+        args[0].each do |arg|
+          rep = nil
+          if arg.class == Hash
+            rep = klass.new(arg)
+          elsif arg.class == klass
+            rep = arg
+          end
+
+          if rep.class.belongs_to.values.member? self.class
+            rep.send((rep.class.belongs_to.invert[self.class].to_s + "=").to_sym, self)
+          end
+
+          tmp << rep
+        end
+
+        instance_variable_set(ivar, tmp)
+        return instance_variable_get(ivar)
+      end
+
+      # HTTP methods
+      if RemoteModule::RemoteModel::HTTP_METHODS.member? method
+        return self.class.send(method, *args, &block)
+      end
+
+      super
+    end
+
+    private
+    # PARAMS For a given method symbol, look through the hash
+    #   (which is a map of :symbol => Class)
+    #   and see if that symbol applies to any keys.
+    # RETURNS an array [Klass, symbol] for which the original
+    #   method symbol applies.
+    # EX
+    # setter_klass({:answers => Answer}, :answers=)
+    # => [Answer, :answers]
+    # setter_klass({:answers => Answer}, :setAnswers)
+    # => [Answer, :answers]
+    def setter_klass(hash, symbol)
+
+      # go ahead and guess it's of the form :symbol=:
+      hash_symbol = symbol.to_s[0..-2].to_sym
+
+      # if it's the ObjC style setSymbol, change it to that.
+      if symbol[0..2] == "set"
+        # handles camel case arguments. ex setSomeVariableLikeThis => some_variable_like_this
+        hash_symbol = symbol.to_s[3..-1].split(/([[:upper:]][[:lower:]]*)/).delete_if(&:empty?).map(&:downcase).join("_").to_sym
+      end
+
+      klass = hash[hash_symbol]
+      if klass.nil?
+        return nil
+      end
+      [klass, hash_symbol]
+    end
+  end
+end

data/lib/remote_model/requests.rb

@@ -0,0 +1,95 @@
+module RemoteModule
+  class RemoteModel
+    class << self
+      attr_accessor :root_url, :default_url_options
+      attr_writer :extension
+
+      def extension
+        @extension || (self == RemoteModel ? false : RemoteModel.extension) || ".json"
+      end
+
+      #################################
+      # URLs for the resource
+      # Can be called by <class>.<url>
+      def collection_url(url_format = -1)
+        return @collection_url || nil if url_format == -1
+
+        @collection_url = RemoteModule::FormatableString.new(url_format)
+      end
+
+      def member_url(url_format = -1)
+        return @member_url if url_format == -1
+
+        @member_url = RemoteModule::FormatableString.new(url_format)
+      end
+
+      def custom_urls(params = {})
+        @custom_urls ||= {}
+        params.each do |fn, url_format|
+          @custom_urls[fn] = RemoteModule::FormatableString.new(url_format)
+        end
+        @custom_urls
+      end
+
+      #################################
+      # URL helpers (via BubbleWrap)
+      # EX
+      # Question.get(a_question.custom_url) do |response, json|
+      #   p json
+      # end
+      def get(url, params = {}, &block)
+        http_call(:get, url, params, &block)
+      end
+
+      def post(url, params = {}, &block)
+        http_call(:post, url, params, &block)
+      end
+
+      def put(url, params = {}, &block)
+        http_call(:put, url, params, &block)
+      end
+
+      def delete(url, params = {}, &block)
+        http_call(:delete, url, params, &block)
+      end
+
+      private
+      def complete_url(fragment)
+        if fragment[0..3] == "http"
+          return fragment
+        end
+        (self.root_url || RemoteModule::RemoteModel.root_url) + fragment +  self.extension
+      end
+
+      def http_call(method, url, call_options = {}, &block)
+        options = call_options 
+        options.merge!(RemoteModule::RemoteModel.default_url_options || {})
+        if query = options.delete(:query)
+          if url.index("?").nil?
+            url += "?"
+          end
+          url += query.map{|k,v| "#{k}=#{v}"}.join('&')
+        end
+        if self.default_url_options
+          options.merge!(self.default_url_options)
+        end
+        BubbleWrap::HTTP.send(method, complete_url(url), options) do |response|
+          if response.ok?
+            json = BubbleWrap::JSON.parse(response.body.to_str)
+            block.call response, json
+          else
+            block.call response, nil
+          end
+        end
+      end
+    end
+
+    def collection_url(params = {})
+      self.class.collection_url.format(params, self)
+    end
+
+    def member_url(params = {})
+      self.class.member_url.format(params, self)
+    end
+  end
+end

data/lib/remote_model/string.rb

@@ -0,0 +1,9 @@
+class String
+  def pluralize
+    self + "s"
+  end
+
+  def singularize
+    self[0..-2]
+  end
+end

data/lib/remote_model/version.rb

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

data/remote_model.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/remote_model/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "remote_model"
+  s.version     = RemoteModel::VERSION
+  s.authors     = ["Clay Allsopp"]
+  s.email       = ["clay.allsopp@gmail.com"]
+  s.homepage    = "https://github.com/clayallsopp/remote_model"
+  s.summary     = "JSON API <-> NSObject via RubyMotion"
+  s.description = "JSON API <-> NSObject via RubyMotion. Create REST-aware models."
+
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+  s.add_dependency "bubble-wrap"
+end

data/spec/record_spec.rb

@@ -0,0 +1,113 @@
+class User < RemoteModule::RemoteModel
+  attr_accessor :id
+
+  has_many :questions
+end
+
+class Answer < RemoteModule::RemoteModel
+  attr_accessor :id
+
+  belongs_to :question
+end
+
+class Question < RemoteModule::RemoteModel
+  attr_accessor :id, :question
+
+  belongs_to :user
+  has_many :answers
+
+  def user_id
+    user && user.id
+  end
+end
+
+class CamelCaseModel < RemoteModule::RemoteModel
+  has_one :another_camel_case_model
+  has_many :bunch_of_camel_case_models
+end
+
+class AnotherCamelCaseModel < RemoteModule::RemoteModel
+  attr_accessor :id
+
+  belongs_to :camel_case_model
+end
+
+class BunchOfCamelCaseModel < RemoteModule::RemoteModel
+  belongs_to :camel_case_model
+end
+
+describe "The active record-esque stuff" do
+  it "creates object from hash" do
+    hash = {id: 5, question: "Hello my name is clay"}
+    q = Question.new(hash)
+    hash.each {|key, value|
+      q.send(key).should == value
+    }
+
+    # test other classes
+    [User, Answer].each {|klass|
+      hash = {id: 1337}
+      obj = klass.new(hash)
+      obj.id.should == hash[:id]
+    }
+  end
+
+  it "creates nested objects" do
+    hash = {id: 5, question: "question this", user: {id: 6}}
+    q = Question.new(hash)
+    q.user.class.should == User
+    q.user.id.should == hash[:user][:id]
+  end
+
+  def check_question_and_answers(q, answers)
+    q.answers.count.should == answers.count
+    q.answers.each_with_index { |answer, index|
+      answer.class.should == Answer
+      answer.id.should == answers[index][:id]
+      answer.question.should == q
+    }
+  end
+
+  it "creates nested relationships" do
+    answers = [{id: 3, id: 100}]
+    hash = {id: 5, question: "my question", answers: answers}
+    q = Question.new(hash)
+    check_question_and_answers(q, answers)
+  end
+
+  it "creates inception relationships" do
+    answers = [[], [{id: 3, id: 100}]]
+    questions = [{id: 8, question: "question 8"}, {id: 10, question: "question 10", answers: answers[1]}]
+    hash = {id: 1, questions: questions}
+    u = User.new(hash)
+    u.questions.count.should == questions.count
+    u.questions.each_with_index {|q, index|
+      q.class.should == Question
+      q.user.should == u
+      q.id.should == questions[index][:id]
+      q.question.should == questions[index][:question]
+      if q.answers.count > 0
+        check_question_and_answers(q, answers[index])
+      end
+    }
+  end
+
+  it "works with camel cased models" do
+    c = CamelCaseModel.new({another_camel_case_model: {id: 7}, bunch_of_camel_case_models: [{}, {}]})
+    c.another_camel_case_model.class.should == AnotherCamelCaseModel
+    c.another_camel_case_model.id.should == 7
+    c.bunch_of_camel_case_models.count.should == 2
+    c.bunch_of_camel_case_models.each {|model|
+      model.class.should == BunchOfCamelCaseModel
+    }
+
+    c.setAnotherCamelCaseModel({id: 8})
+    c.another_camel_case_model.id.should == 8
+
+    c.setBunchOfCamelCaseModels([{}, {}, {}])
+    c.bunch_of_camel_case_models.count.should == 3
+    c.bunch_of_camel_case_models.each {|model|
+      model.class.should == BunchOfCamelCaseModel
+    }
+  end
+end

data/spec/remote_model_spec.rb

@@ -0,0 +1,35 @@
+class CustomUrlModel < RemoteModule::RemoteModel
+  collection_url "collection"
+  member_url "collection/:id"
+
+  custom_urls :a_url => "custom", :format_url => "custom/:var",
+    :method_url => "custom/:a_method"
+
+  def id
+    8
+  end
+
+  def a_method
+    10
+  end
+end
+
+describe "URLs" do
+  it "should make visible urls at class and instance level" do
+    CustomUrlModel.a_url.should == "custom"
+    CustomUrlModel.collection_url.should == "collection"
+    CustomUrlModel.member_url.should == "collection/:id"
+
+    # NOTE that Class.member_url(params) won't work (it's the setter).
+    CustomUrlModel.member_url.format(:id => 9).should == "collection/9"
+
+    c = CustomUrlModel.new
+    c.collection_url.should == "collection"
+    c.member_url.should == "collection/8"
+    c.a_url.should == "custom"
+
+    CustomUrlModel.format_url.should == "custom/:var"
+    c.format_url(:var => 3).should == "custom/3"
+    c.method_url.should == "custom/10"
+  end
+end

data/spec/requests_spec.rb

@@ -0,0 +1,14 @@
+describe "The requests stuff" do
+  it "should parse json" do
+    ran = false
+    RemoteModule::RemoteModel.get("http://graph.facebook.com/btaylor") do |response, json|
+      json.class.should == Hash
+      response.ok?.should == true
+      ran = true
+    end
+    # really stupid, haven't made an async request example...
+    wait 5.0 do
+      ran.should == true
+    end
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: remote_model
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Clay Allsopp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bubble-wrap
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: JSON API <-> NSObject via RubyMotion. Create REST-aware models.
+email: 
+- clay.allsopp@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .gitmodules
+- Gemfile
+- README.md
+- Rakefile
+- app/app_delegate.rb
+- examples/FacebookGraph/.gitignore
+- examples/FacebookGraph/README.md
+- examples/FacebookGraph/Rakefile
+- examples/FacebookGraph/app/app_delegate.rb
+- examples/FacebookGraph/app/controllers/facebook_login_controller.rb
+- examples/FacebookGraph/app/controllers/friends_controller.rb
+- examples/FacebookGraph/app/controllers/wall_posts_controller.rb
+- examples/FacebookGraph/app/initializers/remote_model.rb
+- examples/FacebookGraph/app/models/User.rb
+- examples/FacebookGraph/app/models/wall_post.rb
+- examples/FacebookGraph/spec/main_spec.rb
+- lib/remote_model.rb
+- lib/remote_model/formatable_string.rb
+- lib/remote_model/record.rb
+- lib/remote_model/remote_model.rb
+- lib/remote_model/requests.rb
+- lib/remote_model/string.rb
+- lib/remote_model/version.rb
+- remote_model.gemspec
+- spec/record_spec.rb
+- spec/remote_model_spec.rb
+- spec/requests_spec.rb
+homepage: https://github.com/clayallsopp/remote_model
+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: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: JSON API <-> NSObject via RubyMotion
+test_files: 
+- spec/record_spec.rb
+- spec/remote_model_spec.rb
+- spec/requests_spec.rb