sax 0.5.6 → 0.6.1

package/LICENSE

@@ -30,3 +30,28 @@ IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 The file "examples/strict.dtd" is licensed by the W3C and used according
 to the terms of the W3C SOFTWARE NOTICE AND LICENSE.  See LICENSE-W3C.html
 for details.
+
+
+"String.fromCodePoint" used under the terms of the MIT license.  Its license
+follows:
+
+    Copyright Mathias Bynens <http://mathiasbynens.be/>
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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 {
@@ -321,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;
@@ -633,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
@@ -890,7 +904,8 @@ function parseEntity (parser) {
     strictFail(parser, "Invalid character entity")
     return "&"+parser.entity + ";"
   }
-  return String.fromCharCode(num)
+
+  return String.fromCodePoint(num)
 }
 
 function write (chunk) {
@@ -1237,7 +1252,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:
@@ -1325,4 +1353,58 @@ function write (chunk) {
   return parser
 }
 
-})(typeof exports === "undefined" ? sax = {} : exports)
+/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+if (!String.fromCodePoint) {
+        (function() {
+                var stringFromCharCode = String.fromCharCode;
+                var floor = Math.floor;
+                var fromCodePoint = function() {
+                        var MAX_SIZE = 0x4000;
+                        var codeUnits = [];
+                        var highSurrogate;
+                        var lowSurrogate;
+                        var index = -1;
+                        var length = arguments.length;
+                        if (!length) {
+                                return '';
+                        }
+                        var result = '';
+                        while (++index < length) {
+                                var codePoint = Number(arguments[index]);
+                                if (
+                                        !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
+                                        codePoint < 0 || // not a valid Unicode code point
+                                        codePoint > 0x10FFFF || // not a valid Unicode code point
+                                        floor(codePoint) != codePoint // not an integer
+                                ) {
+                                        throw RangeError('Invalid code point: ' + codePoint);
+                                }
+                                if (codePoint <= 0xFFFF) { // BMP code point
+                                        codeUnits.push(codePoint);
+                                } else { // Astral code point; split in surrogate halves
+                                        // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+                                        codePoint -= 0x10000;
+                                        highSurrogate = (codePoint >> 10) + 0xD800;
+                                        lowSurrogate = (codePoint % 0x400) + 0xDC00;
+                                        codeUnits.push(highSurrogate, lowSurrogate);
+                                }
+                                if (index + 1 == length || codeUnits.length > MAX_SIZE) {
+                                        result += stringFromCharCode.apply(null, codeUnits);
+                                        codeUnits.length = 0;
+                                }
+                        }
+                        return result;
+                };
+                if (Object.defineProperty) {
+                        Object.defineProperty(String, 'fromCodePoint', {
+                                'value': fromCodePoint,
+                                'configurable': true,
+                                'writable': true
+                        });
+                } else {
+                        String.fromCodePoint = fromCodePoint;
+                }
+        }());
+}
+
+})(typeof exports === "undefined" ? sax = {} : exports);

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.6",
+  "version": "0.6.1",
   "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/emoji.js

@@ -0,0 +1,12 @@
+// split high-order numeric attributes into surrogate pairs
+require(__dirname).test
+  ( { xml : '<a>&#x1f525;</a>'
+    , expect :
+      [ [ 'opentag', { name: 'A', attributes: {}, isSelfClosing: false } ]
+      , [ 'text', '\ud83d\udd25' ]
+      , [ 'closetag', 'A' ]
+      ]
+    , strict : false
+    , 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/component.json

@@ -1,12 +0,0 @@
-{
-  "name": "sax",
-  "description": "An evented streaming XML parser in JavaScript",
-  "author": "Isaac Z. Schlueter <i@izs.me> (http://blog.izs.me/)",
-  "version": "0.5.2",
-  "main": "lib/sax.js",
-  "license": "BSD",
-  "scripts": [
-    "lib/sax.js"
-  ],
-  "repository": "git://github.com/isaacs/sax-js.git"
-}