sax 0.1.1 → 0.1.5

{1289345704997-0.9273225662764162 → package}/README.md

@@ -38,9 +38,9 @@ Unknown entities will fail in strict mode, and in loose mode, will pass through
     var sax = require("./lib/sax"),
       strict = true, // set to false for html-mode
       parser = sax.parser(strict);
-    
+
     parser.onerror = function (e) {
-      // an error happened. 
+      // an error happened.
     };
     parser.ontext = function (t) {
       // got some text.  t is the string of text.
@@ -54,7 +54,7 @@ Unknown entities will fail in strict mode, and in loose mode, will pass through
     parser.onend = function () {
       // parser stream is done, and ready to have more stuff written to it.
     };
-    
+
     parser.write('<xml>Hello, <who name="world">world</who>!</xml>').close();
 
 ## Arguments
@@ -90,7 +90,7 @@ At all times, the parser object will have the following members:
 `line`, `column`, `position` - Indications of the position in the XML document where
 the parser currently is looking.
 
-`closed` - Boolean indicating whether or not the parser can be written to.  If it's 
+`closed` - Boolean indicating whether or not the parser can be written to.  If it's
 `true`, then wait for the `ready` event to write again.
 
 `strict` - Boolean indicating whether or not the parser is a jerk.
@@ -133,10 +133,14 @@ will have `closeTag` emitted immediately after `openTag`.  Argument: tag name.
 
 `comment` - A comment node.  Argument: the string of the comment.
 
-`cdata` - A `<![CDATA[` block.  Since `<![CDATA[` blocks can get quite large, this event
+`opencdata` - The opening tag of a `<![CDATA[` block.
+
+`cdata` - The text of a `<![CDATA[` block.  Since `<![CDATA[` blocks can get quite large, this event
 may fire multiple times for a single block, if it is broken up into multiple `write()`s.
 Argument: the string of random character data.
 
+`closecdata` - The closing tag (`]]>`) of a `<![CDATA[` block.
+
 `end` - Indication that the closed stream has ended.
 
 `ready` - Indication that the stream has reset, and is ready to be written to.
@@ -146,4 +150,4 @@ Argument: the string of random character data.
 Build an HTML parser on top of this, which follows the same parsing rules as web browsers.
 
 Make it fast by replacing the trampoline with a switch, and not buffering so much
-stuff.
+stuff.

{1289345704997-0.9273225662764162 → package}/lib/sax.js

@@ -1,5 +1,6 @@
+// wrapper for non-node envs
+;(function (sax) {
 
-var sax = exports;
 sax.parser = function (strict, opt) { return new SAXParser(strict, opt) };
 sax.SAXParser = SAXParser;
 
@@ -38,18 +39,23 @@ function SAXParser (strict, opt) {
   emit(this, "onready");
 }
 function checkBufferLength (parser) {
-  var maxAllowed = sax.MAX_BUFFER_LENGTH,
+  var maxAllowed = Math.max(sax.MAX_BUFFER_LENGTH, 10),
     maxActual = 0;
   for (var i = 0, l = buffers.length; i < l; i ++) {
     var len = parser[buffers[i]].length;
     if (len > maxAllowed) {
-      if (buffers[i] === "textNode") {
-        // Text nodes can get big, and since they're buffered, we can get here
-        // under normal conditions.  Avoid issues by emitting the text node now,
-        // so at least it won't get any bigger.
-        closeText(parser);
-      } else {
-        error(parser, "Max buffer length exceeded: "+buffers[i]);
+      // Text/cdata nodes can get big, and since they're buffered,
+      // we can get here under normal conditions.
+      // Avoid issues by emitting the text node now,
+      // so at least it won't get any bigger.
+      switch (buffers[i]) {
+        case "textNode": closeText(parser) ; break
+        case "cdata":
+          emitNode(parser, "oncdata", parser.cdata)
+          parser.cdata = ""
+          break
+        default:
+          error(parser, "Max buffer length exceeded: "+buffers[i])
       }
     }
     maxActual = Math.max(maxActual, len);
@@ -112,9 +118,9 @@ sax.STATE =
 , ATTRIB                    : S++ // <a
 , ATTRIB_NAME               : S++ // <a foo
 , ATTRIB_NAME_SAW_WHITE     : S++ // <a foo _
-, ATTRIB_VALUE              : S++ // <a foo="bar
+, ATTRIB_VALUE              : S++ // <a foo=
 , ATTRIB_VALUE_QUOTED       : S++ // <a foo="bar
-, ATTRIB_VALUE_UNQUOTED     : S++ // <a foo="bar
+, ATTRIB_VALUE_UNQUOTED     : S++ // <a foo=bar
 , ATTRIB_VALUE_ENTITY_Q     : S++ // <foo bar="&quot;"
 , ATTRIB_VALUE_ENTITY_U     : S++ // <foo bar=&quot;
 , CLOSE_TAG                 : S++ // </a
@@ -136,7 +142,7 @@ S = sax.STATE;
 sax.EVENTS = [ // for discoverability.
   "text", "processinginstruction", "sgmldeclaration",
   "doctype", "comment", "attribute", "opentag", "closetag",
-  "cdata", "error", "end", "ready" ];
+  "opencdata", "cdata", "closecdata", "error", "end", "ready" ];
 
 function emit (parser, event, data) {
   parser[event] && parser[event](data);
@@ -268,6 +274,20 @@ function write (chunk) {
         }
       continue;
       case S.TEXT:
+        if (parser.sawRoot && !parser.closedRoot) {
+          var starti = i-1;
+          while (c && c!=="<" && c!=="&") {
+            c = chunk.charAt(i++);
+            if (c) {
+              parser.position ++;
+              if (c === "\n") {
+                parser.line ++;
+                parser.column = 0;
+              } else parser.column ++;
+            }
+          }
+          parser.textNode += chunk.substring(starti, i-1);
+        }
         if (c === "<") parser.state = S.OPEN_WAKA;
         else {
           if (not(whitespace, c) && (!parser.sawRoot || parser.closedRoot))
@@ -300,6 +320,7 @@ function write (chunk) {
       continue;
       case S.SGML_DECL:
         if ((parser.sgmlDecl+c).toUpperCase() === CDATA) {
+          emitNode(parser, "onopencdata");
           parser.state = S.CDATA;
           parser.sgmlDecl = "";
           parser.cdata = "";
@@ -398,8 +419,11 @@ function write (chunk) {
       case S.CDATA_ENDING_2:
         if (c === ">") {
           if (parser.cdata) emitNode(parser, "oncdata", parser.cdata);
+          emitNode(parser, "onclosecdata");
           parser.cdata = "";
           parser.state = S.TEXT;
+        } else if (c === "]") {
+          parser.cdata += "]"
         } else {
           parser.cdata += "]]" + c;
           parser.state = S.CDATA;
@@ -586,10 +610,11 @@ function write (chunk) {
     }
   } // while
   // cdata blocks can get very big under normal conditions. emit and move on.
-  if (parser.state === S.CDATA && parser.cdata) {
-    emitNode(parser, "oncdata", parser.cdata);
-    parser.cdata = "";
-  }
+  // if (parser.state === S.CDATA && parser.cdata) {
+  //   emitNode(parser, "oncdata", parser.cdata);
+  //   parser.cdata = "";
+  // }
   if (parser.position >= parser.bufferCheckPosition) checkBufferLength(parser);
   return parser;
 }
+})(typeof exports === "undefined" ? sax = {} : exports)

{1289345704997-0.9273225662764162 → package}/package.json

@@ -1,6 +1,6 @@
 { "name" : "sax"
 , "author" : "Isaac Z. Schlueter <i@izs.me>"
-, "version" : "0.1.1"
+, "version" : "0.1.5"
 , "main" : "lib/sax"
 , "license" : "MIT"
 , "scripts" : { "test" : "node test/index.js" }

{1289345704997-0.9273225662764162 → package}/test/buffer-overrun.js

@@ -1,5 +1,7 @@
 // set this really low so that I don't have to put 64 MB of xml in here.
-require(require("path").join(__dirname, "../lib/sax")).MAX_BUFFER_LENGTH = 5;
+var sax = require("../lib/sax")
+var bl = sax.MAX_BUFFER_LENGTH
+sax.MAX_BUFFER_LENGTH = 5;
 
 require(__dirname).test({
   expect : [
@@ -19,4 +21,5 @@ require(__dirname).test({
   .write("STUVWXYZ>")
   .write("yo")
   .write("</abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ>")
-  .close();
+  .close();
+sax.MAX_BUFFER_LENGTH = bl

{1289345704997-0.9273225662764162 → package}/test/cdata-chunked.js

@@ -2,8 +2,9 @@
 require(__dirname).test({
   expect : [
     ["opentag", {"name": "R","attributes": {}}],
-    ["cdata", " this is "],
-    ["cdata", "character data  "],
+    ["opencdata", undefined],
+    ["cdata", " this is character data  "],
+    ["closecdata", undefined],
     ["closetag", "R"]
   ]
 }).write("<r><![CDATA[ this is ").write("character data  ").write("]]></r>").close();

package/test/cdata-end-split.js

@@ -0,0 +1,15 @@
+
+require(__dirname).test({
+  expect : [
+    ["opentag", {"name": "R","attributes": {}}],
+    ["opencdata", undefined],
+    ["cdata", " this is "],
+    ["closecdata", undefined],
+    ["closetag", "R"]
+  ]
+})
+  .write("<r><![CDATA[ this is ]")
+  .write("]>")
+  .write("</r>")
+  .close();
+

package/test/cdata-fake-end.js

@@ -0,0 +1,28 @@
+
+var p = require(__dirname).test({
+  expect : [
+    ["opentag", {"name": "R","attributes": {}}],
+    ["opencdata", undefined],
+    ["cdata", "[[[[[[[[]]]]]]]]"],
+    ["closecdata", undefined],
+    ["closetag", "R"]
+  ]
+})
+var x = "<r><![CDATA[[[[[[[[[]]]]]]]]]]></r>"
+for (var i = 0; i < x.length ; i ++) {
+  p.write(x.charAt(i))
+}
+p.close();
+
+
+var p2 = require(__dirname).test({
+  expect : [
+    ["opentag", {"name": "R","attributes": {}}],
+    ["opencdata", undefined],
+    ["cdata", "[[[[[[[[]]]]]]]]"],
+    ["closecdata", undefined],
+    ["closetag", "R"]
+  ]
+})
+var x = "<r><![CDATA[[[[[[[[[]]]]]]]]]]></r>"
+p2.write(x).close();

package/test/cdata-multiple.js

@@ -0,0 +1,15 @@
+
+require(__dirname).test({
+  expect : [
+    ["opentag", {"name": "R","attributes": {}}],
+    ["opencdata", undefined],
+    ["cdata", " this is "],
+    ["closecdata", undefined],
+    ["opencdata", undefined],
+    ["cdata", "character data  "],
+    ["closecdata", undefined],
+    ["closetag", "R"]
+  ]
+}).write("<r><![CDATA[ this is ]]>").write("<![CDA").write("T").write("A[")
+  .write("character data  ").write("]]></r>").close();
+

{1289345704997-0.9273225662764162 → package}/test/cdata.js

@@ -2,7 +2,9 @@ require(__dirname).test({
   xml : "<r><![CDATA[ this is character data  ]]></r>",
   expect : [
     ["opentag", {"name": "R","attributes": {}}],
+    ["opencdata", undefined],
     ["cdata", " this is character data  "],
+    ["closecdata", undefined],
     ["closetag", "R"]
   ]
 });

{1289345704997-0.9273225662764162 → package}/test/index.js

@@ -21,17 +21,18 @@ exports.test = function test (options) {
       assert.ok( e < expect.length,
         "expectation #"+e+" "+sys.inspect(expect[e])+"\n"+
         "Unexpected event: "+ev+" "+(n ? sys.inspect(n) : ""));
+      var inspected = n instanceof Error ? "\n"+ n.message : sys.inspect(n)
       assert.equal(ev, expect[e][0],
         "expectation #"+e+"\n"+
         "Didn't get expected event\n"+
         "expect: "+expect[e][0] + " " +sys.inspect(expect[e][1])+"\n"+
-        "actual: "+ev+" "+sys.inspect(n)+"\n");
+        "actual: "+ev+" "+inspected+"\n");
       if (ev === "error") assert.equal(n.message, expect[e][1]);
       else assert.deepEqual(n, expect[e][1],
         "expectation #"+e+"\n"+
         "Didn't get expected argument\n"+
         "expect: "+expect[e][0] + " " +sys.inspect(expect[e][1])+"\n"+
-        "actual: "+ev+" "+sys.inspect(n)+"\n");
+        "actual: "+ev+" "+inspected+"\n");
       e++;
       if (ev === "error") parser.resume();
     };
@@ -40,30 +41,33 @@ exports.test = function test (options) {
   return parser;
 }
 
-if (module.id === ".") {
+if (module === require.main) {
   var running = true,
     failures = 0;
-  function fail (file, next) { return function (er) {
+  function fail (file, er) {
     sys.error("Failed: "+file);
-    sys.error(er.message);
+    sys.error(er.stack || er.message);
     failures ++;
-    next();
-  }}
-  
-  fs.readdir(__dirname, function (error, files) {(function T (f) {
-    var file = files[f];
-    if (!file) {
-      if (!failures) return sys.puts("ok");
-      else return sys.error(failures + " failure" + (failures > 1 ? "s" : ""));
-    }
-    if (path.basename(file) === path.basename(__filename))
-      return process.nextTick(function () { T(f + 1) });
-    // run this test.
-    function next () { T(f + 1) };
-    if (/\.js$/.exec(file)) {
-      require.async(__dirname + "/"+file.replace(/\.js$/, ''), function (er) {
-        return (er) ? fail(file, next) : next()
-      });
-    }
-  })(0)});
-}
+  }
+
+  fs.readdir(__dirname, function (error, files) {
+    files = files.filter(function (file) {
+      return (/\.js$/.exec(file) && file !== 'index.js')
+    })
+    var n = files.length
+      , i = 0
+    console.log("0.." + n)
+    files.forEach(function (file) {
+      // run this test.
+      try {
+        require(path.resolve(__dirname, file))
+        console.log("ok " + (++i) + " - " + file)
+      } catch (er) {
+        console.log("not ok "+ (++i) + " - " + file)
+        fail(file, er)
+      }
+    })
+    if (!failures) return console.log("#all pass");
+    else return console.error(failures + " failure" + (failures > 1 ? "s" : ""));
+  });
+}

package/test/issue-23.js

@@ -0,0 +1,43 @@
+
+require(__dirname).test
+  ( { xml :
+      "<compileClassesResponse>"+
+        "<result>"+
+          "<bodyCrc>653724009</bodyCrc>"+
+          "<column>-1</column>"+
+          "<id>01pG0000002KoSUIA0</id>"+
+          "<line>-1</line>"+
+          "<name>CalendarController</name>"+
+          "<success>true</success>"+
+        "</result>"+
+      "</compileClassesResponse>"
+
+    , expect :
+      [ [ "opentag", { name: "COMPILECLASSESRESPONSE", attributes: {} } ]
+      , [ "opentag", { name : "RESULT", attributes: {} } ]
+      , [ "opentag", { name: "BODYCRC", attributes: {} } ]
+      , [ "text", "653724009" ]
+      , [ "closetag", "BODYCRC" ]
+      , [ "opentag", { name: "COLUMN", attributes: {} } ]
+      , [ "text", "-1" ]
+      , [ "closetag", "COLUMN" ]
+      , [ "opentag", { name: "ID", attributes: {} } ]
+      , [ "text", "01pG0000002KoSUIA0" ]
+      , [ "closetag", "ID" ]
+      , [ "opentag", {name: "LINE", attributes: {} } ]
+      , [ "text", "-1" ]
+      , [ "closetag", "LINE" ]
+      , [ "opentag", {name: "NAME", attributes: {} } ]
+      , [ "text", "CalendarController" ]
+      , [ "closetag", "NAME" ]
+      , [ "opentag", {name: "SUCCESS", attributes: {} } ]
+      , [ "text", "true" ]
+      , [ "closetag", "SUCCESS" ]
+      , [ "closetag", "RESULT" ]
+      , [ "closetag", "COMPILECLASSESRESPONSE" ]
+      ]
+    , strict : false
+    , opt : {}
+    }
+  )
+

package/test/parser-position.js

@@ -0,0 +1,27 @@
+var sax = require("../lib/sax"),
+    assert = require("assert")
+
+function testPosition(chunks, expectedEvents) {
+  var parser = sax.parser();
+  expectedEvents.forEach(function(expectation) {
+    parser['on' + expectation[0]] = function() {
+      assert.equal(parser.position, expectation[1]);
+    }
+  });
+  chunks.forEach(function(chunk) {
+    parser.write(chunk);
+  });
+};
+
+testPosition(['<div>abcdefgh</div>'],
+             [ ['opentag', 5]
+             , ['text', 19]
+             , ['closetag', 19]
+             ]);
+
+testPosition(['<div>abcde','fgh</div>'],
+             [ ['opentag', 5]
+             , ['text', 19]
+             , ['closetag', 19]
+             ]);
+