Izmjenjena struktura, dodan backand

web/node_modules/dom-converter/scripts/js/lib/domConverter.js

@@ -0,0 +1,33 @@
+// Generated by CoffeeScript 1.6.3
+var domToMarkup, object, objectToSaneObject, saneObjectToDom, self;
+
+objectToSaneObject = require('./objectToSaneObject');
+
+saneObjectToDom = require('./saneObjectToDom');
+
+domToMarkup = require('./domToMarkup');
+
+object = require('utila').object;
+
+module.exports = self = {
+  objectToDom: function(o) {
+    o = self._object2SaneObject(o);
+    return saneObjectToDom.convert(o);
+  },
+  object2markup: function(o) {
+    var dom;
+    dom = self.toDom(o);
+    return domToMarkup.convert(dom);
+  },
+  domToMarkup: function(dom) {
+    return domToMarkup.convert(dom);
+  },
+  _object2SaneObject: function(o) {
+    if (!Array.isArray(o)) {
+      if (!object.isBareObject(o)) {
+        throw Error("toDom() only accepts arrays and bare objects as input");
+      }
+    }
+    return objectToSaneObject.sanitize(o);
+  }
+};

web/node_modules/dom-converter/scripts/js/lib/domToMarkup.js

@@ -0,0 +1,2 @@
+// Generated by CoffeeScript 1.6.3
+

web/node_modules/dom-converter/scripts/js/lib/dummer.js

