.reinit

#!/usr/bin/env node

// tslint:disable: tsr-detect-non-literal-fs-filename no-var-requires tsr-detect-child-process
const fs = require("fs");
const path = require("path");
const readline = require("readline");

const cp = require("child_process");
const pkgFname = "package.json";
const pkgJson = JSON.parse(fs.readFileSync(pkgFname, "utf8"));

const resetPackageJsonPreInstall = (ctx) => {
  const pkg = JSON.parse(fs.readFileSync(pkgFname, "utf8"));
  const origname = pkg.name;
  delete pkg.scripts.preinstall;
  pkg.name = `@${ctx.org}/${ctx.app}`;
  pkg.description = "";
  pkg.version = "0.0.1";
  pkg.keywords = [];
  pkg.repository = {
    type: "git",
    url: `git+https://github.com/${ctx.org}/${ctx.app}.git`,
  };
  pkg.homepage = `https://github.com/${ctx.org}/${ctx.app}#readme`;
  pkg.bugs = {
    url: `https://github.com/${ctx.org}/${ctx.app}/issues`,
  };
  // remove scripts from distributed files
  pkg.files = [
    "dist",
    "docs",
  ];
  fs.writeFileSync(pkgFname, JSON.stringify(pkg, null, 2), "utf8");
  return {
    ...ctx,
    origname,
  };
};

const resetPackageJsonPostInstall = () => {
  const pkg = JSON.parse(fs.readFileSync(pkgFname, "utf8"));
  delete pkg.scripts.postinstall;
  fs.writeFileSync(pkgFname, JSON.stringify(pkg, null, 2), "utf8");
  return pkg;
};

// Since this is a pre-install configuration script, meant to be run
// one-time, it's not right to install dependencies into target repo.
// We have simple local implementations of needed functionality.
// This file self-deletes after successful execution.

function sed(fname, match_re, replacement) {
  const content = fs.readFileSync(fname, "utf8");
  fs.writeFileSync(fname, content.replace(match_re, replacement), "utf8");
}

function rimraf(dir) {
  if (dir === "/") { return; }
  if (fs.existsSync(dir)) {
    fs.readdirSync(dir).forEach((file, index) => {
      const curdir = path.join(dir, file);
      if (fs.lstatSync(curdir).isDirectory()) { // recurse
        rimraf(curdir);
      } else { // delete file
        fs.unlinkSync(curdir);
      }
    });
    fs.rmdirSync(dir);
  }
}

function spawn(_cmd, args, opts) {
  opts = opts || {
    cwd: process.cwd(),
    stdio: "inherit",
  };
  // tslint:disable-next-line: no-console
  console.log([_cmd].concat(args).join(" "));
  return new Promise((resolve, reject) => {
    const proc = cp.spawn(_cmd, args, opts);
    proc.on("close", (code) => {
      code ? reject(code) : resolve();
    });
  });
}

const isSourceRepo = path.basename(__dirname) === pkgJson.name.split("/").pop();

const [exe, script, cmd, ...rest] = process.argv;
// tslint:disable-next-line: no-use-before-declare
if (require.main !== module) {
  // this file is being included as a library
  // export the utility functions defined within
  module.exports = {
    resetPackageJsonPostInstall,
    resetPackageJsonPreInstall,
    rimraf,
    sed,
    spawn,
  };
} else if (!isSourceRepo && cmd === "preinstall") {
  // this is the purpose
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
  });

  // defaults
  const result = {
    app: `@tufan-io/${path.basename(process.cwd())}`,
    org: "tufan-io",
  };

  // tslint:disable: no-shadowed-variable
  return new Promise((resolve, reject) => {
    // Q1 ----
    rl.question(`Git organization (${result.org}): `, (answer1) => {
      result.org = answer1 || result.org;
      // Q2 ----
      rl.question(`Name of the project (@${result.org}/${result.app.replace(/.*\//, "")}): `, (answer2) => {
        result.app = answer2 || `@${result.org}/${result.app.replace(/.*\//, "")}`;
        return resolve(result);
      });
    });
  }).then((result) => {
    result.app = result.app.replace(/.*\//, "");
    const ctx = resetPackageJsonPreInstall(result);
    fs.writeFileSync("./.reinit-lock", JSON.stringify(ctx), "utf8");
    // reset changelog.md
    fs.writeFileSync("CHANGELOG.md", "", "utf8");
    sed("./README.md", /tufan-io/g, result.org);
    sed("./README.md", /action-starter/g, result.app);
    sed("./action.yml", /action-starter/g, result.app);
    sed("./src/index.ts", /action-starter/g, result.app);
    return result;
  }).then((result) => {
    // delete old git repo and initialize a new one.
    rimraf(path.join(process.cwd(), ".git"));
    return result;
  }).then((result) => {
    // initialize new git repo
    return spawn("git", ["init"]).then(() => result);
  }).then((result) => {
    return spawn("git", ["add", "."]).then(() => result);
  }).then((result) => {
    process.exit(0);
  }).catch((err) => {
    // tslint:disable: no-console
    console.error(err);
    process.exit(-1);
  });
} else if (isSourceRepo && cmd === "postinstall") {
  // need to split pre and post install here.
  return Promise.resolve().then(() => {
    try {
      const raw = fs.readFileSync("./.reinit-lock", "utf8");
      const ctx = JSON.parse(raw);
    } catch (err) {
      // invoking post install on unmodified starter module
      const raw = fs.readFileSync("./package.json", "utf8");
      const pkg = JSON.parse(raw);
      if (pkg.name.match(/starter/)) {
        throw new Error(`This is a starter repo. Ignore`);
      } else {
        throw new Error(`Invoked '.reinit postinstall' without a './.reinit-lock' present.`);
      }
    }
  }).then(() => {
    const pkg = resetPackageJsonPostInstall();
    fs.unlinkSync(".reinit");
    fs.unlinkSync(".reinit-lock");
    return pkg;
  }).then((pkg) => {
    return spawn(`npm`, [`run`, `build`]).then(() => pkg);
  }).then((pkg) => {
    return spawn(`git`, [`add`, `.`, `--all`]).then(() => pkg);
  }).then((pkg) => {
    return spawn(`git`, [
      `remote`,
      `add`,
      `origin`,
      pkg.repository.url,
    ]).then(() => pkg);
  }).then((pkg) => {
    console.log(``);
    console.log(`TODO: configure git username and email before committing`);
    console.log(``);
    console.log(`    git config user.name \"John Doe\"`);
    console.log(`    git config user.email john@doe.com`);
    console.log(``);
    console.log(`---`);
    console.log(`The repo has been properly re-initialized.`);
    console.log(`Go forth and make a brave new npm package...`);
    console.log(`---`);
    process.exit(0);
  }).catch((err) => {
    if (err.message.match(/This is a starter repo. Ignore/)) {
      process.exit(0);
    } else {
      console.error(err);
      process.exit(-1);
    }
  });
} else if (!isSourceRepo) {
  console.error(`Usage: .reinit <preinstall|postinstall>.\n Missing required argument`);
}