meteor-motion 0.1.0

data/app/controllers/connection_controller.rb

@@ -0,0 +1,83 @@
+class ConnectionController < UIViewController
+
+	def viewDidLoad
+    super
+
+    self.view.backgroundColor = UIColor.whiteColor
+    @label = UILabel.alloc.initWithFrame(CGRectZero)
+    @label.text = "Connecting..."
+    @label.sizeToFit
+    @label.center = CGPointMake(self.view.frame.size.width / 2, self.view.frame.size.height / 2)
+    self.view.addSubview @label
+
+		@meteorClient = MeteorMotion::Client.new
+		@meteorClient.on_error( self.method(:meteor_error) )
+		@meteorClient.connect 'localhost', 3000, self.method(:connected)
+
+  end
+
+  def connected result, details
+		if result
+			@meteorClient.add_collection('books')
+			@meteorClient.subscribe('books')
+
+			form = buildLoginForm
+
+			@controller = LoginController.alloc.initWithForm(form)
+			@controller.meteor = @meteorClient
+
+  		self.presentViewController( @controller, animated: true, completion: nil )
+  	else
+  		exit(0)
+  	end
+	end
+
+  # Meteor basic error handler - alert error to screen
+  #
+  def meteor_error code, reason, details
+  	if reason != :unknown
+  		alert = UIAlertView.new
+  		alert.message = reason.to_s
+  		alert.addButtonWithTitle "OK"
+  		alert.show
+  	else
+  		puts "Meteor Error: #{reason}. Details: #{details}"
+  	end
+  end
+
+
+  def buildLoginForm
+  	form = Formotion::Form.new
+
+		form.build_section do |section|
+		  section.title = "Credentials"
+
+		  section.build_row do |row|
+		    row.title = "Username"
+		    row.key = :user
+		    row.type = :string
+		    row.auto_correction = :no
+	  		row.auto_capitalization = :none
+	  		row.placeholder = 'Your username'
+		  end
+
+		  section.build_row do |row|
+		    row.title = "Password"
+		    row.key = :pass
+		    row.type = :string
+		    row.secure = true
+		    row.auto_correction = :no
+	  		row.auto_capitalization = :none
+	  		row.placeholder = 'Your password'
+		  end
+
+		  section.build_row do |row|
+		  	row.title = 'Submit'
+		  	row.type = :submit
+		  end
+		end
+
+		return form
+  end
+
+end

data/app/controllers/login_controller.rb

@@ -0,0 +1,35 @@
+class LoginController < Formotion::FormController
+	attr_accessor :meteor
+
+  def viewDidLoad
+    super
+
+    self.view.backgroundColor = UIColor.whiteColor
+    self.title = "Login"
+
+    self.form.on_submit do |form|
+    	data = form.render
+    	self.view.endEditing(true)
+
+    	@meteor.login_with_username( data[:user], data[:pass], self.method(:login_handler) )
+    end
+
+  end
+
+  def login_handler action, details
+  	if action == :success
+  		controller = BookListController.alloc.initWithNibName(nil, bundle: nil)
+			controller.meteor = @meteor
+			navigationController = UINavigationController.alloc.initWithRootViewController(controller)
+
+			self.presentViewController(navigationController , animated: true, completion: nil)
+
+  	elsif action == :error
+  		alert = UIAlertView.new
+  		alert.message = "Error: #{details['reason'].to_s}"
+  		alert.addButtonWithTitle "OK"
+  		alert.show
+  	end
+  end
+
+end

data/lib/meteor-motion.rb

@@ -0,0 +1,12 @@
+require "meteor-motion/version"
+BW.require 'motion/**/*.rb'
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  app.vendor_project(File.expand_path(File.join(File.dirname(__FILE__), '../vendor/SocketRocket')), :static, cflags: "-fobjc-arc")
+  app.libs += ['/usr/lib/libicucore.dylib']
+ 	app.frameworks += ['CFNetwork', 'Security', 'Foundation']
+end

data/lib/meteor-motion/version.rb

@@ -0,0 +1,3 @@
+module MeteorMotion
+  VERSION = "0.1.0"
+end

