newznab-feedparser/lib/index.js

Parses newznab rss feeds into an array of objects

'use strict';

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

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

var _xml2json = require('xml2json');

var _xml2json2 = _interopRequireDefault(_xml2json);

var _bluebird = require('bluebird');

var _bluebird2 = _interopRequireDefault(_bluebird);

var _lodash = require('lodash');

var _lodash2 = _interopRequireDefault(_lodash);

var _requestPromise = require('request-promise');

var _requestPromise2 = _interopRequireDefault(_requestPromise);

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

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { return step("next", value); }, function (err) { return step("throw", err); }); } } return step("next"); }); }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var fs = _bluebird2.default.promisifyAll(require('fs'));

var customUnescape = function customUnescape(str) {
  var string = str.replace(/&#(\d+);/g, function (match, dec) {
    return unescape(String.fromCharCode(dec));
  });

  return _lodash2.default.unescape(string);
};

var parseNewznab = function () {
  function parseNewznab() {
    _classCallCheck(this, parseNewznab);
  }

  _createClass(parseNewznab, null, [{
    key: 'fromFeed',
    value: function () {
      var ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee(url) {
        var string;
        return regeneratorRuntime.wrap(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return (0, _requestPromise2.default)(url);

              case 2:
                string = _context.sent;
                _context.next = 5;
                return this.fromString(string);

              case 5:
                return _context.abrupt('return', _context.sent);

              case 6:
              case 'end':
                return _context.stop();
            }
          }
        }, _callee, this);
      }));

      return function fromFeed(_x) {
        return ref.apply(this, arguments);
      };
    }()
  }, {
    key: 'fromString',
    value: function () {
      var ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee2(string) {
        var json, nzbs, lastUpdated, feed;
        return regeneratorRuntime.wrap(function _callee2$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                json = JSON.parse(_xml2json2.default.toJson(string));
                nzbs = json.rss.channel.item.map(function (nzb) {
                  if ('pubDate' in nzb) nzb.pubDate = new Date(nzb.pubDate);

                  var newznab = {
                    'newznab:categories': []
                  };

                  nzb['newznab:attr'].forEach(function (attr) {
                    if (!isNaN(+attr.value)) attr.value = +attr.value;

                    if (attr.name === 'category') {
                      newznab['newznab:categories'].push(attr.value);
                    } else {
                      newznab['newznab:' + attr.name] = attr.value;
                    }
                  });

                  for (var k in nzb) {
                    if (typeof nzb[k] === 'string') {
                      nzb[k] = customUnescape(nzb[k]);
                    }
                  }

                  return _extends({}, nzb, newznab);
                });

                // get newest pubDate

                lastUpdated = json.rss.channel.item.reduce(function (prev, current, i) {
                  var d = json.rss.channel.item[i].pubDate;
                  var max = new Date(prev) > new Date(d) ? new Date(prev) : new Date(d);
                  return max;
                });
                feed = {
                  title: customUnescape(json.rss.channel.title),
                  description: customUnescape(json.rss.channel.description),
                  link: json.rss.channel.link,
                  language: json.rss.channel.language,
                  webMaster: customUnescape(json.rss.channel.webMaster),
                  lastUpdated: lastUpdated,
                  nzbs: nzbs
                };
                return _context2.abrupt('return', feed);

              case 5:
              case 'end':
                return _context2.stop();
            }
          }
        }, _callee2, this);
      }));

      return function fromString(_x2) {
        return ref.apply(this, arguments);
      };
    }()
  }, {
    key: 'fromFile',
    value: function () {
      var ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee3(path) {
        var string;
        return regeneratorRuntime.wrap(function _callee3$(_context3) {
          while (1) {
            switch (_context3.prev = _context3.next) {
              case 0:
                _context3.next = 2;
                return fs.readFileAsync(path);

              case 2:
                string = _context3.sent;
                _context3.next = 5;
                return this.fromString(string);

              case 5:
                return _context3.abrupt('return', _context3.sent);

              case 6:
              case 'end':
                return _context3.stop();
            }
          }
        }, _callee3, this);
      }));

      return function fromFile(_x3) {
        return ref.apply(this, arguments);
      };
    }()
  }]);

  return parseNewznab;
}();

exports.default = parseNewznab;