envjs 0.1.7 → 0.2.0

data/src/dom/dom.js

@@ -0,0 +1,134 @@
+// =========================================================================
+//
+// xmlw3cdom.js - a W3C compliant DOM parser for XML for <SCRIPT>
+//
+// version 3.1
+//
+// =========================================================================
+//
+// Copyright (C) 2002, 2003, 2004 Jon van Noort (jon@webarcana.com.au), David Joham (djoham@yahoo.com) and Scott Severtson
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+//
+// visit the XML for <SCRIPT> home page at xmljs.sourceforge.net
+//
+// Contains text (used within comments to methods) from the
+//  XML Path Language (XPath) Version 1.0 W3C Recommendation
+//  Copyright © 16 November 1999 World Wide Web Consortium,
+//  (Massachusetts Institute of Technology,
+//  European Research Consortium for Informatics and Mathematics, Keio University).
+//  All Rights Reserved.
+//  (see: http://www.w3.org/TR/2000/WD-DOM-Level-1-20000929/)
+
+/**
+ * @function addClass - add new className to classCollection
+ *
+ * @author Jon van Noort (jon@webarcana.com.au)
+ *
+ * @param  classCollectionStr : string - list of existing class names
+ *   (separated and top and tailed with '|'s)
+ * @param  newClass           : string - new class name to add
+ *
+ * @return : string - the new classCollection, with new className appended,
+ *   (separated and top and tailed with '|'s)
+ */
+function addClass(classCollectionStr, newClass) {
+  if (classCollectionStr) {
+    if (classCollectionStr.indexOf("|"+ newClass +"|") < 0) {
+      classCollectionStr += newClass + "|";
+    }
+  }
+  else {
+    classCollectionStr = "|"+ newClass + "|";
+  }
+
+  return classCollectionStr;
+}
+
+///////////////////////
+//  NOT IMPLEMENTED  //
+///////////////////////
+DOMEntity          = function() { alert("DOMEntity.constructor(): Not Implemented"         ); };
+DOMEntityReference = function() { alert("DOMEntityReference.constructor(): Not Implemented"); };
+DOMNotation        = function() { alert("DOMNotation.constructor(): Not Implemented"       ); };
+
+
+Strings = new Object()
+Strings.WHITESPACE = " \t\n\r";
+Strings.QUOTES = "\"'";
+
+Strings.isEmpty = function Strings_isEmpty(strD) {
+    return (strD == null) || (strD.length == 0);
+};
+Strings.indexOfNonWhitespace = function Strings_indexOfNonWhitespace(strD, iB, iE) {
+  if(Strings.isEmpty(strD)) return -1;
+  iB = iB || 0;
+  iE = iE || strD.length;
+
+  for(var i = iB; i < iE; i++)
+    if(Strings.WHITESPACE.indexOf(strD.charAt(i)) == -1) {
+      return i;
+    }
+  return -1;
+};
+Strings.lastIndexOfNonWhitespace = function Strings_lastIndexOfNonWhitespace(strD, iB, iE) {
+  if(Strings.isEmpty(strD)) return -1;
+  iB = iB || 0;
+  iE = iE || strD.length;
+
+  for(var i = iE - 1; i >= iB; i--)
+    if(Strings.WHITESPACE.indexOf(strD.charAt(i)) == -1)
+      return i;
+  return -1;
+};
+Strings.indexOfWhitespace = function Strings_indexOfWhitespace(strD, iB, iE) {
+  if(Strings.isEmpty(strD)) return -1;
+  iB = iB || 0;
+  iE = iE || strD.length;
+
+  for(var i = iB; i < iE; i++)
+    if(Strings.WHITESPACE.indexOf(strD.charAt(i)) != -1)
+      return i;
+  return -1;
+};
+Strings.replace = function Strings_replace(strD, iB, iE, strF, strR) {
+  if(Strings.isEmpty(strD)) return "";
+  iB = iB || 0;
+  iE = iE || strD.length;
+
+  return strD.substring(iB, iE).split(strF).join(strR);
+};
+Strings.getLineNumber = function Strings_getLineNumber(strD, iP) {
+  if(Strings.isEmpty(strD)) return -1;
+  iP = iP || strD.length;
+
+  return strD.substring(0, iP).split("\n").length
+};
+Strings.getColumnNumber = function Strings_getColumnNumber(strD, iP) {
+  if(Strings.isEmpty(strD)) return -1;
+  iP = iP || strD.length;
+
+  var arrD = strD.substring(0, iP).split("\n");
+  var strLine = arrD[arrD.length - 1];
+  arrD.length--;
+  var iLinePos = arrD.join("\n").length;
+
+  return iP - iLinePos;
+};
+
+
+StringBuffer = function() {this._a=new Array();};
+StringBuffer.prototype.append = function StringBuffer_append(d){this._a[this._a.length]=d;};
+StringBuffer.prototype.toString = function StringBuffer_toString(){return this._a.join("");};

