motion-prime 0.9.9 → 0.9.9.1

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

@@ -9,7 +9,7 @@ module MotionPrime
     after_initialize :observe_model_errors
 
     def prepare_table_data
-      @form = @options[:table]
+      @form = @options[:collection_section]
       if options[:observe_errors]
         # Do not remove clone() after delete()
         @errors_observer_options = normalize_options(options.delete(:observe_errors).clone, elements_eval_object)
@@ -46,7 +46,7 @@ module MotionPrime
             reload_section
           else
             create_elements!
-            form.reload_table_data
+            form.reload_collection_data
           end
         end
       }.weak!
@@ -72,21 +72,21 @@ module MotionPrime
       end if begin_editing
 
       # scroll to cell
-      # path = form.table_view.indexPathForCell(cell)
-      # form.table_view.scrollToRowAtIndexPath path,
+      # path = form.collection_view.indexPathForCell(cell)
+      # form.collection_view.scrollToRowAtIndexPath path,
       #   atScrollPosition: UITableViewScrollPositionTop, animated: true
       return self unless input_view = element(:input).try(:view)
       origin = input_view.frame.origin
-      point = container_view.convertPoint(origin, toView: form.table_view)
+      point = container_view.convertPoint(origin, toView: form.collection_view)
 
       nav_bar_height = screen.navigationController ? screen.navigationController.navigationBar.frame.size.height : 0
       nav_bar_height += 20 # status bar height
 
-      offset = form.table_view.contentOffset
+      offset = form.collection_view.contentOffset
       new_top_offset = point.y - nav_bar_height
       unless new_top_offset == offset.y
         offset.y = new_top_offset
-        form.table_view.setContentOffset(offset, animated: true)
+        form.collection_view.setContentOffset(offset, animated: true)
       end
 
       self

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

@@ -1,4 +1,4 @@
-motion_require '../table/table_delegate.rb'
+motion_require '../table/table_delegate'
 module MotionPrime
   class FormDelegate < TableDelegate
     def textFieldShouldReturn(text_field)

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

@@ -1,4 +1,4 @@
-motion_require '../header.rb'
+motion_require '../header'
 module MotionPrime
   class FormHeaderSection < HeaderSection
     DEFAULT_HEADER_HEIGHT = 20

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

@@ -3,7 +3,7 @@ module MotionPrime
     element :label, type: :label do
       default_label_options
     end
-    element :input, type: :text_field, delegate: proc { table_delegate } do
+    element :input, type: :text_field, delegate: proc { collection_delegate } do
       {secure_text_entry: true}.merge(options[:input] || {})
     end
     element :error_message, type: :error_message, text: proc { |field| field.all_errors.join("\n") if field.observing_errors? }

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

@@ -3,7 +3,7 @@ module MotionPrime
     include CellSectionMixin
 
     def form
-      table
+      collection_section
     end
 
     protected

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

@@ -4,7 +4,7 @@ module MotionPrime
       default_label_options
     end
 
-    element :input, type: :text_field, delegate: proc { table_delegate } do
+    element :input, type: :text_field, delegate: proc { collection_delegate } do
       options[:input] || {}
     end
 

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

@@ -3,7 +3,7 @@ module MotionPrime
     element :label, type: :label do
       default_label_options
     end
-    element :input, type: :text_view, delegate: proc { table_delegate } do
+    element :input, type: :text_view, delegate: proc { collection_delegate } do
       {editable: true}.merge(options[:input] || {})
     end
 

data/motion-prime/sections/grid.rb

