motion-yapper 0.0.1 → 0.0.2

data/lib/yapper/attachment.rb

@@ -1,48 +0,0 @@
-motion_require 'document.rb'
-motion_require 'sync.rb'
-
-class Yapper::Attachment
-  include Yapper::Document
-  include Yapper::Sync
-
-  sync
-
-  class_attribute :attachments
-  self.attachments = {}.with_indifferent_access
-
-  field :name
-  field :uid
-  field :additional_fields
-
-  def self.create(name, fields={})
-    name = name.pluralize
-    raise "#{name} attachment not a defined" unless attachments[name]
-    fields.keys.each do |field|
-      raise "Attachment field #{field} not defined for #{name}" unless attachments[name][:with].include?(field)
-    end
-
-    attachment = self.new
-    attachment.name = name
-    attachment.additional_fields = fields
-    attachment.save
-
-    attachment
-  end
-
-  def self.url(uid, size=nil)
-    options = "[[\"f\",\"#{uid}\"]"
-    options << ",[\"p\",\"thumb\", \"#{size}\"]" if size
-    options << "]"
-    path = [options].pack("m").tr("\n=",'')
-
-    NSURL.URLWithString("#{Yapper::Sync.base_url}/#{path}.jpg")
-  end
-
-  def data
-    self.attachments[name][:block].call(self)
-  end
-
-  def metadata
-    self.additional_fields.merge(:id => self.id, :name => self.name).with_indifferent_access
-  end
-end

data/lib/yapper/document/attachment.rb

@@ -1,26 +0,0 @@
-module Yapper::Document
-  module Attachment
-    extend MotionSupport::Concern
-
-    included do
-      field(:_attachments)
-    end
-
-    def attach(name, attachments)
-      raise "Attachment #{name} not defined on #{self.class}" unless Yapper::Attachment.attachments[name]
-
-      self._attachments ||= {}
-      self._attachments[name.to_s] = attachments.collect(&:id)
-    end
-
-    module ClassMethods
-      def attach(name, options={}, &block)
-
-        options[:block] = block
-
-        field(name)
-        Yapper::Attachment.attachments[name] = options
-      end
-    end
-  end
-end

data/lib/yapper/sync.rb

@@ -1,134 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,194 +0,0 @@
-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

@@ -1,164 +0,0 @@
-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