@application-kit/acceptance 0.0.0-stage → 0.1.1

package/dist/esm/scenarios/run.js

@@ -0,0 +1,141 @@
+import { parseArgs } from 'node:util';
+import { classesCommand } from './classes.js';
+import { ConfigError, loadConfig } from './config.js';
+import { coverageCommand } from './coverage.js';
+import { localToday, periodOf } from './dates.js';
+import { inventoryCommand } from './inventory.js';
+import { linksCommand } from './links.js';
+import { lintCommand, removedCommand } from './lint.js';
+import { parseRevisions } from './projects.js';
+import { messageOf } from './python-text.js';
+import { formatReport } from './report.js';
+const usage = `usage: scenarios [--config <файл>] <команда>
+  lint [--list-json <файл>] [--unused-steps <файл>]
+  removed --base <ref>
+  links --projects <каталог> [--ref <проект>=<ref>]…
+  classes --projects <каталог> [--ref <проект>=<ref>]… [--list]
+  coverage --projects <каталог> [--ref <проект>=<ref>]… [--since <дата>] [--until <дата>]
+           [--out <файл.html>] [--json <файл.json>]
+  inventory --out <файл.json> [--story <файл>]…
+Коды возврата: 0 — дефектов нет; 1 — есть дефекты; 2 — ошибка вызова или конфига.
+`;
+const text = { type: 'string' };
+const defaultConfig = 'scenarios.config.json';
+const configPrefix = '--config=';
+const flagErrorCode = 'ERR_PARSE_ARGS';
+const projectOptions = { projects: text, ref: { multiple: true, type: 'string' } };
+const commandOptions = {
+    classes: { ...projectOptions, list: { type: 'boolean' } },
+    coverage: { ...projectOptions, json: text, out: text, since: text, until: text },
+    inventory: { out: text, story: { multiple: true, type: 'string' } },
+    links: projectOptions,
+    lint: { 'list-json': text, 'unused-steps': text },
+    removed: { base: text },
+};
+const requiredOptions = {
+    classes: ['projects'],
+    coverage: ['projects'],
+    inventory: ['out'],
+    links: ['projects'],
+    lint: [],
+    removed: ['base'],
+};
+class UsageError extends Error {
+    name = 'UsageError';
+}
+const optional = (values, name) => {
+    const value = values[name];
+    return typeof value === 'string' ? value : undefined;
+};
+const required = (values, name) => {
+    const value = optional(values, name);
+    if (value === undefined) {
+        throw new UsageError(`нужен --${name}`);
+    }
+    return value;
+};
+const projectInput = async (context, config, values) => {
+    const projects = required(values, 'projects');
+    const items = Array.isArray(values.ref) ? values.ref.map(String) : [];
+    const revisions = await parseRevisions(context.cwd, projects, items);
+    return { config, cwd: context.cwd, projects, revisions };
+};
+const coverage = async (context, config, values) => {
+    const today = localToday(context.now);
+    const period = periodOf({ since: optional(values, 'since'), today, until: optional(values, 'until') });
+    const input = await projectInput(context, config, values);
+    return coverageCommand(input, { json: optional(values, 'json'), out: optional(values, 'out'), period, today });
+};
+const handlers = {
+    classes: async (context, config, values) => {
+        const input = await projectInput(context, config, values);
+        return classesCommand(input, values.list === true);
+    },
+    coverage,
+    inventory: async (context, config, values) => inventoryCommand(context.cwd, config, {
+        out: required(values, 'out'),
+        stories: Array.isArray(values.story) ? values.story.map(String) : [],
+    }),
+    links: async (context, config, values) => linksCommand(config, await projectInput(context, config, values)),
+    lint: async (context, config, values) => lintCommand(context.cwd, config, {
+        listJson: optional(values, 'list-json'),
+        unusedSteps: optional(values, 'unused-steps'),
+    }),
+    removed: async (context, config, values) => removedCommand(context.cwd, config, required(values, 'base')),
+};
+const isCommand = (name) => Object.hasOwn(commandOptions, name);
+const inlineConfig = (first, argv) => {
+    const isInline = first?.startsWith(configPrefix) === true;
+    return isInline ? [first.slice(configPrefix.length), argv.slice(1)] : [defaultConfig, argv];
+};
+const splitGlobal = (argv) => {
+    const [first, second] = argv;
+    return first === '--config' && second !== undefined ? [second, argv.slice(2)] : inlineConfig(first, argv);
+};
+const commandOf = (name) => {
+    if (!isCommand(name)) {
+        throw new UsageError(name === '' ? 'нужна команда' : `команды «${name}» нет`);
+    }
+    return name;
+};
+const parseCommand = (argv) => {
+    const [configFile, rest] = splitGlobal(argv);
+    const [name = '', ...options] = rest;
+    const command = commandOf(name);
+    const parsed = parseArgs({ allowPositionals: false, args: options, options: commandOptions[command], strict: true });
+    const { values } = parsed;
+    const names = requiredOptions[command];
+    for (const option of names) {
+        required(values, option);
+    }
+    return { command, configFile, values };
+};
+const codeOf = (error) => String(Reflect.get(new Object(error), 'code'));
+const isUsageError = (error) => error instanceof UsageError || codeOf(error).startsWith(flagErrorCode);
+const failure = (error) => {
+    if (error instanceof ConfigError) {
+        return { code: 2, stderr: `ошибка: ${error.message}\n`, stdout: '' };
+    }
+    if (isUsageError(error)) {
+        return { code: 2, stderr: `${usage}ошибка вызова: ${messageOf(error)}\n`, stdout: '' };
+    }
+    throw error;
+};
+const isHelp = (argv) => argv.includes('--help') || argv.includes('-h');
+const execute = async (argv, context) => {
+    const { command, configFile, values } = parseCommand(argv);
+    const config = await loadConfig(configFile, context.cwd);
+    const report = await handlers[command](context, config, values);
+    return { code: report.defects.length > 0 ? 1 : 0, stderr: '', stdout: formatReport(report) };
+};
+export const runScenarios = async (argv, context) => {
+    if (isHelp(argv)) {
+        return { code: 0, stderr: '', stdout: usage };
+    }
+    try {
+        return await execute(argv, context);
+    }
+    catch (error) {
+        return failure(error);
+    }
+};

