sax 0.3.4 → 0.4.2

package/AUTHORS

@@ -7,3 +7,4 @@ Jann Horn <jann@Jann-PC.fritz.box>
 Elijah Insua <tmpvar@gmail.com>
 Henry Rawas <henryr@schakra.com>
 Justin Makeig <jmpublic@makeig.com>
+Mike <mike@emotive.com>

package/README.md

@@ -98,9 +98,10 @@ Settings supported:
 * `trim` - Boolean. Whether or not to trim text and comment nodes.
 * `normalize` - Boolean. If true, then turn any whitespace into a single
   space.
-* `lowercasetags` - Boolean. If true, then lowercase tags in loose mode, 
-  rather than uppercasing them.
+* `lowercase` - Boolean. If true, then lowercase tag names and attribute names
+  in loose mode, rather than uppercasing them.
 * `xmlns` - Boolean. If true, then namespaces are supported.
+* `position` - Boolean. If false, then don't track line/col/position.
 
 ## Methods
 
@@ -164,7 +165,7 @@ might go away at some point. SAX isn't intended to be used to parse SGML,
 after all.
 
 `opentag` - An opening tag. Argument: object with `name` and `attributes`.
-In non-strict mode, tag names are uppercased, unless the `lowercasetags`
+In non-strict mode, tag names are uppercased, unless the `lowercase`
 option is set.  If the `xmlns` option is set, then it will contain
 namespace binding information on the `ns` member, and will have a
 `local`, `prefix`, and `uri` member.
@@ -174,8 +175,10 @@ parent closes. In strict mode, well-formedness is enforced. Note that
 self-closing tags will have `closeTag` emitted immediately after `openTag`.
 Argument: tag name.
 
-`attribute` - An attribute node.  Argument: object with `name` and `value`,
-and also namespace information if the `xmlns` option flag is set.
+`attribute` - An attribute node.  Argument: object with `name` and `value`.
+In non-strict mode, attribute names are uppercased, unless the `lowercase`
+option is set.  If the `xmlns` option is set, it will also contains namespace
+information.
 
 `comment` - A comment node.  Argument: the string of the comment.
 

package/examples/example.js

@@ -1,16 +1,16 @@
 
 var fs = require("fs"),
