motion-prime 0.1.7 → 0.2.0

data/motion-prime/models/errors.rb

@@ -1,3 +1,64 @@
 module MotionPrime
-  class StoreError < StandardError; end
+  class Errors
+    attr_accessor :keys
+    attr_accessor :errors
+
+    def initialize(model)
+      @keys = []
+      @errors = {}
+      model.class.attributes.map(&:to_sym).each do |key|
+        initialize_for_key key
+      end
+    end
+
+    def initialize_for_key(key)
+      @keys << key.to_sym unless @keys.include?(key.to_sym)
+      @errors[key.to_sym] ||= []
+    end
+
+    def get(key)
+      initialize_for_key(key)
+      @errors[key.to_sym]
+    end
+
+    def set(key, errors)
+      initialize_for_key(key)
+      @errors[key.to_sym] = Array.wrap(errors)
+    end
+
+    def add(key, error)
+      initialize_for_key(key)
+      @errors[key.to_sym] << error
+    end
+
+    def [](key)
+      get(key)
+    end
+
+    def []=(key, errors)
+      set(key, errors)
+    end
+
+    def reset
+      @keys.each do |key|
+        set(key, [])
+      end
+    end
+
+    def messages
+      errors.values.compact.flatten
+    end
+
+    def blank?
+      messages.blank?
+    end
+
+    def present?
+      !blank?
+    end
+
+    def to_s
+      messages.join(';')
+    end
+  end
 end

data/motion-prime/models/exceptions.rb

@@ -0,0 +1,3 @@
+module MotionPrime
+  class StoreError < StandardError; end
+end

data/motion-prime/models/model.rb

@@ -2,7 +2,6 @@ module MotionPrime
   module ModelMethods
     def save
       raise StoreError, 'No store provided' unless self.store
-
       error_ptr = Pointer.new(:id)
       self.store.addObject(self, error: error_ptr)
       raise StoreError, error_ptr[0].description if error_ptr[0]
@@ -21,6 +20,39 @@ module MotionPrime
     def store
       super || self.class.store
     end
+
+    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?
+        elsif options[:check_attribute_presence]
+          puts "unknown attribute: #{k}"
+        else
+          raise(NoMethodError, "unknown attribute: #{k}")
+        end
+      end
+    end
+
+    def attributes_hash
+      self.info.to_hash.symbolize_keys
+    end
+
+    def new_record?
+      id.blank?
+    end
+
+    def persisted?
+      !new_record?
+    end
+
+    def model_name
+      self.class.name.underscore
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}> " + MotionPrime::JSON.generate(info)
+    end
   end
 
   module ModelClassMethods

data/motion-prime/models/sync.rb

