motion-prime 0.8.1 → 0.8.2

data/motion-prime/models/_association_mixin.rb

@@ -78,9 +78,7 @@ module MotionPrime
 
           association = association_name.classify.constantize.new
           association.fetch_with_attributes(value)
-          association.save
           self.send(:"#{bag_name}") << association
-          self.send(:"#{bag_name}").save
           association
         end
         define_method("#{association_name}") do
@@ -111,7 +109,6 @@ module MotionPrime
           end
           association_data = collection.values
           self.send(:"#{bag_name}=", association_data)
-          self.send(:"#{bag_name}").save
           association_data
         end
         define_method("#{association_name}=") do |value|

data/motion-prime/models/_base_mixin.rb

@@ -33,7 +33,7 @@ module MotionPrime
       super || self.class.store
     end
 
-    # Assigns attributes to model 
+    # Assigns attributes to model
     #
     # @params attributes [Hash] attributes to be assigned
     # @params options [Hash] options
@@ -53,7 +53,7 @@ module MotionPrime
       end
     end
 
-    # Assigns attribute to model 
+    # Assigns attribute to model
     #
     # @params name [String, Symbol] attribute name
     # @params value [Object] attribute value
@@ -105,6 +105,13 @@ module MotionPrime
       "#<#{self.class}:0x#{self.object_id.to_s(16)}> " + MotionPrime::JSON.generate(info)
     end
 
+    # Returns a clone of the record with empty bags
+    #
+    # @return new [Prime::Model] model
+    def clone
+      self.class.new(self.info.select { |key, value| !key.to_s.ends_with?('_bag') })
+    end
+
     module ClassMethods
       # Initialize a new object
       #
@@ -167,7 +174,7 @@ module MotionPrime
         define_method((name + "=").to_sym) do |*args, &block|
           value = args[0]
           case options[:type].to_s
-          when 'integer' 
+          when 'integer'
             value = value.to_i
           when 'float'
             value = value.to_f
@@ -178,6 +185,20 @@ module MotionPrime
           self.info[name] = value
         end
 
+        define_method(name.to_sym) do
+          value = self.info[name]
+          case options[:type].to_s
+          when 'integer'
+            value.to_i
+          when 'float'
+            value.to_f
+          when 'time' && !value.is_a?(String)
+            value.to_short_iso8601
+          else
+            value
+          end
+        end if options[:convert]
+
         if options[:type].to_s == 'boolean'
           define_method("#{name}?") do
             !!self.info[name]

data/motion-prime/models/_filter_mixin.rb

@@ -0,0 +1,28 @@
+module MotionPrime
+  module FilterMixin
+    def filter_array(data, find_options = {}, sort_options = nil)
+      data = data.select do |entity|
+        find_options.all? { |field, value| entity.info[field] == value }
+      end if find_options.present?
+
+      data.sort! do |a, b|
+        left_part = []
+        right_part = []
+
+        sort_options[:sort].each do |(k,v)|
+          left = a.send(k)
+          right = b.send(k)
+          if left.class != right.class
+            left = left.to_s
+            right = right.to_s
+          end
+          left, right = right, left if v.to_s == 'desc'
+          left_part << left
+          right_part << right
+        end
+        left_part <=> right_part
+      end if sort_options.try(:[], :sort).present?
+      data
+    end
+  end
+end

data/motion-prime/models/_sync_mixin.rb

@@ -50,7 +50,7 @@ module MotionPrime
     #
     # @param options [Hash] fetch options
     # @option options [Symbol] :method Http method to calculate url, `:get` by default
-    # @option options [Boolean] :associations Also fetch associations
+    # @option options [Boolean or Array] :associations Also fetch associations
     # @option options [Boolean] :save Save model after fetch
     # @param block [Proc] block to be executed after fetch
     def fetch(options = {}, &block)
@@ -59,8 +59,8 @@ module MotionPrime
       url = sync_url(method, options)
 
       will_fetch_model = !url.blank?
-      will_fetch_associations = !options.has_key?(:associations) || options[:associations]
-      will_fetch_associations = false unless has_associations_to_fetch?
+      will_fetch_associations = options.fetch(:associations, true)
+      will_fetch_associations = false unless has_associations_to_fetch?(options)
 
       fetch_with_url url, options do |data, status_code|
         save if options[:save]
@@ -176,13 +176,13 @@ module MotionPrime
       @associations ||= (self.class._associations || {}).clone
     end
 
