motion_model 0.2

data/.gitignore

@@ -0,0 +1,9 @@
+.repl_history
+build
+resources/*.nib
+resources/*.momd
+resources/*.storyboardc
+.DS_Store
+doc/**/*.*
+doc
+*.gem

data/README.md

@@ -0,0 +1,170 @@
+MotionModel -- Simple Model, Validation, and Input Mixins for RubyMotion
+================
+
+MotionModel is for cases where Core Data is too heavy to lift but you are
+still intending to work with your data.
+
+MotionModel is a bunch of "I don't ever want to have to write that code
+again if I can help it" things extracted into modules. The four modules
+are:
+
+- ext: Core Extensions that provide a few Rails-like niceties. Nothing
+  new here, moving on...
+  
+- model.rb: You can read about it in "What Model Can Do" but it's a
+  mixin that provides you accessible attributes, row indexing,
+  serialization for persistence, and some other niceties like row
+  counting.
+  
+- validatable.rb: Provides a basic validation framework for any
+  arbitrary class. Right now, it can only validate for presence,
+  but expect that to change soon.
+  
+- input_helpers: Hooking an array up to a data form, populating
+  it, and retrieving the data afterwards can be a bunch of code.
+  Not something I'd like to write more often that I have to. These
+  helpers are certainly not the focus of this strawman release, but
+  I am using these in an app to create Apple-like input forms in
+  static tables. I expect some churn in this module.
+
+What Model Can Do
+================
+
+You can define your models and their schemas in Ruby. For example:
+
+```ruby
+class Task
+  include MotionModel::Model
+
+  columns :name        => :string,
+          :description => :string,
+          :due_date    => :date
+end
+
+class MyCoolController
+  def some_method
+    @task = Task.create :name => 'walk the dog',
+                :description => 'get plenty of exercise. pick up the poop',
+                :due_date => '2012-09-15'
+   end
+end
+```
+
+You can also include the `Validations` module to get field validation. For example:
+
+```ruby
+class Task
+  include MotionModel::Model
+  include MotionModel::Validations
+
+  columns :name        => :string,
+          :description => :string,
+          :due_date    => :date
+  validates :name => :presence => true
+end
+
+class MyCoolController
+  def some_method
+    @task = Task.new :name => 'walk the dog',
+                 :description => 'get plenty of exercise. pick up the poop',
+                 :due_date => '2012-09-15'
+
+    show_scary_warning unless @task.valid?
+  end
+end
+```
+
+Model Instances and Unique IDs
+-----------------
+
+It is assumed that models can be created from an external source (JSON from a Web 
+application or NSCoder from the device) or simply be a stand-alone data store. 
+To identify rows properly, the model tracks a special field called `:id`. If it's
+already present, it's left alone. If it's missing, then it is created for you.
+Each row id is guaranteed to be unique, so you can use this when communicating
+with a server or syncing your rowset to a UITableView.
+
+Things That Work
+-----------------
+
+* Models, in general, work. They aren't ultra full-featured, but more is in the
+  works. In particular, finders are just coming online. All column data may be
+  accessed by member name, e.g., `@task.name`.
+  
+  * Finders are implemented using chaining. Here is an examples:
+
+    ```ruby  
+    @tasks = Task.where(:assigned_to).eq('bob').and(:location).contains('seattle')
+    @tasks.all.each { |task| do_something_with(task) }
+    ```
+
+    You can perform ordering using either a field name or block syntax. Here's an example:
+
+    ```ruby
+    @tasks = Task.order(:name).all                                  # Get tasks ordered ascending by :name
+    @tasks = Task.order{|one, two| two.details <=> one.details}.all # Get tasks ordered descending by :details
+    ```
+
+* Serialization using `NSCoder` works. Basically, you might do something like this
+  in your `AppDelegate`:
+
+  ```ruby
+  def load_data
+    if File.exist? documents_file("my_fine.dat")
+      error_ptr = Pointer.new(:object)
+      
+      data = NSData.dataWithContentsOfFile(documents_file('my_fine.dat'), options:NSDataReadingMappedIfSafe, error:error_ptr)
+      
+      if data.nil?
+        error = error_ptr[0]
+        show_user_scary_warning error
+      else
+        @my_data_tree = NSKeyedUnarchiver.unarchiveObjectWithData(data)
+      end
+    else
+      show_user_first_time_welcome
+    end
+  end
+  ```
+  
+  and of course on the "save" side:
+  
+  ```ruby
+  error_ptr = Pointer.new(:object)
+
+  data = NSKeyedArchiver.archivedDataWithRootObject App.delegate.events
+  unless data.writeToFile(documents_file('my_fine.dat'), options: NSDataWritingAtomic, error: error_ptr)
+    error = error_ptr[0]
+    show_scary_message error
+  end
+  ```
+  
+  Note that the archiving of any arbitrarily complex set of relations is
+  automatically handled by `NSCoder` provided you conform to the coding
+  protocol. When you declare your columns, `MotionModel` understands how
+  to serialize your data so you need take no further action.
+  
+* Relations, in principle work. This is a part I'm still noodling over
+  so it's not really safe to use them. In any case, how I expect it will
+  shake out is that one-to-one or one-to-many will be supported out of
+  the box, but you will have to take some extra steps to implement
+  many-to-many, just as you would in Rails' `has_many :through`.
+
+* Core extensions work. The following are supplied:
+
+  - String#humanize
+  - String#titleize
+  - String#empty?
+  - NilClass#empty?
+  - Array#empty?
+  - Hash#empty?
+  - Symbol#titleize
+
+Things In The Pipeline
+----------------------
+
+- More tests!
+- More robust id assignment
+- Testing relations
+- Adding validations and custom validations
+- Did I say more tests?

