update to work with latest set

dist/index.js

@@ -9,10 +9,22 @@ var _values = require('utilise/values');
 
 var _values2 = _interopRequireDefault(_values);
 
+var _clone = require('utilise/clone');
+
+var _clone2 = _interopRequireDefault(_clone);
+
+var _set = require('utilise/set');
+
+var _set2 = _interopRequireDefault(_set);
+
 var _key = require('utilise/key');
 
 var _key2 = _interopRequireDefault(_key);
 
+var _def = require('utilise/def');
+
+var _def2 = _interopRequireDefault(_def);
+
 var _by = require('utilise/by');
 
 var _by2 = _interopRequireDefault(_by);
@@ -30,8 +42,10 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 function version(ripple) {
   log('creating');
 
+  var type = ripple.types['application/data'];
   ripple.on('change.version', commit(ripple));
   ripple.version = checkout(ripple);
+  ripple.version.calc = calc(ripple);
   ripple.version.log = [];
   return ripple;
 }
@@ -56,20 +70,36 @@ var checkout = function checkout(ripple) {
 
 var application = function application(ripple) {
   return function (index) {
-    return ripple.version.log[rel(ripple.version, index)].map(resource(ripple));
+    return ripple.version.log[rel(ripple.version.log, index)].map(resource(ripple));
   };
 };
 
 var resource = function resource(ripple) {
   return function (_ref2) {
     var name = _ref2.name;
     var index = _ref2.index;
-    return ripple(name, ripple.resources[name].body.log[rel(ripple.resources[name].body, index)].value.toJS());
+    return ripple(name, ripple.version.calc(name, index));
+  };
+};
+
+var calc = function calc(ripple) {
+  return function (name, index) {
+    var log = ripple.resources[name].body.log,
+        end = rel(log, index),
+        i = end;
+
+    if (log[end].cache) return log[end].cache;
+
+    while (_is2.default.def(log[i].key)) {
+      i--;
+    }var root = (0, _clone2.default)(log[i].value);
+    while (i !== end) {
+      (0, _set2.default)(log[++i])(root);
+    }return (0, _def2.default)(log[end], 'cache', root);
   };
 };
 
-var rel = function rel(_ref3, index) {
-  var log = _ref3.log;
+var rel = function rel(log, index) {
   return index < 0 ? log.length + index - 1 : index;
 };
 

package.json

@@ -31,8 +31,7 @@
     "mocha-lcov-reporter": "*",
     "uglify-js": "*",
     "rijs.core": "*",
-    "rijs.data": "*",
-    "versioned": "*"
+    "rijs.data": "*"
   },
   "dependencies": {
     "utilise": "*"

src/index.js

@@ -4,8 +4,10 @@
 export default function version(ripple){
   log('creating')
 
+  const type = ripple.types['application/data']
   ripple.on('change.version', commit(ripple))
   ripple.version = checkout(ripple)
+  ripple.version.calc = calc(ripple)
   ripple.version.log = []
   return ripple
 }
@@ -16,11 +18,11 @@ const commit = ripple => (name, change) => logged(ripple.resources[name]) &&
       .filter(by('body.log'))
       .map(index))
 
-const index = ({ name, body }) => ({ name, index: body.log.length-1 })
+const index = ({ name, body }) => ({ name, index: body.log.length - 1 })
 
 const checkout = ripple => function(name, index) {
   return arguments.length == 2                 ? resource(ripple)({ name, index })
-       : arguments.length == 1 && is.str(name) ? ripple.resources[name].body.log.length-1
+       : arguments.length == 1 && is.str(name) ? ripple.resources[name].body.log.length - 1
        : arguments.length == 1 && is.num(name) ? application(ripple)(name)
        : arguments.length == 0                 ? ripple.version.log.length - 1
        : err('could not rollback', name, index)
@@ -29,21 +31,35 @@ const checkout = ripple => function(name, index) {
 const application = ripple => index => ripple
   .version
   .log
-  [rel(ripple.version, index)]
+  [rel(ripple.version.log, index)]
   .map(resource(ripple))
 
-const resource = ripple => ({ name, index }) => ripple(
-  name
-, ripple.resources[name].body.log[rel(ripple.resources[name].body, index)].value.toJS()
-)
+const resource = ripple => ({ name, index }) => ripple(name, ripple.version.calc(name, index))
 
-const rel = ({ log }, index) => index < 0 ? log.length + index - 1 : index
+const calc = ripple => (name, index) => {
+  var log = ripple.resources[name].body.log
+    , end = rel(log, index)
+    , i   = end
+
+  if (log[end].cache) return log[end].cache
+
+  while (is.def(log[i].key)) i--
+  const root = clone(log[i].value)
+  while (i !== end) set(log[++i])(root)
+
+  return def(log[end], 'cache', root)
+}
+
+const rel = (log, index) => index < 0 ? log.length + index - 1 : index
 
 const logged = key('body.log')
 
 const log = require('utilise/log')('[ri/versioned]')
     , err = require('utilise/err')('[ri/versioned]')
 import values from 'utilise/values'
+import clone from 'utilise/clone'
+import set from 'utilise/set'
 import key from 'utilise/key'
+import def from 'utilise/def'
 import by from 'utilise/by'
 import is from 'utilise/is'

test.js

@@ -1,5 +1,4 @@
-var versioned = require('versioned').default
-  , core      = require('rijs.core').default
+var core      = require('rijs.core').default
   , data      = require('rijs.data').default
   , update    = require('utilise/update')
   , push      = require('utilise/push')
@@ -18,7 +17,7 @@ describe('Versioned', function(){
   it('should time travel - resource', function(){  
     var ripple = version(data(core()))
 
-    expect(ripple('foo', versioned({}))).to.be.eql({})
+    expect(ripple('foo', {})).to.be.eql({})
     expect(ripple.version('foo')).to.be.eql(0)
     expect(ripple.version.log).to.be.eql([[{ name: 'foo', index: 0 }]])
 
@@ -42,8 +41,8 @@ describe('Versioned', function(){
   it('should time travel - application', function(){  
     var ripple = version(data(core()))
 
-    expect(ripple('foo', versioned({}))).to.be.eql({})
-    expect(ripple('bar', versioned([]))).to.be.eql([])
+    expect(ripple('foo', {})).to.be.eql({})
+    expect(ripple('bar', [])).to.be.eql([])
     expect(ripple.version()).to.be.eql(1)
     expect(ripple.version.log).to.be.eql([
       [{ name: 'foo', index: 0 }]
@@ -80,11 +79,4 @@ describe('Versioned', function(){
     expect(ripple.version(undefined)).to.eql('could not rollback')
   })
 
-  it('should work gracefully with non-versioned data', function(){
-    var ripple = version(data(core()))
-    ripple('foo', [])
-    push('bar')(ripple('foo'))
-    expect(ripple.version.log).to.eql([])
-  })
-
 })