formotion 0.0.1

data/lib/formotion/row.rb

@@ -0,0 +1,211 @@
+module Formotion
+  class Row < Formotion::Base
+    PROPERTIES = [
+      # @form.render will contain row's value as the value for this key.
+      :key,
+      # the user's (or configured) value for this row.
+      :value,
+      # set as cell.titleLabel.text
+      :title, 
+      # set as cell.detailLabel.text
+      :subtitle,
+      # configures the type of input this is (string, phone, switch, etc)
+      # either Formotion::RowType or a string/symbol representation of one
+      # see row_type.rb
+      :type,
+
+      # The following apply only to text-input fields
+
+      # placeholder text
+      :placeholder,
+      # whether or not the entry field is secure (like a password)
+      :secure, 
+      # given by a UIReturnKey___ integer, string, or symbol
+      # EX :default, :google
+      :return_key,
+      # given by a  UITextAutocorrectionType___ integer, string, or symbol
+      # EX :yes, :no, :default
+      :auto_correction,
+      # given by a UITextAutocapitalizationType___ integer, string, or symbol
+      # EX :none, :words
+      :auto_capitalization,
+      # field.clearButtonMode; given by a UITextFieldViewMode__ integer, string, symbol
+      # EX :never, :while_editing
+      # DEFAULT is nil, which is used as :while_editing
+      :clear_button]
+    PROPERTIES.each {|prop|
+      attr_accessor prop
+    }
+    BOOLEAN_PROPERTIES = [:secure]
+    SERIALIZE_PROPERTIES = PROPERTIES
+
+    # Reference to the row's section
+    attr_accessor :section
+
+    # Index of the row in the section
+    attr_accessor :index
+
+    # The reuse-identifier used in UITableViews
+    # By default is a stringification of section.index and row.index,
+    # thus is unique per row (bad for memory, to fix later.)
+    attr_accessor :reuse_identifier
+
+    # The following apply only to text-input fields
+
+    # reference to the row's UITextField.
+    attr_reader :text_field
+
+    # callback for what happens when the user
+    # hits the enter key while editing #text_field
+    attr_accessor :on_enter_callback
+    # callback for what happens when the user
+    # starts editing #text_field.
+    attr_accessor :on_begin_callback
+
+    def initialize(params = {})
+      super
+
+      BOOLEAN_PROPERTIES.each {|prop|
+        Formotion::Conditions.assert_nil_or_boolean(self.send(prop))
+      }
+    end
+
+    # Makes all ::BOOLEAN_PROPERTIES queriable with an appended ?
+    # these should be done with alias_method but there's currently a bug
+    # in RM which messes up attr_accessors with alias_method
+    # EX
+    # row.editable?
+    # => true
+    # row.checkable?
+    # => nil
+    def method_missing(method, *args, &block)
+      boolean_method = (method.to_s[0..-2]).to_sym
+      if BOOLEAN_PROPERTIES.member? boolean_method
+        return self.send(boolean_method)
+      end
+      super
+    end
+
+    #########################
+    # pseudo-properties
+
+    def index_path
+      NSIndexPath.indexPathForRow(self.index, inSection:self.section.index)
+    end
+
+    def form
+      self.section.form
+    end
+
+    def reuse_identifier
+      @reuse_identifier || "SECTION_#{self.section.index}_ROW_#{self.index}"
+    end
+
+    def next_row
+      # if there are more rows in this section, use that.
+      return self.section.rows[self.index + 1] if self.index < (self.section.rows.count - 1)        
+
+      # if there are more sections, then use the first row of that section.
+      return self.section.next_section.rows[0] if self.section.next_section
+
+      nil
+    end
+
+    def previous_row
+      return self.section.rows[self.index - 1] if self.index > 0        
+
+      # if there are more sections, then use the first row of that section.
+      return self.section.previous_section.rows[-1] if self.section.previous_section
+
+      nil
+    end
+
+    def editable?
+      Formotion::RowType::TEXT_FIELD_TYPES.member? self.type
+    end
+
+    def submit_button?
+      self.type == Formotion::RowType::SUBMIT
+    end
+
+    def switchable?
+      self.type == Formotion::RowType::SWITCH
+    end
+
+    def checkable?
+      self.type == Formotion::RowType::CHECK
+    end
+
+    #########################
+    #  setter overrides
+    def type=(type)
+      @type = Formotion::RowType.for(type)
+    end
+
+    def return_key=(value)
+      @return_key = const_int_get("UIReturnKey", value)
+    end
+
+    def auto_correction=(value)        
+      @auto_correction = const_int_get("UITextAutocorrectionType", value)
+    end
+
+    def auto_capitalization=(value)        
+      @auto_capitalization = const_int_get("UITextAutocapitalizationType", value)
+    end
+
+    def clear_button=(value)        
+      @clear_button = const_int_get("UITextFieldViewMode", value)
+    end
+
+    #########################
+    # setters for callbacks
+
+    def on_enter(&block)
+      self.on_enter_callback = block
+    end
+
+    def on_begin(&block)
+      self.on_begin_callback = block
+    end
+
+    #########################
+    # Methods for making cells
+    # Called in UITableViewDataSource methods
+    # in form_delegate.rb
+    def make_cell
+      cell, text_field = Formotion::RowCellBuilder.make_cell(self)
+      @text_field = text_field
+      cell
+    end
+
+    #########################
+    # Retreiving data
+    def to_hash
+      super
+    end
+
+    private
+    def const_int_get(base, value)
+      return value if value.is_a? Integer
+      value = value.to_s.camelize
+      Kernel.const_get("#{base}#{value}")
+    end
+
+    # Looks like RubyMotion adds UIKit constants
+    # at compile time. If you don't use these
+    # directly in your code, they don't get added
+    # to Kernel and const_int_get crashes.
+    def load_constants_hack
+      [UITextAutocapitalizationTypeNone, UITextAutocapitalizationTypeWords, 
+        UITextAutocapitalizationTypeSentences,UITextAutocapitalizationTypeAllCharacters,
+        UITextAutocorrectionTypeNo, UITextAutocorrectionTypeYes, UITextAutocorrectionTypeDefault,
+        UIReturnKeyDefault, UIReturnKeyGo, UIReturnKeyGoogle, UIReturnKeyJoin, 
+        UIReturnKeyNext, UIReturnKeyRoute, UIReturnKeySearch, UIReturnKeySend,
+        UIReturnKeyYahoo, UIReturnKeyDone, UIReturnKeyEmergencyCall, 
+        UITextFieldViewModeNever, UITextFieldViewModeAlways, UITextFieldViewModeWhileEditing,
+        UITextFieldViewModeUnlessEditing
+      ]
+    end
+  end
+end

