refactor parser-sync

lib/parser-sync.js

@@ -9,80 +9,102 @@ var bitmapper = require('./bitmapper');
 var formatNormaliser = require('./format-normaliser');
 
 
-var ParserSync = module.exports = function(buffer, options) {
+module.exports = function(buffer, options) {
+
+  var err;
+  function handleError(_err_) {
+    err = _err_;
+  }
+
+  var data, bpp, width, height, depth, interlace;
+  function createData(_width_, _height_, _bpp_, _depth_, _interlace_) {
+
+    bpp = _bpp_;
+    width = _width_;
+    height = _height_;
+    depth = _depth_;
+    interlace = _interlace_;
+
+    data = new Buffer(width * height * 4);
+
+    return data; // todo do not return
+  }
+
+  var metaData;
+  function handleMetaData(_metaData_) {
+    metaData = _metaData_;
+  }
+
+  var gamma;
+  function handleGamma(_gamma_) {
+    gamma = _gamma_;
+  }
+
+  var inflateDataList = [];
+  function handleInflateData(inflatedData) {
+    inflateDataList.push(inflatedData);
+  }
 
   var reader = new SyncReader(buffer);
 
-  this._inflateDataList = [];
+  var parser = new Parser(options, {
-  this._parser = new Parser(options, {
     read: reader.read.bind(reader),
-    error: this._handleError.bind(this),
+    error: handleError,
-    metadata: this._metaData.bind(this),
+    metadata: handleMetaData,
-    gamma: this._gamma.bind(this),
+    gamma: handleGamma,
     finished: function() {
+      //todo make optional
     },
-    inflateData: this._inflateData.bind(this),
+    inflateData: handleInflateData,
-    createData: this._createData.bind(this)
+    createData: createData
   });
-  this._options = options;
 
-  this._parser.start();
+  parser.start();
   reader.process();
 
+  if (err) {
+    throw err;
+  }
+
   //join together the inflate datas
-  var inflateData = Buffer.concat(this._inflateDataList);
+  var inflateData = Buffer.concat(inflateDataList);
+  inflateDataList.length = 0;
 
-  var data = zlib.inflateSync(inflateData);
+  var inflatedData = zlib.inflateSync(inflateData);
+  inflateData = null;
 
-  if (!data || !data.length) {
+  if (!inflatedData || !inflatedData.length) {
     throw new Error('bad png - invalid inflate data response');
   }
 
-  data = FilterSync.process(
+  var unfilteredData = FilterSync.process(
-    data,
+    inflatedData,
-    this._width, this._height,
+    width,
-    this._bpp,
+    height,
-    this._depth,
+    bpp,
-    this._interlace,
+    depth,
-    this._options
+    interlace,
+    options
   );
-// todo do not store _data
+  inflateData = null;
-  this._data = bitmapper.dataToBitMap(data, this._width, this._height,
-    this._bpp,
-    this._depth,
-    this._interlace);
 
-  this.data = formatNormaliser(this._data, {
+  var bitmapData = bitmapper.dataToBitMap(unfilteredData, width, height,
-    depth: this._depth, // TODO always store in this format
+    bpp,
-    width: this._width,
+    depth,
-    height: this._height,
+    interlace);
-    colorType: this._parser._colorType,
+  unfilteredData = null;
-    palette: this._parser._palette,
+
-    transColor: this._parser._transColor });
+  var normalisedBitmapData = formatNormaliser(bitmapData, {
+    depth: depth, // TODO always store in this format
+    width: width,
+    height: height,
+    colorType: parser._colorType, //TODO event this
+    palette: parser._palette,
+    transColor: parser._transColor });
+
+  metaData.data = normalisedBitmapData;
+  metaData.gamma = gamma || 0;
+
+  return metaData;
 };
 
-ParserSync.prototype._handleError = function(err) {
-  this.err = err;
-};
-
-ParserSync.prototype._metaData = function(metaData) {
-  this.metaData = metaData;
-};
-
-ParserSync.prototype._gamma = function(gamma) {
-  this.gamma = gamma;
-};
-
-ParserSync.prototype._inflateData = function(data) {
-  this._inflateDataList.push(data);
-};
-
-ParserSync.prototype._createData = function(width, height, bpp, depth, interlace) {
-  this._data = new Buffer(width * height * 4);
-  this._bpp = bpp;
-  this._width = width;
-  this._height = height;
-  this._depth = depth;
-  this._interlace = interlace;
-  return this._data; // todo do not return
-};

lib/png-sync.js

@@ -1,21 +1,10 @@
 'use strict';
 
 
-var Parser = require('./parser-sync');
+var parse = require('./parser-sync');
 
 
 exports.read = function(buffer, options) {
 
-  var parser = new Parser(buffer, options || {});
+  return parse(buffer, options || {});
-
-  if (parser.err) {
-    throw parser.err;
-  }
-
-  return {
-    data: parser.data,
-    width: parser._width,
-    height: parser._height,
-    gamma: parser.gamma || 0
-  };
 };