everycss/lib/node.js

var stringifier = require('./stringifier'),
    Node,
    set,
    isSet,
    isBlock,
    filterNode,
    getNodeClass,
    getStringifier,
    getTypeClass,
    setTypes  = {};

Node  = function (isBlock) {
  this.extend(isBlock);
};
Node.prototype.extend = function (isBlock) {
  var protected = {};

  // parent node
  protected.parent  = null;
  Object.defineProperty(this, 'parent', {
    configurable: true,
    enumerable: true,
    get: function () {
      return protected.parent;
    }
  });

  // children nodes
  protected.children  = {all: [], types: {}};
  Object.defineProperty(this, 'children', {
    enumerable: true,
    get: function () {
      // return a copy
      return protected.children.all.slice();
    }
  });

  // return number of children
  Object.defineProperty(this, 'length', {
    configurable: true,
    enumerable: true,
    get: function () {
      return protected.children.all.length;
    }
  });

  Object.defineProperty(this, 'depth', { get: function () {
    var node, depth = 0;
    node = this;
    while (node = node.parent) {
      depth++;
    }
    return depth;
  }});

  // return a node definition for copy
  this.getDefinition = function () {
    return {};
  };

  this.copy = function (overlay) {
    var definition = this.getDefinition(),
        copy,
        i;

    // merge definition with overlay
    for (i in overlay) {
      if (overlay.hasOwnProperty(i)) {
        definition[i] = overlay[i];
      }
    }

    // instanciate a copy
    copy = new setTypes[this.type](definition);

    // copy children
    for (i = 0; i < protected.children.all.length; i++) {
      copy.append(protected.children.all[i].copy());
    }
    return copy;
  };

  // non block node
  if (!isBlock) {
    // block "placeholders"
    this.each     =
    this.children =
    this.insertAt =
    this.append   =
    this.prepend  =
    this.remove   = function () {
      return this;
    };
    this.locate = function () {
      return false;
    };
  }
  // Block node
  else {
    protected.getChildrenOfType = function (type) {
      if (!protected.children.types[type]) {
        protected.children.types[type] = [];
      }
      return protected.children.types[type];
    };

    this.remove = function (node) {
      var locations;

      filterNode(node);

      // remove from parent protected.children lists
      locations = this.locate(node);
      protected.children.all.splice(locations[0], 1);
      protected.getChildrenOfType(node.type).splice(locations[1], 1);

      // remove parent reference
      node.parent = undefined;

      return this;
    };

    // override protected.children related methods
    this.append = function (node) {
      filterNode(node);

      Object.defineProperty(node.detach(), 'parent', {configurable: true, value: this});
      protected.children.all.push(node);
      protected.getChildrenOfType(node.type).push(node);
      return this;
    };

    // override protected.children related methods
    this.prepend = function (node) {
      filterNode(node);

      Object.defineProperty(node.detach(), 'parent', {configurable: true, value: this});
      protected.children.all.unshift(node);
      protected.getChildrenOfType(node.type).unshift(node);
      return this;
    };

    this.insertAt = function (node, index) {
      var location = [index, 0];

      filterNode(node);

      if (index < 0) {
        index = 0;
      } else if (index > protected.children.all.length) {
        index = protected.children.all.length;
      }

      // index is 0
      if (!index) {
        return this.prepend(node);
      // index is just after the last node
      } else if (index === protected.children.all.length) {
        return this.append(node);
      }

      // find position in node's type list
      // first node of this type
      if (!protected.children.types[node.type]) {
        protected.children.types[node.type] = [];
        location[1] = 0;
      } else {
        // search for same type node before this
        for (i = location[0] - 1; i > 0; i--) {
          if (protected.children.all[i].type === node.type) {
            break;
          }
        }
        location[1] = this.locate(protected.children.all[i])[1] + 1;
      }

      protected.children.all.splice(location[0], 0, node);
      protected.getChildrenOfType(node.type).splice(location[1], 0, node);

      Object.defineProperty(node.detach(), 'parent', {configurable: true, value: this});

      return this;
    };

    this.children = function (type) {
      var selection = [], i;
      if (typeof type === 'string') {
        selection = protected.children[type] || [];
      } else if(type instanceof Array) {
        for (i = 0; i < type.length; i++) {
          selection.concat(protected.children[type[i]] || []);
        }
      } else {
        for (i in protected.children) {
          if (protected.children.hasOwnProperty(i)) {
            selection.concat(protected.children[i]);
          }
        }
      }
      return protected.children;
    };

    this.each = function (type, limit, callback, _loop) {
      var nodes = protected.children.all.slice(), i, loop;

      if (typeof type === 'function') {
        callback  = type;
        limit     = 0;
        type      = false;
      }

      // default limit
      if (typeof type === 'number') {
        callback  = limit;
        limit     = type;
        type      = false;
      }

      if (typeof type === 'string') {
        if (typeof limit !== 'number') {
          limit = 0;
        }
      }

      // loop through nodes if a callback provided
      if (typeof callback === 'function') {
        // loop informations
        if (!_loop) {
          _loop = {
            cursor: 0,
            depth:  0
          };
        }
        for (i = 0; i < nodes.length; i++) {
          // preserve and expose loop
          loop  = {
            cursor:   _loop.cursor,
            depth:    _loop.depth,
            index:    i,
            // allow descent for current node
            descent:  true
          };

          if (!type || type === nodes[i].type) {
            // return false if callback returns false
            //throw '';// bug hear
            if (false === callback.call(this, nodes[i], loop)) {
              return false;
            }
            _loop.cursor++;
          }


          // loop through nested blocks
          // nodes[i] could have been detached
          if (nodes[i] && limit !== 0 && nodes[i].isBlock && loop.descent) {
            _loop.depth++;
            // return false if eachNode returns false
            if (false === nodes[i].each(type, limit - 1, callback, _loop)) {
              return false;
            }
            _loop.depth--;
          }
        }
      }

      return this;
    };

    this.locate = function (node) {
      var all, byType, i, max, found, locations = false;

      filterNode(node);

      locations = [2];
      // remove from parent protected.children lists
      all     = protected.children.all;
      byType  = protected.getChildrenOfType(node.type);
      max     = all.length > byType.length ? all.length : byType.length;
      found = 0;
      for (i = 0; i < max; i++) {
        // check if node found in the global list
        if (all[i] === node) {
          locations[0] = i;
          if (++found === 2) {
            break;
          }
        }
        // check if node found in the type list
        if (byType[i] === node) {
          locations[1] = i;
          if (++found === 2) {
            break;
          }
        }
      }
      return locations;
    };
  }

  this.detach = function () {
    if (this.parent) {
      this.parent.remove(this);
    }
    return this;
  };

  this.before = function (node) {
    filterNode(node);

    if (!this.parent) {
      throw 'Can\t insert a node before a node without parent';
    }

    return this.parent.insertAt(node, this.parent.locate(this)[0]);
  };

  this.after = function (node) {
    filterNode(node);

    if (!this.parent) {
      throw 'Can\t insert a node after a node without parent';
    }

    return this.parent.insertAt(node, this.parent.locate(this)[0] + 1);
  };

  return protected;
};