data/lib/formotion/row_cell_builder.rb

@@ -0,0 +1,168 @@
+#################
+#
+# Formotion::RowCellBuilder
+# RowCellBuilder handles taking Formotion::Rows
+# and configuring UITableViewCells based on their properties.
+#
+#################
+module Formotion
+  class RowCellBuilder
+    # The new UITextField in a UITableViewCell
+    # will be assigned this tag, if applicable.
+    TEXT_FIELD_TAG=1000
+
+    # PARAMS row.is_a? Formotion::Row
+    # RETURNS [cell configured to that row, a UITextField for that row if applicable or nil]
+    def self.make_cell(row)
+      cell, text_field = nil
+
+      cell = UITableViewCell.alloc.initWithStyle(UITableViewCellStyleSubtitle, reuseIdentifier:row.reuse_identifier)
+
+      cell.accessoryType = UITableViewCellAccessoryNone
+      cell.textLabel.text = row.title
+      cell.detailTextLabel.text = row.subtitle
+
+      if row.submit_button?
+        make_submit_cell(row, cell)
+      elsif row.switchable?
+        make_switch_cell(row, cell)
+      elsif row.checkable?
+        make_check_cell(row, cell)
+      elsif row.editable?
+        text_field = make_text_field(row, cell)
+      end
+      [cell, text_field]
+    end
+
+    # This is actually called whenever again cell is checked/unchecked
+    # in the UITableViewDelegate callbacks. So (for now) don't
+    # instantiate long-lived objects in them.
+    # Maybe that logic should be moved elsewhere?
+    def self.make_check_cell(row, cell)
+      cell.accessoryType = row.value ? UITableViewCellAccessoryCheckmark : UITableViewCellAccessoryNone
+    end
+
+    def self.make_switch_cell(row, cell)
+      cell.selectionStyle = UITableViewCellSelectionStyleNone
+      switchView = UISwitch.alloc.initWithFrame(CGRectZero)
+      cell.accessoryView = switchView
+      switchView.setOn(row.value || false, animated:false)
+      switchView.when(UIControlEventValueChanged) do
+        row.value = switchView.isOn
+      end
+    end
+
+    # Does a clever little trick to override #layoutSubviews
+    # for just this one UITableViewCell object, in order to
+    # center it's labels horizontally.
+    def self.make_submit_cell(row, cell)
+      cell.class.send(:alias_method, :old_layoutSubviews, :layoutSubviews)
+      cell.instance_eval do
+        def layoutSubviews
+          old_layoutSubviews
+
+          center = lambda {|frame, dimen|
+            ((self.frame.size.send(dimen) - frame.size.send(dimen)) / 2.0)
+          }
+
+          self.textLabel.center = CGPointMake(self.frame.size.width / 2 - 10, self.textLabel.center.y)
+          self.detailTextLabel.center = CGPointMake(self.frame.size.width / 2 - 10, self.detailTextLabel.center.y)
+        end
+      end
+    end
+
+    # Configures the cell to have a new UITextField
+    # which is used to enter data. Consists of
+    # 1) setting up that field with the appropriate properties
+    # specified by `row` 2) configures the callbacks on the field
+    # to call any callbacks `row` listens for.
+    # Also does the layoutSubviews swizzle trick
+    # to size the UITextField so it won't bump into the titleLabel.
+    def self.make_text_field(row, cell)
+      field = UITextField.alloc.initWithFrame(CGRectZero)
+      field.tag = TEXT_FIELD_TAG
+
+      field.placeholder = row.placeholder
+      field.text = row.value
+
+      field.clearButtonMode = UITextFieldViewModeWhileEditing
+      field.contentVerticalAlignment = UIControlContentVerticalAlignmentCenter
+      field.textAlignment = UITextAlignmentRight 
+
+      case row.type
+      when RowType::EMAIL
+        field.keyboardType = UIKeyboardTypeEmailAddress
+      when RowType::PHONE
+        field.keyboardType = UIKeyboardTypePhonePad
+      when RowType::NUMBER
+        field.keyboardType = UIKeyboardTypeDecimalPad
+      else
+        field.keyboardType = UIKeyboardTypeDefault
+      end
+      
+      field.secureTextEntry = true if row.secure?
+      field.returnKeyType = row.return_key || UIReturnKeyNext
+      field.autocapitalizationType = row.auto_capitalization if row.auto_capitalization
+      field.autocorrectionType = row.auto_correction if row.auto_correction
+      field.clearButtonMode = row.clear_button || UITextFieldViewModeWhileEditing
+
+      if row.on_enter_callback
+        field.should_return? do |text_field|
+          if row.on_enter_callback.arity == 0
+            row.on_enter_callback.call
+          elsif row.on_enter_callback.arity == 1
+            row.on_enter_callback.call(row)
+          end
+          false
+        end
+      elsif field.returnKeyType == UIReturnKeyDone
+        field.should_return? do |text_field|
+          text_field.resignFirstResponder
+          false
+        end
+      else
+        field.should_return? do |text_field|
+          if row.next_row && row.next_row.text_field
+            row.next_row.text_field.becomeFirstResponder
+          else
+            text_field.resignFirstResponder
+          end
+          true
+        end
+      end
+
+      field.on_begin do |text_field|
+        row.on_begin_callback && row.on_begin_callback.call
+      end
+
+      field.should_begin? do |text_field|
+        row.section.form.active_row = row
+        true
+      end
+
+      field.on_change do |text_field|
+        row.value = text_field.text
+      end
+
+      cell.class.send(:alias_method, :old_layoutSubviews, :layoutSubviews)
+      cell.instance_eval do
+        def layoutSubviews
+          old_layoutSubviews
+
+          # viewWithTag is terrible, but I think it's ok to use here...
+          formotion_field = self.viewWithTag(Formotion::RowCellBuilder::TEXT_FIELD_TAG)
+          formotion_field.sizeToFit
+
+          field_frame = formotion_field.frame
+          field_frame.origin.x = self.textLabel.frame.origin.x + self.textLabel.frame.size.width + 20
+          field_frame.origin.y = ((self.frame.size.height - field_frame.size.height) / 2.0).round
+          field_frame.size.width = self.frame.size.width - field_frame.origin.x - 20
+          formotion_field.frame = field_frame
+        end
+      end
+
+      cell.addSubview(field)
+      field
+    end
+  end
+end

