sax 0.5.4 → 0.5.8

package/lib/sax.js

@@ -133,11 +133,24 @@ function clearBuffers (parser) {
   }
 }
 
+function flushBuffers (parser) {
+  closeText(parser)
+  if (parser.cdata !== "") {
+    emitNode(parser, "oncdata", parser.cdata)
+    parser.cdata = ""
+  }
+  if (parser.script !== "") {
+    emitNode(parser, "onscript", parser.script)
+    parser.script = ""
+  }
+}
+
 SAXParser.prototype =
   { end: function () { end(this) }
   , write: write
   , resume: function () { this.error = null; return this }
   , close: function () { return this.write(null) }
+  , flush: function () { flushBuffers(this) }
   }
 
 try {
@@ -179,6 +192,8 @@ function SAXStream (strict, opt) {
     me._parser.error = null
   }
 
+  this._decoder = null;
+
   streamWraps.forEach(function (ev) {
     Object.defineProperty(me, "on" + ev, {
       get: function () { return me._parser["on" + ev] },
@@ -199,13 +214,23 @@ SAXStream.prototype = Object.create(Stream.prototype,
   { constructor: { value: SAXStream } })
 
 SAXStream.prototype.write = function (data) {
+  if (typeof Buffer === 'function' &&
+      typeof Buffer.isBuffer === 'function' &&
+      Buffer.isBuffer(data)) {
+    if (!this._decoder) {
+      var SD = require('string_decoder').StringDecoder
+      this._decoder = new SD('utf8')
+    }
+    data = this._decoder.write(data);
+  }
+
   this._parser.write(data.toString())
   this.emit("data", data)
   return true
 }
 
 SAXStream.prototype.end = function (chunk) {
-  if (chunk && chunk.length) this._parser.write(chunk.toString())
+  if (chunk && chunk.length) this.write(chunk)
   this._parser.end()
   return true
 }
@@ -309,6 +334,7 @@ sax.STATE =
 , ATTRIB_NAME_SAW_WHITE     : S++ // <a foo _
 , ATTRIB_VALUE              : S++ // <a foo=
 , ATTRIB_VALUE_QUOTED       : S++ // <a foo="bar
+, ATTRIB_VALUE_CLOSED       : 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;
@@ -621,7 +647,7 @@ function error (parser, er) {
 
 function end (parser) {
   if (!parser.closedRoot) strictFail(parser, "Unclosed root tag")
-  if (parser.state !== S.TEXT) error(parser, "Unexpected end")
+  if ((parser.state !== S.BEGIN) && (parser.state !== S.TEXT)) error(parser, "Unexpected end")
   closeText(parser)
   parser.c = ""
   parser.closed = true
@@ -646,14 +672,14 @@ function newTag (parser) {
   parser.attribList.length = 0
 }
 
-function qname (name) {
+function qname (name, attribute) {
   var i = name.indexOf(":")
     , qualName = i < 0 ? [ "", name ] : name.split(":")
     , prefix = qualName[0]
     , local = qualName[1]
 
   // <x "xmlns"="http://foo">
-  if (name === "xmlns") {
+  if (attribute && name === "xmlns") {
     prefix = "xmlns"
     local = ""
   }
@@ -670,7 +696,7 @@ function attrib (parser) {
   }
 
   if (parser.opt.xmlns) {
-    var qn = qname(parser.attribName)
+    var qn = qname(parser.attribName, true)
       , prefix = qn.prefix
       , local = qn.local
 
@@ -743,7 +769,7 @@ function openTag (parser, selfClosing) {
       var nv = parser.attribList[i]
       var name = nv[0]
         , value = nv[1]
-        , qualName = qname(name)
+        , qualName = qname(name, true)
         , prefix = qualName.prefix
         , local = qualName.local
         , uri = prefix == "" ? "" : (tag.ns[prefix] || "")
@@ -1225,7 +1251,20 @@ function write (chunk) {
         }
         attrib(parser)
         parser.q = ""
-        parser.state = S.ATTRIB
+        parser.state = S.ATTRIB_VALUE_CLOSED
+      continue
+
+      case S.ATTRIB_VALUE_CLOSED:
+        if (is(whitespace, c)) {
+          parser.state = S.ATTRIB
+        } else if (c === ">") openTag(parser)
+        else if (c === "/") parser.state = S.OPEN_TAG_SLASH
+        else if (is(nameStart, c)) {
+          strictFail(parser, "No whitespace between attributes")
+          parser.attribName = c
+          parser.attribValue = ""
+          parser.state = S.ATTRIB_NAME
+        } else strictFail(parser, "Invalid attribute name")
       continue
 
       case S.ATTRIB_VALUE_UNQUOTED:

package/package.json

@@ -2,7 +2,7 @@
   "name": "sax",
   "description": "An evented streaming XML parser in JavaScript",
   "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
-  "version": "0.5.4",
+  "version": "0.5.8",
   "main": "lib/sax.js",
   "license": "BSD",
   "scripts": {

package/test/attribute-no-space.js

@@ -0,0 +1,75 @@
+// non-strict: no error
+require(__dirname).test
+  ( { xml : '<root attr1="first"attr2="second"/>'
+
+    , expect :
+      [ [ "attribute", { name: 'attr1', value: 'first' } ]
+      , [ "attribute", { name: 'attr2', value: 'second' } ]
+      , [ "opentag", { name: "root", attributes: {attr1: 'first', attr2: 'second'}, isSelfClosing: true } ]
+      , [ "closetag", "root" ]
+      ]
+    , strict : false
+    , opt : { lowercase: true }
+    }
+  )
+
+// strict: should give an error, but still parse
+require(__dirname).test
+  ( { xml : '<root attr1="first"attr2="second"/>'
+
+    , expect :
+      [ [ "attribute", { name: 'attr1', value: 'first' } ]
+      , [ "error", "No whitespace between attributes\nLine: 0\nColumn: 20\nChar: a" ]
+      , [ "attribute", { name: 'attr2', value: 'second' } ]
+      , [ "opentag", { name: "root", attributes: {attr1: 'first', attr2: 'second'}, isSelfClosing: true } ]
+      , [ "closetag", "root" ]
+      ]
+    , strict : true
+    , opt : { }
+    }
+  )
+
+// strict: other cases should still pass
+require(__dirname).test
+  ( { xml : '<root attr1="first" attr2="second"/>'
+
+    , expect :
+      [ [ "attribute", { name: 'attr1', value: 'first' } ]
+      , [ "attribute", { name: 'attr2', value: 'second' } ]
+      , [ "opentag", { name: "root", attributes: {attr1: 'first', attr2: 'second'}, isSelfClosing: true } ]
+      , [ "closetag", "root" ]
+      ]
+    , strict : true
+    , opt : { }
+    }
+  )
+
+// strict: other cases should still pass
+require(__dirname).test
+  ( { xml : '<root attr1="first"\nattr2="second"/>'
+
+    , expect :
+      [ [ "attribute", { name: 'attr1', value: 'first' } ]
+      , [ "attribute", { name: 'attr2', value: 'second' } ]
+      , [ "opentag", { name: "root", attributes: {attr1: 'first', attr2: 'second'}, isSelfClosing: true } ]
+      , [ "closetag", "root" ]
+      ]
+    , strict : true
+    , opt : { }
+    }
+  )
+
+// strict: other cases should still pass
+require(__dirname).test
+  ( { xml : '<root attr1="first"  attr2="second"/>'
+
+    , expect :
+      [ [ "attribute", { name: 'attr1', value: 'first' } ]
+      , [ "attribute", { name: 'attr2', value: 'second' } ]
+      , [ "opentag", { name: "root", attributes: {attr1: 'first', attr2: 'second'}, isSelfClosing: true } ]
+      , [ "closetag", "root" ]
+      ]
+    , strict : true
+    , opt : { }
+    }
+  )

package/test/end_empty_stream.js

@@ -0,0 +1,5 @@
+var assert = require('assert');
+var saxStream = require('../lib/sax').createStream();
+assert.doesNotThrow(function() {
+    saxStream.end();
+});

package/test/flush.js

@@ -0,0 +1,13 @@
+var parser = require(__dirname).test({
+  expect: [
+    ['opentag', {'name':'T', attributes:{}, isSelfClosing: false}],
+    ['text', 'flush'],
+    ['text', 'rest'],
+    ['closetag', 'T'],
+  ]
+});
+
+parser.write('<T>flush');
+parser.flush();
+parser.write('rest</T>');
+parser.close();

package/test/utf8-split.js

@@ -0,0 +1,32 @@
+var assert = require('assert')
+var saxStream = require('../lib/sax').createStream()
+
+var b = new Buffer('误')
+
+saxStream.on('text', function(text) {
+  assert.equal(text, b.toString())
+})
+
+saxStream.write(new Buffer('<test><a>'))
+saxStream.write(b.slice(0, 1))
+saxStream.write(b.slice(1))
+saxStream.write(new Buffer('</a><b>'))
+saxStream.write(b.slice(0, 2))
+saxStream.write(b.slice(2))
+saxStream.write(new Buffer('</b><c>'))
+saxStream.write(b)
+saxStream.write(new Buffer('</c>'))
+saxStream.write(Buffer.concat([new Buffer('<d>'), b.slice(0, 1)]))
+saxStream.end(Buffer.concat([b.slice(1), new Buffer('</d></test>')]))
+
+var saxStream2 = require('../lib/sax').createStream()
+
+saxStream2.on('text', function(text) {
+  assert.equal(text, '�')
+});
+
+saxStream2.write(new Buffer('<e>'));
+saxStream2.write(new Buffer([0xC0]));
+saxStream2.write(new Buffer('</e>'));
+saxStream2.write(Buffer.concat([new Buffer('<f>'), b.slice(0,1)]));
+saxStream2.end();

package/test/xmlns-as-tag-name.js

@@ -0,0 +1,15 @@
+
+require(__dirname).test
+  ( { xml :
+      "<xmlns/>"
+    , expect :
+      [ [ "opentag", { name: "xmlns", uri: "", prefix: "", local: "xmlns",
+                       attributes: {}, ns: {},
+                       isSelfClosing: true}
+        ],
+        ["closetag", "xmlns"]
+      ]
+    , strict : true
+    , opt : { xmlns: true }
+    }
+  );