data/meteor-motion.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'meteor-motion/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "meteor-motion"
+  spec.version       = MeteorMotion::VERSION
+  spec.authors       = ["Miguel Tavares"]
+  spec.email         = ["mtavares.azrael@gmail.com"]
+  spec.description   = %q{Write a gem description}
+  spec.summary       = %q{Write a gem summary}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'bubble-wrap'
+  spec.add_dependency 'rm-digest'
+  spec.add_dependency 'motion_model'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "motion-redgreen"
+end

data/motion/adapters/motion_model.rb

@@ -0,0 +1,61 @@
+module MeteorMotion
+	module Adapters
+		module MotionModel
+			include ::MotionModel::ArrayModelAdapter
+
+			def self.set_client client
+				@@client = client
+			end
+
+
+
+			# Sends the data to the server and supers for the record to be saved. If saving on the server fails
+			# it has to be dealt with by the user.
+			def do_insert options = {}
+				if !options[:local]
+					attr_hash = build_attr_hash
+					id = SecureRandom.hex
+					@@client.call("/#{self.class.to_s.downcase}/insert", self.method(:handle_update), [{_id: id}.merge(attr_hash)])
+				end
+
+				super
+			end
+
+			def do_update options = {}
+				if !options[:local]
+					id = self.get_attr(:id)
+					@@client.call("/#{self.class.to_s.downcase}/update", self.method(:handle_update), [{_id: id}, attr_hash])
+				end
+
+				super
+			end
+
+			def do_delete 
+				send_remove
+
+				super
+			end
+
+			def send_remove
+				id = self.get_attr(:id)
+				@@client.call("/#{self.class.to_s.downcase}/remove", self.method(:handle_remove), [{_id: id}])
+			end
+			
+			def build_attr_hash
+				attributes.reject{|k,v| k == :id}
+			end
+
+			# Stubs to handle inserts, updates and deletes. Can be overrriden by superclass
+			#
+			def handle_insert action, result; end
+			def handle_update action, result; end
+			def handle_remove action, result; end
+
+			# Nasty, nasty hack to work around inheritance issues. TODO: refactor as adapter.
+			def superclass
+				return Object
+			end
+
+		end
+	end
+end

data/motion/client.rb

