motion-prime 0.9.9 → 0.9.9.1

data/motion-prime/sections/abstract_collection.rb

@@ -0,0 +1,291 @@
+motion_require 'base_section'
+module MotionPrime
+  class AbstractCollectionSection < Section
+    include HasStyleChainBuilder
+
+    attr_accessor :collection_element, :did_appear
+    attr_reader :decelerating
+
+    before_render :render_collection
+
+    delegate :set_options, :update_options, to: :collection_element, allow_nil: true
+
+    %w[table_data
+      fixed_table_data
+      table_view
+      reset_table_data
+      async_table_data
+      reload_table_data
+      table_delegate
+      table_styles
+      table_styles_base
+      prepare_table_cell_sections
+      table_element_options
+      render_table].each do |table_method|
+      define_method table_method do |*args|
+        Prime.logger.info "##{table_method} is deprecated: #{caller[0]}"
+        send(table_method.gsub('table', 'collection'), *args)
+      end
+    end
+
+    # Return sections which will be used to render as collection cells.
+    #
+    # This method should be redefined in your collection section and must return array.
+    # @return [Array<Prime::Section>] array of sections
+    def collection_data
+      @model || []
+    end
+
+    # Returns cached version of collection data
+    #
+    # @return [Array<Prime::Section>] cached array of sections
+    def data
+      @data || set_collection_data
+    end
+
+    # IMPORTANT: when you use #map in collection_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_collection_data
+      collection_data.to_enum.to_a
+    end
+
+    def dealloc
+      Prime.logger.dealloc_message :collection, self, self.collection_element.try(:view).to_s
+      collection_delegate.clear_delegated
+      collection_view.setDataSource nil
+      super
+    end
+
+    # Reset all collection data and reload collection view
+    #
+    # @return [Boolean] true
+    def reload_data
+      reset_collection_data
+      reload_collection_data
+    end
+
+    # Alias for reload_data
+    #
+    # @return [Boolean] true
+    def reload
+      reload_data
+    end
+
+    # Reload collection view data
+    #
+    # @return [Boolean] true
+    def reload_collection_data
+      collection_view.reloadData
+      true
+    end
+
+    # Reload collection view if data was empty before.
+    #
+    # @return [Boolean] true if reload was happened
+    def refresh_if_needed
+      @data.nil? ? reload_collection_data : false
+    end
+
+    # Reset all collection data.
+    #
+    # @return [Boolean] true
+    def reset_collection_data
+      @did_appear = false
+      Array.wrap(@data).each do |section|
+        section.container_element.try(:update_options, reuse_identifier: nil)
+      end
+      @data = nil
+      @data_stamp = nil
+      true
+    end
+
+    def collection_styles_base
+      raise "Implement #collection_styles_base"
+    end
+
+    def collection_styles
+      type = collection_styles_base
+
+      base_styles = Array.wrap(type)
+      item_styles = [name.to_sym]
+      item_styles += Array.wrap(@styles) if @styles.present?
+      {common: base_styles, specific: item_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(collection_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(collection_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 collection_element_options
+      container_options.slice(:render_target).merge({
+        section: self.weak_ref,
+        styles: collection_styles.values.flatten,
+        delegate: collection_delegate,
+        data_source: collection_delegate
+      })
+    end
+
+    def render_collection
+      raise "Implement #render_collection"
+    end
+
+    def collection_view
+      collection_element.try(:view)
+    end
+
+    def hide
+      collection_view.try(:hide)
+    end
+
+    def show
+      collection_view.try(:show)
+    end
+
+    def render_cell(index)
+      raise "Implement #render_cell"
+    end
+
+    def on_cell_render(cell, index); end
+    def on_appear; end
+    def on_click(index); end
+
+    def cell_name(index)
+      record = cell_section_by_index(index)
+      "cell_#{record.object_id}_#{@data_stamp[record.object_id]}"
+    end
+
+    def cell_sections_for_group(section)
+      raise "Implement #cell_sections_for_group"
+    end
+
+    def cell_section_by_index(index)
+      cell_sections_for_group(index.section)[index.row]
+    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 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 cached_cell(index)
+      end
+
+      def display_pending_cells
+        collection_view.visibleCells.each do |cell_view|
+          if cell_view.section && cell_view.section.pending_display
+            cell_view.section.display
+          end
+        end
+      end
+
+      def set_collection_data
+        sections = fixed_collection_data
+        prepare_collection_cell_sections(sections)
+        @data = sections
+        reset_data_stamps
+        create_section_elements
+        @data
+      end
+
+      def prepare_collection_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.collection_section ||= self.weak_ref if cell.respond_to?(:collection_section=)
+        end
+      end
+
+      def container_element_options_for(index)
+        cell_section = cell_section_by_index(index)
+        {
+          reuse_identifier: cell_name(index),
+          parent_view: collection_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 reset_data_stamps
+        keys = data.map(&:object_id)
+        set_data_stamp(keys)
+      end
+
+      def create_section_elements
+        data.flatten.each(&:create_elements)
+      end
+  end
+end

data/motion-prime/sections/base_section.rb

@@ -151,9 +151,9 @@ module MotionPrime
       # reload Draw Elements
       elements_to_draw.values.each(&:update)
 
-      if @table && !self.is_a?(BaseFieldSection)
+      if @collection_section && !self.is_a?(BaseFieldSection)
         cell.setNeedsDisplay
-        @table.reload_table_data
+        @collection_section.reload_collection_data
       end
       true
     end

data/motion-prime/sections/collection/collection_delegate.rb

@@ -0,0 +1,62 @@
+module MotionPrime
+  class CollectionDelegate
+    include DelegateMixin
+    attr_accessor :collection_section
+
+    def initialize(options)
+      self.collection_section = options[:section].try(:weak_ref)
+      @section_instance = collection_section.to_s
+    end
+
+    # def dealloc
+    #   pp 'Deallocating collection_delegate for ', @section_instance
+    #   super
+    # end
+
+    def numberOfSectionsInCollectionView(table)
+      collection_section.number_of_groups
+    end
+
+    def collectionView(table, cellForItemAtIndexPath: index)
+      cur_call_time = Time.now.to_f
+      cur_call_offset = table.contentOffset.y
+      if @prev_call_time
+        time_delta = cur_call_time - @prev_call_time
+        offset_delta = cur_call_offset - @prev_call_offset
+        @deceleration_speed = offset_delta/time_delta
+      end
+      @prev_call_time = cur_call_time
+      @prev_call_offset = cur_call_offset
+
+      collection_section.cell_for_index(index)
+    end
+
+    def collectionView(table, numberOfItemsInSection: group)
+      collection_section.number_of_cells_in_group(group)
+    end
+
+    def collectionView(table, heightForItemAtIndexPath: index)
+      collection_section.height_for_index(index)
+    end
+
+    def collectionView(table, didSelectItemAtIndexPath:index)
+      collection_section.on_click(index)
+    end
+
+    def scrollViewDidScroll(scroll)
+      collection_section.scroll_view_did_scroll(scroll)
+    end
+
+    def scrollViewWillBeginDragging(scroll)
+      collection_section.scroll_view_will_begin_dragging(scroll)
+    end
+
+    def scrollViewDidEndDecelerating(scroll)
+      collection_section.scroll_view_did_end_decelerating(scroll)
+    end
+
+    def scrollViewDidEndDragging(scroll, willDecelerate: will_decelerate)
+      collection_section.scroll_view_did_end_dragging(scroll, willDecelerate: will_decelerate)
+    end
+  end
+end

data/motion-prime/sections/form.rb

@@ -1,4 +1,4 @@
-motion_require './table.rb'
+motion_require 'table.rb'
 motion_require '../helpers/has_style_chain_builder'
 module MotionPrime
   class FormSection < TableSection
@@ -21,7 +21,7 @@ module MotionPrime
     class_attribute :fields_options, :text_field_limits, :text_view_limits, :fields_callbacks
     attr_accessor :fields, :field_indexes, :keyboard_visible, :rendered_views, :grouped_data
 
-    def table_data
+    def collection_data
       if has_many_sections?
         grouped_data.reject(&:nil?)
       else
@@ -109,31 +109,35 @@ module MotionPrime
 
     def set_height_with_keyboard
       return if keyboard_visible
-      self.table_view.height -= KEYBOARD_HEIGHT_PORTRAIT
+      self.collection_view.height -= KEYBOARD_HEIGHT_PORTRAIT
       self.keyboard_visible = true
     end
 
     def set_height_without_keyboard
       return unless keyboard_visible
-      self.table_view.height += KEYBOARD_HEIGHT_PORTRAIT
+      self.collection_view.height += KEYBOARD_HEIGHT_PORTRAIT
       self.keyboard_visible = false
     end
 
     def keyboard_will_show
-      return if table_view.contentSize.height + table_view.top <= UIScreen.mainScreen.bounds.size.height - KEYBOARD_HEIGHT_PORTRAIT
-      current_inset = table_view.contentInset
-      current_inset.bottom = KEYBOARD_HEIGHT_PORTRAIT + (self.table_element.computed_options[:bottom_content_inset] || 0)
-      table_view.contentInset = current_inset
+      return if collection_view.contentSize.height + collection_view.top <= UIScreen.mainScreen.bounds.size.height - KEYBOARD_HEIGHT_PORTRAIT
+      current_inset = collection_view.contentInset
+      current_inset.bottom = KEYBOARD_HEIGHT_PORTRAIT + (self.collection_element.computed_options[:bottom_content_inset] || 0)
+      collection_view.contentInset = current_inset
     end
 
     def keyboard_will_hide
-      current_inset = table_view.contentInset
-      current_inset.bottom = self.table_element.computed_options[:bottom_content_inset] || 0
-      table_view.contentInset = current_inset
+      current_inset = collection_view.contentInset
+      current_inset.bottom = self.collection_element.computed_options[:bottom_content_inset] || 0
+      collection_view.contentInset = current_inset
     end
 
-    def table_delegate
-      @table_delegate ||= FormDelegate.new(section: self)
+    def collection_delegate
+      @collection_delegate ||= FormDelegate.new(section: self)
+    end
+
+    def collection_styles_base
+      :base_form
     end
 
     # ALIASES
@@ -154,7 +158,7 @@ module MotionPrime
 
     def load_field(field)
       field_class = class_factory("#{field[:type]}_field_section", true)
-      field_class.new(field.merge(screen: screen, table: self.weak_ref))
+      field_class.new(field.merge(screen: screen, collection_section: self.weak_ref))
     end
 
     def render_field?(name, options)
@@ -169,15 +173,15 @@ module MotionPrime
     def reload_data
       @groups_count = nil
       init_form_fields # must be before resetting to reflect changes on @data
-      reset_table_data
-      reload_table_data
+      reset_collection_data
+      reload_collection_data
     end
 
     def has_many_sections?
       group_header_options.present? || grouped_data.count > 1
     end
 
-    def render_table
+    def render_collection
       init_form_fields unless self.fields.present?
       super
     end
@@ -213,7 +217,7 @@ module MotionPrime
         subclass.text_view_limits = self.text_view_limits.try(:clone)
       end
 
-      def async_table_data(options = {})
+      def async_collection_data(options = {})
         super
         self.send :include, Prime::AsyncFormMixin
       end