index.js

import rConstants from "r-constants";
import byline from "byline";
import fs from "node:fs";
import {fileTypeStream} from 'file-type';
import tar from "tar-stream";
import zlib from "node:zlib";
import unzip from "unzipper";
import stream from "node:stream";

const deps = rConstants.dependency_types;

function normalize_ws(x) {
  return x.trim().replace(/\s/g, " ");
}

export function parse_desc_stream(descstream) {
  return new Promise((resolve, reject) => {
    var lines = byline(descstream, { keepEmptyLines: true });
    var desc = {};
    var current = "";
    var first = true;

    lines.setEncoding("utf8");

    function reader(line) {
      // First line is special
      if (first) {
        current = line;
        first = false;

        // Starts with space, same record, append
      } else if(line.startsWith("#")){
        // comment
      } else if (line.match(/^\s/)) {
        current = current + "\n" + line.trim();

        // New record, need to emit the previous one
      } else {
        var rec = split_record(current);
        if (rec.key === "") {
          // No way to close a stream, we just remove the listeners
          // if an error happens
          lines.removeListener("data", reader);
          lines.removeListener("end", finisher);
          return reject(new Error("Invalid record: " + rec.value));
        }
        if (deps.indexOf(rec.key) > -1) {
          rec.value = parse_dep_string(rec.value);
        }
        if (rec.key == "Remotes") {
          rec.value = parse_remotes(rec.value);
        }
        if (rec.key == "Built") {
          rec.value = parse_built(rec.value);
        }
        if (rec.key == "Packaged") {
          rec.value = parse_packaged(rec.value);
        }
        desc[rec.key] = rec.value;
        current = line;
      }
    }

    function finisher() {
      resolve(desc);
    }

    lines.on("data", reader);
    lines.on("end", finisher);
  });
}

export function parse_dep_string(str) {
  return str
    .split(/,[\s]*/s)
    .filter(function (str) {
      return str.trim(); //filter out empty strings
    })
    .map(function (str) {
      return str.match(/\(.+\)/s)
        ? {
            package: normalize_ws(str.replace(/\(.+\)/s, "")),
            version: normalize_ws(str.replace(/.*\((.+)\)/s, "$1")),
          }
        : {
            package: normalize_ws(str),
          };
    });
}

function parse_remotes(str) {
  return str.split(/,[\s]*/);
}

function parse_built(str) {
  var built = str.split(/;[\s]*/);
  return {
    R: built[0].replace(/^R /, ""),
    Platform: built[1],
    Date: built[2],
    OStype: built[3],
  };
}

function parse_packaged(str) {
  var packaged = str.split(/;[\s]*/);
  return {
    Date: packaged[0],
    User: packaged[1],
  };
}

function split_record(str) {
  var colon = str.indexOf(":");
  return {
    key: str.substr(0, colon).trim(),
    value: str.substr(colon + 1).trim(),
  };
}

export function parse_desc_file(path) {
  var descstream = fs.createReadStream(path);
  return parse_desc_stream(descstream);
}

function parse_raw_tar_stream(input) {
  return new Promise((resolve, reject) => {
    var extract = tar.extract();
    var done = false;

    extract.on("entry", function (header, tarstream, tarcb) {
      tarstream.on("end", tarcb);
      tarstream.on("error", function (err) {
        done = true;
        reject(err);
      });
      if (!done && header.name.match(/^[^\/]+\/DESCRIPTION$/)) {
        done = true;
        parse_desc_stream(tarstream).then(resolve).catch(reject);
      } else {
        tarstream.resume();
      }
    });

    input.on("error", reject);
    extract.on("error", reject);

    extract.on("finish", function () {
      if (!done) {
        reject(new Error("No DESCRIPTION file in tar archive"));
      }
    });

    input.pipe(extract);
  });
}

function parse_zip_stream(input) {
  return new Promise((resolve, reject) => {
    var done = false;
    var extract = input.pipe(unzip.Parse());
    extract.on("entry", function (entry) {
      const fileName = entry.path;
      if (fileName.match(/^[^\/]+\/DESCRIPTION$/)) {
        done = true;
        parse_desc_stream(entry).then(resolve).catch(reject);
      } else {
        entry.autodrain();
      }
    });

    input.on("error", reject);
    extract.on("error", reject);

    extract.on("finish", function () {
      if (!done) {
        reject(new Error("No DESCRIPTION file in zip file"));
      }
    });
  });
}

export function parse_stream(descstream) {
  return fileTypeStream(descstream).then(function (x) {
    // For no type it is assumed a plain text file
    if (x.fileType === undefined) {
      return parse_desc_stream(x);
    }

    // The type of file
    var mime = x.fileType.mime;

    // .zip file
    if (mime === "application/zip") {
      return parse_zip_stream(x);
    }

    // .tar.gz file
    if (mime === "application/gzip") {
      return parse_raw_tar_stream(x.pipe(zlib.createGunzip()));
    }

    if (mime === "application/zstd") {
      return parse_raw_tar_stream(x.pipe(zlib.createZstdDecompress()));
    }

    // Default is assuming no compression
    return parse_raw_tar_stream(x);
  });
}

export function parse_file(path) {
  var descstream = fs.createReadStream(path);
  return parse_stream(descstream);
}