data/Rakefile

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.delegate_class = 'FakeDelegate'
+  app.files = Dir.glob('./lib/motion_model/**/*.rb')
+  app.files = (Dir.glob('./app/**/*.rb') + app.files).uniq
+end

data/app/app_delegate.rb

@@ -0,0 +1,2 @@
+class FakeDelegate
+end

data/lib/motion_model/ext.rb

@@ -0,0 +1,37 @@
+class String
+  def humanize
+    self.split(/_|-| /).join(' ')
+  end
+  
+  def titleize
+    self.split(/_|-| /).each{|word| word[0...1] = word[0...1].upcase}.join(' ')
+  end
+  
+  def empty?
+    self.length < 1
+  end
+end
+
+class NilClass
+  def empty?
+    true
+  end
+end
+
+class Array
+  def empty?
+    self.length < 1
+  end
+end
+
+class Hash
+  def empty?
+    self.length < 1
+  end
+end    
+
+class Symbol
+  def titleize
+    self.to_s.titleize
+  end
+end

data/lib/motion_model/input_helpers.rb

@@ -0,0 +1,220 @@
+module MotionModel
+  module InputHelpers
+    class ModelNotSetError < RuntimeError; end
+    
+    # FieldBindingMap contains a simple label to model
+    # field binding, and is decorated by a tag to be
+    # used on the UI control.
+    class FieldBindingMap
+      attr_accessor :label, :name, :tag
+      
+      def initialize(options = {})
+        @name = options[:name]
+        @label = options[:label]
+      end
+    end
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set('@data', [])
+    end
+    
+    module ClassMethods
+      # +field+ is a declarative macro that specifies
+      # the field name (i.e., the model field name)
+      # and the label. In the absence of a label,
+      # +field+ attempts to synthesize one from the
+      # model field name. YMMV.
+      #
+      # Usage:
+      #
+      #    class MyInputSheet < UIViewController
+      #      include InputHelpers
+      #
+      #      field 'event_name', :label => 'name'
+      #      field 'event_location', :label => 'location
+      #
+      # Only one field mapping may be supplied for
+      # a given class.
+      def field(field, options = {})
+        puts "adding field #{field}"
+        label = options[:label] || field.humanize
+        @data << FieldBindingMap.new(:label => label, :name => field)
+      end
+    end
+    
+    # +model+ is a mandatory method in which you
+    # specify the instance of the model to which
+    # your fields are bound.
+    
+    def model(model_instance)
+      @model = model_instance
+    end
+    
+    # +field_count+ specifies how many fields have
+    # been bound.
+    #
+    # Usage:
+    #
+    #     def tableView(table, numberOfRowsInSection: section)
+    #       field_count
+    #     end
+
+    def field_count
+      self.class.instance_variable_get('@data'.to_sym).length
+    end
+
+    # +field_at+ retrieves the field at a given index.
+    #
+    # Usage:
+    #  
+    #     field = field_at(indexPath.row)
+    #     label_view = subview(UILabel, :label_frame, text: field.label)
+    
+    def field_at(index)
+      data = self.class.instance_variable_get('@data'.to_sym)
+      data[index].tag = index + 1
+      data[index]
+    end
+
+    # +value_at+ retrieves the value from the form that corresponds
+    # to the name of the field.
+    #
+    # Usage:
+    #
+    #     value_edit_view = subview(UITextField, :input_value_frame, text: value_at(field))
+
+    def value_at(field)
+      @model.send(field.name)
+    end
+    
+    # +fields+ is the iterator for all fields
+    # mapped for this class.
+    #
+    # Usage:
+    #
+    #     fields do |field|
+    #       do_something_with field.label, field.value
+    #     end
+    
+    def fields
+      self.class.instance_variable_get('@data'.to_sym).each{|datum| yield datum}
+    end
+    
+    # +bind+ fetches all mapped fields from
+    # any subview of the current +UIView+
+    # and transfers the contents to the
+    # corresponding fields of the model
+    # specified by the +model+ method.
+    def bind
+      raise ModelNotSetError.new("You must set the model before binding it.") unless @model
+      
+      fields do |field|
+        puts "*** retrieving data for #{field.name} and tag #{field.tag} ***"
+        view_obj = view.viewWithTag(field.tag)
+        puts "view object with tag is #{view_obj.inspect}"
+        @model.send("#{field.name}=".to_sym, view.viewWithTag(field.tag).text)
+      end
+    end
+
+    # Handle hiding the keyboard if the user
+    # taps "return". If you don't want this behavior,
+    # define the function as empty in your class.
+    def textFieldShouldReturn(textField)
+      textField.resignFirstResponder
+    end
+
+    # Keyboard show/hide handlers do this:
+    #
+    # * Reset the table insets so that the
+    #   UITableView knows how large its real
+    #   visible area.
+    # * Scroll the UITableView to reveal the
+    #   cell that has the +firstResponder+
+    #   if it is not already showing.
+    #
+    # Of course, the process is exactly reversed
+    # when the keyboard hides.
+    #
+    # An instance variable +@table+ is assumed to
+    # be the table to affect; if this is missing,
+    # this code will simply no-op.
+    #
+    # Rejigger everything under the sun when the
+    # keyboard slides up.
+    #
+    # You *must* handle the +UIKeyboardWillShowNotification+ and
+    # when you receive it, call this method to handle the keyboard
+    # showing.
+    def handle_keyboard_will_show(notification)
+      return unless @table
+
+      animationCurve = notification.userInfo.valueForKey(UIKeyboardAnimationCurveUserInfoKey)
+      animationDuration = notification.userInfo.valueForKey(UIKeyboardAnimationDurationUserInfoKey)
+      keyboardEndRect = notification.userInfo.valueForKey(UIKeyboardFrameEndUserInfoKey)
+      
+      keyboardEndRect = view.convertRect(keyboardEndRect.CGRectValue, fromView:App.delegate.window)
+
+      UIView.beginAnimations "changeTableViewContentInset", context:nil
+      UIView.setAnimationDuration animationDuration
+      UIView.setAnimationCurve animationCurve
+
+      intersectionOfKeyboardRectAndWindowRect = CGRectIntersection(App.delegate.window.frame, keyboardEndRect)
+      bottomInset = intersectionOfKeyboardRectAndWindowRect.size.height;
+    
+      @table.contentInset = UIEdgeInsetsMake(0, 0, bottomInset, 0)
+
+      # Find active cell
+      indexPathOfOwnerCell = nil
+      numberOfCells = @table.dataSource.tableView(@table, numberOfRowsInSection:0)
+      0.upto(numberOfCells) do |index|
+        indexPath = NSIndexPath.indexPathForRow(index, inSection:0)
+        cell = @table.cellForRowAtIndexPath(indexPath)
+        if cell_has_first_responder?(cell)
+          indexPathOfOwnerCell = indexPath
+          break
+        end
+      end
+
+      UIView.commitAnimations
+
+      if indexPathOfOwnerCell
+        @table.scrollToRowAtIndexPath(indexPathOfOwnerCell, 
+          atScrollPosition:UITableViewScrollPositionMiddle,
+          animated: true)
+      end
+    end
+
+    # Undo all the rejiggering when the keyboard slides
+    # down.
+    #
+    # You *must* handle the +UIKeyboardWillHideNotification+ and
+    # when you receive it, call this method to handle the keyboard
+    # hiding.
+    def handle_keyboard_will_hide(notification)
+      return unless @table
+
+      if UIEdgeInsetsEqualToEdgeInsets(@table.contentInset, UIEdgeInsetsZero)
+        return
+      end
+    
+      animationCurve = notification.userInfo.valueForKey(UIKeyboardAnimationCurveUserInfoKey)
+      animationDuration = notification.userInfo.valueForKey(UIKeyboardAnimationDurationUserInfoKey)
+    
+      UIView.beginAnimations("changeTableViewContentInset", context:nil)
+      UIView.setAnimationDuration(animationDuration)
+      UIView.setAnimationCurve(animationCurve)
+    
+      @table.contentInset = UIEdgeInsetsZero;
+    
+      UIView.commitAnimations    
+    end
+    
+    def cell_has_first_responder?(cell)
+      cell.subviews.each do |subview|
+        return true if subview.isFirstResponder
+      end
+      false
+    end
+  end
+end

