motion-prime 0.2.1 → 0.3.0

data/motion-prime/sections/form.rb

@@ -1,6 +1,9 @@
 motion_require './table.rb'
+motion_require '../helpers/has_style_chain_builder'
 module MotionPrime
   class FormSection < TableSection
+    include HasStyleChainBuilder
+
     # MotionPrime::FormSection is container for Field Sections.
     # Forms are located inside Screen and can contain multiple Field Sections.
     # On render, each field will be added to parent screen.
@@ -18,46 +21,100 @@ module MotionPrime
     #
 
     class_attribute :text_field_limits, :text_view_limits
-    class_attribute :fields_options
-    attr_accessor :fields, :field_indexes, :keyboard_visible
+    class_attribute :fields_options, :section_header_options
+    attr_accessor :fields, :field_indexes, :keyboard_visible, :rendered_views, :section_headers
 
     def table_data
-      fields.values
+      if @groups_count == 1
+        fields.values
+      else
+        section_indexes = []
+        fields.inject([]) do |result, (key, field)|
+          section = self.class.fields_options[key][:group].to_i
+
+          section_indexes[section] ||= 0
+          result[section] ||= []
+          result[section][section_indexes[section]] = field
+          section_indexes[section] += 1
+          result
+        end
+      end
+    end
+
+    def form_styles
+      base_styles = [:base_form]
+      base_styles << :base_form_with_sections unless flat_data?
+      item_styles = [name.to_sym]
+      {common: base_styles, specific: item_styles}
+    end
+
+    def field_styles(field)
+      suffixes = [:field]
+      if field.is_a?(BaseFieldSection)
+        suffixes << field.class_name_without_kvo.demodulize.underscore.gsub(/\_section$/, '')
+      end
+
+      styles = {
+        common: build_styles_chain(form_styles[:common], suffixes),
+        specific: build_styles_chain(form_styles[:specific], suffixes)
+      }
+
+      if field.respond_to?(:container_styles) && field.container_styles.present?
+        styles[:specific] += Array.wrap(field.container_styles)
+      end
+      styles
+    end
+
+    def header_styles(header)
+      suffixes = [:header, :"#{header.name}_header"]
+      styles = {
+        common: build_styles_chain(form_styles[:common], suffixes),
+        specific: build_styles_chain(form_styles[:specific], suffixes)
+      }
+
+      if header.respond_to?(:container_styles) && header.container_styles.present?
+        styles[:specific] += Array.wrap(header.container_styles)
+      end
+      styles
     end
 
     def render_table
       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
+      reset_data_stamps
+      options = {
+        styles: form_styles.values.flatten,
+        delegate: self,
+        dataSource: self,
+        style: (UITableViewStyleGrouped unless flat_data?)}
+      self.table_element = screen.table_view(options)
     end
 
     def render_cell(index, table)
-      item = data[index.row]
-      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)
+      field = rows_for_section(index.section)[index.row]
+      screen.table_view_cell styles: field_styles(field).values.flatten, reuse_identifier: cell_name(table, index), parent_view: table_view do |cell_view|
+        field.cell_view = cell_view if field.respond_to?(:cell_view)
+        field.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
+      index = field_indexes[field].split('_').map(&:to_i)
+      path = NSIndexPath.indexPathForRow(index.last, inSection: index.first)
       table_view.beginUpdates
-      section.cell.removeFromSuperview
+      section.cell.try(:removeFromSuperview)
 
       fields[field] = load_field(self.class.fields_options[field])
       @data = nil
-      set_data_stamp([field_indexes[field]])
+      set_data_stamp(field_indexes[field])
       table_view.reloadRowsAtIndexPaths([path], withRowAnimation: UITableViewRowAnimationNone)
       table_view.endUpdates
     end
 
+    def reset_data_stamps
+      set_data_stamp(self.field_indexes.values)
+    end
+
     # Returns element based on field name and element name
     #
     # Examples:
@@ -89,6 +146,13 @@ module MotionPrime
       fields.to_hash
     end
 
+    def register_elements_from_section(section)
+      self.rendered_views ||= {}
+      section.elements.values.each do |element|
+        self.rendered_views[element.view] = {element: element, section: section}
+      end
+    end
+
     # Set focus on field cell
     #
     # Examples:
@@ -98,7 +162,7 @@ module MotionPrime
     # @return MotionPrime::BaseFieldSection field
     def focus_on(field_name, animated = true)
       # unfocus other field
-      data.each do |item|
+      data.flatten.each do |item|
         item.blur
       end
       # focus on field