@@ -0,0 +1,233 @@
+module MotionPrime
+  module ModelSyncMethods
+    def self.included(base)
+      base.class_attribute :_sync_url
+      base.class_attribute :_updatable_attributes
+      base.class_attribute :_associations
+    end
+
+    def sync_url(method = :get)
+      url = self.class.sync_url
+      url = url.call(method) if url.is_a?(Proc)
+      normalize_sync_url(url)
+    end
+
+    # destroy on server and delete on local
+    def destroy(&block)
+      use_callback = block_given?
+      api_client.delete(sync_url(:delete)) do
+        block.call() if use_callback
+      end
+      delete
+    end
+
+    # sync with server and save on local
+    def sync!(sync_options = {}, &block)
+      sync(sync_options.merge(save: true), &block)
+    end
+
+    # sync with with server
+    # TODO: order of fetch/update should be based on updated time?
+    def sync(sync_options = {}, &block)
+      use_callback = block_given?
+      should_fetch = sync_options[:fetch]
+      should_update = sync_options[:update]
+      should_fetch_associations = if sync_options.has_key?(:fetch_associations)
+        sync_options[:fetch_associations]
+      else # do not need to fetch unless this is a GET request
+        should_fetch
+      end
+
+      method = if should_update
+        persisted? ? :put : :post
+      else
+        :get
+      end
+      url = sync_url(method)
+
+      if url.blank?
+        should_fetch = false
+        should_update = false
+      end
+
+      should_fetch = !new_record? if should_fetch.nil?
+      should_update = new_record? if should_update.nil?
+
+      fetch_with_url url do
+        save if sync_options[:save]
+        block.call if use_callback
+      end if should_fetch
+
+      update_with_url url, sync_options do |data, status_code|
+        save if sync_options[:save] && status_code.to_s =~ /20\d/
+        # run callback only if it wasn't run on fetch
+        block.call(data, status_code) if use_callback && !should_fetch
+      end if should_update
+
+      fetch_associations(sync_options) do
+        # run callback only if it wasn't run on fetch or update
+        block.call 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
+      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)
+        end
+        block.call(data, status_code) if use_callback
+      end
+    end
+
+    # set attributes, using fetch
+    def fetch_with_attributes(attrs, &block)
+      attrs.each do |key, value|
+        if respond_to?(:"fetch_#{key}")
+          self.send(:"fetch_#{key}", value)
+        elsif respond_to?(:"#{key}=")
+          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 || {}
+
+      associations.keys.each_with_index do |key, index|
+        if use_callback && associations.count - 1 == index
+          fetch_association(key, sync_options, &block)
+        else
+          fetch_association(key, sync_options)
+        end
+      end
+    end
+
+    def fetch_association(key, sync_options = {}, &block)
+      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)
+    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|
+        data = data[options[:sync_key]] if options[:sync_key]
+        if data.present?
+          # Update/Create existing records
+          data.each do |attributes|
+            model = old_collection.detect{ |model| model.id == attributes[:id]}
+            unless model
+              model = key.singularize.to_s.classify.constantize.new
+              self.send(:"#{key}_bag") << model
+            end
+            model.fetch_with_attributes(attributes)
+            model.save if sync_options[:save]
+          end
+          old_collection.each do |old_model|
+            model = data.detect{ |model| model[:id] == old_model.id}
+            unless model
+              old_model.delete
+            end
+          end
+          save if sync_options[:save]
+          puts "SYNC: finished sync for #{key} in #{self.class.name}"
+          block.call if use_callback
+        else
+          puts "SYNC ERROR: failed sync for #{key} in #{self.class.name}"
+          block.call 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|
+        data = data[options[:sync_key]] if options[:sync_key]
+        if data.present?
+          model = self.send(key)
+          unless model
+            model = key.singularize.to_s.classify.constantize.new
+            self.send(:"#{key}_bag") << model
+          end
+          model.fetch_with_attributes(data)
+          model.save if sync_options[:save]
+          block.call if use_callback
+        else
+          puts "SYNC ERROR: failed sync for #{key} in #{self.class.name}"
+          block.call if use_callback
+        end
+      end
+    end
+
+    def filtered_updatable_attributes(options = {})
+      slice_attributes = options[:updatable_attributes].map(&:to_sym) if options.has_key?(:updatable_attributes)
+      updatable_attributes = self.class.updatable_attributes
+
+      if updatable_attributes.blank?
+        attrs = attributes_hash.slice(*slice_attributes) if slice_attributes
+        return attrs
+      end
+
+      updatable_attributes = updatable_attributes.slice(*slice_attributes) if slice_attributes
+      updatable_attributes.to_a.inject({}) do |hash, attribute|
+        key, options = *attribute
+        return hash if options[:if] && !send(options[:if])
+        value = if block = options[:block]
+          block.call(self)
+        else
+          info[key]
+        end
+        hash.merge(key => value)
+      end
+    end
+
+    def normalize_sync_url(url)
+      url.to_s.gsub(':id', id.to_s)
+    end
+  end
+
+  module ModelSyncClassMethods
+    def sync_url(url = nil, &block)
+      if url || block_given?
+        self._sync_url = url || block
+      else
+        self._sync_url
+      end
+    end
+
+    def updatable_attributes(*attrs)
+      return self._updatable_attributes if attrs.blank?
+      attrs.each do |attribute|
+        updatable_attribute attribute
+      end
+    end
+
+    def updatable_attribute(attribute, options = {}, &block)
+      options[:block] = block if block_given?
+      self._updatable_attributes ||= {}
+      self._updatable_attributes[attribute] = options
+    end
+  end
+end