data/lib/motion_model/model.rb

@@ -0,0 +1,346 @@
+# MotionModel encapsulates a pattern for synthesizing a model
+# out of thin air. The model will have attributes, types,
+# finders, ordering, ... the works.
+#
+# As an example, consider:
+#
+#    class Task
+#      include MotionModel
+#
+#      columns :task_name => :string,
+#              :details   => :string,
+#              :due_date  => :date
+#
+#      # any business logic you might add...
+#    end
+#
+# Now, you can write code like:
+#
+#    Task.create :task_name => 'Walk the dog',
+#                :details   => 'Pick up after yourself',
+#                :due_date  => '2012-09-17'
+#
+# Recognized types are:
+#
+# * :string
+# * :date (must be in a form that Date.parse can recognize)
+# * :time (must be in a form that Time.parse can recognize)
+# * :integer
+# * :float
+#
+# Assuming you have a bunch of tasks in your data store, you can do this:
+# 
+#    tasks_this_week = Task.where(:due_date).ge(beginning_of_week).and(:due_date).le(end_of_week).order(:due_date)
+#
+# Partial queries are supported so you can do:
+#
+#    tasks_this_week = Task.where(:due_date).ge(beginning_of_week).and(:due_date).le(end_of_week)
+#    ordered_tasks_this_week = tasks_this_week.order(:due_date)
+#
+module MotionModel
+  module Model
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set("@column_attrs", [])
+      base.instance_variable_set("@typed_attrs", [])
+      base.instance_variable_set("@collection", [])
+      base.instance_variable_set("@_next_id", 1)
+    end
+    
+    module ClassMethods
+      # Macro to define names and types of columns. It can be used in one of
+      # two forms:
+      #
+      # Pass a hash, and you define columns with types. E.g.,
+      #
+      #   columns :name => :string, :age => :integer
+      #   
+      # Pass an array, and you create column names, all of which have type +:string+.
+      #   
+      #   columns :name, :age, :hobby
+      def columns(*fields)
+        return @column_attrs if fields.empty?
+
+        case fields.first
+        when Hash
+          fields.first.each_pair do |attr, type|
+            add_attribute(attr, type)
+          end
+        else
+          fields.each do |attr|
+            add_attribute(attr, :string)
+          end
+        end
+
+        unless self.respond_to?(:id)
+          add_attribute(:id, :integer)
+        end
+      end
+
+      def add_attribute(attr, type) #nodoc
+        attr_accessor attr
+        @column_attrs << attr
+        @typed_attrs  << type
+      end
+
+      def next_id #nodoc
+        @_next_id
+      end
+
+      def increment_id #nodoc
+        @_next_id += 1
+      end
+
+      # Returns true if a column exists on this model, otherwise false.
+      def column?(column)
+        @column_attrs.each{|key| 
+          return true if key == column
+          }
+        false
+      end
+      
+      # Returns type of this column.
+      def type(column)
+        index = @column_attrs.index(column)
+        index ? @typed_attrs[index] : nil
+      end
+
+      # Creates an object and saves it. E.g.:
+      #
+      #   @bob = Person.create(:name => 'Bob', :hobby => 'Bird Watching')
+      #
+      # returns the object created or false.
+      def create(options = {})
+        row = self.new(options)
+        # TODO: Check for Validatable and if it's
+        # present, check valid? before saving.
+        @collection.push(row)
+        row
+      end
+
+      def length
+        @collection.length
+      end
+      alias_method :count, :length
+
+      # Empties the entire store.
+      def delete_all
+        @collection = [] # TODO: Handle cascading or let GC take care of it.
+      end
+
+      # Finds row(s) within the data store. E.g.,
+      #
+      #   @post = Post.find(1)  # find a specific row by ID
+      #
+      # or...
+      #
+      #   @posts = Post.find(:author).eq('bob').all
+      def find(*args)
+        unless args[0].is_a?(Symbol) || args[0].is_a?(String)
+          return @collection[args[0].to_i] || nil
+        end
+        
+        FinderQuery.new(args[0].to_sym, @collection)
+      end
+      alias_method :where, :find
+      
+      # Retrieves first row of query
+      def first
+        @collection.first
+      end
+    
+      # Retrieves last row of query
+      def last
+        @collection.last
+      end
+    
+      # Returns query result as an array
+      def all
+        @collection
+      end
+      
+      def order(field_name = nil, &block)
+        FinderQuery.new(@collection).order(field_name, &block)
+      end
+      
+      def each(&block)
+        raise ArgumentError.new("each requires a block") unless block_given?
+        @collection.each{|item| yield item}
+      end
+      
+    end
+ 
+    ####### Instance Methods #######
+    def initialize(options = {})
+      columns.each{|col| instance_variable_set("@#{col.to_s}", nil) unless options.has_key?(col)}
+      
+      options.each do |key, value|
+        instance_variable_set("@#{key.to_s}", value || '') if self.class.column?(key.to_sym)
+      end
+      unless self.id
+        self.id = self.class.next_id
+        self.class.increment_id
+      end
+    end
+
+    def length
+      @collection.length
+    end
+    
+    alias_method :count, :length
+      
+    def column?(target_key)
+      self.class.column?(target_key)
+    end
+
+    def columns
+      self.class.columns
+    end
+
+    def type(field_name)
+      self.class.type(field_name)
+    end
+
+    def initWithCoder(coder)
+      self.init
+      self.class.instance_variable_get("@column_attrs").each do |attr|
+        # If a model revision has taken place, don't try to decode
+        # something that's not there.
+        new_tag_id = 1
+        if coder.containsValueForKey(attr.to_s)
+          value = coder.decodeObjectForKey(attr.to_s)
+          self.instance_variable_set('@' + attr.to_s, value || '')
+        else
+          self.instance_variable_set('@' + attr.to_s, '') # set to empty string if new attribute
+        end
+
+        # re-issue tags to make sure they are unique
+        @tag = new_tag_id
+        new_tag_id += 1
+      end
+      self
+    end
+    
+    def encodeWithCoder(coder)
+      self.class.instance_variable_get("@column_attrs").each do |attr|
+        coder.encodeObject(self.send(attr), forKey: attr.to_s)
+      end
+    end
+    
+  end
+  
+  class FinderQuery
+    attr_accessor :field_name
+    
+    def initialize(*args)
+      @field_name = args[0] if args.length > 1
+      @collection = args.last
+    end
+    
+    def and(field_name)
+      @field_name = field_name
+      self
+    end
+    
+    def order(field = nil, &block)
+      if block_given?
+        @collection = @collection.sort{|o1, o2| yield(o1, o2)}
+      else
+        raise ArgumentError.new('you must supply a field name to sort unless you supply a block.') if field.nil?
+        @collection = @collection.sort{|o1, o2| o1.send(field) <=> o2.send(field)}
+      end
+      self
+    end
+    
+    ######## relational methods ########
+    def do_comparison(query_string)
+      # TODO: Flag case-insensitive searching
+      query_string = query_string.downcase if query_string.respond_to?(:downcase)
+      @collection = @collection.select do |item|
+        comparator = item.send(@field_name.to_sym)
+        yield query_string, comparator
+      end
+      self
+    end
+    
+    def contain(query_string)
+      do_comparison(query_string) do |comparator, item|
+        item =~ Regexp.new(comparator)
+      end
+    end
+    alias_method :contains, :contain
+    alias_method :like, :contain
+    
+    def eq(query_string)
+      do_comparison(query_string) do |comparator, item|
+        comparator == item
+      end
+    end
+    alias_method :==, :eq
+    alias_method :equal, :eq
+    
+    def gt(query_string)
+      do_comparison(query_string) do |comparator, item|
+        comparator > item
+      end
+    end
+    alias_method :>, :gt
+    alias_method :greater_than, :gt
+    
+    def lt(query_string)
+      do_comparison(query_string) do |comparator, item|
+        comparator < item
+      end
+    end
+    alias_method :<, :lt
+    alias_method :less_than, :lt
+    
+    def gte(query_string)
+      do_comparison(query_string) do |comparator, item|
+        comparator >= item
+      end
+    end
+    alias_method :>=, :gte
+    alias_method :greater_than_or_equal, :gte
+    
+    
+    def lte(query_string)
+      do_comparison(query_string) do |comparator, item|
+        comparator <= item
+      end
+    end
+    alias_method :<=, :lte
+    alias_method :less_than_or_equal, :lte
+    
+    def ne(query_string)
+      do_comparison(query_string) do |comparator, item|
+        comparator != item
+      end
+    end
+    alias_method :!=, :ne
+    alias_method :not_equal, :ne
+    
+    ########### accessor methods #########
+    def first
+      @collection.first
+    end
+    
+    def last
+      @collection.last
+    end
+    
+    def all
+      @collection
+    end
+    
+    # each is a shortcut method to turn a query into an iterator. It allows
+    # you to write code like:
+    #
+    #   Task.where(:assignee).eq('bob').each{ |assignee| do_something_with(assignee) }
+    def each(&block)
+      raise ArgumentError.new("each requires a block") unless block_given?
+      @collection.each{|item| yield item}
+    end
+  end
+end
+