data/src/dom/element.js

@@ -0,0 +1,217 @@
+$debug("Defining Element");
+/**
+ * @class  DOMElement - By far the vast majority of objects (apart from text) that authors encounter
+ *   when traversing a document are Element nodes.
+ * @extends DOMNode
+ * @author Jon van Noort (jon@webarcana.com.au) and David Joham (djoham@yahoo.com)
+ * @param  ownerDocument : DOMDocument - The Document object associated with this node.
+ */
+var DOMElement = function(ownerDocument) {
+    this.DOMNode  = DOMNode;
+    this.DOMNode(ownerDocument);                   
+    //this.id = null;                                  // the ID of the element
+};
+DOMElement.prototype = new DOMNode;
+__extend__(DOMElement.prototype, {	
+    // The name of the element.
+    get tagName(){
+        return this.nodeName;  
+    },
+    set tagName(name){
+        this.nodeName = name;  
+    },
+    
+    addEventListener        : function(type, fn, phase){
+      this.ownerDocument._parentWindow.$envx.
+        __addEventListener__(this, type, fn);
+    },
+    removeEventListener     : function(type){
+      this.ownerDocument._parentWindow.$envx.
+        __removeEventListener__(this, type);
+    },
+    dispatchEvent           : function(event, bubbles){
+      this.ownerDocument._parentWindow.$envx.
+        __dispatchEvent__(this, event, bubbles);
+    },
+   
+    getAttribute: function(name) {
+        var ret = null;
+        // if attribute exists, use it
+        var attr = this.attributes.getNamedItem(name);
+        if (attr) {
+            ret = attr.value;
+        }
+        return ret; // if Attribute exists, return its value, otherwise, return null
+    },
+    setAttribute : function (name, value) {
+        // if attribute exists, use it
+        var attr = this.attributes.getNamedItem(name);
+        
+        //I had to add this check becuase as the script initializes
+        //the id may be set in the constructor, and the html element
+        //overrides the id property with a getter/setter.
+        if(__ownerDocument__(this)){
+            if (attr===null||attr===undefined) {
+                attr = __ownerDocument__(this).createAttribute(name);  // otherwise create it
+            }
+            
+            
+            // test for exceptions
+            if (__ownerDocument__(this).implementation.errorChecking) {
+                // throw Exception if Attribute is readonly
+                if (attr._readonly) {
+                    throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+                }
+                
+                // throw Exception if the value string contains an illegal character
+                if (!__isValidString__(value)) {
+                    throw(new DOMException(DOMException.INVALID_CHARACTER_ERR));
+                }
+            }
+            
+            /*if (__isIdDeclaration__(name)) {
+                this.id = value;  // cache ID for getElementById()
+            }*/
+            
+            // assign values to properties (and aliases)
+            attr.value     = value + '';
+            
+            // add/replace Attribute in NamedNodeMap
+            this.attributes.setNamedItem(attr);
+        }else{
+            $warn('Element has no owner document '+this.tagName+'\n\t cant set attribute ' + name + ' = '+value );
+        }
+    },
+    removeAttribute : function removeAttribute(name) {
+        // delegate to DOMNamedNodeMap.removeNamedItem
+        return this.attributes.removeNamedItem(name);
+    },
+    getAttributeNode : function getAttributeNode(name) {
+        // delegate to DOMNamedNodeMap.getNamedItem
+        return this.attributes.getNamedItem(name);
+    },
+    setAttributeNode: function(newAttr) {
+        // if this Attribute is an ID
+        if (__isIdDeclaration__(newAttr.name)) {
+            this.id = newAttr.value;  // cache ID for getElementById()
+        }
+        // delegate to DOMNamedNodeMap.setNamedItem
+        return this.attributes.setNamedItem(newAttr);
+    },
+    removeAttributeNode: function(oldAttr) {
+      // throw Exception if Attribute is readonly
+      if (__ownerDocument__(this).implementation.errorChecking && oldAttr._readonly) {
+        throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+      }
+    
+      // get item index
+      var itemIndex = this.attributes._findItemIndex(oldAttr._id);
+    
+      // throw Exception if node does not exist in this map
+      if (__ownerDocument__(this).implementation.errorChecking && (itemIndex < 0)) {
+        throw(new DOMException(DOMException.NOT_FOUND_ERR));
+      }
+    
+      return this.attributes._removeChild(itemIndex);
+    },
+    getAttributeNS : function(namespaceURI, localName) {
+        var ret = "";
+        // delegate to DOMNAmedNodeMap.getNamedItemNS
+        var attr = this.attributes.getNamedItemNS(namespaceURI, localName);
+        if (attr) {
+            ret = attr.value;
+        }
+        return ret;  // if Attribute exists, return its value, otherwise return ""
+    },
+    setAttributeNS : function(namespaceURI, qualifiedName, value) {
+        // call DOMNamedNodeMap.getNamedItem
+        var attr = this.attributes.getNamedItem(namespaceURI, qualifiedName);
+        
+        if (!attr) {  // if Attribute exists, use it
+            // otherwise create it
+            attr = __ownerDocument__(this).createAttributeNS(namespaceURI, qualifiedName);
+        }
+        
+        var value = value+'';
+        
+        // test for exceptions
+        if (__ownerDocument__(this).implementation.errorChecking) {
+            // throw Exception if Attribute is readonly
+            if (attr._readonly) {
+                throw(new DOMException(DOMException.NO_MODIFICATION_ALLOWED_ERR));
+            }
+            
+            // throw Exception if the Namespace is invalid
+            if (!__isValidNamespace__(namespaceURI, qualifiedName)) {
+                throw(new DOMException(DOMException.NAMESPACE_ERR));
+            }
+            
+            // throw Exception if the value string contains an illegal character
+            if (!__isValidString__(value)) {
+                throw(new DOMException(DOMException.INVALID_CHARACTER_ERR));
+            }
+        }
+        
+        // if this Attribute is an ID
+        /* if (__isIdDeclaration__(name)) {
+            this.id = value;  // cache ID for getElementById()
+        } */
+        
+        // assign values to properties (and aliases)
+        attr.value     = value;
+        attr.nodeValue = value;
+        
+        // delegate to DOMNamedNodeMap.setNamedItem
+        this.attributes.setNamedItemNS(attr);
+    },
+    removeAttributeNS : function(namespaceURI, localName) {
+        // delegate to DOMNamedNodeMap.removeNamedItemNS
+        return this.attributes.removeNamedItemNS(namespaceURI, localName);
+    },
+    getAttributeNodeNS : function(namespaceURI, localName) {
+        // delegate to DOMNamedNodeMap.getNamedItemNS
+        return this.attributes.getNamedItemNS(namespaceURI, localName);
+    },
+    setAttributeNodeNS : function(newAttr) {
+        // if this Attribute is an ID
+        if ((newAttr.prefix == "") &&  __isIdDeclaration__(newAttr.name)) {
+            this.id = newAttr.value+'';  // cache ID for getElementById()
+        }
+        
+        // delegate to DOMNamedNodeMap.setNamedItemNS
+        return this.attributes.setNamedItemNS(newAttr);
+    },
+    hasAttribute : function(name) {
+        // delegate to DOMNamedNodeMap._hasAttribute
+        return __hasAttribute__(this.attributes,name);
+    },
+    hasAttributeNS : function(namespaceURI, localName) {
+        // delegate to DOMNamedNodeMap._hasAttributeNS
+        return __hasAttributeNS__(this.attributes, namespaceURI, localName);
+    },
+    get nodeType(){
+        return DOMNode.ELEMENT_NODE;
+    },
+    get xml() {
+        var ret = "";
+        
+        // serialize namespace declarations
+        var ns = this._namespaces.xml;
+        if (ns.length > 0) ns = " "+ ns;
+        
+        // serialize Attribute declarations
+        var attrs = this.attributes.xml;
+        
+        // serialize this Element
+        ret += "<" + this.nodeName.toLowerCase() + ns + attrs +">";
+        ret += this.childNodes.xml;
+        ret += "</" + this.nodeName.toLowerCase() + ">";
+        
+        return ret;
+    },
+    toString : function(){
+        return "Element #"+this._id + " "+ this.tagName + (this.id?" => "+this.id:'');
+    }
+});
+
+// $w.Element = DOMElement;

