motion_model 0.2.8 → 0.3.0

data/CHANGELOG

@@ -1,3 +1,22 @@
+2012-12-07: Added MIT license file.
+            InputHelpers: Whitespace cleanup. Fixed keyboard show/hide to scroll to correct position.
+            MotionModel::Column: Whitespace cleanup, added code to support cascading delete (:dependent => :destroy)
+            MotionModel::Model: Whitespace cleanup, added code to support cascading destroy, destroy_all, and cascading if specified.
+            relation_spec.rb: removed delete tests into cascading_delete_spec.rb
+
+2012-12-06: Work on has_many to add cascading delete
+
+MotionModel: POTENTIAL CODE-BREAKING CHANGE. has_many now takes two arguments
+             only. Previously, it would allow a list of symbols or strings,
+             now it conforms more to the Rails way of one call per relation.
+             E.g.:
+
+             has_many :pets
+
+             -or-
+
+             has_many :pets, :delete => :destroy  # cascade delete.
+
 2012-10-14: Primary New Feature: Notifications
 
 MotionModel: Added bulk update, which suppresses notifications and added it to delete_all.
@@ -17,15 +36,15 @@ to the column metadata.
 
 * Default values have been added to fill in values
   if not specified in new or create.
-  
+
 2012-09-06: Added block-style finders. Added delete method.
 
 2012-09-07: IMPORTANT! PLEASE READ! Two new methods were added
             to MotionModel to support persistence:
-            
+
             Task#serialize_to_file(file_name)
             Task.deserialize_from_file(file_name)
-            
+
             Note that serialize operates on an instance and
             deserialize is a class method that creates an
-            instance.
+            instance.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Steve Ross
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,3 +1,5 @@
+[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/sxross/MotionModel)
+
 MotionModel -- Simple Model, Validation, and Input Mixins for RubyMotion
 ================
 
@@ -26,6 +28,9 @@ are:
   helpers are certainly not the focus of this release, but
   I am using these in an app to create Apple-like input forms in
   static tables.
+
+MotionModel is MIT licensed, which means you can pretty much do whatever
+you like with it. See the LICENSE file in this project.
   
 Getting Going
 ================
@@ -237,11 +242,45 @@ Using MotionModel
   Assignee.first.task.name            # => "Walk the Dog"
   ```
   
-  At this point, there are a few methods that need to be added
-  for relations, and they will.
-  
-  * destroy
+There are four ways to delete objects from your data store:
+
+* `object.delete     #` just deletes the object and ignores all relations
+* `object.destroy    #` deletes the object and honors any cascading declarations
+* `Class.delete_all  #` just deletes all objects of this class and ignores all relations
+* `Class.destroy_all #` deletes all objects of this class and honors any cascading declarations
   
+The key to how the `destroy` variants work in how the relation is declared. You can declare:
+
+```ruby
+  class Task
+    include MotionModel::Model
+    columns     :name => :string
+    has_many    :assignees
+  end
+```
+
+and `assignees` will *not be considered* when deleting `Task`s. However, by modifying the `has_many`,
+
+```ruby
+    has_many    :assignees, :dependent => :destroy
+```
+
+When you `destroy` an object, all of the objects related to it, and only those related
+to that object, are also destroyed. So, if you call `task.destroy` and there are 5
+`assignees` related to that task, they will also be destroyed. Any other `assignees`
+are left untouched.
+
+You can also specify:
+
+```ruby
+    has_many    :assignees, :dependent => :delete
+```
+
+The difference here is that the cascade stops as the `assignees` are deleted so anything
+related to the assignees remains intact.
+
+Note: This syntax is modeled on the Rails `:dependent => :destroy` options in `ActiveRecord`.
+
 Notifications
 -------------
 
@@ -405,4 +444,4 @@ specs.
 
 Really, for a bug report, even a failing spec or some proposed code is fine. I really want to make
 this a decent tool for RubyMotion developers who need a straightforward data
-modeling and persistence framework.
+modeling and persistence framework.

data/lib/motion_model/ext.rb

@@ -52,11 +52,11 @@ end
 # words. It is very much based on the Rails
 # ActiveSupport implementation or Inflector
 class Inflector
-  def self.instance
+  def self.instance #nodoc
     @__instance__ ||= new
   end
 
-  def initialize
+  def initialize #nodoc
     reset
   end
 
@@ -123,32 +123,28 @@ class Inflector
     false
   end
 