data/lib/motion_model/validatable.rb

@@ -0,0 +1,64 @@
+module MotionModel
+  module Validatable
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.instance_variable_set('@validations', [])
+    end
+
+    module ClassMethods
+      def validate(field = nil, validation_type = {})
+        if field.nil? || field.to_s == ''
+          ex = ValidationSpecificationError.new('field not present in validation call')
+          raise ex
+        end
+    
+        if validation_type == {} # || !(validation_type is_a?(Hash))
+          ex = ValidationSpecificationError.new('validation type not present or not a hash')
+          raise ex
+        end
+    
+        @validations << {field => validation_type}
+      end      
+    end
+  
+    def valid?
+      @messages = []
+      @valid = true
+      self.class.instance_variable_get(@validations).each do |validations|
+        validate_each(validations)
+      end
+      @valid
+    end
+
+    def validate_each(validations)
+      validations.each_pair do |field, validation|
+        validate_one field, validation
+      end
+    end
+  
+    def validate_one(field, validation)
+      validation.each_pair do |validation_type, setting|
+        case validation_type
+        when :presence
+          @valid &&= validate_presence(field)
+          if setting
+            additional_message = "non-empty"
+          else
+            additional_message = "empty"
+          end
+          @valid = !@valid if setting == false
+          @messages << {field => "incorrect value supplied for #{field.to_s} -- should be #{additional_message}"}
+        else
+          @valid = false
+          ex = ValidationSpecificationError.new("unknown validation type :#{validation_type.to_s}")
+        end
+      end
+    end
+  
+    def validate_presence(field)
+      value = self.send(field.to_s)
+      return false if value.nil?
+      return value.strip.length > 0
+    end
+  end
+end

