@diplodoc/cli 4.13.4 → 4.13.6

package/build/index.js

@@ -56,7 +56,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve18, reject) => {
+  return new Promise((resolve19, reject) => {
     var fulfilled = (value) => {
       try {
         step(generator.next(value));
@@ -71,7 +71,7 @@ var __async = (__this, __arguments, generator) => {
         reject(e);
       }
     };
-    var step = (x) => x.done ? resolve18(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    var step = (x) => x.done ? resolve19(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
@@ -1373,33 +1373,33 @@ var UnarchiveIncluderError = class extends Error {
 };
 function pipeline(readPath, writeBasePath) {
   return new Promise((res, rej) => {
-    const reader3 = (0, import_fs2.createReadStream)(readPath);
-    reader3.on("error", (err) => {
+    const reader = (0, import_fs2.createReadStream)(readPath);
+    reader.on("error", (err) => {
       rej(err);
     });
-    const extractor2 = (0, import_tar_stream.extract)();
-    extractor2.on("error", (err) => {
+    const extractor = (0, import_tar_stream.extract)();
+    extractor.on("error", (err) => {
       rej(err);
     });
     (0, import_fs2.mkdirSync)(writeBasePath, { recursive: true });
-    extractor2.on("entry", (header, stream, next) => {
+    extractor.on("entry", (header, stream, next) => {
       const { type, name: name4 } = header;
       const writePath = (0, import_path12.join)(writeBasePath, name4);
       const writeDirPath = type === "directory" ? writePath : (0, import_path12.dirname)(writePath);
       (0, import_fs2.mkdirSync)(writeDirPath, { recursive: true });
       if (type !== "directory") {
-        const writer3 = (0, import_fs2.createWriteStream)(writePath, { flags: "w" });
-        writer3.on("error", (err) => {
+        const writer = (0, import_fs2.createWriteStream)(writePath, { flags: "w" });
+        writer.on("error", (err) => {
           rej(err);
         });
-        stream.pipe(writer3);
+        stream.pipe(writer);
       }
       stream.on("end", () => {
         next();
       });
       stream.resume();
     });
-    reader3.pipe(extractor2).on("finish", () => {
+    reader.pipe(extractor).on("finish", () => {
       res();
     });
   });
@@ -3641,8 +3641,10 @@ function handler2(args) {
 }
 
 // src/cmd/xliff/extract.ts
+var import_assert = require("assert");
+var import_glob4 = __toESM(require("glob"));
 var import_path30 = require("path");
-var import_markdown_translation = __toESM(require("@diplodoc/markdown-translation"));
+var import_markdown_translation = require("@diplodoc/markdown-translation");
 var import_async3 = require("async");
 var {
   promises: { readFile: readFile3, writeFile: writeFile2, mkdir: mkdir2 }
@@ -3650,19 +3652,7 @@ var {
 var command2 = "extract";
 var description2 = "extract xliff and skeleton from yfm documentation";
 var extract2 = { command: command2, description: description2, handler: handler3, builder: builder3 };
-var MD_GLOB2 = "**/*.md";
 var MAX_CONCURRENCY = 50;
-var ExtractError = class extends Error {
-  constructor(message, path) {
-    super(message);
-    this.path = path;
-  }
-};
-var USAGE = `yfm xliff extract --input <folder-with-markdown> --output <folder-to-store-xlff-and-skeleton> --sll <source-language>-<source-locale> --tll <target-language>-<target-locale>
-
-where <source/target-language> is the language code, as described in ISO 639-1.
-
-where <source/target-locale> is the locale code in alpha-2 format, as described in ISO 3166-1`;
 function builder3(argv) {
   return argv.option("source-language-locale", {
     alias: "sll",
@@ -3680,130 +3670,96 @@ function builder3(argv) {
     alias: "o",
     describe: "output folder to store xliff and skeleton files",
     type: "string"
-  }).demandOption(
-    ["source-language-locale", "target-language-locale", "input", "output"],
-    USAGE
-  );
+  }).check(argvValidator);
 }
 function handler3(args) {
   return __async(this, null, function* () {
+    args = Object.assign({}, args.translate || {}, args);
+    delete args.translate;
     argv_default.init(__spreadValues({}, args));
-    const { input, output, sourceLanguageLocale, targetLanguageLocale } = args;
-    let source;
-    let target;
-    try {
-      source = parseLanguageLocale(sourceLanguageLocale);
-      target = parseLanguageLocale(targetLanguageLocale);
-    } catch (err) {
-      if (err instanceof Error) {
-        logger.error(input, err.message);
-      }
-    }
-    let cache = {};
-    let found = [];
-    try {
-      ({
-        state: { found, cache }
-      } = yield glob((0, import_path30.join)(input, MD_GLOB2), {
-        nosort: true,
-        cache
-      }));
-    } catch (err) {
-      if (err instanceof Error) {
-        logger.error(input, err.message);
-      }
-    }
-    const pipelineParameters = { source, target, input, output };
-    const configuredPipeline = pipeline2(pipelineParameters);
-    try {
-      logger.info(input, "starting xliff and skeleton generation pipeline");
-      yield (0, import_async3.eachLimit)(found, MAX_CONCURRENCY, (0, import_async3.asyncify)(configuredPipeline));
-      logger.info(input, "finished xliff and skeleton generation pipeline");
-    } catch (err) {
-      if (err instanceof Error || err instanceof ExtractError) {
-        const file = err instanceof ExtractError ? err.path : input;
-        logger.error(file, err.message);
-      }
+    const {
+      output,
+      exclude = [],
+      sourceLanguage,
+      sourceLocale,
+      targetLanguage,
+      targetLocale
+    } = argv_default.getConfig();
+    let {
+      input,
+      include = [],
+      sourceLanguageLocale,
+      targetLanguageLocale
+    } = argv_default.getConfig();
+    (0, import_assert.ok)(input);
+    (0, import_assert.ok)(output);
+    (0, import_assert.ok)(
+      sourceLanguageLocale || sourceLanguage && sourceLocale,
+      "Source language and locale should be configured"
+    );
+    (0, import_assert.ok)(
+      targetLanguageLocale || targetLanguage && targetLocale,
+      "Source language and locale should be configured"
+    );
+    sourceLanguageLocale = sourceLanguageLocale || sourceLanguage + "-" + sourceLocale;
+    targetLanguageLocale = targetLanguageLocale || targetLanguage + "-" + targetLocale;
+    const source = parseLanguageLocale(sourceLanguageLocale);
+    const target = parseLanguageLocale(targetLanguageLocale);
+    if (input.endsWith(".md")) {
+      include = [(0, import_path30.basename)(input)];
+      input = (0, import_path30.dirname)(input);
+    } else if (!include.length) {
+      include.push("**/*");
     }
+    const files = [].concat(
+      ...include.map(
+        (match) => import_glob4.default.sync(match, {
+          cwd: (0, import_path30.join)(input, source.language),
+          ignore: exclude
+        })
+      )
+    );
+    const found = [...new Set(files)];
+    const configuredPipeline = pipeline2({ source, target, input, output });
+    yield (0, import_async3.eachLimit)(found, MAX_CONCURRENCY, (0, import_async3.asyncify)(configuredPipeline));
   });
 }
 function parseLanguageLocale(languageLocale) {
   const [language, locale] = languageLocale.split("-");
-  if ((language == null ? void 0 : language.length) && (locale == null ? void 0 : locale.length)) {
-    return { language, locale };
+  if (!(language == null ? void 0 : language.length) || !(locale == null ? void 0 : locale.length)) {
+    throw new Error("invalid language-locale string");
   }
-  throw new Error("invalid language-locale string");
+  return { language, locale };
 }
 function pipeline2(params) {
   const { input, output, source, target } = params;
-  return (markdownPath) => __async(this, null, function* () {
-    const markdown = yield reader({ path: markdownPath });
-    const extension = (0, import_path30.extname)(markdownPath);
-    const outputRelativePath = markdownPath.replace(extension, "").slice(input.length);
-    const outputPath = (0, import_path30.join)(output, outputRelativePath);
-    const xlfPath = outputPath + ".xliff";
-    const skeletonPath = outputPath + ".skl.md";
-    const extractParameters = {
-      markdownPath,
+  const inputRoot = (0, import_path30.resolve)(input, source.language);
+  const outputRoot = (0, import_path30.resolve)(output, target.language);
+  return (path) => __async(this, null, function* () {
+    if (!path.endsWith(".md")) {
+      return;
+    }
+    const inputPath = (0, import_path30.join)(inputRoot, path);
+    const xliffPath = (0, import_path30.join)(outputRoot, path + ".xliff");
+    const skeletonPath = (0, import_path30.join)(outputRoot, path + ".skl");
+    const markdown = yield readFile3(inputPath, "utf-8");
+    yield mkdir2((0, import_path30.dirname)(xliffPath), { recursive: true });
+    const { xliff: xliff2, skeleton } = yield (0, import_markdown_translation.extract)({
+      markdownPath: path,
       skeletonPath,
       markdown,
       source,
       target
-    };
-    const extracted = yield extractor(extractParameters);
-    const writerParameters = __spreadProps(__spreadValues({}, extracted), {
-      xlfPath,
-      skeletonPath
     });
-    yield writer(writerParameters);
-  });
-}
-function reader(params) {
-  return __async(this, null, function* () {
-    const { path } = params;
-    let markdown;
-    try {
-      logger.info(path, "reading markdown file");
-      markdown = yield readFile3(path, { encoding: "utf-8" });
-      logger.info(path, "finished reading markdown file");
-    } catch (err) {
-      if (err instanceof Error) {
-        throw new ExtractError(err.message, path);
-      }
-    }
-    return markdown;
-  });
-}
-function extractor(params) {
-  return __async(this, null, function* () {
-    let extracted;
-    logger.info(params.markdownPath, "generating skeleton and xliff from markdown");
-    try {
-      extracted = import_markdown_translation.default.extract(params);
-    } catch (err) {
-      if (err instanceof Error) {
-        throw new ExtractError(err.message, params.markdownPath);
-      }
-    }
-    logger.info(params.markdownPath, "finished generating skeleton and xliff from markdown");
-    return extracted;
-  });
-}
-function writer(params) {
-  return __async(this, null, function* () {
-    const { xlfPath, skeletonPath, xlf, skeleton } = params;
-    logger.info(params.xlfPath, "writing xliff file");
-    logger.info(params.skeletonPath, "writing skeleton file");
-    yield mkdir2((0, import_path30.dirname)(xlfPath), { recursive: true });
-    yield Promise.all([writeFile2(skeletonPath, skeleton), writeFile2(xlfPath, xlf)]);
-    logger.info(params.xlfPath, "finished writing xliff file");
-    logger.info(params.skeletonPath, "finished writing skeleton file");
+    yield Promise.all([writeFile2(skeletonPath, skeleton), writeFile2(xliffPath, xliff2)]);
   });
 }
 
 // src/cmd/xliff/compose.ts
+var import_assert2 = require("assert");
+var import_glob5 = __toESM(require("glob"));
 var import_path31 = require("path");
-var import_markdown_translation2 = __toESM(require("@diplodoc/markdown-translation"));
+var import_markdown_translation2 = require("@diplodoc/markdown-translation");
 var import_async4 = require("async");
 var {
   promises: { readFile: readFile4, writeFile: writeFile3, mkdir: mkdir3 }
@@ -3811,16 +3767,7 @@ var {
 var command3 = "compose";
 var description3 = "compose xliff and skeleton into documentation";
 var compose = { command: command3, description: description3, handler: handler4, builder: builder4 };
-var SKL_MD_GLOB = "**/*.skl.md";
-var XLF_GLOB = "**/*.xliff";
 var MAX_CONCURRENCY2 = 50;
-var ComposeError = class extends Error {
-  constructor(message, path) {
-    super(message);
-    this.path = path;
-  }
-};
-var USAGE2 = "yfm xliff compose --input <folder-with-xliff-and-skeleton> --ouput <folder-to-store-translated-markdown>";
 function builder4(argv) {
   return argv.option("input", {
     alias: "i",
@@ -3830,130 +3777,63 @@ function builder4(argv) {
     alias: "o",
     describe: "output folder where translated markdown will be stored",
     type: "string"
-  }).demandOption(["input", "output"], USAGE2);
+  }).option("target-language", {
+    alias: "tl",
+    describe: "target language",
+    type: "string"
+  }).option("use-source", {
+    describe: "for debug",
+    type: "boolean"
+  }).check(argvValidator);
 }
 function handler4(args) {
   return __async(this, null, function* () {
+    args = Object.assign({}, args.translate || {}, args);
+    delete args.translate;
     argv_default.init(__spreadValues({}, args));
-    const { input, output } = args;
-    let cache = {};
-    let skeletonPaths = [];
-    let xliffPaths = [];
-    try {
-      ({
-        state: { found: skeletonPaths, cache }
-      } = yield glob((0, import_path31.join)(input, SKL_MD_GLOB), {
-        nosort: false,
-        cache
-      }));
-      ({
-        state: { found: xliffPaths, cache }
-      } = yield glob((0, import_path31.join)(input, XLF_GLOB), {
-        nosort: false,
-        cache
-      }));
-      if (xliffPaths.length !== skeletonPaths.length) {
-        throw new ComposeError("number of xliff and skeleton files does'not match", input);
-      }
-    } catch (err) {
-      if (err instanceof Error || err instanceof ComposeError) {
-        const file = err instanceof ComposeError ? err.path : input;
-        logger.error(file, err.message);
-      }
-    }
-    const pipelineParameters = { input, output };
+    const {
+      input,
+      output,
+      exclude = [],
+      targetLanguage,
+      useSource = false
+    } = argv_default.getConfig();
+    (0, import_assert2.ok)(input);
+    (0, import_assert2.ok)(output);
+    (0, import_assert2.ok)(targetLanguage);
+    const skeletons = import_glob5.default.sync("**/*.skl", {
+      cwd: (0, import_path31.join)(input, targetLanguage),
+      ignore: exclude
+    });
+    const xliffs = import_glob5.default.sync("**/*.xliff", {
+      cwd: (0, import_path31.join)(input, targetLanguage),
+      ignore: exclude
+    });
+    (0, import_assert2.ok)(xliffs.length === skeletons.length, "Inconsistent number of xliff and skeleton files.");
+    const pipelineParameters = { input, output, targetLanguage, useSource };
     const configuredPipeline = pipeline3(pipelineParameters);
-    try {
-      logger.info(input, "staring translated markdown composition pipeline");
-      yield (0, import_async4.eachLimit)(xliffPaths, MAX_CONCURRENCY2, configuredPipeline);
-      logger.info(input, "finished translated markdown composition pipeline");
-    } catch (err) {
-      if (err instanceof Error || err instanceof ComposeError) {
-        const file = err instanceof ComposeError ? err.path : input;
-        logger.error(file, err.message);
-      }
-    }
+    yield (0, import_async4.eachLimit)(skeletons, MAX_CONCURRENCY2, configuredPipeline);
   });
 }
 function pipeline3(params) {
-  const { input, output } = params;
-  return (xliffPath) => __async(this, null, function* () {
-    const extension = (0, import_path31.extname)(xliffPath);
-    const extensionLessPath = xliffPath.replace(extension, "");
-    const skeletonPath = extensionLessPath + ".skl.md";
-    const readerParameters = { xliffPath, skeletonPath };
-    const read = yield reader2(readerParameters);
-    const composerParameters = __spreadProps(__spreadValues({}, read), {
+  const { input, output, targetLanguage, useSource } = params;
+  return (skeletonPath) => __async(this, null, function* () {
+    const fileName = skeletonPath.split(".").slice(0, -1).join(".");
+    const xliffPath = fileName + ".xliff";
+    const [skeleton, xliff2] = yield Promise.all([
+      readFile4((0, import_path31.join)(input, targetLanguage, skeletonPath), "utf-8"),
+      readFile4((0, import_path31.join)(input, targetLanguage, xliffPath), "utf-8")
+    ]);
+    const markdown = (0, import_markdown_translation2.compose)({
+      skeleton,
+      xliff: xliff2,
       skeletonPath,
-      xliffPath
+      xliffPath,
+      useSource
     });
-    const { markdown } = yield composer(composerParameters);
-    const inputRelativePath = extensionLessPath.slice(input.length);
-    const markdownPath = (0, import_path31.join)(output, inputRelativePath) + ".md";
-    const writerParameters = {
-      markdown,
-      markdownPath
-    };
-    yield writer2(writerParameters);
-  });
-}
-function reader2(params) {
-  return __async(this, null, function* () {
-    const { skeletonPath, xliffPath } = params;
-    let skeleton;
-    let xlf;
-    try {
-      logger.info(skeletonPath, "reading skeleton file");
-      skeleton = yield readFile4(skeletonPath, { encoding: "utf-8" });
-      logger.info(skeletonPath, "finished reading skeleton file");
-    } catch (err) {
-      if (err instanceof Error) {
-        throw new ComposeError(err.message, skeletonPath);
-      }
-    }
-    try {
-      logger.info(xliffPath, "reading xliff file");
-      xlf = yield readFile4(xliffPath, { encoding: "utf-8" });
-      logger.info(xliffPath, "finished reading xliff file");
-    } catch (err) {
-      if (err instanceof Error) {
-        throw new ComposeError(err.message, xliffPath);
-      }
-    }
-    return { skeleton, xlf };
-  });
-}
-function composer(params) {
-  return __async(this, null, function* () {
-    const { skeletonPath, xliffPath } = params;
-    let markdown;
-    try {
-      logger.info(skeletonPath, "composing markdown from xliff and skeleton");
-      logger.info(xliffPath, "composing markdown from xliff and skeleton");
-      markdown = import_markdown_translation2.default.compose(params);
-      logger.info(skeletonPath, "finished composing markdown from xliff and skeleton");
-      logger.info(xliffPath, "finished composing markdown from xliff and skeleton");
-    } catch (err) {
-      if (err instanceof Error) {
-        throw new ComposeError(err.message, `${xliffPath} ${skeletonPath}`);
-      }
-    }
-    return { markdown };
-  });
-}
-function writer2(params) {
-  return __async(this, null, function* () {
-    const { markdown, markdownPath } = params;
-    try {
-      logger.info(markdownPath, "writing markdown file");
-      yield mkdir3((0, import_path31.dirname)(markdownPath), { recursive: true });
-      yield writeFile3(markdownPath, markdown);
-      logger.info(markdownPath, "finished writing markdown file");
-    } catch (err) {
-      if (err instanceof Error) {
-        throw new ComposeError(err.message, markdownPath);
-      }
-    }
+    const markdownPath = (0, import_path31.join)(output, targetLanguage, fileName);
+    yield mkdir3((0, import_path31.dirname)(markdownPath), { recursive: true });
+    yield writeFile3(markdownPath, markdown);
   });
 }
 
@@ -3974,16 +3854,10 @@ function builder5(argv) {
   );
 }
 
-// src/cmd/translate/index.ts
-var import_glob4 = __toESM(require("glob"));
-var import_assert = require("assert");
-var import_async5 = require("async");
+// src/cmd/translate/handler.ts
+var import_assert3 = require("assert");
 var import_path33 = require("path");
-var import_promises4 = require("fs/promises");
-var import_session = require("@yandex-cloud/nodejs-sdk/dist/session");
-var import_service_clients = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/service_clients");
-var import_translation_service = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/ai/translate/v2/translation_service");
-var import_markdown_translation3 = require("@diplodoc/markdown-translation");
+var import_glob6 = __toESM(require("glob"));
 
 // src/packages/credentials/yandex-oauth.ts
 var import_promises3 = require("fs/promises");
@@ -4016,32 +3890,16 @@ function getYandexOAuthTokenFromHomeDir() {
   });
 }
 
-// src/cmd/translate/index.ts
-var command5 = "translate";
-var description5 = "translate documentation with Yandex.Cloud Translator API";
-var translate = {
-  command: command5,
-  description: description5,
-  handler: handler5,
-  builder: builder6
-};
+// src/cmd/translate/handler.ts
+var import_async5 = require("async");
+var import_session = require("@yandex-cloud/nodejs-sdk/dist/session");
+var import_service_clients = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/service_clients");
+var import_translation_service = require("@yandex-cloud/nodejs-sdk/dist/generated/yandex/cloud/ai/translate/v2/translation_service");
+var import_promises4 = require("fs/promises");
+var import_markdown_translation3 = require("@diplodoc/markdown-translation");
 var REQUESTS_LIMIT = 20;
 var BYTES_LIMIT = 1e4;
 var RETRY_LIMIT = 3;
-function builder6(argv) {
-  return argv.option("folder-id", {
-    describe: "folder id",
-    type: "string"
-  }).option("source-language", {
-    alias: "sl",
-    describe: "source language code",
-    type: "string"
-  }).option("target-language", {
-    alias: "tl",
-    describe: "target language code",
-    type: "string"
-  }).check(argvValidator);
-}
 var TranslatorError = class extends Error {
   constructor(message, path) {
     super(message);
@@ -4064,9 +3922,9 @@ function handler5(args) {
       `translating documentation from ${sourceLanguage} to ${targetLanguage} language`
     );
     output = output || input;
-    (0, import_assert.ok)(input, "Required param input is not configured");
-    (0, import_assert.ok)(sourceLanguage, "Required param sourceLanguage is not configured");
-    (0, import_assert.ok)(targetLanguage, "Required param targetLanguage is not configured");
+    (0, import_assert3.ok)(input, "Required param input is not configured");
+    (0, import_assert3.ok)(sourceLanguage, "Required param sourceLanguage is not configured");
+    (0, import_assert3.ok)(targetLanguage, "Required param targetLanguage is not configured");
     try {
       if (input.endsWith(".md")) {
         include = [(0, import_path33.basename)(input)];
@@ -4076,7 +3934,7 @@ function handler5(args) {
       }
       const files = [].concat(
         ...include.map(
-          (match) => import_glob4.default.sync(match, {
+          (match) => import_glob6.default.sync(match, {
             cwd: (0, import_path33.join)(input, sourceLanguage),
             ignore: exclude
           })
@@ -4245,13 +4103,43 @@ function backoff(action) {
 }
 var Defer = class {
   constructor() {
-    this.promise = new Promise((resolve18, reject) => {
-      this.resolve = resolve18;
+    this.promise = new Promise((resolve19, reject) => {
+      this.resolve = resolve19;
       this.reject = reject;
     });
   }
 };
 
+// src/cmd/translate/index.ts
+var command5 = "translate";
+var description5 = "translate documentation with Yandex.Cloud Translator API";
+var translate = {
+  command: command5,
+  description: description5,
+  handler: handler5,
+  builder: builder6
+};
+function builder6(argv) {
+  return argv.command(extract2).command(compose).option("folder-id", {
+    describe: "folder id",
+    type: "string"
+  }).option("source-language", {
+    alias: "sl",
+    describe: "source language code",
+    type: "string"
+  }).option("target-language", {
+    alias: "tl",
+    describe: "target language code",
+    type: "string"
+  }).option("include", {
+    describe: "relative to input globs to include in processing",
+    type: "string"
+  }).option("exclude", {
+    describe: "relative to input globs to exclude from processing",
+    type: "string"
+  }).check(argvValidator);
+}
+
 // src/index.ts
 console.time(MAIN_TIMER_ID);
 import_yargs.default.command(build).command(publish).command(xliff).command(translate).option("config", {
@@ -4268,7 +4156,7 @@ import_yargs.default.command(build).command(publish).command(xliff).command(tran
   default: false,
   describe: "Run in quiet mode. Don't write logs to stdout",
   type: "boolean"
-}).group(["config", "strict", "quiet", "help", "version"], "Common options:").version(true ? "4.13.4" : "").help().parse((0, import_helpers.hideBin)(process.argv), {}, (err, { strict }, output) => {
+}).group(["config", "strict", "quiet", "help", "version"], "Common options:").version(true ? "4.13.6" : "").help().parse((0, import_helpers.hideBin)(process.argv), {}, (err, { strict }, output) => {
   console.timeEnd(MAIN_TIMER_ID);
   if (err) {
     console.error(err);