package/dist/esm/scenarios/task-links.d.ts

@@ -0,0 +1,15 @@
+import type { ProjectsInputInterface } from './projects.js';
+export interface LinkRowInterface {
+    readonly file: string;
+    readonly line: number;
+    readonly project: string;
+    readonly status: string;
+    readonly text: string;
+}
+export interface ReadProjectsInterface {
+    readonly notes: readonly string[];
+    readonly rows: readonly LinkRowInterface[];
+    readonly sources: readonly string[];
+}
+export declare const linkToken: RegExp;
+export declare const readProjects: (input: ProjectsInputInterface) => Promise<ReadProjectsInterface>;

package/dist/esm/scenarios/task-links.js

@@ -0,0 +1,50 @@
+import { ConfigError } from './config.js';
+import { readText, walkFiles } from './features.js';
+import { runGit, stdoutText } from './git.js';
+import { projectStatuses, sourceOf, storyKey, walkProjects } from './projects.js';
+import { splitLines } from './python-text.js';
+export const linkToken = /@(?<project>[\da-z][\d\-a-z]*):AC-[\d\-.A-Za-z]*[\dA-Za-z]/gu;
+const linkGrep = '@[a-z0-9][a-z0-9-]*:AC-';
+const hasLink = (text) => text.match(linkToken) !== null;
+const fileLines = async (cwd, file) => {
+    const text = await readText(cwd, file);
+    return splitLines(text).flatMap((line, index) => (hasLink(line) ? [[file, index + 1, line]] : []));
+};
+const ownTaskLines = async (cwd) => {
+    const files = await walkFiles(cwd, 'tasks', '.md');
+    const lines = await Promise.all(files.map(async (file) => fileLines(cwd, file)));
+    return lines.flat();
+};
+const splitGrepLine = (line) => {
+    const first = line.indexOf(':');
+    const second = line.indexOf(':', first + 1);
+    const file = line.slice(0, first);
+    return second === -1 || !file.endsWith('.md')
+        ? []
+        : [[file, Number(line.slice(first + 1, second)), line.slice(second + 1)]];
+};
+const revisionTaskLines = async (cwd, project, revision) => {
+    const done = await runGit({ cwd, repo: project.repo }, ['grep', '-n', '-I', '-E', linkGrep, revision, '--', 'tasks']);
+    if (done.code > 1 || done.code < 0) {
+        throw new ConfigError(`git grep в ${project.repo} на ${revision} не прошёл: ${done.stderr.trim()}`);
+    }
+    return splitLines(stdoutText(done))
+        .flatMap((line) => splitGrepLine(line.slice(revision.length + 1)));
+};
+const taskLines = async (cwd, project) => (project.revision === undefined ? ownTaskLines(cwd) : revisionTaskLines(cwd, project, project.revision));
+const projectRows = async (cwd, project) => {
+    const statuses = await projectStatuses(cwd, project);
+    const lines = await taskLines(cwd, project);
+    return lines.map(([file, line, text]) => ({
+        file,
+        line,
+        project: project.name,
+        status: statuses.get(storyKey(file)) ?? '',
+        text,
+    }));
+};
+export const readProjects = async (input) => {
+    const walk = await walkProjects(input);
+    const rows = await Promise.all(walk.projects.map(async (project) => projectRows(input.cwd, project)));
+    return { notes: walk.notes, rows: rows.flat(), sources: walk.projects.map((project) => sourceOf(project)) };
+};

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "@application-kit/acceptance",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Инструмент репозитория приёмочных тестов: команда application-scenarios (lint, removed, links, classes, coverage, inventory) по feature-файлам и story проектов, каденс прогона, реестр окружений и чтение учётных данных окружения",
+  "keywords": [
+    "acceptance",
+    "bdd",
+    "gherkin",
+    "playwright"
+  ],
+  "homepage": "https://gitlab.com/application-kit/application-kit/-/tree/main/packages/acceptance",
+  "bugs": "https://gitlab.com/application-kit/application-kit/-/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://gitlab.com/application-kit/application-kit.git",
+    "directory": "packages/acceptance"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "application-kit"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "bin": {
+    "application-scenarios": "./dist/esm/bin/application-scenarios.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf ./dist && node ../../scripts/barrels.mjs create ./src --entry-only=bin,scenarios && tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json && node ../../scripts/barrels.mjs clean ./src && node ../../scripts/mark-cjs.mjs ./dist/cjs",
+    "lint:tsc": "tsc --noEmit --pretty --project .",
+    "test:mutation": "stryker run",
+    "test:unit": "vitest run"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@stryker-mutator/core": "^10.0.0",
+    "@stryker-mutator/vitest-runner": "^10.0.0",
+    "@types/node": "^26.2.0",
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.