formotion 0.0.1

data/lib/formotion/exceptions.rb

@@ -0,0 +1,20 @@
+module Formotion
+  class InvalidClassError < StandardError; end
+  class InvalidSectionError < StandardError; end
+
+  class Conditions
+    class << self
+      def assert_nil_or_boolean(obj)
+        if not (obj.nil? or obj.is_a? TrueClass or obj.is_a? FalseClass)
+          raise Formotion::InvalidClassError, "#{obj.inspect} should be nil, true, or false, but is #{obj.class.to_s}"
+        end
+      end
+
+      def assert_class(obj, klass)
+        if not obj.is_a? klass
+          raise Formotion::InvalidClassError, "#{obj.inspect} of class #{obj.class.to_s} is not of class #{klass.to_s}"
+        end
+      end
+    end
+  end
+end

data/lib/formotion/form.rb

@@ -0,0 +1,173 @@
+module Formotion
+  class Form < Formotion::Base
+    PROPERTIES = [
+      # By default, Formotion::Controller will set it's title to this
+      # (so navigation bars will reflect it).
+      :title, 
+      # If you want to have some internal id to track the form.
+      :id
+    ]
+    PROPERTIES.each {|prop|
+      attr_accessor prop
+    }
+
+    # Sections are create specially using #create_section, so we don't allow
+    # them to be pased in the hash
+    SERIALIZE_PROPERTIES = PROPERTIES + [:sections]
+
+    def initialize(params = {})
+      # super takes care of initializing the ::PROPERTIES in params
+      super
+
+      sections = params[:sections] || params["sections"]
+      sections && sections.each_with_index {|section_hash, index|
+        section = create_section(section_hash.merge({index: index}))
+      }
+    end
+
+    # Use this as a DSL for building forms
+    # EX
+    # @form = Form.build do |form|
+    #   form.title = 'Form Title'
+    #   form.id = 'anything'
+    # end
+    class << self
+      def build(&block)
+        form = new
+        block.call(form)
+        form
+      end
+    end
+
+    # Use this as a DSL for adding sections
+    # EX
+    # @form.build_section do |section|
+    #   section.title = 'Section Title'
+    # end
+    def build_section(&block)
+      section = create_section
+      block.call(section)
+      section
+    end
+
+    # Use this to add sections via a hash
+    # EX
+    # @form.create_section(:title => 'Section Title')
+    def create_section(hash = {})
+      section = Formotion::Section.new(hash)
+      section.form = self
+      section.index = self.sections.count
+      self.sections << section
+      section
+    end
+
+    #########################
+    #  attributes
+
+    def sections
+      @sections ||= []
+    end
+
+    def sections=(sections)
+      sections.each {|section|
+        Formotion::Conditions.assert_class(section, Formotion::Section)
+      }
+      @sections = sections
+    end
+
+    # Accepts an NSIndexPath and gives back a Formotion::Row
+    # EX
+    # row = @form.row_for_index_path(NSIndexPath.indexPathForRow(0, inSection: 0))
+    def row_for_index_path(index_path)
+      self.sections[index_path.section].rows[index_path.row]
+    end
+
+    #########################
+    #  callbacks
+
+    # Stores the callback block when you do #submit.
+    # EX
+    # @form.on_submit do 
+    #   do_something(@form.render)
+    # end
+    #
+    # EX
+    # @form.on_submit do |form|
+    #   pass_to_server(form.render)
+    # end
+    def on_submit(&block)
+      @on_submit_callback = block
+    end
+
+    # Triggers the #on_submit block
+    # Handles either zero or one arguments,
+    # as shown above.
+    def submit
+      if @on_submit_callback.arity == 0
+        @on_submit_callback.call
+      elsif @on_submit_callback.arity == 1
+        @on_submit_callback.call(self)
+      end
+    end
+  
+    #########################
+    # Retreiving data
+
+    # A complete hashification of the Form
+    # EX
+    # @form = Formotion::Form.new(title: 'My Title')
+    # @form.id = 'anything'
+    # @form.to_hash
+    # => {title: 'My Title', id: 'anything'}
+    def to_hash
+      # super handles all of the ::PROPERTIES
+      h = super
+      h[:sections] = self.sections.collect { |section|
+        section.to_hash 
+      }
+      recursive_delete_nil(h)
+      h
+    end
+
+    # A hashification with the user's inputted values
+    # and row keys.
+    # EX
+    # @form = Formotion::Form.new(sections: [{
+    #  rows: [{
+    #    key: 'Email', 
+    #    editable: true, 
+    #    title: 'Email'
+    #  }]}])
+    # ...user plays with the Form...
+    # @form.render
+    # => {email: 'something@email.com'}
+    def render
+      kv = {}
+      self.sections.each {|section|
+        if section.select_one?
+          section.rows.each {|row|
+            if row.value
+              kv[section.key] = row.key
+            end
+          }
+        else
+          section.rows.each {|row|
+            next if row.submit_button?
+            kv[row.key] = row.value
+          }
+        end
+      }
+      kv.delete_if {|k, v| k.nil? }
+      kv
+    end
+
+    private
+    def recursive_delete_nil(h)
+      delete_empty = Proc.new { |k, v|
+        v.delete_if(&delete_empty) if v.kind_of?(Hash)
+        v.nil?
+      }
+      h.delete_if &delete_empty
+    end
+  end
+end

