src: externalize zlib.js messages

nodejs · jasnell · Jan 7, 2016 · Jan 8, 2016 · Jan 8, 2016 · Jan 8, 2016
commit cd4db97ef442355fbbbb08798726a503cb1e8c79
diff --git a/lib/zlib.js b/lib/zlib.js
@@ -1,13 +1,13 @@
 'use strict';
 
+const I18N = require('internal/messages');
 const Buffer = require('buffer').Buffer;
 const Transform = require('_stream_transform');
 const binding = process.binding('zlib');
 const util = require('util');
 const assert = require('assert').ok;
 const kMaxLength = require('buffer').kMaxLength;
-const kRangeErrorMessage = 'Cannot create final Buffer. ' +
-    'It would be larger than 0x' + kMaxLength.toString(16) + ' bytes';
+const kRangeErrorMessage = I18N(I18N.ZLIB_RANGE_ERROR, kMaxLength.toString(16));
 
 // zlib doesn't provide these, so kludge them in following the same
 // const naming scheme zlib uses.
@@ -232,7 +232,7 @@ function zlibBufferSync(engine, buffer) {
   if (typeof buffer === 'string')
     buffer = new Buffer(buffer);
   if (!(buffer instanceof Buffer))
-    throw new TypeError('Not a string or buffer');
+    throw I18N.TypeError(I18N.ZLIB_STRING_OR_BUFFER, 'buffer');
 
   var flushFlag = binding.Z_FINISH;
 
@@ -301,36 +301,36 @@ function Zlib(opts, mode) {
         opts.flush !== binding.Z_FULL_FLUSH &&
         opts.flush !== binding.Z_FINISH &&
         opts.flush !== binding.Z_BLOCK) {
-      throw new Error('Invalid flush flag: ' + opts.flush);
+      throw I18N.Error(I18N.ZLIB_INVALID_FLUSH_FLAG, opts.flush);
     }
   }
   this._flushFlag = opts.flush || binding.Z_NO_FLUSH;
 
   if (opts.chunkSize) {
     if (opts.chunkSize < exports.Z_MIN_CHUNK ||
         opts.chunkSize > exports.Z_MAX_CHUNK) {
-      throw new Error('Invalid chunk size: ' + opts.chunkSize);
+      throw I18N.Error(I18N.ZLIB_INVALID_CHUNK_SIZE, opts.chunkSize);
     }
   }
 
   if (opts.windowBits) {
     if (opts.windowBits < exports.Z_MIN_WINDOWBITS ||
         opts.windowBits > exports.Z_MAX_WINDOWBITS) {
-      throw new Error('Invalid windowBits: ' + opts.windowBits);
+      throw I18N.Error(I18N.ZLIB_INVALID_WINDOWBITS, opts.windowBits);
     }
   }
 
   if (opts.level) {
     if (opts.level < exports.Z_MIN_LEVEL ||
         opts.level > exports.Z_MAX_LEVEL) {
-      throw new Error('Invalid compression level: ' + opts.level);
+      throw I18N.Error(I18N.ZLIB_INVALID_COMPRESSION, opts.level);
     }
   }
 
   if (opts.memLevel) {
     if (opts.memLevel < exports.Z_MIN_MEMLEVEL ||
         opts.memLevel > exports.Z_MAX_MEMLEVEL) {
-      throw new Error('Invalid memLevel: ' + opts.memLevel);
+      throw I18N.Error(I18N.ZLIB_INVALID_MEMLEVEL, opts.memLevel);
     }
   }
 
@@ -340,14 +340,13 @@ function Zlib(opts, mode) {
         opts.strategy != exports.Z_RLE &&
         opts.strategy != exports.Z_FIXED &&
         opts.strategy != exports.Z_DEFAULT_STRATEGY) {
-      throw new Error('Invalid strategy: ' + opts.strategy);
+      throw I18N.Error(I18N.ZLIB_INVALID_STRATEGY, opts.strategy);
     }
   }
 
   if (opts.dictionary) {
-    if (!(opts.dictionary instanceof Buffer)) {
-      throw new Error('Invalid dictionary: it should be a Buffer instance');
-    }
+    if (!(opts.dictionary instanceof Buffer))
+      throw I18N.Error(I18N.ZLIB_INVALID_DICTIONARY);
   }
 
   this._handle = new binding.Zlib(mode);