@@ -0,0 +1,179 @@
+module MeteorMotion
+	class Client
+		attr_accessor :collections, :subscriptions, :method_callbacks
+
+		def initialize
+			@collections = {}
+			@subscriptions = {}
+			@method_callbacks = {}
+
+			@auth_client = nil
+			@auth_key = nil
+			@username = nil
+			@password = nil
+
+			@ddp = MeteorMotion::DDP.new self
+			@error_handler = nil
+
+			MeteorMotion::Adapters::MotionModel.set_client(self)
+		end
+
+
+		def connect hostname='localhost', port=3000, callback=nil
+			@ddp.connect hostname, port
+			if callback
+				@method_callbacks['connect'] = callback
+			end
+		end
+
+		def handle_connect status
+			if @method_callbacks['connect']
+				obj = { method: @method_callbacks['connect'], action: status == :success, result: nil}
+				self.performSelectorInBackground('background_method_handler:', withObject: obj)
+				@method_callbacks.delete('connect')
+			end
+		end
+
+		def add_collection klass, name = ""
+			if klass.is_a? String
+				if @collections[klass]
+					raise "A MeteorMotion::Collection named '#{klass}' already exists."
+				end
+
+				@collections[klass] = MeteorMotion::Collections::Default.new klass
+			else
+				coll = MeteorMotion::Collections::MotionModel.new klass, name
+
+				@collections[coll.name] = coll
+			end
+		end
+
+
+		def remove_collection name
+			@collections.delete(name)
+		end
+
+
+		def subscribe pub_name, params=[]
+			sub_id = @ddp.sub(pub_name, params)
+			@subscriptions[sub_id] = {name: pub_name, ready: false}
+
+			return sub_id
+		end
+
+		def unsubscribe sub_id
+			@ddp.unsub(sub_id)
+			@subscriptions.delete(sub_id)
+		end
+
+
+		def call method_name, callback, params=[]
+			method_id = @ddp.call(method_name, params)
+
+			@method_callbacks[method_id] = { method: callback, result: false, updated: false}
+		end
+
+
+		# Methods for SRP authentication
+		#
+		def login_with_username username, password, callback
+			@method_callbacks['login'] = callback
+			@auth_client = SRP::Client.new
+			@username = username
+			@password = password
+			
+
+			a = @auth_client.start_authentication()
+			id = @ddp.call( 'beginPasswordExchange', { 'A' => a, user: { username: username } } )
+
+			@method_callbacks[id] = { method: self.method(:handle_login_challenge), result: false, updated: false }
+		end
+
+		def handle_login_challenge action, result
+			if action == :updated
+				return
+			elsif action == :error
+				obj = { method: @method_callbacks['login'], action: action, result: result }
+				self.performSelectorInBackground('background_method_handler:', withObject: obj)
+
+				@method_callbacks.delete('login') 
+				return
+			end
+
+			m = @auth_client.process_challenge(result['identity'], @password, result['salt'], result['B'])
+			id = @ddp.call( 'login', {srp: {'M' => m} } )
+
+			@method_callbacks[id] = { method: self.method(:verify_login), result: false, updated: false }
+		end
+
+		def verify_login action, result
+			if action == :updated
+				return
+			elsif action == :error
+				obj = { method: @method_callbacks['login'], action: action, result: result }
+				self.performSelectorInBackground('background_method_handler:', withObject: obj)
+
+				@method_callbacks.delete('login') 
+				return
+			end
+
+			if @auth_client.verify result['HAMK']
+				obj = { method: @method_callbacks['login'], action: :success, result: nil }
+			else
+				obj = { method: @method_callbacks['login'], action: :error, result: {reason: 'Failed HAMK validation.'} }
+			end
+
+			self.performSelectorInBackground('background_method_handler:', withObject: obj)
+			@method_callbacks.delete('login') 
+		end
+
+
+		def on_error method
+			@error_handler = method
+		end
+
+		# Methods required for MeteorMotion::DDP delegation
+		#
+		def handle_method id, action, result
+			callback = @method_callbacks[id]
+
+			if !callback
+				return
+			end
+
+			obj = { method: callback[:method], action: action, result: result}
+
+			self.performSelectorInBackground('background_method_handler:', withObject: obj)
+
+			if callback[action] == :error
+				callback[action] = :result
+			end
+
+			callback[action] = true
+			if callback[:result] && callback[:updated]
+				@method_callbacks.delete(id)
+			else
+				@method_callbacks[id] = callback
+			end
+		end
+
+		def error code, reason, details
+			if @error_handler
+				obj = { method: @error_handler, code: code, reason: reason, details: details}
+				self.performSelectorInBackground('background_error_handler:', withObject: obj)
+			else
+				#TODO: silent error handling
+			end
+		end
+
+		private
+			def background_method_handler obj
+				obj[:method].call( obj[:action], obj[:result])
+			end
+
+			def background_error_handler obj
+				obj[:method].call( obj[:code], obj[:reason], obj[:details])
+			end
+
+	end
+end

data/motion/collection.rb

@@ -0,0 +1,50 @@
+module MeteorMotion
+	class Collection
+		attr_accessor :name, :observers
+
+		def initialize name
+			@name = name
+			@observers = []
+		end
+
+		# Method hooks - be sure to call super after reimplementing these
+		# Right now these are here more for testing purposes, should be reimplemented as a hook with some testing compromise
+		#
+		def add id, fields
+			notify_observers :added, id
+		end
+
+		def update id, fields, cleared
+			notify_observers :changed, id
+		end
+
+		def remove id
+			notify_observers :removed, id
+		end
+
+		# Observer methods
+		#
+		def add_observer method
+			@observers << method
+		end
+
+		def remove_observer method
+			@observers.delete( method )
+		end
+
+		private
+			def notify_observers action, id
+				obj = {action: action, id: id}
+				self.performSelectorInBackground('background_notify:', withObject: obj)
+			end
+
+			# These callbacks should be done as background tasks to prevent the connection thread from holding in intensive tasks
+			#
+			def background_notify object
+				observers.each do |method_name|
+					#puts "Calling method with action #{object[:action]}"
+					method_name.call( object[:action], object[:id] )
+				end
+			end
+	end
+end