@@ -0,0 +1,92 @@
+motion_require './collection/collection_delegate'
+
+module MotionPrime
+  class GridSection < AbstractCollectionSection
+    DEFAULT_GRID_SIZE = 3
+
+    class_attribute :grid_size_value
+
+    before_render :render_collection
+
+    # Get index path for cell section
+    #
+    # @param section [Prime::Section] cell section.
+    # @return index [NSIndexPath] index of cell section.
+    def index_for_cell_section(section)
+      return unless item = @data.try(:index, section)
+      group = item/grid_size
+      row = cell_sections_for_group(group).index(section)
+      NSIndexPath.indexPathForRow(row, inSection: group)
+    end
+
+    def collection_styles_base
+      :base_collection
+    end
+
+    def collection_delegate
+      @collection_delegate ||= CollectionDelegate.new(section: self)
+    end
+
+    def grid_element_options
+      collection_element_options.merge({
+        grid_size: grid_size
+      })
+    end
+
+    def render_collection
+      self.collection_element = screen.collection_view(grid_element_options)
+    end
+
+    def render_cell(index)
+      collection_view.registerClass(MPCollectionCellWithSection, forCellWithReuseIdentifier: cell_name(index))
+      view = collection_view.dequeueReusableCellWithReuseIdentifier(cell_name(index), forIndexPath: index)
+
+      section = cell_section_by_index(index)
+      element = section.container_element || section.init_container_element(container_element_options_for(index))
+      unless view.section
+        element.view = view
+        screen.set_options_for view, element.computed_options.except(:parent_view) do
+          section.render
+        end
+
+        on_cell_render(view, index)
+      end
+      view
+    end
+
+    def cell_sections_for_group(section)
+      data[section, grid_size]
+    end
+
+    # Table View Delegate
+    # ---------------------
+
+    def grid_size
+      self.class.grid_size || DEFAULT_GRID_SIZE
+    end
+
+    def number_of_cells_in_group(group)
+      cell_sections_for_group(group).count.to_i
+    end
+
+    def number_of_groups
+      (data.count.to_f / grid_size).ceil
+    end
+
+    private
+      def container_element_options_for(index)
+        super.merge({
+          type: :collection_view_cell,
+          view_class: 'MPCollectionCellWithSection'
+        })
+      end
+
+    def self.grid_size(value = nil)
+      if value
+        self.grid_size_value = value
+      else
+        self.grid_size_value
+      end
+    end
+  end
+end

data/motion-prime/sections/table.rb

@@ -2,102 +2,26 @@ motion_require './table/refresh_mixin'
 motion_require './table/table_delegate'
 
 module MotionPrime
-  class TableSection < Section
+  class TableSection < AbstractCollectionSection
     include TableSectionRefreshMixin
-    include HasStyleChainBuilder
     include HasSearchBar
 
     class_attribute :group_header_options, :pull_to_refresh_block
 
-    attr_accessor :table_element, :did_appear, :group_header_sections, :group_header_options
-    attr_reader :decelerating
-    before_render :render_table
+    attr_accessor :group_header_sections, :group_header_options
     after_render :init_pull_to_refresh
-    delegate :init_pull_to_refresh, to: :table_delegate
-    delegate :set_options, :update_options, to: :table_element, allow_nil: true
-
-    # Return sections which will be used to render as table cells.
-    #
-    # This method should be redefined in your table section and must return array.
-    # @return [Array<Prime::Section>] array of sections
-    def table_data
-      @model || []
-    end
-
-    # Returns cached version of table data
-    #
-    # @return [Array<Prime::Section>] cached array of sections
-    def data
-      @data || set_table_data
-    end
-
-    # IMPORTANT: when you use #map in table_data,
-    # then #dealloc of Prime::Section will not be called to section created on that #map.
-    # We did not find yet why this happening, for now just using hack.
-    def fixed_table_data
-      table_data.to_enum.to_a
-    end
-
-    def dealloc
-      Prime.logger.dealloc_message :table, self, self.table_element.try(:view).to_s
-      table_delegate.clear_delegated
-      table_view.setDataSource nil
-      super
-    end
-
-    # Reset all table data and reload table view
-    #
-    # @return [Boolean] true
-    def reload_data
-      reset_table_data
-      reload_table_data
-    end
-
-    # Alias for reload_data
-    #
-    # @return [Boolean] true
-    def reload
-      reload_data
-    end
-
-    # Reload table view data
-    #
-    # @return [Boolean] true
-    def reload_table_data
-      table_view.reloadData
-      true
-    end
-
-    # Reload table view if data was empty before.
-    #
-    # @return [Boolean] true if reload was happened
-    def refresh_if_needed
-      @data.nil? ? reload_table_data : false
-    end
-
-    # Reset all table data.
-    #
-    # @return [Boolean] true
-    def reset_table_data
-      @did_appear = false
-      Array.wrap(@data).flatten.each do |section|
-        section.container_element.try(:update_options, reuse_identifier: nil)
-      end
-      @data = nil
-      @data_stamp = nil
-      true
-    end
+    delegate :init_pull_to_refresh, to: :collection_delegate
 
     # Add cells to table view and reload table view.
     #
     # @param cell sections [Prime::Section, Array<Prime::Section>] cells which will be added to table view.
     # @return [Boolean] true
     def add_cell_sections(sections, index = nil)