-  sys = require("sys"),
+  util = require('util'),
   path = require("path"),
   xml = fs.cat(path.join(__dirname, "test.xml")),
   sax = require("../lib/sax"),
   strict = sax.parser(true),
   loose = sax.parser(false, {trim:true}),
   inspector = function (ev) { return function (data) {
-    // sys.error("");
-    // sys.error(ev+": "+sys.inspect(data));
-    // for (var i in data) sys.error(i+ " "+sys.inspect(data[i]));
-    // sys.error(this.line+":"+this.column);
+    // util.error("");
+    // util.error(ev+": "+util.inspect(data));
+    // for (var i in data) util.error(i+ " "+util.inspect(data[i]));
+    // util.error(this.line+":"+this.column);
   }};
 
 xml.addCallback(function (xml) {
@@ -20,8 +20,8 @@ xml.addCallback(function (xml) {
     loose["on"+ev] = inspector(ev);
   });
   loose.onend = function () {
-    // sys.error("end");
-    // sys.error(sys.inspect(loose));
+    // util.error("end");
+    // util.error(util.inspect(loose));
   };
   
   // do this one char at a time to verify that it works.

package/lib/sax.js

@@ -51,7 +51,8 @@ function SAXParser (strict, opt) {
   parser.q = parser.c = ""
   parser.bufferCheckPosition = sax.MAX_BUFFER_LENGTH
   parser.opt = opt || {}
-  parser.tagCase = parser.opt.lowercasetags ? "toLowerCase" : "toUpperCase"
+  parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
+  parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase"
   parser.tags = []
   parser.closed = parser.closedRoot = parser.sawRoot = false
   parser.tag = parser.error = null
@@ -67,7 +68,10 @@ function SAXParser (strict, opt) {
   if (parser.opt.xmlns) parser.ns = Object.create(rootNS)
 
   // mostly just for error reporting
-  parser.position = parser.line = parser.column = 0
+  parser.trackPosition = parser.opt.position !== false
+  if (parser.trackPosition) {
+    parser.position = parser.line = parser.column = 0
+  }
   emit(parser, "onready")
 }
 
@@ -134,7 +138,6 @@ SAXParser.prototype =
   , write: write
   , resume: function () { this.error = null; return this }
   , close: function () { return this.write(null) }
-  , end: function () { return this.write(null) }
   }
 
 try {
@@ -234,14 +237,37 @@ var whitespace = "\r\n\t "
   , nameBody = nameStart+number+"-."
   , quote = "'\""
   , entity = number+letter+"#"
+  , attribEnd = whitespace + ">"
   , CDATA = "[CDATA["
   , DOCTYPE = "DOCTYPE"
   , XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace"
   , XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/"
   , rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE }
 
-function is (charclass, c) { return charclass.indexOf(c) !== -1 }
-function not (charclass, c) { return !is(charclass, c) }
+// turn all the string character sets into character class objects.
+whitespace = charClass(whitespace)
+number = charClass(number)
+letter = charClass(letter)
+nameStart = charClass(nameStart)
+nameBody = charClass(nameBody)
+quote = charClass(quote)
+entity = charClass(entity)
+attribEnd = charClass(attribEnd)
+
+function charClass (str) {
+  return str.split("").reduce(function (s, c) {
+    s[c] = true
+    return s
+  }, {})
+}
+
+function is (charclass, c) {
+  return charclass[c]
+}
+
+function not (charclass, c) {
+  return !charclass[c]
+}
 
 var S = 0
 sax.STATE =
@@ -318,9 +344,11 @@ function textopts (opt, text) {
 
 function error (parser, er) {
   closeText(parser)
-  er += "\nLine: "+parser.line+
-        "\nColumn: "+parser.column+
-        "\nChar: "+parser.c
+  if (parser.trackPosition) {
+    er += "\nLine: "+parser.line+
+          "\nColumn: "+parser.column+
+          "\nChar: "+parser.c
+  }
   er = new Error(er)
   parser.error = er
   emit(parser, "onerror", er)
@@ -342,7 +370,7 @@ function strictFail (parser, message) {
 }
 
 function newTag (parser) {
-  if (!parser.strict) parser.tagName = parser.tagName[parser.tagCase]()
+  if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]()
   var parent = parser.tags[parser.tags.length - 1] || parser
     , tag = parser.tag = { name : parser.tagName, attributes : {} }
 
@@ -367,6 +395,7 @@ function qname (name) {
 }
 
 function attrib (parser) {
+  if (!parser.strict) parser.attribName = parser.attribName[parser.looseCase]()
   if (parser.opt.xmlns) {
     var qn = qname(parser.attribName)
       , prefix = qn.prefix
@@ -434,6 +463,8 @@ function openTag (parser, selfClosing) {
     }
 
     // handle deferred onattribute events
+    // Note: do not apply default ns to attributes:
+    //   http://www.w3.org/TR/REC-xml-names/#defaulting
     for (var i = 0, l = parser.attribList.length; i < l; i ++) {
       var nv = parser.attribList[i]
       var name = nv[0]
@@ -441,7 +472,7 @@ function openTag (parser, selfClosing) {
         , qualName = qname(name)
         , prefix = qualName.prefix
         , local = qualName.local
-        , uri = tag.ns[prefix] || ""
+        , uri = prefix == "" ? "" : (tag.ns[prefix] || "")
         , a = { name: name
               , value: value
               , prefix: prefix
@@ -491,7 +522,7 @@ function closeTag (parser) {
   // <a><b></c></b></a> will close everything, otherwise.
   var t = parser.tags.length
   var tagName = parser.tagName
-  if (!parser.strict) tagName = tagName[parser.tagCase]()
+  if (!parser.strict) tagName = tagName[parser.looseCase]()
   var closeTo = tagName
   while (t --) {
     var close = parser.tags[t]
@@ -565,11 +596,13 @@ function write (chunk) {
   if (chunk === null) return end(parser)
   var i = 0, c = ""
   while (parser.c = c = chunk.charAt(i++)) {
-    parser.position ++
-    if (c === "\n") {
-      parser.line ++
-      parser.column = 0
-    } else parser.column ++
+    if (parser.trackPosition) {
+      parser.position ++
+      if (c === "\n") {
+        parser.line ++
+        parser.column = 0
+      } else parser.column ++
+    }
     switch (parser.state) {
 
       case S.BEGIN:
@@ -588,7 +621,7 @@ function write (chunk) {
           var starti = i-1
           while (c && c!=="<" && c!=="&") {
             c = chunk.charAt(i++)
-            if (c) {
+            if (c && parser.trackPosition) {
               parser.position ++
               if (c === "\n") {
                 parser.line ++
@@ -905,7 +938,7 @@ function write (chunk) {
       continue
 
       case S.ATTRIB_VALUE_UNQUOTED:
-        if (not(whitespace+">",c)) {
+        if (not(attribEnd,c)) {
           if (c === "&") parser.state = S.ATTRIB_VALUE_ENTITY_U
           else parser.attribValue += c
           continue

package/package.json

@@ -1,10 +1,15 @@
-{ "name" : "sax"
-, "description": "An evented streaming XML parser in JavaScript"
-, "author" : "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)"
-, "version" : "0.3.4"
-, "main" : "lib/sax.js"
-, "license" : { "type": "MIT"
-              , "url": "https://raw.github.com/isaacs/sax-js/master/LICENSE" }
-, "scripts" : { "test" : "node test/index.js" }
-, "repository": "git://github.com/isaacs/sax-js.git"
+{
+  "name": "sax",
+  "description": "An evented streaming XML parser in JavaScript",
+  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
+  "version": "0.4.2",
+  "main": "lib/sax.js",
+  "license": {
+    "type": "MIT",
+    "url": "https://raw.github.com/isaacs/sax-js/master/LICENSE"
+  },
+  "scripts": {
+    "test": "node test/index.js"
+  },
+  "repository": "git://github.com/isaacs/sax-js.git"
 }

package/test/case.js

@@ -0,0 +1,47 @@
+// default to uppercase
+require(__dirname).test
+  ( { xml :
+      "<span class=\"test\" hello=\"world\"></span>"
+    , expect :
+      [ [ "attribute", { name: "CLASS", value: "test" } ]
+      , [ "attribute", { name: "HELLO", value: "world" } ]
+      , [ "opentag", { name: "SPAN",
+                       attributes: { CLASS: "test", HELLO: "world" } } ]
+      , [ "closetag", "SPAN" ]
+      ]
+    , strict : false
+    , opt : {}
+    }
+  )
+
+// lowercase option : lowercase tag/attribute names
+require(__dirname).test
+  ( { xml :
+      "<span class=\"test\" hello=\"world\"></span>"
+    , expect :
+      [ [ "attribute", { name: "class", value: "test" } ]
+      , [ "attribute", { name: "hello", value: "world" } ]
+      , [ "opentag", { name: "span",
+                       attributes: { class: "test", hello: "world" } } ]
+      , [ "closetag", "span" ]
+      ]
+    , strict : false
+    , opt : {lowercase:true}
+    }
+  )
+
+// backward compatibility with old lowercasetags opt
+require(__dirname).test
+  ( { xml :
+      "<span class=\"test\" hello=\"world\"></span>"
+    , expect :
+      [ [ "attribute", { name: "class", value: "test" } ]
+      , [ "attribute", { name: "hello", value: "world" } ]
+      , [ "opentag", { name: "span",
+                       attributes: { class: "test", hello: "world" } } ]
+      , [ "closetag", "span" ]
+      ]
+    , strict : false
+    , opt : {lowercasetags:true}
+    }
+  )

package/test/index.js

@@ -1,5 +1,5 @@
-
-var util = require("util")
+var globalsBefore = JSON.stringify(Object.keys(global))
+  , util = require("util")
   , assert = require("assert")
   , fs = require("fs")
   , path = require("path")
@@ -47,7 +47,7 @@ exports.test = function test (options) {
 
 if (module === require.main) {
   var running = true
-  , failures = 0
+    , failures = 0
 
   function fail (file, er) {
     util.error("Failed: "+file)
@@ -66,6 +66,14 @@ if (module === require.main) {
       // run this test.
       try {
         require(path.resolve(__dirname, file))
+        var globalsAfter = JSON.stringify(Object.keys(global))
+        if (globalsAfter !== globalsBefore) {
+          var er = new Error("new globals introduced\n"+
+                             "expected: "+globalsBefore+"\n"+
+                             "actual:   "+globalsAfter)
+          globalsBefore = globalsAfter
+          throw er
+        }
         console.log("ok " + (++i) + " - " + file)
       } catch (er) {
         console.log("not ok "+ (++i) + " - " + file)

package/test/unquoted.js

@@ -4,10 +4,10 @@ require(__dirname).test
   ( { xml :
       "<span class=test hello=world></span>"
     , expect :
-      [ [ "attribute", { name: "class", value: "test" } ]
-      , [ "attribute", { name: "hello", value: "world" } ]
+      [ [ "attribute", { name: "CLASS", value: "test" } ]
+      , [ "attribute", { name: "HELLO", value: "world" } ]
       , [ "opentag", { name: "SPAN",
-                       attributes: { class: "test", hello: "world" } } ]
+                       attributes: { CLASS: "test", HELLO: "world" } } ]
       , [ "closetag", "SPAN" ]
       ]
     , strict : false

package/test/xmlns-strict.js

@@ -29,9 +29,9 @@ require(__dirname).test
             attributes: { "xmlns": { name: "xmlns", value: "uri:default", prefix: "xmlns", local: "", uri: "http://www.w3.org/2000/xmlns/" } },
             ns: { "": "uri:default" } } ]
 
-      , [ "attribute", { name: "attr", value: "normal", prefix: "", local: "attr", uri: "uri:default" } ]
+      , [ "attribute", { name: "attr", value: "normal", prefix: "", local: "attr", uri: "" } ]
       , [ "opentag", { name: "plain", prefix: "", local: "plain", uri: "uri:default", ns: { '': 'uri:default' },
-            attributes: { "attr": { name: "attr", value: "normal", prefix: "", local: "attr", uri: "uri:default" } } } ]
+            attributes: { "attr": { name: "attr", value: "normal", prefix: "", local: "attr", uri: "" } } } ]
       , [ "closetag", "plain" ]
 
       , [ "closetag", "ns1" ]

package/test/xmlns-xml-default-ns.js

@@ -0,0 +1,30 @@
+var xmlns_attr =
+{
+    name: "xmlns", value: "http://foo", prefix: "xmlns",
+    local: "", uri : "http://www.w3.org/2000/xmlns/"
+};
+
+var attr_attr =
+{
+    name: "attr", value: "bar", prefix: "",
+    local : "attr",  uri : ""
+};
+
+
+require(__dirname).test
+  ( { xml :
+      "<elm xmlns='http://foo' attr='bar'/>"
+    , expect :
+      [ [ "opennamespace", { prefix: "", uri: "http://foo" } ]
+      , [ "attribute", xmlns_attr ]
+      , [ "attribute", attr_attr ]
+      , [ "opentag", { name: "elm", prefix: "", local: "elm", uri : "http://foo",
+                       ns : { "" : "http://foo" },
+                       attributes: { xmlns: xmlns_attr, attr: attr_attr } } ]
+      , [ "closetag", "elm" ]
+      , [ "closenamespace", { prefix: "", uri: "http://foo"} ]
+      ]
+    , strict : true
+    , opt : {xmlns: true}
+    }
+  )