@@ -392,20 +391,20 @@ util.inherits(Zlib, Transform);
 Zlib.prototype.params = function(level, strategy, callback) {
   if (level < exports.Z_MIN_LEVEL ||
       level > exports.Z_MAX_LEVEL) {
-    throw new RangeError('Invalid compression level: ' + level);
+    throw I18N.RangeError(I18N.ZLIB_INVALID_COMPRESSION, level);
   }
   if (strategy != exports.Z_FILTERED &&
       strategy != exports.Z_HUFFMAN_ONLY &&
       strategy != exports.Z_RLE &&
       strategy != exports.Z_FIXED &&
       strategy != exports.Z_DEFAULT_STRATEGY) {
-    throw new TypeError('Invalid strategy: ' + strategy);
+    throw I18N.TypeError(I18N.ZLIB_INVALID_STRATEGY, strategy);
   }
 
   if (this._level !== level || this._strategy !== strategy) {
     var self = this;
     this.flush(binding.Z_SYNC_FLUSH, function() {
-      assert(!self._closed, 'zlib binding closed');
+      assert(!self._closed, I18N(I18N.ZLIB_ASSERT_BINDING_CLOSED));
       self._handle.params(level, strategy);
       if (!self._hadError) {
         self._level = level;
@@ -419,7 +418,7 @@ Zlib.prototype.params = function(level, strategy, callback) {
 };
 
 Zlib.prototype.reset = function() {
-  assert(!this._closed, 'zlib binding closed');
+  assert(!this._closed, I18N(I18N.ZLIB_ASSERT_BINDING_CLOSED));
   return this._handle.reset();
 };
 
@@ -478,10 +477,10 @@ Zlib.prototype._transform = function(chunk, encoding, cb) {
   var last = ending && (!chunk || ws.length === chunk.length);
 
   if (chunk !== null && !(chunk instanceof Buffer))
-    return cb(new Error('invalid input'));
+    return cb(I18N.Error(I18N.ZLIB_INVALID_INPUT));
 
   if (this._closed)
-    return cb(new Error('zlib binding closed'));
+    return cb(I18N.Error(I18N.ZLIB_ASSERT_BINDING_CLOSED));
 
   // If it's the last chunk, or a final flush, we use the Z_FINISH flush flag.
   // If it's explicitly flushing at some other time, then we use
@@ -519,7 +518,7 @@ Zlib.prototype._processChunk = function(chunk, flushFlag, cb) {
       error = er;
     });
 
-    assert(!this._closed, 'zlib binding closed');
+    assert(!this._closed, I18N(I18N.ZLIB_ASSERT_BINDING_CLOSED));
     do {
       var res = this._handle.writeSync(flushFlag,
                                        chunk, // in
@@ -545,7 +544,7 @@ Zlib.prototype._processChunk = function(chunk, flushFlag, cb) {
     return buf;
   }
 
-  assert(!this._closed, 'zlib binding closed');
+  assert(!this._closed, I18N(I18N.ZLIB_ASSERT_BINDING_CLOSED));
   var req = this._handle.write(flushFlag,
                                chunk, // in
                                inOff, // in_off
@@ -562,7 +561,7 @@ Zlib.prototype._processChunk = function(chunk, flushFlag, cb) {
       return;
 
     var have = availOutBefore - availOutAfter;
-    assert(have >= 0, 'have should not go down');
+    assert(have >= 0, I18N(I18N.ZLIB_ASSERT_HAVE_GO_DOWN));
 
     if (have > 0) {
       var out = self._buffer.slice(self._offset, self._offset + have);

diff --git a/src/messages/en/messages.h b/src/messages/en/messages.h
@@ -430,5 +430,19 @@
   XX(UTIL_ERROR_DEPRECATED,                                                   \
     NODE_DEPRECATE_MESSAGE("util.error", "console.error"))                    \
   XX(UTIL_LOCAL, "Local")                                                     \
+  XX(ZLIB_RANGE_ERROR,                                                        \
+    "Cannot create final Buffer. It would be larger than 0x{0} bytes")        \
+  XX(ZLIB_STRING_OR_BUFFER, "'{0}' must be a string or Buffer")               \
+  XX(ZLIB_INVALID_FLUSH_FLAG, "Invalid flush flag: {0}")                      \
+  XX(ZLIB_INVALID_CHUNK_SIZE, "Invalid chunk size: {0}")                      \
+  XX(ZLIB_INVALID_WINDOWBITS, "Invalid windowBits: {0}")                      \
+  XX(ZLIB_INVALID_COMPRESSION, "Invalid compression level: {0}")              \
+  XX(ZLIB_INVALID_MEMLEVEL, "Invalid memLevel: {0}")                          \
+  XX(ZLIB_INVALID_STRATEGY, "Invalid strategy: {0}")                          \
+  XX(ZLIB_INVALID_DICTIONARY,                                                 \
+    "Invalid dictionary: it should be a Buffer instance")                     \
+  XX(ZLIB_ASSERT_BINDING_CLOSED, "zlib binding closed")                       \
+  XX(ZLIB_INVALID_INPUT, "invalid input")                                     \
+  XX(ZLIB_ASSERT_HAVE_GO_DOWN, "have should not go down")                     \
 
 #endif  // SRC_NODE_MESSAGES_SRC_H_