rasputin 0.12.1 → 0.13.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rasputin (0.11.3)
+    rasputin (0.12.2)
       actionpack (~> 3.1.0)
       jquery-rails (~> 1.0)
       railties (~> 3.1.0)
@@ -34,9 +34,9 @@ GEM
     jquery-rails (1.0.19)
       railties (~> 3.0)
       thor (~> 0.14)
-    json (1.6.3)
+    json (1.6.4)
     multi_json (1.0.4)
-    rack (1.3.5)
+    rack (1.3.6)
     rack-cache (1.1)
       rack (>= 0.4)
     rack-mount (0.8.3)
@@ -53,7 +53,7 @@ GEM
       rdoc (~> 3.4)
       thor (~> 0.14.6)
     rake (0.9.2.2)
-    rdoc (3.11)
+    rdoc (3.12)
       json (~> 1.4)
     sprockets (2.0.3)
       hike (~> 1.2)

data/README.md

@@ -3,20 +3,13 @@ Rasputin
 
 This is a gem for integration of Ember.js with Rails 3.1 assets pipeline.
 
-It provide direct requires for official ember packages :
+It provide direct requires for following ember packages :
 
 * ember
-* ember-datetime
 * ember-data
-* ember-touch
-* ember-routing
-
-And it also provides one unnoficial package :
-
-* ember-i18n (integration with i18n-js gem)
 
 Rasputin also provide sprockets engine for handlebars templates. Any template in your
-javascript assets folder with extention handlebars will be availabel in sproutcore.
+javascript assets folder with extention `handlebars` or `hbs` will be availabel in ember.
 
 Examples :
 
@@ -33,6 +26,7 @@ The new default is '/'
 Precompilation :
 
 Starting with 0.9.0 release, Rasputin will precompile your handlebars templates.
+Starting with 0.12.1 release, default behavior is to precompile templates only in production environment.
 If you do not want this behavior you can tourn it off in your rails configuration block :
 
     config.rasputin.precompile_handlebars = false
@@ -48,6 +42,20 @@ It will be translated as :
         {{view Ember.Button}}OK{{/view}}
     </script>
 
+Preprocessor :
+
+If you chouse to use "javascript native require" your application.js file will look like this :
+
+    require('jquery');
+    require('ember');
+    require('ember-data');
+    require('app/**/*');
+
+Ther is two new settings :
+
+    config.rasputin.use_javascript_require = true
+    config.rasputin.strip_javascript_require = true
+
 Install
 -------
 
@@ -62,11 +70,7 @@ In your javascript asset manifest (app/assets/javascripts/application.js) add th
 
 And any of the following you want to include:
 
-    //= require ember-datetime
     //= require ember-data
-    //= require ember-touch
-    //= require ember-routing
-    //= require ember-i18n
 
 In your stylesheet asset manifest (app/assets/stylesheets/application.css) add the following:
 
@@ -77,6 +81,22 @@ In your stylesheet asset manifest (app/assets/stylesheets/application.css) add t
 ChangeLog
 ----------
 
+0.13.1
+
+* fix to ensure rasputin is initialized in all groups (thanks @chrisconley)
+* update ember-data
+
+0.13.0
+
+* new preprocessor for "javascript native require" (WIP)
+* remove legacy packages
+
+0.12.1
+
+* new precompiler (borrowed from @keithpitt)
+* default behavior is to precompil only in production environment
+* haml filter (thanks @ootoovak)
+
 0.12.0
 
 * replace ember-datastore with ember-data

data/lib/rasputin.rb

@@ -8,13 +8,19 @@ require "rasputin/handlebars/template"
 require "rasputin/slim" if defined? Slim
 require "rasputin/haml" if defined? Haml
 
+require "rasputin/require_preprocessor"
+
 module Rasputin
   class Engine < ::Rails::Engine
     config.rasputin = ActiveSupport::OrderedOptions.new
     config.rasputin.precompile_handlebars = Rails.env.production?
     config.rasputin.template_name_separator = '/'
 
