motion-prime 0.2.1 → 0.3.0

data/motion-prime/models/association.rb

@@ -18,17 +18,15 @@ module MotionPrime
     # @param [String] name - the name of bag
     # @return [Nil]
     def bag(name)
-      klass = self
-
       define_method(name) do |*args, &block|
         return _bags[name] if _bags[name]
-
         bag_key = self.info[name]
-        if bag_key.nil?
+        if bag_key.present?
+          bag = self.class.store.bagsWithKeysInArray([bag_key]).first
+        end
+        unless bag
           bag = Bag.bag
           self.info[name] = bag.key
-        else
-          bag = self.class.store.bagsWithKeysInArray([bag_key]).first
         end
 
         _bags[name] = bag
@@ -109,13 +107,28 @@ module MotionPrime
         self.send(bag_name).clear
         self.send(:"#{bag_name}=", value)
       end
-      define_method("#{association_name}") do |options = {}|
+      define_method("#{association_name}") do |*args|
         bag = self.send(:"#{bag_name}")
         collection_options = {
-          association_name: association_name
+          association_name: association_name,
+          inverse_relation: {
+            type: :has_one,
+            name: self.class_name_without_kvo.demodulize.underscore,
+            instance: self
+          }
         }
-        AssociationCollection.new(bag, collection_options, options)
+        AssociationCollection.new(bag, collection_options, *args)
       end
     end
+
+    def belongs_to(association_name, options = {})
+      self._associations ||= {}
+      self._associations[association_name] = {
+        type: :belongs_to_one,
+        class_name: association_name.classify
+      }.merge(options)
+
+      self.send(:attr_accessor, association_name)
+    end
   end
 end

data/motion-prime/models/association_collection.rb

@@ -1,39 +1,70 @@
 module MotionPrime
   class AssociationCollection < ::Array
-    attr_reader :bag
+    attr_reader :bag, :association_name
+    attr_reader :inverse_relation_name, :inverse_relation_key, :model_inverse_relation_name
 
     delegate :<<, to: :bag
 
-    def initialize(bag, options, fetch_options = {})
+    def initialize(bag, options, *args)
       @bag = bag
       @association_name = options[:association_name]
-      super(all(fetch_options))
-    end
-
-    def all(fetch_options = {})
-      data = bag.to_a
-      if sort_options = sort_options(fetch_options[:sort])
-        data = data.sort do |a, b|
-          left = []
-          right = []
-          sort_options.each do |key, order|
-            if order == :desc
-              left << b.send(key)
-              right << a.send(key)
-            else
-              left << a.send(key)
-              right << b.send(key)
-            end
-          end
-          left <=> right
+      bag.bare_class = model_class
+
+      inverse_relation_options = options[:inverse_relation]
+      define_inverse_relation(inverse_relation_options)
+
+      @model_inverse_relation_name = (model_class._associations || {}).find do |name, options|
+        options[:class_name] == inverse_relation.class_name_without_kvo
+      end.try(:first)
+
+      super all(*args)
+    end
+
+    def new(attributes = {})
+      model_class.new(attributes).tap do |model|
+        set_inverse_relation_for(model)
+      end
+    end
+
+    def define_inverse_relation(options)
+      # TODO: handle different relation types (habtm, has_one...)
+      @inverse_relation_name = name = options[:name].to_sym
+      self.class_eval do
+        define_method name do
+          options[:instance]
         end
+        alias_method :inverse_relation, name
       end
+
+      @inverse_relation_key = inverse_relation._associations[association_name][:foreign_key].try(:to_sym)
+    end
+
+    def all(*args)
+      return [] unless bag.store.present?
+      data = bag.find(find_options(args[0]), sort_options(args[1]))
+      set_inverse_relation_for(data)
       data
     end
 
