motion_model 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9fa1c9fe578bfec914279fad0ced2ff4f6df49a1
-  data.tar.gz: 9952292bdef965d7ab76ab1f8a8c906a2f69fd67
+  metadata.gz: df4d3bdf11fc759be47d10723d1f84ddae0e43fb
+  data.tar.gz: 2624cbb78924e42b3c2d1e008f2c4e75f2427598
 SHA512:
-  metadata.gz: 41cb26133a685d546300513985f57e41fa58b4b8eb678689311d2b23bfddb6d9394d66f6f849ad4faff27369f3f95945c1525dcd7fa0105dfd801812236f2c8f
-  data.tar.gz: 8a1a29e8a90468f7392b1c9f54281fa3038956ad8776be4e668d5286057fbc164af9d25ca6b59efefdf2b0eb0daedff3481506264d33e9831fc64a1105d70d41
+  metadata.gz: 8e77f43b0997215ae37c366d2a5eb8f69c27cebe40bc5902dcd0c07c219d9a2e31120c0bb7da6859d530779f934c034e98819351696649dbb7c691d9c4dd6627
+  data.tar.gz: 45029f00583ddbb5e839d5ba173c0228d8e4ddad0bb87773c4adf92c761df3949ad79679fe0c9c21e4c30ff7ab46bb85454606584624efccc22b875ee8c9558a

data/README.md

