motion_model 0.2.3 → 0.2.4

data/README.md

@@ -187,20 +187,59 @@ Things That Work
   protocol. When you declare your columns, `MotionModel` understands how to
   serialize your data so you need take no further action.
   
-* Relations, in principle work. They are more embedded documents similar
-  to CouchDB or MongoDB. So instead of being separate tables, the embedded
-  documents are model objects contained in a collection.
+  **Warning**: As of this release, persistence will serialize only one
+  model at a time and not your entire data store. This will be fixed next.
   
-  **Relations Are Untested**. This is completely experimental, but to use
-  them, just define a column as type `:array`. Initializing these properly
-  and testing them is a high priority for me, so expect it to be addressed
-  soon.
+  * Relations now are usable, although not complete fleshed out:
+  
+  ```ruby
+  class Task
+    include MotionModel::Model
+    columns     :name => :string
+    has_many    :assignees
+  end
+  
+  class Assignee
+    include MotionModel::Model
+    columns     :assignee_name => :string
+    belongs_to  :task
+  end
+  
+  # Create a task, then create an assignee as a
+  # related object on that task
+  a_task = Task.create(:name => "Walk the Dog")
+  a_task.assignees.create(:assignee_name => "Howard")
+  
+  # See? It works.
+  a_task.assignees.assignee_name      # => "Howard"
+  Task.first.assignees.assignee_name  # => "Howard"
+  
+  # Create another assignee but don't save
+  # Add to assignees collection. Both objects
+  # are saved.
+  another_assignee = Assignee.new(:name => "Douglas")
+  a_task.assignees << another_assignee  # adds to relation and saves both objects
+  
+  # The count of assignees accurately reflects current state
+  a_task.assignees.count              # => 2
+  
+  # And backreference access through belongs_to works.
+  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.
+  
+  * delete
+  * destroy
 
 * Core extensions work. The following are supplied:
 
   - String#humanize
   - String#titleize
   - String#empty?
+  - String#singularize
+  - String#pluralize
   - NilClass#empty?
   - Array#empty?
   - Hash#empty?
@@ -214,15 +253,44 @@ Things That Work
   - Debug.info(message)
   - Debug.warning(message)
   - Debug.error(message)
+  - Debug.silence / Debug.resume to turn on and off logging
+  - Debug.colorize (true/false) for pretty console display
+  
+  Finally, there is an inflector singleton class based around the one
+  Rails has implemented. You don't need to dig around in this class
+  too much, as its core functionality is exposed through two methods:
+  
+  String#singularize
+  String#pluralize
+  
+  These work, with the caveats that 1) The inflector is English-language
+  based; 2) Irregular nouns are not handled; 3) Singularizing a singular
+  or pluralizing a plural makes for good cocktail-party stuff, but in
+  code, it mangles things pretty badly.
+  
+  You may want to get into customizing your inflections using:
+  
+  - Inflector.inflections.singular(rule, replacement)
+  - Inflector.inflections.plural(rule, replacement)
+  - Inflector.inflections.irregular(rule, replacement)
+  
+  These allow you to add to the list of rules the inflector uses when
+  processing singularize and pluralize. For each singular rule, you will
+  probably want to add a plural one. Note that order matters for rules,
+  so if your inflection is getting chewed up in one of the baked-in
+  inflections, you may have to use Inflector.inflections.reset to empty
+  them all out and build your own.
+  
+  Of particular note is Inflector.inflections.irregular. This is for words
+  that defy regular rules such as 'man' => 'men' or 'person' => 'people'.
+  Again, a reversing rule is required for both singularize and 
+  pluralize to work properly.
 
 Things In The Pipeline
 ----------------------
 
-- More tests!
 - More robust id assignment
-- Testing relations
 - Adding validations and custom validations
-- Did I say more tests?
 
 Problems/Comments
 ------------------

data/lib/motion_model/ext.rb

@@ -10,6 +10,113 @@ class String
   def empty?
     self.length < 1
   end
+  
+  def pluralize
+    Inflector.inflections.pluralize self
+  end
+  
+  def singularize
+    Inflector.inflections.singularize self
+  end
+end
+
+# Inflector is a singleton class that helps
+# singularize, pluralize and other-thing-ize
+# words. It is very much based on the Rails
+# ActiveSupport implementation or Inflector
+class Inflector
+  def self.instance
+    @__instance__ ||= new
+  end
+  
+  def initialize
+    reset
+  end
+  
+  def reset
+    @plurals = [
+      [/^(.*)ee$/i, '\1ees'],     # attendee => attendees
+      [/^(.*)us$/i, '\1i'],       # alumnus  => alumni
+      [/^(.*s)$/i, '\1es'],       # pass     => passes
+      [/^(.*)$/, '\1s']           # normal   => normals
+    ]
+
+    @singulars = [
+      [/^(.*)ees$/i, '\1ee'],     # attendees  => attendee
+      [/^(.*)es$/i, '\1'],        # passes     => pass
+      [/^(.*)i$/i, '\1us'],       # alumni     => alumnus
+      [/^(.*)s$/i, '\1']          # normals    => normal
+    ]
+    
+    @irregulars = [
+      ['person', 'people'],
+      ['people', 'person']
+    ]
+    
+    @uncountables = [
+      'fish',
+      'sheep'
+    ]
+  end
+  
+  attr_reader :plurals, :singulars, :uncountables, :irregulars
+  
+  def self.inflections
+    if block_given?
+      yield Inflector.instance
+    else
+      Inflector.instance
+    end
+  end
+      
+  def uncountable(word)
+    @uncountables << word
+  end
+  
+  def singular(rule, replacement)
+    @singulars << [rule, replacement]
+  end
+  
+  def plural(rule, replacement)
+    @plurals << [rule, replacement]
+  end
+  
+  def irregular(rule, replacement)
+    @irregulars << [rule, replacement]
+  end
+  
+  def uncountable?(word)
+    return word if @uncountables.include?(word.downcase)
+    false
+  end
+  
+  def singularize(word)
+    return word if uncountable?(word)
+    plural = word.dup
+    
+    @irregulars.each do |rule|
+      return plural if plural.gsub!(rule.first, rule.last)
+    end
+    
+    @singulars.each do |rule|
+      return plural if plural.gsub!(rule.first, rule.last)
+    end
+    plural
+  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
+    
+    @plurals.each do |rule|
+      return singular if singular.gsub!(rule.first, rule.last)
+    end
+    singular
+  end
 end
 
 class NilClass
@@ -36,8 +143,33 @@ class Symbol
   end
 end
 
+class Ansi
+  ESCAPE = "\033"
+  
+  def self.color(color_constant)
+    "#{ESCAPE}[#{color_constant}m"
+  end
+  
+  def self.reset_color
+    color 0
+  end
+  
+  def self.yellow_color
+    color 33
+  end
+  
+  def self.green_color
+    color 32
+  end
+  
+  def self.red_color
+    color 31
+  end
+end
+
 class Debug
   @@silent = false
+  @@colorize = true
   
   # Use silence if you want to keep messages from being echoed
   # to the console.
@@ -45,25 +177,36 @@ class Debug
     @@silent = true
   end
   
+  def self.colorize
+    @@colorize
+  end
+  
+  def self.colorize=(value)
+    @@colorize = value == true
+  end
+  
   # Use resume when you want messages that were silenced to
   # resume displaying.
   def self.resume
     @@silent = false
   end
   
-  def self.put_message(type, message)
-    puts("#{type} #{caller[1]}: #{message}") unless @@silent
+  def self.put_message(type, message, color = Ansi.reset_color)
+    open_color = @@colorize ? color : ''
+    close_color = @@colorize ? Ansi.reset_color : ''
+    NSLog("#{open_color}#{type} #{caller[1]}: #{message}#{close_color}") unless @@silent
   end
   
   def self.info(msg)
-    put_message 'INFO', msg
+    put_message 'INFO', msg, Ansi.green_color
   end
   
   def self.warning(msg)
-    put_message 'WARNING', msg
+    put_message 'WARNING', msg, Ansi.yellow_color
   end
   
   def self.error(msg)
-    put_message 'ERROR', msg
+    put_message 'ERROR', msg, Ansi.red_color
   end
-end
+  
+end

data/lib/motion_model/model/column.rb

@@ -17,6 +17,17 @@ module MotionModel
         @default = default || nil
       end
       alias_method :add_attribute, :add_attr
+      
+      def classify
+        case @type
+        when :belongs_to
+          @klass ||= Object.const_get @name.to_s.downcase.capitalize
+        when :has_many
+          @klass ||= Object.const_get @name.to_s.downcase.singularize.capitalize
+        else
+          raise "#{@name} is not a relation. This isn't supposed to happen."
+        end
+      end
     end
   end
 end

data/lib/motion_model/model/finder_query.rb

@@ -2,16 +2,34 @@ module MotionModel
   class FinderQuery
     attr_accessor :field_name
     
-    def initialize(*args)
+    def initialize(*args)#nodoc
       @field_name = args[0] if args.length > 1
       @collection = args.last
     end
     
+    def belongs_to(obj, klass = nil)
+      @related_object = obj
+      @klass          = klass
+      self
+    end
+    
+    # Conjunction to add conditions to query.
+    #
+    # Task.find(:name => 'bob').and(:gender).eq('M')
+    # Task.asignees.where(:assignee_name).eq('bob')
     def and(field_name)
+      # TODO: Allow for Task.assignees.where(:assignee_name => 'bob')
+
       @field_name = field_name
       self
     end
+    alias_method :where, :and
     
+    # Specifies how to sort. only ascending sort is supported in the short
+    # form. For descending, implement the block form.
+    #
+    #     Task.where(:name).eq('bob').order(:pay_grade).all  => array of bobs ascending by pay grade
+    #     Task.where(:name).eq('bob').order(:pay_grade){|o1, o2| o2 <=> o1}  => array of bobs descending by pay grade
     def order(field = nil, &block)
       if block_given?
         @collection = @collection.sort{|o1, o2| yield(o1, o2)}
@@ -22,7 +40,7 @@ module MotionModel
       self
     end
     
-    ######## relational methods ########
+    ######## relational operators ########
     def translate_case(item, case_sensitive)#nodoc
       item = item.downcase if case_sensitive === false && item.respond_to?(:downcase)
       item
@@ -38,6 +56,9 @@ module MotionModel
       self
     end
     
+    # performs a "like" query.
+    #
+    # Task.find(:work_group).contain('dev') => ['UI dev', 'Core dev', ...]
     def contain(query_string, options = {:case_sensitive => false})
       do_comparison(query_string) do |comparator, item|
         if options[:case_sensitive]
@@ -50,6 +71,22 @@ module MotionModel
     alias_method :contains, :contain
     alias_method :like, :contain
     
+    # performs a set-inclusion test.
+    #
+    # Task.find(:id).id([3, 5, 9])
+    def in(set)
+      @collection = @collection.collect do |item|
+        item if set.include?(item.send(@field_name.to_sym))
+      end.compact
+    end
+    
+    # performs strict equality comparison.
+    #
+    # If arguments are strings, they are, by default,
+    # compared case-insensitive, if case-sensitivity
+    # is required, use:
+    #
+    # eq('something', :case_sensitive => true)
     def eq(query_string, options = {:case_sensitive => false})
       do_comparison(query_string, options) do |comparator, item|
         comparator == item
@@ -58,6 +95,9 @@ module MotionModel
     alias_method :==, :eq
     alias_method :equal, :eq
     
+    # performs greater-than comparison.
+    #
+    # see `eq` for notes on case sensitivity.
     def gt(query_string, options = {:case_sensitive => false})
       do_comparison(query_string, options) do |comparator, item|
         comparator > item
@@ -66,6 +106,9 @@ module MotionModel
     alias_method :>, :gt
     alias_method :greater_than, :gt
     
+    # performs less-than comparison.
+    #
+    # see `eq` for notes on case sensitivity.
     def lt(query_string, options = {:case_sensitive => false})
       do_comparison(query_string, options) do |comparator, item|
         comparator < item
@@ -74,6 +117,9 @@ module MotionModel
     alias_method :<, :lt
     alias_method :less_than, :lt
     
+    # performs greater-than-or-equal comparison.
+    #
+    # see `eq` for notes on case sensitivity.
     def gte(query_string, options = {:case_sensitive => false})
       do_comparison(query_string, options) do |comparator, item|
         comparator >= item
@@ -82,7 +128,9 @@ module MotionModel
     alias_method :>=, :gte
     alias_method :greater_than_or_equal, :gte
     
-    
+    # performs less-than-or-equal comparison.
+    #
+    # see `eq` for notes on case sensitivity.
     def lte(query_string, options = {:case_sensitive => false})
       do_comparison(query_string, options) do |comparator, item|
         comparator <= item
@@ -91,6 +139,9 @@ module MotionModel
     alias_method :<=, :lte
     alias_method :less_than_or_equal, :lte
     
+    # performs inequality comparison.
+    #
+    # see `eq` for notes on case sensitivity.
     def ne(query_string, options = {:case_sensitive => false})
       do_comparison(query_string, options) do |comparator, item|
         comparator != item
@@ -100,14 +151,18 @@ module MotionModel
     alias_method :not_equal, :ne
     
     ########### accessor methods #########
+    
+    # returns first element that matches.
     def first
       @collection.first
     end
     
+    # returns last element that matches.
     def last
       @collection.last
     end
     
+    # returns all elements that match as an array.
     def all
       @collection
     end
@@ -120,10 +175,55 @@ module MotionModel
       raise ArgumentError.new("each requires a block") unless block_given?
       @collection.each{|item| yield item}
     end
+   
+    # returns length of the result set.
+    def length
+      @collection.length
+    end
+    alias_method :count, :length
+    
+    ################ relation support ##############
+    
+    # task.assignees.create(:name => 'bob')
+    # creates a new Assignee object on the Task object task
+    def create(options)
+      raise ArgumentError.new("Creating on a relation requires the parent be saved first.") if @related_object.nil?
+      obj = new(options)
+      obj.save
+      obj
+    end
+    
+    # task.assignees.new(:name => 'BoB')
+    # creates a new unsaved Assignee object on the Task object task
+    def new(options)
+      raise ArgumentError.new("Creating on a relation requires the parent be saved first.") if @related_object.nil?
+      
+      id_field = (@related_object.class.to_s.downcase + '_id').to_sym
+      new_obj = @klass.new(options.merge(id_field => @related_object.id))
+      
+      new_obj
+    end
     
     def length
       @collection.length
     end
     alias_method :count, :length
+    
+    # Pushes an object onto an association. For e.g.:
+    #
+    #    Task.find(3).assignees.push(assignee)
+    #
+    # This both establishes the relation and saves the related
+    # object, so make sure the related object is valid.
+    def push(object)
+      id_field = (@related_object.class.to_s.downcase + '_id=').to_sym
+      object.send(id_field, @related_object.id)
+      result = object.save
+      result ||= @related_object.save
+      result
+    end
+    alias_method :<<, :push
+    
+    
   end
 end

data/lib/motion_model/model/model.rb

@@ -43,10 +43,11 @@ module MotionModel
   module Model
     def self.included(base)
       base.extend(ClassMethods)
-      base.instance_variable_set("@_columns", [])
-      base.instance_variable_set("@_column_hashes", {})
-      base.instance_variable_set("@collection", [])
-      base.instance_variable_set("@_next_id", 1)
+      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
+      base.instance_variable_set("@collection", [])       # Actual data
+      base.instance_variable_set("@_next_id", 1)          # Next assignable id
     end
     
     module ClassMethods
@@ -101,6 +102,52 @@ module MotionModel
         end
       end
       
+      # Use at class level, as follows:
+      #
+      #   class Task
+      #     include MotionModel::Model
+      #
+      #     columns  :name, :details, :assignees
+      #     has_many :assignees
+      #
+      # Note that :assignees must be declared as a virtual attribute on the
+      # model before you can has_many on it.
+      #
+      # This enables code like:
+      #
+      #   Task.find(:due_date).gt(Time.now).first.assignees
+      #
+      # to get the people assigned to first task that is due after right now.
+      #
+      # 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
+      end
+      
+      def belongs_to_id(relation)
+        (relation.downcase + '_id').to_sym
+      end
+
+      # Use at class level, as follows
+      #
+      #   class Assignee
+      #     include MotionModel::Model
+      #
+      #     columns :assignee_name, :department
+      #     belongs_to :task
+      #
+      # Allows code like this:
+      #
+      #   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]
@@ -135,7 +182,17 @@ module MotionModel
       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')
@@ -161,6 +218,7 @@ module MotionModel
       # Empties the entire store.
       def delete_all
         @collection = [] # TODO: Handle cascading or let GC take care of it.
+        @_next_id = 1
         @collection.compact!
       end
 
@@ -180,7 +238,7 @@ module MotionModel
         end
         
         unless args[0].is_a?(Symbol) || args[0].is_a?(String)
-          return @collection[args[0].to_i] || nil
+          return @collection.select{|c| c.id == args[0].to_i}.first || nil
         end
         
         FinderQuery.new(args[0].to_sym, @collection)
@@ -224,7 +282,7 @@ module MotionModel
       @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 = "yyyy-MM-dd HH:mm"
+      @cached_date_formatter.dateFormat = "MM-dd-yyyy HH:mm"
 
       unless options[:id]
         options[:id] = self.class.next_id
@@ -234,9 +292,15 @@ module MotionModel
       end
 
       columns.each do |col|
-        options[col] ||= self.class.default(col)
-        cast_value = cast_to_type(col, options[col])
-        @data[col] = cast_value
+        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
+        else
+          if column_named(col).type == :belongs_to_id
+            @data[col] = options[col]
+          end
+        end
       end
       
       dirty = true
@@ -264,7 +328,7 @@ module MotionModel
     end
 
     def to_s
-      columns.each{|c| "#{c}: #{self.send(c)}"}
+      columns.each{|c| "#{c}: #{self.send(c)}\n"}
     end
 
     def save
@@ -318,6 +382,32 @@ module MotionModel
       @dirty      
     end
     
+    def relation_for(col)
+      # relation is a belongs_to or a has_many
+      case col.type
+        when :belongs_to
+          # column = col.match(/^(.*)_id$/)
+          # column = column[0] if column.length > 1
+          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
+        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
+        else
+          nil
+      end
+    end
+    
     # Handle attribute retrieval
     # 
     # Gets and sets work as expected, and type casting occurs
@@ -330,15 +420,21 @@ module MotionModel
     #     date = Task.date
     # 
     # Date is a real date object.
-    def method_missing(method, *args, &block)
+    def method_missing(method, *args, &block)      
       base_method = method.to_s.gsub('=', '').to_sym
       
       col = column_named(base_method)
+      raise RuntimeError.new("nil column #{method} accessed.") if col.nil?
+
+      unless col.type == :belongs_to_id
+        has_relation = relation_for(col) if self.class.has_relation?(col)
+        return has_relation if has_relation
+      end
       
       if col
         if method.to_s.include?('=')
           @dirty = true
-          return @data[base_method] = self.cast_to_type(base_method, args[0])
+          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
@@ -353,4 +449,3 @@ ERRORINFO
 
   end
 end
-

data/lib/motion_model/version.rb

@@ -1,3 +1,3 @@
 module MotionModel
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/spec/ext_spec.rb

@@ -0,0 +1,57 @@
+describe 'Extensions' do
+  describe 'Pluralization' do
+    it 'pluralizes a normal word: dog' do
+      Inflector.inflections.pluralize('dog').should == 'dogs'
+    end
+  
+    it 'pluralizes words that end in "s": pass' do
+      Inflector.inflections.pluralize('pass').should == 'passes'
+    end
+    
+    it "pluralizes words that end in 'us'" do
+      Inflector.inflections.pluralize('alumnus').should == 'alumni'
+    end
+    
+    it "pluralizes words that end in 'ee'" do
+      Inflector.inflections.pluralize('attendee').should == 'attendees'
+    end
+  end
+  
+  describe 'Singularization' do
+    it 'singularizes a normal word: "dogs"' do
+      Inflector.inflections.singularize('dogs').should == 'dog'
+    end
+    
+    it "singualarizes a word that ends in 's': passes" do
+      Inflector.inflections.singularize('passes').should == 'pass'
+    end
+    
+    it "singualarizes a word that ends in 'ee': assignees" do
+      Inflector.inflections.singularize('assignees').should == 'assignee'
+    end
+    
+    it "singualarizes words that end in 'us'" do
+      Inflector.inflections.singularize('alumni').should == 'alumnus'
+    end
+  end
+  
+  describe 'Irregular Patterns' do
+    it "handles person to people singularizing" do
+      Inflector.inflections.singularize('people').should == 'person'
+    end
+
+    it "handles person to people pluralizing" do
+      Inflector.inflections.singularize('person').should == 'people'
+    end
+  end
+  
+  describe 'Adding Rules to Inflector' do
+    it 'accepts new rules' do
+      Inflector.inflections.irregular /^foot$/, 'feet'
+      Inflector.inflections.irregular /^feet$/, 'foot'
+      Inflector.inflections.pluralize('foot').should == 'feet'
+      Inflector.inflections.singularize('feet').should == 'foot'
+    end
+  end
+end
+

data/spec/model_spec.rb

@@ -180,6 +180,20 @@ describe "Creating a model" do
         found_task = Task.where(:details).contain("s 1").first.details.should == 'details 1'
       end
       
+      it "performs set inclusion(in) queries" do
+        class InTest
+          include MotionModel::Model
+          columns :name
+        end
+        
+        1.upto(10) do |i|
+          InTest.create(:id => i, :name => "test #{i}")
+        end
+        
+        results = InTest.find(:id).in([3, 5, 7])
+        results.length.should == 3
+      end
+      
       it 'handles case-sensitive queries' do
         task = Task.create :name => 'Bob'
         Task.find(:name).eq('bob', :case_sensitive => true).all.length.should == 0

data/spec/relation_spec.rb

@@ -0,0 +1,92 @@
+class Assignee
+  include MotionModel::Model
+  columns :assignee_name => :string
+  belongs_to :task
+end
+
+class Task
+  include MotionModel::Model
+  columns       :name => :string, 
+  							:details => :string,
+  							:some_day => :date
+  has_many :assignees
+end
+
+
+Inflector.inflections.irregular 'assignees', 'assignee'
+Inflector.inflections.irregular 'assignee', 'assignees'
+
+describe 'related objects' do
+  describe 'has_many' do
+    it "is wired up right" do
+      lambda {Task.new}.should.not.raise
+      lambda {Task.new.assignees}.should.not.raise
+    end
+  
+    it 'relation objects are empty on initialization' do
+      a_task = Task.create
+      a_task.assignees.all.should.be.empty
+    end
+    
+    it "supports creating related objects directly on parents" do
+      a_task = Task.create(:name => 'Walk the Dog')
+      a_task.assignees.create(:assignee_name => 'bob')
+      a_task.assignees.length.should == 1
+      a_task.assignees.first.assignee_name.should == 'bob'
+      Assignee.count.should == 1
+    end
+    
+    describe "supporting has_many" do
+      before do
+        Task.delete_all
+        Assignee.delete_all
+      
+        @tasks = []
+        @assignees = []
+        1.upto(3) do |task|
+          t = Task.create(:name => "task #{task}")
+          assignee_index = 1
+          @tasks << t
+          1.upto(task * 2) do |assignee|
+            @assignees << t.assignees.create(:assignee_name => "employee #{assignee_index}_assignee_for_task_#{t.id}")
+            assignee_index += 1
+          end
+        end
+      end
+
+      it "is wired up right" do
+        Task.count.should == 3
+        Assignee.count.should == 12        
+      end
+      
+      it "has 2 assignees for the first task" do
+        Task.first.assignees.count.should == 2
+      end
+      
+      it "the first assignee for the second task is employee 7" do
+        Task.find(2).name.should == @tasks[1].name
+        Task.find(2).assignees.first.assignee_name.should == @assignees[2].assignee_name
+      end
+    end
+    
+    it 'supports adding related objects to parents' do
+      assignee = Assignee.new(:assignee_name => 'Zoe')
+      assignee_count = Task.find(3).assignees.count
+      Task.find(3).assignees.push(assignee)
+      Task.find(3).assignees.count.should == assignee_count + 1
+    end
+  end
+  
+  describe "supporting belongs_to" do
+    before do
+      Task.delete_all
+      Assignee.delete_all
+    end
+
+    it "allows a child to back-reference its parent" do
+      t = Task.create(:name => "Walk the Dog")
+      t.assignees.create(:assignee_name => "Rihanna")
+      Assignee.first.task.name.should == "Walk the Dog"
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: motion_model
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-13 00:00:00.000000000 Z
+date: 2012-09-22 00:00:00.000000000 Z
 dependencies: []
 description: Simple model and validation mixins for RubyMotion
 email:
@@ -33,8 +33,10 @@ files:
 - lib/motion_model/validatable.rb
 - lib/motion_model/version.rb
 - motion_model.gemspec
+- spec/ext_spec.rb
 - spec/model_spec.rb
 - spec/persistence_spec.rb
+- spec/relation_spec.rb
 homepage: https://github.com/sxross/MotionModel
 licenses: []
 post_install_message: 
@@ -60,5 +62,7 @@ signing_key:
 specification_version: 3
 summary: Simple model and validation mixins for RubyMotion
 test_files:
+- spec/ext_spec.rb
 - spec/model_spec.rb
 - spec/persistence_spec.rb
+- spec/relation_spec.rb