-  def singularize(word)
+  def inflect(word, direction) #nodoc
     return word if uncountable?(word)
-    plural = word.dup
+
+    subject = word.dup
 
     @irregulars.each do |rule|
-      return plural if plural.gsub!(rule.first, rule.last)
+      return subject if subject.gsub!(rule.first, rule.last)
     end
 
-    @singulars.each do |rule|
-      return plural if plural.gsub!(rule.first, rule.last)
+    sense_group = direction == :singularize ? @singulars : @plurals
+    sense_group.each do |rule|
+      return subject if subject.gsub!(rule.first, rule.last)
     end
-    plural
+    subject
   end
 
-  def pluralize(word)
-    return word if uncountable?(word)
-    singular = word.dup
-
-    @irregulars.each do |rule|
-      return singular if singular.gsub!(rule.first, rule.last)
-    end
+  def singularize(word)
+     inflect word, :singularize
+  end
 
-    @plurals.each do |rule|
-      return singular if singular.gsub!(rule.first, rule.last)
-    end
-    singular
+  def pluralize(word)
+    inflect word, :pluralize
   end
 end
 

data/lib/motion_model/input_helpers.rb

@@ -1,24 +1,24 @@
 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('@binding_data', [])
     end
-    
+
     module ClassMethods
       # +field+ is a declarative macro that specifies
       # the field name (i.e., the model field name)
@@ -41,15 +41,15 @@ module MotionModel
         @binding_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.
     #
@@ -66,10 +66,10 @@ module MotionModel
     # +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('@binding_data'.to_sym)
       data[index].tag = index + 1
@@ -86,7 +86,7 @@ module MotionModel
     def value_at(field)
       @model.send(field.name)
     end
-    
+
     # +fields+ is the iterator for all fields
     # mapped for this class.
     #
@@ -95,11 +95,11 @@ module MotionModel
     #     fields do |field|
     #       do_something_with field.label, field.value
     #     end
