motion-yapper 0.0.1

data/lib/yapper/extensions.rb

@@ -0,0 +1,80 @@
+module Kernel
+  def qualified_const_get(str)
+    path = str.to_s.split('::')
+    from_root = path[0].empty?
+    if from_root
+      from_root = []
+      path = path[1..-1]
+    else
+      start_ns = ((Class === self)||(Module === self)) ? self : self.class
+      from_root = start_ns.to_s.split('::')
+    end
+    until from_root.empty?
+      begin
+        return (from_root+path).inject(Object) { |ns,name| ns.const_get(name) }
+      rescue NameError
+        from_root.delete_at(-1)
+      end
+    end
+    path.inject(Object) { |ns,name| ns.const_get(name) }
+  end
+end
+
+class Time
+  def self.parse(string)
+    return nil if string.nil?
+
+    unless time = NSDate.dateWithString(string)
+      # XXX Try iso8601 date
+      time = NSDate.dateWithString(string.gsub('T',' ').gsub('Z', ' +0000').gsub(/([-+]\d{2}:\d{2})/,' \1'))
+    end
+    time
+  end
+
+  def to_iso8601
+    dateFormatter = NSDateFormatter.alloc.init
+    locale = NSLocale.alloc.initWithLocaleIdentifier("en_US_POSIX")
+    dateFormatter.setLocale(locale)
+    dateFormatter.setDateFormat("yyyy-MM-dd'T'HH:mm:ssZZZZZ")
+
+    dateFormatter.stringFromDate(self)
+  end
+end
+
+class Object
+  def as_json
+    self
+  end
+end
+
+class Hash
+  def as_json
+    hash = self.class.new
+    self.each { |k,v| hash[k] = v.as_json }
+    hash
+  end
+end
+
+class NSDictionary
+  def as_json
+    to_hash.as_json
+  end
+end
+
+class Array
+  def as_json
+    self.map { |v| v.as_json }
+  end
+end
+
+class NSArray
+  def as_json
+    self.map { |v| v.as_json }
+  end
+end
+
+class Time
+  def as_json
+    self.to_iso8601
+  end
+end

data/lib/yapper/log.rb

@@ -0,0 +1,5 @@
+if defined?(Motion::Yapper::Log)
+  Yapper::Yapper::Log = Motion::Yapper::Log
+  Yapper::Log.addYapper::Logger DDTTYYapper::Logger.sharedInstance
+  Yapper::Log.addYapper::Logger DDASLYapper::Logger.sharedInstance
+end

data/lib/yapper/sync.rb

@@ -0,0 +1,134 @@
+motion_require 'extensions'
+motion_require 'timestamps'
+
+module Yapper::Sync
+  motion_require 'sync/data'
+  motion_require 'sync/event'
+
+  extend MotionSupport::Concern
+
+  included do
+    field :_synced_at
+
+    unless self.ancestors.include?(Yapper::Timestamps)
+      include Yapper::Timestamps
+    end
+
+    cattr_accessor :always
+
+    class << self
+      attr_accessor :attachments
+    end
+    self.attachments = {}
+  end
+
+  class << self
+    attr_accessor :base_url
+    attr_accessor :data_path
+    attr_accessor :attachment_path
+    attr_accessor :access_token
+    attr_accessor :max_failure_count
+  end
+  self.data_path = '/api/data'
+  self.attachment_path = '/api/attachment'
+
+  def self.configure(options)
+    self.access_token      = options[:access_token]
+    self.max_failure_count = options[:max_failure_count] || 100
+  end
+
+  def self.sync
+    Queue.sync
+  end
+
+  def self.disabled(&block)
+    previous_value = Thread.current[:sync_disabled]
+    Thread.current[:sync_disabled] = true
+    yield
+    Thread.current[:sync_disabled] = previous_value
+  end
+
+  module ClassMethods
+    def sync(options={})
+      self.always = options[:always] || []
+    end
+
+    def attachment(name, options, &block)
+      raise ArgumentError unless options[:on] # XXX Use a consistent approach to checking hash params
+
+      self.attachments[name] = block
+      field(options[:on])
+    end
+  end
+
+  def sync_as
+    attrs = self.changes.deep_dup
+    attrs = attrs.deep_delete_if { |k,v| k.to_s =~ /^_/ }
+    attrs
+  end
+
+  def synced?
+    !self._synced_at.nil?
+  end
+
+  def sync_paused?
+    Queue.paused?
+  end
+
+  def sync
+    @config ||= Config.new(self)
+  end
+
+  def sync_op
+    self.was_new? ? :create : :update
+  end
+
+  private
+
+  def perform_sync(changes)
+    Queue.process(self.class, self.id, self.sync_op, changes) unless changes.empty?
+  end
+
+  def sync_changes
+    perform_sync(self.previous_changes.merge(always_attributes)) unless Thread.current[:sync_disabled]
+  end
+
+  def always_attributes
+    {}.tap do |attrs|
+      self.always.each { |field| attrs[field] = self.send(field) }
+    end
+  end
+
+  class Config
+    def initialize(instance)
+      @instance = instance
+      @root = if parent
+                instance.send(parent)
+              else
+                instance
+              end
+    end
+
+    def id
+      @root.id
+    end
+
+    def model
+      @root.model_name.capitalize
+    end
+
+    def delta
+      delta = @root.sync_as
+      unless @root == @instance
+        delta.merge!(@instance.model_name.pluralize => [@instance.sync_as.merge(:id => @instance.id)])
+      end
+      delta
+    end
+
+    private
+
+    def parent
+      @instance.class.relations[:belongs_to].find { |r| r.find { |k,v| v[:embedded] } }.try(:keys).try(:first)
+    end
+  end
+end