@@ -117,6 +181,19 @@ module MotionPrime
       self.keyboard_visible = false
     end
 
+    def keyboard_will_show
+      return if table_view.contentSize.height + table_view.top <= UIScreen.mainScreen.bounds.size.height
+      current_inset = table_view.contentInset
+      current_inset.bottom = KEYBOARD_HEIGHT_PORTRAIT + (self.table_element.computed_options[:bottom_content_offset] || 0)
+      table_view.contentInset = current_inset
+    end
+
+    def keyboard_will_hide
+      current_inset = table_view.contentInset
+      current_inset.bottom = self.table_element.computed_options[:bottom_content_offset] || 0
+      table_view.contentInset = current_inset
+    end
+
     # ALIASES
     def on_input_change(text_field); end
     def on_input_edit(text_field); end
@@ -159,19 +236,57 @@ module MotionPrime
       klass.new(field.merge(form: self))
     end
 
-    def render_field?(name)
-      true
+    def render_field?(name, options)
+      condition = options.delete(:if)
+      if condition.nil?
+        true
+      elsif condition.is_a?(Proc)
+        self.instance_eval(&condition)
+      else
+        condition
+      end
+    end
+
+    def render_header(section)
+      return unless options = self.class.section_header_options.try(:[], section)
+      self.section_headers[section] ||= BaseHeaderSection.new(options.merge(form: self))
+    end
+
+    def header_for_section(section)
+      self.section_headers ||= []
+      self.section_headers[section] || render_header(section)
+    end
+
+    def tableView(table, viewForHeaderInSection: section)
+      return unless header = header_for_section(section)
+      wrapper = MotionPrime::BaseElement.factory(:view, styles: header_styles(header).values.flatten, parent_view: table_view)
+      wrapper.render(to: screen) do |cell_view|
+        header.cell_view = cell_view if header.respond_to?(:cell_view)
+        header.render(to: screen)
+      end
+    end
+
+    def tableView(table, heightForHeaderInSection: section)
+      header_for_section(section).try(:container_height) || 0
     end
 
     class << self
-      def field(name, options = {})
+      def field(name, options = {}, &block)
         options[:name] = name
         options[:type] ||= :string
+        options[:block] = block
         self.fields_options ||= {}
         self.fields_options[name] = options
         self.fields_options[name]
       end
 
+      def group_header(name, options)
+        options[:name] = name
+        self.section_header_options ||= []
+        section = options.delete(:id)
+        self.section_header_options[section] = options
+      end
+
       def limit_text_field_length(name, limit)
         self.text_field_limits ||= {}
         self.text_field_limits[name] = limit
@@ -186,12 +301,15 @@ module MotionPrime
       def init_form_fields
         self.fields = {}
         self.field_indexes = {}
-        index = 0
+        section_indexes = []
         (self.class.fields_options || []).each do |key, field|
-          next unless render_field?(key)
+          next unless render_field?(key, field)
+          section_id = field[:group].to_i
+          section_indexes[section_id] ||= 0
+          @groups_count = [@groups_count || 1, section_id + 1].max
           self.fields[key] = load_field(field)
-          self.field_indexes[key] = index
-          index += 1
+          self.field_indexes[key] = "#{section_id}_#{section_indexes[section_id]}"
+          section_indexes[section_id] += 1
         end
       end
   end

data/motion-prime/sections/form/base_field_section.rb

@@ -1,5 +1,6 @@
 module MotionPrime
   class BaseFieldSection < BaseSection
+    include CellSection
     include BW::KVO
     attr_accessor :form
 
@@ -7,18 +8,23 @@ module MotionPrime
 
     def initialize(options = {})
       @form = options.delete(:form)
-      if options[:observe_errors_for]
-        @observe_errors_for = self.send(:instance_eval, &options.delete(:observe_errors_for))
-      end
+      @errors_observer_options = normalize_options(options.delete(:observe_errors).clone, self) if options[:observe_errors]
       super
-      @container_options = options.delete(:container)
       observe_model_errors
     end
 
+    def style_options
+      @style_options ||= Styles.for(section_styles.values.flatten)
+    end
+
+    def section_styles
+      form.try(:field_styles, self)
+    end
+
     def render_element?(element_name)
       case element_name.to_sym
       when :error_message
-        @observe_errors_for && @observe_errors_for.errors[name].present?
+        has_errors?
       when :label
         not @options[:label] === false
       else true
