ng-translation-gen

#!/usr/bin/env node
'use strict';

const fs = require('fs');
const fse = require('fs-extra');
const path = require('path');
const ArgumentParser = require('argparse').ArgumentParser;

/**
 * JSON configuration file read by the generator (if present).
 */
const CONFIG = "ng-translation-gen.json";

/**
 * JSON Schema used to define the JSON configuration file.
 */
const SCHEMA = "ng-translation-gen-schema.json";

/**
 * Read the package configuration.
 */
const pkg = parseJSON(path.join(__dirname, "package.json"));

/**
 * Read the configuration schema.
 */
const schema = parseJSON(path.join(__dirname, SCHEMA));

/******************************************************************************/
/********************************* MAIN ***************************************/
/******************************************************************************/

var argParser = new ArgumentParser({
  version: pkg.version,
  addHelp: true,
  description: "Translation message accessors generator for Angular 2+ projects. " +
    "Either a file named " + CONFIG + " should exist in the current directory " +
    "or arguments can be specified. Also, a configuration file can be generated " +
    "with all default values if --gen-config is specified."
});
argParser.addArgument(
  ["-i", "--input"],
  {
    help: schema.properties.input.description,
    defaultValue: schema.properties.input.default,
    dest: "input",
  }
);
argParser.addArgument(
  ["-o", "--output"],
  {
    help: schema.properties.output.description,
    defaultValue: schema.properties.output.default,
    dest: "output"
  }
);
argParser.addArgument(
  ["-m", "--mapping"],
  {
    help: schema.properties.mapping.description,
    defaultValue: schema.properties.mapping.default,
    dest: "mapping"
  }
);
argParser.addArgument(
  ["--gen-config"],
  {
    help: "Generates the configuration file " + CONFIG +
      " in the current directory. No message accessor classes are generated." +
      " If input and output are specified, their values are stored in the" +
      " generated file as well.",
    action: "storeTrue",
    dest: "genConfig"
  }
);
argParser.addArgument(
  ["-w", "--watch"],
  {
    help: "Watches for changes in the input directory, re-generating files" +
      " when source translations change",
    action: "storeTrue",
    dest: "watch"
  }
);
argParser.addArgument(
  ["--merge"],
  {
    help: "Merges the translation files for additional locales, from the" +
      " source locale",
    action: "storeTrue",
    dest: "merge"
  }
);

var args = argParser.parseArgs();

// The mapping is specified as file1=Class1:file2=Class2:...
if (args.mapping) {
  var mapping = {};
  for (let part of args.mapping.split(':')) {
    let subparts = part.split('=');
    let name = subparts[0].trim();
    let value = (subparts[1] || '').trim();
    mapping[name] = value;
  }
  args.mapping = mapping;
}

// Check the action
var configExists = fse.existsSync(CONFIG);
if (args.genConfig) {
  if (configExists) {
    // Ask for confirmation
    askThenGenerateConfig();
  } else {
    // Write the configuration file
    generateConfig();
  }
} else {
  const config = parseJSON(CONFIG);
  if (args.merge) {
    // Merge translations
    merge(config);
  } else {
    // Main execution
    if (configExists) {
      // The configuration file exists, so read it
      run(config, args.watch);
    } else {
      // No configuration file. Show the usage and exit.
      argParser.parseArgs(["--help"]);
    }
  }
}

/******************************************************************************/
/*************************** Utility functions ********************************/
/******************************************************************************/

/**
 * Generates a configuration file in the current directory
 */
function generateConfig() {
  var options = {
    "$schema": "./node_modules/ng-translation-gen/ng-translation-gen-schema.json"
  };
  if (args.input) {
    options.input = args.input;
  }
  if (args.output) {
    options.output = args.output;
  }
  if (args.mapping) {
    options.mapping = args.mapping;
  }
  if (args.separator) {
    options.separator = args.separator;
  }
  setDefaults(options, schema);

  var json = JSON.stringify(options, null, 2);
  fse.writeFileSync(CONFIG, json, { encoding: "utf8" });
  console.info("Wrote configuration file " + CONFIG);
}

/**
 * Asks if the configuration file should be overridden, then, if so, do it
 */
function askThenGenerateConfig() {
  const readline = require('readline');
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });
  rl.question("The configuration file " + CONFIG + " already exists.\n" +
    "Do you want to override it? [y/N]", (answer) => {
      if (answer == 'y' || answer == 'Y') {
        generateConfig();
      }
      rl.close();
    });
}

/**
 * Sets the default options for those properties not set.
 */
function setDefaults(options, schema) {
  // apply the default values for those properties not defined
  var properties = schema.properties;
  for (var propName in properties) {
    var propDef = properties[propName];
    if (propDef.default && !options.hasOwnProperty(propName)) {
      options[propName] = propDef.default;
    }
  }
  if (!options.hasOwnProperty("mapping")) {
    options.mapping = {};
  }
}

function preprocess(options) {
  // sets the default values for those properties not set in the options
  setDefaults(options, schema);

  if (!fse.existsSync(options.input)) {
    console.log("Error: missing input folder: " + options.input);
    process.exit(1);
  }
}

/**
 * Runs the ng-translation-gen generation
 */
function run(options, watch) {
  preprocess(options);

  var ngTranslationGen = require("./ng-translation-gen.js");
  try {
    ngTranslationGen(options);
  } catch (e) {
    console.error("Error generating translations");
    console.dir(e);
    console.error(e.stack);
  }

  if (watch) {
    console.info("Watching " + options.input + " for changes");
    let fsWait = false;
    fs.watch(options.input, (_event, filename) => {
      if (filename) {
        if (fsWait) {
          return;
        }
        fsWait = setTimeout(() => {
          fsWait = false;
          try {
            ngTranslationGen(options);
          } catch (e) {
            console.error("Error generating translations");
            console.dir(e);
            console.error(e.stack);
          }
        }, 100);
      }
    });
  }
}

function merge(options) {
  preprocess(options);
  var mergeTranslations = require("./merge-translations.js");
  mergeTranslations(options);
}

function parseJSON(file) {
  return JSON.parse(fse.readFileSync(file, "utf8"));
}