data/lib/formotion/form_controller.rb

@@ -0,0 +1,102 @@
+#################
+#
+# Formotion::FormController
+# Use #initWithForm to create a view controller
+# loaded with your form.
+#
+#################
+module Formotion
+  class FormController < UIViewController
+    attr_accessor :form
+    attr_reader :table_view
+
+    # Initializes controller with a form
+    # PARAMS form.is_a? [Hash, Formotion::Form]
+    # RETURNS An instance of Formotion::FormController
+    def initWithForm(form)
+      self.initWithNibName(nil, bundle: nil)
+      self.form = form
+      self
+    end
+
+    # Set the form; ensure it is/can be converted to Formotion::Form
+    # or raises an exception.
+    def form=(form)
+      if form.is_a? Hash
+        form = Formotion::Form.new(form)
+      elsif not form.is_a? Formotion::Form
+        raise Formotion::InvalidClassError, "Attempted FormController.form = #{form.inspect} should be of type Formotion::Form or Hash"
+      end
+      @form = form
+    end
+
+    def viewDidLoad
+      super
+
+      # via https://gist.github.com/330916, could be wrong.
+      tabBarHeight = self.tabBarController && self.tabBarController.tabBar.bounds.size.height
+      tabBarHeight ||= 0
+      navBarHeight = self.navigationController && (self.navigationController.isNavigationBarHidden ? 0.0 : self.navigationController.navigationBar.bounds.size.height)
+      navBarHeight ||= 0
+      frame = self.view.frame
+      frame.size.height = frame.size.height - navBarHeight - tabBarHeight
+      self.view.frame = frame
+
+      self.title = self.form.title
+
+      NSNotificationCenter.defaultCenter.addObserver(self, selector:'keyboardWillHideOrShow:', name:UIKeyboardWillHideNotification, object:nil);
+      NSNotificationCenter.defaultCenter.addObserver(self, selector:'keyboardWillHideOrShow:', name:UIKeyboardWillShowNotification, object:nil);
+
+      @table_view = UITableView.alloc.initWithFrame(self.view.bounds, style: UITableViewStyleGrouped)
+      self.view.addSubview @table_view
+
+      # Triggers this block when the enter key is pressed 
+      # while editing the last text field.
+      @form.sections[-1] && @form.sections[-1].rows[-1].on_enter do |row|
+        if row.text_field
+          @form.submit
+          row.text_field.resignFirstResponder
+        end
+      end
+
+      # Setting @form.controller assigns
+      # @form as the datasource and delegate
+      # and reloads the data.
+      @form.controller = self
+    end
+
+    # This re-sizes + scrolls the tableview to account for the keyboard size.
+    # TODO: Test this on iPads, etc.
+    def keyboardWillHideOrShow(note)
+      last_note = @keyboard_state
+      @keyboard_state = note.name
+      if last_note == @keyboard_state
+        return
+      end
+
+      userInfo = note.userInfo
+      duration = userInfo[UIKeyboardAnimationDurationUserInfoKey].doubleValue
+      curve = userInfo[UIKeyboardAnimationCurveUserInfoKey].intValue
+      keyboardFrame = userInfo[UIKeyboardFrameEndUserInfoKey].CGRectValue
+
+      view_frame = @table_view.frame;
+
+      if @keyboard_state == UIKeyboardWillHideNotification
+        view_frame.size.height = self.view.bounds.size.height
+      else
+        view_frame.size.height -= keyboardFrame.size.height
+      end
+
+      UIView.beginAnimations(nil, context: nil)
+      UIView.setAnimationDuration(duration)
+      UIView.setAnimationDelay(0)
+      UIView.setAnimationCurve(curve)
+      UIView.setAnimationBeginsFromCurrentState(true)
+
+      @table_view.frame = view_frame
+      @form.active_row = @form.active_row
+
+      UIView.commitAnimations
+    end
+  end
+end

