motion_model 0.3.6 → 0.3.7

data/README.md

@@ -1,4 +1,4 @@
-[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/sxross/MotionModel)
+[![Code Climate](https://codeclimate.com/github/sxross/MotionModel.png)](https://codeclimate.com/github/sxross/MotionModel)
 
 MotionModel -- Simple Model, Validation, and Input Mixins for RubyMotion
 ================
@@ -17,7 +17,7 @@ File                 | Module                    | Description
 
 MotionModel is MIT licensed, which means you can pretty much do whatever
 you like with it. See the LICENSE file in this project.
-  
+
 * [Getting Going](#getting-going)
 * [What Model Can Do](#what-model-can-do)
 * [Model Data Types](#model-data-types)
@@ -87,11 +87,11 @@ Models support default values, so if you specify your model like this, you get d
 ```ruby
 class Task
   include MotionModel::Model
-  
+
   columns :name     => :string,
           :due_date => {:type => :date, :default => '2012-09-15'}
 end
-```          
+```
 
 You can also include the `Validatable` module to get field validation. For example:
 
@@ -197,11 +197,19 @@ You are responsible for adding an error message using:
 
 You must return `true` from your validator if the value passes validation otherwise `false`.
 
+An important note about `save` once you include `Validatable`, you have two flavors
+of save:
+
+Method                 | Meaning              
+-----------------------|---------------------------
+`save(options)`        |Just saves the data if it is valid (passes validations) or if you have specified `:validate => false`
+`save!`                |Saves the data if it is valid, otherwise raises a `MotionModel::Validatable::RecordInvalid` exception
+
 Model Instances and Unique IDs
 -----------------
 
-It is assumed that models can be created from an external source (JSON from a Web 
-application or `NSCoder` from the device) or simply be a stand-alone data store. 
+It is assumed that models can be created from an external source (JSON from a Web
+application or `NSCoder` from the device) or simply be a stand-alone data store.
 To identify rows properly, the model tracks a special field called `:id`. If it's
 already present, it's left alone. If it's missing, then it is created for you.
 Each row id is guaranteed to be unique, so you can use this when communicating
@@ -214,24 +222,24 @@ Using MotionModel
   This should make transitioning from Rails or any ORM that follows the
   ActiveRecord pattern pretty easy. Some of the finder syntactic sugar is
   similar to that of Sequel or DataMapper.
-  
+
   * Finders are implemented using chaining. Here is an examples:
 
-    ```ruby  
+    ```ruby
     @tasks = Task.where(:assigned_to).eq('bob').and(:location).contains('seattle')
     @tasks.all.each { |task| do_something_with(task) }
     ```
-    
+
     You can use a block with find:
-    
-    ```ruby  
+
+    ```ruby
     @tasks = Task.find{|task| task.name =~ /dog/i && task.assigned_to == 'Bob'}
     ```
-    
+
     Note that finders always return a proxy (`FinderQuery`). You must use `first`, `last`, or `all`
     to get useful results.
-    
-    ```ruby  
+
+    ```ruby
     @tasks = Task.where(:owner).eq('jim')   # => A FinderQuery.
     @tasks.all                              # => An array of matching results.
     @tasks.first                            # => The first result
@@ -256,68 +264,68 @@ Using MotionModel
   ```ruby
     @tasks = Task.deserialize_from_file('tasks.dat')
   ```
-  
+
   and of course on the "save" side:
-  
+
   ```ruby
     Task.serialize_to_file('tasks.dat')
   end
   ```
   After the first serialize or deserialize, your model will remember the file
   name so you can call these methods without the filename argument.
-  
+
   Implementation note: that the this serialization of any arbitrarily complex set of relations
   is automatically handled by `NSCoder` provided you conform to the coding
   protocol (which MotionModel does). When you declare your columns, `MotionModel` understands how to
   serialize your data so you need take no specific action.
-  
+
   **Warning**: As of this release, persistence will serialize only one
   model at a time and not your entire data store.
-  
+
   * Relations
-  
+
   ```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"
   ```
-  
+
 There are four ways to delete objects from your data store:
 
 * `object.delete     #` just deletes the object and ignores all relations
 * `object.destroy    #` deletes the object and honors any cascading declarations
 * `Class.delete_all  #` just deletes all objects of this class and ignores all relations
 * `Class.destroy_all #` deletes all objects of this class and honors any cascading declarations
-  
+
 The key to how the `destroy` variants work in how the relation is declared. You can declare:
 
 ```ruby
@@ -379,14 +387,14 @@ Notifications
 -------------
 
 Notifications are issued on object save, update, and delete. They work like this:
-  
+
 ```ruby
 def viewDidAppear(animated)
   super
   # other stuff here to set up your view
-  
-  NSNotificationCenter.defaultCenter.addObserver(self, selector:'dataDidChange:', 
-                                                           name:'MotionModelDataDidChangeNotification', 
+
+  NSNotificationCenter.defaultCenter.addObserver(self, selector:'dataDidChange:',
+                                                           name:'MotionModelDataDidChangeNotification',
                                                          object:nil)
 end
 
@@ -406,11 +414,11 @@ def dataDidChange(notification)
   #     'delete'
 end
 ```
-  
+
   In your `dataDidChange` notification handler, you can respond to the `MotionModelDataDidChangeNotification` notification any way you like,
   but in the instance of a tableView, you might want to use the id of the object passed back to locate
   the correct row in the table and act upon it instead of doing a wholesale `reloadData`.
-  
+
   Note that if you do a delete_all, no notifications are issued because there is no single object
   on which to report. You pretty much know what you need to do: Refresh your view.
 
@@ -418,7 +426,7 @@ end
   like a remote synch operation but still be confident you will be updating the UI only on the main thread.
   MotionModel does not currently send notification messages that differentiate by class, so if your
   UI presents `Task`s and you get a notification that an `Assignee` has changed:
-  
+
 ```ruby
 class Task
   include MotionModel::Model
@@ -448,12 +456,12 @@ else
   # We don't display anything other than tasks
 end
 ```
-  
+
   The above example implies you are only presenting, say, a list of tasks in the current
   view. If, however, you are presenting a list of tasks along with their assignees and
   the assignees could change as a result of a background sync, then your code could and
   should recognize the change to assignee objects.
-  
+
 Core Extensions
 ----------------
 
@@ -466,47 +474,47 @@ Core Extensions
   - Array#empty?
   - Hash#empty?
   - Symbol#titleize
-  
+
   Also in the extensions is a `Debug` class to log stuff to the console.
   It uses NSLog so you will have a separate copy in your application log.
   This may be preferable to `puts` just because it's easier to spot in
   your code and it gives you the exact level and file/line number of the
   info/warning/error in your console output:
-  
+
   - 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 
+  Again, a reversing rule is required for both singularize and
   pluralize to work properly.
 
 Formotion Support

data/lib/motion_model/ext.rb

@@ -64,31 +64,87 @@ class Inflector
     # Put singular-form to plural form transformations here
     @plurals = [
       [/^person$/, 'people'],
-      [/^identity$/, 'identities'],
+      [/^man$/, 'men'],
       [/^child$/, 'children'],
-      [/^(.*)ee$/i, '\1ees'],     # attendee => attendees
-      [/^(.*)us$/i, '\1i'],       # alumnus  => alumni
-      [/^(.*s)$/i, '\1es'],       # pass     => passes
-      [/^(.*)$/, '\1s']           # normal   => normals
+      [/^sex$/, 'sexes'],
+      [/^move$/, 'moves'],
+      [/^cow$/, 'kine'],
+      [/^zombie$/, 'zombies'],
+      [/(quiz)$/i, '\1zes'],
+      [/^(oxen)$/i, '\1'],
+      [/^(ox)$/i, '\1en'],
+      [/^(m|l)ice$/i, '\1ice'],
+      [/^(m|l)ouse$/i, '\1ice'],
+      [/(matr|vert|ind)(?:ix|ex)$/i, '\1ices'],
+      [/(x|ch|ss|sh)$/i, '\1es'],
+      [/([^aeiouy]|qu)y$/i, '\1ies'],
+      [/(hive)$/i, '\1s'],
+      [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'],
+      [/sis$/i, 'ses'],
+      [/([ti])a$/i, '\1a'],
+      [/([ti])um$/i, '\1a'],
+      [/(buffal|tomat)o$/i, '\1oes'],
+      [/(bu)s$/i, '\1ses'],
+      [/(alias|status)$/i, '\1es'],
+      [/(octop|vir)i$/i, '\1i'],
+      [/(octop|vir|alumn)us$/i, '\1i'],
+      [/^(ax|test)is$/i, '\1es'],
+      [/s$/i, 's'],
+      [/$/, 's']
     ]
 
     # Put plural-form to singular form transformations here
     @singulars = [
       [/^people$/, 'person'],
-      [/^identities$/, 'identity'],
+      [/^men$/, 'man'],
       [/^children$/, 'child'],
-      [/^(.*)ees$/i, '\1ee'],     # attendees  => attendee
-      [/^(.*)es$/i, '\1'],        # passes     => pass
-      [/^(.*)i$/i, '\1us'],       # alumni     => alumnus
-      [/^(.*)s$/i, '\1']          # normals    => normal
+      [/^sexes$/, 'sex'],
+      [/^moves$/, 'move'],
+      [/^kine$/, 'cow'],
+      [/^zombies$/, 'zombie'],
+      [/(database)s$/i, '\1'],
+      [/(quiz)zes$/i, '\1'],
+      [/(matr)ices$/i, '\1ix'],
+      [/(vert|ind)ices$/i, '\1ex'],
+      [/^(ox)en/i, '\1'],
+      [/(alias|status)(es)?$/i, '\1'],
+      [/(octop|vir|alumn)(us|i)$/i, '\1us'],
+      [/^(a)x[ie]s$/i, '\1xis'],
+      [/(cris|test)(is|es)$/i, '\1is'],
+      [/(shoe)s$/i, '\1'],
+      [/(o)es$/i, '\1'],
+      [/(bus)(es)?$/i, '\1'],
+      [/^(m|l)ice$/i, '\1ouse'],
+      [/(x|ch|ss|sh)es$/i, '\1'],
+      [/(m)ovies$/i, '\1ovie'],
+      [/(s)eries$/i, '\1eries'],
+      [/([^aeiouy]|qu)ies$/i, '\1y'],
+      [/([lr])ves$/i, '\1f'],
+      [/(tive)s$/i, '\1'],
+      [/(hive)s$/i, '\1'],
+      [/([^f])ves$/i, '\1fe'],
+      [/(^analy)(sis|ses)$/i, '\1sis'],
+      [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis'],
+      [/([ti])a$/i, '\1um'],
+      [/(n)ews$/i, '\1ews'],
+      [/(ss)$/i, '\1'],
+      [/s$/i, '']
     ]
 
     @irregulars = [
     ]
 
     @uncountables = [
+      'equipment',
+      'information',
+      'rice',
+      'money',
+      'species',
+      'series',
       'fish',
-      'sheep'
+      'sheep',
+      'jeans',
+      'police'
     ]
   end
 

data/lib/motion_model/model/formotion.rb

@@ -3,6 +3,7 @@ module MotionModel
     FORMOTION_MAP = {
       :string   => :string,
       :date     => :date,
+      :time     => :date,
       :int      => :number,
       :integer  => :number,
       :float    => :number,
@@ -31,9 +32,14 @@ module MotionModel
        }
     end
 
+    def is_date_time?(column)
+      column_type = type(column)
+      [:date, :time].include?(column_type)
+     end
+
     def value_for(column) #nodoc
       value = self.send(column)
-      value = value.to_f if type(column) == :date && !value.nil?
+      value = value.to_f if value && is_date_time?(column)
       value
     end
 
@@ -66,14 +72,14 @@ module MotionModel
       end
       form
     end
-    
+
     # <tt>from_formotion</tt> takes the information rendered from a Formotion
     # form and stuffs it back into a MotionModel. This data is not saved until
     # you say so, offering you the opportunity to validate your form data.
     def from_formotion!(data)
       self.returnable_columns.each{|column|
-        if type(column) == :date && !data[column].nil?
-          data[column] = Time.at(data[column]) 
+        if data[column] && type(column) == :date || type(column) == :time
+          data[column] = Time.at(data[column]) unless data[column].nil?
         end
         value = self.send("#{column}=", data[column])
       }

data/lib/motion_model/model/model.rb

@@ -20,9 +20,13 @@
 # Recognized types are:
 #
 # * :string
+# * :text
 # * :date (must be in YYYY-mm-dd form)
+# * :time
 # * :integer
 # * :float
+# * :boolean
+# * :array
 #
 # Assuming you have a bunch of tasks in your data store, you can do this:
 #
@@ -187,7 +191,7 @@ module MotionModel
       def destroy_all
         ids = self.all.map{|item| item.id}
         bulk_update do
-          ids.each do |item| 
+          ids.each do |item|
             find(item).destroy
           end
         end
@@ -396,7 +400,7 @@ module MotionModel
     # Save current object. Speaking from the context of relational
     # databases, this inserts a row if it's a new one, or updates
     # in place if not.
-    def save
+    def save(*)
       call_hooks 'save' do
         @dirty = false
 
@@ -435,7 +439,7 @@ module MotionModel
     def delete
       call_hooks('delete') do
         target_index = collection.index{|item| item.id == self.id}
-        collection.delete_at(target_index)
+        collection.delete_at(target_index) unless target_index.nil?
         self.class.issue_notification(self, :action => 'delete')
       end
     end

data/lib/motion_model/model/model_casts.rb

@@ -45,7 +45,7 @@ module MotionModel
       when :boolean, :bool then cast_to_bool(arg)
       when :int, :integer, :belongs_to_id then cast_to_integer(arg)
       when :float, :double then cast_to_float(arg)
-      when :date then cast_to_date(arg)
+      when :date, :time then cast_to_date(arg)
       when :text then cast_to_string(arg)
       when :array then cast_to_array(arg)
       else

data/lib/motion_model/model/persistence.rb

@@ -38,7 +38,7 @@ module MotionModel
       # want to use. If you omit this, it will use the last
       # remembered file name.
       #
-      # Raises a +MotionModel::PersistFileFailureError+ on failure.
+      # Raises a +MotionModel::PersistFileError+ on failure.
       def serialize_to_file(file_name = nil)
         @file_name = file_name if file_name
         error_ptr = Pointer.new(:object)
@@ -49,7 +49,7 @@ module MotionModel
           error = error_ptr[0]
 
           # Now we can use the `error' object.
-          raise MotionModel::PersistFileFailureError.new "Error when writing data: #{error}"
+          raise MotionModel::PersistFileError.new "Error when writing data: #{error}"
         end
       end
     

data/lib/motion_model/validatable.rb

@@ -1,6 +1,8 @@
 module MotionModel
   module Validatable
     class ValidationSpecificationError < RuntimeError;  end
+    class RecordInvalid < RuntimeError; end
+
 
     def self.included(base)
       base.extend(ClassMethods)
@@ -13,6 +15,8 @@ module MotionModel
           ex = ValidationSpecificationError.new('field not present in validation call')
           raise ex
         end
+
+
     
         if validation_type == {}
           ex = ValidationSpecificationError.new('validation type not present or not a hash')
@@ -28,6 +32,17 @@ module MotionModel
       end
     end
   
+     # It doesn't save when validations fails
+    def save(options={ :validate => true})
+      (valid? || !options[:validate]) ? super : false
+    end
+
+    # it fails loudly
+    def save!
+      raise RecordInvalid.new('failed validation') unless valid?
+      save
+    end
+
     # This has two functions:
     # 
     # * First, it triggers validations.

data/lib/motion_model/version.rb

@@ -1,4 +1,4 @@
 
 module MotionModel
-  VERSION = "0.3.6"
+  VERSION = "0.3.7"
 end

data/spec/ext_spec.rb

@@ -3,38 +3,46 @@ describe 'Extensions' 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
+
+    it "pluralizes words that end in 'e'" do
+      Inflector.inflections.pluralize('article').should == 'articles'
+    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
+
+    it "singualarizes words that end in 'es'" do
+      Inflector.inflections.singularize('articles').should == 'article'
+    end
   end
-  
+
   describe 'Irregular Patterns' do
     it "handles person to people singularizing" do
       Inflector.inflections.singularize('people').should == 'person'
@@ -44,7 +52,7 @@ describe 'Extensions' do
       Inflector.inflections.pluralize('person').should == 'people'
     end
   end
-  
+
   describe 'Adding Rules to Inflector' do
     it 'accepts new rules' do
       Inflector.inflections.irregular /^foot$/, 'feet'

data/spec/validation_spec.rb

@@ -102,3 +102,37 @@ describe "validations" do
 
   end
 end
+
+class VTask
+  include MotionModel::Model
+  include MotionModel::Validatable
+
+  columns :name => :string
+  validate :name, :presence => true
+end
+
+describe "saving with validations" do
+
+  it "fails loudly" do
+    task = VTask.new
+    lambda { task.save!}.should.raise
+  end
+
+  it "can skip the validations" do
+    task = VTask.new
+    lambda { task.save({:validate => false})}.should.change { VTask.count }
+  end
+
+  it "should not save when validation fails" do
+    task = VTask.new
+    lambda { task.save }.should.not.change{ VTask.count }
+    task.save.should == false
+  end
+
+  it "saves it when everything is ok" do
+    task = VTask.new
+    task.name = "Save it"
+    lambda { task.save }.should.change { VTask.count }
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: motion_model
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-25 00:00:00.000000000 Z
+date: 2013-02-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bubble-wrap