string_decoder: make write after end to reset

doc/api/string_decoder.md

@@ -66,6 +66,16 @@ substitution characters appropriate for the character encoding.
 If the `buffer` argument is provided, one final call to `stringDecoder.write()`
 is performed before returning the remaining input.
 
+### stringDecoder.reset([encoding])
+<!-- YAML
+added: REPLACEME
+-->
+
+* `encoding` {string} The character encoding the `StringDecoder` will use.
+  Defaults to the current `encoding` of the decoder.
+
+Flushes all the internal data and the decoder will behave like a new object.
+
 ### stringDecoder.write(buffer)
 <!-- YAML
 added: v0.1.99
@@ -82,3 +92,4 @@ Returns a decoded string, ensuring that any incomplete multibyte characters at
 the end of the `Buffer` are omitted from the returned string and stored in an
 internal buffer for the next call to `stringDecoder.write()` or
 `stringDecoder.end()`.
+

lib/string_decoder.js

@@ -41,36 +41,43 @@ function normalizeEncoding(enc) {
 // characters.
 exports.StringDecoder = StringDecoder;
 function StringDecoder(encoding) {
+  if (encoding === this.encoding && encoding !== undefined) {
+    this.lastNeed = 0;
+    this.lastTotal = 0;
+    this.lastChar = Buffer.allocUnsafe(this._nb || 0);
+    return;
+  }
+
   this.encoding = normalizeEncoding(encoding);
-  var nb;
   switch (this.encoding) {
     case 'utf16le':
       this.text = utf16Text;
-      this.end = utf16End;
-      nb = 4;
+      this._nb = 4;
       break;
     case 'utf8':
       this.fillLast = utf8FillLast;
-      nb = 4;
+      this._nb = 4;
       break;
     case 'base64':
       this.text = base64Text;
-      this.end = base64End;
-      nb = 3;
+      this._nb = 3;
       break;
     default:
       this.write = simpleWrite;
-      this.end = simpleEnd;
+      this._nb = 0;
       return;
   }
   this.lastNeed = 0;
   this.lastTotal = 0;
-  this.lastChar = Buffer.allocUnsafe(nb);
+  this.lastChar = Buffer.allocUnsafe(this._nb);
 }
 
+StringDecoder.prototype.reset = StringDecoder;
+
 StringDecoder.prototype.write = function(buf) {
   if (buf.length === 0)
     return '';
+
   var r;
   var i;
   if (this.lastNeed) {
@@ -87,7 +94,7 @@ StringDecoder.prototype.write = function(buf) {
   return r || '';
 };
 
-StringDecoder.prototype.end = utf8End;
+StringDecoder.prototype.end = end;
 
 // Returns only complete characters in a Buffer
 StringDecoder.prototype.text = utf8Text;
@@ -208,9 +215,9 @@ function utf8Text(buf, i) {
 
 // For UTF-8, a replacement character is added when ending on a partial
 // character.
-function utf8End(buf) {
-  const r = (buf && buf.length ? this.write(buf) : '');
-  if (this.lastNeed)
+function utf8End(ctx, buf) {
+  const r = (buf && buf.length ? ctx.write(buf) : '');
+  if (ctx.lastNeed)
     return r + '\ufffd';
   return r;
 }
@@ -242,11 +249,11 @@ function utf16Text(buf, i) {
 
 // For UTF-16LE we do not explicitly append special replacement characters if we
 // end on a partial character, we simply let v8 handle that.
-function utf16End(buf) {
-  const r = (buf && buf.length ? this.write(buf) : '');
-  if (this.lastNeed) {
-    const end = this.lastTotal - this.lastNeed;
-    return r + this.lastChar.toString('utf16le', 0, end);
+function utf16End(ctx, buf) {
+  const r = (buf && buf.length ? ctx.write(buf) : '');
+  if (ctx.lastNeed) {
+    const end = ctx.lastTotal - ctx.lastNeed;
+    return r + ctx.lastChar.toString('utf16le', 0, end);
   }
   return r;
 }
@@ -267,10 +274,10 @@ function base64Text(buf, i) {
 }
 
 
-function base64End(buf) {
-  const r = (buf && buf.length ? this.write(buf) : '');
-  if (this.lastNeed)
-    return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);
+function base64End(ctx, buf) {
+  const r = (buf && buf.length ? ctx.write(buf) : '');
+  if (ctx.lastNeed)
+    return r + ctx.lastChar.toString('base64', 0, 3 - ctx.lastNeed);
   return r;
 }
 
@@ -279,6 +286,18 @@ function simpleWrite(buf) {
   return buf.toString(this.encoding);
 }
 
-function simpleEnd(buf) {
-  return (buf && buf.length ? this.write(buf) : '');
+function simpleEnd(ctx, buf) {
+  return (buf && buf.length ? ctx.write(buf) : '');
+}
+
+const endMappings = new Map([
+  ['utf16le', utf16End],
+  ['utf8', utf8End],
+  ['base64', base64End]
+]);
+
+function end(buf) {
+  const result = (endMappings.get(this.encoding) || simpleEnd)(this, buf);
+  this.reset(this.encoding);
+  return result;
 }

test/parallel/test-string-decoder-end.js

@@ -66,3 +66,13 @@ function testBuf(encoding, buf) {
   assert.strictEqual(res1, res3, 'one byte at a time should match toString');
   assert.strictEqual(res2, res3, 'all bytes at once should match toString');
 }
+
+{
+  // test to check if the write after end doesn't accumulate the data
+  const decoder = new SD('utf8');
+  const euroPart1 = Buffer.from([0xE2]);
+  const euroPart2 = Buffer.from([0x82, 0xAC]);
+  decoder.end(euroPart1);
+  const result = decoder.write(euroPart2);
+  assert.notStrictEqual(result, '€');
+}