-    
+
     def fields
       self.class.instance_variable_get('@binding_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
@@ -107,7 +107,7 @@ module MotionModel
     # specified by the +model+ method.
     def bind
       raise ModelNotSetError.new("You must set the model before binding it.") unless @model
-      
+
       fields do |field|
         view_obj = self.view.viewWithTag(field.tag)
         @model.send("#{field.name}=".to_sym, view_obj.text) if view_obj.respond_to?(:text)
@@ -149,7 +149,6 @@ module MotionModel
       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
@@ -158,28 +157,29 @@ module MotionModel
 
       intersectionOfKeyboardRectAndWindowRect = CGRectIntersection(App.delegate.window.frame, keyboardEndRect)
       bottomInset = intersectionOfKeyboardRectAndWindowRect.size.height;
-    
+
       @table.contentInset = UIEdgeInsetsMake(0, 0, bottomInset, 0)
 
+      UIView.commitAnimations
+
+
+      @table.scrollToRowAtIndexPath(owner_cell_index_path,
+          atScrollPosition:UITableViewScrollPositionMiddle,
+          animated: true)
+    end
+
+    def owner_cell_index_path
       # 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
+        return indexPath if find_first_responder(cell)
       end
 
-      UIView.commitAnimations
-
-      if indexPathOfOwnerCell
-        @table.scrollToRowAtIndexPath(indexPathOfOwnerCell, 
-          atScrollPosition:UITableViewScrollPositionMiddle,
-          animated: true)
-      end
+      # By default use the first section, first row.
+      NSIndexPath.indexPathForRow 0, inSection: 0
     end
 
     # Undo all the rejiggering when the keyboard slides
@@ -194,25 +194,28 @@ module MotionModel
       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    
+
+      UIView.commitAnimations
     end
-    
-    def cell_has_first_responder?(cell)
-      return false unless cell.respond_to?(:subviews)
-      cell.subviews.each do |subview|
-        return true if subview.isFirstResponder
+
+    def find_first_responder(parent)
+      return parent if parent.isFirstResponder
+
+      parent.subviews.each do |subview|
+        first_responder = find_first_responder(subview)
+        return first_responder if first_responder
       end
-      false
+
+      return false
     end
   end
 end

data/lib/motion_model/model/column.rb

@@ -4,20 +4,25 @@ module MotionModel
       attr_accessor :name
       attr_accessor :type
       attr_accessor :default
+      attr_accessor :destroy
 
-      def initialize(name = nil, type = nil, default = nil)
+      def initialize(name = nil, type = nil, options = {})
         @name = name
         @type = type
-        @default = default || nil
+        @default = options[:default]
+        @destroy = options[:dependent]
       end
-      
-      def add_attr(name, type, default = nil)
+
+      # REVIEW: Dead code?
+      def add_attr(name, type, options)
         @name = name
         @type = type
-        @default = default || nil
+        @default = options[:default]
+        @destroy = options[:dependent]
       end
+
       alias_method :add_attribute, :add_attr
-      
+
       def classify
         case @type
         when :belongs_to
@@ -30,4 +35,4 @@ module MotionModel
       end
     end
   end
-end
+end

data/lib/motion_model/model/model.rb

@@ -28,7 +28,7 @@
 # * :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:
@@ -36,13 +36,15 @@
 #    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
   class PersistFileError < Exception; end
-  
+  class RelationIsNilError < Exception; end
+
   module Model
     def self.included(base)
-      base.extend(ClassMethods)
+      base.extend(PrivateClassMethods)
+      base.extend(PublicClassMethods)
       base.instance_variable_set("@_columns", [])               # Columns in model
       base.instance_variable_set("@_column_hashes", {})         # Hashes to for quick column lookup
       base.instance_variable_set("@_relations", {})             # relations
@@ -50,8 +52,8 @@ module MotionModel
       base.instance_variable_set("@_next_id", 1)                # Next assignable id
       base.instance_variable_set("@_issue_notifications", true) # Next assignable id
     end
-    
-    module ClassMethods
+
+    module PublicClassMethods
       # Use to do bulk insertion, updating, or deleting without
       # making repeated calls to a delegate. E.g., when syncing
       # with an external data source.
@@ -60,55 +62,6 @@ module MotionModel
         class_eval &block
         @_issue_notifications = true
       end
-      
-      def issue_notification(object, info) #nodoc
-        if @_issue_notifications == true && !object.nil?
-          NSNotificationCenter.defaultCenter.postNotificationName('MotionModelDataDidChangeNotification', object: object, userInfo: info)
-        end
-      end
-
-      def define_accessor_methods(name)
-        define_method(name.to_sym) {
-          @data[name]
-        }
-        define_method("#{name}=".to_sym) { |value|
-          @data[name] = cast_to_type(name, value)
-        }
-      end
-
-      def define_belongs_to_methods(name)
-        define_method(name) {
-          col = column_named(name)
-          parent_id = @data[self.class.belongs_to_id(col.name)]
-          col.classify.find(parent_id)
-        }
-        define_method("#{name}=") { |value|
-          col = column_named(name)
-          parent_id = self.class.belongs_to_id(col.name)
-          @data[parent_id.to_sym] = value.to_i
-        }
-      end
-
-      def define_has_many_methods(name)
-        define_method(name) {
-          relation_for(name)
-        }
-      end
-
-      def add_field(name, type, default = nil) #nodoc
-        col = Column.new(name, type, default)
-        @_columns.push col
-        @_column_hashes[col.name.to_sym] = col
-
-        case type
-          when :has_many
-            define_has_many_methods(name)
-          when :belongs_to
-            define_belongs_to_methods(name)
-          else
-            define_accessor_methods(name)
-          end
-      end
 
       # Macro to define names and types of columns. It can be used in one of
       # two forms:
@@ -120,41 +73,30 @@ module MotionModel
       # Pass a hash of hashes and you can specify defaults such as:
       #
       #   columns :name => {:type => :string, :default => 'Joe Bob'}, :age => :integer
-      #   
+      #
       # Pass an array, and you create column names, all of which have type +:string+.
-      #   
+      #
       #   columns :name, :age, :hobby
-      
+
       def columns(*fields)
         return @_columns.map{|c| c.name} if fields.empty?
 
-        col = Column.new
-        
+        # col = Column.new    # REVIEW: Dead code?
+
         case fields.first
         when Hash
-          fields.first.each_pair do |name, options|
-            raise ArgumentError.new("you cannot use `description' as a column name because of a conflict with Cocoa.") if name.to_s == 'description'
-            
-            case options
-            when Symbol, String
-              add_field(name, options)
-            when Hash
-              add_field(name, options[:type], options[:default])
-            else
-              raise ArgumentError.new("arguments to fields must be a symbol, a hash, or a hash of hashes.")
-            end
-          end
+          column_from_hash fields
+        when String, Symbol
+          column_from_string_or_sym fields
         else
-          fields.each do |name|
-            add_field(name, :string)
-          end
+          raise ArgumentError.new("arguments to `columns' must be a symbol, a hash, or a hash of hashes -- was #{fields.first}.")
         end
 
         unless self.respond_to?(:id)
           add_field(:id, :integer)
         end
       end
-      
+
       # Use at class level, as follows:
       #
       #   class Task
@@ -174,15 +116,14 @@ module MotionModel
       #
       # This must be used with a belongs_to macro in the related model class
       # if you want to be able to access the inverse relation.
-      def has_many(*relations)
-        relations.each do |relation|
-          raise ArgumentError.new("arguments to has_many must be a symbol, a string or an array of same.") unless relation.is_a?(Symbol) || relation.is_a?(String)
-          add_field relation, :has_many                                   # Relation must be plural
-        end
+
+      def has_many(relation, options = {})
+        raise ArgumentError.new("arguments to has_many must be a symbol or string.") unless [Symbol, String].include? relation.class
+        add_field relation, :has_many, options        # Relation must be plural
       end
-      
-      def belongs_to_id(relation)
-        (relation.to_s.underscore + '_id').to_sym
+
+      def generate_belongs_to_id(relation)
+        (relation.to_s.singularize.underscore + '_id').to_sym
       end
 
       # Use at class level, as follows
@@ -198,54 +139,24 @@ module MotionModel
       #   Assignee.find(:assignee_name).like('smith').first.task
       def belongs_to(relation)
         add_field relation, :belongs_to
-        add_field belongs_to_id(relation), :belongs_to_id    # a relation is singular.
-      end
-      
-      # Returns a column denoted by +name+
-      def column_named(name)
-        @_column_hashes[name.to_sym]
-      end
-
-      # Returns next available id
-      def next_id #nodoc
-        @_next_id
-      end
-
-      # Sets next available id
-      def next_id=(value)
-        @_next_id = value
-      end
-
-      # Increments next available id
-      def increment_id #nodoc
-        @_next_id += 1
+        add_field generate_belongs_to_id(relation), :belongs_to_id    # a relation is singular.
       end
 
       # Returns true if a column exists on this model, otherwise false.
       def column?(column)
         respond_to?(column)
       end
-      
+
       # Returns type of this column.
       def type(column)
         column_named(column).type || nil
       end
-      
+
       # returns default value for this column or nil.
       def default(column)
         column_named(column).default || nil
       end
-      
-      def has_relation?(col)
-        col = case col
-        when MotionModel::Model::Column
-          column_named(col.name)
-        else
-          column_named(col)
-        end
-        col.type == :has_many || col.type == :belongs_to
-      end
-      
+
       # Creates an object and saves it. E.g.:
       #
       #   @bob = Person.create(:name => 'Bob', :hobby => 'Bird Watching')
@@ -255,20 +166,22 @@ module MotionModel
         row = self.new(options)
         row.before_create if row.respond_to?(:before_create)
         row.before_save   if row.respond_to?(:before_save)
-        
+
         # TODO: Check for Validatable and if it's
         # present, check valid? before saving.
 
         row.save
         row
       end
-      
+
       def length
         @collection.length
       end
       alias_method :count, :length
 
-      # Empties the entire store.
+      # Deletes all rows in the model -- no hooks are called and
+      # deletes are not cascading so this does not affected related
+      # data.
       def delete_all
         # Do each delete so any on_delete and
         # cascades are called, then empty the
@@ -278,7 +191,19 @@ module MotionModel
         end
         @collection = []
         @_next_id = 1
-        # @collection.compact!
+      end
+
+      # Destroys all rows in the model -- before_delete and after_delete
+      # hooks are called and deletes are not cascading if declared with
+      # :delete => destroy in the has_many macro.
+      def destroy_all
+        ids = self.all.map{|item| item.id}
+        bulk_update do
+          ids.each do |item| 
+            find(item).destroy
+          end
+        end
+        # Note collection is not emptied, and next_id is not reset.
       end
 
       # Finds row(s) within the data store. E.g.,
@@ -295,226 +220,366 @@ module MotionModel
           end.compact
           return FinderQuery.new(matches)
         end
-        
+
         unless args[0].is_a?(Symbol) || args[0].is_a?(String)
-          return @collection.select{|c| c.id == args[0].to_i}.first || nil
+          target_id = args[0].to_i
+          return @collection.select{|element| element.id == target_id}.first
         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
+
       def empty?
         @collection.empty?
       end
     end
- 
-    ####### Instance Methods #######
-    def initialize(options = {})
-      @data ||= {}  # REVIEW: Why make this conditional?
-      
-      # Time zone, for future use.
-      @tz_offset ||= NSDate.date.to_s.gsub(/^.*?( -\d{4})/, '\1')
-
-      @cached_date_formatter = NSDateFormatter.alloc.init # Create once, as they are expensive to create
-      @cached_date_formatter.dateFormat = "MM-dd-yyyy HH:mm"
-      
-      unless options[:id]
-        options[:id] = self.class.next_id
-      else
-        self.class.next_id = [options[:id].to_i, self.class.next_id].max
+
+    module PrivateClassMethods
+      # This populates a column from something like:
+      #
+      #   columns :name => :string, :age => :integer
+      #
+      #   or
+      #
+      #   columns :name => {:type => :string, :default => 'Joe Bob'}, :age => :integer
+
+      def column_from_hash(hash) #nodoc
+        hash.first.each_pair do |name, options|
+          raise ArgumentError.new("you cannot use `description' as a column name because of a conflict with Cocoa.") if name.to_s == 'description'
+
+          case options
+          when Symbol, String
+            add_field(name, options)
+          when Hash
+            add_field(name, options[:type], :default => options[:default])
+          else
+            raise ArgumentError.new("arguments to `columns' must be a symbol, a hash, or a hash of hashes.")
+          end
+        end
+      end
+
+      # This populates a column from something like:
+      #
+      #   columns :name, :age, :hobby
+
+      def column_from_string_or_sym(string) #nodoc
+        string.each do |name|
+          add_field(name.to_sym, :string)
+        end
+      end
+
+      def issue_notification(object, info) #nodoc
+        if @_issue_notifications == true && !object.nil?
+          NSNotificationCenter.defaultCenter.postNotificationName('MotionModelDataDidChangeNotification', object: object, userInfo: info)
+        end
+      end
+
+      def define_accessor_methods(name) #nodoc
+        define_method(name.to_sym) {
+          @data[name]
+        }
+        define_method("#{name}=".to_sym) { |value|
+          @data[name] = cast_to_type(name, value)
+          @dirty = true
+        }
       end
-      self.class.increment_id
+
+      def define_belongs_to_methods(name) #nodoc
+        define_method(name) {
+          col = column_named(name)
+          parent_id = @data[self.class.generate_belongs_to_id(col.name)]
+          col.classify.find(parent_id)
+        }
+        define_method("#{name}=") { |value|
+          col = column_named(name)
+          parent_id = self.class.generate_belongs_to_id(col.name)
+          @data[parent_id.to_sym] = value.to_i
+        }
+      end
+
+      def define_has_many_methods(name) #nodoc
+        define_method(name) {
+          relation_for(name)
+        }
+      end
+
+      def add_field(name, type, options = {:default => nil}) #nodoc
+        col = Column.new(name, type, options)
+
+        @_columns.push col
+        @_column_hashes[col.name.to_sym] = col
+
+        case type
+          when :has_many then define_has_many_methods(name)
+          when :belongs_to then define_belongs_to_methods(name)
+          else
+            define_accessor_methods(name)
+          end
+      end
+
+      # Returns a column denoted by +name+
+      def column_named(name) #nodoc
+        @_column_hashes[name.to_sym]
+      end
+
+      # Returns next available id
+      def next_id #nodoc
+        @_next_id
+      end
+
+      # Sets next available id
+      def next_id=(value) #nodoc
+        @_next_id = value
+      end
+
+      # Increments next available id
+      def increment_id #nodoc
+        @_next_id += 1
+      end
+
+      def has_relation?(col) #nodoc
+        return false if col.nil?
+
+        col = case col
+        when MotionModel::Model::Column
+          column_named(col.name)
+        else
+          column_named(col)
+        end
+        col.type == :has_many || col.type == :belongs_to
+      end
+
+    end
+
+    def initialize(options = {})
+      @data ||= {}
+
+      assign_id options
 
       columns.each do |col|
-        unless [:belongs_to, :belongs_to_id, :has_many].include? column_named(col).type
-          options[col] ||= self.class.default(col)
-          cast_value = cast_to_type(col, options[col])
-          @data[col] = cast_value
+        unless relation_column?(col) # all data columns
+          initialize_data_columns col, options
         else
-          if column_named(col).type == :belongs_to_id
-            @data[col] = options[col]
-          end
+          @data[col] = options[col] if column_named(col).type == :belongs_to_id
         end
       end
-      
-      dirty = true
+
+      @dirty = true
     end
 
+    # Default to_i implementation returns value of id column, much as
+    # in Rails.
+
     def to_i
       @data[:id].to_i
     end
 
-    def cast_to_type(column_name, arg)
-      return nil if arg.nil?
-      
-      return_value = arg
-      
-      case type(column_name)
-      when :string
-        return_value = arg.to_s
-      when :int, :integer, :belongs_to_id
-        return_value = arg.is_a?(Integer) ? arg : arg.to_i
-      when :float, :double
-        return_value = arg.is_a?(Float) ? arg : arg.to_f
-      when :date
-        return arg if arg.is_a?(NSDate)
-        return_value = NSDate.dateWithNaturalLanguageString(arg, locale:NSUserDefaults.standardUserDefaults.dictionaryRepresentation)
-      else
-        raise ArgumentError.new("type #{column_name} : #{type(column_name)} is not possible to cast.")
-      end
-      return_value
-    end
-
+    # Default to_s implementation returns a list of columns and values
+    # separated by newlines.
     def to_s
       columns.each{|c| "#{c}: #{self.send(c)}\n"}
     end
-    
+
+    # Save current object. Speaking from the context of relational
+    # databases, this inserts a row if it's a new one, or updates
+    # in place if not.
     def save
-      collection = self.class.instance_variable_get('@collection')
       @dirty = false
-      
+
       # Existing object implies update in place
       # TODO: Optimize location of existing id
       action = 'add'
       if obj = collection.find{|o| o.id == @data[:id]}
-        collection = self
+        obj = self
         action = 'update'
       else
         collection << self
       end
       self.class.issue_notification(self, :action => action)
     end
-    
+
+    # Deletes the current object. The object can still be used.
+
     def delete
-      collection = self.class.instance_variable_get('@collection')
-            
       target_index = collection.index{|item| item.id == self.id}
       collection.delete_at(target_index)
       self.class.issue_notification(self, :action => 'delete')
     end
 
+    # Destroys the current object. The difference between delete
+    # and destroy is that destroy calls <tt>before_delete</tt>
+    # and <tt>after_delete</tt> hooks. As well, it will cascade
+    # into related objects, deleting them if they are related
+    # using <tt>:delete => :destroy</tt> in the <tt>has_many</tt>
+    # declaration
+    def destroy
+      before_delete if respond_to? :before_delete
+      has_many_columns.each do |col|
+        delete_candidates = self.send(col.name)
+
+        delete_candidates.each do |candidate|
+          candidate.delete if col.destroy == :delete
+          candidate.destroy if col.destroy == :destroy
+        end
+      end
+      delete
+      after_delete if respond_to? :after_delete
+    end
+
+    # Undelete does pretty much as its name implies. However,
+    # the natural sort order is not preserved. IMPORTANT: If
+    # you are trying to undo a cascading delete, this will not
+    # work. It only undeletes the object you still own.
+
+    def undelete
+      collection << self
+      self.class.issue_notification(self, :action => 'add')
+    end
+
+    # Count of objects in the current collection
     def length
-      @collection.length
+      collection.length
     end
-    
     alias_method :count, :length
-      
-    def column?(target_key)
-      self.class.column?(target_key.to_sym)
+
+    # True if the column exists, otherwise false
+    def column?(column_name)
+      self.class.column?(column_name.to_sym)
     end
 
+    # Returns list of column names as an array
     def columns
       self.class.columns
     end
 
-    def column_named(name)
-      self.class.column_named(name.to_sym)
+    # Type of a given column
+    def type(column_name)
+      self.class.type(column_name)
     end
 
-    def type(field_name)
-      self.class.type(field_name)
-    end
-    
-    # Modify respond_to? to add model's attributes.
+    # True if this object responds to the method or
+    # property, otherwise false.
     alias_method :old_respond_to?, :respond_to?
     def respond_to?(method)
       column_named(method) || old_respond_to?(method)
     end
-    
+
     def dirty?
-      @dirty      
+      @dirty
     end
-    
-    def relation_for(col)
-      # relation is a belongs_to or a has_many
+
+
+    private
+
+    def assign_id(options) #nodoc
+      unless options[:id]
+        options[:id] = self.class.next_id
+      else
+        self.class.next_id = [options[:id].to_i, self.class.next_id].max
+      end
+      self.class.increment_id
+    end
+
+    def relation_column?(column) #nodoc
+      [:belongs_to, :belongs_to_id, :has_many].include? column_named(column).type
+    end
+
+    def initialize_data_columns(column, options) #nodoc
+      options[column] ||= self.class.default(column)
+      cast_value = cast_to_type(column, options[column])
+      @data[column] = cast_value
+    end
+
+    def cast_to_type(column_name, arg) #nodoc
+      return nil if arg.nil?
+
+      return case type(column_name)
+      when :string then arg.to_s
+      when :int, :integer, :belongs_to_id
+        arg.is_a?(Integer) ? arg : arg.to_i
+      when :float, :double
+        arg.is_a?(Float) ? arg : arg.to_f
+      when :date
+        arg.is_a?(NSDate) ? arg : NSDate.dateWithNaturalLanguageString(arg, locale:NSUserDefaults.standardUserDefaults.dictionaryRepresentation)
+      else
+        raise ArgumentError.new("type #{column_name} : #{type(column_name)} is not possible to cast.")
+      end
+    end
+
+    def collection #nodoc
+      self.class.instance_variable_get('@collection')
+    end
+
+    def column_named(name) #nodoc
+      self.class.column_named(name.to_sym)
+    end
+
+    def has_many_columns
+      columns.map{|col| column_named(col)}.select{|col| col.type == :has_many}
+    end
+
+   def generate_belongs_to_id(class_or_column) # nodoc
+      self.class.generate_belongs_to_id(self.class)
+    end
+
+    def relation_for(col) # nodoc
       col = column_named(col)
+      related_klass = col.classify
+
       case col.type
         when :belongs_to
-          result = col.classify.find(       # for clarity, we get the class
-            @data.send(                     # and look inside it to find the
-              :[], :id                      # parent element that the current 
-            )                               # object belongs to.
-          )
-          result
+          related_klass.find(@data[:id])
         when :has_many
-          belongs_to_id = self.class.send(:belongs_to_id, self.class.to_s)
-          
-          # For has_many to work, the finder query needs the
-          # actual object, and the class of the relation
-          result = col.classify.find(belongs_to_id).belongs_to(self, col.classify).eq(    # find all elements of belongs_to 
-              @data.send(:[], :id)                                                # class that have the ID of this element       Task.find(:assignee_id).eq(3)
-            )
-          result
+          related_klass.find(generate_belongs_to_id(self.class)).belongs_to(self, related_klass).eq(@data[:id])
         else
           nil
       end
     end
-    
+
+
     # Handle attribute retrieval
-    # 
+    #
     # Gets and sets work as expected, and type casting occurs
     # For example:
-    # 
+    #
     #     Task.date = '2012-09-15'
-    # 
+    #
     # This creates a real Date object in the data store.
-    # 
+    #
     #     date = Task.date
-    # 
+    #
     # Date is a real date object.
-    def method_missing(method, *args, &block)      
-      base_method = method.to_s.gsub('=', '').to_sym
-      col = column_named(base_method)
-      raise NoMethodError.new("nil column #{method} accessed from #{caller[1]}.") if col.nil?
-
-      unless col.type == :belongs_to_id
-        Debug.error "method missing for #{base_method}"
-        has_relation = relation_for(col) if self.class.has_relation?(col)
-        return has_relation if has_relation
-      end
-      
-      unless col.nil?
-        if method.to_s.include?('=')
-          @dirty = true
-          return @data[base_method] = col.type == :belongs_to_id ? args[0] : self.cast_to_type(base_method, args[0])
-        else
-          return @data[base_method]
-        end
+    def method_missing(method, *args, &block) #nodoc
+      if self.respond_to? method
+        return method(args, &block)
       else
-        exception = NoMethodError.new(<<ERRORINFO
-method: #{method}
-args:   #{args.inspect}
-in:     #{self.class.name}
-ERRORINFO
-)
-        raise exception
+        raise NoMethodError.new("nil column #{self.class}##{method} accessed from #{caller[1]}.")
       end
     end
-
   end
 end