// return a new node class for the given type
set = function (constructor, type, isBlock) {
  var TypedNode;

  // prevent type overwrite
  if (isSet(type)) {
    throw 'Type `' + type + '` was already defined';
  }

  // New typed node class
  TypedNode = function (definition) {
    var protected;

    // set reference to Node class
    Object.defineProperty(this, '_super', { value: new Node(isBlock) });

    // Call constructors
    protected = this._super.extend.call(this, isBlock);
    constructor.call(this, protected, definition instanceof Object ? definition : {});
  };

  // set type attribute once for all
  Object.defineProperty(TypedNode.prototype, 'type', { enumerable: true, value: type });
  Object.defineProperty(TypedNode.prototype, 'isBlock', { enumerable: true, value: !!isBlock });

  // register node
  setTypes[type] = TypedNode;
  
  return TypedNode;
};

get = function (type, definition) {
  if (!isSet(type)) {
    throw 'Unknown type `' + type + '`';
  }
  return new setTypes[type](definition);
};

// throw exception if node is not a node class
// and is not of given type if provided
filterNode = function (node, type) {
  if (typeof node !== 'object') {
    throw 'Invalid node';
  }
  if (type && node.type !== type) {
    throw 'Node is not of type `' + type + '`';
  }
  if (!isSet(node.type)) {
    throw 'Unknown type `' + node.type + '`';
  }
  if (!(node instanceof setTypes[node.type])) {
    throw 'Node\'s type and class mismatch';
  }
};

// return if a node type is prepared or not
isSet = function (type) {
  return !!setTypes[type];
};

setStringifier = function (type, func, main) {
  stringifier.set(type, func, main);
};
getStringifier = function (type, style) {
  stringifier.get(type, style);
};

isBlock = function (type) {
  return !!setTypes[type] && setTypes[type].prototype.isBlock;
};
getNodeClass = function (node) {
  if (isSet(node.type)) {
    return setTypes[node.type];
  }
};
getTypeClass = function (type) {
  if (isSet(type)) {
    return setTypes[type];
  }
};

exports.filter          = filterNode;
exports.set             = set;
exports.get             = get;
exports.setStringifier  = setStringifier;
exports.getStringifier  = getStringifier;

exports.isSet           = isSet;
exports.isBlock         = isBlock;
exports.getNodeClass    = getNodeClass;
exports.getTypeClass    = getTypeClass;