Rewrite in ES6 using webpack

.travis.yml

@@ -0,0 +1,5 @@
+language: node_js
+node_js: "5"
+
+before_script:
+  - webpack

README.md

@@ -33,10 +33,10 @@ $ npm install
 
 #### Building
 
-Rivets.js uses [gulp](http://gulpjs.com/) as it's build tool. Run the following task to compile + minify the source into `dist/`.
+Rivets.js uses [webpack](http://gulpjs.com/) as it's bundling / build tool. Run the following  to compile the source into `dist/`.
 
 ```
-$ gulp build
+$ npm run build
 ```
 
 #### Testing

docs/docs/guide/_sections/iteration/index.md

@@ -0,0 +1,17 @@
+To access the index of the current iteration use the syntax `%item%`, Where `item` is the name of the model you provided in `rv-each-[item]`.  You can also access the index of the iteration by using the key `index` but using this will access only the current iterations index. Note that when nesting `rv-each`'s the parent index is still accessible within the scope via the model name.
+
+```html
+<ul>
+  <li rv-each-user="app.users">
+    <span>User Index : { %user% }</span>
+
+    <ul>
+        <li rv-each-comment="user.comments">
+            <span>Comment Index : { %comment% }</span>
+
+            <span>User Index : { %user% }</span>
+        </li>
+    </ul>
+  </li>
+<ul>
+```

docs/docs/guide/_sections/usage/configuring.md

@@ -15,6 +15,11 @@ rivets.configure({
   // Template delimiters for text bindings
   templateDelimiters: ['{', '}'],
 
+  // Alias for index in rv-each binder
+  iterationAlias : function(modelName) {
+    return '%' + modelName + '%';
+  },
+
   // Augment the event handler of the on-* binder
   handler: function(target, event, binding) {
     this.call(target, event, binding.view.models)

package.json

@@ -19,21 +19,26 @@
     "sightglass": "~0.2.4"
   },
   "scripts": {
-    "test": "gulp spec",
-    "build": "gulp build"
+    "pretest": "babel src/parsers.js --out-file spec/lib/parsers.js --presets es2015 --plugins transform-es2015-modules-umd",
+    "test": "mocha-phantomjs spec/runner.html",
+    "build": "webpack"
   },
   "devDependencies": {
-    "mocha": "~1.20.1",
+
+    "minimist": "~1.1.0",
+    "mocha": "2.5.3",
     "should": "~4.0.4",
     "sinon": "~1.10.2",
-    "minimist": "~1.1.0",
-    "gulp": "~3.8.7",
-    "gulp-util": "~2.2.14",
-    "gulp-coffee": "~1.4.3",
-    "gulp-header": "~1.0.2",
-    "gulp-concat": "~2.2.0",
-    "gulp-uglify": "~0.3.0",
-    "gulp-bump": "~0.1.11",
-    "gulp-mocha-phantomjs": "~0.2.0"
+    "webpack": "1.13.1",
+    "babel-core": "6.9.1",
+    "babel-cli": "^6.0.0",
+    "mocha-phantomjs": "4.0.2",
+    "babel-loader" : "6.2.4",
+    "commander": "^2.8.1",
+    "mocha-phantomjs-core" : "1.3.1",
+    "babel-preset-es2015": "6.9.0",
+    "babel-plugin-transform-es2015-modules-umd": "6.8.0",
+    "phantomjs": "2.1.7",
+    "babel-plugin-add-module-exports" : "0.2.1"
   }
 }

spec/lib/parsers.js

@@ -0,0 +1,109 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(['exports'], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports);
+    global.parsers = mod.exports;
+  }
+})(this, function (exports) {
+  'use strict';
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  exports.parseType = parseType;
+  exports.parseTemplate = parseTemplate;
+  var PRIMITIVE = 0;
+  var KEYPATH = 1;
+  var TEXT = 0;
+  var BINDING = 1;
+
+  // Parser and tokenizer for getting the type and value from a string.
+  function parseType(string) {
+    var type = PRIMITIVE;
+    var value = string;
+
+    if (/^'.*'$|^".*"$/.test(string)) {
+      value = string.slice(1, -1);
+    } else if (string === 'true') {
+      value = true;
+    } else if (string === 'false') {
+      value = false;
+    } else if (string === 'null') {
+      value = null;
+    } else if (string === 'undefined') {
+      value = undefined;
+    } else if (isNaN(Number(string)) === false) {
+      value = Number(string);
+    } else {
+      type = KEYPATH;
+    }
+
+    return { type: type, value: value };
+  }
+
+  // Template parser and tokenizer for mustache-style text content bindings.
+  // Parses the template and returns a set of tokens, separating static portions
+  // of text from binding declarations.
+  function parseTemplate(template, delimiters) {
+    var tokens = [];
+    var length = template.length;
+    var index = 0;
+    var lastIndex = 0;
+
+    while (lastIndex < length) {
+      index = template.indexOf(delimiters[0], lastIndex);
+
+      if (index < 0) {
+        tokens.push({
+          type: TEXT,
+          value: template.slice(lastIndex)
+        });
+
+        break;
+      } else {
+        if (index > 0 && lastIndex < index) {
+          tokens.push({
+            type: TEXT,
+            value: template.slice(lastIndex, index)
+          });
+        }
+
+        lastIndex = index + delimiters[0].length;
+        index = template.indexOf(delimiters[1], lastIndex);
+
+        if (index < 0) {
+          var substring = template.slice(lastIndex - delimiters[1].length);
+          var lastToken = tokens[tokens.length - 1];
+
+          if (lastToken && lastToken.type === TEXT) {
+            lastToken.value += substring;
+          } else {
+            tokens.push({
+              type: TEXT,
+              value: substring
+            });
+          }
+
+          break;
+        }
+
+        var value = template.slice(lastIndex, index).trim();
+
+        tokens.push({
+          type: BINDING,
+          value: value
+        });
+
+        lastIndex = index + delimiters[1].length;
+      }
+    }
+
+    return tokens;
+  }
+});