@@ -10,7 +10,7 @@ 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 should read about it in "[What Model Can Do](#what-model-can-do)". Model is the raison d'etre and the centerpiece of MotionModel.
+**model.rb**         | MotionModel::Model        | You should read about it in "[What MotionModel Can Do](#what-motionmodel-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
@@ -21,7 +21,7 @@ you like with it. See the LICENSE file in this project.
 
 * [Getting Going](#getting-going)
 * [Bugs, Features, and Issues, Oh My!](#bugs-features-and-issues-oh-my)
-* [What Model Can Do](#what-model-can-do)
+* [What MotionModel Can Do](#what-motionmodel-can-do)
 * [Model Data Types](#model-data-types)
 * [Validation Methods](#validation-methods)
 * [Model Instances and Unique IDs](#model-instances-and-unique-ids)
@@ -274,6 +274,65 @@ Currently supported types are:
 You are really not encouraged to stuff big things in your models, which is why a blob type
 is not implemented. The smaller your data, the less overhead involved in saving/loading.
 
+### User Defined Types
+
+*New as of 0.6*: THIS FEATURE IS EXPERIMENTAL. You can use a class name instead of the
+symbols to specify your types. Thus, you can choose more complex types in much the same
+way as you might in a NOSQL database. Consider these examples:
+
+```ruby
+class Address
+  include MotionModel::Model
+  include MotionModel::ArrayModelAdapter
+  columns street:     String,
+          city:       String,
+          state:      String,
+          zip:        Integer
+end
+
+class Person
+  include MotionModel::Model
+  include MotionModel::ArrayModelAdapter
+
+  columns   name:     String,
+            address:  Address
+end
+```
+
+You can now use this `Person` class as follows:
+
+```ruby
+p = Person.find(:name).eq('Laurent').first
+p.address.country = 'Belgium'
+p.save
+```
+
+> **Note** Address includes all the MotionModel goodness. That is so that any class that embeds it can also persist it. You may be able to get away with defining `encodeWithCoder(coder)` and `initWithCoder(coder)` -- it's your choice, but not currently supported.
+
+### Native Ruby Types
+
+You can also use native Ruby types (limited to those supported by RubyMotion so no `DateTime`):
+
+```ruby
+class Person
+  include MotionModel::Model
+  include MotionModel::ArrayModelAdapter
+
+  columns   name:     String,
+            address:  Hash
+end
+```
+
+and you can use the class as follows:
+
+```ruby
+Person.create(name: 'Miss Piggy', address: {street: '111 Swine Ave', city: 'Muppetville', state: 'IN'})
+```
+
+etc.
+
+> Special note: This is a bleeding edge feature as of 0.6, and because of the semantics of copying in Ruby, there are some deep copy situations that may cause objects to be copied or updated incompletely. These should create 100% reproducible bugs in your code so they should not sneak up on you. Nevertheless, understand that the guarantee is a shallow copy. Tests show that an array inside a class copies properly. YMMV.
+
 ### Special Columns
 
 The two column names, `created_at` and `updated_at` will be adjusted automatically if they

data/motion/date_parser.rb

@@ -1,5 +1,6 @@
 module DateParser
   @@isoDateFormatter = nil
+  @@detector = nil
 
   # Parse a date string: E.g.:
   #
@@ -58,6 +59,16 @@ module DateParser
     date = @@isoDateFormatter.dateFromString date_string
     return date
   end
+
+  def self.allocate_data_detector
+    error = Pointer.new(:object)
+    @@detector = NSDataDetector.dataDetectorWithTypes(NSTextCheckingTypeDate, error:error)
+  end
+
+  def self.detector
+    allocate_data_detector if @@detector.nil?
+    return @@detector
+  end
 end
 
 

data/motion/model/model.rb

@@ -317,7 +317,7 @@ module MotionModel
           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
+          when Symbol, String, Class
             add_field(name, options)
           when Hash
             add_field(name, options.delete(:type), options)
@@ -448,6 +448,10 @@ module MotionModel
       "#{self.class.name}##{id}"
     end
 
+    def motion_model?
+      true
+    end
+
     def new_record?
       @new_record
     end
@@ -486,6 +490,11 @@ module MotionModel
       @data[name]
     end
 
+    def write_attribute(attr_name, value)
+      @data[attr_name] = value
+      @dirty = true
+    end
+
     # Default to_i implementation returns value of id column, much as
     # in Rails.
 
@@ -825,7 +834,7 @@ module MotionModel
       when Symbol
         {column => self.send(column)}
       else
-        {column => default}
+        {column => (value.nil? ? default : value)}
       end
     end
 

data/motion/model/model_casts.rb

@@ -44,6 +44,42 @@ module MotionModel
       String(arg)
     end
 
+    def cast_to_arbitrary_class(arg, klass)
+      # This little oddity is because a number of built-in
+      # Ruby classes cannot be dup'ed. Not only that, they
+      # respond_to?(:dup) but raise an exception when you
+      # actually do it. Not only that, the behavior can be
+      # different depending on architecture (32- versus 64-bit).
+      #
+      # This is Ruby, folks, not just RubyMotion.
+      #
+      # We don't have to worry if it's a MotionModel, because
+      # using a reference to the data is ok. The by-reference
+      # copy is fine.
+
+      return arg if arg.respond_to?(:motion_model?)
+
+      # Another case is where there is a predefined cast rule
+      # on the type declared as a class level method motion_model_cast:
+
+      if klass.respond_to?(:motion_model_cast)
+        return klass.send(:motion_model_cast, arg)
+      end
+
+      # But if it is not a MotionModel, we either need to dup
+      # it (for most cases), or just assign it (for built-in
+      # types like Integer, Fixnum, Float, NilClass, etc.)
+
+      result = nil
+      begin
+        result = arg.dup
+      rescue
+        result = arg
+      end
+
+      result
+    end
+
     def cast_to_type(column_name, arg) #nodoc
       return nil if arg.nil? && ![ :boolean, :bool ].include?(column_type(column_name))
 
@@ -56,9 +92,11 @@ module MotionModel
       when :text then cast_to_string(arg)
       when :array then cast_to_array(arg)
       when :hash then cast_to_hash(arg)
+      when Class then cast_to_arbitrary_class(arg, column_type(column_name))
       else
         raise ArgumentError.new("type #{column_name} : #{column_type(column_name)} is not possible to cast.")
       end
     end
   end
 end
+

data/motion/version.rb

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

data/spec/date_spec.rb

@@ -66,6 +66,13 @@ describe "time conversions" do
     end
   end
 
+  describe "date parser data detector reuse" do
+    it "creates a data detector if none is present" do
+      DateParser.class_variable_get(:@@detector).should.be.nil
+      DateParser.detector.class.should == NSDataDetector
+    end
+  end
+
   describe "parsing ISO8601 date formats" do
     class Model
       include MotionModel::Model

data/spec/model_casting_spec.rb

@@ -22,7 +22,7 @@ describe 'Type casting' do
     @convertible.a_date = '2012-09-15'
     @convertible.an_array = 1..10
   end
-  
+
   it 'does the type casting on instantiation' do
     @convertible.a_boolean.should.is_a FalseClass
     @convertible.an_int.should.is_a Integer
@@ -108,7 +108,7 @@ describe 'Type casting' do
   it 'returns a NSDate for a date field' do
     @convertible.a_date.should.is_a(NSDate)
   end
-  
+
   it 'the date field should be the same as it was in string form' do
     @convertible.a_date.to_s.should.match(/^2012-09-15/)
   end
@@ -125,4 +125,125 @@ describe 'Type casting' do
   it 'the array field should be the same as the range form' do
     (@convertible.an_array.first..@convertible.an_array.last).should.equal(1..10)
   end
+
+  describe 'can cast to an arbitrary type' do
+    class HasArbitraryTypes
+      include MotionModel::Model
+      include MotionModel::ArrayModelAdapter
+      columns name: String,
+              properties: Hash
+    end
+
+    class EmbeddedAddress
+      include MotionModel::Model
+      include MotionModel::ArrayModelAdapter
+      columns     street: String,
+                  city:   String,
+                  state:  String,
+                  zip:    Integer,
+                  pets:   Array
+      # attr_accessor :street
+      # attr_accessor :city
+      # attr_accessor :state
+      # attr_accessor :zip
+      # attr_accessor :pets
+
+      # def initialize(options = {})
+      #   @street = options[:street] if options[:street]
+      #   @city = options[:city] if options[:city]
+      #   @state = options[:state] if options[:state]
+      #   @zip = options[:zip] if options[:zip]
+      #   @pets = options[:pets] if options[:pets]
+      # end
+    end
+
+    class EmbeddingClass
+      include MotionModel::Model
+      include MotionModel::ArrayModelAdapter
+      columns name: String,
+              address: EmbeddedAddress,
+              pets: Array
+    end
+
+    before do
+      EmbeddingClass.delete_all
+      HasArbitraryTypes.delete_all
+    end
+
+    it "creation works" do
+      arb = HasArbitraryTypes.create(name: 'A Name', properties: {address: '123 Main Street', city: 'Seattle', state: 'WA'})
+      arb.name.should == 'A Name'
+      arb.properties.class.should == Hash
+      arb.properties[:address].should == '123 Main Street'
+    end
+
+    it "updating works" do
+      HasArbitraryTypes.create(name: 'Another Name', properties: {address: '123 Main Street', city: 'Seattle', state: 'WA'})
+      arb = HasArbitraryTypes.first
+      arb.properties[:address] = '234 Main Street'
+      arb.save
+      arb.properties[:address].should == '234 Main Street'
+      arb = HasArbitraryTypes.find(:name).eq('Another Name').first
+      arb.properties[:address].should == '234 Main Street'
+    end
+
+    it "creating objects with embedded documents works" do
+      addr = EmbeddedAddress.new(street: '2211 First', city: 'Seattle', state: 'WA', zip: 98104)
+      emb = EmbeddingClass.create(name: 'On Class', address: addr)
+      emb.address.class.should == EmbeddedAddress
+      emb.address.street.should == '2211 First'
+    end
+
+    it "copies embedded types" do
+      addr = EmbeddedAddress.new(street: '2211 First', city: 'Seattle', state: 'WA', zip: 98104, pets: ['rover', 'fido', 'barney'])
+      emb = EmbeddingClass.create(name: 'On Class', address: addr)
+      emb.address.pets.class.should == Array
+      emb.address.pets.should.include?('barney')
+      EmbeddingClass.first.address.pets.should.include?('barney')
+    end
+
+    it "updates embedded types" do
+      addr = EmbeddedAddress.new(street: '3322 First', city: 'Seattle', state: 'WA', zip: 98104, pets: ['rover', 'fido', 'barney'])
+      emb = EmbeddingClass.create(name: 'On Class', address: addr)
+      emb.address.pets.should.include?('barney')
+      found = EmbeddingClass.find(:name).eq('On Class').first
+      found.address.pets.should.include?('barney')
+      found.address.pets.delete('barney')
+      found.save
+      EmbeddingClass.find(:name).eq('On Class').first.address.pets.should.not.include?('barney')
+    end
+
+    it "serializes with arbitrary Ruby types without error" do
+      HasArbitraryTypes.create(name: 'A Name', properties: {address: '123 Main Street', city: 'Seattle', state: 'WA'})
+      lambda{HasArbitraryTypes.serialize_to_file('test.dat')}.should.not.raise
+    end
+
+    it "deserializes arbitrary Ruby types with correct values" do
+      HasArbitraryTypes.create(name: 'A Name', properties: {address: '123 Main Street', city: 'Seattle', state: 'WA'})
+      HasArbitraryTypes.serialize_to_file('test.dat')
+      HasArbitraryTypes.deserialize_from_file('test.dat')
+      result = HasArbitraryTypes.find(:name).eq('A Name').first
+      result.should.not.be.nil
+      result.properties.class.should == Hash
+      result.properties[:city].should == 'Seattle'
+    end
+
+    it "serializes arbitrary user-defined classes without error" do
+      addr = EmbeddedAddress.new(street: '2211 First', city: 'Seattle', state: 'WA', zip: 98104)
+      emb = EmbeddingClass.create(name: 'On Class', address: addr)
+      lambda{EmbeddingClass.serialize_to_file('test.dat')}.should.not.raise
+    end
+
+    it "deserializes arbitrary user-defined classes with correct values" do
+      addr = EmbeddedAddress.new(street: '2211 First', city: 'Seattle', state: 'WA', zip: 98104, pets: ['Katniss', 'Peeta'])
+      emb = EmbeddingClass.create(name: 'On Class', address: addr)
+      lambda{EmbeddingClass.serialize_to_file('test.dat')}.should.not.raise
+      EmbeddingClass.deserialize_from_file('test.dat')
+      result = EmbeddingClass.find(:name).eq('On Class').first
+      result.should.not.be.nil
+      result.address.class.should == EmbeddedAddress
+      result.address.city.should == 'Seattle'
+      result.address.pets.should.include?('Katniss')
+    end
+  end
 end

data/spec/model_spec.rb

@@ -1,21 +1,31 @@
-class Task
+class ModelSpecTask
   include MotionModel::Model
   include MotionModel::ArrayModelAdapter
   columns       :name => :string,
   							:details => :string,
-  							:some_day => :date
+  							:some_day => :date,
+                :enabled => {:type => :boolean, :default => false}
 
   def custom_attribute_by_method
     "#{name} - #{details}"
   end
 end
 
-class ATask
+class AModelSpecTask
   include MotionModel::Model
   include MotionModel::ArrayModelAdapter
   columns :name, :details, :some_day
 end
 
+class BModelSpecTask
+  include MotionModel::Model
+  include MotionModel::ArrayModelAdapter
+  columns :name, :details
+  def details=(value)
+    write_attribute(:details, "overridden")
+  end
+end
+
 class TypeCast
   include MotionModel::Model
   include MotionModel::ArrayModelAdapter
@@ -32,16 +42,16 @@ end
 describe "Creating a model" do
   describe 'column macro behavior' do
     before do
-      Task.delete_all
+      ModelSpecTask.delete_all
     end
 
     it 'succeeds when creating a valid model from attributes' do
-      a_task = Task.new(:name => 'name', :details => 'details')
+      a_task = ModelSpecTask.new(:name => 'name', :details => 'details')
       a_task.name.should.equal('name')
     end
 
     it 'creates a model with all attributes even if some omitted' do
-      atask = Task.create(:name => 'bob')
+      atask = ModelSpecTask.create(:name => 'bob')
       atask.should.respond_to(:details)
     end
 
@@ -49,175 +59,185 @@ describe "Creating a model" do
       a_type_test = TypeCast.new
       a_type_test.an_int.should.equal(3)
     end
+    
+    it "on initialization uses supplied value instead of default value, if supplied" do
+      a_task = ModelSpecTask.new(:enabled => true)
+      a_task.enabled.should.be.true
+    end
+        
+    it "on creation uses supplied value instead of default value, if supplied" do
+      a_task = ModelSpecTask.create(:enabled => true)
+      a_task.enabled.should.be.true
+    end
 
     it "can check for a column's existence on a model" do
-      Task.column?(:name).should.be.true
+      ModelSpecTask.column?(:name).should.be.true
     end
 
     it "can check for a column's existence on an instance" do
-      a_task = Task.new(:name => 'name', :details => 'details')
+      a_task = ModelSpecTask.new(:name => 'name', :details => 'details')
       a_task.column?(:name).should.be.true
     end
 
     it "gets a list of columns on a model" do
-      cols = Task.columns
+      cols = ModelSpecTask.columns
       cols.should.include(:name)
       cols.should.include(:details)
     end
 
     it "gets a list of columns on an instance" do
-      a_task = Task.new
+      a_task = ModelSpecTask.new
       cols = a_task.columns
       cols.should.include(:name)
       cols.should.include(:details)
     end
 
     it "columns can be specified as a Hash" do
-      lambda{Task.new}.should.not.raise
-      Task.new.column?(:name).should.be.true
+      lambda{ModelSpecTask.new}.should.not.raise
+      ModelSpecTask.new.column?(:name).should.be.true
     end
 
     it "columns can be specified as an Array" do
-      lambda{ATask.new}.should.not.raise
-      Task.new.column?(:name).should.be.true
+      lambda{AModelSpecTask.new}.should.not.raise
+      ModelSpecTask.new.column?(:name).should.be.true
     end
 
     it "the type of a column can be retrieved" do
-      Task.new.column_type(:some_day).should.equal(:date)
+      ModelSpecTask.new.column_type(:some_day).should.equal(:date)
     end
 
   end
 
   describe "ID handling" do
     before do
-      Task.delete_all
+      ModelSpecTask.delete_all
     end
 
 
     it 'creates an id if none present' do
-      task = Task.create
+      task = ModelSpecTask.create
       task.should.respond_to(:id)
     end
 
     it 'does not overwrite an existing ID' do
-      task = Task.create(:id => 999)
+      task = ModelSpecTask.create(:id => 999)
       task.id.should.equal(999)
     end
 
     it 'creates multiple objects with unique ids' do
-      Task.create.id.should.not.equal(Task.create.id)
+      ModelSpecTask.create.id.should.not.equal(ModelSpecTask.create.id)
     end
 
   end
 
   describe 'count and length methods' do
     before do
-      Task.delete_all
+      ModelSpecTask.delete_all
     end
 
     it 'has a length method' do
-      Task.should.respond_to(:length)
+      ModelSpecTask.should.respond_to(:length)
     end
 
     it 'has a count method' do
-      Task.should.respond_to(:count)
+      ModelSpecTask.should.respond_to(:count)
     end
 
     it 'when there is one element, length returns 1' do
-      task = Task.create
-      Task.length.should.equal(1)
+      task = ModelSpecTask.create
+      ModelSpecTask.length.should.equal(1)
     end
 
     it 'when there is one element, count returns 1' do
-      task = Task.create
-      Task.count.should.equal(1)
+      task = ModelSpecTask.create
+      ModelSpecTask.count.should.equal(1)
     end
 
     it 'instance variables have access to length and count' do
-      task = Task.create
+      task = ModelSpecTask.create
       task.length.should.equal(1)
       task.count.should.equal(1)
     end
 
     it 'when there is more than one element, length returned is correct' do
-      10.times { Task.create }
-      Task.length.should.equal(10)
+      10.times { ModelSpecTask.create }
+      ModelSpecTask.length.should.equal(10)
     end
 
   end
 
   describe 'adding or updating' do
     before do
-      Task.delete_all
+      ModelSpecTask.delete_all
     end
 
     it 'adds to the collection when a new task is saved' do
-      task = Task.new
-      lambda{task.save}.should.change{Task.count}
+      task = ModelSpecTask.new
+      lambda{task.save}.should.change{ModelSpecTask.count}
     end
 
     it 'does not add to the collection when an existing task is saved' do
-      task = Task.create(:name => 'updateable')
+      task = ModelSpecTask.create(:name => 'updateable')
       task.name = 'updated'
-      lambda{task.save}.should.not.change{Task.count}
+      lambda{task.save}.should.not.change{ModelSpecTask.count}
     end
 
     it 'updates data properly' do
-      task = Task.create(:name => 'updateable')
+      task = ModelSpecTask.create(:name => 'updateable')
       task.name = 'updated'
-      Task.where(:name).eq('updated').should == 0
-      lambda{task.save}.should.change{Task.where(:name).eq('updated')}
+      ModelSpecTask.where(:name).eq('updated').should == 0
+      lambda{task.save}.should.change{ModelSpecTask.where(:name).eq('updated')}
     end
   end
 
   describe 'deleting' do
     before do
-      Task.delete_all
-      Task.bulk_update do
-        1.upto(10) {|i| Task.create(:name => "task #{i}")}
+      ModelSpecTask.delete_all
+      ModelSpecTask.bulk_update do
+        1.upto(10) {|i| ModelSpecTask.create(:name => "task #{i}")}
       end
     end
 
     it 'deletes a row' do
-      target = Task.find(:name).eq('task 3').first
+      target = ModelSpecTask.find(:name).eq('task 3').first
       target.should.not == nil
       target.delete
-      Task.find(:name).eq('task 3').count.should.equal 0
+      ModelSpecTask.find(:name).eq('task 3').count.should.equal 0
     end
 
     it 'deleting a row changes length' do
-      target = Task.find(:name).eq('task 2').first
-      lambda{target.delete}.should.change{Task.length}
+      target = ModelSpecTask.find(:name).eq('task 2').first
+      lambda{target.delete}.should.change{ModelSpecTask.length}
     end
 
     it 'undeleting a row restores it' do
-      target = Task.find(:name).eq('task 3').first
+      target = ModelSpecTask.find(:name).eq('task 3').first
       target.should.not == nil
       target.delete
       target.undelete
-      Task.find(:name).eq('task 3').count.should.equal 1
+      ModelSpecTask.find(:name).eq('task 3').count.should.equal 1
     end
   end
 
   describe 'Handling Attribute Implementation' do
     it 'raises a NoMethodError exception when an unknown attribute it referenced' do
-      task = Task.new
+      task = ModelSpecTask.new
       lambda{task.bar}.should.raise(NoMethodError)
     end
 
     it 'raises a NoMethodError exception when an unknown attribute receives an assignment' do
-      task = Task.new
+      task = ModelSpecTask.new
       lambda{task.bar = 'foo'}.should.raise(NoMethodError)
     end
 
     it 'successfully retrieves by attribute' do
-      task = Task.create(:name => 'my task')
+      task = ModelSpecTask.create(:name => 'my task')
       task.name.should == 'my task'
     end
 
     describe "dirty" do
       before do
-        @new_task = Task.new
+        @new_task = ModelSpecTask.new
       end
 
       it 'marks a new object as dirty' do
@@ -246,8 +266,8 @@ describe "Creating a model" do
 
   describe 'defining custom attributes' do
     before do
-      Task.delete_all
-      @task = Task.create :name => 'Feed the Cat', :details => 'Get food, pour out'
+      ModelSpecTask.delete_all
+      @task = ModelSpecTask.create :name => 'Feed the Cat', :details => 'Get food, pour out'
     end
 
     it 'uses a custom attribute by method' do
@@ -255,6 +275,25 @@ describe "Creating a model" do
     end
   end
 
+  describe 'overloading accessors using write_attribute' do
+    before do
+      BModelSpecTask.delete_all
+    end
+
+    it 'updates the attribute on creation' do
+      @task = BModelSpecTask.create :name => 'foo', :details => 'bar'
+      @task.details.should.equal('overridden')
+      @task.should.not.be.dirty
+    end
+
+    it 'updates the attribute but does not save a new instance' do
+      @task = BModelSpecTask.new :name => 'foo', :details => 'bar'
+      @task.details.should.equal('overridden')
+      @task.should.be.dirty
+    end
+
+  end
+
   describe 'protecting timestamps' do
     class NoTimestamps
       include MotionModel::Model

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion_model
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Steve Ross
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-24 00:00:00.000000000 Z
+date: 2014-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bubble-wrap
@@ -105,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.3.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Simple model and validation mixins for RubyMotion
@@ -127,3 +127,4 @@ test_files:
 - spec/relation_spec.rb
 - spec/transaction_spec.rb
 - spec/validation_spec.rb
+has_rdoc: