motion-yapper 0.0.1

data/lib/yapper/document/attachment.rb

@@ -0,0 +1,26 @@
+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/document/callbacks.rb

@@ -0,0 +1,86 @@
+module Yapper::Document
+  module Callbacks
+    extend MotionSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :before_save_callbacks
+        attr_accessor :after_save_callbacks
+      end
+
+      self.before_save_callbacks = []
+      self.after_save_callbacks  = []
+    end
+
+    def self.postpone_callbacks(&block)
+      Thread.current[:postponed_callbacks] = []
+
+      block.call
+
+      Thread.current[:postponed_callbacks].each(&:call)
+      Thread.current[:postponed_callbacks] = nil
+    end
+
+    def self.disabled(&block)
+      previous_value = Thread.current[:disabled_callbacks]
+      Thread.current[:disabled_callbacks] = true
+
+      block.call
+
+      Thread.current[:disabled_callbacks] = previous_value
+    end
+
+    def self.disabled?
+      !!Thread.current[:disabled_callbacks]
+    end
+
+    def self.postpone_callback(&block)
+      Thread.current[:postponed_callbacks] << Proc.new(block)
+    end
+
+    def self.postponed_callbacks
+      Thread.current[:postponed_callbacks]
+    end
+
+    module ClassMethods
+      def before_save(method)
+        self.before_save_callbacks << method
+      end
+
+      def after_save(method)
+        self.after_save_callbacks << method
+      end
+    end
+
+    def run_callback(hook, operation)
+      self.class.send("#{hook}_#{operation}_callbacks").each do |method|
+        self.send(method)
+      end
+    end
+
+    def run_callbacks(operation, &block)
+      return yield if Yapper::Document::Callbacks.disabled?
+
+      if run_callback('before', operation)
+        block.call
+      end
+
+      callback_proc = Proc.new do
+        run_callback('after', operation)
+        notify_callback(operation)
+      end
+
+      if Yapper::Document::Callbacks.postponed_callbacks
+        Yapper::Document::Callbacks.postpone_callback(&callback_proc)
+      else
+        callback_proc.call
+      end
+    end
+
+    private
+
+    def notify_callback(operation)
+      NSNotificationCenter.defaultCenter.postNotificationName("yapper:#{self.model_name}:#{operation}", object: self , userInfo: nil)
+    end
+  end
+end

data/lib/yapper/document/persistance.rb

@@ -0,0 +1,171 @@
+module Yapper::Document
+  module Persistance
+    extend MotionSupport::Concern
+
+    included do
+      attr_accessor :attributes
+      attr_accessor :changes
+      attr_accessor :previous_changes
+
+      class << self
+        attr_accessor :fields
+      end
+
+      self.fields = {}.with_indifferent_access
+      field :id
+    end
+
+    module ClassMethods
+      def create(*args)
+        new(*args).tap { |doc| doc.save }
+      end
+
+      def field(name, options={})
+        name = name.to_sym
+        self.fields[name] = options
+
+        define_method(name) do |*args, &block|
+          self.attributes[name]
+        end
+
+        define_method("#{name}=".to_sym) do |*args, &block|
+          self.set_attribute(name, args[0])
+        end
+
+        if options[:index]
+          index(name, options[:type])
+        end
+      end
+
+      def index(*index_fields)
+        index_fields.each do |field|
+          options = self.fields[field]; raise "#{self._type}:#{field} not defined" unless options
+          type    = options[:type];    raise "#{self._type}:#{field} must define type as its indexed" if type.nil?
+
+          db.index(self._type, field, type)
+        end
+      end
+
+      def indexes
+        db.indexes[self._type]
+      end
+    end
+
+    def initialize(attrs={}, options={})
+      super
+
+      @new_record = options[:new].nil? ? true : options[:new]
+      @changes = {}
+
+      assign_attributes({:id => generate_id}, options) if @new_record
+      assign_attributes(attrs, options)
+
+      self
+    end
+
+    def update_attributes(attrs, options={})
+      self.assign_attributes(attrs, options)
+      self.save(options)
+    end
+
+    def assign_attributes(attrs, options={})
+      self.attributes ||= {}
+
+      if options[:pristine]
+        self.attributes = {}
+      end
+
+      attrs.each do |k,v|
+        if respond_to?("#{k}=")
+          __send__("#{k}=", v) unless v.nil?
+        else
+          Log.warn "#{k} not defined on #{self.class}"
+        end
+      end
+
+      if options[:pristine]
+        self.changes = {}
+      end
+    end
+    alias_method :attributes=, :assign_attributes
+
+    def set_attribute(name, value)
+      if self.class.fields[name][:type] == Time
+        value = Time.parse(value) unless value.is_a?(Time)
+      end
+      # XXX This should not be set if the object was created from a
+      # selection
+      @changes[name.to_s] = value
+      self.attributes[name] = value
+    end
+
+    def reload
+      reloaded = self.class.find(self.id)
+      self.assign_attributes(reloaded.attributes, :pristine => true)
+      self
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def was_new?
+      @was_new
+    end
+
+    def destroyed?
+      !!@destroyed
+    end
+
+    def persisted?
+      !new_record? && !destroyed?
+    end
+
+    def save(options={})
+      db.execute do |txn|
+        run_callbacks 'save' do
+          txn.setObject(stringify_keys(attributes), forKey: self.id, inCollection: _type)
+
+          @was_new = @new_record
+          @new_record = false
+
+          self.previous_changes = self.changes
+          self.changes = {}
+        end
+
+        # XXX Use middleware pattern instead of this ugliness
+        sync_changes if defined? sync_changes
+
+        true
+      end
+    end
+
+    def destroy(options={})
+      db.execute { |txn| txn.removeObjectForKey(self.id, inCollection: _type) }
+      @destroyed = true
+    end
+
+    private
+
+    def generate_id
+      BSON::ObjectId.generate
+    end
+  end
+
+  private
+
+  # TODO Use deep_stringify_keys once https://github.com/kareemk/motion-support is merged upstream
+  def stringify_keys(hash)
+    result = {}
+    hash.each do |key, value|
+      result[key.to_s] = if value.is_a?(Hash)
+        stringify_keys(value)
+      elsif value.is_a?(Array)
+        value.map { |v| v.is_a?(Hash) ? stringify_keys(v) : v }
+      else
+       value
+      end
+    end
+    result
+  end
+end

data/lib/yapper/document/relation.rb

@@ -0,0 +1,84 @@
+module Yapper::Document
+  module Relation
+    extend MotionSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :relations
+      end
+
+      self.relations = {}
+      self.relations[:has_many] = []
+      self.relations[:belongs_to] = []
+    end
+
+    module ClassMethods
+      def has_many(relation, options={})
+        self.relations[:has_many] << { relation => options } unless self.relations[:has_many].find { |r,o| r == relation }
+
+        define_method(relation) do
+          Object.qualified_const_get(relation.to_s.singularize.camelize).where("#{self._type.underscore}_id".to_sym => self.id)
+        end
+
+        define_method("#{relation}=") do |docs|
+          raise "You must pass an array of objects or attributes" unless docs.is_a?(Array)
+          raise "All elements in the array must be of the same type" unless docs.all? { |doc| doc.is_a?(docs.first.class) }
+
+          changes = {}
+          Yapper::Sync.disabled do
+            db.execute do |txn|
+              docs.each do |doc|
+                if doc.is_a?(Yapper::Document)
+                  if doc.persisted?
+                    doc.update_attributes("#{self._type.underscore}" => self)
+                    changes["#{relation.singularize}_ids"] ||= []
+                    changes["#{relation.singularize}_ids"] << doc.id
+                  else
+                    doc.assign_attributes("#{self._type.underscore}" => self)
+
+                    changes[relation] ||= []
+                    changes[relation] << doc.attributes
+
+                    doc.save
+                  end
+                elsif doc.is_a?(Hash)
+                  doc = doc.with_indifferent_access
+
+                  klass = Object.qualified_const_get(relation.singularize.to_s.camelize)
+                  instance = klass.find(doc[:id]) if doc[:id]
+                  instance ||= klass.new
+                  instance.assign_attributes("#{self._type.underscore}" => self)
+                  instance.assign_attributes(doc)
+
+                  changes[relation] ||= []
+                  changes[relation] << instance.attributes
+
+                  instance.save
+                else
+                  raise "Must pass either attributes or an object"
+                end
+              end
+            end
+            @changes.merge!(changes)
+          end
+        end
+      end
+
+      def belongs_to(relation, options={})
+        fk_field = "#{relation}_id".to_sym
+        self.relations[:belongs_to] << { relation => options } unless self.relations[:belongs_to].find { |r,o| r == relation }
+        self.field(fk_field, :type => String)
+        self.index(fk_field)
+
+        define_method(relation) do
+          instance_variable_get("@#{relation}") || Object.qualified_const_get(relation.to_s.camelize).find(self.send("#{relation}_id"))
+        end
+
+        define_method("#{relation}=") do |parent|
+          self.instance_variable_set("@#{relation}", parent)
+          self.send("#{relation}_id=", parent.id)
+        end
+      end
+    end
+  end
+end