@@ -0,0 +1,123 @@
+var dummer, object, sanitizer,
+  __hasProp = {}.hasOwnProperty;
+
+object = require('utila').object;
+
+sanitizer = require('./sanitizer');
+
+module.exports = dummer = {
+  toDom: function(o) {
+    if (!Array.isArray(o)) {
+      if (!object.isBareObject(o)) {
+        throw Error("toDom() only accepts arrays and bare objects as input");
+      }
+    }
+    o = sanitizer.sanitize(o);
+    return dummer._children(o);
+  },
+  _children: function(a, parent) {
+    var children, node, prev, v, _i, _len;
+    if (parent == null) {
+      parent = null;
+    }
+    children = [];
+    prev = null;
+    for (_i = 0, _len = a.length; _i < _len; _i++) {
+      v = a[_i];
+      if (typeof v === 'string') {
+        node = dummer._textNode(v);
+      } else {
+        node = dummer._objectToDom(v, parent);
+        node.prev = null;
+        node.next = null;
+        node.parent = parent;
+        if (prev != null) {
+          node.prev = prev;
+          prev.next = node;
+        }
+        prev = node;
+      }
+      children.push(node);
+    }
+    return children;
+  },
+  _objectToDom: function(o) {
+    var attribs, children, i, k, key, name, node, v, val, _ref;
+    i = 0;
+    for (k in o) {
+      if (!__hasProp.call(o, k)) continue;
+      v = o[k];
+      if (i > 0) {
+        throw Error("_objectToDom() only accepts an object with one key/value");
+      }
+      key = k;
+      val = v;
+      i++;
+    }
+    node = {};
+    if (typeof key !== 'string') {
+      throw Error("_objectToDom()'s key must be a string of tag name and classes");
+    }
+    if (typeof val === 'string') {
+      children = [dummer._textNode(val)];
+    } else if (Array.isArray(val)) {
+      children = dummer._children(val, node);
+    } else {
+      inspect(o);
+      throw Error("_objectToDom()'s key's value must only be a string or an array");
+    }
+    node.type = 'tag';
+    _ref = dummer._parseTag(key), name = _ref.name, attribs = _ref.attribs;
+    node.name = name;
+    node.attribs = attribs;
+    node.children = children;
+    return node;
+  },
+  _textNode: function(s) {
+    return {
+      type: 'text',
+      data: s
+    };
+  },
+  _nameRx: /^[a-zA-Z\-\_]{1}[a-zA-Z0-9\-\_]*$/,
+  _parseTag: function(k) {
+    var attribs, classes, cls, id, m, name, parts;
+    if (!k.match(/^[a-zA-Z0-9\#\-\_\.\[\]\"\'\=\,\s]+$/) || k.match(/^[0-9]+/)) {
+      throw Error("cannot parse tag `" + k + "`");
+    }
+    attribs = {};
+    parts = {
+      name: '',
+      attribs: attribs
+    };
+    if (m = k.match(/^([^\.#]+)/)) {
+      name = m[1];
+      if (!name.match(dummer._nameRx)) {
+        throw Error("tag name `" + name + "` is not valid");
+      }
+      parts.name = name;
+      k = k.substr(name.length, k.length);
+    }
+    if (m = k.match(/^#([a-zA-Z0-9\-]+)/)) {
+      id = m[1];
+      if (!id.match(dummer._nameRx)) {
+        throw Error("tag id `" + id + "` is not valid");
+      }
+      attribs.id = id;
+      k = k.substr(id.length + 1, k.length);
+    }
+    classes = [];
+    while (m = k.match(/\.([a-zA-Z0-9\-\_]+)/)) {
+      cls = m[1];
+      if (!cls.match(dummer._nameRx)) {
+        throw Error("tag class `" + cls + "` is not valid");
+      }
+      classes.push(cls);
+      k = k.replace('.' + cls, '');
+    }
+    if (classes.length) {
+      attribs["class"] = classes.join(" ");
+    }
+    return parts;
+  }
+};

web/node_modules/dom-converter/scripts/js/lib/objectToSaneObject.js

@@ -0,0 +1,63 @@
+// Generated by CoffeeScript 1.6.3
+var object, self,
+  __hasProp = {}.hasOwnProperty;
+
+object = require('utila').object;
+
+module.exports = self = {
+  sanitize: function(val) {
+    return self._toChildren(val);
+  },
+  _toChildren: function(val) {
+    var _ref;
+    if (object.isBareObject(val)) {
+      return self._objectToChildren(val);
+    } else if (Array.isArray(val)) {
+      return self._arrayToChildren(val);
+    } else if (val === null || typeof val === 'undefined') {
+      return [];
+    } else if ((_ref = typeof val) === 'string' || _ref === 'number') {
+      return [String(val)];
+    } else {
+      throw Error("not a valid child node: `" + val);
+    }
+  },
+  _objectToChildren: function(o) {
+    var a, cur, key, val;
+    a = [];
+    for (key in o) {
+      if (!__hasProp.call(o, key)) continue;
+      val = o[key];
+      cur = {};
+      cur[key] = self.sanitize(val);
+      a.push(cur);
+    }
+    return a;
+  },
+  _arrayToChildren: function(a) {
+    var ret, v, _i, _len;
+    ret = [];
+    for (_i = 0, _len = a.length; _i < _len; _i++) {
+      v = a[_i];
+      ret.push(self._toNode(v));
+    }
+    return ret;
+  },
+  _toNode: function(o) {
+    var key, keys, obj, _ref;
+    if ((_ref = typeof o) === 'string' || _ref === 'number') {
+      return String(o);
+    } else if (object.isBareObject(o)) {
+      keys = Object.keys(o);
+      if (keys.length !== 1) {
+        throw Error("a node must only have one key as tag name");
+      }
+      key = keys[0];
+      obj = {};
+      obj[key] = self._toChildren(o[key]);
+      return obj;
+    } else {
+      throw Error("not a valid node: `" + o + "`");
+    }
+  }
+};

web/node_modules/dom-converter/scripts/js/lib/saneObjectToDom.js

@@ -0,0 +1,114 @@
+// Generated by CoffeeScript 1.6.3
+var self,
+  __hasProp = {}.hasOwnProperty;
+
+module.exports = self = {
+  convert: function(obj) {
+    return self._arrayToChildren(obj);
+  },
+  _arrayToChildren: function(a, parent) {
+    var children, node, prev, v, _i, _len;
+    if (parent == null) {
+      parent = null;
+    }
+    children = [];
+    prev = null;
+    for (_i = 0, _len = a.length; _i < _len; _i++) {
+      v = a[_i];
+      if (typeof v === 'string') {
+        node = self._getTextNodeFor(v);
+      } else {
+        node = self._objectToNode(v, parent);
+        node.prev = null;
+        node.next = null;
+        node.parent = parent;
+        if (prev != null) {
+          node.prev = prev;
+          prev.next = node;
+        }
+        prev = node;
+      }
+      children.push(node);
+    }
+    return children;
+  },
+  _objectToNode: function(o) {
+    var attribs, children, i, k, key, name, node, v, val, _ref;
+    i = 0;
+    for (k in o) {
+      if (!__hasProp.call(o, k)) continue;
+      v = o[k];
+      if (i > 0) {
+        throw Error("_objectToNode() only accepts an object with one key/value");
+      }
+      key = k;
+      val = v;
+      i++;
+    }
+    node = {};
+    if (typeof key !== 'string') {
+      throw Error("_objectToNode()'s key must be a string of tag name and classes");
+    }
+    if (typeof val === 'string') {
+      children = [self._getTextNodeFor(val)];
+    } else if (Array.isArray(val)) {
+      children = self._arrayToChildren(val, node);
+    } else {
+      inspect(o);
+      throw Error("_objectToNode()'s key's value must only be a string or an array");
+    }
+    node.type = 'tag';
+    _ref = self._parseTag(key), name = _ref.name, attribs = _ref.attribs;
+    node.name = name;
+    node.attribs = attribs;
+    node.children = children;
+    return node;
+  },
+  _getTextNodeFor: function(s) {
+    return {
+      type: 'text',
+      data: s
+    };
+  },
+  _nameRx: /^[a-zA-Z\-\_]{1}[a-zA-Z0-9\-\_]*$/,
+  _parseTag: function(k) {
+    var attribs, classes, cls, id, m, name, parts;
+    if (!k.match(/^[a-zA-Z0-9\#\-\_\.\[\]\"\'\=\,\s]+$/) || k.match(/^[0-9]+/)) {
+      throw Error("cannot parse tag `" + k + "`");
+    }
+    attribs = {};
+    parts = {
+      name: '',
+      attribs: attribs
+    };
+    if (m = k.match(/^([^\.#]+)/)) {
+      name = m[1];
+      if (!name.match(self._nameRx)) {
+        throw Error("tag name `" + name + "` is not valid");
+      }
+      parts.name = name;
+      k = k.substr(name.length, k.length);
+    }
+    if (m = k.match(/^#([a-zA-Z0-9\-]+)/)) {
+      id = m[1];
+      if (!id.match(self._nameRx)) {
+        throw Error("tag id `" + id + "` is not valid");
+      }
+      attribs.id = id;
+      k = k.substr(id.length + 1, k.length);
+    }
+    classes = [];
+    while (m = k.match(/\.([a-zA-Z0-9\-\_]+)/)) {
+      cls = m[1];
+      if (!cls.match(self._nameRx)) {
+        throw Error("tag class `" + cls + "` is not valid");
+      }
+      classes.push(cls);
+      k = k.replace('.' + cls, '');
+    }
+    if (classes.length) {
+      attribs["class"] = classes.join(" ");
+    }
+    return parts;
+  }
+};

web/node_modules/dom-converter/scripts/js/lib/saneObjectToMarkup.js

@@ -0,0 +1 @@
+

web/node_modules/dom-converter/scripts/js/lib/sanitizer.js

@@ -0,0 +1,62 @@
+var object, sanitizer,
+  __hasProp = {}.hasOwnProperty;
+
+object = require('utila').object;
+
+module.exports = sanitizer = {
+  sanitize: function(val) {
+    return sanitizer._sanitizeAsChildren(val);
+  },
+  _sanitizeAsChildren: function(val) {
+    var _ref;
+    if (object.isBareObject(val)) {
+      return sanitizer._sanitizeObjectAsChildren(val);
+    } else if (Array.isArray(val)) {
+      return sanitizer._sanitizeArrayAsChildren(val);
+    } else if (val === null || typeof val === 'undefined') {
+      return [];
+    } else if ((_ref = typeof val) === 'string' || _ref === 'number') {
+      return [String(val)];
+    } else {
+      throw Error("not a valid child node: `" + val);
+    }
+  },
+  _sanitizeObjectAsChildren: function(o) {
+    var a, cur, key, val;
+    a = [];
+    for (key in o) {
+      if (!__hasProp.call(o, key)) continue;
+      val = o[key];
+      cur = {};
+      cur[key] = sanitizer.sanitize(val);
+      a.push(cur);
+    }
+    return a;
+  },
+  _sanitizeArrayAsChildren: function(a) {
+    var ret, v, _i, _len;
+    ret = [];
+    for (_i = 0, _len = a.length; _i < _len; _i++) {
+      v = a[_i];
+      ret.push(sanitizer._sanitizeAsNode(v));
+    }
+    return ret;
+  },
+  _sanitizeAsNode: function(o) {
+    var key, keys, obj, _ref;
+    if ((_ref = typeof o) === 'string' || _ref === 'number') {
+      return String(o);
+    } else if (object.isBareObject(o)) {
+      keys = Object.keys(o);
+      if (keys.length !== 1) {
+        throw Error("a node must only have one key as tag name");
+      }
+      key = keys[0];
+      obj = {};
+      obj[key] = sanitizer._sanitizeAsChildren(o[key]);
+      return obj;
+    } else {
+      throw Error("not a valid node: `" + o + "`");
+    }
+  }
+};

web/node_modules/dom-converter/scripts/js/test/_prepare.js

@@ -0,0 +1,8 @@
+// Generated by CoffeeScript 1.6.3
+var path, pathToLib;
+
+path = require('path');
+
+pathToLib = path.resolve(__dirname, '../../js/lib');
+
+require('little-popo')(pathToLib, false);

web/node_modules/dom-converter/scripts/js/test/domConverter.js

@@ -0,0 +1,22 @@
+// Generated by CoffeeScript 1.6.3
+var domConverter;
+
+require('./_prepare');
+
+domConverter = mod('domConverter');
+
+describe("input types");
+
+it("should work with objects", function() {
+  return domConverter.objectToDom({});
+});
+
+it("should work with arrays", function() {
+  return domConverter.objectToDom([]);
+});
+
+it("should not work with other types", function() {
+  return (function() {
+    return domConverter.objectToDom('a');
+  }).should["throw"](Error);
+});

web/node_modules/dom-converter/scripts/js/test/objectToSaneObject.js

@@ -0,0 +1,108 @@
+// Generated by CoffeeScript 1.6.3
+var objectToSaneObject;
+
+require('./_prepare');
+
+objectToSaneObject = mod('objectToSaneObject');
+
+describe("sanitize()");
+
+test("case: 'text'", function() {
+  var expectation, input, ret;
+  input = 'text';
+  expectation = ['text'];
+  ret = objectToSaneObject.sanitize(input);
+  return ret.should.be.like(expectation);
+});
+
+test("case: ['text']", function() {
+  var expectation, input, ret;
+  input = ['text'];
+  expectation = ['text'];
+  ret = objectToSaneObject.sanitize(input);
+  return ret.should.be.like(expectation);
+});
+
+test("case: {a:b}", function() {
+  var expectation, input, ret;
+  input = {
+    a: 'b'
+  };
+  expectation = [
+    {
+      a: ['b']
+    }
+  ];
+  ret = objectToSaneObject.sanitize(input);
+  return ret.should.be.like(expectation);
+});
+
+test("case: {a:[b: 'c']}", function() {
+  var expectation, input, ret;
+  input = {
+    a: [
+      {
+        b: 'c'
+      }
+    ]
+  };
+  expectation = [
+    {
+      a: [
+        {
+          b: ['c']
+        }
+      ]
+    }
+  ];
+  ret = objectToSaneObject.sanitize(input);
+  return ret.should.be.like(expectation);
+});
+
+test("case: {a:b: 'c'}", function() {
+  var expectation, input, ret;
+  input = {
+    a: {
+      b: 'c'
+    }
+  };
+  expectation = [
+    {
+      a: [
+        {
+          b: ['c']
+        }
+      ]
+    }
+  ];
+  ret = objectToSaneObject.sanitize(input);
+  return ret.should.be.like(expectation);
+});
+
+test("case: {a:b: ['c', d: 'e']}", function() {
+  var expectation, input, ret;
+  input = {
+    a: {
+      b: [
+        'c', {
+          d: 'e'
+        }
+      ]
+    }
+  };
+  expectation = [
+    {
+      a: [
+        {
+          b: [
+            'c', {
+              d: ['e']
+            }
+          ]
+        }
+      ]
+    }
+  ];
+  ret = objectToSaneObject.sanitize(input);
+  return ret.should.be.like(expectation);
+});

web/node_modules/dom-converter/scripts/js/test/saneObjectToDom.js

@@ -0,0 +1,73 @@
+// Generated by CoffeeScript 1.6.3
+var s2d;
+
+require('./_prepare');
+
+s2d = mod('saneObjectToDom');
+
+describe("_arrayToChildren()");
+
+it("should work", function() {
+  var a, aChild, b, bChildren, node, ret, _i, _len;
+  ret = s2d._arrayToChildren([
+    {
+      a: 'text'
+    }, {
+      'b.someClass': ['b1', 'b2']
+    }, {
+      c: [
+        {
+          d: 'text'
+        }, {
+          e: []
+        }
+      ]
+    }
+  ]);
+  ret.should.be.an('array');
+  ret.should.have.length.of(3);
+  for (_i = 0, _len = ret.length; _i < _len; _i++) {
+    node = ret[_i];
+    node.should.be.an('object');
+    node.should.have.keys(['type', 'name', 'attribs', 'children', 'next', 'prev', 'parent']);
+  }
+  a = ret[0];
+  a.children.should.be.an('array');
+  a.children.should.have.length.of(1);
+  aChild = a.children[0];
+  aChild.should.be.an('object');
+  aChild.should.be.like({
+    type: 'text',
+    data: 'text'
+  });
+  expect(a.prev).to.equal(null);
+  expect(a.parent).to.equal(null);
+  b = ret[1];
+  a.next.should.equal(b);
+  b.prev.should.equal(a);
+  b.attribs.should.be.like({
+    "class": 'someClass'
+  });
+  bChildren = b.children;
+  bChildren[0].should.be.like({
+    type: 'text',
+    data: 'b1'
+  });
+  bChildren[1].should.be.like({
+    type: 'text',
+    data: 'b2'
+  });
+  return ret.should.have.deep.property('[2].children[1].name', 'e');
+});
+
+describe("_parseTag");
+
+it("should work", function() {
+  return s2d._parseTag('tagName#id.c1.c2[a=b, d="1 2 3"]').should.be.like({
+    name: 'tagName',
+    attribs: {
+      id: 'id',
+      "class": 'c1 c2'
+    }
+  });
+});