data/lib/motion_model/version.rb

@@ -0,0 +1,3 @@
+module MotionModel
+  VERSION = "0.2"
+end

data/lib/motion_model.rb

@@ -0,0 +1,5 @@
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), "motion_model/**/*.rb")).each do |file|
+    app.files.unshift(file)
+  end
+end

data/motion_model.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/motion_model/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Steve Ross"]
+  gem.email         = ["sxross@gmail.com"]
+  gem.description   = "Simple model and validation mixins for RubyMotion"
+  gem.summary       = "Simple model and validation mixins for RubyMotion"
+  gem.homepage      = "https://github.com/sxross/MotionModel"
+
+  gem.files         = `git ls-files`.split($\)
+  puts "gem files are #{`git ls-files`.split($\)}"
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "motion_model"
+  gem.require_paths = ["lib"]
+  gem.version       = MotionModel::VERSION
+end

data/spec/model_spec.rb

@@ -0,0 +1,200 @@
+class Task
+  include MotionModel::Model
+  columns       :name => :string, 
+  							:details => :string,
+  							:some_day => :date
+end
+
+class ATask
+  include MotionModel::Model
+  columns :name, :details, :some_day
+end
+
+describe "Creating a model" do
+  before do
+    Task.delete_all
+  end
+
+  describe 'column macro behavior' do
+
+    it 'succeeds when creating a valid model from attributes' do
+  	  a_task = Task.new(:name => 'name', :details => 'details')
+  	  a_task.name.should.equal('name')
+    end
+    
+    it 'creates a model with all attributes even if some omitted' do
+      atask = Task.create(:name => 'bob')
+      atask.should.respond_to(:details)
+    end
+
+    it 'simply bypasses spurious attributes erroneously set' do
+    	a_task = Task.new(:name => 'details', :zoo => 'very bad')
+    	a_task.should.not.respond_to(:zoo)
+    	a_task.name.should.equal('details')
+    end
+
+    it "can check for a column's existence on a model" do
+  	  Task.column?(:name).should.be.true
+    end
+
+    it "can check for a column's existence on an instance" do
+  	  a_task = Task.new(:name => 'name', :details => 'details')
+  	  a_task.column?(:name).should.be.true
+    end
+
+    it "gets a list of columns on a model" do
+    	cols = Task.columns
+    	cols.should.include(:name)
+    	cols.should.include(:details)
+    end
+
+    it "gets a list of columns on an instance" do
+    	a_task = Task.new
+    	cols = a_task.columns
+    	cols.should.include(:name)
+    	cols.should.include(:details)
+    end
+
+    it "columns can be specified as a Hash" do
+    	lambda{Task.new}.should.not.raise
+    	Task.new.column?(:name).should.be.true
+    end
+
+    it "columns can be specified as an Array" do
+    	lambda{ATask.new}.should.not.raise
+    	Task.new.column?(:name).should.be.true
+    end
+
+    it "the type of a column can be retrieved" do
+    	Task.new.type(:some_day).should.equal(:date)
+    end
+
+  end
+
+  describe "ID handling" do
+
+    it 'creates an id if none present' do
+      task = Task.create
+      task.should.respond_to(:id)
+    end
+
+    it 'does not overwrite an existing ID' do
+      task = Task.create(:id => 999)
+      task.id.should.equal(999)
+    end
+
+    it 'creates multiple objects with unique ids' do
+      Task.create.id.should.not.equal(Task.create.id)
+    end
+
+  end
+
+  describe 'count and length methods' do
+
+    it 'has a length method' do
+      Task.should.respond_to(:length)
+    end
+
+    it 'has a count method' do
+      Task.should.respond_to(:count)
+    end
+
+    it 'when there is one element, length returns 1' do
+      task = Task.create
+      Task.length.should.equal(1)
+    end
+
+    it 'when there is one element, count returns 1' do
+      task = Task.create
+      Task.count.should.equal(1)
+    end
+
+    it 'when there is more than one element, length returned is correct' do
+      10.times { Task.create }
+      Task.length.should.equal(10)
+    end
+
+  end
+
+  describe 'finders' do
+    before do
+      10.times {|i| Task.create(:name => "task #{i}")}
+    end
+
+    describe 'find' do
+      it 'finds elements within the collection' do
+        Task.find(3).name.should.equal('task 3')
+      end
+
+      it 'returns nil if find by id is not found' do
+        Task.find(999).should.be.nil
+      end
+      
+      it 'looks into fields if field name supplied' do
+        Task.create(:name => 'find me')
+        Task.find(:name).eq('find me').all.length.should.equal(1)
+      end
+      
+      it 'allows for multiple (chained) query parameters' do
+        Task.create(:name => 'find me', :details => "details 1")
+        Task.create(:name => 'find me', :details => "details 2")
+        tasks = Task.find(:name).eq('find me').and(:details).like('2')
+        tasks.first.details.should.equal('details 2')
+        tasks.all.length.should.equal(1)
+      end
+
+      it 'where should respond to finder methods' do
+        Task.where(:details).should.respond_to(:contain)
+      end
+      
+      it 'returns a FinderQuery object' do
+        Task.where(:details).should.is_a(MotionModel::FinderQuery)
+      end
+      
+      it 'using where instead of find' do
+        atask = Task.create(:name => 'find me', :details => "details 1")
+        found_task = Task.where(:details).contain("details 1").first.details.should.equal("details 1")
+      end
+    
+      it 'all returns all members of the collection as an array' do
+        Task.all.length.should.equal(10)
+      end
+    
+      it 'each yields each row in sequence' do
+        i = 0
+        Task.each do |task|
+          task.name.should.equal("task #{i}")
+          i += 1
+        end
+      end
+
+    end
+    
+    describe 'sorting' do
+      before do
+        Task.delete_all
+        Task.create(:name => 'Task 3', :details => 'detail 3')
+        Task.create(:name => 'Task 1', :details => 'detail 1')
+        Task.create(:name => 'Task 2', :details => 'detail 6')
+        Task.create(:name => 'Random Task', :details => 'another random task')
+      end
+
+      it 'sorts by field' do
+        tasks = Task.order(:name).all
+        tasks[0].name.should.equal('Random Task')
+        tasks[1].name.should.equal('Task 1')
+        tasks[2].name.should.equal('Task 2')
+        tasks[3].name.should.equal('Task 3')
+      end
+
+      it 'sorts observing block syntax' do
+        tasks = Task.order{|one, two| two.details <=> one.details}.all
+        tasks[0].details.should.equal('detail 6')
+        tasks[1].details.should.equal('detail 3')
+        tasks[2].details.should.equal('detail 1')
+        tasks[3].details.should.equal('another random task')
+      end
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: motion_model
+version: !ruby/object:Gem::Version
+  version: '0.2'
+  prerelease: 
+platform: ruby
+authors:
+- Steve Ross
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-20 00:00:00.000000000 Z
+dependencies: []
+description: Simple model and validation mixins for RubyMotion
+email:
+- sxross@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- README.md
+- Rakefile
+- app/app_delegate.rb
+- lib/motion_model.rb
+- lib/motion_model/ext.rb
+- lib/motion_model/input_helpers.rb
+- lib/motion_model/model.rb
+- lib/motion_model/validatable.rb
+- lib/motion_model/version.rb
+- motion_model.gemspec
+- spec/model_spec.rb
+homepage: https://github.com/sxross/MotionModel
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Simple model and validation mixins for RubyMotion
+test_files:
+- spec/model_spec.rb