data/lib/formotion/form_delegate.rb

@@ -0,0 +1,87 @@
+module Formotion
+  class Form
+    attr_reader :table
+    attr_reader :controller
+    attr_reader :active_row
+
+    def active_row=(row)
+      @active_row = row
+
+      if @active_row && @table
+        index_path = NSIndexPath.indexPathForRow(@active_row.index, inSection:@active_row.section.index)
+        @table.scrollToRowAtIndexPath(index_path, atScrollPosition:UITableViewScrollPositionMiddle,  animated:true)
+      end
+    end
+
+    ####################
+    # Table Methods
+    def controller=(controller)
+      @controller = controller
+      self.table = controller.table_view
+    end
+
+    def table=(table_view)
+      @table = table_view
+
+      @table.delegate = self
+      @table.dataSource = self
+      reload_data
+    end
+
+    def reload_data
+      previous_row, next_row = nil
+
+      last_row = self.sections[-1].rows[-1]
+      if last_row
+        last_row.return_key ||= UIReturnKeyDone
+      end
+
+      @table.reloadData
+    end
+
+    # UITableViewDataSource Methods
+    def numberOfSectionsInTableView(tableView)
+      self.sections.count
+    end
+
+    def tableView(tableView, numberOfRowsInSection: section)
+      self.sections[section].rows.count
+    end
+
+    def tableView(tableView, titleForHeaderInSection:section)
+      section = self.sections[section].title
+    end
+
+    def tableView(tableView, cellForRowAtIndexPath:indexPath)
+      row = row_for_index_path(indexPath)
+      reuseIdentifier = row.reuse_identifier
+
+      cell = tableView.dequeueReusableCellWithIdentifier(reuseIdentifier) || begin
+        row.make_cell
+      end
+
+      cell
+    end
+
+    # UITableViewDelegate Methods
+    def tableView(tableView, didSelectRowAtIndexPath:indexPath)
+      tableView.deselectRowAtIndexPath(indexPath, animated:true)
+      row = row_for_index_path(indexPath)
+      if row.submit_button?
+        self.submit
+      elsif row.checkable?
+        if row.section.select_one and !row.value
+          row.section.rows.each {|other_row|
+            other_row.value = (other_row == row)
+            Formotion::RowCellBuilder.make_check_cell(other_row, tableView.cellForRowAtIndexPath(other_row.index_path))
+          }
+        elsif !row.section.select_one
+          row.value = !row.value
+          Formotion::RowCellBuilder.make_check_cell(row, tableView.cellForRowAtIndexPath(row.index_path))
+        end
+      elsif row.editable?
+        row.text_field.becomeFirstResponder
+      end
+    end
+  end
+end

data/lib/formotion/patch/ui_text_field.rb