-    def associations_to_fetch
-      @associations_to_fetch ||= associations.select { |key, v| fetch_association?(key) }
+    def associations_to_fetch(options = {})
+      associations.select { |key, v| fetch_association?(key, options) }
     end
 
     def fetch_associations(sync_options = {}, &block)
       use_callback = block_given?
-      associations_to_fetch.keys.each_with_index do |key, index|
+      associations_to_fetch(sync_options).keys.each_with_index do |key, index|
         if use_callback && associations.count - 1 == index
           fetch_association(key, sync_options, &block)
         else
@@ -191,22 +191,25 @@ module MotionPrime
       end
     end
 
-    def has_associations_to_fetch?
-      associations_to_fetch.present?
+    def has_associations_to_fetch?(options = {})
+      associations_to_fetch(options).present?
     end
 
     def has_association?(key)
       !associations[key.to_sym].nil?
     end
 
-    def fetch_association?(key)
+    def fetch_association?(key, options = {})
+      allowed_associations = options[:associations].map(&:to_sym) if options[:associations].is_a?(Array)
+      return false if allowed_associations.try(:exclude?, key.to_sym)
+
       options = associations[key.to_sym]
       return false if options[:if] && !options[:if].to_proc.call(self)
       association_sync_url(key, options).present?
     end
 
     def fetch_association(key, sync_options = {}, &block)
-      return unless fetch_association?(key)
+      return unless fetch_association?(key, sync_options)
       options = associations[key.to_sym]
       if options[:type] == :many
         fetch_has_many(key, options, sync_options, &block)

data/motion-prime/models/association_collection.rb

@@ -1,10 +1,10 @@
 module MotionPrime
   class AssociationCollection < ::Array
+    include FilterMixin
+
     attr_reader :bag, :association_name
     attr_reader :inverse_relation_name, :inverse_relation_key, :model_inverse_relation_name
 
-    delegate :<<, to: :bag
-
     def initialize(bag, options, *args)
       @bag = bag
       @association_name = options[:association_name]
@@ -17,7 +17,8 @@ module MotionPrime
         options[:class_name] == inverse_relation.class_name_without_kvo
       end.try(:first)
 
-      super all(*args)
+      data = bag.store.present? ? find(*args) : filter(*args)
+      super data
     end
 
     # Initialize a new object and add to collection.
@@ -28,9 +29,7 @@ module MotionPrime
     # @params attributes [Hash] attributes beeing assigned to model
     # @return MotionPrime::Model unsaved model
     def new(attributes = {})
-      record = model_class.new(attributes).tap do |model|
-        set_inverse_relation_for(model)
-      end
+      record = model_class.new(attributes)
       add(record)
     end
 
@@ -42,30 +41,50 @@ module MotionPrime
     # @params record [Prime::Model] model which will be added to collection.
     # @return MotionPrime::Model model
     def add(record)
+      set_inverse_relation_for(record)
       self.bag << record
       record
     end
+    alias_method :<<, :add
 
     # Return all association records.
     #
     # @example:
     #   project.users.all
-    #   project.users.all(age: 10)
+    #
+    # @return Array<MotionPrime::Model> association records
+    def all
+      data = bag.to_a
+      set_inverse_relation_for(data)
+      data
+    end
+    alias_method :to_a, :all
+
+    # Find association records.
+    #
+    # @example:
+    #   project.users.find(age: 10)
     #
     # @params find_options [Hash] finder options.
     # @params sort_options [Hash] sorting options.
     # @return Array<MotionPrime::Model> association records
-    def all(find_options = nil, sort_options = nil)
+    def find(find_options = {}, sort_options = nil)
+      raise "Use `filter` method when bag has not been saved yet" unless bag.store.present?
+
       find_options = build_find_options(find_options)
       sort_options = build_sort_options(sort_options)
 
-      data = if bag.store.present?
-        bag.find(find_options, sort_options)
-      else
-        bag.to_a.select do |entity| 
-          find_options.all? { |field, value| entity.info[field] == value }
-        end
-      end
+      data = bag.find(find_options, sort_options)
+      set_inverse_relation_for(data)
+      data
+    end
+
+    def filter(find_options = {}, sort_options = nil)
+      find_options = build_find_options(find_options)
+      sort_options = build_sort_options(sort_options)
+
+      data = filter_array(bag.to_a, find_options, sort_options)
+
       set_inverse_relation_for(data)
       data
     end
@@ -96,7 +115,13 @@ module MotionPrime
       end
 
       def build_sort_options(options)