data/motion-prime/screens/_base_mixin.rb

@@ -37,7 +37,10 @@ module MotionPrime
         self.send("#{k}=", v) if self.respond_to?("#{k}=")
       end
 
-      self.add_navigation_controller if args[:navigation]
+      if @wrap_in_navigation = args[:navigation]
+        self.add_navigation_controller
+      end
+
       self.on_init if respond_to?(:on_init)
       self
     end

data/motion-prime/screens/_navigation_mixin.rb

@@ -10,9 +10,9 @@ module MotionPrime
       ensure_wrapper_controller_in_place(screen, args)
       screen.send(:on_screen_load) if screen.respond_to?(:on_screen_load)
       if args[:modal]
-        present_modal_view_controller screen, (args[:animated] || true)
+        present_modal_view_controller screen, (args.has_key?(:animated) ? args[:animated] : true)
       elsif has_navigation?
-        push_view_controller screen
+        push_view_controller screen, args
       else
         app_delegate.open_screen(screen.main_controller)
       end
@@ -32,7 +32,7 @@ module MotionPrime
 
     def close_screen(args = {})
       args ||= {}
-      args[:animated] ||= true
+      args[:animated] = args.has_key?(:animated) ? args[:animated] : true
       # Pop current view, maybe with arguments, if in navigation controller
       if modal?
         close_modal_screen args
@@ -52,8 +52,8 @@ module MotionPrime
       end
     end
 
-    def push_view_controller(vc)
-      navigation_controller.pushViewController(vc, animated: true)
+    def push_view_controller(vc, args = {})
+      navigation_controller.pushViewController(vc, animated: (args.has_key?(:animated) ? args[:animated] : true))
     end
 
     protected

data/motion-prime/sections/base.rb

@@ -23,11 +23,15 @@ module MotionPrime
     def initialize(options = {})
       @options = options
       @model = options[:model]
-      @name = options[:name] ||= self.class.name.demodulize.underscore.gsub(/\_section$/, '')
+      @name = options[:name] ||= default_name
       create_elements
       self.hide if container_options[:hidden]
     end
 
+    def default_name
+      self.class.name.demodulize.underscore.gsub(/\_section$/, '')
+    end
+
     def elements_options
       self.class.elements_options || {}
     end
@@ -35,14 +39,23 @@ module MotionPrime
     def create_elements
       self.elements = {}
       elements_options.each do |key, opts|
-        # we should clone options to prevent overriding options
-        # in next element with same name in another class
-        options = opts.clone
-        options[:section] = self
+        next unless render_element?(key)
+        options = build_options_for_element(opts)
         self.elements[key] = MotionPrime::BaseElement.factory(options.delete(:type), options)
       end
     end
 
+    def render_element?(element_name)
+      true
+    end
+
+    def build_options_for_element(opts)
+      # we should clone options to prevent overriding options
+      # in next element with same name in another class
+      options = opts.clone
+      options.merge(section: self)
+    end
+
     def render(container_options = {})
       self.container_options.merge!(container_options)
       self.screen = container_options.delete(:to)

data/motion-prime/sections/form.rb

@@ -20,6 +20,7 @@ module MotionPrime
     KEYBOARD_HEIGHT_PORTRAIT = 216
     KEYBOARD_HEIGHT_LANDSCAPE = 162
 
+    class_attribute :text_field_limits, :text_view_limits
     class_attribute :fields_options
     attr_accessor :fields, :field_indexes, :keyboard_visible
 
@@ -30,8 +31,8 @@ module MotionPrime
     end
 
     def render_table
-      @data_stamp = Time.now.to_i
       init_form_fields