@@ -0,0 +1,158 @@
+# Methods which use blocks for UITextFieldDelegate methods.
+# EX
+# field.should_end? do |text_field|
+#   if text_field.text != "secret"
+#     return false
+#   end
+#   true
+# end
+#
+# Also includes an on_change method, which calls after the text
+# has changed (there is no UITextFieldDelegate equivalent.)
+# EX
+# field.on_change do |text_field|
+#   p text_field.text
+# end
+
+class UITextField
+  attr_accessor :menu_options_enabled
+
+  def canPerformAction(action, withSender:sender)
+    self.menu_options_enabled
+  end
+
+  # block takes argument textField; should return true/false
+  def should_begin?(&block)
+    add_delegate_method do
+      @delegate.textFieldShouldBeginEditing_callback = block
+    end
+  end
+
+  # block takes argument textField
+  def on_begin(&block)
+    add_delegate_method do
+      @delegate.textFieldDidBeginEditing_callback = block
+    end
+  end
+
+  # block takes argument textField; should return true/false
+  def should_end?(&block)
+    add_delegate_method do
+      @delegate.textFieldShouldEndEditing_callback = block
+    end
+  end
+
+  # block takes argument textField
+  def on_end(&block)
+    add_delegate_method do
+      @delegate.textFieldDidBeginEditing_callback = block
+    end
+  end
+
+  # block takes argument textField, range [NSRange], and string; should return true/false
+  def should_change?(&block)
+    add_delegate_method do
+      @delegate.shouldChangeCharactersInRange_callback = block
+    end
+  end
+
+  # block takes argument textField
+  def on_change(&block)
+    add_delegate_method do
+      @delegate.on_change_callback = block
+      self.addTarget(@delegate, action: 'on_change:', forControlEvents: UIControlEventEditingChanged)
+    end
+  end
+
+  # block takes argument textField; should return true/false
+  def should_clear?(&block)
+    add_delegate_method do
+      @delegate.textFieldShouldClear_callback = block
+    end
+  end
+
+  # block takes argument textField; should return true/false
+  def should_return?(&block)
+    add_delegate_method do
+      @delegate.textFieldShouldReturn_callback = block
+    end
+  end
+
+  private
+  def add_delegate_method
+    # create strong reference to the delegate
+    # (.delegate= only creates a weak reference)
+    @delegate ||= UITextField_Delegate.new
+    yield
+    self.delegate = @delegate
+  end
+end
+
+class UITextField_Delegate
+  [:textFieldShouldBeginEditing, :textFieldDidBeginEditing,
+   :textFieldShouldEndEditing, :textFieldDidEndEditing,
+   :shouldChangeCharactersInRange, :textFieldShouldClear,
+   :textFieldShouldReturn].each {|method|
+    attr_accessor (method.to_s + "_callback").to_sym
+  }
+
+  # Called from
+  # [textField addTarget:block
+  #              action:'call'
+  #    forControlEvents:UIControlEventEditingChanged],
+  # NOT a UITextFieldDelegate method.
+  attr_accessor :on_change_callback
+
+  def textFieldShouldBeginEditing(theTextField)
+    if self.textFieldShouldBeginEditing_callback
+      return self.textFieldShouldBeginEditing_callback.call(theTextField)
+    end
+    true
+  end
+
+  def textFieldDidBeginEditing(theTextField)
+    if self.textFieldDidBeginEditing_callback
+      return self.textFieldDidBeginEditing_callback.call(theTextField)
+    end
+  end
+
+  def textFieldShouldEndEditing(theTextField)
+    if self.textFieldShouldEndEditing_callback
+      return self.textFieldShouldEndEditing_callback.call(theTextField)
+    end
+    true
+  end
+
+  def textFieldDidEndEditing(theTextField)
+    if self.textFieldDidEndEditing_callback
+      return self.textFieldDidEndEditing_callback.call(theTextField)
+    end
+  end
+
+  def textField(theTextField, shouldChangeCharactersInRange:range, replacementString:string)
+    if self.shouldChangeCharactersInRange_callback
+      return self.shouldChangeCharactersInRange_callback.call(theTextField, range, string)
+    end
+    true
+  end
+
+  def on_change(theTextField)
+    if self.on_change_callback
+      self.on_change_callback.call(theTextField)
+    end
+  end
+
+  def textFieldShouldClear(theTextField)
+    if self.textFieldShouldClear_callback
+      return self.textFieldShouldClear_callback.call(theTextField)
+    end
+    true
+  end
+
+  def textFieldShouldReturn(theTextField)
+    if self.textFieldShouldReturn_callback
+      return self.textFieldShouldReturn_callback.call(theTextField)
+    end
+    true
+  end
+end