-        options || {sort: model_class.default_sort_options}
+        options || begin
+          {sort: model_class.default_sort_options} if has_default_sort?
+        end
+      end
+
+      def has_default_sort?
+        model_class.default_sort_options.present?
       end
 
       def set_inverse_relation_for(models)

data/motion-prime/models/errors.rb

@@ -1,41 +1,39 @@
 module MotionPrime
   class Errors
-    attr_accessor :_unique_keys
+    attr_accessor :info
+    attr_reader :changes
 
     def initialize(model)
-      @_unique_keys = []
+      @info = MotionSupport::HashWithIndifferentAccess.new
+      @changes = MotionSupport::HashWithIndifferentAccess.new
       @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)
-      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
+    def to_hash
+      @info
     end
 
     def get(key)
       initialize_for_key(key)
-      send(unique_key(key))
+      to_hash[key]
     end
 
-    def set(key, errors)
+    def set(key, errors, options = {})
       initialize_for_key(key)
-      send :"#{unique_key(key)}=", Array.wrap(errors)
+
+      track_changed options do
+        to_hash[key] = Array.wrap(errors)
+      end
     end
 
-    def add(key, error)
+    def add(key, error, options = {})
       initialize_for_key(key)
-      send(unique_key(key)) << error
+      track_changed do
+        to_hash[key] << error
+      end
     end
 
     def [](key)
@@ -46,22 +44,26 @@ module MotionPrime
       set(key, errors)
     end
 
-    def reset_for(key)
-      send :"#{unique_key(key)}=", []
+    def reset_for(key, options = {})
+      track_changed options do
+        to_hash[key] = []
+      end
     end
 
     def reset
-      @_unique_keys.each do |unique_key|
-        send :"#{unique_key}=", []
+      track_changed do
+        to_hash.keys.each do |key|
+          reset_for(key, silent: true)
+        end
       end
     end
 
     def messages
-      @_unique_keys.map{ |uniq_k| send(uniq_k) }.compact.flatten
+      to_hash.values.flatten
     end
 
     def blank?
-      messages.blank?
+      messages.none?
     end
 
     def present?
@@ -71,5 +73,25 @@ module MotionPrime
     def to_s
       messages.join(';')
     end
+
+    def track_changed(options = {})
+      return yield if options[:silent]
+      @changes = MotionSupport::HashWithIndifferentAccess.new
+      saved_info = to_hash.clone
+      willChangeValueForKey(:info)
+      yield
+      to_hash.each do |key, value|
+        @changes[key] = [value, saved_info[key]] unless value == saved_info[key]
+      end
+      didChangeValueForKey(:info)
+    end
+
+    private
+      def initialize_for_key(key)
+        key = key.to_sym
+        return if @info.has_key?(key)
+
+        to_hash[key] ||= []
+      end
   end
 end

data/motion-prime/models/model.rb

@@ -24,6 +24,14 @@ module MotionPrime
       @errors ||= Errors.new(self.weak_ref)
     end
 
+    def set_errors(data)
+      errors.track_changed do
+        data.symbolize_keys.each do |key, error_messages|
+          errors.set(key, error_messages, silent: true) if error_messages.present?
+        end
+      end
+    end
+
     def dealloc
       Prime.logger.dealloc_message :model, self
       super

data/motion-prime/screens/_sections_mixin.rb

@@ -15,7 +15,7 @@ module MotionPrime
     end
 
     def all_sections
-      @sections.values
+      Array.wrap(@sections.try(:values))
     end
 
     def create_sections

data/motion-prime/screens/extensions/_indicators_mixin.rb

@@ -38,8 +38,10 @@ module MotionPrime
       when 'alert' then MBAlertViewHUDTypeExclamationMark
       else MBAlertViewHUDTypeCheckmark
       end
-      MBHUDView.hudWithBody message,
-        type: hud_type, hidesAfter: time, show: true
+
+      unless time === false
+        MBHUDView.hudWithBody(message, type: hud_type, hidesAfter: time, show: true)
+      end
     end
 
     def show_spinner(message = nil)

data/motion-prime/screens/extensions/_navigation_bar_mixin.rb

@@ -58,8 +58,8 @@ module MotionPrime
         face = UIButton.buttonWithType UIButtonTypeCustom
         face.setImage(image, forState: UIControlStateNormal)
         face.setTitle(title, forState: UIControlStateNormal)
-        face.bounds = CGRectMake(0, 0, 100, 60)
         face.setContentHorizontalAlignment UIControlContentHorizontalAlignmentLeft
+        face.sizeToFit
         face.on :touch do
           args[:action].to_proc.call(self)
         end