+    def set_inverse_relation_for(models)
+      [*models].each do |model|
+        model.send("#{inverse_relation_name}=", inverse_relation)
+      end if model_inverse_relation_name.present?
+    end
+
+    def find_options(options)
+      options ||= {}
+      options.merge!(bag_key: bag.key)
+      if inverse_relation_key.present?
+        {inverse_relation_key => inverse_relation.id}.merge options
+      else
+        options
+      end
+    end
+
     def sort_options(options)
-      return options if options
-      model_class.default_sort_options
+      return options if options.present?
+      {sort: model_class.default_sort_options}
     end
 
     def model_class

data/motion-prime/models/bag.rb

@@ -27,30 +27,30 @@ module MotionPrime
       self.savedObjects.values + self.unsavedObjects.values
     end
 
-    # Add an object to bag
-    #
-    # @return self
-    def <<(object)
-      error_ptr = Pointer.new(:id)
-      self.addObject(object, error:error_ptr)
-      raise StoreError, error_ptr[0].description if error_ptr[0]
-      self
-    end
-
     # Add an object or array of objects to bag
     #
     # @return self
     def add(object_or_array)
       error_ptr = Pointer.new(:id)
       if object_or_array.is_a?(Array)
-        self.addObjectsFromArray(object_or_array, error:error_ptr)
+        self.addObjectsFromArray(prepare_for_store(object_or_array), error:error_ptr)
       else
-        self.addObject(object_or_array, error:error_ptr)
+        self.addObject(prepare_for_store(object_or_array), error:error_ptr)
       end
       raise StoreError, error_ptr[0].description if error_ptr[0]
       self
     end
     alias_method :+, :add
+    alias_method :<<, :add
+
+    def prepare_for_store(object)
+      if object.is_a?(Array)
+        object.map { |entity| prepare_for_store(entity) }
+      else
+        object.bag_key = self.key
+        object
+      end
+    end
 
     # Remove object from bag with key
     #
@@ -126,5 +126,6 @@ module MotionPrime
 end
 
 class NSFNanoBag
+  include MotionPrime::ModelFinderMethods
   include MotionPrime::BagInstanceMethods
 end

data/motion-prime/models/base.rb

@@ -18,6 +18,8 @@ module MotionPrime
     extend MotionPrime::ModelAssociationClassMethods
     extend MotionPrime::ModelSyncClassMethods
 
+    attribute :bag_key # need this as we use shared store; each nested resource must belong to parent bag
+
     def errors
       @errors ||= Errors.new(self)
     end

data/motion-prime/models/errors.rb

@@ -1,35 +1,40 @@
 module MotionPrime
   class Errors
-    attr_accessor :keys
+    attr_accessor :_unique_keys
 
     def initialize(model)
-      @keys = []
+      @_unique_keys = []
+      @model = model
       model.class.attributes.map(&:to_sym).each do |key|
         initialize_for_key key
       end
     end
 
+    def unique_key(key)
+      [key, @model.object_id].join('_').to_sym
+    end
+
     def initialize_for_key(key)
-      return if @keys.include?(key.to_sym)
-      @keys << key.to_sym unless @keys.include?(key.to_sym)
-      unless instance_variable_get("@#{key}")
-        instance_variable_set("@#{key}", [])
-      end
-      self.class.send :attr_accessor, key.to_sym
+      unique_key = unique_key(key)
+
+      return if @_unique_keys.include?(unique_key)
+      @_unique_keys << unique_key
+      instance_variable_set("@#{unique_key}", [])
+      self.class.send :attr_accessor, unique_key
     end
 
     def get(key)
       initialize_for_key(key)
-      send(:"#{key.to_sym}")
+      send(unique_key(key))
     end
 
     def set(key, errors)
       initialize_for_key(key)
-      send :"#{key.to_sym}=", Array.wrap(errors)
+      send :"#{unique_key(key)}=", Array.wrap(errors)
     end
 
     def add(key, error)
-      get(key) << error
+      send(unique_key(key)) << error
     end
 
     def [](key)
@@ -40,14 +45,18 @@ module MotionPrime
       set(key, errors)
     end
 
+    def reset_for(key)
+      send :"#{unique_key(key)}=", []
+    end
+
     def reset