-      prepare_table_cell_sections(sections)
+      prepare_collection_cell_sections(sections)
       @data ||= []
       index ||= @data.count
       @data.insert([index, @data.count].min, *sections)
-      reload_table_data
+      reload_collection_data
     end
 
     # Delete cells from table data and remove them from table view with animation.
@@ -114,9 +38,9 @@ module MotionPrime
       end
       if paths.any?
         UIView.animate(duration: 0, after: block) do
-          table_view.beginUpdates
-          table_view.deleteRowsAtIndexPaths(paths, withRowAnimation: UITableViewRowAnimationLeft)
-          table_view.endUpdates
+          collection_view.beginUpdates
+          collection_view.deleteRowsAtIndexPaths(paths, withRowAnimation: UITableViewRowAnimationLeft)
+          collection_view.endUpdates
         end
       end
       paths
@@ -145,8 +69,8 @@ module MotionPrime
     #
     # @param [Array<NSIndexPath>] index paths of cells to reload.
     def reload_cells(*paths)
-      table_view.reloadRowsAtIndexPaths(Array.wrap(paths), withRowAnimation: UITableViewRowAnimationFade)
-      table_view.reloadData # do not use reload_table_data (due to async_form_mixin)
+      collection_view.reloadRowsAtIndexPaths(Array.wrap(paths), withRowAnimation: UITableViewRowAnimationFade)
+      collection_view.reloadData # do not use reload_collection_data (due to async_form_mixin)
     end
 
     # Changes height of cells with animation.
@@ -188,90 +112,28 @@ module MotionPrime
       end
     end
 
-    def table_styles
-      type = self.is_a?(FormSection) ? :base_form : :base_table
-
-      base_styles = [type]
+    def collection_styles_base
+      base_styles = [:base_table]
       base_styles << :"#{type}_with_sections" unless flat_data?
-      item_styles = [name.to_sym]
-      item_styles += Array.wrap(@styles) if @styles.present?
-      {common: base_styles, specific: item_styles}
+      base_styles
     end
 