data/src/dom/entities.js

@@ -0,0 +1,273 @@
+/**
+ * @author Glen Ivey (gleneivey@wontology.org)
+ */
+
+$debug("Instantiating list of HTML4 standard entities");
+/*
+ * $w.$entityDefinitions
+ */
+
+var $entityDefinitions = {
+        // content taken from W3C "HTML 4.01 Specification"
+        //                        "W3C Recommendation 24 December 1999"
+
+    nbsp: "\u00A0",
+    iexcl: "\u00A1",
+    cent: "\u00A2",
+    pound: "\u00A3",
+    curren: "\u00A4",
+    yen: "\u00A5",
+    brvbar: "\u00A6",
+    sect: "\u00A7",
+    uml: "\u00A8",
+    copy: "\u00A9",
+    ordf: "\u00AA",
+    laquo: "\u00AB",
+    not: "\u00AC",
+    shy: "\u00AD",
+    reg: "\u00AE",
+    macr: "\u00AF",
+    deg: "\u00B0",
+    plusmn: "\u00B1",
+    sup2: "\u00B2",
+    sup3: "\u00B3",
+    acute: "\u00B4",
+    micro: "\u00B5",
+    para: "\u00B6",
+    middot: "\u00B7",
+    cedil: "\u00B8",
+    sup1: "\u00B9",
+    ordm: "\u00BA",
+    raquo: "\u00BB",
+    frac14: "\u00BC",
+    frac12: "\u00BD",
+    frac34: "\u00BE",
+    iquest: "\u00BF",
+    Agrave: "\u00C0",
+    Aacute: "\u00C1",
+    Acirc: "\u00C2",
+    Atilde: "\u00C3",
+    Auml: "\u00C4",
+    Aring: "\u00C5",
+    AElig: "\u00C6",
+    Ccedil: "\u00C7",
+    Egrave: "\u00C8",
+    Eacute: "\u00C9",
+    Ecirc: "\u00CA",
+    Euml: "\u00CB",
+    Igrave: "\u00CC",
+    Iacute: "\u00CD",
+    Icirc: "\u00CE",
+    Iuml: "\u00CF",
+    ETH: "\u00D0",
+    Ntilde: "\u00D1",
+    Ograve: "\u00D2",
+    Oacute: "\u00D3",
+    Ocirc: "\u00D4",
+    Otilde: "\u00D5",
+    Ouml: "\u00D6",
+    times: "\u00D7",
+    Oslash: "\u00D8",
+    Ugrave: "\u00D9",
+    Uacute: "\u00DA",
+    Ucirc: "\u00DB",
+    Uuml: "\u00DC",
+    Yacute: "\u00DD",
+    THORN: "\u00DE",
+    szlig: "\u00DF",
+    agrave: "\u00E0",
+    aacute: "\u00E1",
+    acirc: "\u00E2",
+    atilde: "\u00E3",
+    auml: "\u00E4",
+    aring: "\u00E5",
+    aelig: "\u00E6",
+    ccedil: "\u00E7",
+    egrave: "\u00E8",
+    eacute: "\u00E9",
+    ecirc: "\u00EA",
+    euml: "\u00EB",
+    igrave: "\u00EC",
+    iacute: "\u00ED",
+    icirc: "\u00EE",
+    iuml: "\u00EF",
+    eth: "\u00F0",
+    ntilde: "\u00F1",
+    ograve: "\u00F2",
+    oacute: "\u00F3",
+    ocirc: "\u00F4",
+    otilde: "\u00F5",
+    ouml: "\u00F6",
+    divide: "\u00F7",
+    oslash: "\u00F8",
+    ugrave: "\u00F9",
+    uacute: "\u00FA",
+    ucirc: "\u00FB",
+    uuml: "\u00FC",
+    yacute: "\u00FD",
+    thorn: "\u00FE",
+    yuml: "\u00FF",
+    fnof: "\u0192",
+    Alpha: "\u0391",
+    Beta: "\u0392",
+    Gamma: "\u0393",
+    Delta: "\u0394",
+    Epsilon: "\u0395",
+    Zeta: "\u0396",
+    Eta: "\u0397",
+    Theta: "\u0398",
+    Iota: "\u0399",
+    Kappa: "\u039A",
+    Lambda: "\u039B",
+    Mu: "\u039C",
+    Nu: "\u039D",
+    Xi: "\u039E",
+    Omicron: "\u039F",
+    Pi: "\u03A0",
+    Rho: "\u03A1",
+    Sigma: "\u03A3",
+    Tau: "\u03A4",
+    Upsilon: "\u03A5",
+    Phi: "\u03A6",
+    Chi: "\u03A7",
+    Psi: "\u03A8",
+    Omega: "\u03A9",
+    alpha: "\u03B1",
+    beta: "\u03B2",
+    gamma: "\u03B3",
+    delta: "\u03B4",
+    epsilon: "\u03B5",
+    zeta: "\u03B6",
+    eta: "\u03B7",
+    theta: "\u03B8",
+    iota: "\u03B9",
+    kappa: "\u03BA",
+    lambda: "\u03BB",
+    mu: "\u03BC",
+    nu: "\u03BD",
+    xi: "\u03BE",
+    omicron: "\u03BF",
+    pi: "\u03C0",
+    rho: "\u03C1",
+    sigmaf: "\u03C2",
+    sigma: "\u03C3",
+    tau: "\u03C4",
+    upsilon: "\u03C5",
+    phi: "\u03C6",
+    chi: "\u03C7",
+    psi: "\u03C8",
+    omega: "\u03C9",
+    thetasym: "\u03D1",
+    upsih: "\u03D2",
+    piv: "\u03D6",
+    bull: "\u2022",
+    hellip: "\u2026",
+    prime: "\u2032",
+    Prime: "\u2033",
+    oline: "\u203E",
+    frasl: "\u2044",
+    weierp: "\u2118",
+    image: "\u2111",
+    real: "\u211C",
+    trade: "\u2122",
+    alefsym: "\u2135",
+    larr: "\u2190",
+    uarr: "\u2191",
+    rarr: "\u2192",
+    darr: "\u2193",
+    harr: "\u2194",
+    crarr: "\u21B5",
+    lArr: "\u21D0",
+    uArr: "\u21D1",
+    rArr: "\u21D2",
+    dArr: "\u21D3",
+    hArr: "\u21D4",
+    forall: "\u2200",
+    part: "\u2202",
+    exist: "\u2203",
+    empty: "\u2205",
+    nabla: "\u2207",
+    isin: "\u2208",
+    notin: "\u2209",
+    ni: "\u220B",
+    prod: "\u220F",
+    sum: "\u2211",
+    minus: "\u2212",
+    lowast: "\u2217",
+    radic: "\u221A",
+    prop: "\u221D",
+    infin: "\u221E",
+    ang: "\u2220",
+    and: "\u2227",
+    or: "\u2228",
+    cap: "\u2229",
+    cup: "\u222A",
+    intXX: "\u222B",
+    there4: "\u2234",
+    sim: "\u223C",
+    cong: "\u2245",
+    asymp: "\u2248",
+    ne: "\u2260",
+    equiv: "\u2261",
+    le: "\u2264",
+    ge: "\u2265",
+    sub: "\u2282",
+    sup: "\u2283",
+    nsub: "\u2284",
+    sube: "\u2286",
+    supe: "\u2287",
+    oplus: "\u2295",
+    otimes: "\u2297",
+    perp: "\u22A5",
+    sdot: "\u22C5",
+    lceil: "\u2308",
+    rceil: "\u2309",
+    lfloor: "\u230A",
+    rfloor: "\u230B",
+    lang: "\u2329",
+    rang: "\u232A",
+    loz: "\u25CA",
+    spades: "\u2660",
+    clubs: "\u2663",
+    hearts: "\u2665",
+    diams: "\u2666",
+    quot: "\u0022",
+    amp: "\u0026",
+    lt: "\u003C",
+    gt: "\u003E",
+    OElig: "\u0152",
+    oelig: "\u0153",
+    Scaron: "\u0160",
+    scaron: "\u0161",
+    Yuml: "\u0178",
+    circ: "\u02C6",
+    tilde: "\u02DC",
+    ensp: "\u2002",
+    emsp: "\u2003",
+    thinsp: "\u2009",
+    zwnj: "\u200C",
+    zwj: "\u200D",
+    lrm: "\u200E",
+    rlm: "\u200F",
+    ndash: "\u2013",
+    mdash: "\u2014",
+    lsquo: "\u2018",
+    rsquo: "\u2019",
+    sbquo: "\u201A",
+    ldquo: "\u201C",
+    rdquo: "\u201D",
+    bdquo: "\u201E",
+    dagger: "\u2020",
+    Dagger: "\u2021",
+    permil: "\u2030",
+    lsaquo: "\u2039",
+    rsaquo: "\u203A",
+    euro: "\u20AC",
+
+    // non-standard entities
+    apos: "'"
+};
+
+
+// $w.$entityDefinitions = $entityDefinitions;
+