-      @keys.each do |key|
-        set(key, [])
+      @_unique_keys.each do |unique_key|
+        send :"#{unique_key}=", []
       end
     end
 
     def messages
-      @keys.map{ |k| get(k)}.compact.flatten
+      @_unique_keys.map{ |uniq_k| send(uniq_k) }.compact.flatten
     end
 
     def blank?

data/motion-prime/models/finder.rb

@@ -1,5 +1,7 @@
 module MotionPrime
   module ModelFinderMethods
+    attr_accessor :bare_class
+
     # Find all models
     #
     # @return [Array] array of models
@@ -141,7 +143,8 @@ module MotionPrime
     end
 
     def bare_class_name
-      self.to_s.split("::").last
+      subject = @bare_class || self
+      subject.to_s.split("::").last
     end
 
     private

data/motion-prime/models/model.rb

@@ -28,8 +28,8 @@ module MotionPrime
     def assign_attributes(new_attributes, options = {})
       attributes = new_attributes.symbolize_keys
       attributes.each do |k, v|
-        if respond_to?("#{k}=")
-          send("#{k}=", v) unless options[:skip_nil_values] && v.nil?
+        if has_attribute?(k)
+          assign_attribute(k, v) unless options[:skip_nil_values] && v.nil?
         elsif options[:check_attribute_presence]
           puts "unknown attribute: #{k}"
         else
@@ -38,6 +38,14 @@ module MotionPrime
       end
     end
 
+    def assign_attribute(name, value)
+      self.send("#{name}=", value) if has_attribute?(name)
+    end
+
+    def has_attribute?(name)
+      respond_to?("#{name}=")
+    end
+
     def attributes_hash
       self.info.to_hash.symbolize_keys
     end
@@ -51,7 +59,7 @@ module MotionPrime
     end
 
     def model_name
-      self.class.name.underscore
+      self.class_name_without_kvo.underscore
     end
 
     def inspect
@@ -97,7 +105,7 @@ module MotionPrime
     #   end
     #
     # @return Nil
-    def attribute(name)
+    def attribute(name, options = {})
       attributes << name
 
       define_method(name) do |*args, &block|
@@ -105,7 +113,19 @@ module MotionPrime
       end
 
       define_method((name + "=").to_sym) do |*args, &block|
-        self.info[name] = args[0]
+        value = args[0]
+        case options[:type].to_s
+        when 'integer' then value = value.to_i
+        when 'float' then value = value.to_f
+        end unless value.nil?
+
+        self.info[name] = value
+      end
+
+      if options[:type].to_s == 'boolean'
+        define_method("#{name}?") do
+          !!self.info[name]
+        end
       end
     end
 

data/motion-prime/models/store_extension.rb

@@ -43,13 +43,7 @@ class NSFNanoStore
     raise MotionPrime::StoreError, error_ptr[0].description if error_ptr[0]
     self
   end
-
-  def +(object)
-    error_ptr = Pointer.new(:id)
-    self.addObject(object, error:error_ptr)
-    raise MotionPrime::StoreError, error_ptr[0].description if error_ptr[0]
-    self
-  end
+  alias_method :+, :<<
 
   # delete a object or array of objects from the array
   def delete(objects)

data/motion-prime/models/sync.rb

@@ -6,9 +6,9 @@ module MotionPrime
       base.class_attribute :_associations
     end
 
-    def sync_url(method = :get)
+    def sync_url(method = :get, options = {})
       url = self.class.sync_url
-      url = url.call(method, self) if url.is_a?(Proc)
+      url = url.call(method, self, options) if url.is_a?(Proc)
       normalize_sync_url(url)
     end
 
@@ -38,12 +38,13 @@ module MotionPrime
         should_fetch
       end
 
-      method = if should_update
+      method = sync_options[:method]
+      method ||= if should_update
         persisted? ? :put : :post
       else
         :get
       end
-      url = sync_url(method)
+      url = sync_url(method, sync_options)
 
       if url.blank?
         should_fetch = false