data/lib/yapper/document/selection.rb

@@ -0,0 +1,100 @@
+module Yapper::Document
+  module Selection
+    extend MotionSupport::Concern
+
+    module ClassMethods
+      def find(id)
+        return nil if id.nil?
+
+        attrs = db.execute { |txn| txn.objectForKey(id, inCollection: self._type) }
+
+        attrs ? object_for_attrs(attrs) : nil
+      end
+
+      def all(options={})
+        results = []
+        each_result_proc = proc do |key, attrs, stop|
+          results << object_for_attrs(attrs)
+        end
+
+        db.execute { |txn| txn.enumerateKeysAndObjectsInCollection(self._type, usingBlock: each_result_proc) }
+        results
+      end
+
+      def when(id, &block)
+        observer = nil
+        observer_block = proc do |data|
+          observer = nil
+          NSNotificationCenter.defaultCenter.removeObserver(observer)
+          block.call(data.object)
+        end
+        observer = NSNotificationCenter.
+                     defaultCenter.
+                     addObserverForName("yapper:#{self.model_name}:save",
+                                        object: nil,
+                                        queue: NSOperationQueue.mainQueue,
+                                        usingBlock: observer_block) 
+        if result = self.find(id)
+          unless observer.nil?
+            NSNotificationCenter.defaultCenter.removeObserver(observer)
+            block.call(result) 
+          end
+        end
+      end
+
+      def where(criteria, options={})
+        values = []; query_str = ''
+
+        # Sort keys so that query string is always the same and is cached
+        criteria.sort.each do |field, value|
+          raise "#{field} is not indexed" if self.indexes[field].nil?
+
+          query_str.blank? ? query_str = "WHERE " : query_str += " AND "
+          query_str += "#{field} = ?"
+
+          # XXX Casting should only happen if the type of the field allows for it
+          value = case value.class.to_s
+                  when 'Time'
+                    value.to_i
+                  else
+                    value
+                  end
+          values << value
+        end
+
+        options.each do |option, params|
+          case option
+          when :order
+            params.each do |sort_field, direction|
+              if query_str.include?("ORDER by")
+                query_str += ", "
+              else
+                query_str += " ORDER by "
+              end
+              query_str += "#{sort_field} #{direction.upcase}"
+            end
+          else
+            raise "#{option} not a valid option on #where"
+          end
+        end
+
+        query = YapDatabaseQuery.alloc.initWithQueryString(query_str, queryParameters: values)
+
+        results = []
+        each_result_proc = proc do |collection, key, attrs, stop|
+          results << object_for_attrs(attrs)
+        end
+
+        db.execute { |txn| txn.ext("#{self._type}_IDX").enumerateKeysAndObjectsMatchingQuery(query, usingBlock: each_result_proc) }
+
+        results
+      end
+
+      private
+
+      def object_for_attrs(attrs)
+        Object.qualified_const_get(self._type).new(attrs.deep_dup, :new => false, :pristine => true)
+      end
+    end
+  end
+end