@@ -27,37 +33,28 @@ module MotionPrime
 
     def on_section_render
       @status_for_updated = :rendered
+      form.register_elements_from_section(self)
     end
 
     def observe_model_errors
-      return unless @observe_errors_for
-      observe @observe_errors_for.errors, name do |old_value, new_value|
-        if @status_for_updated == :rendered
-          clear_observer_and_reload
-        else
-          create_elements
-          form.table_view.reloadData
+      return unless observing_errors?
+      errors_observer_fields.each do |field|
+        observe observing_errors_for.errors, observing_errors_for.errors.unique_key(field) do |old_value, new_value|
+          next if old_value == new_value
+          if @status_for_updated == :rendered
+            reload_section
+          else
+            load_section
+            form.table_view.reloadData
+          end
         end
       end
     end
 
-    def clear_observer_and_reload
-      unobserve @observe_errors_for.errors, name
-      reload_section
-    end
-
-    def build_options_for_element(opts)
-      super.merge(observe_errors_for: @observe_errors_for)
-    end
-
     def form_name
       form.name
     end
 
-    def container_options
-      @container_options || super
-    end
-
     def focus(begin_editing = true)
       # scroll to cell
       path = form.table_view.indexPathForCell cell
@@ -72,7 +69,7 @@ module MotionPrime
       end
       self
     rescue
-      puts "can't focus on element #{self.class.name}"
+      puts "can't focus on element #{self.class_name_without_kvo}"
     end
 
     def blur
@@ -83,7 +80,7 @@ module MotionPrime
       end
       self
     rescue
-      puts "can't blur on element #{self.class.name}"
+      puts "can't blur on element #{self.class_name_without_kvo}"
     end
 
     def bind_text_input
@@ -94,13 +91,49 @@ module MotionPrime
       view(:input).delegate = self.form
     end
 
+    def observing_errors?
+      @errors_observer_options.present?
+    end
+
+    def has_errors?
+      return false unless observing_errors?
+      errors_observer_fields.any? do |field|
+        observing_errors_for.errors[field].present?
+      end
+    end
+
+    def errors_observer_fields
+      @errors_observer_fields ||= begin
+        fields = Array.wrap(@errors_observer_options[:fields])
+        fields << name if fields.empty?
+        fields.uniq
+      end
+    end
+
+    def observing_errors_for
+      @errors_observer_options[:resource]
+    end
+
+    def all_errors
+      return [] unless observing_errors?
+
+      errors_observer_fields.map do |field|
+        observing_errors_for.errors[field]
+      end
+    end
+
     def reload_section
+      errors_observer_fields.each do |field|
+        unobserve observing_errors_for.errors, observing_errors_for.errors.unique_key(field)
+      end if observing_errors?
       form.reload_cell(self)
     end
 
     def container_height
-      error_height = element(:error_message).try(:content_height)
-      super + error_height.to_i
+      return 0 if container_options[:hidden]
+      element = element(:error_message)
+      error_height = element ? element.content_height + 5 : 0
+      super + error_height
     end
   end
 end

data/motion-prime/sections/form/base_header_section.rb

@@ -0,0 +1,27 @@
+module MotionPrime
+  class BaseHeaderSection < BaseSection
+    include CellSection
+    DEFAULT_HEADER_HEIGHT = 20
+
+    element :title, text: proc { @options[:title] }
+
+    attr_accessor :form
+
+    def initialize(options = {})
+      @form = options[:form]
+      super
+    end
+
+    def style_options
+      @style_options ||= Styles.for(section_styles.values.flatten)
+    end
+
+    def section_styles
+      form.header_styles(self)
+    end
+
+    def container_height
+      container_options[:height] || DEFAULT_HEADER_HEIGHT
+    end
+  end
+end

data/motion-prime/sections/form/date_field_section.rb

@@ -2,24 +2,9 @@ module MotionPrime
   class DateFieldSection < BaseFieldSection
     container height: 190
     element :label, type: :label do
-      {
-        styles: [
-          :base_field_label,
-          :base_date_picker_field_label,
-          :"#{form_name}_field_label",
-          :"#{form_name}_#{name}_field_label"
-        ]
-      }.merge(options[:label] || {})
-    end
-    element :date_picker, type: :date_picker do
-      {
-        styles: [
-          :base_date_picker,
-          :"#{form_name}_date_picker",
-          :"#{form_name}_#{name}_date_picker"
-        ]
-      }
+      options[:label] || {}
     end
+    element :date_picker, type: :date_picker
 
     after_render :bind_date_picker