data/lib/formotion/row_type.rb

@@ -0,0 +1,33 @@
+module Formotion
+  class RowType
+    STRING=0
+    EMAIL=1
+    PHONE=2
+    NUMBER=3
+    SUBMIT=4
+    SWITCH=5
+    CHECK=6
+    STATIC=100
+
+    TYPES = [STRING, EMAIL, PHONE, NUMBER, SUBMIT, SWITCH, CHECK, STATIC]
+    TEXT_FIELD_TYPES=[STRING, EMAIL, PHONE, NUMBER]
+
+    class << self
+      def for(string_or_sym_or_int)
+        type = string_or_sym_or_int
+
+        if type.is_a?(Symbol) or type.is_a? String
+          string = type.to_s.upcase
+          if not const_defined? string
+            raise Formotion::InvalidClassError, "Invalid RowType value #{string_or_sym}"
+          end
+          Formotion::RowType.const_get(string)
+        elsif type.is_a? Integer and TYPES.member? type
+          TYPES[type]
+        else
+          raise Formotion::InvalidClassError, "Attempted row type #{type.inspect} is not a valid RowType."
+        end
+      end
+    end
+  end
+end

data/lib/formotion/section.rb

@@ -0,0 +1,108 @@
+module Formotion
+  class Section < Formotion::Base
+    PROPERTIES = [
+      # Displayed in the section header row
+      :title,
+      # Arranges the section as a 'radio' section,
+      # such that only one row can be checked at a time.
+      :select_one,
+      # IF :select_one is true, then @form.render will contain
+      # the checked row's value as the value for this key.
+      # ELSE it does nothing.
+      :key
+    ]
+    PROPERTIES.each {|prop|
+      attr_accessor prop
+    }
+    SERIALIZE_PROPERTIES = PROPERTIES + [:rows]
+
+    # Relationships
+
+    # This section's form
+    attr_accessor :form
+
+    # This section's index in it's form.
+    attr_accessor :index
+
+    def initialize(params = {})
+      super
+
+      Formotion::Conditions.assert_nil_or_boolean(self.select_one)
+
+      rows = params[:rows] || params["rows"]
+      rows && rows.each {|row_hash|
+        row = create_row(row_hash)
+      }
+    end
+
+    def build_row(&block)
+      row = create_row
+      block.call(row)
+      row
+    end
+
+    def create_row(hash = {})
+      row = hash
+      if hash.class == Hash
+        row = Formotion::Row.new(hash)
+      end
+      row.section = self
+      row.index = self.rows.count
+      self.rows << row
+      row
+    end
+
+    #########################
+    #  attribute overrides
+
+    def rows
+      @rows ||= []
+    end
+
+    def rows=(rows)
+      rows.each {|row|
+        Formotion::Conditions.assert_class(row, Formotion::Row)
+      }
+      @rows = rows
+    end
+
+    def index=(index)
+      @index = index.to_i
+    end
+
+    #########################
+    # pseudo-properties
+
+    # should be done with alias_method but there's currently a bug
+    # in RM which messes up attr_accessors with alias_method
+    def select_one?
+      self.select_one
+    end
+
+    def next_section
+      # if there are more sections in this form, use that.
+      if self.index < self.form.sections.count - 1
+        return self.form.sections[self.index + 1]
+      end
+
+      nil
+    end
+
+    def previous_section
+      # if there are more sections in this form, use that.
+      if self.index > 0
+        return self.form.sections[self.index - 1]
+      end
+
+      nil
+    end
+
+    #########################
+    # Retreiving data    
+    def to_hash
+      h = super
+      h[:rows] = self.rows.collect {|row| row.to_hash}
+      h
+    end
+  end
+end