+      set_data_stamp(self.field_indexes.values)
       self.table_view = screen.table_view(
         styles: [:base_form, name.to_sym], delegate: self, dataSource: self
       ).view
@@ -39,12 +40,29 @@ module MotionPrime
 
     def render_cell(index, table)
       item = data[index.row]
-
-      screen.table_view_cell styles: [:base_form_field, :"#{name}_field"], reuse_identifier: cell_name(table, index) do
+      styles = [:base_form_field, :"#{name}_field"]
+      if item.respond_to?(:container_styles) && item.container_styles.present?
+        styles += Array.wrap(item.container_styles)
+      end
+      screen.table_view_cell styles: styles, reuse_identifier: cell_name(table, index) do |cell_element|
+        item.cell_element = cell_element if item.respond_to?(:cell_element)
         item.render(to: screen)
       end
     end
 
+    def reload_cell(section)
+      field = section.name.to_sym
+      path = table_view.indexPathForRowAtPoint(section.cell.center) # do not use indexPathForCell here as field may be invisibe
+      table_view.beginUpdates
+      section.cell.removeFromSuperview
+
+      fields[field] = load_field(self.class.fields_options[field])
+      @data = nil
+      set_data_stamp([field_indexes[field]])
+      table_view.reloadRowsAtIndexPaths([path], withRowAnimation: UITableViewRowAnimationNone)
+      table_view.endUpdates
+    end
+
     # Returns element based on field name and element name
     #
     # Examples:
@@ -88,16 +106,6 @@ module MotionPrime
       field(field_name).focus
     end
 
-    class << self
-      def field(name, options = {})
-        options[:name] = name
-        options[:type] ||= :string
-        self.fields_options ||= {}
-        self.fields_options[name] = options
-        self.fields_options[name]
-      end
-    end
-
     def set_height_with_keyboard
       return if keyboard_visible
       self.table_view.height -= KEYBOARD_HEIGHT_PORTRAIT
@@ -148,15 +156,66 @@ module MotionPrime
       on_input_edit(text_field)
     end
 
-    private
+    def textView(text_view, shouldChangeTextInRange:range, replacementText:string)
+      limit = (self.class.text_view_limits || {}).find do |field_name, limit|
+        view("#{field_name}:input")
+      end.try(:last)
+      return true unless limit
+      allow_string_replacement?(text_view, limit, range, string)
+    end
+
+    def textField(text_field, shouldChangeCharactersInRange:range, replacementString:string)
+      limit = (self.class.text_field_limits || {}).find do |field_name, limit|
+        view("#{field_name}:input")
+      end.try(:last)
+      return true unless limit
+      allow_string_replacement?(text_field, limit, range, string)
+    end
+
+    def allow_string_replacement?(target, limit, range, string)
+      if string.length.zero? || (range.length + limit - target.text.length) >= string.length
+        true
+      else
+        target.text.length < limit
+      end
+    end
+
+    def load_field(field)
+      klass = "MotionPrime::#{field[:type].classify}FieldSection".constantize
+      klass.new(field.merge(form: self))
+    end
+
+    def render_field?(name)
+      true
+    end
+
+    class << self
+      def field(name, options = {})
+        options[:name] = name
+        options[:type] ||= :string
+        self.fields_options ||= {}
+        self.fields_options[name] = options
+        self.fields_options[name]
+      end
 
+      def limit_text_field_length(name, limit)
+        self.text_field_limits ||= {}
+        self.text_field_limits[name] = limit
+      end
+      def limit_text_view_length(name, limit)
+        self.text_view_limits ||= {}
+        self.text_view_limits[name] = limit
+      end
+    end
+
+    private
       def init_form_fields
         self.fields = {}
         self.field_indexes = {}
         index = 0
         (self.class.fields_options || []).each do |key, field|
-          klass = "MotionPrime::#{field[:type].classify}FieldSection".constantize
-          self.fields[key] = klass.new(field.merge(form: self))
+          next unless render_field?(key)
+          self.fields[key] = load_field(field)
           self.field_indexes[key] = index
           index += 1
         end