-    initializer :setup_rasputin do |app|
+    config.rasputin.use_javascript_require = true
+    config.rasputin.strip_javascript_require = true
+
+    initializer :setup_rasputin, :group => :all do |app|
+      app.assets.register_preprocessor 'application/javascript', Rasputin::RequirePreprocessor
       app.assets.register_engine '.handlebars', Rasputin::HandlebarsTemplate
       app.assets.register_engine '.hbs', Rasputin::HandlebarsTemplate
     end

data/lib/rasputin/require_preprocessor.rb

@@ -0,0 +1,188 @@
+
+module Rasputin
+  class RequirePreprocessor < Tilt::Template
+
+    REQUIRE_PATTERN = /require\(\s*['"]([^\)]+)['"]\s*\)\s*;?\s*/
+    HEADER_PATTERN = /
+      \A (
+        (?m:\s*) (
+          (\/\* (?m:.*?) \*\/) |
+          (\#\#\# (?m:.*?) \#\#\#) |
+          (\/\/ .* \n?)+ |
+          (\# .* \n?)+ |
+          (#{REQUIRE_PATTERN} \n?)+
+        )
+      )+
+    /x
+    DIRECTIVE_PATTERN = /^\s*#{REQUIRE_PATTERN}$/
+    TREE_PATTERN = /\*\*\/\*$/
+    DIRECTORY_PATTERN = /\*$/
+
+    attr_reader :pathname
+    attr_reader :header, :body
+
+    def prepare
+      @pathname = Pathname.new(file)
+
+      @use_javascript_require = Rails.configuration.rasputin.use_javascript_require
+      @strip_javascript_require = Rails.configuration.rasputin.strip_javascript_require
+
+      if @use_javascript_require
+        @header = data[HEADER_PATTERN, 0] || ""
+        @body   = $' || data
+        # Ensure body ends in a new line
+        @body  += "\n" if @body != "" && @body !~ /\n\Z/m
+      else
+        @body = data
+      end
+    end
+
+    def evaluate(context, locals, &block)
+      if @use_javascript_require
+        @context = context
+        process_directives
+
+        processed_source
+      else
+        body
+      end
+    end
+
+    def processed_header
+      if @use_javascript_require && @strip_javascript_require
+        lineno = 0
+        @processed_header ||= header.lines.map { |line|
+          lineno += 1
+          # Replace directive line with a clean break
+          directives.assoc(lineno) ? "\n" : line
+        }.join.chomp
+      else
+        @processed_header ||= header.chomp
+      end
+    end
+
+    def processed_source
+      @processed_source ||= processed_header + "\n" + body
+    end
+
+    def directives
+      @directives ||= header.lines.each_with_index.map { |line, index|
+        if line =~ DIRECTIVE_PATTERN
+          name, path = detect_directive($1)
+          if respond_to?("process_#{name}_directive")
+            [index + 1, name, path]
+          end
+        end
+      }.compact
+    end
+
+    protected
+
+    attr_reader :context
+
+    def process_directives
+      directives.each do |line_number, name, path|
+        context.__LINE__ = line_number
+        send("process_#{name}_directive", path)
+        context.__LINE__ = nil
+      end
+    end
+
+    def detect_directive(path)
+      if path =~ TREE_PATTERN
+        return :require_tree, absolute_path_to_directory(path, TREE_PATTERN)
+      elsif path =~ DIRECTORY_PATTERN
+        return :require_directory, absolute_path_to_directory(path, DIRECTORY_PATTERN)
+      else
+        return :require_file, path
+      end
+    end
+
+    ###
+    # Directives implementation
+    ###
+
+    # `path`
+    def process_require_file_directive(path)
+      if relative?(path)
+        # The path must be absolute.
+        raise ArgumentError, "require argument must be absolute path"
+      else
+        context.require_asset(path)
+      end
+    end
+
+    # `path/*`
+    def process_require_directory_directive(path)
+      if relative?(path)
+        # The path must be absolute.
+        raise ArgumentError, "require_directory argument must be absolute path"
+      else
+        root = Pathname.new(path)
+
+        unless (stats = stat(root)) && stats.directory?
+          raise ArgumentError, "require_directory argument must be a directory"
+        end
+
+        context.depend_on(root)
+
+        entries(root).each do |pathname|
+          pathname = root.join(pathname)
+          if pathname.to_s == self.file
+            next
+          elsif context.asset_requirable?(pathname)
+            context.require_asset(pathname)
+          end
+        end
+      end
+    end
+
+    # `path/**/*`
+    def process_require_tree_directive(path)
+      if relative?(path)
+        # The path must be absolute.
+        raise ArgumentError, "require_tree argument must be absolute path"
+      else
+        root = Pathname.new(path)
+
+        unless (stats = stat(root)) && stats.directory?
+          raise ArgumentError, "require_tree argument must be a directory"
+        end
+
+        context.depend_on(root)
+
+        each_entry(root) do |pathname|
+          if pathname.to_s == self.file
+            next
+          elsif stat(pathname).directory?
+            context.depend_on(pathname)
+          elsif context.asset_requirable?(pathname)
+            context.require_asset(pathname)
+          end
+        end
+      end
+    end
+
+    private
+
+    def absolute_path_to_directory(path, pattern)
+      File.join(context.root_path, path.gsub(pattern, ''))
+    end
+
+    def relative?(path)
+      path =~ /^\.($|\.?\/)/
+    end
+
+    def stat(path)
+      context.environment.stat(path)
+    end
+
+    def entries(path)
+      context.environment.entries(path)
+    end
+
+    def each_entry(root, &block)
+      context.environment.each_entry(root, &block)
+    end
+  end
+end

data/lib/rasputin/version.rb

@@ -1,3 +1,3 @@
 module Rasputin
-  VERSION = "0.12.1"
+  VERSION = "0.13.1"
 end

data/vendor/assets/javascripts/ember-data.js

@@ -9,33 +9,33 @@ window.DS = SC.Namespace.create();
 DS.Adapter = SC.Object.extend({
   commit: function(store, commitDetails) {
     commitDetails.updated.eachType(function(type, array) {
-      this.updateMany(store, type, array.slice());
+      this.updateRecords(store, type, array.slice());
     }, this);
 
     commitDetails.created.eachType(function(type, array) {
-      this.createMany(store, type, array.slice());
+      this.createRecords(store, type, array.slice());
     }, this);
 
     commitDetails.deleted.eachType(function(type, array) {
-      this.deleteMany(store, type, array.slice());
+      this.deleteRecords(store, type, array.slice());
     }, this);
   },
 
-  createMany: function(store, type, models) {
+  createRecords: function(store, type, models) {
     models.forEach(function(model) {
-      this.create(store, type, model);
+      this.createRecord(store, type, model);
     }, this);
   },
 
-  updateMany: function(store, type, models) {
+  updateRecords: function(store, type, models) {
     models.forEach(function(model) {
-      this.update(store, type, model);
+      this.updateRecord(store, type, model);
     }, this);
   },
 
-  deleteMany: function(store, type, models) {
+  deleteRecords: function(store, type, models) {
     models.forEach(function(model) {
-      this.deleteModel(store, type, model);
+      this.deleteRecord(store, type, model);
     }, this);
   },
 
@@ -84,10 +84,10 @@ DS.ModelArray = SC.ArrayProxy.extend({
   },
 
   arrayDidChange: function(array, index, removed, added) {
-    this._super(array, index, removed, added);
-
     var modelCache = get(this, 'modelCache');
     modelCache.replace(index, 0, Array(added));
+    
+    this._super(array, index, removed, added);
   },
 
   arrayWillChange: function(array, index, removed, added) {
@@ -145,6 +145,196 @@ DS.AdapterPopulatedModelArray = DS.ModelArray.extend({
 })({});
 
 
+(function(exports) {
+var get = Ember.get, set = Ember.set, getPath = Ember.getPath, fmt = Ember.String.fmt;
+
+var OrderedSet = SC.Object.extend({
+  init: function() {
+    this.clear();
+  },
+
+  clear: function() {
+    this.set('presenceSet', {});
+    this.set('list', SC.NativeArray.apply([]));
+  },
+
+  add: function(obj) {
+    var guid = SC.guidFor(obj),
+        presenceSet = get(this, 'presenceSet'),
+        list = get(this, 'list');
+
+    if (guid in presenceSet) { return; }
+
+    presenceSet[guid] = true;
+    list.pushObject(obj);
+  },
+
+  remove: function(obj) {
+    var guid = SC.guidFor(obj),
+        presenceSet = get(this, 'presenceSet'),
+        list = get(this, 'list');
+
+    delete presenceSet[guid];
+    list.removeObject(obj);
+  },
+
+  isEmpty: function() {
+    return getPath(this, 'list.length') === 0;
+  },
+
+  forEach: function(fn, self) {
+    get(this, 'list').forEach(function(item) {
+      fn.call(self, item);
+    });
+  },
+
+  toArray: function() {
+    return get(this, 'list').slice();
+  }
+});
+
+/**
+  A Hash stores values indexed by keys. Unlike JavaScript's
+  default Objects, the keys of a Hash can be any JavaScript
+  object.
+
+  Internally, a Hash has two data structures:
+
+    `keys`: an OrderedSet of all of the existing keys
+    `values`: a JavaScript Object indexed by the
+      Ember.guidFor(key)
+
+  When a key/value pair is added for the first time, we
+  add the key to the `keys` OrderedSet, and create or
+  replace an entry in `values`. When an entry is deleted,
+  we delete its entry in `keys` and `values`.
+*/
+
+var Hash = SC.Object.extend({
+  init: function() {
+    set(this, 'keys', OrderedSet.create());
+    set(this, 'values', {});
+  },
+
+  add: function(key, value) {
+    var keys = get(this, 'keys'), values = get(this, 'values');
+    var guid = Ember.guidFor(key);
+
+    keys.add(key);
+    values[guid] = value;
+
+    return value;
+  },
+
+  remove: function(key) {
+    var keys = get(this, 'keys'), values = get(this, 'values');
+    var guid = Ember.guidFor(key), value;
+
+    keys.remove(key);
+
+    value = values[guid];
+    delete values[guid];
+
+    return value;
+  },
+
+  fetch: function(key) {
+    var values = get(this, 'values');
+    var guid = Ember.guidFor(key);
+
+    return values[guid];
+  },
+
+  forEach: function(fn, binding) {
+    var keys = get(this, 'keys'), values = get(this, 'values');
+
+    keys.forEach(function(key) {
+      var guid = Ember.guidFor(key);
+      fn.call(binding, key, values[guid]);
+    });
+  }
+});
+
+DS.Transaction = Ember.Object.extend({
+  init: function() {
+    set(this, 'dirty', {
+      created: Hash.create(),
+      updated: Hash.create(),
+      deleted: Hash.create()
+    });
+  },
+
+  createRecord: function(type, hash) {
+    var store = get(this, 'store');
+
+    return store.createRecord(type, hash, this);
+  },
+
+  add: function(model) {
+    var modelTransaction = get(model, 'transaction');
+    ember_assert("Models cannot belong to more than one transaction at a time.", !modelTransaction);
+
+    set(model, 'transaction', this);
+  },
+
+  modelBecameDirty: function(kind, model) {
+    var dirty = get(get(this, 'dirty'), kind),
+        type = model.constructor;
+
+    var models = dirty.fetch(type);
+
+    models = models || dirty.add(type, OrderedSet.create());
+    models.add(model);
+  },
+
+  modelBecameClean: function(kind, model) {
+    var dirty = get(get(this, 'dirty'), kind),
+        type = model.constructor;
+
+    var models = dirty.fetch(type);
+    models.remove(model);
+
+    set(model, 'transaction', null);
+  },
+
+  commit: function() {
+    var dirtyMap = get(this, 'dirty');
+
+    var iterate = function(kind, fn, binding) {
+      var dirty = get(dirtyMap, kind);
+
+      dirty.forEach(function(type, models) {
+        if (models.isEmpty()) { return; }
+
+        models.forEach(function(model) { model.willCommit(); });
+        fn.call(binding, type, models.toArray());
+      });
+    };
+
+    var commitDetails = {
+      updated: {
+        eachType: function(fn, binding) { iterate('updated', fn, binding); }
+      },
+
+      created: {
+        eachType: function(fn, binding) { iterate('created', fn, binding); }
+      },
+
+      deleted: {
+        eachType: function(fn, binding) { iterate('deleted', fn, binding); }
+      }
+    };
+
+    var store = get(this, 'store');
+    var adapter = get(store, '_adapter');
+    if (adapter && adapter.commit) { adapter.commit(store, commitDetails); }
+    else { throw fmt("Adapter is either null or do not implement `commit` method", this); }
+  }
+});
+
+})({});
+
+
 (function(exports) {
 var get = SC.get, set = SC.set, getPath = SC.getPath, fmt = SC.String.fmt;
 
@@ -245,13 +435,15 @@ DS.Store = SC.Object.extend({
     set(this, 'models', []);
     set(this, 'modelArrays', []);
     set(this, 'modelArraysByClientId', {});
-    set(this, 'updatedTypes', OrderedSet.create());
-    set(this, 'createdTypes', OrderedSet.create());
-    set(this, 'deletedTypes', OrderedSet.create());
+    set(this, 'defaultTransaction', DS.Transaction.create({ store: this }));
 
     return this._super();
   },
 
+  transaction: function() {
+    return DS.Transaction.create({ store: this });
+  },
+
   modelArraysForClientId: function(clientId) {
     var modelArrays = get(this, 'modelArraysByClientId');
     var ret = modelArrays[clientId];
@@ -287,23 +479,29 @@ DS.Store = SC.Object.extend({
   // . CREATE NEW MODEL .
   // ....................
 
-  create: function(type, hash) {
+  createRecord: function(type, hash, transaction) {
     hash = hash || {};
 
     var id = hash[getPath(type, 'proto.primaryKey')] || null;
 
-    var model = type.create({ data: hash || {}, store: this });
+    var model = type.create({
+      data: hash || {},
+      store: this,
+      transaction: transaction
+    });
+
     model.adapterDidCreate();
 
     var data = this.clientIdToHashMap(type);
     var models = get(this, 'models');
 
     var clientId = this.pushHash(hash, id, type);
-    this.updateModelArrays(type, clientId, hash);
 
     set(model, 'clientId', clientId);
 
-    get(this, 'models')[clientId] = model;
+    models[clientId] = model;
+    
+    this.updateModelArrays(type, clientId, hash);
 
     return model;
   },
@@ -312,8 +510,8 @@ DS.Store = SC.Object.extend({
   // . DELETE MODEL .
   // ................
 
-  deleteModel: function(model) {
-    model.deleteModel();
+  deleteRecord: function(model) {
+    model.deleteRecord();
   },
 
   // ...............
@@ -466,126 +664,27 @@ DS.Store = SC.Object.extend({
     this.updateModelArrays(type, clientId, hash);
   },
 
-
-  // Internally, the store keeps two data structures representing
-  // the dirty models.
-  //
-  // It holds an OrderedSet of all of the dirty types and a Hash
-  // keyed off of the guid of each type.
-  //
-  // Assuming that Ember.guidFor(Person) is 'sc1', guidFor(Place)
-  // is 'sc2', and guidFor(Thing) is 'sc3', the structure will look
-  // like:
-  //
-  //   store: {
-  //     updatedTypes: [ Person, Place, Thing ],
-  //     updatedModels: {
-  //       sc1: [ person1, person2, person3 ],
-  //       sc2: [ place1 ],
-  //       sc3: [ thing1, thing2 ]
-  //     }
-  //   }
-  //
-  // Adapters receive an iterator that they can use to retrieve the
-  // type and array at the same time:
-  //
-  //   adapter: {
-  //     commit: function(store, commitDetails) {
-  //       commitDetails.updated.eachType(function(type, array) {
-  //         // this callback will be invoked three times:
-  //         //
-  //         //   1. Person, [ person1, person2, person3 ]
-  //         //   2. Place,  [ place1 ]
-  //         //   3. Thing,  [ thing1, thing2 ]
-  //       }
-  //     }
-  //   }
-  //
-  // This encapsulates the internal structure and presents it to the
-  // adapter as if it was a regular Hash with types as keys and dirty
-  // models as values.
-  //
-  // Note that there is a pair of *Types and *Models for each of
-  // `created`, `updated` and `deleted`. These correspond with the
-  // commitDetails passed into the adapter's commit method.
-
-  modelBecameDirty: function(kind, model) {
-    var dirtyTypes = get(this, kind + 'Types'), type = model.constructor;
-    dirtyTypes.add(type);
-
-    var dirtyModels = this.typeMap(type)[kind + 'Models'];
-    dirtyModels.add(model);
-  },
-
-  modelBecameClean: function(kind, model) {
-    var dirtyTypes = get(this, kind + 'Types'), type = model.constructor;
-
-    var dirtyModels = this.typeMap(type)[kind + 'Models'];
-    dirtyModels.remove(model);
-
-    if (dirtyModels.isEmpty()) {
-      dirtyTypes.remove(type);
-    }
-  },
-
-  eachDirtyType: function(kind, fn, self) {
-    var types = get(this, kind + 'Types'), dirtyModels;
-
-    types.forEach(function(type) {
-      dirtyModels = this.typeMap(type)[kind + 'Models'];
-      fn.call(self, type, get(dirtyModels, 'list'));
-    }, this);
-  },
-
   // ..............
   // . PERSISTING .
   // ..............
 
   commit: function() {
-    var self = this;
-
-    var iterate = function(kind, fn, binding) {
-      self.eachDirtyType(kind, function(type, models) {
-        models.forEach(function(model) {
-          model.willCommit();
-        });
-
-        fn.call(binding, type, models);
-      });
-    };
-
-    var commitDetails = {
-      updated: {
-        eachType: function(fn, binding) { iterate('updated', fn, binding); }
-      },
-
-      created: {
-        eachType: function(fn, binding) { iterate('created', fn, binding); }
-      },
-
-      deleted: {
-        eachType: function(fn, binding) { iterate('deleted', fn, binding); }
-      }
-    };
-
-    var adapter = get(this, '_adapter');
-    if (adapter && adapter.commit) { adapter.commit(this, commitDetails); }
-    else { throw fmt("Adapter is either null or do not implement `commit` method", this); }
+    get(this, 'defaultTransaction').commit();
   },
 
-  didUpdateModels: function(array, hashes) {
+  didUpdateRecords: function(array, hashes) {
     if (arguments.length === 2) {
       array.forEach(function(model, idx) {
-        this.didUpdateModel(model, hashes[idx]);
+        this.didUpdateRecord(model, hashes[idx]);
       }, this);
     } else {
       array.forEach(function(model) {
-        this.didUpdateModel(model);
+        this.didUpdateRecord(model);
       }, this);
     }
   },
 
-  didUpdateModel: function(model, hash) {
+  didUpdateRecord: function(model, hash) {
     if (arguments.length === 2) {
       var clientId = get(model, 'clientId');
       var data = this.clientIdToHashMap(model.constructor);
@@ -597,17 +696,17 @@ DS.Store = SC.Object.extend({
     model.adapterDidUpdate();
   },
 
-  didDeleteModels: function(array) {
+  didDeleteRecords: function(array) {
     array.forEach(function(model) {
       model.adapterDidDelete();
     });
   },
 
-  didDeleteModel: function(model) {
+  didDeleteRecord: function(model) {
     model.adapterDidDelete();
   },
 
-  didCreateModels: function(type, array, hashes) {
+  didCreateRecords: function(type, array, hashes) {
     var id, clientId, primaryKey = getPath(type, 'proto.primaryKey');
 
     var idToClientIdMap = this.idToClientIdMap(type);
@@ -629,7 +728,7 @@ DS.Store = SC.Object.extend({
     }
   },
 
-  didCreateModel: function(model, hash) {
+  didCreateRecord: function(model, hash) {
     var type = model.constructor;
 
     var id, clientId, primaryKey = getPath(type, 'proto.primaryKey');
@@ -650,6 +749,10 @@ DS.Store = SC.Object.extend({
     model.adapterDidUpdate();
   },
 
+  recordWasInvalid: function(record, errors) {
+    record.wasInvalid(errors);
+  },
+
   // ................
   // . MODEL ARRAYS .
   // ................
@@ -753,10 +856,7 @@ DS.Store = SC.Object.extend({
           idToCid: {},
           idList: [],
           cidList: [],
-          cidToHash: {},
-          updatedModels: OrderedSet.create(),
-          createdModels: OrderedSet.create(),
-          deletedModels: OrderedSet.create()
+          cidToHash: {}
       });
     }
   },
@@ -931,7 +1031,8 @@ DS.State = SC.State.extend({
   isSaving: stateProperty,
   isDeleted: stateProperty,
   isError: stateProperty,
-  isNew: stateProperty
+  isNew: stateProperty,
+  isValid: stateProperty
 });
 
 var cantLoadData = function() {
@@ -939,6 +1040,99 @@ var cantLoadData = function() {
   throw "You cannot load data into the store when its associated model is in its current state";
 };
 
+var isEmptyObject = function(obj) {
+  for (var prop in obj) {
+    if (!obj.hasOwnProperty(prop)) { continue; }
+    return false;
+  }
+
+  return true;
+};
+
+var setProperty = function(manager, context) {
+  var key = context.key, value = context.value;
+
+  var model = get(manager, 'model'), type = model.constructor;
+  var store = get(model, 'store');
+  var data = get(model, 'data');
+
+  data[key] = value;
+
+  if (store) { store.hashWasUpdated(type, get(model, 'clientId')); }
+};
+
+// several states share extremely common functionality, so we are factoring
+// them out into a common class.
+var DirtyState = DS.State.extend({
+  // these states are virtually identical except that
+  // they (thrice) use their states name explicitly.
+  //
+  // child classes implement stateName.
+  stateName: null,
+  isDirty: true,
+  willLoadData: cantLoadData,
+
+  enter: function(manager) {
+    var stateName = get(this, 'stateName'),
+        model = get(manager, 'model');
+
+    model.withTransaction(function (t) {
+      t.modelBecameDirty(stateName, model);
+    });
+  },
+
+  exit: function(manager) {
+    var stateName = get(this, 'stateName'),
+        model = get(manager, 'model');
+
+    this.notifyModel(model);
+
+    model.withTransaction(function (t) {
+      t.modelBecameClean(stateName, model);
+    });
+  },
+
+  setProperty: setProperty,
+
+  willCommit: function(manager) {
+    manager.goToState('saving');
+  },
+
+  saving: DS.State.extend({
+    isSaving: true,
+
+    didUpdate: function(manager) {
+      manager.goToState('loaded');
+    },
+
+    wasInvalid: function(manager, errors) {
+      var model = get(manager, 'model');
+
+      set(model, 'errors', errors);
+      manager.goToState('invalid');
+    }
+  }),
+
+  invalid: DS.State.extend({
+    isValid: false,
+
+    setProperty: function(manager, context) {
+      setProperty(manager, context);
+
+      var stateName = getPath(this, 'parentState.stateName'),
+          model = get(manager, 'model'),
+          errors = get(model, 'errors'),
+          key = context.key;
+
+      delete errors[key];
+
+      if (isEmptyObject(errors)) {
+        manager.goToState(stateName);
+      }
+    }
+  })
+});
+
 var states = {
   rootState: SC.State.create({
     isLoaded: false,
@@ -947,6 +1141,7 @@ var states = {
     isDeleted: false,
     isError: false,
     isNew: false,
+    isValid: true,
 
     willLoadData: cantLoadData,
 
@@ -988,16 +1183,7 @@ var states = {
       willLoadData: SC.K,
 
       setProperty: function(manager, context) {
-        var key = context.key, value = context.value;
-
-        var model = get(manager, 'model'), type = model.constructor;
-        var store = get(model, 'store');
-        var data = get(model, 'data');
-
-        data[key] = value;
-
-        if (store) { store.hashWasUpdated(type, get(model, 'clientId')); }
-
+        setProperty(manager, context);
         manager.goToState('updated');
       },
 
@@ -1005,83 +1191,21 @@ var states = {
         manager.goToState('deleted');
       },
 
-      created: DS.State.create({
+      created: DirtyState.create({
+        stateName: 'created',
         isNew: true,
-        isDirty: true,
-
-        enter: function(manager) {
-          var model = get(manager, 'model');
-          var store = get(model, 'store');
-
-          if (store) { store.modelBecameDirty('created', model); }
-        },
-
-        exit: function(manager) {
-          var model = get(manager, 'model');
-          var store = get(model, 'store');
 
+        notifyModel: function(model) {
           model.didCreate();
-
-          if (store) { store.modelBecameClean('created', model); }
-        },
-
-        setProperty: function(manager, context) {
-          var key = context.key, value = context.value;
-
-          var model = get(manager, 'model'), type = model.constructor;
-          var store = get(model, 'store');
-          var data = get(model, 'data');
-
-          data[key] = value;
-
-          if (store) { store.hashWasUpdated(type, get(model, 'clientId')); }
-        },
-
-        willCommit: function(manager) {
-          manager.goToState('saving');
-        },
-
-        saving: DS.State.create({
-          isSaving: true,
-
-          didUpdate: function(manager) {
-            manager.goToState('loaded');
-          }
-        })
+        }
       }),
 
-      updated: DS.State.create({
-        isDirty: true,
-
-        willLoadData: cantLoadData,
-
-        enter: function(manager) {
-          var model = get(manager, 'model');
-          var store = get(model, 'store');
-
-          if (store) { store.modelBecameDirty('updated', model); }
-        },
-
-        willCommit: function(manager) {
-          manager.goToState('saving');
-        },
-
-        exit: function(manager) {
-          var model = get(manager, 'model');
-          var store = get(model, 'store');
+      updated: DirtyState.create({
+        stateName: 'updated',
 
+        notifyModel: function(model) {
           model.didUpdate();
-
-          if (store) { store.modelBecameClean('updated', model); }
-        },
-
-        saving: DS.State.create({
-          isSaving: true,
-
-          didUpdate: function(manager) {
-            manager.goToState('loaded');
-          }
-        })
+        }
       })
     }),
 
@@ -1098,8 +1222,11 @@ var states = {
 
         if (store) {
           store.removeFromModelArrays(model);
-          store.modelBecameDirty('deleted', model);
         }
+
+        model.withTransaction(function(t) {
+          t.modelBecameDirty('deleted', model);
+        });
       },
 
       willCommit: function(manager) {
@@ -1115,9 +1242,10 @@ var states = {
 
         exit: function(stateManager) {
           var model = get(stateManager, 'model');
-          var store = get(model, 'store');
 
-          store.modelBecameClean('deleted', model);
+          model.withTransaction(function(t) {
+            t.modelBecameClean('deleted', model);
+          });
         }
       }),
 
@@ -1149,11 +1277,15 @@ DS.Model = SC.Object.extend({
   isDeleted: retrieveFromCurrentState,
   isError: retrieveFromCurrentState,
   isNew: retrieveFromCurrentState,
+  isValid: retrieveFromCurrentState,
 
   clientId: null,
 
+  // because unknownProperty is used, any internal property
+  // must be initialized here.
   primaryKey: 'id',
   data: null,
+  transaction: null,
 
   didLoad: Ember.K,
   didUpdate: Ember.K,
@@ -1168,6 +1300,12 @@ DS.Model = SC.Object.extend({
     stateManager.goToState('empty');
   },
 
+  withTransaction: function(fn) {
+    var transaction = get(this, 'transaction') || getPath(this, 'store.defaultTransaction');
+
+    if (transaction) { fn(transaction); }
+  },
+
   setData: function(data) {
     var stateManager = get(this, 'stateManager');
     stateManager.send('setData', data);
@@ -1178,11 +1316,16 @@ DS.Model = SC.Object.extend({
     stateManager.send('setProperty', { key: key, value: value });
   },
 
-  "deleteModel": function() {
+  deleteRecord: function() {
     var stateManager = get(this, 'stateManager');
     stateManager.send('delete');
   },
 
+  destroy: function() {
+    this.deleteRecord();
+    this._super();
+  },
+
   loadingData: function() {
     var stateManager = get(this, 'stateManager');
     stateManager.send('loadingData');
@@ -1213,6 +1356,11 @@ DS.Model = SC.Object.extend({
     stateManager.send('didDelete');
   },
 
+  wasInvalid: function(errors) {
+    var stateManager = get(this, 'stateManager');
+    stateManager.send('wasInvalid', errors);
+  },
+
   unknownProperty: function(key) {
     var data = get(this, 'data');
 
@@ -1332,7 +1480,7 @@ DS.attr.transforms = {
 
       if (type === "string" || type === "number") {
         return new Date(serialized);
-      } else if (serialized == null) {
+      } else if (serialized === null || serialized === undefined) {
         // if the value is not present in the data,
         // return undefined, not null.
         return serialized;