read-xml/lib/index.js

Read a xml file respecting its encoding information

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.readXML = readXML;
exports.createStream = createStream;

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _debug = require('debug');

var _debug2 = _interopRequireDefault(_debug);

var _once = require('once');

var _once2 = _interopRequireDefault(_once);

var _concatStream = require('concat-stream');

var _concatStream2 = _interopRequireDefault(_concatStream);

var _iconvLite = require('iconv-lite');

var _iconvLite2 = _interopRequireDefault(_iconvLite);

var _findEncoding = require('./findEncoding');

var _findEncoding2 = _interopRequireDefault(_findEncoding);

var _defaultEncoding = require('./defaultEncoding');

var _defaultEncoding2 = _interopRequireDefault(_defaultEncoding);

var _DecoderXMLStream = require('./DecoderXMLStream');

var _DecoderXMLStream2 = _interopRequireDefault(_DecoderXMLStream);

var _package = require('../package.json');

var _package2 = _interopRequireDefault(_package);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var debugMe = (0, _debug2.default)(_package2.default.name);
var MAX_BYTES_TO_READ = 100;

function readOrCopyBytes(xmlData, bytes, ready) {
  if (Buffer.isBuffer(xmlData)) {
    ready(null, xmlData.slice(0, bytes));
  } else {
    readXMLBytes(xmlData, bytes, ready);
  }
}

function readXMLBytes(path, bytes, ready) {
  var xmlFileStream = _fs2.default.createReadStream(path, { start: 0, end: bytes });

  var concatStream = (0, _concatStream2.default)(function (buf) {
    ready(null, buf);
  });

  xmlFileStream.on('error', function (err) {
    debugMe('error trying to read file', path);
    ready(err);
  });

  xmlFileStream.pipe(concatStream);
}

function decodeXML(content, encoding, cb) {
  if (!_iconvLite2.default.encodingExists(encoding)) {
    return cb(new Error(encoding + ' is not supported'));
  }

  (function (next) {
    if (Buffer.isBuffer(content)) {
      next(null, content);
    } else {
      _fs2.default.readFile(content, function (readFileErr, xmlBuf) {
        if (readFileErr) {
          return next(readFileErr);
        }

        next(null, xmlBuf);
      });
    }
  })(function (err, buf) {
    if (err) {
      return cb(err);
    }

    debugMe('decoding xml content (' + encoding + ')..');

    cb(null, {
      encoding: encoding,
      content: _iconvLite2.default.decode(buf, encoding)
    });
  });
}

function readXML(content, cb) {
  var done = (0, _once2.default)(function (err, data) {
    return cb(err, data);
  });
  var readCount = 1,
      bufLength = void 0;

  function readBufferHandler(err, encoding) {
    var hasMoreContent = false,
        maxBytes = MAX_BYTES_TO_READ * readCount;

    if (err) {
      return done(err);
    }

    if (bufLength > maxBytes) {
      hasMoreContent = true;
    }

    if (encoding == null) {
      if (!hasMoreContent) {
        return decodeXML(content, _defaultEncoding2.default, done);
      }

      // eslint-disable-next-line no-plusplus
      readCount++;

      readOrCopyBytes(content, MAX_BYTES_TO_READ * readCount, function (readNextErr, nextContent) {
        if (readNextErr) {
          return done(readNextErr);
        }

        (0, _findEncoding2.default)(nextContent, _defaultEncoding2.default, readBufferHandler);
      });
    } else {
      decodeXML(content, encoding, done);
    }
  }

  if (Buffer.isBuffer(content)) {
    debugMe('trying to parse xml from buffer..');
    bufLength = content.length;

    (0, _findEncoding2.default)(content.slice(0, MAX_BYTES_TO_READ), _defaultEncoding2.default, readBufferHandler);
  } else {
    debugMe('trying to parse xml from file', content);

    _fs2.default.stat(content, function (statErr, stats) {
      if (statErr) {
        return done(statErr);
      }

      // getting the bytes size of file
      bufLength = stats.size;

      readXMLBytes(content, MAX_BYTES_TO_READ, function (readXMLErr, xmlBuf) {
        if (readXMLErr) {
          return done(readXMLErr);
        }

        (0, _findEncoding2.default)(xmlBuf, _defaultEncoding2.default, readBufferHandler);
      });
    });
  }
}

function createStream(streamOpts) {
  return new _DecoderXMLStream2.default(streamOpts);
}