data/lib/yapper/sync/data.rb

@@ -0,0 +1,12 @@
+module Yapper::Sync
+  class Attachment
+    attr_accessor :data
+    attr_accessor :name
+    attr_accessor :fileName
+    attr_accessor :mimeType
+
+    def initialize(params)
+      params.each { |k,v| self.send("#{k}=", v) }
+    end
+  end
+end

data/lib/yapper/sync/event.rb

@@ -0,0 +1,194 @@
+module Yapper::Sync
+  module Event
+    extend self
+
+    def attach(attachment)
+      params = {
+        :attachment => attachment.metadata
+      }
+      request = http_client.multipartFormRequestWithMethod(
+        'POST',
+        path: Yapper::Sync.attachment_path,
+        parameters: params.as_json,
+        constructingBodyWithBlock: lambda { |form_data|
+            form_data.appendPartWithFileData(UIImageJPEGRepresentation(attachment.data, 0.8),
+                                             name: "attachment[data]",
+                                             fileName: attachment.name,
+                                             mimeType: 'image/jpg')
+        })
+
+      if process(request)
+        Yapper::Log.info "[Yapper::Sync::Event][ATTACHMENT][#{attachment.id}]"
+        :success
+      else
+        :failure
+      end
+    end
+
+    def create(instance, type)
+      params =  {
+        :event => {
+          :model    => instance.sync.model,
+          :model_id => instance.sync.id,
+          :type     => type,
+          :delta    => instance.sync.delta
+        }
+      }
+      if instance._attachments
+        params.merge!(:attachments => instance._attachments)
+      end
+
+      request = http_client.requestWithMethod(
+        'POST',
+        :path => Yapper::Sync.data_path,
+        :parameters => params.as_json)
+
+      if operation = process(request)
+        attrs = operation.responseJSON.deep_dup
+        Yapper::Log.info "[Yapper::Sync::Event][POST][#{instance.model_name}] #{attrs}"
+
+        new_attrs = {}
+        attrs.each do |k, v|
+          new_attrs[k] = v if instance.respond_to?(k) && instance.send(k).nil?
+        end
+        Yapper::Sync.disabled { instance.reload.update_attributes(new_attrs) }
+        :success
+      else
+        :failure
+      end
+    rescue Exception => e
+      if e.is_a?(NSException)
+        Yapper::Log.error "[Yapper::Sync][CRITICAL][#{instance.model_name}] #{e.reason}: #{e.callStackSymbols}"
+      else
+        Yapper::Log.error "[Yapper::Sync][CRITICAL][#{instance.model_name}] #{e.message}: #{e.backtrace.join('::')}"
+      end
+      :critical
+    end
+
+    def get
+      request = http_client.requestWithMethod(
+        'GET',
+        path: Yapper::Sync.data_path,
+        parameters: { :since => Yapper::Config.get(:last_event_id) }
+      )
+
+      instances = []
+      begin
+        if operation = process(request)
+          events = compact(operation.responseJSON)
+          return events if events.empty?
+
+          if events.first['model'] == 'User'
+            instances << handle(events.shift)
+          end
+
+          events.each do |event|
+            Yapper::DB.instance.execute do |txn|
+              instances << handle(event)
+              Yapper::Config.set(:last_event_id, event['created_at'])
+            end
+          end
+        end
+      rescue Exception => e
+        Yapper::Log.error "[Yapper::Sync::Event][FAILURE] #{e.message}: #{e.backtrace.join('::')}"
+      end
+
+      instances.compact
+    end
+
+    private
+
+    def handle(event)
+      Yapper::Log.info "[Yapper::Sync::Event][GET][#{event['type']}][#{event['model']}] #{event['delta']}"
+
+      model = Object.qualified_const_get(event['model'])
+      instance = nil
+      if event['type'] == 'create'
+        instance = model.new(event['delta']) # XXX shouldn't need to pass in delta
+      else
+        instance = model.find(event['model_id'])
+      end
+
+      if instance
+        # XXX Return array of updates vs. overwriting entire object
+        Yapper::Sync.disabled { instance.update_attributes(event['delta']) }
+      else
+        Yapper::Log.error  "Model instance not found!. This is not good!"
+      end
+
+      instance
+    end
+
+    def compact(events)
+      event_lookup = {}; compact_events = []
+      events.each_with_index do |event, i|
+        case event['type']
+        when 'create'
+          event_lookup[event['model_id']] = compact_events.count
+          compact_events << event
+        when 'update'
+          if index = event_lookup[event['model_id']]
+            create_event = compact_events[index].dup
+            create_event['delta'] = recursive_merge(create_event['delta'], event['delta'])
+            compact_events[index] = create_event
+          else
+            compact_events << event
+          end
+        else
+          raise "Only 'update' AND 'create' supported"
+        end
+      end
+      compact_events
+    end
+
+    def http_client
+      @http_client ||= begin
+                         client = AFHTTPClient.alloc.initWithBaseURL(NSURL.URLWithString(Yapper::Sync.base_url))
+                         client.setParameterEncoding(AFJSONParameterEncoding)
+                         client
+                       end
+      @http_client.setAuthorizationHeaderWithToken(Yapper::Sync.access_token.call)
+      @http_client.setDefaultHeader('DEVICEID', value: UIDevice.currentDevice.identifierForVendor.UUIDString)
+    end
+
+    def process(request)
+      operation = AFJSONRequestOperation.alloc.initWithRequest(request)
+
+      operation.start
+      operation.waitUntilFinished
+
+      if operation.response && operation.response.statusCode >= 200 && operation.response.statusCode < 300
+        operation
+      else
+        Yapper::Log.error "[Yapper::Sync::Event][FAILURE] #{operation.error.localizedDescription}"
+        false
+      end
+    end
+
+    def recursive_merge(h1, h2)
+      return h1 unless h1.is_a?(Array) || h1.is_a?(Hash)
+
+      result = h1.dup; h2 = h2.dup
+      h2.each_pair do |k,v|
+        tv = h1[k]
+        if tv.is_a?(Hash) && v.is_a?(Hash)
+          result[k] = recursive_merge(tv, v)
+        elsif tv.is_a?(Array) && v.is_a?(Array)
+          v = v.dup
+          result[k] = tv.map do |_tv|
+            if match = v.find { |_v| _tv.is_a?(Hash) && _v.is_a?(Hash) && _tv['id'] == _v['id'] }
+              v.delete(match)
+              recursive_merge(_tv, match)
+            else
+              _tv
+            end
+          end
+          result[k] += v
+        else
+          result[k] = v
+        end
+      end
+      result
+    end
+  end
+end

