unpoly-rails 0.20.0

data/spec_app/vendor/assets/bower_components/jasmine-ajax/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "jasmine-ajax",
+  "description": "A library for faking Ajax responses in your Jasmine suite",
+  "version": "3.2.0",
+  "main": "lib/mock-ajax.js",
+  "license": "MIT",
+
+  "url": "https://github.com/jasmine/jasmine-ajax",
+  "contributors": [
+    "Gregg Van Hove <gregg@slackersoft.net>",
+    "JR Boyens <jboyens@fooninja.org>"
+  ],
+  "private": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jasmine/jasmine-ajax"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "grunt": "0.4.0",
+    "grunt-cli": "~0.1.13",
+    "grunt-contrib-concat": "~0.5.0",
+    "grunt-contrib-jshint": "~0.1.1",
+    "grunt-shell": "~0.2.1"
+  }
+}

data/spec_app/vendor/assets/bower_components/jasmine-ajax/release_notes/2.0.2.md

@@ -0,0 +1,50 @@
+# Jasmine-Ajax 2.0.2 Release Notes
+
+## Summary
+
+Release of jasmine-ajax with many fixes to be more compatible with the full XHR spec.
+
+## Changes
+
+- Combine request headers with the same name
+- Find response case-insensitively
+- Split into multiple files for development
+  - We use the `getJasmineRequireObj()` for loading dependencies
+  - CI runs specs against both separate and concatenated files
+
+## Pull Requests and Issues
+- Allow progress event callbacks to be null instead of just empty functions.
+    - Fixes [#85](http://github.com/pivotal/jasmine-ajax/issues/85)
+
+- Support listening to XHR progress events via `addEventListener`
+    - Fixes [#79](http://github.com/pivotal/jasmine-ajax/issues/79)
+
+- Support all XHR events
+    - Fixes [#81](http://github.com/pivotal/jasmine-ajax/issues/81)
+    - Fixes [#82](http://github.com/pivotal/jasmine-ajax/issues/82)
+
+- Parse `responseText` into a `responseXML` if the contentType is xml-ish
+    - Fixes [#55](http://github.com/pivotal/jasmine-ajax/issues/55)
+
+- Un-pin jasmine dependency from version 2.0.0
+    - Merges [#76](http://github.com/pivotal/jasmine-ajax/issues/76) from @macroeyes
+
+- added support for multiple headers with same name
+    - Merges [#72](http://github.com/pivotal/jasmine-ajax/issues/72) from @resident-uhlig
+
+- Record overridden mime types
+    - Fixes [#74](http://github.com/pivotal/jasmine-ajax/issues/74)
+
+- Throw an error if response() is called more than once on requests
+    - Fixes [#70](http://github.com/pivotal/jasmine-ajax/issues/70)
+    - Merges [#71](http://github.com/pivotal/jasmine-ajax/issues/71) from @kmontag
+
+- Allow stubs to match only a particular http method (GET, POST, PUT, etc.)
+    - Fixes [#36](http://github.com/pivotal/jasmine-ajax/issues/36)
+
+- Add some files to the bower.json ignore list
+    - Merges [#69](http://github.com/pivotal/jasmine-ajax/issues/69 ) from @lencioni
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/spec_app/vendor/assets/bower_components/jasmine-ajax/release_notes/2.99.md

@@ -0,0 +1,14 @@
+# Jasmine-Ajax 2.99 Release Notes
+
+## Summary
+
+Release of jasmine-ajax to provide a non-breaking upgrade path as we move to support XHR 2.
+
+## Changes
+
+- Deprecate the `response` function on fake request in favor of `respondWith`.
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/spec_app/vendor/assets/bower_components/jasmine-ajax/release_notes/3.0.md

@@ -0,0 +1,28 @@
+# Jasmine-Ajax 3.0 Release Notes
+
+## Summary
+
+Support XHR 2
+
+This release contains a breaking change. The `response` method is no longer supported, you should use `respondWith` instead.
+
+## Changes
+
+* Add grunt tasks for releasing packages
+* Bring npm and bower configurations in line with each other
+* Also test in IE 11 on travis
+
+## Pull Requests & Issues
+
+* Include trailing newline in response headers to match browsers.
+    - Fixes [#91](https://github.com/jasmine/jasmine-ajax/issues/91)
+
+* modify example code 'response' method is deprecated. use 'respondWith' instead
+    - Merges [#87](https://github.com/jasmine/jasmine-ajax/issues/87) from @Mstudio-Ishikawa
+
+* Support for XHR 2
+    - Merges [#60](https://github.com/jasmine/jasmine-ajax/issues/60) from @albertyw
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/spec_app/vendor/assets/bower_components/jasmine-ajax/release_notes/3.1.0.md

@@ -0,0 +1,24 @@
+# Jasmine-Ajax 3.1 Release Notes
+
+## Summary
+
+This is a maintenance release.
+
+## Changes
+
+* Add safari 7 & 8 to browser matrix
+
+## Pull Requests & Issues
+
+* Add version number to combined file
+    - Fixes #93
+
+* Implement `removeEventListener`
+    - Merges #89 from @illiptic
+
+* Add `responseHeaders` to `andReturn` s options
+    - Merges #94 from @tomalec
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/spec_app/vendor/assets/bower_components/jasmine-ajax/release_notes/3.1.1.md

@@ -0,0 +1,23 @@
+# Jasmine-Ajax 3.1 Release Notes
+
+## Pull Requests & Issues
+
+* Loosen bower dependency on jasmine
+    - Fixes [#106](https://github.com/jasmine/jasmine-ajax/issues/106)
+
+* Event readystatechange is triggered when headers are available
+    - Merges [#104](https://github.com/jasmine/jasmine-ajax/issues/104) from @mjeanroy
+    - Fixes [#97](https://github.com/jasmine/jasmine-ajax/issues/97)
+    - Fixes [#103](https://github.com/jasmine/jasmine-ajax/issues/103)
+    - Fixes [#102](https://github.com/jasmine/jasmine-ajax/issues/102)
+
+* Throw error on duplicate calls to MockAjax#install.
+    - Merges [#98](https://github.com/jasmine/jasmine-ajax/issues/98) from @jhamon
+    - Fixes [#96](https://github.com/jasmine/jasmine-ajax/issues/96)
+
+* Readme tweaks and updated links
+    - Merges [#99](https://github.com/jasmine/jasmine-ajax/issues/99) from @jhamon
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/spec_app/vendor/assets/bower_components/jasmine-ajax/release_notes/3.2.0.md

@@ -0,0 +1,20 @@
+# Jasmine-Ajax 3.2.0 Release Notes
+
+## Pull Requests & Issues
+
+* Set the `this` context for event handler to the current XHR and pass proper ProgressEvent arguments
+    - Merges [#114](https://github.com/jasmine/jasmine-ajax/issues/114) from @mjeanroy
+    - Fixes [#108](https://github.com/jasmine/jasmine-ajax/issues/108)
+
+* added feature to match data/query against RegExp
+    - Merges [#116](https://github.com/jasmine/jasmine-ajax/issues/116) from @SunboX
+    - Fixes [#115](https://github.com/jasmine/jasmine-ajax/issues/115)
+
+* Allow error and timeout using RequestStub
+    - Merges [#112](https://github.com/jasmine/jasmine-ajax/issues/112) from @Mordred
+    - Fixes [#111](https://github.com/jasmine/jasmine-ajax/issues/111)
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

data/spec_app/vendor/assets/bower_components/jasmine-fixture/.bower.json

@@ -0,0 +1,27 @@
+{
+  "name": "jasmine-fixture",
+  "version": "1.3.3",
+  "main": "dist/jasmine-fixture.js",
+  "ignore": [
+    "app",
+    "config",
+    "spec",
+    "tasks",
+    ".travis.yml",
+    "Gruntfile.js",
+    "main.js",
+    "package.json"
+  ],
+  "dependencies": {},
+  "devDependencies": {},
+  "homepage": "https://github.com/searls/jasmine-fixture",
+  "_release": "1.3.3",
+  "_resolution": {
+    "type": "version",
+    "tag": "1.3.3",
+    "commit": "688c26fd5f56d7c843ae18f45f8cf87e4ebd7cb8"
+  },
+  "_source": "git://github.com/searls/jasmine-fixture.git",
+  "_target": "*",
+  "_originalSource": "jasmine-fixture"
+}

data/spec_app/vendor/assets/bower_components/jasmine-fixture/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+
+#ignore node_modules, as the node project is not "deployed" per se: http://www.mikealrogers.com/posts/nodemodules-in-git.html
+/node_modules
+
+/generated
+
+.sass-cache

data/spec_app/vendor/assets/bower_components/jasmine-fixture/.npmignore

@@ -0,0 +1,8 @@
+.DS_Store
+
+#ignore node_modules, as the node project is not "deployed" per se: http://www.mikealrogers.com/posts/nodemodules-in-git.html
+/node_modules
+
+/generated
+
+.sass-cache

data/spec_app/vendor/assets/bower_components/jasmine-fixture/LICENSE.txt

@@ -0,0 +1,24 @@
+=================================================
+jasmine-fixture is licensed under the MIT License
+=================================================
+
+Copyright (c) 2013 Test Double, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/spec_app/vendor/assets/bower_components/jasmine-fixture/README.md

@@ -0,0 +1,118 @@
+# jasmine-fixture
+
+[![Build Status](https://secure.travis-ci.org/searls/jasmine-fixture.png)](http://travis-ci.org/searls/jasmine-fixture)
+
+jasmine-fixture helps you write specs that interact with the DOM by making it easier to inject (and then clean up) HTML fixtures using a syntax that's just like jQuery's selectors. (As a result, it requires jQuery.)
+
+**[Download the latest version here](https://github.com/searls/jasmine-fixture/releases)**.
+
+# The concept
+
+Here's one way to think about it:
+
+In *jQuery*, you give `$()` a CSS selector and it *finds* elements on the DOM.
+
+In *jasmine-fixture*, you give `affix()` a CSS selector and it *adds* those elements to the DOM.
+
+This is very useful for tests, because it means that after setting up the state of the DOM with `affix`, your subject code under test will have the elements it needs to do its work.
+
+Finally, jasmine-fixture will help you avoid test pollution by tidying up and remove everything you affix to the DOM after each spec runs.
+
+## affix() example
+
+Let's say you want to write a Jasmine spec for some code that needs to select elements from the DOM with jQuery:
+
+``` javascript
+$('#toddler .hidden.toy input[name="toyName"][value="cuddle bunny"]')
+```
+
+In the good ol' days of manually crafting your HTML fixtures, you'd have to append some raw HTML to the DOM like this:
+
+``` javascript
+beforeEach(function(){
+  $('<div id="toddler"><div class="hidden toy"><input name="toyName" value="cuddle bunny"></div></div>').appendTo('body');
+});
+
+afterEach(function(){
+  $('#toddler').remove()
+});
+```
+
+But jasmine-fixture's `affix` method lets you do this instead:
+
+``` javascript
+beforeEach(function(){
+  affix('#toddler .hidden.toy input[name="toyName"][value="cuddle bunny"]')
+});
+
+```
+
+That's right, the spec setup above was able to *re-use the exact same ugly jQuery selector* and everything just worked! That means:
+
+* No external (or worse, shared) fixture files means no risk that they become dumping grounds
+* The spec can remain comprehensive (meaning that future readers can understand what the code does without referencing an external file)
+* Less temptation to couple your unit test to your server or client-side HTML templates
+* More one-line setup, fewer multi-line globs of HTML crowding out the behavior your spec is trying to describe
+
+Bottom line: it's just like jQuery, but in reverse! (And, of course, it'll clean up after itself after your spec runs.)
+
+## affixing the affixed by chaining invocations
+
+`#affix` is both a globally available property on the `window` as well as a jQuery plugin that can be chained with existing jQuery objects (affixing itself beneath their results).
+
+Let's say our subject has a `$container` element that's been added to the DOM like this:
+
+``` javascript
+var $container = affix('.container')
+```
+
+That means we can add things to the container by chaining a call to `affix`, like any other jQuery plugin:
+
+``` javascript
+var $content = $container.affix('#content')
+```
+
+Now our container with the class "container" has some content with the ID "content". Huzzah!
+
+Note that for easy assignability, affix will always return the topmost element of the thing that it just appended, which in this example is `<div id="content"></div>` (which runs counter to most jQuery plugins, which return the original jQuery object).
+
+## more examples
+
+I heard you wanted more examples, so I pulled some from `affix`'s [specs](https://github.com/searls/jasmine-fixture/blob/master/spec/affix-spec.coffee).
+
+``` coffeescript
+'span'                                                                  #<span></span>
+'.foo'                                                                  #<div class="foo"></div>
+'.foo-hah'                                                              #<div class="foo-hah"></div>
+'#baz'                                                                  #<div id="baz"></div>
+'h1.foo'                                                                #<h1 class="foo"></h1>
+'h2#baz'                                                                #<h2 id="baz"></h2>
+'h3#zing.zoom'                                                          #<h3 id="zing" class="zoom"></h3>
+'h4.zoom#zing'                                                          #<h4 id="zing" class="zoom"></h4>
+'div span ul li'                                                        #<div><span><ul><li></li></ul></span></div>
+'a b c d e f g h i j k l m n o p q r s t u v w x y z'                   #<a><b><c><d><e><f><g><h><i><j><k><l><m><n><o><p><q><r><s><t><u><v><w><x><y><z></z></y></x></w></v></u></t></s></r></q></p></o></n></m></l></k></j></i></h></g></f></e></d></c></b></a>
+'.boom.bang.pow#whoosh'                                                 #<div id="whoosh" class="boom bang pow"></div>
+'#foo .panda'                                                           #<div id="foo"><div class="panda"></div></div>
+'input#man .restroom'                                                   #<input id="man"></input>
+'.pants.zipper'                                                         #<div class="pants zipper"></div>
+'foo > bar > baz'                                                       #<foo><bar><baz></baz></bar></foo>
+'input[value="12"]'                                                     #<input value="12">
+'div[class="class1 class2 class3"] span[div="div1 div2 div3"]'          #<div class="class1 class2 class3"><span div="div1 div2 div3"></span></div>
+'form fieldset[name=ok] input#foo.sp1.sp1[foo="woo"][value="13"]'       #<form><fieldset name="ok"><input foo="woo" value="13" id="foo" class="sp1 sp1"></fieldset></form>
+'[name="foo"][bar="baz"]'                                               #<name name="foo" bar="baz"></name>
+'div[data-bind="my_item"]'                                              #<div data-bind="my_item"></div>
+'.ui-dialog[style="width: 1px; height: 5px"]'                           #<div style="width: 1px; height: 5px" class="ui-dialog"></div>
+'#toddler .hidden.toy input[name="toyName"][value="cuddle bunny"]'      #<div id="toddler"><div class="hidden toy"><input name="toyName" value="cuddle bunny"></div></div>
+'div h1+h2'                                                             #<div><h1></h1><h2></h2></div>
+```
+# Contributing
+
+1. `npm install -g lineman` if you don't already have lineman installed.
+2. `lineman build`
+3. `lineman spec` to run the fast, isolated specs.
+4. Add your feature or bug fix on a feature branch, with tests.
+5. Submit a pull request.
+
+# Thanks
+
+I want to offer thanks to Mike Kent, whose [JavaScript port of ZenCoding](https://github.com/zodoz/jquery-ZenCoding) was the basis for parsing most of this (classes, ids, elements, etc.). I also want to thank [Peter Kananen](https://twitter.com/#!/pkananen), for pairing with me on the initial spike of the `affix` method.

data/spec_app/vendor/assets/bower_components/jasmine-fixture/bower.json

@@ -0,0 +1,17 @@
+{
+  "name": "jasmine-fixture",
+  "version": "1.3.3",
+  "main": "dist/jasmine-fixture.js",
+  "ignore": [
+    "app",
+    "config",
+    "spec",
+    "tasks",
+    ".travis.yml",
+    "Gruntfile.js",
+    "main.js",
+    "package.json"
+  ],
+  "dependencies": {},
+  "devDependencies": {}
+}

data/spec_app/vendor/assets/bower_components/jasmine-fixture/dist/jasmine-fixture.js

@@ -0,0 +1,433 @@
+/* jasmine-fixture - 1.3.3
+ * Makes injecting HTML snippets into the DOM easy & clean!
+ * https://github.com/searls/jasmine-fixture
+ */
+(function() {
+  var createHTMLBlock,
+    __slice = [].slice;
+
+  (function($) {
+    var ewwSideEffects, jasmineFixture, originalAffix, originalJasmineDotFixture, originalJasmineFixture, root, _, _ref;
+    root = (1, eval)('this');
+    originalJasmineFixture = root.jasmineFixture;
+    originalJasmineDotFixture = (_ref = root.jasmine) != null ? _ref.fixture : void 0;
+    originalAffix = root.affix;
+    _ = function(list) {
+      return {
+        inject: function(iterator, memo) {
+          var item, _i, _len, _results;
+          _results = [];
+          for (_i = 0, _len = list.length; _i < _len; _i++) {
+            item = list[_i];
+            _results.push(memo = iterator(memo, item));
+          }
+          return _results;
+        }
+      };
+    };
+    root.jasmineFixture = function($) {
+      var $whatsTheRootOf, affix, create, jasmineFixture, noConflict;
+      affix = function(selectorOptions) {
+        return create.call(this, selectorOptions, true);
+      };
+      create = function(selectorOptions, attach) {
+        var $top;
+        $top = null;
+        _(selectorOptions.trim().split(/[ ](?![^\{]*\})(?=[^\]]*?(?:\[|$))/)).inject(function($parent, elementSelector) {
+          var $el;
+          if (elementSelector === ">") {
+            return $parent;
+          }
+          $el = createHTMLBlock($, elementSelector);
+          if (attach || $top) {
+            $el.appendTo($parent);
+          }
+          $top || ($top = $el);
+          return $el;
+        }, $whatsTheRootOf(this));
+        return $top;
+      };
+      noConflict = function() {
+        var currentJasmineFixture, _ref1;
+        currentJasmineFixture = jasmine.fixture;
+        root.jasmineFixture = originalJasmineFixture;
+        if ((_ref1 = root.jasmine) != null) {
+          _ref1.fixture = originalJasmineDotFixture;
+        }
+        root.affix = originalAffix;
+        return currentJasmineFixture;
+      };
+      $whatsTheRootOf = function(that) {
+        if ((that != null ? that.jquery : void 0) != null) {
+          return that;
+        } else if ($('#jasmine_content').length > 0) {
+          return $('#jasmine_content');
+        } else {
+          return $('<div id="jasmine_content"></div>').appendTo('body');
+        }
+      };
+      jasmineFixture = {
+        affix: affix,
+        create: create,
+        noConflict: noConflict
+      };
+      ewwSideEffects(jasmineFixture);
+      return jasmineFixture;
+    };
+    ewwSideEffects = function(jasmineFixture) {
+      var _ref1;
+      if ((_ref1 = root.jasmine) != null) {
+        _ref1.fixture = jasmineFixture;
+      }
+      $.fn.affix = root.affix = jasmineFixture.affix;
+      return afterEach(function() {
+        return $('#jasmine_content').remove();
+      });
+    };
+    if ($) {
+      return jasmineFixture = root.jasmineFixture($);
+    } else {
+      return root.affix = function() {
+        var nowJQueryExists;
+        nowJQueryExists = window.jQuery || window.$;
+        if (nowJQueryExists != null) {
+          jasmineFixture = root.jasmineFixture(nowJQueryExists);
+          return affix.call.apply(affix, [this].concat(__slice.call(arguments)));
+        } else {
+          throw new Error("jasmine-fixture requires jQuery to be defined at window.jQuery or window.$");
+        }
+      };
+    }
+  })(window.jQuery || window.$);
+
+  createHTMLBlock = (function() {
+    var bindData, bindEvents, parseAttributes, parseClasses, parseContents, parseEnclosure, parseReferences, parseVariableScope, regAttr, regAttrDfn, regAttrs, regCBrace, regClass, regClasses, regData, regDatas, regEvent, regEvents, regExclamation, regId, regReference, regTag, regTagNotContent, regZenTagDfn;
+    createHTMLBlock = function($, ZenObject, data, functions, indexes) {
+      var ZenCode, arr, block, blockAttrs, blockClasses, blockHTML, blockId, blockTag, blocks, el, el2, els, forScope, indexName, inner, len, obj, origZenCode, paren, result, ret, zc, zo;
+      if ($.isPlainObject(ZenObject)) {
+        ZenCode = ZenObject.main;
+      } else {
+        ZenCode = ZenObject;
+        ZenObject = {
+          main: ZenCode
+        };
+      }
+      origZenCode = ZenCode;
+      if (indexes === undefined) {
+        indexes = {};
+      }
+      if (ZenCode.charAt(0) === "!" || $.isArray(data)) {
+        if ($.isArray(data)) {
+          forScope = ZenCode;
+        } else {
+          obj = parseEnclosure(ZenCode, "!");
+          obj = obj.substring(obj.indexOf(":") + 1, obj.length - 1);
+          forScope = parseVariableScope(ZenCode);
+        }
+        while (forScope.charAt(0) === "@") {
+          forScope = parseVariableScope("!for:!" + parseReferences(forScope, ZenObject));
+        }
+        zo = ZenObject;
+        zo.main = forScope;
+        el = $();
+        if (ZenCode.substring(0, 5) === "!for:" || $.isArray(data)) {
+          if (!$.isArray(data) && obj.indexOf(":") > 0) {
+            indexName = obj.substring(0, obj.indexOf(":"));
+            obj = obj.substr(obj.indexOf(":") + 1);
+          }
+          arr = ($.isArray(data) ? data : data[obj]);
+          zc = zo.main;
+          if ($.isArray(arr) || $.isPlainObject(arr)) {
+            $.map(arr, function(value, index) {
+              var next;
+              zo.main = zc;
+              if (indexName !== undefined) {
+                indexes[indexName] = index;
+              }
+              if (!$.isPlainObject(value)) {
+                value = {
+                  value: value
+                };
+              }
+              next = createHTMLBlock($, zo, value, functions, indexes);
+              if (el.length !== 0) {
+                return $.each(next, function(index, value) {
+                  return el.push(value);
+                });
+              }
+            });
+          }
+          if (!$.isArray(data)) {
+            ZenCode = ZenCode.substr(obj.length + 6 + forScope.length);
+          } else {
+            ZenCode = "";
+          }
+        } else if (ZenCode.substring(0, 4) === "!if:") {
+          result = parseContents("!" + obj + "!", data, indexes);
+          if (result !== "undefined" || result !== "false" || result !== "") {
+            el = createHTMLBlock($, zo, data, functions, indexes);
+          }
+          ZenCode = ZenCode.substr(obj.length + 5 + forScope.length);
+        }
+        ZenObject.main = ZenCode;
+      } else if (ZenCode.charAt(0) === "(") {
+        paren = parseEnclosure(ZenCode, "(", ")");
+        inner = paren.substring(1, paren.length - 1);
+        ZenCode = ZenCode.substr(paren.length);
+        zo = ZenObject;
+        zo.main = inner;
+        el = createHTMLBlock($, zo, data, functions, indexes);
+      } else {
+        blocks = ZenCode.match(regZenTagDfn);
+        block = blocks[0];
+        if (block.length === 0) {
+          return "";
+        }
+        if (block.indexOf("@") >= 0) {
+          ZenCode = parseReferences(ZenCode, ZenObject);
+          zo = ZenObject;
+          zo.main = ZenCode;
+          return createHTMLBlock($, zo, data, functions, indexes);
+        }
+        block = parseContents(block, data, indexes);
+        blockClasses = parseClasses($, block);
+        if (regId.test(block)) {
+          blockId = regId.exec(block)[1];
+        }
+        blockAttrs = parseAttributes(block, data);
+        blockTag = (block.charAt(0) === "{" ? "span" : "div");
+        if (ZenCode.charAt(0) !== "#" && ZenCode.charAt(0) !== "." && ZenCode.charAt(0) !== "{") {
+          blockTag = regTag.exec(block)[1];
+        }
+        if (block.search(regCBrace) !== -1) {
+          blockHTML = block.match(regCBrace)[1];
+        }
+        blockAttrs = $.extend(blockAttrs, {
+          id: blockId,
+          "class": blockClasses,
+          html: blockHTML
+        });
+        el = $("<" + blockTag + ">", blockAttrs);
+        el.attr(blockAttrs);
+        el = bindEvents(block, el, functions);
+        el = bindData(block, el, data);
+        ZenCode = ZenCode.substr(blocks[0].length);
+        ZenObject.main = ZenCode;
+      }
+      if (ZenCode.length > 0) {
+        if (ZenCode.charAt(0) === ">") {
+          if (ZenCode.charAt(1) === "(") {
+            zc = parseEnclosure(ZenCode.substr(1), "(", ")");
+            ZenCode = ZenCode.substr(zc.length + 1);
+          } else if (ZenCode.charAt(1) === "!") {
+            obj = parseEnclosure(ZenCode.substr(1), "!");
+            forScope = parseVariableScope(ZenCode.substr(1));
+            zc = obj + forScope;
+            ZenCode = ZenCode.substr(zc.length + 1);
+          } else {
+            len = Math.max(ZenCode.indexOf("+"), ZenCode.length);
+            zc = ZenCode.substring(1, len);
+            ZenCode = ZenCode.substr(len);
+          }
+          zo = ZenObject;
+          zo.main = zc;
+          els = $(createHTMLBlock($, zo, data, functions, indexes));
+          els.appendTo(el);
+        }
+        if (ZenCode.charAt(0) === "+") {
+          zo = ZenObject;
+          zo.main = ZenCode.substr(1);
+          el2 = createHTMLBlock($, zo, data, functions, indexes);
+          $.each(el2, function(index, value) {
+            return el.push(value);
+          });
+        }
+      }
+      ret = el;
+      return ret;
+    };
+    bindData = function(ZenCode, el, data) {
+      var datas, i, split;
+      if (ZenCode.search(regDatas) === 0) {
+        return el;
+      }
+      datas = ZenCode.match(regDatas);
+      if (datas === null) {
+        return el;
+      }
+      i = 0;
+      while (i < datas.length) {
+        split = regData.exec(datas[i]);
+        if (split[3] === undefined) {
+          $(el).data(split[1], data[split[1]]);
+        } else {
+          $(el).data(split[1], data[split[3]]);
+        }
+        i++;
+      }
+      return el;
+    };
+    bindEvents = function(ZenCode, el, functions) {
+      var bindings, fn, i, split;
+      if (ZenCode.search(regEvents) === 0) {
+        return el;
+      }
+      bindings = ZenCode.match(regEvents);
+      if (bindings === null) {
+        return el;
+      }
+      i = 0;
+      while (i < bindings.length) {
+        split = regEvent.exec(bindings[i]);
+        if (split[2] === undefined) {
+          fn = functions[split[1]];
+        } else {
+          fn = functions[split[2]];
+        }
+        $(el).bind(split[1], fn);
+        i++;
+      }
+      return el;
+    };
+    parseAttributes = function(ZenBlock, data) {
+      var attrStrs, attrs, i, parts;
+      if (ZenBlock.search(regAttrDfn) === -1) {
+        return undefined;
+      }
+      attrStrs = ZenBlock.match(regAttrDfn);
+      attrs = {};
+      i = 0;
+      while (i < attrStrs.length) {
+        parts = regAttr.exec(attrStrs[i]);
+        attrs[parts[1]] = "";
+        if (parts[3] !== undefined) {
+          attrs[parts[1]] = parseContents(parts[3], data);
+        }
+        i++;
+      }
+      return attrs;
+    };
+    parseClasses = function($, ZenBlock) {
+      var classes, clsString, i;
+      ZenBlock = ZenBlock.match(regTagNotContent)[0];
+      if (ZenBlock.search(regClasses) === -1) {
+        return undefined;
+      }
+      classes = ZenBlock.match(regClasses);
+      clsString = "";
+      i = 0;
+      while (i < classes.length) {
+        clsString += " " + regClass.exec(classes[i])[1];
+        i++;
+      }
+      return $.trim(clsString);
+    };
+    parseContents = function(ZenBlock, data, indexes) {
+      var html;
+      if (indexes === undefined) {
+        indexes = {};
+      }
+      html = ZenBlock;
+      if (data === undefined) {
+        return html;
+      }
+      while (regExclamation.test(html)) {
+        html = html.replace(regExclamation, function(str, str2) {
+          var begChar, fn, val;
+          begChar = "";
+          if (str.indexOf("!for:") > 0 || str.indexOf("!if:") > 0) {
+            return str;
+          }
+          if (str.charAt(0) !== "!") {
+            begChar = str.charAt(0);
+            str = str.substring(2, str.length - 1);
+          }
+          fn = new Function("data", "indexes", "var r=undefined;" + "with(data){try{r=" + str + ";}catch(e){}}" + "with(indexes){try{if(r===undefined)r=" + str + ";}catch(e){}}" + "return r;");
+          val = unescape(fn(data, indexes));
+          return begChar + val;
+        });
+      }
+      html = html.replace(/\\./g, function(str) {
+        return str.charAt(1);
+      });
+      return unescape(html);
+    };
+    parseEnclosure = function(ZenCode, open, close, count) {
+      var index, ret;
+      if (close === undefined) {
+        close = open;
+      }
+      index = 1;
+      if (count === undefined) {
+        count = (ZenCode.charAt(0) === open ? 1 : 0);
+      }
+      if (count === 0) {
+        return;
+      }
+      while (count > 0 && index < ZenCode.length) {
+        if (ZenCode.charAt(index) === close && ZenCode.charAt(index - 1) !== "\\") {
+          count--;
+        } else {
+          if (ZenCode.charAt(index) === open && ZenCode.charAt(index - 1) !== "\\") {
+            count++;
+          }
+        }
+        index++;
+      }
+      ret = ZenCode.substring(0, index);
+      return ret;
+    };
+    parseReferences = function(ZenCode, ZenObject) {
+      ZenCode = ZenCode.replace(regReference, function(str) {
+        var fn;
+        str = str.substr(1);
+        fn = new Function("objs", "var r=\"\";" + "with(objs){try{" + "r=" + str + ";" + "}catch(e){}}" + "return r;");
+        return fn(ZenObject, parseReferences);
+      });
+      return ZenCode;
+    };
+    parseVariableScope = function(ZenCode) {
+      var forCode, rest, tag;
+      if (ZenCode.substring(0, 5) !== "!for:" && ZenCode.substring(0, 4) !== "!if:") {
+        return undefined;
+      }
+      forCode = parseEnclosure(ZenCode, "!");
+      ZenCode = ZenCode.substr(forCode.length);
+      if (ZenCode.charAt(0) === "(") {
+        return parseEnclosure(ZenCode, "(", ")");
+      }
+      tag = ZenCode.match(regZenTagDfn)[0];
+      ZenCode = ZenCode.substr(tag.length);
+      if (ZenCode.length === 0 || ZenCode.charAt(0) === "+") {
+        return tag;
+      } else if (ZenCode.charAt(0) === ">") {
+        rest = "";
+        rest = parseEnclosure(ZenCode.substr(1), "(", ")", 1);
+        return tag + ">" + rest;
+      }
+      return undefined;
+    };
+    regZenTagDfn = /([#\.\@]?[\w-]+|\[([\w-!?=:"']+(="([^"]|\\")+")? {0,})+\]|\~[\w$]+=[\w$]+|&[\w$]+(=[\w$]+)?|[#\.\@]?!([^!]|\\!)+!){0,}(\{([^\}]|\\\})+\})?/i;
+    regTag = /(\w+)/i;
+    regId = /(?:^|\b)#([\w-!]+)/i;
+    regTagNotContent = /((([#\.]?[\w-]+)?(\[([\w!]+(="([^"]|\\")+")? {0,})+\])?)+)/i;
+    /*
+     See lookahead syntax (?!) at https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp
+    */
+
+    regClasses = /(\.[\w-]+)(?!["\w])/g;
+    regClass = /\.([\w-]+)/i;
+    regReference = /(@[\w$_][\w$_\d]+)/i;
+    regAttrDfn = /(\[([\w-!]+(="?([^"]|\\")+"?)? {0,})+\])/ig;
+    regAttrs = /([\w-!]+(="([^"]|\\")+")?)/g;
+    regAttr = /([\w-!]+)(="?((([\w]+(\[.*?\])+)|[^"\]]|\\")+)"?)?/i;
+    regCBrace = /\{(([^\}]|\\\})+)\}/i;
+    regExclamation = /(?:([^\\]|^))!([^!]|\\!)+!/g;
+    regEvents = /\~[\w$]+(=[\w$]+)?/g;
+    regEvent = /\~([\w$]+)=([\w$]+)/i;
+    regDatas = /&[\w$]+(=[\w$]+)?/g;
+    regData = /&([\w$]+)(=([\w$]+))?/i;
+    return createHTMLBlock;
+  })();
+
+}).call(this);