motion_model 0.4.2 → 0.4.4

data/.travis.yml

@@ -0,0 +1,5 @@
+language: objective-c
+before_install: ruby --version
+rvm:
+  - "1.9.3"
+script: bundle exec rake spec

data/README.md

@@ -1,15 +1,16 @@
-[![Code Climate](https://codeclimate.com/github/sxross/MotionModel.png)](https://codeclimate.com/github/sxross/MotionModel)
+[![Code Climate](https://codeclimate.com/github/sxross/MotionModel.png)](https://codeclimate.com/github/sxross/MotionModel)[![Build Status](https://travis-ci.org/sxross/MotionModel.png)](https://travis-ci.org/sxross]/MotionModel)
 
-MotionModel -- Simple Model, Validation, and Input Mixins for RubyMotion
+MotionModel: Models, Relations, and Validation for RubyMotion
 ================
 
 MotionModel is a DSL for cases where Core Data is too heavy to lift but you are
-still intending to work with your data, its types, and its relations.
+still intending to work with your data, its types, and its relations. It also provides for
+data validation and actually quite a bit more.
 
 File                 | Module                    | Description
 ---------------------|---------------------------|------------------------------------
 **ext.rb**           | N/A                       | Core Extensions that provide a few Rails-like niceties. Nothing new here, moving on...
-**model.rb**         | MotionModel::Model        | 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.
+**model.rb**         | MotionModel::Model        | You should read about it in "[What Model Can Do](#what-model-can-do)". Model is the raison d'etre and the centerpiece of MotionModel.
 **validatable.rb**   | MotionModel::Validatable  | Provides a basic validation framework for any arbitrary class. You can also create custom validations to suit your app's unique needs.
 **input_helpers**    | MotionModel::InputHelpers | Helps hook a collection up to a data form, populate the form, and retrieve the data afterwards. Note: *MotionModel supports Formotion for input handling as well as these input helpers*.
 **formotion.rb**     | MotionModel::Formotion    | Provides an interface between MotionModel and Formotion
@@ -31,7 +32,7 @@ you like with it. See the LICENSE file in this project.
 * [Problems/Comments](#problemscomments)
 * [Submissions/Patches](#submissionspatches)
 
-Most Recent Important Change
+Changes for Existing Users to Be Aware Of
 =================
 
 Please see the CHANGELOG for update on changes.
@@ -61,6 +62,8 @@ or if you are using bundler:
 gem motion_model, "0.3.8"
 ```
 
+Version 0.3.8 was the last that did not separate the model and persistence concerns.
+
 Getting Going
 ================
 
@@ -88,8 +91,15 @@ then put this in your Rakefile after requiring `motion/project`:
 require 'motion_model'
 ```
 
+If you want to use Bundler from `master`, put this in your Gemfile:
+
+```
+gem 'motion_model', :git => 'git@github.com:sxross/MotionModel.git'
+```
+
+Note that in the above construct, Ruby 1.8.x hash keys are used. That's because Apple's System Ruby is 1.8.7 and won't recognize keen new 1.9.x hash syntax.
 
-What Model Can Do
+What MotionModel Can Do
 ================
 
 You can define your models and their schemas in Ruby. For example:
@@ -100,19 +110,21 @@ class Task
   include MotionModel::ArrayModelAdapter
 
   columns :name        => :string,
-          :description => :string,
+          :long_name   => :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'
+                :long_name    => 'get plenty of exercise. pick up the poop',
+                :due_date     => '2012-09-15'
    end
 end
 ```
 
+Side note: The original documentation on this used `description` for the column that is now `long_name`. It turns out Apple reserves `description` so MotionModel saves you the trouble of finding that particular bug by not allowing you to use it for a column name.
+
 Models support default values, so if you specify your model like this, you get defaults:
 
 ```ruby
@@ -134,16 +146,16 @@ class Task
   include MotionModel::Validatable
 
   columns :name        => :string,
-          :description => :string,
+          :long_name   => :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'
+    @task = Task.new :name  => 'walk the dog',
+                 :long_name => 'get plenty of exercise. pick up the poop',
+                 :due_date  => '2012-09-15'
 
     show_scary_warning unless @task.valid?
   end

data/lib/motion_model/adapters/array_model_adapter.rb

@@ -125,17 +125,12 @@ module MotionModel
       @dirty = @new_record = false
     end
 
-
-
     # Count of objects in the current collection
     def length
       collection.length
     end
     alias_method :count, :length
 
-    def rebuild_relation_for(name, instance_or_collection) # nodoc
-    end
-
     private
 
     def _next_id
@@ -147,18 +142,21 @@ module MotionModel
       increment_next_id(options[:id])
     end
 
-    def relation_for(col) # nodoc
-      col = column_named(col)
-      related_klass = col.classify
+    def belongs_to_relation(col) # nodoc
+      col.classify.find(_get_attr(col.foreign_key))
+    end
 
-      case col.type
-        when :belongs_to
-          related_klass.find(@data[:id])
-        when :has_many
-          related_klass.find(generate_belongs_to_id(self.class)).belongs_to(self, related_klass).eq(@data[:id])
-        else
-          nil
-      end
+    def has_many_relation(col) # nodoc
+      _has_many_has_one_relation(col)
+    end
+
+    def has_one_relation(col) # nodoc
+      _has_many_has_one_relation(col)
+    end
+
+    def _has_many_has_one_relation(col) # nodoc
+      related_klass = col.classify
+      related_klass.find(col.inverse_column.foreign_key).belongs_to(self, related_klass).eq(_get_attr(:id))
     end
 
     def do_insert(options = {})

data/lib/motion_model/adapters/array_model_persistence.rb

@@ -128,7 +128,7 @@ module MotionModel
     def encodeWithCoder(coder)
       columns.each do |attr|
         # Serialize attributes except the proxy has_many and belongs_to ones.
-        unless [:belongs_to, :has_many].include? column_named(attr).type
+        unless [:belongs_to, :has_many].include? column(attr).type
           value = self.send(attr)
           unless value.nil?
             coder.encodeObject(value, forKey: attr.to_s)

data/lib/motion_model/model/column.rb

@@ -1,31 +1,51 @@
 module MotionModel
   module Model
     class Column
-      attr_accessor :name
-      attr_accessor :type
-      attr_accessor :default
-      attr_accessor :dependent
+      attr_reader :name
+      attr_reader :owner
+      attr_reader :type
+      attr_reader :options
 
-      def initialize(name = nil, type = nil, options = {})
+      OPTION_ATTRS = [:as, :conditions, :default, :dependent, :foreign_key, :inverse_of, :joined_class_name,
+          :polymorphic, :symbolize, :through]
+
+      OPTION_ATTRS.each do |key|
+        define_method(key) { @options[key] }
+      end
+
+      def initialize(owner, name = nil, type = nil, options = {})
+        raise RuntimeError.new "columns need a type declared." if type.nil?
+        @owner = owner
         @name = name
         @type = type
-        raise RuntimeError.new "columns need a type declared." if type.nil?
-        @default = options.delete :default
-        @dependent = options.delete :dependent
+        @klass = options.delete(:class)
         @options = options
       end
 
-      def options
-        @options
+      def class_name
+        joined_class_name || name
       end
 
-      def class_name
-        @options[:joined_class_name] || @name
+      def primary_key
+        :id
+      end
+
+      def foreign_name
+        as || name
+      end
+
+      def foreign_polymorphic_type
+        "#{foreign_name}_type".to_sym
+      end
+
+      def foreign_key
+        @options[:foreign_key] || "#{foreign_name.to_s.singularize}_id".to_sym
       end
 
       def classify
-        if @options[:class]
-          @options[:class]
+        fail "Column#classify indeterminate for polymorphic associations" if type == :belongs_to && polymorphic
+        if @klass
+          @klass
         else
           case @type
           when :belongs_to
@@ -43,8 +63,33 @@ module MotionModel
       end
 
       def through_class
-        Kernel::const_get(@options[:through].to_s.classify)
+        Kernel::const_get(through.to_s.classify)
+      end
+
+      def inverse_foreign_key
+        inverse_column.foreign_key
       end
+
+      def inverse_name
+        if as
+          as
+        elsif inverse_of
+          inverse_of
+        elsif type == :belongs_to
+          # Check for a singular and a plural relationship
+          name = owner.name.singularize.underscore
+          col = classify.column(name)
+          col ||= classify.column(name.pluralize)
+          col.name
+        else
+          owner.name.singularize.underscore.to_sym
+        end
+      end
+
+      def inverse_column
+        classify.column(inverse_name)
+      end
+
     end
   end
 end

data/lib/motion_model/model/formotion.rb

@@ -44,7 +44,7 @@ module MotionModel
     end
 
     def combine_options(column, hash) #nodoc
-      options = column_named(column).options[:formotion]
+      options = column(column).options[:formotion]
       options ? hash.merge(options) : hash
     end
 

data/lib/motion_model/model/model.rb

@@ -47,13 +47,19 @@ module MotionModel
     def self.included(base)
       base.extend(PrivateClassMethods)
       base.extend(PublicClassMethods)
+
+      base.instance_eval do
+        unless self.respond_to?(:id)
+          add_field(:id, :integer)
+        end
+      end
     end
 
     module PublicClassMethods
 
       def new(options = {})
         object_class = options[:inheritance_type] ? Kernel.const_get(options[:inheritance_type]) : self
-        object_class.alloc.instance_eval do
+        object_class.allocate.instance_eval do
           initialize(options)
           self
         end
@@ -130,10 +136,6 @@ module MotionModel
         add_field relation, :has_one, options        # Relation must be plural
       end
 
-      def generate_belongs_to_id(relation)
-        (relation.to_s.singularize.underscore + '_id').to_sym
-      end
-
       # Use at class level, as follows
       #
       #   class Assignee
@@ -150,13 +152,17 @@ module MotionModel
       end
 
       # Returns true if a column exists on this model, otherwise false.
-      def column?(column)
-        !column_named(column).nil?
+      def column?(col)
+        !column(col).nil?
       end
 
       # Returns type of this column.
-      def column_type(column)
-        column_named(column).type || nil
+      def column_type(col)
+        column(col).type || nil
+      end
+
+      def column(col)
+        col.is_a?(Column) ? col : _column_hashes[col.to_sym]
       end
 
       def has_many_columns
@@ -176,9 +182,9 @@ module MotionModel
       end
 
       # returns default value for this column or nil.
-      def default(column)
-        col = column_named(column)
-        col.nil? ? nil : col.default
+      def default(col)
+        _col = column(col)
+        _col.nil? ? nil : _col.default
       end
 
       # Build an instance that represents a saved object from the persistence layer.
@@ -249,8 +255,10 @@ module MotionModel
         @_column_hashes ||= {}
       end
 
+      # BUGBUG: This appears not to be executed, therefore @_issue_notifications is always nil to begin with.
       @_issue_notifications = true
       def _issue_notifications
+        @_issue_notifications = true if @_issue_notifications.nil?
         @_issue_notifications
       end
 
@@ -302,135 +310,42 @@ module MotionModel
       end
 
       def define_accessor_methods(name, type, options = {}) #nodoc
-        unless alloc.respond_to?(name.to_sym)
-          define_method(name.to_sym) {
-            return nil if @data[name].nil?
-            if options[:symbolize]
-              @data[name].to_sym
-            else
-              @data[name]
-            end
-          }
-        end
-        define_method("#{name}=".to_sym) { |value|
-          old_value = @data[name]
-          new_value = cast_to_type(name, value)
-          if new_value != old_value
-            @data[name] = new_value
-            @dirty = true
-          end
-        }
+        define_method(name.to_sym)        { _get_attr(name) } unless allocate.respond_to?(name)
+        define_method("#{name}=".to_sym)  { |v| _set_attr(name, v) }
       end
 
       def define_belongs_to_methods(name) #nodoc
-        col = column_named(name)
-
-        define_method(name) {
-          return @data[name] if @data[name]
-          if col.options[:polymorphic]
-            if (owner_class_name = send("#{name}_type"))
-              owner_class = Kernel::deep_const_get(owner_class_name.classify)
-              parent_id = send("#{name}_id")
-            end
-          else
-            owner_class = col.classify
-            parent_id = send(self.class.generate_belongs_to_id(col.name))
-          end
-          parent_id.nil? ? nil : owner_class.find_by_id(parent_id)
-        }
-
-        define_method("#{name}_relation") {
-          relation_for(name)
-        }
-
-        # Associate the parent and delegate the inverse assignment
-        define_method("#{name}=") { |parent|
-          rebuild_relation_for(name, parent)
-          send("set_#{name}", parent)
-          if col.options[:polymorphic]
-            foreign_column_name = parent.column_as_name(col.options[:as] || col.name)
-          else
-            foreign_column_name = self.class.name.underscore.to_sym
-          end
-          parent.rebuild_relation_for(foreign_column_name, self) if parent
-        }
-
-        # Associate the parent but without delegating the inverse assignment
-        define_method("set_#{name}") { |parent|
-          @data[name] = parent
-          if col.options[:polymorphic]
-            send("#{name}_type=", parent.class.name)
-            send("#{name}_id=", parent.id)
-          else
-            parent_id_name = self.class.generate_belongs_to_id(col.name)
-            send("#{parent_id_name}=", parent ? parent.id : nil)
-          end
-        }
+        col = column(name)
+        define_method(name)               { get_belongs_to_attr(col) }
+        define_method("#{name}=")         { |owner| set_belongs_to_attr(col, owner) }
 
         # TODO also define #{name}+id= methods....
 
-        if col.options[:polymorphic]
-          add_field "#{name}_type", :belongs_to_type
-          add_field "#{name}_id", :belongs_to_id
+        if col.polymorphic
+          add_field col.foreign_polymorphic_type, :belongs_to_type
+          add_field col.foreign_key,              :belongs_to_id
         else
-          add_field generate_belongs_to_id(name), :belongs_to_id    # a relation is singular.
+          add_field col.foreign_key,              :belongs_to_id    # a relation is singular.
         end
       end
 
       def define_has_many_methods(name) #nodoc
-        col = column_named(name)
-
-        define_method("#{name}_relation") {
-          relation_for(name)
-        }
-
-        define_method(name) {
-          send("#{name}_relation").to_a
-        }
-
-        define_method("#{name}=") do |collection|
-          rebuild_relation_for(name, collection)
-          collection.each do |instance|
-            if col.options[:polymorphic]
-              foreign_column_name = col.options[:as] || col.name
-            else
-              foreign_column_name = self.class.name.underscore.to_sym
-            end
-            instance.send("set_#{foreign_column_name}", self)
-            instance.rebuild_relation_for(foreign_column_name, self)
-          end
-        end
-
+        col = column(name)
+        define_method(name)               { get_has_many_attr(col) }
+        define_method("#{name}=")         { |collection| set_has_many_attr(col, *collection) }
       end
 
       def define_has_one_methods(name) #nodoc
-        col = column_named(name)
-
-        define_method("#{name}_relation") {
-          relation_for(name)
-        }
-
-        define_method(name) {
-          send("#{name}_relation").instance
-        }
-
-        define_method("#{name}=") do |instance|
-          relation_for(name).instance = instance
-          if instance
-            if col.options[:polymorphic]
-              foreign_column_name = col.options[:as] || col.name
-            else
-              foreign_column_name = self.class.name.underscore.to_sym
-            end
-            instance.rebuild_relation_for(foreign_column_name, self)
-          end
-        end
+        col = column(name)
+        define_method(name)               { get_has_one_attr(col) }
+        define_method("#{name}=")         { |instance| set_has_one_attr(col, instance) }
       end
 
       def add_field(name, type, options = {:default => nil}) #nodoc
-        col = Column.new(name, type, options)
+        name = name.to_sym
+        col = Column.new(self, name, type, options)
 
-        _column_hashes[col.name.to_sym] = col
+        _column_hashes[col.name] = col
 
         case type
           when :has_many    then define_has_many_methods(name)
@@ -440,36 +355,28 @@ module MotionModel
           end
       end
 
-      # Returns a column denoted by +name+
-      def column_named(name) #nodoc
-        _column_hashes[name.to_sym]
-      end
-
       # Returns the column that has the name as its :as option
-      def column_as(name) #nodoc
-        _column_hashes.values.find{ |c| c.options[:as] == name }
+      def column_as(col) #nodoc
+        _col = column(col)
+        _column_hashes.values.find{ |c| c.as == _col.name }
       end
 
       # All relation columns, including type and id columns for polymorphic associations
-      def relation_column?(column) #nodoc
-        [:belongs_to, :belongs_to_id, :belongs_to_type, :has_many, :has_one].include? column_named(column).type
+      def relation_column?(col) #nodoc
+        _col = column(col)
+        [:belongs_to, :belongs_to_id, :belongs_to_type, :has_many, :has_one].include?(_col.type)
       end
 
       # Polymorphic association columns that are not stored in DB
-      def virtual_polymorphic_relation_column?(column) #nodoc
-        [:belongs_to, :has_many, :has_one].include? column_named(column).type
+      def virtual_polymorphic_relation_column?(col) #nodoc
+        _col = column(col)
+        [:belongs_to, :has_many, :has_one].include?(_col.type)
       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
-        [:has_many, :has_one, :belongs_to].include?(col.type)
+        _col = column(col)
+        [:has_many, :has_one, :belongs_to].include?(_col.type)
       end
 
     end
@@ -523,7 +430,7 @@ module MotionModel
     def ==(comparison_object)
       super ||
         comparison_object.instance_of?(self.class) &&
-        id.present? &&
+        !id.nil? &&
         comparison_object.id == id
     end
     alias :eql? :==
@@ -533,7 +440,7 @@ module MotionModel
     end
 
     def attributes=(attrs)
-      attrs.each { |k, v| send("#{k}=", v) }
+      attrs.each { |k, v| set_attr(k, v) }
     end
 
     def update_attributes(attrs)
@@ -552,10 +459,14 @@ module MotionModel
       @data[:id].to_i
     end
 
-    # Default to_s implementation returns a list of columns and values
-    # separated by newlines.
+    # Default inspect implementation returns identifier and ID
+    # Need to keep this short, i.e. for running specs as the output could be very large
+    def inspect
+      object_identifier
+    end
+
     def to_s
-      columns.each{|c| "#{c}: #{self.send(c)}\n"}
+      columns.each{|c| "#{c}: #{get_attr(c)}\n"}
     end
 
     def save!(options = {})
@@ -604,6 +515,8 @@ module MotionModel
     def after_save(sender);  end
     def before_delete(sender); end
     def after_delete(sender); end
+    def before_destroy(sender); end
+    def after_destroy(sender); end
 
     def call_hook(hook_name, postfix)
       hook = "#{hook_name}_#{postfix}"
@@ -644,7 +557,7 @@ module MotionModel
         options[:omit_model_identifiers] ||= {}
         options[:omit_model_identifiers][model_identifier] = self
         self.class.association_columns.each do |name, col|
-          delete_candidates = self.send(name)
+          delete_candidates = get_attr(name)
           Array(delete_candidates).each do |candidate|
             next if options[:omit_model_identifiers][candidate.model_identifier]
             if col.dependent == :destroy
@@ -660,8 +573,12 @@ module MotionModel
     end
 
     # True if the column exists, otherwise false
-    def column?(column_name)
-      self.class.column?(column_name.to_sym)
+    def column?(col)
+      self.class.column?(col)
+    end
+
+    def column(col)
+      self.class.column(col)
     end
 
     # Returns list of column names as an array
@@ -670,8 +587,8 @@ module MotionModel
     end
 
     # Type of a given column
-    def column_type(column_name)
-      self.class.column_type(column_name)
+    def column_type(col)
+      self.class.column_type(col)
     end
 
     # Options hash for column, excluding the core
@@ -682,8 +599,8 @@ module MotionModel
     # example:
     #
     #    columns :date => {:type => :date, :formotion => {:picker_type => :date_time}}
-    def options(column_name)
-      column_named(column_name).options
+    def options(col)
+      column(col).options
     end
 
     def dirty?
@@ -694,8 +611,141 @@ module MotionModel
       @dirty = true
     end
 
-    def column_as_name(name) #nodoc
-      self.class.send(:column_as, name.to_sym).try(:name)
+    def get_attr(name)
+      send(name)
+    end
+
+    def _attr_present?(name)
+      @data.has_key?(name)
+    end
+
+    def _get_attr(col)
+      _col = column(col)
+      return nil if @data[_col.name].nil?
+      if _col.symbolize
+        @data[_col.name].to_sym
+      else
+        @data[_col.name]
+      end
+    end
+
+    def set_attr(name, value)
+      send("#{name}=", value)
+    end
+
+    def _set_attr(name, value)
+      name = name.to_sym
+      old_value = @data[name]
+      new_value = relation_column?(name) ? value : cast_to_type(name, value)
+      if new_value != old_value
+        @data[name] = new_value
+        @dirty = true
+      end
+    end
+
+    def get_belongs_to_attr(col)
+      belongs_to_relation(col)
+    end
+
+    def get_has_many_attr(col)
+      _has_many_has_one_relation(col)
+    end
+
+    def get_has_one_attr(col)
+      _has_many_has_one_relation(col)
+    end
+
+    # Associate the owner but without rebuilding the inverse assignment
+    def set_belongs_to_attr(col, owner, options = {})
+      _col = column(col)
+      unless belongs_to_synced?(_col, owner)
+        _set_attr(_col.name, owner)
+        rebuild_relation(_col, owner, set_inverse: options[:set_inverse])
+        if _col.polymorphic
+          set_polymorphic_attr(_col.name, owner)
+        else
+          _set_attr(_col.foreign_key, owner ? owner.id : nil)
+        end
+      end
+
+      owner
+    end
+
+    # Determine if the :belongs_to relationship is synchronized. Checks the instance and the DB column attributes.
+    def belongs_to_synced?(col, owner)
+      # The :belongs_to that points to the instance has changed
+      return false if get_belongs_to_attr(col) != owner
+
+      # The polymorphic reference (_type, _id) columns do not match, maybe it was just saved
+      return false if col.polymorphic && !polymorphic_attr_matches?(col, owner)
+
+      # The key reference (_id) column does not match, maybe it was just saved
+      return false if _get_attr(col.foreign_key) != owner.try(:id)
+
+      true
+    end
+
+    def push_has_many_attr(col, *instances)
+      _col = column(col)
+      collection = get_has_many_attr(_col)
+      _collection = []
+      instances.each do |instance|
+        next if collection.include?(instance)
+        _collection << instance
+      end
+      push_relation(_col, *_collection)
+      instances
+    end
+
+    # TODO clean up existing reference, check rails
+    def set_has_many_attr(col, *instances)
+      _col = column(col)
+      unload_relation(_col)
+      push_has_many_attr(_col, *instances)
+      instances
+    end
+
+    def set_has_one_attr(col, instance)
+      _col = column(col)
+      if get_has_one_attr(_col) != instance
+        rebuild_relation(_col, instance)
+      end
+      instance
+    end
+
+    def get_polymorphic_attr(col)
+      _col = column(col)
+      owner_class = nil
+      id                  = _get_attr(_col.foreign_key)
+      unless id.nil?
+        owner_class_name  = _get_attr(_col.foreign_polymorphic_type)
+        owner_class_name  = String(owner_class_name) # RubyMotion issue, String#classify might fail otherwise
+        owner_class       = Kernel::deep_const_get(owner_class_name.classify)
+      end
+      [owner_class, id]
+    end
+
+
+    def polymorphic_attr_matches?(col, instance)
+      klass, id = get_polymorphic_attr(col)
+      klass == instance.class && id == instance.id
+    end
+
+    def set_polymorphic_attr(col, instance)
+      _col = column(col)
+      _set_attr(_col.foreign_polymorphic_type,  instance.class.name)
+      _set_attr(_col.foreign_key,               instance.id)
+      instance
+    end
+
+    def foreign_column_name(col)
+      if col.polymorphic
+        col.as || col.name
+      elsif col.foreign_key
+        col.foreign_key
+      else
+        self.class.name.underscore.to_sym
+      end
     end
 
     private
@@ -716,20 +766,15 @@ module MotionModel
       self.class.send(:has_relation?, col)
     end
 
-    def initialize_data_columns(column, value) #nodoc
-      self.attributes = {column => value || self.class.default(column)}
-    end
-
-    def column_named(name) #nodoc
-      self.class.send(:column_named, name.to_sym)
+    def rebuild_relation(column_name, instance_or_collection, options = {}) # nodoc
     end
 
-    def column_as(name) #nodoc
-      self.class.send(:column_as, name.to_sym)
+    def initialize_data_columns(column, value) #nodoc
+      self.attributes = {column => value || self.class.default(column)}
     end
 
-    def generate_belongs_to_id(class_or_column) # nodoc
-      self.class.generate_belongs_to_id(self.class)
+    def column_as(col) #nodoc
+      self.class.send(:column_as, col)
     end
 
     def issue_notification(info) #nodoc
@@ -737,19 +782,8 @@ module MotionModel
     end
 
     def method_missing(sym, *args, &block)
-      if sym.to_s[-1] == '='
-        @data["#{sym.to_s.chop}".to_sym] = args.first
-        return args.first
-      else
-        return @data[sym] if @data && @data.has_key?(sym)
-      end
-      begin
-        r = super
-      rescue NoMethodError => exc
-        unless exc.to_s =~ /undefined method `(?:before|after)_/
-          raise
-        end
-      end
+      return @data[sym] if sym.to_s[-1] != '=' && @data && @data.has_key?(sym)
+      super
     end
 
   end

data/lib/motion_model/validatable.rb

@@ -60,6 +60,9 @@ module MotionModel
     # * First, it triggers validations.
     #
     # * Second, it returns the result of performing the validations.
+    def before_validation(sender); end
+    def after_validation(sender); end
+
     def valid?
       call_hooks 'validation' do
         @messages = []
@@ -181,5 +184,10 @@ module MotionModel
     def add_message(field, message)
       @messages.push({field.to_sym => message})
     end
+
+    # Stub methods for hook protocols
+    def before_validation(sender); end
+    def after_validation(sender);  end
+
   end
 end

data/lib/motion_model/version.rb

@@ -4,5 +4,5 @@
 # or forward port their code to take advantage
 # of adapters.
 module MotionModel
-  VERSION = "0.4.2"
+  VERSION = "0.4.4"
 end

data/motion_model.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = "motion_model"
   gem.require_paths = ["lib"]
-  gem.add_dependency 'bubble-wrap', '~> 1.1.4'
+  gem.add_dependency 'bubble-wrap', '1.3.0.osx'
   gem.add_dependency 'motion-support', '>=0.1.0'
   gem.version       = MotionModel::VERSION
 end

data/spec/array_model_persistence_spec.rb

@@ -205,8 +205,8 @@ end
 describe "serialization of relations" do
   before do
     parent = Parent.create(:name => 'BoB')
-    parent.children_relation.create :name => 'Fergie'
-    parent.children_relation.create :name => 'Will I Am'
+    parent.children.create :name => 'Fergie'
+    parent.children.create :name => 'Will I Am'
   end
 
   it "is wired up right" do

data/spec/cascading_delete_spec.rb

@@ -35,7 +35,7 @@ class Employee
   include MotionModel::Model
   include MotionModel::ArrayModelAdapter
   columns       :name
-  belongs_to    :CascadedAssignee
+  belongs_to    :cascaded_assignee
 end
 
 describe "cascading deletes" do
@@ -58,8 +58,8 @@ describe "cascading deletes" do
 
     it "deletes assignees that belong to a destroyed task" do
       task = CascadingTask.create(:name => 'cascading')
-      task.cascaded_assignees_relation.create(:assignee_name => 'joe')
-      task.cascaded_assignees_relation.create(:assignee_name => 'bill')
+      task.cascaded_assignees.create(:assignee_name => 'joe')
+      task.cascaded_assignees.create(:assignee_name => 'bill')
 
       CascadingTask.count.should == 1
       CascadedAssignee.count.should == 2
@@ -74,7 +74,7 @@ describe "cascading deletes" do
       1.upto(3) do |item|
         task = CascadingTask.create :name => "Task #{item}"
         1.upto(3) do |assignee|
-          task.cascaded_assignees_relation.create :assignee_name => "assignee #{assignee} for task #{task}"
+          task.cascaded_assignees.create :assignee_name => "assignee #{assignee} for task #{task}"
         end
       end
       CascadingTask.count.should == 3
@@ -88,8 +88,8 @@ describe "cascading deletes" do
 
     it "deletes only one level when a task is destroyed but dependent is delete" do
       task = CascadingTask.create :name => 'dependent => :delete'
-      assignee = task.cascaded_assignees_relation.create :assignee_name => 'deletable assignee'
-      assignee.employees_relation.create :name => 'person who sticks around'
+      assignee = task.cascaded_assignees.create :assignee_name => 'deletable assignee'
+      assignee.employees.create :name => 'person who sticks around'
 
       CascadingTask.count.should == 1
       CascadedAssignee.count.should == 1

data/spec/model_spec.rb

@@ -205,6 +205,11 @@ describe "Creating a model" do
       lambda{task.bar}.should.raise(NoMethodError)
     end
 
+    it 'raises a NoMethodError exception when an unknown attribute receives an assignment' do
+      task = Task.new
+      lambda{task.bar = 'foo'}.should.raise(NoMethodError)
+    end
+
     it 'successfully retrieves by attribute' do
       task = Task.create(:name => 'my task')
       task.name.should == 'my task'

data/spec/relation_spec.rb

@@ -39,7 +39,7 @@ describe 'related objects' do
 
     it "camelcased style" do
       t = User.create(:name => "Arkan")
-      t.email_accounts_relation.create(:name => "Gmail")
+      t.email_accounts.create(:name => "Gmail")
       EmailAccount.first.user.name.should == "Arkan"
       User.last.email_accounts.last.name.should == "Gmail"
     end
@@ -58,12 +58,12 @@ describe 'related objects' do
 
     it 'relation objects are empty on initialization' do
       a_task = Task.create
-      a_task.assignees_relation.all.should.be.empty
+      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_relation.create(:assignee_name => 'bob')
+      a_task.assignees.create(:assignee_name => 'bob')
       a_task.assignees.count.should == 1
       a_task.assignees.first.assignee_name.should == 'bob'
       Assignee.count.should == 1
@@ -81,7 +81,7 @@ describe 'related objects' do
           assignee_index = 1
           @tasks << t
           1.upto(task * 2) do |assignee|
-            @assignees << t.assignees_relation.create(:assignee_name => "employee #{assignee_index}_assignee_for_task_#{t.id}")
+            @assignees << t.assignees.create(:assignee_name => "employee #{assignee_index}_assignee_for_task_#{t.id}")
             assignee_index += 1
           end
         end
@@ -105,7 +105,7 @@ describe 'related objects' do
         assignee = Assignee.new(:assignee_name => 'Zoe')
         Task.count.should == 3
         assignee_count = Task.find(3).assignees.count
-        Task.find(3).assignees_relation.push(assignee)
+        Task.find(3).assignees.push(assignee)
         Task.find(3).assignees.count.should == assignee_count + 1
       end
 
@@ -113,7 +113,7 @@ describe 'related objects' do
 
     it "supports creating blank (empty) scratchpad associated objects" do
       task = Task.create :name => 'watch a movie'
-      assignee = task.assignees_relation.new # TODO per Rails convention, this should really be #build, not #new
+      assignee = task.assignees.new # TODO per Rails convention, this should really be #build, not #new
       assignee.assignee_name = 'Chloe'
       assignee.save
       task.assignees.count.should == 1
@@ -129,7 +129,7 @@ describe 'related objects' do
 
     it "allows a child to back-reference its parent" do
       t = Task.create(:name => "Walk the Dog")
-      t.assignees_relation.create(:assignee_name => "Rihanna")
+      t.assignees.create(:assignee_name => "Rihanna")
       Assignee.first.task.name.should == "Walk the Dog"
     end
 
@@ -143,7 +143,7 @@ describe 'related objects' do
 
       describe "basic wiring" do
         before do
-          @t1.assignees_relation << @a1
+          @t1.assignees << @a1
         end
 
         it "pushing a created assignee gives a task count of 1" do
@@ -161,7 +161,7 @@ describe 'related objects' do
 
       describe "when pushing assignees onto two different tasks" do
         before do
-          @t2.assignees_relation << @a1
+          @t2.assignees << @a1
         end
 
         it "pushing assignees to two different tasks lets the last task have the assignee (count)" do

metadata

@@ -1,61 +1,57 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: motion_model
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 4
-  - 2
-  version: 0.4.2
+version: !ruby/object:Gem::Version
+  version: 0.4.4
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Steve Ross
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-05-01 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2013-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: bubble-wrap
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 1
-        - 4
-        version: 1.1.4
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.0.osx
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: motion-support
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 1
-        - 0
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.3.0.osx
+- !ruby/object:Gem::Dependency
+  name: motion-support
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 0.1.0
   type: :runtime
-  version_requirements: *id002
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.0
 description: Simple model and validation mixins for RubyMotion
-email: 
+email:
 - sxross@gmail.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
+- .travis.yml
 - CHANGELOG
 - Gemfile
 - LICENSE
@@ -91,37 +87,31 @@ files:
 - spec/relation_spec.rb
 - spec/transaction_spec.rb
 - spec/validation_spec.rb
-has_rdoc: true
 homepage: https://github.com/sxross/MotionModel
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
+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.3.6
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Simple model and validation mixins for RubyMotion
-test_files: 
+test_files:
 - spec/adapter_spec.rb
 - spec/array_model_persistence_spec.rb
 - spec/cascading_delete_spec.rb