data/lib/yapper/sync/queue.rb

@@ -0,0 +1,164 @@
+motion_require '../document.rb'
+
+module Yapper::Sync
+  class Queue
+    include Yapper::Document
+
+    field :sync_class
+    field :sync_id
+    field :sync_changes
+    field :sync_type
+    field :created_at, :type => Time
+    field :failure_count
+
+    index :created_at
+
+    @@mutex = Mutex.new
+    @@notify_count = 0
+
+    @@queue = NSOperationQueue.alloc.init
+    @@queue.name = "#{NSBundle.mainBundle.bundleIdentifier}.yapper.sync"
+    @@queue.MaxConcurrentOperationCount = 1
+    @@queue.setSuspended(true)
+
+    @@reachability ||= begin
+                         reachability = Reachability.reachabilityForInternetConnection
+                         reachability.reachableBlock   = lambda { |reachable| self.toggle_queue }
+                         reachability.unreachableBlock = lambda { |reachable| self.toggle_queue }
+                         reachability.reachableOnWWAN = true
+                         reachability.startNotifier
+                         reachability
+                       end
+
+    NSNotificationCenter.defaultCenter.addObserver(self,
+                                                   selector: 'onBackground',
+                                                   name: UIApplicationDidEnterBackgroundNotification,
+                                                   object: nil)
+
+
+    def self.start
+      operation = NSBlockOperation.blockOperationWithBlock lambda {
+        job_started
+        jobs = self.where({}, :order => { :created_at => :asc })
+        Yapper::Log.info "[Yapper::Sync][START] Processing #{jobs.count} jobs"
+        jobs.each { |job| handle(job) }
+        @@queue.setSuspended(!@@reachability.isReachable)
+        job_ended
+      }
+      self.toggle_queue
+      @@queue.addOperation(operation)
+    end
+
+    def self.onBackground
+      @@background_task = UIApplication.sharedApplication.beginBackgroundTaskWithExpirationHandler(nil)
+      operation = NSBlockOperation.blockOperationWithBlock lambda {
+        UIApplication.sharedApplication.endBackgroundTask(@@background_task) unless @@background_task == UIBackgroundTaskInvalid
+        @@background_task = UIBackgroundTaskInvalid
+      }
+      @@queue.addOperation(operation)
+    end
+
+    def self.paused?
+      @@queue.isSuspended
+    end
+
+    def self.sync
+      return false if self.paused?
+
+      operation = NSBlockOperation.blockOperationWithBlock lambda {
+        job_started
+        Yapper::Sync::Event.get.each { |instance| self.notification(instance, 'success') }
+        job_ended
+      }
+      @@queue.addOperation(operation)
+
+      true
+    end
+
+    def self.process(klass, id, type, changes)
+      instance = klass.find(id)
+      self.notification(instance, 'start')
+
+      job = self.create(:sync_class    => instance.class.to_s,
+                        :sync_id       => instance.id,
+                        :sync_changes  => changes,
+                        :sync_type     => type.to_s,
+                        :created_at    => Time.now.utc,
+                        :failure_count => 0)
+      handle(job)
+    end
+
+    def self.handle(job)
+      operation = NSBlockOperation.blockOperationWithBlock lambda {
+        job_started
+        instance = Object.qualified_const_get(job.sync_class).find(job.sync_id)
+        instance.changes = job.sync_changes
+        job.attempt(instance, job.sync_type)
+        job_ended
+      }
+      self.toggle_queue
+
+      @@queue.addOperation(operation)
+      nil
+    end
+
+    def attempt(instance, type)
+      case event(instance, type)
+      when :success
+        Yapper::Sync.disabled { instance.update_attributes(:_synced_at => Time.now) }
+        self.destroy
+        self.class.notification(instance, 'success')
+      when :failure
+        if self.failure_count < Yapper::Sync.max_failure_count
+          sleep 2 ** (self.failure_count)
+          self.failure_count += 1
+          self.save
+          attempt(instance, type)
+          self.class.notification(instance, 'retry')
+        else
+          Yapper::Log.error "[Yapper::Queue][CRITICAL] Job #{self.sync_class}:#{self.sync_id} exceeded failure threshold and has been removed"
+          self.destroy
+          self.class.notification(instance, 'failure')
+        end
+      when :critical
+        self.destroy
+        self.class.notification(instance, 'failure')
+      end
+    end
+
+    private
+
+    def event(instance, type)
+      if instance.is_a?(Yapper::Attachment)
+        Yapper::Sync::Event.attach(instance)
+      else
+        Yapper::Sync::Event.create(instance, type)
+      end
+    end
+
+    def self.toggle_queue
+      was_paused = self.paused?
+      @@queue.setSuspended(!@@reachability.isReachable)
+      if was_paused != self.paused?
+        NSNotificationCenter.defaultCenter.postNotificationName("yapper:sync:paused", object: true, userInfo: nil) if self.paused?
+      end
+    end
+
+    def self.notification(instance, type)
+      NSNotificationCenter.defaultCenter.postNotificationName("yapper:#{instance.model_name}:sync:#{type}", object: instance , userInfo: nil)
+    end
+
+    def self.job_started
+      if @@queue.operationCount == 1
+        @@job_started_at = Time.now
+        NSNotificationCenter.defaultCenter.postNotificationName("yapper:sync:start", object: true , userInfo: nil)
+      end
+    end
+
+    def self.job_ended
+      if @@queue.operationCount == 1
+        NSNotificationCenter.defaultCenter.postNotificationName("yapper:sync:end", object: Time.now - @@job_started_at , userInfo: nil)
+      end
+    end
+  end
+end