-    def cell_section_styles(section)
-      # type = [`cell`, `header`, `field`]
-
-      # UserFormSection example: field :email, type: :string
-      # form_name = `user`
-      # type = `field`
-      # field_name = `email`
-      # field_type = `string_field`
-
-      # CategoriesTableSection example: table is a `CategoryTableSection`, cell is a `CategoryTitleSection`, element :icon, type: :image
-      # table_name = `categories`
-      # type = `cell` (always true)
-      # table_cell_section_name = `title`
-      type = section.respond_to?(:cell_type) ? section.cell_type : 'cell'
-      suffixes = [type]
-      if section.is_a?(BaseFieldSection)
-        suffixes << section.default_name
-      end
-
-      styles = {}
-      # table: base_table_<type>
-      # form: base_form_<type>, base_form_<field_type>
-      styles[:common] = build_styles_chain(table_styles[:common], suffixes)
-      if section.is_a?(BaseFieldSection)
-        # form cell: _<type>_<field_name> = `_field_email`
-        suffixes << :"#{type}_#{section.name}" if section.name
-      elsif section.respond_to?(:cell_section_name) # cell section came from table
-        # table cell: _<table_cell_section_name> = `_title`
-        suffixes << section.cell_section_name
-      end
-      # table: <table_name>_table_<type>, <table_name>_table_<table_cell_section_name> = `categories_table_cell`, `categories_table_title`
-      # form: <form_name>_form_<type>, <form_name>_form_<field_type>, user_form_<type>_email = `user_form_field`, `user_form_string_field`, `user_form_field_email`
-      styles[:specific] = build_styles_chain(table_styles[:specific], suffixes)
-
-      container_options_styles = section.container_options[:styles]
-      if container_options_styles.present?
-        styles[:specific] += Array.wrap(container_options_styles)
-      end
-
-      styles
-    end
-
-    def table_delegate
-      @table_delegate ||= TableDelegate.new(section: self)
+    def collection_delegate
+      @collection_delegate ||= TableDelegate.new(section: self)
     end
 
     def table_element_options