@@ -53,9 +54,9 @@ module MotionPrime
       should_fetch = !new_record? if should_fetch.nil?
       should_update ||= new_record? unless should_fetch
 
-      fetch_with_url url do
+      fetch_with_url url do |data, status_code|
         save if sync_options[:save]
-        block.call if use_callback
+        block.call(data, status_code) if use_callback
       end if should_fetch
 
       update_with_url url, sync_options do |data, status_code|
@@ -64,38 +65,50 @@ module MotionPrime
         block.call(data, status_code) if use_callback && !should_fetch
       end if should_update
 
-      fetch_associations(sync_options) do
+      fetch_associations(sync_options) do |data, status_code|
         # run callback only if it wasn't run on fetch or update
-        block.call if use_callback && !should_fetch && !should_update
+        block.call(data, status_code) if use_callback && !should_fetch && !should_update
       end if should_fetch_associations
     end
 
     # fetch from server using url
     def fetch_with_url(url, &block)
-      api_client.get(url) do |data|
-        if data.present?
-          fetch_with_attributes(data, &block)
-        end
+      use_callback = block_given?
+      api_client.get(url) do |data, status_code|
+        fetch_with_attributes(data, &block) if data.present?
+        block.call(data, status_code) if use_callback
       end
     end
 
     # update on server using url
     def update_with_url(url, sync_options = nil, &block)
       use_callback = block_given?
-      post_data = { model_name => filtered_updatable_attributes(sync_options)}
-      api_client.send(id ? :put : :post, url, post_data) do |data, status_code|
-        if status_code.to_s =~ /20\d/ && data.is_a?(Hash)
-          self.id ||= data['id']
-          accessible_attributes = self.class.attributes.map(&:to_sym) - [:id]
-          attrs = data.symbolize_keys.slice(*accessible_attributes)
-          fetch_with_attributes(attrs)
+      filtered_attributes = filtered_updatable_attributes(sync_options)
+
+      post_data = sync_options[:params_root] || {}
+      post_data[:files] = {}
+      filtered_attributes.delete(:files).each do |file_name, file|
+        post_data[:files][[model_name, file_name].join] = file
+      end
+      post_data[model_name] = filtered_attributes
+
+      method = sync_options[:method] || (id ? :put : :post)
+      api_client.send(method, url, post_data) do |data, status_code|
+        update_from_response = sync_options.has_key?(:update_from_response) ? sync_options[:update_from_response] : true
+        if update_from_response && status_code.to_s =~ /20\d/ && data.is_a?(Hash)
+          set_attributes_from_response(data)
         end
         block.call(data, status_code) if use_callback
       end
     end
 
+    def set_attributes_from_response(data)
+      self.id ||= data.delete('id')
+      fetch_with_attributes(data)
+    end
+
     # set attributes, using fetch
-    def fetch_with_attributes(attrs, &block)
+    def fetch_with_attributes(attrs)
       attrs.each do |key, value|
         if respond_to?(:"fetch_#{key}")
           self.send(:"fetch_#{key}", value)
@@ -103,14 +116,14 @@ module MotionPrime
           self.send(:"#{key}=", value)
         end
       end
-      block.call(self) if block_given?
     end
 
     def fetch_associations(sync_options = {}, &block)
       use_callback = block_given?
       associations = self.class._associations || {}
+      association_keys = associations.keys.select { |key| fetch_association?(key) }
 
-      associations.keys.each_with_index do |key, index|
+      association_keys.each_with_index do |key, index|
         if use_callback && associations.count - 1 == index
           fetch_association(key, sync_options, &block)
         else
@@ -119,21 +132,30 @@ module MotionPrime
       end
     end
 
+    def fetch_association?(key)
+      options = self.class._associations[key]
+      return if options[:if] && !options[:if].to_proc.call(self)
+      options[:sync_url].present?
+    end
+
     def fetch_association(key, sync_options = {}, &block)