-      container_options.slice(:render_target).merge({
-        section: self.weak_ref,
-        styles: table_styles.values.flatten,
-        delegate: table_delegate,
-        data_source: table_delegate,
+      collection_element_options.merge({
         style: (UITableViewStyleGrouped unless flat_data?)
       })
     end
 
-    def render_table
-      self.table_element = screen.table_view(table_element_options)
-    end
-
-    def table_view
-      table_element.try(:view)
-    end
-
-    def hide
-      table_view.try(:hide)
-    end
-
-    def show
-      table_view.try(:show)
+    def render_collection
+      self.collection_element = screen.table_view(table_element_options)
     end
 
     def render_cell(index)
-      section = cell_sections_for_group(index.section)[index.row]
+      section = cell_section_by_index(index)
       element = section.container_element || section.init_container_element(container_element_options_for(index))
 
       view = element.render do
@@ -284,7 +146,7 @@ module MotionPrime
 
     def render_header(group)
       return unless options = self.group_header_options.try(:[], group)
-      self.group_header_sections[group] ||= FormHeaderSection.new(options.merge(screen: screen, table: self.weak_ref))
+      self.group_header_sections[group] ||= FormHeaderSection.new(options.merge(screen: screen, collection_section: self.weak_ref))
     end
 
     def header_section_for_group(group)
@@ -292,10 +154,6 @@ module MotionPrime
       self.group_header_sections[group] || render_header(group)
     end
 
-    def on_cell_render(cell, index); end
-    def on_appear; end
-    def on_click(index); end
-
     def has_many_sections?
       group_header_options.present? || data.try(:first).is_a?(Array)
     end
@@ -308,15 +166,6 @@ module MotionPrime
       flat_data? ? data : data[section]
     end
 
-    def cell_section_by_index(index)
-      cell_sections_for_group(index.section)[index.row]
-    end
-
-    def cell_name(index)
-      record = cell_section_by_index(index)
-      "cell_#{record.object_id}_#{@data_stamp[record.object_id]}"
-    end
-
     # Table View Delegate
     # ---------------------
 
@@ -324,33 +173,18 @@ module MotionPrime
       has_many_sections? ? data.count : 1
     end
 
-    def cell_for_index(index)
-      cell = cached_cell(index) || render_cell(index)
-      # run table view is appeared callback if needed
-      if !@did_appear && index.row == cell_sections_for_group(index.section).size - 1
-        on_appear
-      end
-      cell.is_a?(UIView) ? cell : cell.view
-    end
-
-    def height_for_index(index)
-      section = cell_section_by_index(index)
-      section.create_elements
-      section.container_height
-    end
-
     def header_cell_in_group(group)
       return unless header = header_section_for_group(group)
 
       reuse_identifier = "header_#{group}_#{@header_stamp}"
-      cached = table_view.dequeueReusableHeaderFooterViewWithIdentifier(reuse_identifier)
+      cached = collection_view.dequeueReusableHeaderFooterViewWithIdentifier(reuse_identifier)
       return cached if cached.present?
 
       styles = cell_section_styles(header).values.flatten
       wrapper = MotionPrime::BaseElement.factory(:table_header,
         screen: screen,
         styles: styles,
-        parent_view: table_view,
+        parent_view: collection_view,
         reuse_identifier: reuse_identifier,
         section: header.weak_ref
       )
@@ -364,22 +198,6 @@ module MotionPrime
       header_section_for_group(group).try(:container_height) || 0
     end
 
-    def scroll_view_will_begin_dragging(scroll)
-      @decelerating = true
-    end
-
-    def scroll_view_did_end_decelerating(scroll)
-      @decelerating = false
-      display_pending_cells
-    end
-
-    def scroll_view_did_scroll(scroll)
-    end
-
-    def scroll_view_did_end_dragging(scroll, willDecelerate: will_decelerate)
-      display_pending_cells unless @decelerating = will_decelerate
-    end
-
     private
       def delete_from_flat_data(index)
         @data[index.row] = nil
@@ -391,25 +209,8 @@ module MotionPrime
         @data[index.section].delete_at(index.row)
       end
 
-      def display_pending_cells
-        table_view.visibleCells.each do |cell_view|
-          if cell_view.section && cell_view.section.pending_display
-            cell_view.section.display
-          end
-        end
-      end
-
-      def set_table_data
-        sections = fixed_table_data
-        prepare_table_cell_sections(sections)
-        @data = sections
-        reset_data_stamps
-        create_section_elements
-        @data
-      end
-
       def cached_cell(index)
-        table_view.dequeueReusableCellWithIdentifier(cell_name(index)) || begin
+        collection_view.dequeueReusableCellWithIdentifier(cell_name(index)) || begin
           section = cell_section_by_index(index)
           cell = section.try(:cell)
           if cell.try(:superview)
@@ -420,62 +221,27 @@ module MotionPrime
       end
 
       def deque_cell(section, at: index)
-        table_view.dequeueReusableCellWithIdentifier(cell_name(index))
+        collection_view.dequeueReusableCellWithIdentifier(cell_name(index))
         section.cell.try(:removeFromSuperview)
         set_data_stamp(section.object_id)
       end
 
-      def prepare_table_cell_sections(cells)
-        Array.wrap(cells.flatten).each do |cell|
-          Prime::Config.prime.cell_section.mixins.each do |mixin|
-            cell.class.send(:include, mixin) unless (class << cell; self; end).included_modules.include?(mixin)
-          end
-          cell.screen ||= screen
-          cell.table ||= self.weak_ref if cell.respond_to?(:table=)
-        end
-      end
-
-      def container_element_options_for(index)
-        cell_section = cell_section_by_index(index)
-        {
-          reuse_identifier: cell_name(index),
-          parent_view: table_view,
-          bounds: {height: cell_section.container_height}
-        }
-      end
-
-      def set_data_stamp(section_ids)
-        @data_stamp ||= {}
-        [*section_ids].each do |id|
-          @data_stamp[id] = Time.now.to_f
-        end
-      end
-
       def set_header_stamp
         @header_stamp = Time.now.to_i
       end
 
       def reset_data_stamps
-        keys = data.flatten.map(&:object_id)
-        set_data_stamp(keys)
+        super
         set_header_stamp
       end
 
-      def create_section_elements
-        if flat_data?
-          data.each(&:create_elements)
-        else
-          data.each { |group_sections| group_sections.each(&:create_elements) }
-        end
-      end
-
     class << self
       def inherited(subclass)
         super
         subclass.group_header_options = self.group_header_options.try(:clone)
       end
 
-      def async_table_data(options = {})
+      def async_collection_data(options = {})
         self.send :include, Prime::AsyncTableMixin
         self.set_async_data_options options
       end