+      return unless fetch_association?(key)
       options = self.class._associations[key]
-      return unless options[:sync_url]
-      options[:type] == :many ?
-      fetch_has_many(key, options, sync_options, &block) :
-      fetch_has_one(key, options, sync_options, &block)
+      if options[:type] == :many
+        fetch_has_many(key, options, sync_options, &block)
+      else
+        fetch_has_one(key, options, sync_options, &block)
+      end
     end
 
     def fetch_has_many(key, options = {}, sync_options = {}, &block)
       old_collection = self.send(key)
+
       use_callback = block_given?
-      puts "SYNC: started sync for #{key} in #{self.class.name}"
-      api_client.get normalize_sync_url(options[:sync_url]) do |data|
+      puts "SYNC: started sync for #{key} in #{self.class_name_without_kvo}"
+      api_client.get normalize_sync_url(options[:sync_url]) do |data, status_code|
         data = data[options[:sync_key]] if options[:sync_key]
-        if data.present?
+        if data
           # Update/Create existing records
           data.each do |attributes|
             model = old_collection.detect{ |model| model.id == attributes[:id]}
@@ -151,19 +173,19 @@ module MotionPrime
             end
           end
           save if sync_options[:save]
-          puts "SYNC: finished sync for #{key} in #{self.class.name}"
-          block.call if use_callback
+          puts "SYNC: finished sync for #{key} in #{self.class_name_without_kvo}"
+          block.call(data, status_code) if use_callback
         else
-          puts "SYNC ERROR: failed sync for #{key} in #{self.class.name}"
-          block.call if use_callback
+          puts "SYNC ERROR: failed sync for #{key} in #{self.class_name_without_kvo}"
+          block.call(data, status_code) if use_callback
         end
       end
     end
 
     def fetch_has_one(key, options = {}, &block)
       use_callback = block_given?
-      puts "SYNC: started sync for #{key} in #{self.class.name}"
-      api_client.get normalize_sync_url(options[:sync_url]) do |data|
+      puts "SYNC: started sync for #{key} in #{self.class_name_without_kvo}"
+      api_client.get normalize_sync_url(options[:sync_url]) do |data, status_code|
         data = data[options[:sync_key]] if options[:sync_key]
         if data.present?
           model = self.send(key)
@@ -173,10 +195,10 @@ module MotionPrime
           end
           model.fetch_with_attributes(data)
           model.save if sync_options[:save]
-          block.call if use_callback
+          block.call(data, status_code) if use_callback
         else
-          puts "SYNC ERROR: failed sync for #{key} in #{self.class.name}"
-          block.call if use_callback
+          puts "SYNC ERROR: failed sync for #{key} in #{self.class_name_without_kvo}"
+          block.call(data, status_code) if use_callback
         end
       end
     end
@@ -186,19 +208,29 @@ module MotionPrime
       updatable_attributes = self.class.updatable_attributes
 
       if updatable_attributes.blank?
-        return slice_attributes ? attributes_hash.slice(*slice_attributes) : attributes_hash
+        attrs =  slice_attributes ? attributes_hash.slice(*slice_attributes) : attributes_hash
+        return attrs.merge(files: {})
       end
 
       updatable_attributes = updatable_attributes.slice(*slice_attributes) if slice_attributes
-      updatable_attributes.to_a.inject({}) do |hash, attribute|
+      updatable_attributes.to_a.inject({files: {}}) do |hash, attribute|
         key, options = *attribute
-        return hash if options[:if] && !send(options[:if])
+        next hash if options[:if] && !send(options[:if])
         value = if block = options[:block]
-          block.call(self)
+          block.call(self, hash)
         else
           info[key]
         end
-        hash.merge(key => value)
+
+        if key.to_s.starts_with?('file_')
+          value.to_a.each do |file_data|
+            file_name, file = file_data.to_a
+            hash[:files]["[#{key.partition('_').last}]#{file_name}"] = file
+          end
+        else
+          hash.merge!(key => value)
+        end
+        hash
       end
     end