Fix Colima builds failing

.github/actions/upload-artifact/action.yaml

@@ -1,15 +0,0 @@
-inputs:
-  name:
-    required: true
-  path:
-    required: true
-
-runs:
-  using: composite
-  steps:
-    -
-      name: Upload artifact
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ inputs.name }}
-        path: ${{ inputs.path }}

.github/workflows/checks.build.yaml

@@ -86,9 +86,21 @@ jobs:
         name: Install Docker on macOS
         if: contains(matrix.os, 'macos') # macOS runner is missing Docker
         run: |-
+          # Verify Intel-based macOS
+          arch=$(uname -m)
+          case "$arch" in
+            i386|x86_64)
+              echo "Supported architecture: $arch"
+              ;;
+            *)
+              >&2 echo 'The macOS is not running on a supported Intel architecture. Virtualization is not supported.'
+              exit 1
+              ;;
+          esac
           # Install Docker
           brew install docker
-          # Docker on macOS misses daemon due to licensing, so install colima as runtime
+          # Docker on macOS does not include the Docker daemon due to licensing issues.
+          # Install Colima to use as the Docker runtime.
           brew install colima
           # Start the daemon
           colima start

.github/workflows/checks.desktop-runtime-errors.yaml

@@ -10,8 +10,8 @@ jobs:
     strategy:
       matrix:
         os:
-          - macos-latest  # Apple silicon (ARM64)
-          - macos-13      # Intel-based (x86-64)
+          - macos-latest  # Latest Apple silicon (ARM64)
+          - macos-12      # Latest Intel-based (x86-64)
           - ubuntu-latest
           - windows-latest
       fail-fast: false # Allows to see results from other combinations
@@ -70,7 +70,7 @@ jobs:
       -
         name: Upload screenshot
         if: always() # Run even if previous step fails
-        uses: ./.github/actions/upload-artifact
+        uses: actions/upload-artifact@v3
         with:
           name: screenshot-${{ matrix.os }}
           path: screenshot.png

.github/workflows/tests.e2e.yaml

@@ -51,14 +51,14 @@ jobs:
       -
         name: Upload screenshots
         if: failure() # Run only if previous steps fail because screenshots will be generated only if E2E test failed
-        uses: ./.github/actions/upload-artifact
+        uses: actions/upload-artifact@v3
         with:
           name: e2e-screenshots-${{ matrix.os }}
           path: ${{ steps.artifacts.outputs.SCREENSHOTS_DIR }}
       -
         name: Upload videos
         if: always() # Run even if previous steps fail because test run video is always captured
-        uses: ./.github/actions/upload-artifact
+        uses: actions/upload-artifact@v3
         with:
           name: e2e-videos-${{ matrix.os }}
           path: ${{ steps.artifacts.outputs.VIDEOS_DIR }}

CHANGELOG.md

@@ -1,27 +1,5 @@
 # Changelog
 
-## 0.13.4 (2024-05-27)
-
-* Add specific empty function name compiler error | [870120b](https://github.com/undergroundwires/privacy.sexy/commit/870120bc13909a3681e0f0a2351806849476342f)
-* ci/cd: fix recent Docker build failures on macOS | [a1922c5](https://github.com/undergroundwires/privacy.sexy/commit/a1922c50c12b3b7806e9e681ace842194a178bda)
-* win: standardize registry edit + delete on revert | [cec0b4b](https://github.com/undergroundwires/privacy.sexy/commit/cec0b4b4f63c3563a0e7923ce6324a38d71a3955)
-* Fix e2e test failing on Windows | [4a7efa2](https://github.com/undergroundwires/privacy.sexy/commit/4a7efa27c8df73ef9b7960afed29f216b066cba2)
-* Add support for macOS universal binary #348, #362 | [d25c4e8](https://github.com/undergroundwires/privacy.sexy/commit/d25c4e8c812b8d012010ba38070a2931dcd28908)
-* Migrate to GitHub issue forms | [9ab3ff7](https://github.com/undergroundwires/privacy.sexy/commit/9ab3ff75b0a69ac2ba27dd02e82db9b5bd76ea0f)
-* ci/cd: fix quality checks not running on all OSes | [2390530](https://github.com/undergroundwires/privacy.sexy/commit/2390530d929fb92c266558c52376569a0ecb90c1)
-* Bump Vue to latest and fix universal selector CSS | [aae5434](https://github.com/undergroundwires/privacy.sexy/commit/aae54344511ec51d17ad0420a92cb5a064e0e7bb)
-* Centralize and optimize `ResizeObserver` usage | [2923621](https://github.com/undergroundwires/privacy.sexy/commit/292362135db0519ec1050bab80ed373aad115731)
-* win: improve app access disabling and docs #138 | [ff3d5c4](https://github.com/undergroundwires/privacy.sexy/commit/ff3d5c48419f663379f5aba8936636c22f2c5de8)
-* win: document and discourage RSA key script #363 | [f347fde](https://github.com/undergroundwires/privacy.sexy/commit/f347fde0c85f8b51b0060fdea0a2724b042aaeed)
-* win: improve printing removal /w Print Queue #279 | [150e067](https://github.com/undergroundwires/privacy.sexy/commit/150e0670392bb62348c20ec644a4ed8a6bbffe74)
-* win: discourage blocking app access #121 #339 #350 | [7794846](https://github.com/undergroundwires/privacy.sexy/commit/77948461856e6837ddfbcbbef72a1bf9fc706b4e)
-* Improve context for errors thrown by compiler | [4212c7b](https://github.com/undergroundwires/privacy.sexy/commit/4212c7b9e0b1500378a1e4e88efc2d59f39f3d29)
-* win: document disabling firewall #115 #152 #364 | [12b1f18](https://github.com/undergroundwires/privacy.sexy/commit/12b1f183f7ce966d6ce090d98aeea7ec491f8c7c)
-* win: add script to disable Recall feature | [ce4cfdd](https://github.com/undergroundwires/privacy.sexy/commit/ce4cfdd169b7da0edc3da61143c988ed5f3c976e)
-* win, mac, linux: fix typos and dead URLs #367 | [9e34e64](https://github.com/undergroundwires/privacy.sexy/commit/9e34e644493674ca709b64a47206763d5d4bd60c)
-
-[compare](https://github.com/undergroundwires/privacy.sexy/compare/0.13.3...0.13.4)
-
 ## 0.13.3 (2024-05-11)
 
 * win: organize and document network disablement | [2eed6f4](https://github.com/undergroundwires/privacy.sexy/commit/2eed6f4afb6cf85fdc1d6acb808f82405a35cafd)

README.md

@@ -122,7 +122,7 @@
 ## Get started
 
 - 🌍️ **Online**: [https://privacy.sexy](https://privacy.sexy).
-- 🖥️ **Offline**: Download directly for: [Windows](https://github.com/undergroundwires/privacy.sexy/releases/download/0.13.4/privacy.sexy-Setup-0.13.4.exe), [macOS](https://github.com/undergroundwires/privacy.sexy/releases/download/0.13.4/privacy.sexy-0.13.4.dmg), [Linux](https://github.com/undergroundwires/privacy.sexy/releases/download/0.13.4/privacy.sexy-0.13.4.AppImage). For more options, see [here](#additional-install-options).
+- 🖥️ **Offline**: Download directly for: [Windows](https://github.com/undergroundwires/privacy.sexy/releases/download/0.13.3/privacy.sexy-Setup-0.13.3.exe), [macOS](https://github.com/undergroundwires/privacy.sexy/releases/download/0.13.3/privacy.sexy-0.13.3.dmg), [Linux](https://github.com/undergroundwires/privacy.sexy/releases/download/0.13.3/privacy.sexy-0.13.3.AppImage). For more options, see [here](#additional-install-options).
 
 See also:
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "privacy.sexy",
-  "version": "0.13.4",
+  "version": "0.13.3",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "privacy.sexy",
-  "version": "0.13.4",
+  "version": "0.13.3",
   "private": true,
   "slogan": "Privacy is sexy",
   "description": "Enforce privacy & security best-practices on Windows, macOS and Linux, because privacy is sexy.",

src/application/Common/CustomError.ts

@@ -1,4 +1,4 @@
-import { isFunction, type ConstructorArguments } from '@/TypeHelpers';
+import { isFunction } from '@/TypeHelpers';
 
 /*
   Provides a unified and resilient way to extend errors across platforms.
@@ -12,8 +12,8 @@ import { isFunction, type ConstructorArguments } from '@/TypeHelpers';
     > https://web.archive.org/web/20230810014143/https://github.com/Microsoft/TypeScript-wiki/blob/main/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
 */
 export abstract class CustomError extends Error {
-  constructor(...args: ConstructorArguments<typeof Error>) {
-    super(...args);
+  constructor(message?: string, options?: ErrorOptions) {
+    super(message, options);
 
     fixPrototype(this, new.target.prototype);
     ensureStackTrace(this);

src/application/Parser/CategoryParser.ts

@@ -3,12 +3,10 @@ import type {
 } from '@/application/collections/';
 import { Script } from '@/domain/Script';
 import { Category } from '@/domain/Category';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import type { ICategory } from '@/domain/ICategory';
-import { parseDocs, type DocsParser } from './DocumentationParser';
-import { parseScript, type ScriptParser } from './Script/ScriptParser';
-import { createNodeDataValidator, type NodeDataValidator, type NodeDataValidatorFactory } from './NodeValidation/NodeDataValidator';
-import { NodeDataType } from './NodeValidation/NodeDataType';
+import { NodeValidator } from '@/application/Parser/NodeValidation/NodeValidator';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
+import { parseDocs } from './DocumentationParser';
+import { parseScript } from './Script/ScriptParser';
 import type { ICategoryCollectionParseContext } from './Script/ICategoryCollectionParseContext';
 
 let categoryIdCounter = 0;
@@ -16,108 +14,96 @@ let categoryIdCounter = 0;
 export function parseCategory(
   category: CategoryData,
   context: ICategoryCollectionParseContext,
-  utilities: CategoryParserUtilities = DefaultCategoryParserUtilities,
+  factory: CategoryFactoryType = CategoryFactory,
 ): Category {
   return parseCategoryRecursively({
     categoryData: category,
     context,
-    utilities,
+    factory,
   });
 }
 
-interface CategoryParseContext {
-  readonly categoryData: CategoryData;
-  readonly context: ICategoryCollectionParseContext;
-  readonly parentCategory?: CategoryData;
-  readonly utilities: CategoryParserUtilities;
+interface ICategoryParseContext {
+  readonly categoryData: CategoryData,
+  readonly context: ICategoryCollectionParseContext,
+  readonly factory: CategoryFactoryType,
+  readonly parentCategory?: CategoryData,
 }
 
-function parseCategoryRecursively(
-  context: CategoryParseContext,
-): Category | never {
-  const validator = ensureValidCategory(context);
-  const children: CategoryChildren = {
-    subcategories: new Array<Category>(),
-    subscripts: new Array<Script>(),
+function parseCategoryRecursively(context: ICategoryParseContext): Category | never {
+  ensureValidCategory(context.categoryData, context.parentCategory);
+  const children: ICategoryChildren = {
+    subCategories: new Array<Category>(),
+    subScripts: new Array<Script>(),
   };
   for (const data of context.categoryData.children) {
     parseNode({
       nodeData: data,
       children,
       parent: context.categoryData,
-      utilities: context.utilities,
+      factory: context.factory,
       context: context.context,
     });
   }
   try {
-    return context.utilities.createCategory({
-      id: categoryIdCounter++,
-      name: context.categoryData.category,
-      docs: context.utilities.parseDocs(context.categoryData),
-      subcategories: children.subcategories,
-      scripts: children.subscripts,
-    });
-  } catch (error) {
-    throw context.utilities.wrapError(
-      error,
-      validator.createContextualErrorMessage('Failed to parse category.'),
+    return context.factory(
+      /* id: */ categoryIdCounter++,
+      /* name: */ context.categoryData.category,
+      /* docs: */ parseDocs(context.categoryData),
+      /* categories: */ children.subCategories,
+      /* scripts: */ children.subScripts,
     );
+  } catch (err) {
+    return new NodeValidator({
+      type: NodeType.Category,
+      selfNode: context.categoryData,
+      parentNode: context.parentCategory,
+    }).throw(err.message);
   }
 }
 
-function ensureValidCategory(
-  context: CategoryParseContext,
-): NodeDataValidator {
-  const category = context.categoryData;
-  const validator: NodeDataValidator = context.utilities.createValidator({
-    type: NodeDataType.Category,
-    selfNode: context.categoryData,
-    parentNode: context.parentCategory,
-  });
-  validator.assertDefined(category);
-  validator.assertValidName(category.category);
-  validator.assert(
-    () => Boolean(category.children) && category.children.length > 0,
-    `"${category.category}" has no children.`,
-  );
-  return validator;
+function ensureValidCategory(category: CategoryData, parentCategory?: CategoryData) {
+  new NodeValidator({
+    type: NodeType.Category,
+    selfNode: category,
+    parentNode: parentCategory,
+  })
+    .assertDefined(category)
+    .assertValidName(category.category)
+    .assert(
+      () => category.children.length > 0,
+      `"${category.category}" has no children.`,
+    );
 }
 
-interface CategoryChildren {
-  readonly subcategories: Category[];
-  readonly subscripts: Script[];
+interface ICategoryChildren {
+  subCategories: Category[];
+  subScripts: Script[];
 }
 
-interface NodeParseContext {
+interface INodeParseContext {
   readonly nodeData: CategoryOrScriptData;
-  readonly children: CategoryChildren;
+  readonly children: ICategoryChildren;
   readonly parent: CategoryData;
+  readonly factory: CategoryFactoryType;
   readonly context: ICategoryCollectionParseContext;
-
-  readonly utilities: CategoryParserUtilities;
 }
-
-function parseNode(context: NodeParseContext) {
-  const validator: NodeDataValidator = context.utilities.createValidator({
-    selfNode: context.nodeData,
-    parentNode: context.parent,
-  });
+function parseNode(context: INodeParseContext) {
+  const validator = new NodeValidator({ selfNode: context.nodeData, parentNode: context.parent });
   validator.assertDefined(context.nodeData);
-  validator.assert(
-    () => isCategory(context.nodeData) || isScript(context.nodeData),
-    'Node is neither a category or a script.',
-  );
   if (isCategory(context.nodeData)) {
     const subCategory = parseCategoryRecursively({
       categoryData: context.nodeData,
       context: context.context,
+      factory: context.factory,
       parentCategory: context.parent,
-      utilities: context.utilities,
     });
-    context.children.subcategories.push(subCategory);
-  } else { // A script
-    const script = context.utilities.parseScript(context.nodeData, context.context);
-    context.children.subscripts.push(script);
+    context.children.subCategories.push(subCategory);
+  } else if (isScript(context.nodeData)) {
+    const script = parseScript(context.nodeData, context.context);
+    context.children.subScripts.push(script);
+  } else {
+    validator.throw('Node is neither a category or a script.');
   }
 }
 
@@ -137,35 +123,11 @@ function hasCall(data: unknown) {
   return hasProperty(data, 'call');
 }
 
-function hasProperty(
-  object: unknown,
-  propertyName: string,
-): object is NonNullable<object> {
-  if (typeof object !== 'object') {
-    return false;
-  }
-  if (object === null) { // `typeof object` is `null`
-    return false;
-  }
+function hasProperty(object: unknown, propertyName: string) {
   return Object.prototype.hasOwnProperty.call(object, propertyName);
 }
 
-export type CategoryFactory = (
-  ...parameters: ConstructorParameters<typeof Category>
-) => ICategory;
+export type CategoryFactoryType = (
+  ...parameters: ConstructorParameters<typeof Category>) => Category;
 
-interface CategoryParserUtilities {
-  readonly createCategory: CategoryFactory;
-  readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: NodeDataValidatorFactory;
-  readonly parseScript: ScriptParser;
-  readonly parseDocs: DocsParser;
-}
-
-const DefaultCategoryParserUtilities: CategoryParserUtilities = {
-  createCategory: (...parameters) => new Category(...parameters),
-  wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createNodeDataValidator,
-  parseScript,
-  parseDocs,
-};
+const CategoryFactory: CategoryFactoryType = (...parameters) => new Category(...parameters);

src/application/Parser/ContextualError.ts

@@ -1,42 +0,0 @@
-import { CustomError } from '@/application/Common/CustomError';
-
-export interface ErrorWithContextWrapper {
-  (
-    error: Error,
-    additionalContext: string,
-  ): Error;
-}
-
-export const wrapErrorWithAdditionalContext: ErrorWithContextWrapper = (
-  error: Error,
-  additionalContext: string,
-) => {
-  return (error instanceof ContextualError ? error : new ContextualError(error))
-    .withAdditionalContext(additionalContext);
-};
-
-/* AggregateError is similar but isn't well-serialized or displayed by browsers */
-class ContextualError extends CustomError {
-  private readonly additionalContext = new Array<string>();
-
-  constructor(
-    public readonly innerError: Error,
-  ) {
-    super();
-  }
-
-  public withAdditionalContext(additionalContext: string): this {
-    this.additionalContext.push(additionalContext);
-    return this;
-  }
-
-  public get message(): string { // toString() is not used when Chromium logs it on console
-    return [
-      '\n',
-      this.innerError.message,
-      '\n',
-      'Additional context:',
-      ...this.additionalContext.map((context, index) => `${index + 1}: ${context}`),
-    ].join('\n');
-  }
-}

src/application/Parser/DocumentationParser.ts

@@ -1,7 +1,7 @@
 import type { DocumentableData, DocumentationData } from '@/application/collections/';
 import { isString, isArray } from '@/TypeHelpers';
 
-export const parseDocs: DocsParser = (documentable) => {
+export function parseDocs(documentable: DocumentableData): readonly string[] {
   const { docs } = documentable;
   if (!docs) {
     return [];
@@ -9,12 +9,6 @@ export const parseDocs: DocsParser = (documentable) => {
   let result = new DocumentationContainer();
   result = addDocs(docs, result);
   return result.getAll();
-};
-
-export interface DocsParser {
-  (
-    documentable: DocumentableData,
-  ): readonly string[];
 }
 
 function addDocs(

src/application/Parser/NodeValidation/NodeDataError.ts

@@ -0,0 +1,34 @@
+import { CustomError } from '@/application/Common/CustomError';
+import { NodeType } from './NodeType';
+import type { NodeData } from './NodeData';
+
+export class NodeDataError extends CustomError {
+  constructor(message: string, public readonly context: INodeDataErrorContext) {
+    super(createMessage(message, context));
+  }
+}
+
+export interface INodeDataErrorContext {
+  readonly type?: NodeType;
+  readonly selfNode: NodeData;
+  readonly parentNode?: NodeData;
+}
+
+function createMessage(errorMessage: string, context: INodeDataErrorContext) {
+  let message = '';
+  if (context.type !== undefined) {
+    message += `${NodeType[context.type]}: `;
+  }
+  message += errorMessage;
+  message += `\n${dump(context)}`;
+  return message;
+}
+
+function dump(context: INodeDataErrorContext): string {
+  const printJson = (obj: unknown) => JSON.stringify(obj, undefined, 2);
+  let output = `Self: ${printJson(context.selfNode)}`;
+  if (context.parentNode) {
+    output += `\nParent: ${printJson(context.parentNode)}`;
+  }
+  return output;
+}

src/application/Parser/NodeValidation/NodeDataErrorContext.ts

@@ -1,25 +0,0 @@
-import type { CategoryData, ScriptData } from '@/application/collections/';
-import { NodeDataType } from './NodeDataType';
-import type { NodeData } from './NodeData';
-
-export type NodeDataErrorContext = {
-  readonly parentNode?: CategoryData;
-} & (CategoryNodeErrorContext | ScriptNodeErrorContext | UnknownNodeErrorContext);
-
-export type CategoryNodeErrorContext = {
-  readonly type: NodeDataType.Category;
-  readonly selfNode: CategoryData;
-  readonly parentNode?: CategoryData;
-};
-
-export type ScriptNodeErrorContext = {
-  readonly type: NodeDataType.Script;
-  readonly selfNode: ScriptData;
-  readonly parentNode?: CategoryData;
-};
-
-export type UnknownNodeErrorContext = {
-  readonly type?: undefined;
-  readonly selfNode: NodeData;
-  readonly parentNode?: CategoryData;
-};

src/application/Parser/NodeValidation/NodeDataErrorContextMessage.ts

@@ -1,35 +0,0 @@
-import { NodeDataType } from './NodeDataType';
-import type { NodeDataErrorContext } from './NodeDataErrorContext';
-import type { NodeData } from './NodeData';
-
-export interface NodeContextErrorMessageCreator {
-  (
-    errorMessage: string,
-    context: NodeDataErrorContext,
-  ): string;
-}
-
-export const createNodeContextErrorMessage: NodeContextErrorMessageCreator = (
-  errorMessage,
-  context,
-) => {
-  let message = '';
-  if (context.type !== undefined) {
-    message += `${NodeDataType[context.type]}: `;
-  }
-  message += errorMessage;
-  message += `\n${getErrorContextDetails(context)}`;
-  return message;
-};
-
-function getErrorContextDetails(context: NodeDataErrorContext): string {
-  let output = `Self: ${printNodeDataAsJson(context.selfNode)}`;
-  if (context.parentNode) {
-    output += `\nParent: ${printNodeDataAsJson(context.parentNode)}`;
-  }
-  return output;
-}
-
-function printNodeDataAsJson(node: NodeData): string {
-  return JSON.stringify(node, undefined, 2);
-}

src/application/Parser/NodeValidation/NodeDataType.ts

@@ -1,4 +0,0 @@
-export enum NodeDataType {
-  Script,
-  Category,
-}

src/application/Parser/NodeValidation/NodeDataValidator.ts

@@ -1,69 +0,0 @@
-import { isString } from '@/TypeHelpers';
-import { type NodeDataErrorContext } from './NodeDataErrorContext';
-import { createNodeContextErrorMessage, type NodeContextErrorMessageCreator } from './NodeDataErrorContextMessage';
-import type { NodeData } from './NodeData';
-
-export interface NodeDataValidatorFactory {
-  (context: NodeDataErrorContext): NodeDataValidator;
-}
-
-export interface NodeDataValidator {
-  assertValidName(nameValue: string): void;
-  assertDefined(
-    node: NodeData | undefined,
-  ): asserts node is NonNullable<NodeData> & void;
-  assert(
-    validationPredicate: () => boolean,
-    errorMessage: string,
-  ): asserts validationPredicate is (() => true);
-  createContextualErrorMessage(errorMessage: string): string;
-}
-
-export const createNodeDataValidator
-: NodeDataValidatorFactory = (context) => new ContextualNodeDataValidator(context);
-
-export class ContextualNodeDataValidator implements NodeDataValidator {
-  constructor(
-    private readonly context: NodeDataErrorContext,
-    private readonly createErrorMessage
-    : NodeContextErrorMessageCreator = createNodeContextErrorMessage,
-  ) {
-
-  }
-
-  public assertValidName(nameValue: string): void {
-    this.assert(() => Boolean(nameValue), 'missing name');
-    this.assert(
-      () => isString(nameValue),
-      `Name (${JSON.stringify(nameValue)}) is not a string but ${typeof nameValue}.`,
-    );
-  }
-
-  public assertDefined(
-    node: NodeData,
-  ): asserts node is NonNullable<NodeData> {
-    this.assert(
-      () => node !== undefined && node !== null && Object.keys(node).length > 0,
-      'missing node data',
-    );
-  }
-
-  public assert(
-    validationPredicate: () => boolean,
-    errorMessage: string,
-  ): asserts validationPredicate is (() => true) {
-    if (!validationPredicate()) {
-      this.throw(errorMessage);
-    }
-  }
-
-  public createContextualErrorMessage(errorMessage: string): string {
-    return this.createErrorMessage(errorMessage, this.context);
-  }
-
-  private throw(errorMessage: string): never {
-    throw new Error(
-      this.createContextualErrorMessage(errorMessage),
-    );
-  }
-}

src/application/Parser/NodeValidation/NodeType.ts

@@ -0,0 +1,4 @@
+export enum NodeType {
+  Script,
+  Category,
+}

src/application/Parser/NodeValidation/NodeValidator.ts

@@ -0,0 +1,39 @@
+import { isString } from '@/TypeHelpers';
+import { type INodeDataErrorContext, NodeDataError } from './NodeDataError';
+import type { NodeData } from './NodeData';
+
+export class NodeValidator {
+  constructor(private readonly context: INodeDataErrorContext) {
+
+  }
+
+  public assertValidName(nameValue: string) {
+    return this
+      .assert(
+        () => Boolean(nameValue),
+        'missing name',
+      )
+      .assert(
+        () => isString(nameValue),
+        `Name (${JSON.stringify(nameValue)}) is not a string but ${typeof nameValue}.`,
+      );
+  }
+
+  public assertDefined(node: NodeData) {
+    return this.assert(
+      () => node !== undefined && node !== null && Object.keys(node).length > 0,
+      'missing node data',
+    );
+  }
+
+  public assert(validationPredicate: () => boolean, errorMessage: string) {
+    if (!validationPredicate()) {
+      this.throw(errorMessage);
+    }
+    return this;
+  }
+
+  public throw(errorMessage: string): never {
+    throw new NodeDataError(errorMessage, this.context);
+  }
+}

src/application/Parser/Script/Compiler/Expressions/Expression/Expression.ts

@@ -7,18 +7,15 @@ import type { IReadOnlyFunctionParameterCollection } from '../../Function/Parame
 import type { IExpression } from './IExpression';
 
 export type ExpressionEvaluator = (context: IExpressionEvaluationContext) => string;
-
 export class Expression implements IExpression {
   public readonly parameters: IReadOnlyFunctionParameterCollection;
 
-  public readonly position: ExpressionPosition;
-
-  public readonly evaluator: ExpressionEvaluator;
-
-  constructor(parameters: ExpressionInitParameters) {
-    this.parameters = parameters.parameters ?? new FunctionParameterCollection();
-    this.evaluator = parameters.evaluator;
-    this.position = parameters.position;
+  constructor(
+    public readonly position: ExpressionPosition,
+    public readonly evaluator: ExpressionEvaluator,
+    parameters?: IReadOnlyFunctionParameterCollection,
+  ) {
+    this.parameters = parameters ?? new FunctionParameterCollection();
   }
 
   public evaluate(context: IExpressionEvaluationContext): string {
@@ -29,12 +26,6 @@ export class Expression implements IExpression {
   }
 }
 
-export interface ExpressionInitParameters {
-  readonly position: ExpressionPosition,
-  readonly evaluator: ExpressionEvaluator,
-  readonly parameters?: IReadOnlyFunctionParameterCollection,
-}
-
 function validateThatAllRequiredParametersAreSatisfied(
   parameters: IReadOnlyFunctionParameterCollection,
   args: IReadOnlyFunctionCallArgumentCollection,

src/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory.ts

@@ -1,13 +1,8 @@
 import { ExpressionPosition } from './ExpressionPosition';
 
-export interface ExpressionPositionFactory {
-  (
-    match: RegExpMatchArray,
-  ): ExpressionPosition
-}
-
-export const createPositionFromRegexFullMatch
-: ExpressionPositionFactory = (match) => {
+export function createPositionFromRegexFullMatch(
+  match: RegExpMatchArray,
+): ExpressionPosition {
   const startPos = match.index;
   if (startPos === undefined) {
     throw new Error(`Regex match did not yield any results: ${JSON.stringify(match)}`);
@@ -18,4 +13,4 @@ export const createPositionFromRegexFullMatch
   }
   const endPos = startPos + fullMatch.length;
   return new ExpressionPosition(startPos, endPos);
-};
+}

src/application/Parser/Script/Compiler/Expressions/Parser/CompositeExpressionParser.ts

@@ -3,10 +3,10 @@ import { WithParser } from '../SyntaxParsers/WithParser';
 import type { IExpression } from '../Expression/IExpression';
 import type { IExpressionParser } from './IExpressionParser';
 
-const Parsers: readonly IExpressionParser[] = [
+const Parsers = [
   new ParameterSubstitutionParser(),
   new WithParser(),
-] as const;
+];
 
 export class CompositeExpressionParser implements IExpressionParser {
   public constructor(private readonly leafs: readonly IExpressionParser[] = Parsers) {

src/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.ts

@@ -1,127 +1,53 @@
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { Expression, type ExpressionEvaluator } from '../../Expression/Expression';
-import { createPositionFromRegexFullMatch, type ExpressionPositionFactory } from '../../Expression/ExpressionPositionFactory';
-import { createFunctionParameterCollection, type FunctionParameterCollectionFactory } from '../../../Function/Parameter/FunctionParameterCollectionFactory';
+import { FunctionParameterCollection } from '../../../Function/Parameter/FunctionParameterCollection';
+import { createPositionFromRegexFullMatch } from '../../Expression/ExpressionPositionFactory';
 import type { IExpressionParser } from '../IExpressionParser';
 import type { IExpression } from '../../Expression/IExpression';
 import type { IFunctionParameter } from '../../../Function/Parameter/IFunctionParameter';
-import type { IFunctionParameterCollection, IReadOnlyFunctionParameterCollection } from '../../../Function/Parameter/IFunctionParameterCollection';
-
-export interface RegexParserUtilities {
-  readonly wrapError: ErrorWithContextWrapper;
-  readonly createPosition: ExpressionPositionFactory;
-  readonly createExpression: ExpressionFactory;
-  readonly createParameterCollection: FunctionParameterCollectionFactory;
-}
 
 export abstract class RegexParser implements IExpressionParser {
   protected abstract readonly regex: RegExp;
 
-  public constructor(
-    private readonly utilities: RegexParserUtilities = DefaultRegexParserUtilities,
-  ) {
-
-  }
-
   public findExpressions(code: string): IExpression[] {
     return Array.from(this.findRegexExpressions(code));
   }
 
-  protected abstract buildExpression(match: RegExpMatchArray): PrimitiveExpression;
+  protected abstract buildExpression(match: RegExpMatchArray): IPrimitiveExpression;
 
   private* findRegexExpressions(code: string): Iterable<IExpression> {
     if (!code) {
-      throw new Error(
-        this.buildErrorMessageWithContext({ errorMessage: 'missing code', code: 'EMPTY' }),
-      );
+      throw new Error('missing code');
     }
-    const createErrorContext = (message: string): ErrorContext => ({ code, errorMessage: message });
-    const matches = this.doOrRethrow(
-      () => code.matchAll(this.regex),
-      createErrorContext('Failed to match regex.'),
-    );
+    const matches = code.matchAll(this.regex);
     for (const match of matches) {
-      const primitiveExpression = this.doOrRethrow(
-        () => this.buildExpression(match),
-        createErrorContext('Failed to build expression.'),
-      );
-      const position = this.doOrRethrow(
-        () => this.utilities.createPosition(match),
-        createErrorContext('Failed to create position.'),
-      );
-      const parameters = this.doOrRethrow(
-        () => createParameters(
-          primitiveExpression,
-          this.utilities.createParameterCollection(),
-        ),
-        createErrorContext('Failed to create parameters.'),
-      );
-      const expression = this.doOrRethrow(
-        () => this.utilities.createExpression({
-          position,
-          evaluator: primitiveExpression.evaluator,
-          parameters,
-        }),
-        createErrorContext('Failed to create expression.'),
-      );
+      const primitiveExpression = this.buildExpression(match);
+      const position = this.doOrRethrow(() => createPositionFromRegexFullMatch(match), 'invalid script position', code);
+      const parameters = createParameters(primitiveExpression);
+      const expression = new Expression(position, primitiveExpression.evaluator, parameters);
       yield expression;
     }
   }
 
-  private doOrRethrow<T>(
-    action: () => T,
-    context: ErrorContext,
-  ): T {
+  private doOrRethrow<T>(action: () => T, errorText: string, code: string): T {
     try {
       return action();
     } catch (error) {
-      throw this.utilities.wrapError(
-        error,
-        this.buildErrorMessageWithContext(context),
-      );
+      throw new Error(`[${this.constructor.name}] ${errorText}: ${error.message}\nRegex: ${this.regex}\nCode: ${code}`);
     }
   }
-
-  private buildErrorMessageWithContext(context: ErrorContext): string {
-    return [
-      context.errorMessage,
-      `Class name: ${this.constructor.name}`,
-      `Regex pattern used: ${this.regex}`,
-      `Code: ${context.code}`,
-    ].join('\n');
-  }
-}
-
-interface ErrorContext {
-  readonly errorMessage: string,
-  readonly code: string,
 }
 
 function createParameters(
-  expression: PrimitiveExpression,
-  parameterCollection: IFunctionParameterCollection,
-): IReadOnlyFunctionParameterCollection {
+  expression: IPrimitiveExpression,
+): FunctionParameterCollection {
   return (expression.parameters || [])
     .reduce((parameters, parameter) => {
       parameters.addParameter(parameter);
       return parameters;
-    }, parameterCollection);
+    }, new FunctionParameterCollection());
 }
 
-export interface PrimitiveExpression {
-  readonly evaluator: ExpressionEvaluator;
-  readonly parameters?: readonly IFunctionParameter[];
+export interface IPrimitiveExpression {
+  evaluator: ExpressionEvaluator;
+  parameters?: readonly IFunctionParameter[];
 }
-
-export interface ExpressionFactory {
-  (
-    ...args: ConstructorParameters<typeof Expression>
-  ): IExpression;
-}
-
-const DefaultRegexParserUtilities: RegexParserUtilities = {
-  wrapError: wrapErrorWithAdditionalContext,
-  createPosition: createPositionFromRegexFullMatch,
-  createExpression: (...args) => new Expression(...args),
-  createParameterCollection: createFunctionParameterCollection,
-};

src/application/Parser/Script/Compiler/Expressions/SyntaxParsers/ParameterSubstitutionParser.ts

@@ -1,5 +1,5 @@
 import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
-import { RegexParser, type PrimitiveExpression } from '../Parser/Regex/RegexParser';
+import { RegexParser, type IPrimitiveExpression } from '../Parser/Regex/RegexParser';
 import { ExpressionRegexBuilder } from '../Parser/Regex/ExpressionRegexBuilder';
 
 export class ParameterSubstitutionParser extends RegexParser {
@@ -12,7 +12,7 @@ export class ParameterSubstitutionParser extends RegexParser {
     .expectExpressionEnd()
     .buildRegExp();
 
-  protected buildExpression(match: RegExpMatchArray): PrimitiveExpression {
+  protected buildExpression(match: RegExpMatchArray): IPrimitiveExpression {
     const parameterName = match[1];
     const pipeline = match[2];
     return {

src/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.ts

@@ -8,7 +8,7 @@ export class FunctionCallArgument implements IFunctionCallArgument {
   ) {
     ensureValidParameterName(parameterName);
     if (!argumentValue) {
-      throw new Error(`Missing argument value for the parameter "${parameterName}".`);
+      throw new Error(`missing argument value for "${parameterName}"`);
     }
   }
 }

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/AdaptiveFunctionCallCompiler.ts

@@ -72,7 +72,7 @@ function throwIfUnexpectedParametersExist(
     // eslint-disable-next-line prefer-template
     `Function "${functionName}" has unexpected parameter(s) provided: `
       + `"${unexpectedParameters.join('", "')}"`
-      + '.\nExpected parameter(s): '
-      + (expectedParameters.length ? `"${expectedParameters.join('", "')}".` : 'none'),
+      + '. Expected parameter(s): '
+      + (expectedParameters.length ? `"${expectedParameters.join('", "')}"` : 'none'),
   );
 }

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.ts

@@ -6,14 +6,11 @@ import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/
 import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
 import { ParsedFunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/ParsedFunctionCall';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import type { ArgumentCompiler } from './ArgumentCompiler';
 
 export class NestedFunctionArgumentCompiler implements ArgumentCompiler {
   constructor(
     private readonly expressionsCompiler: IExpressionsCompiler = new ExpressionsCompiler(),
-    private readonly wrapError: ErrorWithContextWrapper
-    = wrapErrorWithAdditionalContext,
   ) { }
 
   public createCompiledNestedCall(
@@ -25,26 +22,18 @@ export class NestedFunctionArgumentCompiler implements ArgumentCompiler {
       nestedFunction,
       parentFunction.args,
       context,
-      {
-        expressionsCompiler: this.expressionsCompiler,
-        wrapError: this.wrapError,
-      },
+      this.expressionsCompiler,
     );
     const compiledCall = new ParsedFunctionCall(nestedFunction.functionName, compiledArgs);
     return compiledCall;
   }
 }
 
-interface ArgumentCompilationUtilities {
-  readonly expressionsCompiler: IExpressionsCompiler,
-  readonly wrapError: ErrorWithContextWrapper;
-}
-
 function compileNestedFunctionArguments(
   nestedFunction: FunctionCall,
   parentFunctionArgs: IReadOnlyFunctionCallArgumentCollection,
   context: FunctionCallCompilationContext,
-  utilities: ArgumentCompilationUtilities,
+  expressionsCompiler: IExpressionsCompiler,
 ): IReadOnlyFunctionCallArgumentCollection {
   const requiredParameterNames = context
     .allFunctions
@@ -58,7 +47,7 @@ function compileNestedFunctionArguments(
         paramName,
         nestedFunction,
         parentFunctionArgs,
-        utilities,
+        expressionsCompiler,
       ),
     }))
     // Filter out arguments with absent values
@@ -100,13 +89,13 @@ function compileArgument(
   parameterName: string,
   nestedFunction: FunctionCall,
   parentFunctionArgs: IReadOnlyFunctionCallArgumentCollection,
-  utilities: ArgumentCompilationUtilities,
+  expressionsCompiler: IExpressionsCompiler,
 ): string {
   try {
     const { argumentValue: codeInArgument } = nestedFunction.args.getArgument(parameterName);
-    return utilities.expressionsCompiler.compileExpressions(codeInArgument, parentFunctionArgs);
-  } catch (error) {
-    throw utilities.wrapError(error, `Error when compiling argument for "${parameterName}"`);
+    return expressionsCompiler.compileExpressions(codeInArgument, parentFunctionArgs);
+  } catch (err) {
+    throw new AggregateError([err], `Error when compiling argument for "${parameterName}"`);
   }
 }
 

src/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/NestedFunctionCallCompiler.ts

@@ -1,21 +1,14 @@
-import {
-  type CallFunctionBody, FunctionBodyType,
-  type ISharedFunction,
-} from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
+import { type CallFunctionBody, FunctionBodyType, type ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
 import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 import type { FunctionCallCompilationContext } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompilationContext';
 import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { NestedFunctionArgumentCompiler } from './Argument/NestedFunctionArgumentCompiler';
 import type { SingleCallCompilerStrategy } from '../SingleCallCompilerStrategy';
 import type { ArgumentCompiler } from './Argument/ArgumentCompiler';
 
 export class NestedFunctionCallCompiler implements SingleCallCompilerStrategy {
   public constructor(
-    private readonly argumentCompiler: ArgumentCompiler
-    = new NestedFunctionArgumentCompiler(),
-    private readonly wrapError: ErrorWithContextWrapper
-    = wrapErrorWithAdditionalContext,
+    private readonly argumentCompiler: ArgumentCompiler = new NestedFunctionArgumentCompiler(),
   ) {
   }
 
@@ -36,11 +29,8 @@ export class NestedFunctionCallCompiler implements SingleCallCompilerStrategy {
         const compiledNestedCall = context.singleCallCompiler
           .compileSingleCall(compiledParentCall, context);
         return compiledNestedCall;
-      } catch (error) {
-        throw this.wrapError(
-          error,
-          `Failed to call '${nestedCall.functionName}' (callee function) from '${callToFunction.functionName}' (caller function).`,
-        );
+      } catch (err) {
+        throw new AggregateError([err], `Error with call to "${nestedCall.functionName}" function from "${callToFunction.functionName}" function`);
       }
     }).flat();
   }

src/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.ts

@@ -1,12 +0,0 @@
-import { FunctionParameterCollection } from './FunctionParameterCollection';
-import type { IFunctionParameterCollection } from './IFunctionParameterCollection';
-
-export interface FunctionParameterCollectionFactory {
-  (
-    ...args: ConstructorParameters<typeof FunctionParameterCollection>
-  ): IFunctionParameterCollection;
-}
-
-export const createFunctionParameterCollection: FunctionParameterCollectionFactory = (...args) => {
-  return new FunctionParameterCollection(...args);
-};

src/application/Parser/Script/Compiler/Function/SharedFunctionCollection.ts

@@ -15,7 +15,7 @@ export class SharedFunctionCollection implements ISharedFunctionCollection {
     if (!name) { throw Error('missing function name'); }
     const func = this.functionsByName.get(name);
     if (!func) {
-      throw new Error(`Called function is not defined: "${name}"`);
+      throw new Error(`called function is not defined "${name}"`);
     }
     return func;
   }

src/application/Parser/Script/Compiler/Function/SharedFunctionsParser.ts

@@ -1,6 +1,5 @@
 import type {
-  FunctionData, CodeInstruction, CodeFunctionData, CallFunctionData,
-  CallInstruction, ParameterDefinitionData,
+  FunctionData, CodeInstruction, CodeFunctionData, CallFunctionData, CallInstruction,
 } from '@/application/collections/';
 import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
 import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
@@ -8,30 +7,20 @@ import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmp
 import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
 import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
 import { isArray, isNullOrUndefined, isPlainObject } from '@/TypeHelpers';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
 import { createFunctionWithInlineCode, createCallerFunction } from './SharedFunction';
 import { SharedFunctionCollection } from './SharedFunctionCollection';
 import { FunctionParameter } from './Parameter/FunctionParameter';
+import { FunctionParameterCollection } from './Parameter/FunctionParameterCollection';
 import { parseFunctionCalls } from './Call/FunctionCallParser';
-import { createFunctionParameterCollection, type FunctionParameterCollectionFactory } from './Parameter/FunctionParameterCollectionFactory';
 import type { ISharedFunctionCollection } from './ISharedFunctionCollection';
 import type { ISharedFunctionsParser } from './ISharedFunctionsParser';
 import type { IReadOnlyFunctionParameterCollection } from './Parameter/IFunctionParameterCollection';
 import type { ISharedFunction } from './ISharedFunction';
 
-const DefaultSharedFunctionsParsingUtilities: SharedFunctionsParsingUtilities = {
-  wrapError: wrapErrorWithAdditionalContext,
-  createParameter: (...args) => new FunctionParameter(...args),
-  codeValidator: CodeValidator.instance,
-  createParameterCollection: createFunctionParameterCollection,
-};
-
 export class SharedFunctionsParser implements ISharedFunctionsParser {
   public static readonly instance: ISharedFunctionsParser = new SharedFunctionsParser();
 
-  constructor(
-    private readonly utilities = DefaultSharedFunctionsParsingUtilities,
-  ) { }
+  constructor(private readonly codeValidator: ICodeValidator = CodeValidator.instance) { }
 
   public parseFunctions(
     functions: readonly FunctionData[],
@@ -43,7 +32,7 @@ export class SharedFunctionsParser implements ISharedFunctionsParser {
     }
     ensureValidFunctions(functions);
     return functions
-      .map((func) => parseFunction(func, syntax, this.utilities))
+      .map((func) => parseFunction(func, syntax, this.codeValidator))
       .reduce((acc, func) => {
         acc.addFunction(func);
         return acc;
@@ -51,26 +40,15 @@ export class SharedFunctionsParser implements ISharedFunctionsParser {
   }
 }
 
-interface SharedFunctionsParsingUtilities {
-  readonly wrapError: ErrorWithContextWrapper;
-  readonly createParameter: FunctionParameterFactory;
-  readonly codeValidator: ICodeValidator;
-  readonly createParameterCollection: FunctionParameterCollectionFactory;
-}
-
-export type FunctionParameterFactory = (
-  ...args: ConstructorParameters<typeof FunctionParameter>
-) => FunctionParameter;
-
 function parseFunction(
   data: FunctionData,
   syntax: ILanguageSyntax,
-  utilities: SharedFunctionsParsingUtilities,
+  validator: ICodeValidator,
 ): ISharedFunction {
   const { name } = data;
-  const parameters = parseParameters(data, utilities);
+  const parameters = parseParameters(data);
   if (hasCode(data)) {
-    validateCode(data, syntax, utilities.codeValidator);
+    validateCode(data, syntax, validator);
     return createFunctionWithInlineCode(name, parameters, data.code, data.revertCode);
   }
   // Has call
@@ -93,38 +71,22 @@ function validateCode(
     );
 }
 
-function parseParameters(
-  data: FunctionData,
-  utilities: SharedFunctionsParsingUtilities,
-): IReadOnlyFunctionParameterCollection {
+function parseParameters(data: FunctionData): IReadOnlyFunctionParameterCollection {
   return (data.parameters || [])
-    .map((parameter) => createFunctionParameter(
-      data.name,
-      parameter,
-      utilities,
-    ))
+    .map((parameter) => {
+      try {
+        return new FunctionParameter(
+          parameter.name,
+          parameter.optional || false,
+        );
+      } catch (err) {
+        throw new Error(`"${data.name}": ${err.message}`);
+      }
+    })
     .reduce((parameters, parameter) => {
       parameters.addParameter(parameter);
       return parameters;
-    }, utilities.createParameterCollection());
-}
-
-function createFunctionParameter(
-  functionName: string,
-  parameterData: ParameterDefinitionData,
-  utilities: SharedFunctionsParsingUtilities,
-): FunctionParameter {
-  try {
-    return utilities.createParameter(
-      parameterData.name,
-      parameterData.optional || false,
-    );
-  } catch (err) {
-    throw utilities.wrapError(
-      err,
-      `Failed to create parameter: ${parameterData.name} for function "${functionName}"`,
-    );
-  }
+    }, new FunctionParameterCollection());
 }
 
 function hasCode(data: FunctionData): data is CodeFunctionData {

src/application/Parser/Script/Compiler/ScriptCompiler.ts

@@ -1,11 +1,10 @@
 import type { FunctionData, ScriptData, CallInstruction } from '@/application/collections/';
 import type { IScriptCode } from '@/domain/IScriptCode';
+import { ScriptCode } from '@/domain/ScriptCode';
 import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
 import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
 import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
 import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { createScriptCode, type ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
 import { SharedFunctionsParser } from './Function/SharedFunctionsParser';
 import { FunctionCallSequenceCompiler } from './Function/Call/Compiler/FunctionCallSequenceCompiler';
 import { parseFunctionCalls } from './Function/Call/FunctionCallParser';
@@ -24,8 +23,6 @@ export class ScriptCompiler implements IScriptCompiler {
     sharedFunctionsParser: ISharedFunctionsParser = SharedFunctionsParser.instance,
     private readonly callCompiler: FunctionCallCompiler = FunctionCallSequenceCompiler.instance,
     private readonly codeValidator: ICodeValidator = CodeValidator.instance,
-    private readonly wrapError: ErrorWithContextWrapper = wrapErrorWithAdditionalContext,
-    private readonly scriptCodeFactory: ScriptCodeFactory = createScriptCode,
   ) {
     this.functions = sharedFunctionsParser.parseFunctions(functions, syntax);
   }
@@ -42,12 +39,12 @@ export class ScriptCompiler implements IScriptCompiler {
       const calls = parseFunctionCalls(script.call);
       const compiledCode = this.callCompiler.compileFunctionCalls(calls, this.functions);
       validateCompiledCode(compiledCode, this.codeValidator);
-      return this.scriptCodeFactory(
+      return new ScriptCode(
         compiledCode.code,
         compiledCode.revertCode,
       );
     } catch (error) {
-      throw this.wrapError(error, `Failed to compile script: ${script.name}`);
+      throw Error(`Script "${script.name}" ${error.message}`);
     }
   }
 }

src/application/Parser/Script/ScriptParser.ts

@@ -4,52 +4,37 @@ import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syn
 import { Script } from '@/domain/Script';
 import { RecommendationLevel } from '@/domain/RecommendationLevel';
 import type { IScriptCode } from '@/domain/IScriptCode';
+import { ScriptCode } from '@/domain/ScriptCode';
 import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
-import { wrapErrorWithAdditionalContext, type ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
-import { createScriptCode } from '@/domain/ScriptCodeFactory';
-import type { IScript } from '@/domain/IScript';
-import { parseDocs, type DocsParser } from '../DocumentationParser';
+import { parseDocs } from '../DocumentationParser';
 import { createEnumParser, type IEnumParser } from '../../Common/Enum';
-import { NodeDataType } from '../NodeValidation/NodeDataType';
-import { createNodeDataValidator, type NodeDataValidator, type NodeDataValidatorFactory } from '../NodeValidation/NodeDataValidator';
+import { NodeType } from '../NodeValidation/NodeType';
+import { NodeValidator } from '../NodeValidation/NodeValidator';
 import { CodeValidator } from './Validation/CodeValidator';
 import { NoDuplicatedLines } from './Validation/Rules/NoDuplicatedLines';
 import type { ICategoryCollectionParseContext } from './ICategoryCollectionParseContext';
 
-export interface ScriptParser {
-  (
-    data: ScriptData,
-    context: ICategoryCollectionParseContext,
-    utilities?: ScriptParserUtilities,
-  ): IScript;
-}
-
-export const parseScript: ScriptParser = (
-  data,
-  context,
-  utilities = DefaultScriptParserUtilities,
-) => {
-  const validator = utilities.createValidator({
-    type: NodeDataType.Script,
-    selfNode: data,
-  });
+export function parseScript(
+  data: ScriptData,
+  context: ICategoryCollectionParseContext,
+  levelParser = createEnumParser(RecommendationLevel),
+  scriptFactory: ScriptFactoryType = ScriptFactory,
+  codeValidator: ICodeValidator = CodeValidator.instance,
+): Script {
+  const validator = new NodeValidator({ type: NodeType.Script, selfNode: data });
   validateScript(data, validator);
   try {
-    const script = utilities.createScript({
-      name: data.name,
-      code: parseCode(data, context, utilities.codeValidator, utilities.createCode),
-      docs: utilities.parseDocs(data),
-      level: parseLevel(data.recommend, utilities.levelParser),
-    });
-    return script;
-  } catch (error) {
-    throw utilities.wrapError(
-      error,
-      validator.createContextualErrorMessage('Failed to parse script.'),
+    const script = scriptFactory(
+      /* name: */ data.name,
+      /* code: */ parseCode(data, context, codeValidator),
+      /* docs: */ parseDocs(data),
+      /* level: */ parseLevel(data.recommend, levelParser),
     );
+    return script;
+  } catch (err) {
+    return validator.throw(err.message);
   }
-};
+}
 
 function parseLevel(
   level: string | undefined,
@@ -65,19 +50,18 @@ function parseCode(
   script: ScriptData,
   context: ICategoryCollectionParseContext,
   codeValidator: ICodeValidator,
-  createCode: ScriptCodeFactory,
 ): IScriptCode {
   if (context.compiler.canCompile(script)) {
     return context.compiler.compile(script);
   }
   const codeScript = script as CodeScriptData; // Must be inline code if it cannot be compiled
-  const code = createCode(codeScript.code, codeScript.revertCode);
+  const code = new ScriptCode(codeScript.code, codeScript.revertCode);
   validateHardcodedCodeWithoutCalls(code, codeValidator, context.syntax);
   return code;
 }
 
 function validateHardcodedCodeWithoutCalls(
-  scriptCode: IScriptCode,
+  scriptCode: ScriptCode,
   validator: ICodeValidator,
   syntax: ILanguageSyntax,
 ) {
@@ -93,48 +77,25 @@ function validateHardcodedCodeWithoutCalls(
 
 function validateScript(
   script: ScriptData,
-  validator: NodeDataValidator,
+  validator: NodeValidator,
 ): asserts script is NonNullable<ScriptData> {
-  validator.assertDefined(script);
-  validator.assertValidName(script.name);
-  validator.assert(
-    () => Boolean((script as CodeScriptData).code || (script as CallScriptData).call),
-    'Neither "call" or "code" is defined.',
-  );
-  validator.assert(
-    () => !((script as CodeScriptData).code && (script as CallScriptData).call),
-    'Both "call" and "code" are defined.',
-  );
-  validator.assert(
-    () => !((script as CodeScriptData).revertCode && (script as CallScriptData).call),
-    'Both "call" and "revertCode" are defined.',
-  );
+  validator
+    .assertDefined(script)
+    .assertValidName(script.name)
+    .assert(
+      () => Boolean((script as CodeScriptData).code || (script as CallScriptData).call),
+      'Neither "call" or "code" is defined.',
+    )
+    .assert(
+      () => !((script as CodeScriptData).code && (script as CallScriptData).call),
+      'Both "call" and "code" are defined.',
+    )
+    .assert(
+      () => !((script as CodeScriptData).revertCode && (script as CallScriptData).call),
+      'Both "call" and "revertCode" are defined.',
+    );
 }
 
-interface ScriptParserUtilities {
-  readonly levelParser: IEnumParser<RecommendationLevel>;
-  readonly createScript: ScriptFactory;
-  readonly codeValidator: ICodeValidator;
-  readonly wrapError: ErrorWithContextWrapper;
-  readonly createValidator: NodeDataValidatorFactory;
-  readonly createCode: ScriptCodeFactory;
-  readonly parseDocs: DocsParser;
-}
+export type ScriptFactoryType = (...parameters: ConstructorParameters<typeof Script>) => Script;
 
-export type ScriptFactory = (
-  ...parameters: ConstructorParameters<typeof Script>
-) => IScript;
-
-const createScript: ScriptFactory = (...parameters) => {
-  return new Script(...parameters);
-};
-
-const DefaultScriptParserUtilities: ScriptParserUtilities = {
-  levelParser: createEnumParser(RecommendationLevel),
-  createScript,
-  codeValidator: CodeValidator.instance,
-  wrapError: wrapErrorWithAdditionalContext,
-  createValidator: createNodeDataValidator,
-  createCode: createScriptCode,
-  parseDocs,
-};
+const ScriptFactory: ScriptFactoryType = (...parameters) => new Script(...parameters);

src/application/Parser/ScriptingDefinition/CodeSubstituter.ts

@@ -5,7 +5,6 @@ import { ExpressionsCompiler } from '@/application/Parser/Script/Compiler/Expres
 import type { ProjectDetails } from '@/domain/Project/ProjectDetails';
 import { FunctionCallArgumentCollection } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgumentCollection';
 import { FunctionCallArgument } from '@/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument';
-import type { IExpressionParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/IExpressionParser';
 import type { ICodeSubstituter } from './ICodeSubstituter';
 
 export class CodeSubstituter implements ICodeSubstituter {
@@ -30,9 +29,7 @@ export class CodeSubstituter implements ICodeSubstituter {
 }
 
 function createSubstituteCompiler(): IExpressionsCompiler {
-  const parsers: readonly IExpressionParser[] = [
-    new ParameterSubstitutionParser(),
-  ] as const;
+  const parsers = [new ParameterSubstitutionParser()];
   const parser = new CompositeExpressionParser(parsers);
   const expressionCompiler = new ExpressionsCompiler(parser);
   return expressionCompiler;

src/application/collections/linux.yaml

@@ -2072,8 +2072,8 @@ actions:
               [1]: https://web.archive.org/web/20221029165307/https://packages.fedoraproject.org/pkgs/zeitgeist/zeitgeist/index.html "zeitgeist - Fedora Packages | packages.fedoraproject.org"
               [2]: https://web.archive.org/web/20221029165603/https://archlinux.org/packages/extra/x86_64/zeitgeist/ "Arch Linux - zeitgeist 1.0.4-1 (x86_64) | archlinux.org"
               [3]: https://web.archive.org/web/20221029165609/https://packages.debian.org/search?keywords=zeitgeist-core "Debian -- Package Search Results -- zeitgeist-core | packages.debian.org"
-              [4]: https://web.archive.org/web/20221029165714/https://releases.ubuntu.com/xenial/ubuntu-16.04.6-desktop-i386.manifest "List of software packages shipped with Ubuntu 16.04.6 | releases.ubuntu.com"
-              [5]: https://web.archive.org/web/20221029165726/https://releases.ubuntu.com/18.04/ubuntu-18.04.6-desktop-amd64.manifest "List of software packages shipped with Ubuntu 18.04.6 | releases.ubuntu.com"
+              [4]: https://web.archive.org/web/20221029165714/https://releases.ubuntu.com/xenial/ubuntu-16.04.6-desktop-i386.manifest "List of sofware packags shipped with Ubuntu 16.04.6 | releases.ubuntu.com"
+              [5]: https://web.archive.org/web/20221029165726/https://releases.ubuntu.com/18.04/ubuntu-18.04.6-desktop-amd64.manifest "List of sofware packags shipped with Ubuntu 18.04.6 | releases.ubuntu.com"
               [6]: https://web.archive.org/web/20221029165821/https://bugs.archlinux.org/task/52326 "FS#52326 : [midori-gtk2] Please remove the zeitgeist dependency! | archlinux.org"
               [7]: https://web.archive.org/web/20221029165914/https://forum.artixlinux.org/index.php/topic,1432.0.html "Remove Unmaintained Zeitgeist (Spyware/Telemetry) from Default MATE installation | artixlinux.org"
               [8]: https://web.archive.org/web/20221029165902/https://askubuntu.com/questions/45548/disabling-zeitgeist/57487 "Disabling Zeitgeist - Ask Ubuntu | askubuntu.com"

src/application/collections/macos.yaml

@@ -1408,7 +1408,7 @@ actions:
                         name: Disable Gatekeeper
                         docs:
                             # References for spctl --master-disable
-                                - https://web.archive.org/web/20240523173608/https://www.manpagez.com/man/8/spctl/
+                                - https://www.manpagez.com/man/8/spctl/
                             # References for /var/db/SystemPolicy-prefs.plist
                                 - https://krypted.com/mac-security/manage-gatekeeper-from-the-command-line-in-mountain-lion/
                                 - https://community.jamf.com/t5/jamf-pro/users-can-t-change-password-greyed-out/m-p/54228

src/domain/Category.ts

@@ -5,21 +5,15 @@ import type { IScript } from './IScript';
 export class Category extends BaseEntity<number> implements ICategory {
   private allSubScripts?: ReadonlyArray<IScript> = undefined;
 
-  public readonly name: string;
-
-  public readonly docs: ReadonlyArray<string>;
-
-  public readonly subCategories: ReadonlyArray<ICategory>;
-
-  public readonly scripts: ReadonlyArray<IScript>;
-
-  constructor(parameters: CategoryInitParameters) {
-    super(parameters.id);
-    validateParameters(parameters);
-    this.name = parameters.name;
-    this.docs = parameters.docs;
-    this.subCategories = parameters.subcategories;
-    this.scripts = parameters.scripts;
+  constructor(
+    id: number,
+    public readonly name: string,
+    public readonly docs: ReadonlyArray<string>,
+    public readonly subCategories: ReadonlyArray<ICategory>,
+    public readonly scripts: ReadonlyArray<IScript>,
+  ) {
+    super(id);
+    validateCategory(this);
   }
 
   public includes(script: IScript): boolean {
@@ -34,14 +28,6 @@ export class Category extends BaseEntity<number> implements ICategory {
   }
 }
 
-export interface CategoryInitParameters {
-  readonly id: number;
-  readonly name: string;
-  readonly docs: ReadonlyArray<string>;
-  readonly subcategories: ReadonlyArray<ICategory>;
-  readonly scripts: ReadonlyArray<IScript>;
-}
-
 function parseScriptsRecursively(category: ICategory): ReadonlyArray<IScript> {
   return [
     ...category.scripts,
@@ -49,11 +35,11 @@ function parseScriptsRecursively(category: ICategory): ReadonlyArray<IScript> {
   ];
 }
 
-function validateParameters(parameters: CategoryInitParameters) {
-  if (!parameters.name) {
+function validateCategory(category: ICategory) {
+  if (!category.name) {
     throw new Error('missing name');
   }
-  if (parameters.subcategories.length === 0 && parameters.scripts.length === 0) {
+  if (category.subCategories.length === 0 && category.scripts.length === 0) {
     throw new Error('A category must have at least one sub-category or script');
   }
 }

src/domain/Script.ts

@@ -4,21 +4,14 @@ import type { IScript } from './IScript';
 import type { IScriptCode } from './IScriptCode';
 
 export class Script extends BaseEntity<string> implements IScript {
-  public readonly name: string;
-
-  public readonly code: IScriptCode;
-
-  public readonly docs: ReadonlyArray<string>;
-
-  public readonly level?: RecommendationLevel;
-
-  constructor(parameters: ScriptInitParameters) {
-    super(parameters.name);
-    this.name = parameters.name;
-    this.code = parameters.code;
-    this.docs = parameters.docs;
-    this.level = parameters.level;
-    validateLevel(parameters.level);
+  constructor(
+    public readonly name: string,
+    public readonly code: IScriptCode,
+    public readonly docs: ReadonlyArray<string>,
+    public readonly level?: RecommendationLevel,
+  ) {
+    super(name);
+    validateLevel(level);
   }
 
   public canRevert(): boolean {
@@ -26,13 +19,6 @@ export class Script extends BaseEntity<string> implements IScript {
   }
 }
 
-export interface ScriptInitParameters {
-  readonly name: string;
-  readonly code: IScriptCode;
-  readonly docs: ReadonlyArray<string>;
-  readonly level?: RecommendationLevel;
-}
-
 function validateLevel(level?: RecommendationLevel) {
   if (level !== undefined && !(level in RecommendationLevel)) {
     throw new Error(`invalid level: ${level}`);

src/domain/ScriptCodeFactory.ts

@@ -1,10 +0,0 @@
-import { ScriptCode } from './ScriptCode';
-import type { IScriptCode } from './IScriptCode';
-
-export interface ScriptCodeFactory {
-  (
-    ...args: ConstructorParameters<typeof ScriptCode>
-  ): IScriptCode;
-}
-
-export const createScriptCode: ScriptCodeFactory = (...args) => new ScriptCode(...args);

src/presentation/components/Scripts/View/Cards/CardExpansionPanel.vue

@@ -1,91 +0,0 @@
-<template>
-  <div>
-    <CardExpansionArrow />
-    <div class="card__expander">
-      <div class="card__expander__close-button">
-        <FlatButton
-          icon="xmark"
-          @click="collapse()"
-        />
-      </div>
-      <div class="card__expander__content">
-        <ScriptsTree
-          :category-id="categoryId"
-          :has-top-padding="false"
-        />
-      </div>
-    </div>
-  </div>
-</template>
-
-<script lang="ts">
-import {
-  defineComponent,
-} from 'vue';
-import FlatButton from '@/presentation/components/Shared/FlatButton.vue';
-import ScriptsTree from '@/presentation/components/Scripts/View/Tree/ScriptsTree.vue';
-import CardExpansionArrow from './CardExpansionArrow.vue';
-
-export default defineComponent({
-  components: {
-    ScriptsTree,
-    FlatButton,
-    CardExpansionArrow,
-  },
-  props: {
-    categoryId: {
-      type: Number,
-      required: true,
-    },
-  },
-  emits: {
-    /* eslint-disable @typescript-eslint/no-unused-vars */
-    onCollapse: () => true,
-    /* eslint-enable @typescript-eslint/no-unused-vars */
-  },
-  setup(_, { emit }) {
-    function collapse() {
-      emit('onCollapse');
-    }
-
-    return {
-      collapse,
-    };
-  },
-});
-</script>
-
-<style scoped lang="scss">
-@use "@/presentation/assets/styles/main" as *;
-@use "./card-gap" as *;
-
-.card__expander {
-  position: relative;
-  background-color: $color-primary-darker;
-  color: $color-on-primary;
-  margin-top: $spacing-absolute-xx-large;
-
-  display: flex;
-  align-items: center;
-  flex-direction: column;
-
-  .card__expander__content {
-    display: flex;
-    justify-content: center;
-    word-break: break-word;
-    max-width: 100%; // Prevents horizontal expansion of inner content (e.g., when a code block is shown)
-    width: 100%; // Expands the container to fill available horizontal space, enabling alignment of child items.
-  }
-
-  .card__expander__close-button {
-    font-size: $font-size-absolute-large;
-    align-self: flex-end;
-    margin-right: $spacing-absolute-small;
-    @include clickable;
-    color: $color-primary-light;
-    @include hover-or-touch {
-      color: $color-primary;
-    }
-  }
-}
-</style>

src/presentation/components/Scripts/View/Cards/CardList.vue

@@ -7,9 +7,9 @@
         <!-- <div id="responsivity-debug">
           Width: {{ width || 'undefined' }}
           Size:
-          <span v-if="width <= 500">small</span>
-          <span v-if="width > 500 && width < 750">medium</span>
-          <span v-if="width >= 750">big</span>
+            <span v-if="width <= 500">small</span>
+            <span v-if="width > 500 && width < 750">medium</span>
+            <span v-if="width >= 750">big</span>
         </div> -->
         <div
           v-if="categoryIds.length > 0"
@@ -27,7 +27,6 @@
             :data-category="categoryId"
             :category-id="categoryId"
             :active-category-id="activeCategoryId"
-            :card-layout="cardLayout"
             @card-expansion-changed="onSelected(categoryId, $event)"
           />
         </div>
@@ -47,7 +46,6 @@ import { injectKey } from '@/presentation/injectionSymbols';
 import SizeObserver from '@/presentation/components/Shared/SizeObserver.vue';
 import { hasDirective } from './NonCollapsingDirective';
 import CardListItem from './CardListItem.vue';
-import { useCardLayout } from './UseCardLayout';
 
 export default defineComponent({
   components: {
@@ -63,14 +61,8 @@ export default defineComponent({
     const categoryIds = computed<readonly number[]>(
       () => currentState.value.collection.actions.map((category) => category.id),
     );
-
     const activeCategoryId = ref<number | undefined>(undefined);
 
-    const cardLayout = useCardLayout({
-      containerWidth: computed(() => width.value ?? 0),
-      totalCards: computed(() => categoryIds.value.length),
-    });
-
     function onSelected(categoryId: number, isExpanded: boolean) {
       activeCategoryId.value = isExpanded ? categoryId : undefined;
     }
@@ -109,7 +101,6 @@ export default defineComponent({
       width,
       categoryIds,
       activeCategoryId,
-      cardLayout,
       onSelected,
     };
   },

src/presentation/components/Scripts/View/Cards/CardListItem.vue

@@ -29,12 +29,26 @@
       />
     </div>
     <CardExpandTransition>
-      <CardExpansionPanel
-        v-show="isExpanded"
-        :category-id="categoryId"
-        @on-collapse="collapse"
-        @click.stop
-      />
+      <div v-show="isExpanded">
+        <CardExpansionArrow />
+        <div
+          class="card__expander"
+          @click.stop
+        >
+          <div class="card__expander__close-button">
+            <FlatButton
+              icon="xmark"
+              @click="collapse()"
+            />
+          </div>
+          <div class="card__expander__content">
+            <ScriptsTree
+              :category-id="categoryId"
+              :has-top-padding="false"
+            />
+          </div>
+        </div>
+      </div>
     </CardExpandTransition>
   </div>
 </template>
@@ -42,32 +56,30 @@
 <script lang="ts">
 import {
   defineComponent, computed, shallowRef,
-  type PropType,
 } from 'vue';
 import AppIcon from '@/presentation/components/Shared/Icon/AppIcon.vue';
+import FlatButton from '@/presentation/components/Shared/FlatButton.vue';
 import { injectKey } from '@/presentation/injectionSymbols';
+import ScriptsTree from '@/presentation/components/Scripts/View/Tree/ScriptsTree.vue';
 import { sleep } from '@/infrastructure/Threading/AsyncSleep';
 import CardSelectionIndicator from './CardSelectionIndicator.vue';
 import CardExpandTransition from './CardExpandTransition.vue';
-import CardExpansionPanel from './CardExpansionPanel.vue';
-import type { CardLayout } from './UseCardLayout';
+import CardExpansionArrow from './CardExpansionArrow.vue';
 
 export default defineComponent({
   components: {
+    ScriptsTree,
     AppIcon,
     CardSelectionIndicator,
-    CardExpansionPanel,
+    FlatButton,
     CardExpandTransition,
+    CardExpansionArrow,
   },
   props: {
     categoryId: {
       type: Number,
       required: true,
     },
-    cardLayout: {
-      type: Object as PropType<CardLayout>,
-      required: true,
-    },
     activeCategoryId: {
       type: Number,
       default: undefined,
@@ -117,7 +129,6 @@ export default defineComponent({
       cardTitle,
       isExpanded,
       cardElement,
-      totalColumns: props.cardLayout.totalColumns,
       collapse,
     };
   },
@@ -130,6 +141,7 @@ export default defineComponent({
 @use "./card-gap" as *;
 
 $card-inner-padding     : $spacing-absolute-xx-large;
+$expanded-margin-top    : $spacing-absolute-xx-large;
 $card-horizontal-gap    : $card-gap;
 
 .card {
@@ -178,13 +190,44 @@ $card-horizontal-gap    : $card-gap;
       font-size: $font-size-absolute-normal;
     }
   }
+  .card__expander {
+    position: relative;
+    background-color: $color-primary-darker;
+    color: $color-on-primary;
+
+    display: flex;
+    align-items: center;
+    flex-direction: column;
+
+    .card__expander__content {
+      display: flex;
+      justify-content: center;
+      word-break: break-word;
+      max-width: 100%; // Prevents horizontal expansion of inner content (e.g., when a code block is shown)
+      width: 100%; // Expands the container to fill available horizontal space, enabling alignment of child items.
+    }
+
+    .card__expander__close-button {
+      font-size: $font-size-absolute-large;
+      align-self: flex-end;
+      margin-right: $spacing-absolute-small;
+      @include clickable;
+      color: $color-primary-light;
+      @include hover-or-touch {
+        color: $color-primary;
+      }
+    }
+  }
 
   &.is-expanded {
     .card__inner {
       height: auto;
       background-color: $color-secondary;
       color: $color-on-secondary;
-      margin-bottom: $spacing-absolute-xx-large;
+    }
+
+    .card__expander {
+      margin-top: $expanded-margin-top;
     }
 
     @include hover-or-touch {
@@ -210,32 +253,36 @@ $card-horizontal-gap    : $card-gap;
     }
   }
 }
-
-.card {
-  $total-columns: v-bind(totalColumns);
-  $total-times-gap-is-used-in-row: calc($total-columns - 1);
-  $total-gap-width-in-row: calc($total-times-gap-is-used-in-row * $card-horizontal-gap);
-  $available-row-width-for-cards: calc(100% - #{$total-gap-width-in-row});
-  $available-width-per-card: calc(#{$available-row-width-for-cards} / $total-columns);
-  width:$available-width-per-card;
-  :deep(.card__expander) {
-    $all-cards-width: calc(100% * $total-columns);
-    $additional-padding-width: calc($card-horizontal-gap * ($total-columns - 1));
-    width: calc(#{$all-cards-width} + #{$additional-padding-width});
-  }
-  // @for $nth-card from 2 through $total-columns { // From second card to rest
-  //   &:nth-of-type(#{$total-columns}n+#{$nth-card}) {
-  //     :deep(.card__expander) {
-  //       $card-left: -100% * ($nth-card - 1);
-  //       $additional-space: $card-horizontal-gap * ($nth-card - 1);
-  //       margin-left: calc(#{$card-left} - #{$additional-space});
-  //     }
-  //   }
-  // }
-  // Ensure new line after last row
-  $card-after-last: $total-columns + 1;
-  &:nth-of-type(#{$total-columns}n+#{$card-after-last}) {
-    clear: left;
+@mixin adaptive-card($cards-in-row) {
+  &.card {
+    $total-times-gap-is-used-in-row: $cards-in-row - 1;
+    $total-gap-width-in-row: $total-times-gap-is-used-in-row * $card-horizontal-gap;
+    $available-row-width-for-cards: calc(100% - #{$total-gap-width-in-row});
+    $available-width-per-card: calc(#{$available-row-width-for-cards} / #{$cards-in-row});
+    width:$available-width-per-card;
+    .card__expander {
+      $all-cards-width: 100% * $cards-in-row;
+      $additional-padding-width: $card-horizontal-gap * ($cards-in-row - 1);
+      width: calc(#{$all-cards-width} + #{$additional-padding-width});
+    }
+    @for $nth-card from 2 through $cards-in-row { // From second card to rest
+      &:nth-of-type(#{$cards-in-row}n+#{$nth-card}) {
+        .card__expander {
+          $card-left: -100% * ($nth-card - 1);
+          $additional-space: $card-horizontal-gap * ($nth-card - 1);
+          margin-left: calc(#{$card-left} - #{$additional-space});
+        }
+      }
+    }
+    // Ensure new line after last row
+    $card-after-last: $cards-in-row + 1;
+    &:nth-of-type(#{$cards-in-row}n+#{$card-after-last}) {
+      clear: left;
+    }
   }
 }
+
+.big-screen     {   @include adaptive-card(3);  }
+.medium-screen  {   @include adaptive-card(2);  }
+.small-screen   {   @include adaptive-card(1);  }
 </style>

src/presentation/components/Scripts/View/Cards/UseCardLayout.ts

@@ -1,68 +0,0 @@
-import { computed, type Ref } from 'vue';
-
-export function useCardLayout(options: {
-  readonly containerWidth: Readonly<Ref<number>>;
-  readonly totalCards: Readonly<Ref<number>>;
-}): Readonly<Ref<CardLayout>> {
-  return computed(() => {
-    return determineCardLayout(
-      options.containerWidth.value,
-      options.totalCards.value,
-    );
-  });
-}
-
-export interface CardLayout {
-  readonly totalRows: number;
-  readonly totalColumns: number;
-  readonly availableCardWidth: number;
-}
-
-function determineCardLayout(
-  containerWidth: number,
-  totalCards: number,
-): CardLayout {
-  const containerSize = getContainerSize(containerWidth);
-  const totalColumns = countTotalColumns(containerSize);
-  const totalRows = countTotalRows(totalColumns, totalCards);
-  return {
-    totalColumns,
-    totalRows,
-    availableCardWidth: containerWidth / totalRows,
-  };
-}
-
-enum ContainerSize {
-  Small,
-  Medium,
-  Big,
-}
-
-function countTotalRows(totalColumns: number, totalCards: number): number {
-  return Math.ceil(totalCards / totalColumns);
-}
-
-function countTotalColumns(size: ContainerSize): number {
-  switch (size) {
-    case ContainerSize.Small:
-      return 1;
-    case ContainerSize.Medium:
-      return 2;
-    case ContainerSize.Big:
-      return 3;
-    default:
-      throw new Error(`Unknown size: ${size}`);
-  }
-}
-
-function getContainerSize(containerWidth: number): ContainerSize {
-  const smallBreakpoint = 500;
-  const bigBreakpoint = 750;
-  if (containerWidth <= smallBreakpoint) {
-    return ContainerSize.Small;
-  }
-  if (containerWidth < bigBreakpoint) {
-    return ContainerSize.Medium;
-  }
-  return ContainerSize.Big;
-}

tests/unit/application/Parser/CategoryParser.spec.ts

@@ -1,395 +1,258 @@
 import { describe, it, expect } from 'vitest';
 import type { CategoryData, CategoryOrScriptData } from '@/application/collections/';
-import { type CategoryFactory, parseCategory } from '@/application/Parser/CategoryParser';
-import { type ScriptParser } from '@/application/Parser/Script/ScriptParser';
-import { type DocsParser } from '@/application/Parser/DocumentationParser';
+import { type CategoryFactoryType, parseCategory } from '@/application/Parser/CategoryParser';
+import { parseScript } from '@/application/Parser/Script/ScriptParser';
+import { parseDocs } from '@/application/Parser/DocumentationParser';
+import { ScriptCompilerStub } from '@tests/unit/shared/Stubs/ScriptCompilerStub';
 import { CategoryCollectionParseContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionParseContextStub';
+import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
 import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
-import { getAbsentCollectionTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
+import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
+import { expectThrowsNodeError, type ITestScenario, NodeValidationTestRunner } from '@tests/unit/application/Parser/NodeValidation/NodeValidatorTestRunner';
 import type { ICategoryCollectionParseContext } from '@/application/Parser/Script/ICategoryCollectionParseContext';
-import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { ErrorWrapperStub } from '@tests/unit/shared/Stubs/ErrorWrapperStub';
-import type { NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import { NodeDataValidatorStub, createNodeDataValidatorFactoryStub } from '@tests/unit/shared/Stubs/NodeDataValidatorStub';
-import type { CategoryNodeErrorContext, UnknownNodeErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
-import { createCategoryFactorySpy } from '@tests/unit/shared/Stubs/CategoryFactoryStub';
-import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
-import { ScriptParserStub } from '@tests/unit/shared/Stubs/ScriptParserStub';
-import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
-import { indentText } from '@tests/shared/Text';
-import { itThrowsContextualError } from './ContextualErrorTester';
-import { itValidatesName, itValidatesDefinedData, itAsserts } from './NodeDataValidationTester';
-import { generateDataValidationTestScenarios } from './DataValidationTestScenarioGenerator';
+import { Category } from '@/domain/Category';
+import { createScriptDataWithCall, createScriptDataWithCode, createScriptDataWithoutCallOrCodes } from '@tests/unit/shared/Stubs/ScriptDataStub';
 
 describe('CategoryParser', () => {
   describe('parseCategory', () => {
-    describe('validation', () => {
-      describe('validates for name', () => {
-        // arrange
-        const expectedName = 'expected category name to be validated';
-        const category = new CategoryDataStub()
-          .withName(expectedName);
-        const expectedContext: CategoryNodeErrorContext = {
-          type: NodeDataType.Category,
-          selfNode: category,
-        };
-        itValidatesName((validatorFactory) => {
-          // act
-          new TestBuilder()
-            .withData(category)
-            .withValidatorFactory(validatorFactory)
-            .parseCategory();
-          // assert
-          return {
-            expectedNameToValidate: expectedName,
-            expectedErrorContext: expectedContext,
-          };
-        });
-      });
-      describe('validates for defined data', () => {
-        // arrange
-        const category = new CategoryDataStub();
-        const expectedContext: CategoryNodeErrorContext = {
-          type: NodeDataType.Category,
-          selfNode: category,
-        };
-        itValidatesDefinedData(
-          (validatorFactory) => {
-            // act
-            new TestBuilder()
-              .withData(category)
-              .withValidatorFactory(validatorFactory)
-              .parseCategory();
-            // assert
-            return {
-              expectedDataToValidate: category,
-              expectedErrorContext: expectedContext,
-            };
-          },
-        );
-      });
-      describe('validates that category has some children', () => {
-        const categoryName = 'test';
-        const testScenarios = generateDataValidationTestScenarios<CategoryData>({
-          expectFail: getAbsentCollectionTestCases<CategoryOrScriptData>().map(({
-            valueName, absentValue: absentCollectionValue,
-          }) => ({
-            description: `with \`${valueName}\` value as children`,
-            data: new CategoryDataStub()
-              .withName(categoryName)
-              .withChildren(absentCollectionValue as unknown as CategoryOrScriptData[]),
-          })),
-          expectPass: [{
-            description: 'has single children',
-            data: new CategoryDataStub()
-              .withName(categoryName)
-              .withChildren([createScriptDataWithCode()]),
-          }],
-        });
-        testScenarios.forEach(({
-          description, expectedPass, data: categoryData,
-        }) => {
-          describe(description, () => {
-            itAsserts({
-              expectedConditionResult: expectedPass,
-              test: (validatorFactory) => {
-                const expectedMessage = `"${categoryName}" has no children.`;
-                const expectedContext: CategoryNodeErrorContext = {
-                  type: NodeDataType.Category,
-                  selfNode: categoryData,
-                };
-                // act
-                try {
-                  new TestBuilder()
-                    .withData(categoryData)
-                    .withValidatorFactory(validatorFactory)
-                    .parseCategory();
-                } catch { /* It may throw due to assertions not being evaluated */ }
-                // assert
-                return {
-                  expectedErrorMessage: expectedMessage,
-                  expectedErrorContext: expectedContext,
-                };
-              },
+    describe('invalid category data', () => {
+      describe('validates script data', () => {
+        describe('satisfies shared node tests', () => {
+          new NodeValidationTestRunner()
+            .testInvalidNodeName((invalidName) => {
+              return createTest(
+                new CategoryDataStub().withName(invalidName),
+              );
+            })
+            .testMissingNodeData((node) => {
+              return createTest(node as CategoryData);
             });
-          });
         });
-      });
-      describe('validates that a child is a category or a script', () => {
-        // arrange
-        const testScenarios = generateDataValidationTestScenarios<CategoryOrScriptData>({
-          expectFail: [{
-            description: 'child has incorrect properties',
-            data: { property: 'non-empty-value' } as unknown as CategoryOrScriptData,
-          }],
-          expectPass: [
-            {
-              description: 'child is a category',
-              data: new CategoryDataStub(),
-            },
-            {
-              description: 'child is a script with call',
-              data: createScriptDataWithCall(),
-            },
-            {
-              description: 'child is a script with code',
-              data: createScriptDataWithCode(),
-            },
-          ],
+        describe('throws when category children is absent', () => {
+          itEachAbsentCollectionValue<CategoryOrScriptData>((absentValue) => {
+            // arrange
+            const categoryName = 'test';
+            const expectedMessage = `"${categoryName}" has no children.`;
+            const category = new CategoryDataStub()
+              .withName(categoryName)
+              .withChildren(absentValue);
+            // act
+            const test = createTest(category);
+            // assert
+            expectThrowsNodeError(test, expectedMessage);
+          }, { excludeUndefined: true, excludeNull: true });
         });
-        testScenarios.forEach(({
-          description, expectedPass, data: childData,
-        }) => {
-          describe(description, () => {
-            itAsserts({
-              expectedConditionResult: expectedPass,
-              test: (validatorFactory) => {
-                const expectedError = 'Node is neither a category or a script.';
-                const parent = new CategoryDataStub()
-                  .withName('parent')
-                  .withChildren([new CategoryDataStub().withName('valid child'), childData]);
-                const expectedContext: UnknownNodeErrorContext = {
-                  selfNode: childData,
-                  parentNode: parent,
-                };
+        describe('throws when category child is missing', () => {
+          new NodeValidationTestRunner()
+            .testMissingNodeData((missingNode) => {
+              // arrange
+              const invalidChildNode = missingNode;
+              const parent = new CategoryDataStub()
+                .withName('parent')
+                .withChildren([new CategoryDataStub().withName('valid child'), invalidChildNode]);
+              return ({
                 // act
-                new TestBuilder()
+                act: () => new TestBuilder()
                   .withData(parent)
-                  .withValidatorFactory(validatorFactory)
-                  .parseCategory();
+                  .parseCategory(),
                 // assert
-                return {
-                  expectedErrorMessage: expectedError,
-                  expectedErrorContext: expectedContext,
-                };
+                expectedContext: {
+                  selfNode: invalidChildNode,
+                  parentNode: parent,
+                },
+              });
+            });
+        });
+        it('throws when node is neither a category or a script', () => {
+          // arrange
+          const expectedError = 'Node is neither a category or a script.';
+          const invalidChildNode = { property: 'non-empty-value' } as never as CategoryOrScriptData;
+          const parent = new CategoryDataStub()
+            .withName('parent')
+            .withChildren([new CategoryDataStub().withName('valid child'), invalidChildNode]);
+          // act
+          const test: ITestScenario = {
+            // act
+            act: () => new TestBuilder()
+              .withData(parent)
+              .parseCategory(),
+            // assert
+            expectedContext: {
+              selfNode: invalidChildNode,
+              parentNode: parent,
+            },
+          };
+          // assert
+          expectThrowsNodeError(test, expectedError);
+        });
+        describe('throws when category child is invalid category', () => {
+          new NodeValidationTestRunner().testInvalidNodeName((invalidName) => {
+            // arrange
+            const invalidChildNode = new CategoryDataStub()
+              .withName(invalidName);
+            const parent = new CategoryDataStub()
+              .withName('parent')
+              .withChildren([new CategoryDataStub().withName('valid child'), invalidChildNode]);
+            return ({
+              // act
+              act: () => new TestBuilder()
+                .withData(parent)
+                .parseCategory(),
+              // assert
+              expectedContext: {
+                type: NodeType.Category,
+                selfNode: invalidChildNode,
+                parentNode: parent,
               },
             });
           });
         });
-      });
-      describe('validates children recursively', () => {
-        describe('validates (1th-level) child data', () => {
-          // arrange
-          const expectedName = 'child category';
-          const child = new CategoryDataStub()
-            .withName(expectedName);
-          const parent = new CategoryDataStub()
-            .withName('parent')
-            .withChildren([child]);
-          const expectedContext: UnknownNodeErrorContext = {
-            selfNode: child,
-            parentNode: parent,
-          };
-          itValidatesDefinedData(
-            (validatorFactory) => {
-              // act
-              new TestBuilder()
-                .withData(parent)
-                .withValidatorFactory(validatorFactory)
-                .parseCategory();
-              // assert
-              return {
-                expectedDataToValidate: child,
-                expectedErrorContext: expectedContext,
-              };
+        function createTest(category: CategoryData): ITestScenario {
+          return {
+            act: () => new TestBuilder()
+              .withData(category)
+              .parseCategory(),
+            expectedContext: {
+              type: NodeType.Category,
+              selfNode: category,
             },
-          );
-        });
-        describe('validates that (2nd-level) child name', () => {
-          // arrange
-          const expectedName = 'grandchild category';
-          const grandChild = new CategoryDataStub()
-            .withName(expectedName);
-          const child = new CategoryDataStub()
-            .withChildren([grandChild])
-            .withName('child category');
-          const parent = new CategoryDataStub()
-            .withName('parent')
-            .withChildren([child]);
-          const expectedContext: CategoryNodeErrorContext = {
-            type: NodeDataType.Category,
-            selfNode: grandChild,
-            parentNode: child,
           };
-          itValidatesName((validatorFactory) => {
-            // act
-            new TestBuilder()
-              .withData(parent)
-              .withValidatorFactory(validatorFactory)
-              .parseCategory();
-            // assert
-            return {
-              expectedNameToValidate: expectedName,
-              expectedErrorContext: expectedContext,
-            };
-          });
-        });
+        }
+      });
+      it(`rethrows exception if ${Category.name} cannot be constructed`, () => {
+        // arrange
+        const expectedError = 'category creation failed';
+        const factoryMock: CategoryFactoryType = () => { throw new Error(expectedError); };
+        const data = new CategoryDataStub();
+        // act
+        const act = () => new TestBuilder()
+          .withData(data)
+          .withFactory(factoryMock)
+          .parseCategory();
+        // expect
+        expectThrowsNodeError({
+          act,
+          expectedContext: {
+            type: NodeType.Category,
+            selfNode: data,
+          },
+        }, expectedError);
       });
     });
-    describe('rethrows exception if category factory fails', () => {
-      // arrange
-      const givenData = new CategoryDataStub();
-      const expectedContextMessage = 'Failed to parse category.';
-      const expectedError = new Error();
-      // act & assert
-      itThrowsContextualError({
-        throwingAction: (wrapError) => {
-          const validatorStub = new NodeDataValidatorStub();
-          validatorStub.createContextualErrorMessage = (message) => message;
-          const factoryMock: CategoryFactory = () => {
-            throw expectedError;
-          };
-          new TestBuilder()
-            .withCategoryFactory(factoryMock)
-            .withValidatorFactory(() => validatorStub)
-            .withErrorWrapper(wrapError)
-            .withData(givenData)
-            .parseCategory();
-        },
-        expectedWrappedError: expectedError,
-        expectedContextMessage,
-      });
-    });
-    it('parses docs correctly', () => {
+    it('returns expected docs', () => {
       // arrange
       const url = 'https://privacy.sexy';
-      const categoryData = new CategoryDataStub()
+      const expected = parseDocs({ docs: url });
+      const category = new CategoryDataStub()
         .withDocs(url);
-      const parseDocs: DocsParser = (data) => {
-        return [
-          `parsed docs: ${JSON.stringify(data)}`,
-        ];
-      };
-      const expectedDocs = parseDocs(categoryData);
-      const { categoryFactorySpy, getInitParameters } = createCategoryFactorySpy();
       // act
-      const actualCategory = new TestBuilder()
-        .withData(categoryData)
-        .withCategoryFactory(categoryFactorySpy)
-        .withDocsParser(parseDocs)
-        .parseCategory();
+      const actual = new TestBuilder()
+        .withData(category)
+        .parseCategory()
+        .docs;
       // assert
-      const actualDocs = getInitParameters(actualCategory)?.docs;
-      expect(actualDocs).to.deep.equal(expectedDocs);
+      expect(actual).to.deep.equal(expected);
     });
     describe('parses expected subscript', () => {
-      it('parses single script correctly', () => {
+      it('single script with code', () => {
         // arrange
-        const expectedScript = new ScriptStub('expected script');
-        const scriptParser = new ScriptParserStub();
-        const childScriptData = createScriptDataWithCode();
-        const categoryData = new CategoryDataStub()
-          .withChildren([childScriptData]);
-        scriptParser.setupParsedResultForData(childScriptData, expectedScript);
-        const { categoryFactorySpy, getInitParameters } = createCategoryFactorySpy();
+        const script = createScriptDataWithCode();
+        const context = new CategoryCollectionParseContextStub();
+        const expected = [parseScript(script, context)];
+        const category = new CategoryDataStub()
+          .withChildren([script]);
         // act
-        const actualCategory = new TestBuilder()
-          .withData(categoryData)
-          .withScriptParser(scriptParser.get())
-          .withCategoryFactory(categoryFactorySpy)
-          .parseCategory();
+        const actual = new TestBuilder()
+          .withData(category)
+          .withContext(context)
+          .parseCategory()
+          .scripts;
         // assert
-        const actualScripts = getInitParameters(actualCategory)?.scripts;
-        expectExists(actualScripts);
-        expect(actualScripts).to.have.lengthOf(1);
-        const actualScript = actualScripts[0];
-        expect(actualScript).to.equal(expectedScript);
+        expect(actual).to.deep.equal(expected);
       });
-      it('parses multiple scripts correctly', () => {
+      it('single script with function call', () => {
         // arrange
-        const expectedScripts = [
-          new ScriptStub('expected-first-script'),
-          new ScriptStub('expected-second-script'),
-        ];
-        const childrenData = [
-          createScriptDataWithCall(),
-          createScriptDataWithCode(),
-        ];
-        const scriptParser = new ScriptParserStub();
-        childrenData.forEach((_, index) => {
-          scriptParser.setupParsedResultForData(childrenData[index], expectedScripts[index]);
-        });
-        const categoryData = new CategoryDataStub()
-          .withChildren(childrenData);
-        const { categoryFactorySpy, getInitParameters } = createCategoryFactorySpy();
+        const script = createScriptDataWithCall();
+        const compiler = new ScriptCompilerStub()
+          .withCompileAbility(script);
+        const context = new CategoryCollectionParseContextStub()
+          .withCompiler(compiler);
+        const expected = [parseScript(script, context)];
+        const category = new CategoryDataStub()
+          .withChildren([script]);
         // act
-        const actualCategory = new TestBuilder()
-          .withScriptParser(scriptParser.get())
-          .withData(categoryData)
-          .withCategoryFactory(categoryFactorySpy)
-          .parseCategory();
+        const actual = new TestBuilder()
+          .withData(category)
+          .withContext(context)
+          .parseCategory()
+          .scripts;
         // assert
-        const actualParsedScripts = getInitParameters(actualCategory)?.scripts;
-        expectExists(actualParsedScripts);
-        expect(actualParsedScripts.length).to.equal(expectedScripts.length);
-        expect(actualParsedScripts).to.have.members(expectedScripts);
+        expect(actual).to.deep.equal(expected);
       });
-      it('parses all scripts with correct context', () => {
+      it('multiple scripts with function call and code', () => {
         // arrange
-        const expectedParseContext = new CategoryCollectionParseContextStub();
-        const scriptParser = new ScriptParserStub();
-        const childrenData = [
-          createScriptDataWithCode(),
-          createScriptDataWithCode(),
-          createScriptDataWithCode(),
-        ];
-        const categoryData = new CategoryDataStub()
-          .withChildren(childrenData);
-        const { categoryFactorySpy, getInitParameters } = createCategoryFactorySpy();
+        const callableScript = createScriptDataWithCall();
+        const scripts = [callableScript, createScriptDataWithCode()];
+        const category = new CategoryDataStub()
+          .withChildren(scripts);
+        const compiler = new ScriptCompilerStub()
+          .withCompileAbility(callableScript);
+        const context = new CategoryCollectionParseContextStub()
+          .withCompiler(compiler);
+        const expected = scripts.map((script) => parseScript(script, context));
         // act
-        const actualCategory = new TestBuilder()
-          .withData(categoryData)
-          .withContext(expectedParseContext)
-          .withScriptParser(scriptParser.get())
-          .withCategoryFactory(categoryFactorySpy)
-          .parseCategory();
+        const actual = new TestBuilder()
+          .withData(category)
+          .withContext(context)
+          .parseCategory()
+          .scripts;
         // assert
-        const actualParsedScripts = getInitParameters(actualCategory)?.scripts;
-        expectExists(actualParsedScripts);
-        const actualParseContexts = actualParsedScripts.map(
-          (s) => scriptParser.getParseParameters(s)[1],
-        );
-        expect(
-          actualParseContexts.every(
-            (actualParseContext) => actualParseContext === expectedParseContext,
-          ),
-          formatAssertionMessage([
-            `Expected all elements to be ${JSON.stringify(expectedParseContext)}`,
-            'All elements:',
-            indentText(JSON.stringify(actualParseContexts)),
-          ]),
-        ).to.equal(true);
+        expect(actual).to.deep.equal(expected);
+      });
+      it('script is created with right context', () => { // test through script validation logic
+        // arrange
+        const commentDelimiter = 'should not throw';
+        const duplicatedCode = `${commentDelimiter} duplicate-line\n${commentDelimiter} duplicate-line`;
+        const parseContext = new CategoryCollectionParseContextStub()
+          .withSyntax(new LanguageSyntaxStub().withCommentDelimiters(commentDelimiter));
+        const category = new CategoryDataStub()
+          .withChildren([
+            new CategoryDataStub()
+              .withName('sub-category')
+              .withChildren([
+                createScriptDataWithoutCallOrCodes()
+                  .withCode(duplicatedCode),
+              ]),
+          ]);
+        // act
+        const act = () => new TestBuilder()
+          .withData(category)
+          .withContext(parseContext)
+          .parseCategory()
+          .scripts;
+        // assert
+        expect(act).to.not.throw();
       });
     });
     it('returns expected subcategories', () => {
       // arrange
-      const expectedChildCategory = new CategoryStub(33);
-      const childCategoryData = new CategoryDataStub()
-        .withName('expected child category')
-        .withChildren([createScriptDataWithCode()]);
-      const categoryData = new CategoryDataStub()
+      const expected = [new CategoryDataStub()
+        .withName('test category')
+        .withChildren([createScriptDataWithCode()]),
+      ];
+      const category = new CategoryDataStub()
         .withName('category name')
-        .withChildren([childCategoryData]);
-      const { categoryFactorySpy, getInitParameters } = createCategoryFactorySpy();
+        .withChildren(expected);
       // act
-      const actualCategory = new TestBuilder()
-        .withData(categoryData)
-        .withCategoryFactory((parameters) => {
-          if (parameters.name === childCategoryData.category) {
-            return expectedChildCategory;
-          }
-          return categoryFactorySpy(parameters);
-        })
-        .parseCategory();
+      const actual = new TestBuilder()
+        .withData(category)
+        .parseCategory()
+        .subCategories;
       // assert
-      const actualSubcategories = getInitParameters(actualCategory)?.subcategories;
-      expectExists(actualSubcategories);
-      expect(actualSubcategories).to.have.lengthOf(1);
-      expect(actualSubcategories[0]).to.equal(expectedChildCategory);
+      expect(actual).to.have.lengthOf(1);
+      expect(actual[0].name).to.equal(expected[0].category);
+      expect(actual[0].scripts.length).to.equal(expected[0].children.length);
     });
   });
 });
@@ -399,62 +262,24 @@ class TestBuilder {
 
   private context: ICategoryCollectionParseContext = new CategoryCollectionParseContextStub();
 
-  private categoryFactory: CategoryFactory = () => new CategoryStub(33);
-
-  private errorWrapper: ErrorWithContextWrapper = new ErrorWrapperStub().get();
-
-  private validatorFactory: NodeDataValidatorFactory = createNodeDataValidatorFactoryStub;
-
-  private docsParser: DocsParser = () => ['docs'];
-
-  private scriptParser: ScriptParser = new ScriptParserStub().get();
+  private factory?: CategoryFactoryType = undefined;
 
   public withData(data: CategoryData) {
     this.data = data;
     return this;
   }
 
-  public withContext(context: ICategoryCollectionParseContext): this {
+  public withContext(context: ICategoryCollectionParseContext) {
     this.context = context;
     return this;
   }
 
-  public withCategoryFactory(categoryFactory: CategoryFactory): this {
-    this.categoryFactory = categoryFactory;
-    return this;
-  }
-
-  public withValidatorFactory(validatorFactory: NodeDataValidatorFactory): this {
-    this.validatorFactory = validatorFactory;
-    return this;
-  }
-
-  public withErrorWrapper(errorWrapper: ErrorWithContextWrapper): this {
-    this.errorWrapper = errorWrapper;
-    return this;
-  }
-
-  public withScriptParser(scriptParser: ScriptParser): this {
-    this.scriptParser = scriptParser;
-    return this;
-  }
-
-  public withDocsParser(docsParser: DocsParser): this {
-    this.docsParser = docsParser;
+  public withFactory(factory: CategoryFactoryType) {
+    this.factory = factory;
     return this;
   }
 
   public parseCategory() {
-    return parseCategory(
-      this.data,
-      this.context,
-      {
-        createCategory: this.categoryFactory,
-        wrapError: this.errorWrapper,
-        createValidator: this.validatorFactory,
-        parseScript: this.scriptParser,
-        parseDocs: this.docsParser,
-      },
-    );
+    return parseCategory(this.data, this.context, this.factory);
   }
 }

tests/unit/application/Parser/ContextualError.spec.ts

@@ -1,121 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CustomError } from '@/application/Common/CustomError';
-import { wrapErrorWithAdditionalContext } from '@/application/Parser/ContextualError';
-
-describe('wrapErrorWithAdditionalContext', () => {
-  it('preserves the original error when wrapped', () => {
-    // arrange
-    const expectedError = new Error();
-    const context = new TestContext()
-      .withError(expectedError);
-    // act
-    const error = context.wrap();
-    // assert
-    const actualError = extractInnerErrorFromContextualError(error);
-    expect(actualError).to.equal(expectedError);
-  });
-  it('maintains the original error when re-wrapped', () => {
-    // arrange
-    const expectedError = new Error();
-
-    // act
-    const firstError = new TestContext()
-      .withError(expectedError)
-      .withAdditionalContext('first error')
-      .wrap();
-    const secondError = new TestContext()
-      .withError(firstError)
-      .withAdditionalContext('second error')
-      .wrap();
-
-    // assert
-    const actualError = extractInnerErrorFromContextualError(secondError);
-    expect(actualError).to.equal(expectedError);
-  });
-  it(`the object extends ${CustomError.name}`, () => {
-    // arrange
-    const expected = CustomError;
-    // act
-    const error = new TestContext()
-      .wrap();
-    // assert
-    expect(error).to.be.an.instanceof(expected);
-  });
-  describe('error message construction', () => {
-    it('includes the message from the original error', () => {
-      // arrange
-      const expectedOriginalErrorMessage = 'Message from the inner error';
-
-      // act
-      const error = new TestContext()
-        .withError(new Error(expectedOriginalErrorMessage))
-        .wrap();
-
-      // assert
-      expect(error.message).contains(expectedOriginalErrorMessage);
-    });
-    it('appends provided additional context to the error message', () => {
-      // arrange
-      const expectedAdditionalContext = 'Expected additional context message';
-
-      // act
-      const error = new TestContext()
-        .withAdditionalContext(expectedAdditionalContext)
-        .wrap();
-
-      // assert
-      expect(error.message).contains(expectedAdditionalContext);
-    });
-    it('appends multiple contexts to the error message in sequential order', () => {
-      // arrange
-      const expectedFirstContext = 'First context';
-      const expectedSecondContext = 'Second context';
-
-      // act
-      const firstError = new TestContext()
-        .withAdditionalContext(expectedFirstContext)
-        .wrap();
-      const secondError = new TestContext()
-        .withError(firstError)
-        .withAdditionalContext(expectedSecondContext)
-        .wrap();
-
-      // assert
-      const messageLines = secondError.message.split('\n');
-      expect(messageLines).to.contain(`1: ${expectedFirstContext}`);
-      expect(messageLines).to.contain(`2: ${expectedSecondContext}`);
-    });
-  });
-});
-
-class TestContext {
-  private error: Error = new Error();
-
-  private additionalContext = `[${TestContext.name}] additional context`;
-
-  public withError(error: Error) {
-    this.error = error;
-    return this;
-  }
-
-  public withAdditionalContext(additionalContext: string) {
-    this.additionalContext = additionalContext;
-    return this;
-  }
-
-  public wrap(): ReturnType<typeof wrapErrorWithAdditionalContext> {
-    return wrapErrorWithAdditionalContext(
-      this.error,
-      this.additionalContext,
-    );
-  }
-}
-
-function extractInnerErrorFromContextualError(error: Error): Error {
-  const innerErrorProperty = 'innerError';
-  if (!(innerErrorProperty in error)) {
-    throw new Error(`${innerErrorProperty} property is missing`);
-  }
-  const actualError = error[innerErrorProperty];
-  return actualError as Error;
-}

tests/unit/application/Parser/ContextualErrorTester.ts

@@ -1,53 +0,0 @@
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
-import { indentText } from '@tests/shared/Text';
-import { ErrorWrapperStub } from '@tests/unit/shared/Stubs/ErrorWrapperStub';
-
-interface ContextualErrorTestScenario {
-  readonly throwingAction: (wrapError: ErrorWithContextWrapper) => void;
-  readonly expectedWrappedError: Error;
-  readonly expectedContextMessage: string;
-}
-
-export function itThrowsContextualError(
-  testScenario: ContextualErrorTestScenario,
-) {
-  it('throws wrapped error', () => {
-    // arrange
-    const expectedError = new Error();
-    const wrapperStub = new ErrorWrapperStub()
-      .withError(expectedError);
-    // act
-    const act = () => testScenario.throwingAction(wrapperStub.get());
-    // assert
-    expect(act).to.throw(expectedError);
-  });
-  it('wraps internal error', () => {
-    // arrange
-    const expectedInternalError = testScenario.expectedWrappedError;
-    const wrapperStub = new ErrorWrapperStub();
-    // act
-    try {
-      testScenario.throwingAction(wrapperStub.get());
-    } catch { /* Swallow */ }
-    // assert
-    expect(wrapperStub.lastError).to.deep.equal(expectedInternalError);
-  });
-  it('includes expected context', () => {
-    // arrange
-    const { expectedContextMessage: expectedContext } = testScenario;
-    const wrapperStub = new ErrorWrapperStub();
-    // act
-    try {
-      testScenario.throwingAction(wrapperStub.get());
-    } catch { /* Swallow */ }
-    // assert
-    expectExists(wrapperStub.lastContext);
-    expect(wrapperStub.lastContext).to.equal(expectedContext, formatAssertionMessage([
-      'Unexpected additional context (additional message added to the wrapped error).',
-      `Actual additional context:\n${indentText(wrapperStub.lastContext)}`,
-      `Expected additional context:\n${indentText(expectedContext)}`,
-    ]));
-  });
-}

tests/unit/application/Parser/DataValidationTestScenarioGenerator.ts

@@ -1,36 +0,0 @@
-export interface DataValidationTestScenario<T> {
-  readonly description: string;
-  readonly data: T;
-  readonly expectedPass: boolean;
-  readonly expectedMessage?: string;
-}
-
-export function generateDataValidationTestScenarios<T>(
-  ...conditionBasedScenarios: DataValidationConditionBasedTestScenario<T>[]
-): DataValidationTestScenario<T>[] {
-  return conditionBasedScenarios.flatMap((conditionScenario) => [
-    conditionScenario.expectFail.map((failDefinition): DataValidationTestScenario<T> => ({
-      description: `fails: "${failDefinition.description}"`,
-      data: failDefinition.data,
-      expectedPass: false,
-      expectedMessage: conditionScenario.assertErrorMessage,
-    })),
-    conditionScenario.expectPass.map((passDefinition): DataValidationTestScenario<T> => ({
-      description: `passes: "${passDefinition.description}"`,
-      data: passDefinition.data,
-      expectedPass: true,
-      expectedMessage: conditionScenario.assertErrorMessage,
-    })),
-  ].flat());
-}
-
-interface DataValidationConditionBasedTestScenario<T> {
-  readonly assertErrorMessage?: string;
-  readonly expectPass: readonly DataValidationScenarioDefinition<T>[];
-  readonly expectFail: readonly DataValidationScenarioDefinition<T>[];
-}
-
-interface DataValidationScenarioDefinition<T> {
-  readonly description: string;
-  readonly data: T;
-}

tests/unit/application/Parser/NodeDataValidationTester.ts

@@ -1,213 +0,0 @@
-import { it } from 'vitest';
-import type { NodeDataValidator, NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import type { NodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import { NodeDataValidatorStub } from '@tests/unit/shared/Stubs/NodeDataValidatorStub';
-import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import type { CategoryOrScriptData } from '@/application/collections/';
-import type { FunctionKeys } from '@/TypeHelpers';
-import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
-import { indentText } from '@tests/shared/Text';
-
-type NodeValidationTestFunction<TExpectation> = (
-  factory: NodeDataValidatorFactory,
-) => TExpectation;
-
-interface ValidNameExpectation {
-  readonly expectedNameToValidate: string;
-  readonly expectedErrorContext: NodeDataErrorContext;
-}
-
-export function itValidatesName(
-  test: NodeValidationTestFunction<ValidNameExpectation>,
-) {
-  it('validates for name', () => {
-    // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
-    // act
-    test(factoryStub);
-    // assert
-    const call = validator.callHistory.find((c) => c.methodName === 'assertValidName');
-    expectExists(call);
-  });
-  it('validates for name with correct name', () => {
-    // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
-    // act
-    const expectation = test(factoryStub);
-    // assert
-    const expectedName = expectation.expectedNameToValidate;
-    const names = validator.callHistory
-      .filter((c) => c.methodName === 'assertValidName')
-      .flatMap((c) => c.args[0]);
-    expect(names).to.include(expectedName);
-  });
-  it('validates for name with correct context', () => {
-    expectCorrectContextForFunctionCall({
-      methodName: 'assertValidName',
-      act: test,
-      expectContext: (expectation) => expectation.expectedErrorContext,
-    });
-  });
-}
-
-interface ValidDataExpectation {
-  readonly expectedDataToValidate: CategoryOrScriptData;
-  readonly expectedErrorContext: NodeDataErrorContext;
-}
-
-export function itValidatesDefinedData(
-  test: NodeValidationTestFunction<ValidDataExpectation>,
-) {
-  it('validates data', () => {
-    // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
-    // act
-    test(factoryStub);
-    // assert
-    const call = validator.callHistory.find((c) => c.methodName === 'assertDefined');
-    expectExists(call);
-  });
-  it('validates data with correct data', () => {
-    // arrange
-    const validator = new NodeDataValidatorStub();
-    const factoryStub: NodeDataValidatorFactory = () => validator;
-    // act
-    const expectation = test(factoryStub);
-    // assert
-    const expectedData = expectation.expectedDataToValidate;
-    const calls = validator.callHistory.filter((c) => c.methodName === 'assertDefined');
-    const names = calls.flatMap((c) => c.args[0]);
-    expect(names).to.include(expectedData);
-  });
-  it('validates data with correct context', () => {
-    expectCorrectContextForFunctionCall({
-      methodName: 'assertDefined',
-      act: test,
-      expectContext: (expectation) => expectation.expectedErrorContext,
-    });
-  });
-}
-
-interface AssertionExpectation {
-  readonly expectedErrorMessage: string;
-  readonly expectedErrorContext: NodeDataErrorContext;
-}
-
-export function itAsserts(
-  testScenario: {
-    readonly test: NodeValidationTestFunction<AssertionExpectation>,
-    readonly expectedConditionResult: boolean;
-  },
-) {
-  it('asserts with correct message', () => {
-    // arrange
-    const validator = new NodeDataValidatorStub()
-      .withAssertThrowsOnFalseCondition(false);
-    const factoryStub: NodeDataValidatorFactory = () => validator;
-    // act
-    const expectation = testScenario.test(factoryStub);
-    // assert
-    const expectedError = expectation.expectedErrorMessage;
-    const calls = validator.callHistory.filter((c) => c.methodName === 'assert');
-    const actualMessages = calls.map((call) => {
-      const [, message] = call.args;
-      return message;
-    });
-    expect(actualMessages).to.include(expectedError);
-  });
-  it('asserts with correct context', () => {
-    expectCorrectContextForFunctionCall({
-      methodName: 'assert',
-      act: testScenario.test,
-      expectContext: (expectation) => expectation.expectedErrorContext,
-    });
-  });
-  it('asserts with correct condition result', () => {
-    // arrange
-    const expectedEvaluationResult = testScenario.expectedConditionResult;
-    const validator = new NodeDataValidatorStub()
-      .withAssertThrowsOnFalseCondition(false);
-    const factoryStub: NodeDataValidatorFactory = () => validator;
-    // act
-    const expectation = testScenario.test(factoryStub);
-    // assert
-    const assertCalls = validator.callHistory
-      .filter((call) => call.methodName === 'assert');
-    expect(assertCalls).to.have.length.greaterThan(0);
-    const assertCallsWithMessage = assertCalls
-      .filter((call) => {
-        const [, message] = call.args;
-        return message === expectation.expectedErrorMessage;
-      });
-    expect(assertCallsWithMessage).to.have.length.greaterThan(0);
-    const evaluationResults = assertCallsWithMessage
-      .map((call) => {
-        const [predicate] = call.args;
-        return predicate as (() => boolean);
-      })
-      .map((predicate) => predicate());
-    expect(evaluationResults).to.include(expectedEvaluationResult);
-  });
-}
-
-function expectCorrectContextForFunctionCall<T>(testScenario: {
-  methodName: FunctionKeys<NodeDataValidator>,
-  act: NodeValidationTestFunction<T>,
-  expectContext: (actionResult: T) => NodeDataErrorContext,
-}) {
-  // arrange
-  const { methodName } = testScenario;
-  const createdValidators = new Array<{
-    readonly validator: NodeDataValidatorStub;
-    readonly context: NodeDataErrorContext;
-  }>();
-  const factoryStub: NodeDataValidatorFactory = (context) => {
-    const validator = new NodeDataValidatorStub()
-      .withAssertThrowsOnFalseCondition(false);
-    createdValidators.push(({
-      validator,
-      context,
-    }));
-    return validator;
-  };
-  // act
-  const actionResult = testScenario.act(factoryStub);
-  // assert
-  const expectedContext = testScenario.expectContext(actionResult);
-  const providedContexts = createdValidators
-    .filter((v) => v.validator.callHistory.find((c) => c.methodName === methodName))
-    .map((v) => v.context);
-  expectDeepIncludes( // to.deep.include is not working
-    providedContexts,
-    expectedContext,
-    formatAssertionMessage([
-      'Error context mismatch.',
-      'Provided contexts do not include the expected context.',
-      'Expected context:',
-      indentText(JSON.stringify(expectedContext, undefined, 2)),
-      'Provided contexts:',
-      indentText(JSON.stringify(providedContexts, undefined, 2)),
-    ]),
-  );
-}
-
-function expectDeepIncludes<T>(
-  array: readonly T[],
-  item: T,
-  message: string,
-) {
-  const serializeItem = (c) => JSON.stringify(c);
-  const serializedContexts = array.map((c) => serializeItem(c));
-  const serializedExpectedContext = serializeItem(item);
-  expect(serializedContexts).to.include(serializedExpectedContext, formatAssertionMessage([
-    'Error context mismatch.',
-    'Provided contexts do not include the expected context.',
-    'Expected context:',
-    indentText(JSON.stringify(message, undefined, 2)),
-    'Provided contexts:',
-    indentText(JSON.stringify(message, undefined, 2)),
-  ]));
-}

tests/unit/application/Parser/NodeValidation/NodeDataError.spec.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { type INodeDataErrorContext, NodeDataError } from '@/application/Parser/NodeValidation/NodeDataError';
+import { NodeDataErrorContextStub } from '@tests/unit/shared/Stubs/NodeDataErrorContextStub';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
+import { CustomError } from '@/application/Common/CustomError';
+
+describe('NodeDataError', () => {
+  it('sets message as expected', () => {
+    // arrange
+    const message = 'message';
+    const context = new NodeDataErrorContextStub();
+    const expected = `[${NodeType[context.type]}] ${message}`;
+    // act
+    const sut = new NodeDataErrorBuilder()
+      .withContext(context)
+      .withMessage(expected)
+      .build();
+    // assert
+    expect(sut.message).to.include(expected);
+  });
+  it('sets context as expected', () => {
+    // arrange
+    const expected = new NodeDataErrorContextStub();
+    // act
+    const sut = new NodeDataErrorBuilder()
+      .withContext(expected)
+      .build();
+    // assert
+    expect(sut.context).to.equal(expected);
+  });
+  it('extends CustomError', () => {
+    // arrange
+    const expected = CustomError;
+    // act
+    const sut = new NodeDataErrorBuilder()
+      .build();
+    // assert
+    expect(sut).to.be.an.instanceof(expected);
+  });
+});
+
+class NodeDataErrorBuilder {
+  private message = 'error';
+
+  private context: INodeDataErrorContext = new NodeDataErrorContextStub();
+
+  public withContext(context: INodeDataErrorContext) {
+    this.context = context;
+    return this;
+  }
+
+  public withMessage(message: string) {
+    this.message = message;
+    return this;
+  }
+
+  public build(): NodeDataError {
+    return new NodeDataError(this.message, this.context);
+  }
+}

tests/unit/application/Parser/NodeValidation/NodeDataValidator.spec.ts

@@ -1,242 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
-import type { NodeData } from '@/application/Parser/NodeValidation/NodeData';
-import { createNodeDataErrorContextStub } from '@tests/unit/shared/Stubs/NodeDataErrorContextStub';
-import type { NodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
-import { ContextualNodeDataValidator, createNodeDataValidator, type NodeDataValidator } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import type { NodeContextErrorMessageCreator } from '@/application/Parser/NodeValidation/NodeDataErrorContextMessage';
-import { getAbsentObjectTestCases, getAbsentStringTestCases } from '@tests/unit/shared/TestCases/AbsentTests';
-
-describe('createNodeDataValidator', () => {
-  it(`returns an instance of ${ContextualNodeDataValidator.name}`, () => {
-    // arrange
-    const context = createNodeDataErrorContextStub();
-    // act
-    const validator = createNodeDataValidator(context);
-    // assert
-    expect(validator).to.be.instanceOf(ContextualNodeDataValidator);
-  });
-});
-
-describe('NodeDataValidator', () => {
-  describe('assertValidName', () => {
-    describe('throws when name is invalid', () => {
-      // arrange
-      const testScenarios: readonly {
-        readonly description: string;
-        readonly invalidName: unknown;
-        readonly expectedMessage: string;
-      }[] = [
-        ...getAbsentStringTestCases().map((testCase) => ({
-          description: `missing name (${testCase.valueName})`,
-          invalidName: testCase.absentValue,
-          expectedMessage: 'missing name',
-        })),
-        {
-          description: 'invalid type',
-          invalidName: 33,
-          expectedMessage: 'Name (33) is not a string but number.',
-        },
-      ];
-      testScenarios.forEach(({ description, invalidName, expectedMessage }) => {
-        describe(`given "${description}"`, () => {
-          itThrowsCorrectly({
-            // act
-            throwingAction: (sut) => {
-              sut.assertValidName(invalidName as string);
-            },
-            // assert
-            expectedMessage,
-          });
-        });
-      });
-    });
-    it('does not throw when name is valid', () => {
-      // arrange
-      const validName = 'validName';
-      const sut = new NodeValidatorBuilder()
-        .build();
-      // act
-      const act = () => sut.assertValidName(validName);
-      // assert
-      expect(act).to.not.throw();
-    });
-  });
-  describe('assertDefined', () => {
-    describe('throws when node data is missing', () => {
-      // arrange
-      const testScenarios: readonly {
-        readonly description: string;
-        readonly invalidData: unknown;
-      }[] = [
-        ...getAbsentObjectTestCases().map((testCase) => ({
-          description: `absent object (${testCase.valueName})`,
-          invalidData: testCase.absentValue,
-        })),
-        {
-          description: 'empty object',
-          invalidData: {},
-        },
-      ];
-      testScenarios.forEach(({ description, invalidData }) => {
-        describe(`given "${description}"`, () => {
-          const expectedMessage = 'missing node data';
-          itThrowsCorrectly({
-            // act
-            throwingAction: (sut: NodeDataValidator) => {
-              sut.assertDefined(invalidData as NodeData);
-            },
-            // assert
-            expectedMessage,
-          });
-        });
-      });
-    });
-    it('does not throw if node data is defined', () => {
-      // arrange
-      const definedNode = new CategoryDataStub();
-      const sut = new NodeValidatorBuilder()
-        .build();
-      // act
-      const act = () => sut.assertDefined(definedNode);
-      // assert
-      expect(act).to.not.throw();
-    });
-  });
-  describe('assert', () => {
-    describe('throws if validation fails', () => {
-      const falsePredicate = () => false;
-      const expectedErrorMessage = 'expected error';
-      // assert
-      itThrowsCorrectly({
-        // act
-        throwingAction: (sut: NodeDataValidator) => {
-          sut.assert(falsePredicate, expectedErrorMessage);
-        },
-        // assert
-        expectedMessage: expectedErrorMessage,
-      });
-    });
-    it('does not throw if validation succeeds', () => {
-      // arrange
-      const truePredicate = () => true;
-      const sut = new NodeValidatorBuilder()
-        .build();
-      // act
-      const act = () => sut.assert(truePredicate, 'ignored error');
-      // assert
-      expect(act).to.not.throw();
-    });
-  });
-  describe('createContextualErrorMessage', () => {
-    it('creates using the correct error message', () => {
-      // arrange
-      const expectedErrorMessage = 'expected error';
-      const errorMessageBuilder: NodeContextErrorMessageCreator = (message) => message;
-      const sut = new NodeValidatorBuilder()
-        .withErrorMessageCreator(errorMessageBuilder)
-        .build();
-      // act
-      const actualErrorMessage = sut.createContextualErrorMessage(expectedErrorMessage);
-      // assert
-      expect(actualErrorMessage).to.equal(expectedErrorMessage);
-    });
-    it('creates using the correct context', () => {
-      // arrange
-      const expectedContext = createNodeDataErrorContextStub();
-      let actualContext: NodeDataErrorContext | undefined;
-      const errorMessageBuilder: NodeContextErrorMessageCreator = (_, context) => {
-        actualContext = context;
-        return '';
-      };
-      const sut = new NodeValidatorBuilder()
-        .withContext(expectedContext)
-        .withErrorMessageCreator(errorMessageBuilder)
-        .build();
-      // act
-      sut.createContextualErrorMessage('unimportant');
-      // assert
-      expect(actualContext).to.equal(expectedContext);
-    });
-  });
-});
-
-type ValidationThrowingFunction = (
-  sut: ContextualNodeDataValidator,
-) => void;
-
-interface ValidationThrowingTestScenario {
-  readonly throwingAction: ValidationThrowingFunction,
-  readonly expectedMessage: string;
-}
-
-function itThrowsCorrectly(
-  testScenario: ValidationThrowingTestScenario,
-): void {
-  it('throws an error', () => {
-    // arrange
-    const expectedErrorMessage = 'Injected error message';
-    const errorMessageBuilder: NodeContextErrorMessageCreator = () => expectedErrorMessage;
-    const sut = new NodeValidatorBuilder()
-      .withErrorMessageCreator(errorMessageBuilder)
-      .build();
-    // act
-    const action = () => testScenario.throwingAction(sut);
-    // assert
-    expect(action).to.throw();
-  });
-  it('throws with the correct error message', () => {
-    // arrange
-    const expectedErrorMessage = testScenario.expectedMessage;
-    const errorMessageBuilder: NodeContextErrorMessageCreator = (message) => message;
-    const sut = new NodeValidatorBuilder()
-      .withErrorMessageCreator(errorMessageBuilder)
-      .build();
-    // act
-    const action = () => testScenario.throwingAction(sut);
-    // assert
-    const actualErrorMessage = collectExceptionMessage(action);
-    expect(actualErrorMessage).to.equal(expectedErrorMessage);
-  });
-  it('throws with the correct context', () => {
-    // arrange
-    const expectedContext = createNodeDataErrorContextStub();
-    const serializeContext = (context: NodeDataErrorContext) => JSON.stringify(context);
-    const errorMessageBuilder:
-    NodeContextErrorMessageCreator = (_, context) => serializeContext(context);
-    const sut = new NodeValidatorBuilder()
-      .withContext(expectedContext)
-      .withErrorMessageCreator(errorMessageBuilder)
-      .build();
-    // act
-    const action = () => testScenario.throwingAction(sut);
-    // assert
-    const expectedSerializedContext = serializeContext(expectedContext);
-    const actualSerializedContext = collectExceptionMessage(action);
-    expect(expectedSerializedContext).to.equal(actualSerializedContext);
-  });
-}
-
-class NodeValidatorBuilder {
-  private errorContext: NodeDataErrorContext = createNodeDataErrorContextStub();
-
-  private errorMessageCreator: NodeContextErrorMessageCreator = () => `[${NodeValidatorBuilder.name}] stub error message`;
-
-  public withErrorMessageCreator(errorMessageCreator: NodeContextErrorMessageCreator): this {
-    this.errorMessageCreator = errorMessageCreator;
-    return this;
-  }
-
-  public withContext(errorContext: NodeDataErrorContext): this {
-    this.errorContext = errorContext;
-    return this;
-  }
-
-  public build(): ContextualNodeDataValidator {
-    return new ContextualNodeDataValidator(
-      this.errorContext,
-      this.errorMessageCreator,
-    );
-  }
-}

tests/unit/application/Parser/NodeValidation/NodeValidator.spec.ts

@@ -0,0 +1,99 @@
+import { describe, it, expect } from 'vitest';
+import { NodeDataError } from '@/application/Parser/NodeValidation/NodeDataError';
+import { NodeValidator } from '@/application/Parser/NodeValidation/NodeValidator';
+import { expectDeepThrowsError } from '@tests/shared/Assertions/ExpectDeepThrowsError';
+import { CategoryDataStub } from '@tests/unit/shared/Stubs/CategoryDataStub';
+import { NodeDataErrorContextStub } from '@tests/unit/shared/Stubs/NodeDataErrorContextStub';
+import type { NodeData } from '@/application/Parser/NodeValidation/NodeData';
+import { NodeValidationTestRunner } from './NodeValidatorTestRunner';
+
+describe('NodeValidator', () => {
+  describe('assertValidName', () => {
+    describe('throws if invalid', () => {
+      // arrange
+      const context = new NodeDataErrorContextStub();
+      const sut = new NodeValidator(context);
+      // act
+      const act = (invalidName: string) => sut.assertValidName(invalidName);
+      // assert
+      new NodeValidationTestRunner()
+        .testInvalidNodeName((invalidName) => ({
+          act: () => act(invalidName),
+          expectedContext: context,
+        }));
+    });
+    it('does not throw if valid', () => {
+      // arrange
+      const validName = 'validName';
+      const sut = new NodeValidator(new NodeDataErrorContextStub());
+      // act
+      const act = () => sut.assertValidName(validName);
+      // assert
+      expect(act).to.not.throw();
+    });
+  });
+  describe('assertDefined', () => {
+    describe('throws if missing', () => {
+      // arrange
+      const context = new NodeDataErrorContextStub();
+      const sut = new NodeValidator(context);
+      // act
+      const act = (undefinedNode: NodeData) => sut.assertDefined(undefinedNode);
+      // assert
+      new NodeValidationTestRunner()
+        .testMissingNodeData((invalidName) => ({
+          act: () => act(invalidName),
+          expectedContext: context,
+        }));
+    });
+    it('does not throw if defined', () => {
+      // arrange
+      const definedNode = mockNode();
+      const sut = new NodeValidator(new NodeDataErrorContextStub());
+      // act
+      const act = () => sut.assertDefined(definedNode);
+      // assert
+      expect(act).to.not.throw();
+    });
+  });
+  describe('assert', () => {
+    it('throws expected error if condition is false', () => {
+      // arrange
+      const message = 'error';
+      const falsePredicate = () => false;
+      const context = new NodeDataErrorContextStub();
+      const expected = new NodeDataError(message, context);
+      const sut = new NodeValidator(context);
+      // act
+      const act = () => sut.assert(falsePredicate, message);
+      // assert
+      expectDeepThrowsError(act, expected);
+    });
+    it('does not throw if condition is true', () => {
+      // arrange
+      const truePredicate = () => true;
+      const sut = new NodeValidator(new NodeDataErrorContextStub());
+      // act
+      const act = () => sut.assert(truePredicate, 'ignored error');
+      // assert
+      expect(act).to.not.throw();
+    });
+  });
+  describe('throw', () => {
+    it('throws expected error', () => {
+      // arrange
+      const message = 'error';
+      const context = new NodeDataErrorContextStub();
+      const expected = new NodeDataError(message, context);
+      const sut = new NodeValidator(context);
+      // act
+      const act = () => sut.throw(message);
+      // assert
+      expectDeepThrowsError(act, expected);
+    });
+  });
+});
+
+function mockNode() {
+  return new CategoryDataStub();
+}

tests/unit/application/Parser/NodeValidation/NodeValidatorTestRunner.ts

@@ -0,0 +1,87 @@
+import { describe, it } from 'vitest';
+import { NodeDataError, type INodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataError';
+import type { NodeData } from '@/application/Parser/NodeValidation/NodeData';
+import { getAbsentObjectTestCases, getAbsentStringTestCases, itEachAbsentTestCase } from '@tests/unit/shared/TestCases/AbsentTests';
+import { expectDeepThrowsError } from '@tests/shared/Assertions/ExpectDeepThrowsError';
+
+export interface ITestScenario {
+  readonly act: () => void;
+  readonly expectedContext: INodeDataErrorContext;
+}
+
+export class NodeValidationTestRunner {
+  public testInvalidNodeName(
+    testBuildPredicate: (invalidName: string) => ITestScenario,
+  ) {
+    describe('throws given invalid names', () => {
+      // arrange
+      const testCases = [
+        ...getAbsentStringTestCases().map((testCase) => ({
+          testName: `missing name (${testCase.valueName})`,
+          nameValue: testCase.absentValue,
+          expectedMessage: 'missing name',
+        })),
+        {
+          testName: 'invalid type',
+          nameValue: 33,
+          expectedMessage: 'Name (33) is not a string but number.',
+        },
+      ];
+      for (const testCase of testCases) {
+        it(`given "${testCase.testName}"`, () => {
+          const test = testBuildPredicate(testCase.nameValue as never);
+          expectThrowsNodeError(test, testCase.expectedMessage);
+        });
+      }
+    });
+    return this;
+  }
+
+  public testMissingNodeData(
+    testBuildPredicate: (missingNode: NodeData) => ITestScenario,
+  ) {
+    describe('throws given missing node data', () => {
+      itEachAbsentTestCase([
+        ...getAbsentObjectTestCases(),
+        {
+          valueName: 'empty object',
+          absentValue: {},
+        },
+      ], (absentValue) => {
+        // arrange
+        const expectedError = 'missing node data';
+        // act
+        const test = testBuildPredicate(absentValue as NodeData);
+        // assert
+        expectThrowsNodeError(test, expectedError);
+      });
+    });
+    return this;
+  }
+
+  public runThrowingCase(
+    testCase: {
+      readonly name: string,
+      readonly scenario: ITestScenario,
+      readonly expectedMessage: string
+    },
+  ) {
+    it(testCase.name, () => {
+      expectThrowsNodeError(testCase.scenario, testCase.expectedMessage);
+    });
+    return this;
+  }
+}
+
+export function expectThrowsNodeError(
+  test: ITestScenario,
+  expectedMessage: string,
+) {
+  // arrange
+  const expected = new NodeDataError(expectedMessage, test.expectedContext);
+  // act
+  const act = () => test.act();
+  // assert
+  expectDeepThrowsError(act, expected);
+  return this;
+}

tests/unit/application/Parser/Script/Compiler/Expressions/Expression/Expression.spec.ts

@@ -229,11 +229,7 @@ class ExpressionBuilder {
   }
 
   public build() {
-    return new Expression({
-      position: this.position,
-      evaluator: this.evaluator,
-      parameters: this.parameters,
-    });
+    return new Expression(this.position, this.evaluator, this.parameters);
   }
 
   private evaluator: ExpressionEvaluator = () => `[${ExpressionBuilder.name}] evaluated-expression`;

tests/unit/application/Parser/Script/Compiler/Expressions/Expression/ExpressiontPositionFactory.spec.ts

@@ -1,21 +1,22 @@
 import { describe, it, expect } from 'vitest';
 import { createPositionFromRegexFullMatch } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory';
 import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
-import { itIsTransientFactory } from '@tests/unit/shared/TestCases/TransientFactoryTests';
 
 describe('ExpressionPositionFactory', () => {
   describe('createPositionFromRegexFullMatch', () => {
-    describe('it is a transient factory', () => {
+    it(`creates ${ExpressionPosition.name} instance`, () => {
       // arrange
-      const fakeMatch = createRegexMatch();
-      // act
-      const create = () => createPositionFromRegexFullMatch(fakeMatch);
-      // assert
-      itIsTransientFactory({
-        getter: create,
-        expectedType: ExpressionPosition,
+      const expectedType = ExpressionPosition;
+      const fakeMatch = createRegexMatch({
+        fullMatch: 'matched string',
+        matchIndex: 5,
       });
+      // act
+      const position = createPositionFromRegexFullMatch(fakeMatch);
+      // assert
+      expect(position).to.be.instanceOf(expectedType);
     });
+
     it('creates a position with the correct start position', () => {
       // arrange
       const expectedStartPosition = 5;
@@ -62,8 +63,10 @@ describe('ExpressionPositionFactory', () => {
     describe('invalid values', () => {
       it('throws an error if match.index is undefined', () => {
         // arrange
-        const fakeMatch = createRegexMatch();
-        fakeMatch.index = undefined;
+        const fakeMatch = createRegexMatch({
+          fullMatch: 'matched string',
+          matchIndex: undefined,
+        });
         const expectedError = `Regex match did not yield any results: ${JSON.stringify(fakeMatch)}`;
         // act
         const act = () => createPositionFromRegexFullMatch(fakeMatch);
@@ -91,9 +94,9 @@ function createRegexMatch(options?: {
   readonly capturingGroups?: readonly string[],
   readonly matchIndex?: number,
 }): RegExpMatchArray {
-  const fullMatch = options?.fullMatch ?? 'default fake match';
+  const fullMatch = options?.fullMatch ?? 'fake match';
   const capturingGroups = options?.capturingGroups ?? [];
   const fakeMatch: RegExpMatchArray = [fullMatch, ...capturingGroups];
-  fakeMatch.index = options?.matchIndex ?? 0;
+  fakeMatch.index = options?.matchIndex;
   return fakeMatch;
 }

tests/unit/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser.spec.ts

@@ -1,438 +1,168 @@
 import { describe, it, expect } from 'vitest';
-import type {
-  ExpressionEvaluator, ExpressionInitParameters,
-} from '@/application/Parser/Script/Compiler/Expressions/Expression/Expression';
-import {
-  type PrimitiveExpression, RegexParser, type ExpressionFactory, type RegexParserUtilities,
-} from '@/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser';
+import type { ExpressionEvaluator } from '@/application/Parser/Script/Compiler/Expressions/Expression/Expression';
+import { type IPrimitiveExpression, RegexParser } from '@/application/Parser/Script/Compiler/Expressions/Parser/Regex/RegexParser';
 import { ExpressionPosition } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPosition';
-import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
-import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
-import { ExpressionStub } from '@tests/unit/shared/Stubs/ExpressionStub';
-import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
-import type { IExpression } from '@/application/Parser/Script/Compiler/Expressions/Expression/IExpression';
 import { FunctionParameterStub } from '@tests/unit/shared/Stubs/FunctionParameterStub';
-import type { IReadOnlyFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/IFunctionParameterCollection';
-import type { ExpressionPositionFactory } from '@/application/Parser/Script/Compiler/Expressions/Expression/ExpressionPositionFactory';
-import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
-import { indentText } from '@tests/shared/Text';
-import type { FunctionParameterCollectionFactory } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
+import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
+import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
 describe('RegexParser', () => {
   describe('findExpressions', () => {
-    describe('error handling', () => {
-      describe('throws when code is absent', () => {
-        itEachAbsentStringValue((absentValue) => {
-          // arrange
-          const expectedError = 'missing code';
-          const sut = new RegexParserConcrete({
-            regex: /unimportant/,
-          });
-          // act
-          const act = () => sut.findExpressions(absentValue);
-          // assert
-          const errorMessage = collectExceptionMessage(act);
-          expect(errorMessage).to.include(expectedError);
-        }, { excludeNull: true, excludeUndefined: true });
-      });
-      describe('rethrows regex match errors', () => {
+    describe('throws when code is absent', () => {
+      itEachAbsentStringValue((absentValue) => {
         // arrange
-        const expectedMatchError = new TypeError('String.prototype.matchAll called with a non-global RegExp argument');
-        const expectedMessage = 'Failed to match regex.';
-        const expectedCodeInMessage = 'unimportant code content';
-        const expectedRegexInMessage = /failing-regex-because-it-is-non-global/;
-        const expectedErrorMessage = buildRethrowErrorMessage({
-          message: expectedMessage,
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        });
-        itThrowsContextualError({
-          // act
-          throwingAction: (wrapError) => {
-            const sut = new RegexParserConcrete(
-              {
-                regex: expectedRegexInMessage,
-                utilities: {
-                  wrapError,
-                },
-              },
-            );
-            sut.findExpressions(expectedCodeInMessage);
-          },
-          // assert
-          expectedContextMessage: expectedErrorMessage,
-          expectedWrappedError: expectedMatchError,
-        });
-      });
-      describe('rethrows expression building errors', () => {
-        // arrange
-        const expectedMessage = 'Failed to build expression.';
-        const expectedInnerError = new Error('Expected error from building expression');
-        const {
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        } = createCodeAndRegexMatchingOnce();
-        const throwingExpressionBuilder = () => {
-          throw expectedInnerError;
-        };
-        const expectedErrorMessage = buildRethrowErrorMessage({
-          message: expectedMessage,
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        });
-        itThrowsContextualError({
-          // act
-          throwingAction: (wrapError) => {
-            const sut = new RegexParserConcrete(
-              {
-                regex: expectedRegexInMessage,
-                builder: throwingExpressionBuilder,
-                utilities: {
-                  wrapError,
-                },
-              },
-            );
-            sut.findExpressions(expectedCodeInMessage);
-          },
-          // assert
-          expectedWrappedError: expectedInnerError,
-          expectedContextMessage: expectedErrorMessage,
-        });
-      });
-      describe('rethrows position creation errors', () => {
-        // arrange
-        const expectedMessage = 'Failed to create position.';
-        const expectedInnerError = new Error('Expected error from position factory');
-        const {
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        } = createCodeAndRegexMatchingOnce();
-        const throwingPositionFactory = () => {
-          throw expectedInnerError;
-        };
-        const expectedErrorMessage = buildRethrowErrorMessage({
-          message: expectedMessage,
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        });
-        itThrowsContextualError({
-          // act
-          throwingAction: (wrapError) => {
-            const sut = new RegexParserConcrete(
-              {
-                regex: expectedRegexInMessage,
-                utilities: {
-                  createPosition: throwingPositionFactory,
-                  wrapError,
-                },
-              },
-            );
-            sut.findExpressions(expectedCodeInMessage);
-          },
-          // assert
-          expectedWrappedError: expectedInnerError,
-          expectedContextMessage: expectedErrorMessage,
-        });
-      });
-      describe('rethrows parameter creation errors', () => {
-        // arrange
-        const expectedMessage = 'Failed to create parameters.';
-        const expectedInnerError = new Error('Expected error from parameter collection factory');
-        const {
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        } = createCodeAndRegexMatchingOnce();
-        const throwingParameterCollectionFactory = () => {
-          throw expectedInnerError;
-        };
-        const expectedErrorMessage = buildRethrowErrorMessage({
-          message: expectedMessage,
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        });
-        itThrowsContextualError({
-          // act
-          throwingAction: (wrapError) => {
-            const sut = new RegexParserConcrete(
-              {
-                regex: expectedRegexInMessage,
-                utilities: {
-                  createParameterCollection: throwingParameterCollectionFactory,
-                  wrapError,
-                },
-              },
-            );
-            sut.findExpressions(expectedCodeInMessage);
-          },
-          // assert
-          expectedWrappedError: expectedInnerError,
-          expectedContextMessage: expectedErrorMessage,
-        });
-      });
-      describe('rethrows expression creation errors', () => {
-        // arrange
-        const expectedMessage = 'Failed to create expression.';
-        const expectedInnerError = new Error('Expected error from expression factory');
-        const {
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        } = createCodeAndRegexMatchingOnce();
-        const throwingExpressionFactory = () => {
-          throw expectedInnerError;
-        };
-        const expectedErrorMessage = buildRethrowErrorMessage({
-          message: expectedMessage,
-          code: expectedCodeInMessage,
-          regex: expectedRegexInMessage,
-        });
-        itThrowsContextualError({
-          // act
-          throwingAction: (wrapError) => {
-            const sut = new RegexParserConcrete(
-              {
-                regex: expectedRegexInMessage,
-                utilities: {
-                  createExpression: throwingExpressionFactory,
-                  wrapError,
-                },
-              },
-            );
-            sut.findExpressions(expectedCodeInMessage);
-          },
-          // assert
-          expectedWrappedError: expectedInnerError,
-          expectedContextMessage: expectedErrorMessage,
-        });
-      });
+        const expectedError = 'missing code';
+        const sut = new RegexParserConcrete(/unimportant/);
+        // act
+        const act = () => sut.findExpressions(absentValue);
+        // assert
+        expect(act).to.throw(expectedError);
+      }, { excludeNull: true, excludeUndefined: true });
     });
-    describe('handles matched regex correctly', () => {
+    it('throws when position is invalid', () => {
       // arrange
-      const testScenarios: readonly {
-        readonly description: string;
-        readonly regex: RegExp;
-        readonly code: string;
-      }[] = [
+      const regexMatchingEmpty = /^/gm; /* expressions cannot be empty */
+      const code = 'unimportant';
+      const expectedErrorParts = [
+        `[${RegexParserConcrete.constructor.name}]`,
+        'invalid script position',
+        `Regex: ${regexMatchingEmpty}`,
+        `Code: ${code}`,
+      ];
+      const sut = new RegexParserConcrete(regexMatchingEmpty);
+      // act
+      let errorMessage: string | undefined;
+      try {
+        sut.findExpressions(code);
+      } catch (err) {
+        errorMessage = err.message;
+      }
+      // assert
+      expectExists(errorMessage);
+      const error = errorMessage; // workaround for ts(18048): possibly 'undefined'
+      expect(
+        expectedErrorParts.every((part) => error.includes(part)),
+        `Expected parts: ${expectedErrorParts.join(', ')}`
+          + `Actual error: ${errorMessage}`,
+      );
+    });
+    describe('matches regex as expected', () => {
+      // arrange
+      const testCases = [
         {
-          description: 'non-matching regex',
+          name: 'returns no result when regex does not match',
           regex: /hello/g,
           code: 'world',
         },
         {
-          description: 'single regex match',
+          name: 'returns expected when regex matches single',
           regex: /hello/g,
           code: 'hello world',
         },
         {
-          description: 'multiple regex matches',
+          name: 'returns expected when regex matches multiple',
           regex: /l/g,
           code: 'hello world',
         },
       ];
-      testScenarios.forEach(({
-        description, code, regex,
-      }) => {
-        describe(description, () => {
-          it('generates expressions for all matches', () => {
-            // arrange
-            const expectedTotalExpressions = Array.from(code.matchAll(regex)).length;
-            const sut = new RegexParserConcrete({
-              regex,
-            });
-            // act
-            const expressions = sut.findExpressions(code);
-            // assert
-            const actualTotalExpressions = expressions.length;
-            expect(actualTotalExpressions).to.equal(
-              expectedTotalExpressions,
-              formatAssertionMessage([
-                `Expected ${actualTotalExpressions} expressions due to ${expectedTotalExpressions} matches`,
-                `Expressions:\n${indentText(JSON.stringify(expressions, undefined, 2))}`,
-              ]),
-            );
-          });
-          it('builds primitive expressions for each match', () => {
-            const expected = Array.from(code.matchAll(regex));
-            const matches = new Array<RegExpMatchArray>();
-            const builder = (m: RegExpMatchArray): PrimitiveExpression => {
-              matches.push(m);
-              return createPrimitiveExpressionStub();
-            };
-            const sut = new RegexParserConcrete({
-              regex,
-              builder,
-            });
-            // act
-            sut.findExpressions(code);
-            // assert
-            expect(matches).to.deep.equal(expected);
-          });
-          it('sets positions correctly from matches', () => {
-            // arrange
-            const expectedMatches = [...code.matchAll(regex)];
-            const { createExpression, getInitParameters } = createExpressionFactorySpy();
-            const serializeRegexMatch = (match: RegExpMatchArray) => `[startPos:${match?.index ?? 'none'},length:${match?.[0]?.length ?? 'none'}]`;
-            const positionsForMatches = new Map<string, ExpressionPosition>(expectedMatches.map(
-              (expectedMatch) => [serializeRegexMatch(expectedMatch), new ExpressionPosition(1, 4)],
-            ));
-            const createPositionMock: ExpressionPositionFactory = (match) => {
-              const position = positionsForMatches.get(serializeRegexMatch(match));
-              return position ?? new ExpressionPosition(66, 666);
-            };
-            const sut = new RegexParserConcrete({
-              regex,
-              utilities: {
-                createExpression,
-                createPosition: createPositionMock,
-              },
-            });
-            // act
-            const expressions = sut.findExpressions(code);
-            // assert
-            const expectedPositions = [...positionsForMatches.values()];
-            const actualPositions = expressions.map((e) => getInitParameters(e)?.position);
-            expect(actualPositions).to.deep.equal(expectedPositions, formatAssertionMessage([
-              'Actual positions do not match the expected positions.',
-              `Expected total positions: ${expectedPositions.length} (due to ${expectedMatches.length} regex matches)`,
-              `Actual total positions: ${actualPositions.length}`,
-              `Expected positions:\n${indentText(JSON.stringify(expectedPositions, undefined, 2))}`,
-              `Actual positions:\n${indentText(JSON.stringify(actualPositions, undefined, 2))}`,
-            ]));
-          });
+      for (const testCase of testCases) {
+        it(testCase.name, () => {
+          const expected = Array.from(testCase.code.matchAll(testCase.regex));
+          const matches = new Array<RegExpMatchArray>();
+          const builder = (m: RegExpMatchArray): IPrimitiveExpression => {
+            matches.push(m);
+            return mockPrimitiveExpression();
+          };
+          const sut = new RegexParserConcrete(testCase.regex, builder);
+          // act
+          const expressions = sut.findExpressions(testCase.code);
+          // assert
+          expect(expressions).to.have.lengthOf(matches.length);
+          expect(matches).to.deep.equal(expected);
         });
-      });
+      }
     });
-    it('sets evaluator correctly from expression', () => {
+    it('sets evaluator as expected', () => {
       // arrange
-      const { createExpression, getInitParameters } = createExpressionFactorySpy();
-      const expectedEvaluate = createEvaluatorStub();
-      const { code, regex } = createCodeAndRegexMatchingOnce();
-      const builder = (): PrimitiveExpression => ({
-        evaluator: expectedEvaluate,
-      });
-      const sut = new RegexParserConcrete({
-        regex,
-        builder,
-        utilities: {
-          createExpression,
-        },
+      const expected = getEvaluatorStub();
+      const regex = /hello/g;
+      const code = 'hello';
+      const builder = (): IPrimitiveExpression => ({
+        evaluator: expected,
       });
+      const sut = new RegexParserConcrete(regex, builder);
       // act
       const expressions = sut.findExpressions(code);
       // assert
       expect(expressions).to.have.lengthOf(1);
-      const actualEvaluate = getInitParameters(expressions[0])?.evaluator;
-      expect(actualEvaluate).to.equal(expectedEvaluate);
+      expect(expressions[0].evaluate === expected);
     });
-    it('sets parameters correctly from expression', () => {
+    it('sets parameters as expected', () => {
       // arrange
-      const expectedParameters: IReadOnlyFunctionParameterCollection['all'] = [
-        new FunctionParameterStub().withName('parameter1').withOptional(true),
-        new FunctionParameterStub().withName('parameter2').withOptional(false),
+      const expected = [
+        new FunctionParameterStub().withName('parameter1').withOptionality(true),
+        new FunctionParameterStub().withName('parameter2').withOptionality(false),
       ];
       const regex = /hello/g;
       const code = 'hello';
-      const builder = (): PrimitiveExpression => ({
-        evaluator: createEvaluatorStub(),
-        parameters: expectedParameters,
-      });
-      const parameterCollection = new FunctionParameterCollectionStub();
-      const parameterCollectionFactoryStub
-      : FunctionParameterCollectionFactory = () => parameterCollection;
-      const { createExpression, getInitParameters } = createExpressionFactorySpy();
-      const sut = new RegexParserConcrete({
-        regex,
-        builder,
-        utilities: {
-          createExpression,
-          createParameterCollection: parameterCollectionFactoryStub,
-        },
+      const builder = (): IPrimitiveExpression => ({
+        evaluator: getEvaluatorStub(),
+        parameters: expected,
       });
+      const sut = new RegexParserConcrete(regex, builder);
       // act
       const expressions = sut.findExpressions(code);
       // assert
       expect(expressions).to.have.lengthOf(1);
-      const actualParameters = getInitParameters(expressions[0])?.parameters;
-      expect(actualParameters).to.equal(parameterCollection);
-      expect(actualParameters?.all).to.deep.equal(expectedParameters);
+      expect(expressions[0].parameters.all).to.deep.equal(expected);
+    });
+    it('sets expected position', () => {
+      // arrange
+      const code = 'mate date in state is fate';
+      const regex = /ate/g;
+      const expected = [
+        new ExpressionPosition(1, 4),
+        new ExpressionPosition(6, 9),
+        new ExpressionPosition(15, 18),
+        new ExpressionPosition(23, 26),
+      ];
+      const sut = new RegexParserConcrete(regex);
+      // act
+      const expressions = sut.findExpressions(code);
+      // assert
+      const actual = expressions.map((e) => e.position);
+      expect(actual).to.deep.equal(expected);
     });
   });
 });
 
-function buildRethrowErrorMessage(
-  expectedContext: {
-    readonly message: string;
-    readonly regex: RegExp;
-    readonly code: string;
-  },
-): string {
-  return [
-    expectedContext.message,
-    `Class name: ${RegexParserConcrete.name}`,
-    `Regex pattern used: ${expectedContext.regex}`,
-    `Code: ${expectedContext.code}`,
-  ].join('\n');
-}
-
-function createExpressionFactorySpy() {
-  const createdExpressions = new Map<IExpression, ExpressionInitParameters>();
-  const createExpression: ExpressionFactory = (parameters) => {
-    const expression = new ExpressionStub();
-    createdExpressions.set(expression, parameters);
-    return expression;
-  };
-  return {
-    createExpression,
-    getInitParameters: (expression) => createdExpressions.get(expression),
-  };
-}
-
-function createBuilderStub(): (match: RegExpMatchArray) => PrimitiveExpression {
+function mockBuilder(): (match: RegExpMatchArray) => IPrimitiveExpression {
   return () => ({
-    evaluator: createEvaluatorStub(),
+    evaluator: getEvaluatorStub(),
   });
 }
-function createEvaluatorStub(): ExpressionEvaluator {
-  return () => `[${createEvaluatorStub.name}] evaluated code`;
+function getEvaluatorStub(): ExpressionEvaluator {
+  return () => `[${getEvaluatorStub.name}] evaluated code`;
 }
 
-function createPrimitiveExpressionStub(): PrimitiveExpression {
+function mockPrimitiveExpression(): IPrimitiveExpression {
   return {
-    evaluator: createEvaluatorStub(),
+    evaluator: getEvaluatorStub(),
   };
 }
 
-function createCodeAndRegexMatchingOnce() {
-  const code = 'expected code in context';
-  const regex = /code/g;
-  return { code, regex };
-}
-
 class RegexParserConcrete extends RegexParser {
-  private readonly builder: RegexParser['buildExpression'];
-
   protected regex: RegExp;
 
-  public constructor(parameters?: {
-    regex?: RegExp,
-    builder?: RegexParser['buildExpression'],
-    utilities?: Partial<RegexParserUtilities>,
-  }) {
-    super({
-      wrapError: parameters?.utilities?.wrapError
-        ?? (() => new Error(`[${RegexParserConcrete}] wrapped error`)),
-      createPosition: parameters?.utilities?.createPosition
-        ?? (() => new ExpressionPosition(0, 5)),
-      createExpression: parameters?.utilities?.createExpression
-        ?? (() => new ExpressionStub()),
-      createParameterCollection: parameters?.utilities?.createParameterCollection
-        ?? (() => new FunctionParameterCollectionStub()),
-    });
-    this.builder = parameters?.builder ?? createBuilderStub();
-    this.regex = parameters?.regex ?? /unimportant/g;
+  public constructor(
+    regex: RegExp,
+    private readonly builder = mockBuilder(),
+  ) {
+    super();
+    this.regex = regex;
   }
 
-  protected buildExpression(match: RegExpMatchArray): PrimitiveExpression {
+  protected buildExpression(match: RegExpMatchArray): IPrimitiveExpression {
     return this.builder(match);
   }
 }

tests/unit/application/Parser/Script/Compiler/Function/Call/Argument/FunctionCallArgument.spec.ts

@@ -17,7 +17,7 @@ describe('FunctionCallArgument', () => {
       itEachAbsentStringValue((absentValue) => {
         // arrange
         const parameterName = 'paramName';
-        const expectedError = `Missing argument value for the parameter "${parameterName}".`;
+        const expectedError = `missing argument value for "${parameterName}"`;
         const argumentValue = absentValue;
         // act
         const act = () => new FunctionCallArgumentBuilder()

tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler.spec.ts

@@ -1,7 +1,7 @@
 /* eslint-disable max-classes-per-file */
 import { describe, it, expect } from 'vitest';
 import { FunctionCallSequenceCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallSequenceCompiler';
-import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
+import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
 import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import type { SingleCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
 import type { CodeSegmentMerger } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CodeSegmentJoin/CodeSegmentMerger';
@@ -17,7 +17,7 @@ import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
 describe('FunctionCallSequenceCompiler', () => {
   describe('instance', () => {
-    itIsSingletonFactory({
+    itIsSingleton({
       getter: () => FunctionCallSequenceCompiler.instance,
       expectedType: FunctionCallSequenceCompiler,
     });

tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/NestedFunctionCallCompiler.spec.ts

@@ -9,9 +9,7 @@ import { SingleCallCompilerStub } from '@tests/unit/shared/Stubs/SingleCallCompi
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
 import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
 import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
-import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
+import { expectDeepThrowsError } from '@tests/shared/Assertions/ExpectDeepThrowsError';
 
 describe('NestedFunctionCallCompiler', () => {
   describe('canCompile', () => {
@@ -45,12 +43,12 @@ describe('NestedFunctionCallCompiler', () => {
         // arrange
         const argumentCompiler = new ArgumentCompilerStub();
         const expectedContext = new FunctionCallCompilationContextStub();
-        const { frontFunction, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
+        const { frontFunc, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
         const compiler = new NestedFunctionCallCompilerBuilder()
           .withArgumentCompiler(argumentCompiler)
           .build();
         // act
-        compiler.compileFunction(frontFunction, callToFrontFunc, expectedContext);
+        compiler.compileFunction(frontFunc, callToFrontFunc, expectedContext);
         // assert
         const calls = argumentCompiler.callHistory.filter((call) => call.methodName === 'createCompiledNestedCall');
         expect(calls).have.lengthOf(1);
@@ -61,37 +59,33 @@ describe('NestedFunctionCallCompiler', () => {
         // arrange
         const argumentCompiler = new ArgumentCompilerStub();
         const expectedContext = new FunctionCallCompilationContextStub();
-        const { frontFunction, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
-        const expectedParentCall = callToFrontFunc;
+        const { frontFunc, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
         const compiler = new NestedFunctionCallCompilerBuilder()
           .withArgumentCompiler(argumentCompiler)
           .build();
         // act
-        compiler.compileFunction(frontFunction, callToFrontFunc, expectedContext);
+        compiler.compileFunction(frontFunc, callToFrontFunc, expectedContext);
         // assert
         const calls = argumentCompiler.callHistory.filter((call) => call.methodName === 'createCompiledNestedCall');
         expect(calls).have.lengthOf(1);
         const [,actualParentCall] = calls[0].args;
-        expect(actualParentCall).to.equal(expectedParentCall);
+        expect(actualParentCall).to.equal(callToFrontFunc);
       });
       it('uses correct nested call', () => {
         // arrange
         const argumentCompiler = new ArgumentCompilerStub();
         const expectedContext = new FunctionCallCompilationContextStub();
-        const {
-          frontFunction, callToDeepFunc, callToFrontFunc,
-        } = createSingleFuncCallingAnotherFunc();
-        const expectedNestedCall = callToDeepFunc;
+        const { frontFunc, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
         const compiler = new NestedFunctionCallCompilerBuilder()
           .withArgumentCompiler(argumentCompiler)
           .build();
         // act
-        compiler.compileFunction(frontFunction, callToFrontFunc, expectedContext);
+        compiler.compileFunction(frontFunc, callToFrontFunc, expectedContext);
         // assert
         const calls = argumentCompiler.callHistory.filter((call) => call.methodName === 'createCompiledNestedCall');
         expect(calls).have.lengthOf(1);
         const [actualNestedCall] = calls[0].args;
-        expect(actualNestedCall).to.deep.equal(expectedNestedCall);
+        expect(actualNestedCall).to.deep.equal(callToFrontFunc);
       });
     });
     describe('re-compilation with compiled args', () => {
@@ -100,11 +94,11 @@ describe('NestedFunctionCallCompiler', () => {
         const singleCallCompilerStub = new SingleCallCompilerStub();
         const expectedContext = new FunctionCallCompilationContextStub()
           .withSingleCallCompiler(singleCallCompilerStub);
-        const { frontFunction, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
+        const { frontFunc, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
         const compiler = new NestedFunctionCallCompilerBuilder()
           .build();
         // act
-        compiler.compileFunction(frontFunction, callToFrontFunc, expectedContext);
+        compiler.compileFunction(frontFunc, callToFrontFunc, expectedContext);
         // assert
         const calls = singleCallCompilerStub.callHistory.filter((call) => call.methodName === 'compileSingleCall');
         expect(calls).have.lengthOf(1);
@@ -119,12 +113,12 @@ describe('NestedFunctionCallCompiler', () => {
         const singleCallCompilerStub = new SingleCallCompilerStub();
         const context = new FunctionCallCompilationContextStub()
           .withSingleCallCompiler(singleCallCompilerStub);
-        const { frontFunction, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
+        const { frontFunc, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
         const compiler = new NestedFunctionCallCompilerBuilder()
           .withArgumentCompiler(argumentCompilerStub)
           .build();
         // act
-        compiler.compileFunction(frontFunction, callToFrontFunc, context);
+        compiler.compileFunction(frontFunc, callToFrontFunc, context);
         // assert
         const calls = singleCallCompilerStub.callHistory.filter((call) => call.methodName === 'compileSingleCall');
         expect(calls).have.lengthOf(1);
@@ -146,9 +140,9 @@ describe('NestedFunctionCallCompiler', () => {
         .withScenario({ givenNestedFunctionCall: callToDeepFunc1, result: callToDeepFunc1 })
         .withScenario({ givenNestedFunctionCall: callToDeepFunc2, result: callToDeepFunc2 });
       const expectedFlattenedCodes = [...singleCallCompilationScenario.values()].flat();
-      const frontFunction = createSharedFunctionStubWithCalls()
+      const frontFunc = createSharedFunctionStubWithCalls()
         .withCalls(callToDeepFunc1, callToDeepFunc2);
-      const callToFrontFunc = new FunctionCallStub().withFunctionName(frontFunction.name);
+      const callToFrontFunc = new FunctionCallStub().withFunctionName(frontFunc.name);
       const singleCallCompilerStub = new SingleCallCompilerStub()
         .withCallCompilationScenarios(singleCallCompilationScenario);
       const expectedContext = new FunctionCallCompilationContextStub()
@@ -157,105 +151,73 @@ describe('NestedFunctionCallCompiler', () => {
         .withArgumentCompiler(argumentCompiler)
         .build();
       // act
-      const actualCodes = compiler.compileFunction(frontFunction, callToFrontFunc, expectedContext);
+      const actualCodes = compiler.compileFunction(frontFunc, callToFrontFunc, expectedContext);
       // assert
       expect(actualCodes).have.lengthOf(expectedFlattenedCodes.length);
       expect(actualCodes).to.have.members(expectedFlattenedCodes);
     });
     describe('error handling', () => {
-      describe('rethrows error from argument compiler', () => {
+      it('handles argument compiler errors', () => {
         // arrange
-        const expectedInnerError = new Error(`Expected error from ${ArgumentCompilerStub.name}`);
-        const calleeFunctionName = 'expectedCalleeFunctionName';
-        const callerFunctionName = 'expectedCallerFunctionName';
-        const expectedErrorMessage = buildRethrowErrorMessage({
-          callee: calleeFunctionName,
-          caller: callerFunctionName,
-        });
-        const { frontFunction, callToFrontFunc } = createSingleFuncCallingAnotherFunc({
-          frontFunctionName: callerFunctionName,
-          deepFunctionName: calleeFunctionName,
-        });
+        const argumentCompilerError = new Error('Test error');
         const argumentCompilerStub = new ArgumentCompilerStub();
         argumentCompilerStub.createCompiledNestedCall = () => {
-          throw expectedInnerError;
+          throw argumentCompilerError;
         };
-        const builder = new NestedFunctionCallCompilerBuilder()
-          .withArgumentCompiler(argumentCompilerStub);
-        itThrowsContextualError({
-          // act
-          throwingAction: (wrapError) => {
-            builder
-              .withErrorWrapper(wrapError)
-              .build()
-              .compileFunction(
-                frontFunction,
-                callToFrontFunc,
-                new FunctionCallCompilationContextStub(),
-              );
-          },
-          // assert
-          expectedWrappedError: expectedInnerError,
-          expectedContextMessage: expectedErrorMessage,
-        });
+        const { frontFunc, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
+        const expectedError = new AggregateError(
+          [argumentCompilerError],
+          `Error with call to "${callToFrontFunc.functionName}" function from "${callToFrontFunc.functionName}" function`,
+        );
+        const compiler = new NestedFunctionCallCompilerBuilder()
+          .withArgumentCompiler(argumentCompilerStub)
+          .build();
+        // act
+        const act = () => compiler.compileFunction(
+          frontFunc,
+          callToFrontFunc,
+          new FunctionCallCompilationContextStub(),
+        );
+        // assert
+        expectDeepThrowsError(act, expectedError);
       });
-      describe('rethrows error from single call compiler', () => {
+      it('handles single call compiler errors', () => {
         // arrange
-        const expectedInnerError = new Error(`Expected error from ${SingleCallCompilerStub.name}`);
-        const calleeFunctionName = 'expectedCalleeFunctionName';
-        const callerFunctionName = 'expectedCallerFunctionName';
-        const expectedErrorMessage = buildRethrowErrorMessage({
-          callee: calleeFunctionName,
-          caller: callerFunctionName,
-        });
-        const { frontFunction, callToFrontFunc } = createSingleFuncCallingAnotherFunc({
-          frontFunctionName: callerFunctionName,
-          deepFunctionName: calleeFunctionName,
-        });
+        const singleCallCompilerError = new Error('Test error');
         const singleCallCompiler = new SingleCallCompilerStub();
         singleCallCompiler.compileSingleCall = () => {
-          throw expectedInnerError;
+          throw singleCallCompilerError;
         };
         const context = new FunctionCallCompilationContextStub()
           .withSingleCallCompiler(singleCallCompiler);
-        const builder = new NestedFunctionCallCompilerBuilder();
-        itThrowsContextualError({
-          // act
-          throwingAction: (wrapError) => {
-            builder
-              .withErrorWrapper(wrapError)
-              .build()
-              .compileFunction(
-                frontFunction,
-                callToFrontFunc,
-                context,
-              );
-          },
-          // assert
-          expectedWrappedError: expectedInnerError,
-          expectedContextMessage: expectedErrorMessage,
-        });
+        const { frontFunc, callToFrontFunc } = createSingleFuncCallingAnotherFunc();
+        const expectedError = new AggregateError(
+          [singleCallCompilerError],
+          `Error with call to "${callToFrontFunc.functionName}" function from "${callToFrontFunc.functionName}" function`,
+        );
+        const compiler = new NestedFunctionCallCompilerBuilder()
+          .build();
+        // act
+        const act = () => compiler.compileFunction(
+          frontFunc,
+          callToFrontFunc,
+          context,
+        );
+        // assert
+        expectDeepThrowsError(act, expectedError);
       });
     });
   });
 });
 
-function createSingleFuncCallingAnotherFunc(
-  functionNames?: {
-    readonly frontFunctionName?: string;
-    readonly deepFunctionName?: string;
-  },
-) {
-  const deepFunction = createSharedFunctionStubWithCode()
-    .withName(functionNames?.deepFunctionName ?? 'deep-function (is called by front-function)');
-  const callToDeepFunc = new FunctionCallStub().withFunctionName(deepFunction.name);
-  const frontFunction = createSharedFunctionStubWithCalls()
-    .withCalls(callToDeepFunc)
-    .withName(functionNames?.frontFunctionName ?? 'front-function (calls deep-function)');
-  const callToFrontFunc = new FunctionCallStub().withFunctionName(frontFunction.name);
+function createSingleFuncCallingAnotherFunc() {
+  const deepFunc = createSharedFunctionStubWithCode();
+  const callToDeepFunc = new FunctionCallStub().withFunctionName(deepFunc.name);
+  const frontFunc = createSharedFunctionStubWithCalls().withCalls(callToDeepFunc);
+  const callToFrontFunc = new FunctionCallStub().withFunctionName(frontFunc.name);
   return {
-    deepFunction,
-    frontFunction,
+    deepFunc,
+    frontFunc,
     callToFrontFunc,
     callToDeepFunc,
   };
@@ -264,31 +226,14 @@ function createSingleFuncCallingAnotherFunc(
 class NestedFunctionCallCompilerBuilder {
   private argumentCompiler: ArgumentCompiler = new ArgumentCompilerStub();
 
-  private wrapError: ErrorWithContextWrapper = errorWithContextWrapperStub;
-
   public withArgumentCompiler(argumentCompiler: ArgumentCompiler): this {
     this.argumentCompiler = argumentCompiler;
     return this;
   }
 
-  public withErrorWrapper(wrapError: ErrorWithContextWrapper): this {
-    this.wrapError = wrapError;
-    return this;
-  }
-
   public build(): NestedFunctionCallCompiler {
     return new NestedFunctionCallCompiler(
       this.argumentCompiler,
-      this.wrapError,
     );
   }
 }
-
-function buildRethrowErrorMessage(
-  functionNames: {
-    readonly caller: string;
-    readonly callee: string;
-  },
-) {
-  return `Failed to call '${functionNames.callee}' (callee function) from '${functionNames.caller}' (caller function).`;
-}

tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/AdaptiveFunctionCallCompiler.spec.ts

@@ -11,7 +11,6 @@ import type { FunctionCallCompilationContext } from '@/application/Parser/Script
 import { FunctionCallCompilationContextStub } from '@tests/unit/shared/Stubs/FunctionCallCompilationContextStub';
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
 import type { SingleCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/SingleCallCompiler';
-import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
 
 describe('AdaptiveFunctionCallCompiler', () => {
   describe('compileSingleCall', () => {
@@ -29,40 +28,40 @@ describe('AdaptiveFunctionCallCompiler', () => {
           functionParameters: ['expected-parameter'],
           callParameters: ['unexpected-parameter'],
           expectedError:
-            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter".`
-            + '\nExpected parameter(s): "expected-parameter"',
+            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter"`
+            + '. Expected parameter(s): "expected-parameter"',
         },
         {
           description: 'provided: multiple unexpected parameters, when: different one is expected',
           functionParameters: ['expected-parameter'],
           callParameters: ['unexpected-parameter1', 'unexpected-parameter2'],
           expectedError:
-            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter1", "unexpected-parameter2".`
-            + '\nExpected parameter(s): "expected-parameter"',
+            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter1", "unexpected-parameter2"`
+            + '. Expected parameter(s): "expected-parameter"',
         },
         {
           description: 'provided: an unexpected parameter, when: multiple parameters are expected',
           functionParameters: ['expected-parameter1', 'expected-parameter2'],
           callParameters: ['expected-parameter1', 'expected-parameter2', 'unexpected-parameter'],
           expectedError:
-            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter".`
-            + '\nExpected parameter(s): "expected-parameter1", "expected-parameter2"',
+            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter"`
+            + '. Expected parameter(s): "expected-parameter1", "expected-parameter2"',
         },
         {
           description: 'provided: an unexpected parameter, when: none required',
           functionParameters: [],
           callParameters: ['unexpected-call-parameter'],
           expectedError:
-            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-call-parameter".`
-            + '\nExpected parameter(s): none',
+            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-call-parameter"`
+            + '. Expected parameter(s): none',
         },
         {
           description: 'provided: expected and unexpected parameter, when: one of them is expected',
           functionParameters: ['expected-parameter'],
           callParameters: ['expected-parameter', 'unexpected-parameter'],
           expectedError:
-            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter".`
-            + '\nExpected parameter(s): "expected-parameter"',
+            `Function "${functionName}" has unexpected parameter(s) provided: "unexpected-parameter"`
+            + '. Expected parameter(s): "expected-parameter"',
         },
       ];
       testCases.forEach(({
@@ -89,8 +88,7 @@ describe('AdaptiveFunctionCallCompiler', () => {
           // act
           const act = () => builder.compileSingleCall();
           // assert
-          const errorMessage = collectExceptionMessage(act);
-          expect(errorMessage).to.include(expectedError);
+          expect(act).to.throw(expectedError);
         });
       });
     });

tests/unit/application/Parser/Script/Compiler/Function/Call/Compiler/SingleCall/Strategies/Argument/NestedFunctionArgumentCompiler.spec.ts

@@ -7,44 +7,38 @@ import type { IExpressionsCompiler } from '@/application/Parser/Script/Compiler/
 import { ExpressionsCompilerStub } from '@tests/unit/shared/Stubs/ExpressionsCompilerStub';
 import { FunctionCallCompilationContextStub } from '@tests/unit/shared/Stubs/FunctionCallCompilationContextStub';
 import { FunctionCallStub } from '@tests/unit/shared/Stubs/FunctionCallStub';
+import { expectDeepThrowsError } from '@tests/shared/Assertions/ExpectDeepThrowsError';
 import { FunctionCallArgumentCollectionStub } from '@tests/unit/shared/Stubs/FunctionCallArgumentCollectionStub';
 import { createSharedFunctionStubWithCode } from '@tests/unit/shared/Stubs/SharedFunctionStub';
 import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
 import { SharedFunctionCollectionStub } from '@tests/unit/shared/Stubs/SharedFunctionCollectionStub';
-import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
 
 describe('NestedFunctionArgumentCompiler', () => {
   describe('createCompiledNestedCall', () => {
-    describe('rethrows error from expressions compiler', () => {
+    it('should handle error from expressions compiler', () => {
       // arrange
-      const expectedInnerError = new Error('child-');
       const parameterName = 'parameterName';
-      const expectedErrorMessage = `Error when compiling argument for "${parameterName}"`;
       const nestedCall = new FunctionCallStub()
         .withFunctionName('nested-function-call')
         .withArgumentCollection(new FunctionCallArgumentCollectionStub()
           .withArgument(parameterName, 'unimportant-value'));
       const parentCall = new FunctionCallStub()
         .withFunctionName('parent-function-call');
+      const expressionsCompilerError = new Error('child-');
+      const expectedError = new AggregateError(
+        [expressionsCompilerError],
+        `Error when compiling argument for "${parameterName}"`,
+      );
       const expressionsCompiler = new ExpressionsCompilerStub();
-      expressionsCompiler.compileExpressions = () => { throw expectedInnerError; };
+      expressionsCompiler.compileExpressions = () => { throw expressionsCompilerError; };
       const builder = new NestedFunctionArgumentCompilerBuilder()
         .withParentFunctionCall(parentCall)
         .withNestedFunctionCall(nestedCall)
         .withExpressionsCompiler(expressionsCompiler);
-      itThrowsContextualError({
-        // act
-        throwingAction: (wrapError) => {
-          builder
-            .withErrorWrapper(wrapError)
-            .createCompiledNestedCall();
-        },
-        // assert
-        expectedWrappedError: expectedInnerError,
-        expectedContextMessage: expectedErrorMessage,
-      });
+      // act
+      const act = () => builder.createCompiledNestedCall();
+      // assert
+      expectDeepThrowsError(act, expectedError);
     });
     describe('compilation', () => {
       describe('without arguments', () => {
@@ -264,8 +258,6 @@ class NestedFunctionArgumentCompilerBuilder implements ArgumentCompiler {
 
   private context: FunctionCallCompilationContext = new FunctionCallCompilationContextStub();
 
-  private wrapError: ErrorWithContextWrapper = errorWithContextWrapperStub;
-
   public withExpressionsCompiler(expressionsCompiler: IExpressionsCompiler): this {
     this.expressionsCompiler = expressionsCompiler;
     return this;
@@ -286,16 +278,8 @@ class NestedFunctionArgumentCompilerBuilder implements ArgumentCompiler {
     return this;
   }
 
-  public withErrorWrapper(wrapError: ErrorWithContextWrapper): this {
-    this.wrapError = wrapError;
-    return this;
-  }
-
   public createCompiledNestedCall(): FunctionCall {
-    const compiler = new NestedFunctionArgumentCompiler(
-      this.expressionsCompiler,
-      this.wrapError,
-    );
+    const compiler = new NestedFunctionArgumentCompiler(this.expressionsCompiler);
     return compiler.createCompiledNestedCall(
       this.nestedFunctionCall,
       this.parentFunctionCall,

tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection.spec.ts

@@ -7,8 +7,8 @@ describe('FunctionParameterCollection', () => {
     // arrange
     const expected = [
       new FunctionParameterStub().withName('1'),
-      new FunctionParameterStub().withName('2').withOptional(true),
-      new FunctionParameterStub().withName('3').withOptional(false),
+      new FunctionParameterStub().withName('2').withOptionality(true),
+      new FunctionParameterStub().withName('3').withOptionality(false),
     ];
     const sut = new FunctionParameterCollection();
     for (const parameter of expected) {

tests/unit/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory.spec.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { FunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollection';
-import { createFunctionParameterCollection } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
-import { itIsTransientFactory } from '@tests/unit/shared/TestCases/TransientFactoryTests';
-
-describe('FunctionParameterCollectionFactory', () => {
-  describe('createFunctionParameterCollection', () => {
-    describe('it is a transient factory', () => {
-      itIsTransientFactory({
-        getter: () => createFunctionParameterCollection(),
-        expectedType: FunctionParameterCollection,
-      });
-    });
-    it('returns an empty collection', () => {
-      // arrange
-      const expectedInitialParametersCount = 0;
-      // act
-      const collection = createFunctionParameterCollection();
-      // assert
-      expect(collection.all).to.have.lengthOf(expectedInitialParametersCount);
-    });
-  });
-});

tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionCollection.spec.ts

@@ -35,7 +35,7 @@ describe('SharedFunctionCollection', () => {
     it('throws if function does not exist', () => {
       // arrange
       const name = 'unique-name';
-      const expectedError = `Called function is not defined: "${name}"`;
+      const expectedError = `called function is not defined "${name}"`;
       const func = createSharedFunctionStubWithCode()
         .withName('unexpected-name');
       const sut = new SharedFunctionCollection();

tests/unit/application/Parser/Script/Compiler/Function/SharedFunctionsParser.spec.ts

@@ -1,29 +1,25 @@
 import { describe, it, expect } from 'vitest';
 import type { FunctionData, CodeInstruction } from '@/application/collections/';
 import type { ISharedFunction } from '@/application/Parser/Script/Compiler/Function/ISharedFunction';
-import { SharedFunctionsParser, type FunctionParameterFactory } from '@/application/Parser/Script/Compiler/Function/SharedFunctionsParser';
+import { SharedFunctionsParser } from '@/application/Parser/Script/Compiler/Function/SharedFunctionsParser';
 import { createFunctionDataWithCode, createFunctionDataWithoutCallOrCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
 import { ParameterDefinitionDataStub } from '@tests/unit/shared/Stubs/ParameterDefinitionDataStub';
+import { FunctionParameter } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameter';
 import { FunctionCallDataStub } from '@tests/unit/shared/Stubs/FunctionCallDataStub';
 import { itEachAbsentCollectionValue } from '@tests/unit/shared/TestCases/AbsentTests';
 import type { ILanguageSyntax } from '@/application/Parser/Script/Validation/Syntax/ILanguageSyntax';
 import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
-import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
+import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
 import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
 import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
 import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
 import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { FunctionParameterStub } from '@tests/unit/shared/Stubs/FunctionParameterStub';
-import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
-import { itThrowsContextualError } from '@tests/unit/application/Parser/ContextualErrorTester';
-import type { FunctionParameterCollectionFactory } from '@/application/Parser/Script/Compiler/Function/Parameter/FunctionParameterCollectionFactory';
-import { FunctionParameterCollectionStub } from '@tests/unit/shared/Stubs/FunctionParameterCollectionStub';
+import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
 import { expectCallsFunctionBody, expectCodeFunctionBody } from './ExpectFunctionBodyType';
 
 describe('SharedFunctionsParser', () => {
   describe('instance', () => {
-    itIsSingletonFactory({
+    itIsSingleton({
       getter: () => SharedFunctionsParser.instance,
       expectedType: SharedFunctionsParser,
     });
@@ -131,7 +127,7 @@ describe('SharedFunctionsParser', () => {
         });
       });
       describe('throws when parameters type is not as expected', () => {
-        const testScenarios = [
+        const testCases = [
           {
             state: 'when not an array',
             invalidType: 5,
@@ -141,7 +137,7 @@ describe('SharedFunctionsParser', () => {
             invalidType: ['a', { a: 'b' }],
           },
         ];
-        for (const testCase of testScenarios) {
+        for (const testCase of testCases) {
           it(testCase.state, () => {
             // arrange
             const func = createFunctionDataWithCode()
@@ -174,33 +170,25 @@ describe('SharedFunctionsParser', () => {
           rules: expectedRules,
         });
       });
-      describe('parameter creation', () => {
-        describe('rethrows including function name when creating parameter throws', () => {
-          // arrange
-          const invalidParameterName = 'invalid-function-parameter-name';
-          const functionName = 'functionName';
-          const expectedErrorMessage = `Failed to create parameter: ${invalidParameterName} for function "${functionName}"`;
-          const expectedInnerError = new Error('injected error');
-          const parameterFactory: FunctionParameterFactory = () => {
-            throw expectedInnerError;
-          };
-          const functionData = createFunctionDataWithCode()
-            .withName(functionName)
-            .withParameters(new ParameterDefinitionDataStub().withName(invalidParameterName));
-          itThrowsContextualError({
-            // act
-            throwingAction: (wrapError) => {
-              new ParseFunctionsCallerWithDefaults()
-                .withFunctions([functionData])
-                .withFunctionParameterFactory(parameterFactory)
-                .withErrorWrapper(wrapError)
-                .parseFunctions();
-            },
-            // assert
-            expectedWrappedError: expectedInnerError,
-            expectedContextMessage: expectedErrorMessage,
-          });
-        });
+      it('rethrows including function name when FunctionParameter throws', () => {
+        // arrange
+        const invalidParameterName = 'invalid function p@r4meter name';
+        const functionName = 'functionName';
+        const message = collectExceptionMessage(
+          () => new FunctionParameter(invalidParameterName, false),
+        );
+        const expectedError = `"${functionName}": ${message}`;
+        const functionData = createFunctionDataWithCode()
+          .withName(functionName)
+          .withParameters(new ParameterDefinitionDataStub().withName(invalidParameterName));
+
+        // act
+        const act = () => new ParseFunctionsCallerWithDefaults()
+          .withFunctions([functionData])
+          .parseFunctions();
+
+        // assert
+        expect(act).to.throw(expectedError);
       });
     });
     describe('given empty functions, returns empty collection', () => {
@@ -294,18 +282,6 @@ class ParseFunctionsCallerWithDefaults {
 
   private functions: readonly FunctionData[] = [createFunctionDataWithCode()];
 
-  private wrapError: ErrorWithContextWrapper = errorWithContextWrapperStub;
-
-  private parameterFactory: FunctionParameterFactory = (
-    name: string,
-    isOptional: boolean,
-  ) => new FunctionParameterStub()
-    .withName(name)
-    .withOptional(isOptional);
-
-  private parameterCollectionFactory
-  : FunctionParameterCollectionFactory = () => new FunctionParameterCollectionStub();
-
   public withSyntax(syntax: ILanguageSyntax) {
     this.syntax = syntax;
     return this;
@@ -321,32 +297,8 @@ class ParseFunctionsCallerWithDefaults {
     return this;
   }
 
-  public withErrorWrapper(wrapError: ErrorWithContextWrapper): this {
-    this.wrapError = wrapError;
-    return this;
-  }
-
-  public withFunctionParameterFactory(parameterFactory: FunctionParameterFactory): this {
-    this.parameterFactory = parameterFactory;
-    return this;
-  }
-
-  public withParameterCollectionFactory(
-    parameterCollectionFactory: FunctionParameterCollectionFactory,
-  ): this {
-    this.parameterCollectionFactory = parameterCollectionFactory;
-    return this;
-  }
-
   public parseFunctions() {
-    const sut = new SharedFunctionsParser(
-      {
-        codeValidator: this.codeValidator,
-        wrapError: this.wrapError,
-        createParameter: this.parameterFactory,
-        createParameterCollection: this.parameterCollectionFactory,
-      },
-    );
+    const sut = new SharedFunctionsParser(this.codeValidator);
     return sut.parseFunctions(this.functions, this.syntax);
   }
 }

tests/unit/application/Parser/Script/Compiler/ScriptCompiler.spec.ts

@@ -1,7 +1,9 @@
 import { describe, it, expect } from 'vitest';
 import type { FunctionData } from '@/application/collections/';
+import { ScriptCode } from '@/domain/ScriptCode';
 import { ScriptCompiler } from '@/application/Parser/Script/Compiler/ScriptCompiler';
 import type { ISharedFunctionsParser } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionsParser';
+import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/CompiledCode';
 import type { FunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler';
 import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
 import { createFunctionDataWithCode } from '@tests/unit/shared/Stubs/FunctionDataStub';
@@ -15,13 +17,8 @@ import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICod
 import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
 import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
 import { CompiledCodeStub } from '@tests/unit/shared/Stubs/CompiledCodeStub';
+import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
 import { createScriptDataWithCall, createScriptDataWithCode } from '@tests/unit/shared/Stubs/ScriptDataStub';
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { errorWithContextWrapperStub } from '@tests/unit/shared/Stubs/ErrorWithContextWrapperStub';
-import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
-import { createScriptCodeFactoryStub } from '@tests/unit/shared/Stubs/ScriptCodeFactoryStub';
-import { itThrowsContextualError } from '../../ContextualErrorTester';
 
 describe('ScriptCompiler', () => {
   describe('canCompile', () => {
@@ -61,59 +58,31 @@ describe('ScriptCompiler', () => {
       // assert
       expect(act).to.throw(expectedError);
     });
-    describe('code construction', () => {
-      it('returns code from the factory', () => {
-        // arrange
-        const expectedCode = new ScriptCodeStub();
-        const scriptCodeFactory = () => expectedCode;
-        const sut = new ScriptCompilerBuilder()
-          .withSomeFunctions()
-          .withScriptCodeFactory(scriptCodeFactory)
-          .build();
-        // act
-        const actualCode = sut.compile(createScriptDataWithCall());
-        // assert
-        expect(actualCode).to.equal(expectedCode);
-      });
-      it('creates code correctly', () => {
-        // arrange
-        const expectedCode = 'expected-code';
-        const expectedRevertCode = 'expected-revert-code';
-        let actualCode: string | undefined;
-        let actualRevertCode: string | undefined;
-        const scriptCodeFactory = (code: string, revertCode: string) => {
-          actualCode = code;
-          actualRevertCode = revertCode;
-          return new ScriptCodeStub();
-        };
-        const call = new FunctionCallDataStub();
-        const script = createScriptDataWithCall(call);
-        const functions = [createFunctionDataWithCode().withName('existing-func')];
-        const compiledFunctions = new SharedFunctionCollectionStub();
-        const functionParserMock = new SharedFunctionsParserStub();
-        functionParserMock.setup(functions, compiledFunctions);
-        const callCompilerMock = new FunctionCallCompilerStub();
-        callCompilerMock.setup(
-          parseFunctionCalls(call),
-          compiledFunctions,
-          new CompiledCodeStub()
-            .withCode(expectedCode)
-            .withRevertCode(expectedRevertCode),
-        );
-        const sut = new ScriptCompilerBuilder()
-          .withFunctions(...functions)
-          .withSharedFunctionsParser(functionParserMock)
-          .withFunctionCallCompiler(callCompilerMock)
-          .withScriptCodeFactory(scriptCodeFactory)
-          .build();
-        // act
-        sut.compile(script);
-        // assert
-        expect(actualCode).to.equal(expectedCode);
-        expect(actualRevertCode).to.equal(expectedRevertCode);
-      });
+    it('returns code as expected', () => {
+      // arrange
+      const expected: CompiledCode = {
+        code: 'expected-code',
+        revertCode: 'expected-revert-code',
+      };
+      const call = new FunctionCallDataStub();
+      const script = createScriptDataWithCall(call);
+      const functions = [createFunctionDataWithCode().withName('existing-func')];
+      const compiledFunctions = new SharedFunctionCollectionStub();
+      const functionParserMock = new SharedFunctionsParserStub();
+      functionParserMock.setup(functions, compiledFunctions);
+      const callCompilerMock = new FunctionCallCompilerStub();
+      callCompilerMock.setup(parseFunctionCalls(call), compiledFunctions, expected);
+      const sut = new ScriptCompilerBuilder()
+        .withFunctions(...functions)
+        .withSharedFunctionsParser(functionParserMock)
+        .withFunctionCallCompiler(callCompilerMock)
+        .build();
+      // act
+      const code = sut.compile(script);
+      // assert
+      expect(code.execute).to.equal(expected.code);
+      expect(code.revert).to.equal(expected.revertCode);
     });
-
     describe('parses functions as expected', () => {
       it('parses functions with expected syntax', () => {
         // arrange
@@ -147,57 +116,49 @@ describe('ScriptCompiler', () => {
         expect(parser.callHistory[0].functions).to.deep.equal(expectedFunctions);
       });
     });
-    describe('rethrows error with script name', () => {
+    it('rethrows error with script name', () => {
       // arrange
       const scriptName = 'scriptName';
-      const expectedErrorMessage = `Failed to compile script: ${scriptName}`;
-      const expectedInnerError = new Error();
+      const innerError = 'innerError';
+      const expectedError = `Script "${scriptName}" ${innerError}`;
       const callCompiler: FunctionCallCompiler = {
-        compileFunctionCalls: () => { throw expectedInnerError; },
+        compileFunctionCalls: () => { throw new Error(innerError); },
       };
       const scriptData = createScriptDataWithCall()
         .withName(scriptName);
-      const builder = new ScriptCompilerBuilder()
+      const sut = new ScriptCompilerBuilder()
         .withSomeFunctions()
-        .withFunctionCallCompiler(callCompiler);
-      itThrowsContextualError({
-        // act
-        throwingAction: (wrapError) => {
-          builder
-            .withErrorWrapper(wrapError)
-            .build()
-            .compile(scriptData);
-        },
-        // assert
-        expectedWrappedError: expectedInnerError,
-        expectedContextMessage: expectedErrorMessage,
-      });
+        .withFunctionCallCompiler(callCompiler)
+        .build();
+      // act
+      const act = () => sut.compile(scriptData);
+      // assert
+      expect(act).to.throw(expectedError);
     });
-    describe('rethrows error from script code factory with script name', () => {
+    it('rethrows error from ScriptCode with script name', () => {
       // arrange
       const scriptName = 'scriptName';
-      const expectedErrorMessage = `Failed to compile script: ${scriptName}`;
-      const expectedInnerError = new Error();
-      const scriptCodeFactory: ScriptCodeFactory = () => {
-        throw expectedInnerError;
+      const syntax = new LanguageSyntaxStub();
+      const invalidCode = new CompiledCodeStub()
+        .withCode('' /* invalid code (empty string) */);
+      const realExceptionMessage = collectExceptionMessage(
+        () => new ScriptCode(invalidCode.code, invalidCode.revertCode),
+      );
+      const expectedError = `Script "${scriptName}" ${realExceptionMessage}`;
+      const callCompiler: FunctionCallCompiler = {
+        compileFunctionCalls: () => invalidCode,
       };
       const scriptData = createScriptDataWithCall()
         .withName(scriptName);
-      const builder = new ScriptCompilerBuilder()
+      const sut = new ScriptCompilerBuilder()
         .withSomeFunctions()
-        .withScriptCodeFactory(scriptCodeFactory);
-      itThrowsContextualError({
-        // act
-        throwingAction: (wrapError) => {
-          builder
-            .withErrorWrapper(wrapError)
-            .build()
-            .compile(scriptData);
-        },
-        // assert
-        expectedWrappedError: expectedInnerError,
-        expectedContextMessage: expectedErrorMessage,
-      });
+        .withFunctionCallCompiler(callCompiler)
+        .withSyntax(syntax)
+        .build();
+      // act
+      const act = () => sut.compile(scriptData);
+      // assert
+      expect(act).to.throw(expectedError);
     });
     it('validates compiled code as expected', () => {
       // arrange
@@ -205,27 +166,17 @@ describe('ScriptCompiler', () => {
         NoEmptyLines,
         // Allow duplicated lines to enable calling same function multiple times
       ];
-      const expectedExecuteCode = 'execute code to be validated';
-      const expectedRevertCode = 'revert code to be validated';
       const scriptData = createScriptDataWithCall();
       const validator = new CodeValidatorStub();
       const sut = new ScriptCompilerBuilder()
         .withSomeFunctions()
         .withCodeValidator(validator)
-        .withFunctionCallCompiler(
-          new FunctionCallCompilerStub()
-            .withDefaultCompiledCode(
-              new CompiledCodeStub()
-                .withCode(expectedExecuteCode)
-                .withRevertCode(expectedRevertCode),
-            ),
-        )
         .build();
       // act
-      sut.compile(scriptData);
+      const compilationResult = sut.compile(scriptData);
       // assert
       validator.assertHistory({
-        validatedCodes: [expectedExecuteCode, expectedRevertCode],
+        validatedCodes: [compilationResult.execute, compilationResult.revert],
         rules: expectedRules,
       });
     });
@@ -249,12 +200,6 @@ class ScriptCompilerBuilder {
 
   private codeValidator: ICodeValidator = new CodeValidatorStub();
 
-  private wrapError: ErrorWithContextWrapper = errorWithContextWrapperStub;
-
-  private scriptCodeFactory: ScriptCodeFactory = createScriptCodeFactoryStub({
-    defaultCodePrefix: ScriptCompilerBuilder.name,
-  });
-
   public withFunctions(...functions: FunctionData[]): this {
     this.functions = functions;
     return this;
@@ -299,16 +244,6 @@ class ScriptCompilerBuilder {
     return this;
   }
 
-  public withErrorWrapper(wrapError: ErrorWithContextWrapper): this {
-    this.wrapError = wrapError;
-    return this;
-  }
-
-  public withScriptCodeFactory(scriptCodeFactory: ScriptCodeFactory): this {
-    this.scriptCodeFactory = scriptCodeFactory;
-    return this;
-  }
-
   public build(): ScriptCompiler {
     if (!this.functions) {
       throw new Error('Function behavior not defined');
@@ -319,8 +254,6 @@ class ScriptCompilerBuilder {
       this.sharedFunctionsParser,
       this.callCompiler,
       this.codeValidator,
-      this.wrapError,
-      this.scriptCodeFactory,
     );
   }
 }

tests/unit/application/Parser/Script/ScriptParser.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from 'vitest';
 import type { ScriptData } from '@/application/collections/';
-import { parseScript, type ScriptFactory } from '@/application/Parser/Script/ScriptParser';
-import { type DocsParser } from '@/application/Parser/DocumentationParser';
+import { parseScript, type ScriptFactoryType } from '@/application/Parser/Script/ScriptParser';
+import { parseDocs } from '@/application/Parser/DocumentationParser';
 import { RecommendationLevel } from '@/domain/RecommendationLevel';
 import type { ICategoryCollectionParseContext } from '@/application/Parser/Script/ICategoryCollectionParseContext';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
@@ -11,88 +11,54 @@ import { EnumParserStub } from '@tests/unit/shared/Stubs/EnumParserStub';
 import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
 import { CategoryCollectionParseContextStub } from '@tests/unit/shared/Stubs/CategoryCollectionParseContextStub';
 import { LanguageSyntaxStub } from '@tests/unit/shared/Stubs/LanguageSyntaxStub';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
+import { expectThrowsNodeError, type ITestScenario, NodeValidationTestRunner } from '@tests/unit/application/Parser/NodeValidation/NodeValidatorTestRunner';
 import { Script } from '@/domain/Script';
 import type { IEnumParser } from '@/application/Common/Enum';
 import { NoEmptyLines } from '@/application/Parser/Script/Validation/Rules/NoEmptyLines';
 import { NoDuplicatedLines } from '@/application/Parser/Script/Validation/Rules/NoDuplicatedLines';
 import { CodeValidatorStub } from '@tests/unit/shared/Stubs/CodeValidatorStub';
 import type { ICodeValidator } from '@/application/Parser/Script/Validation/ICodeValidator';
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-import { ErrorWrapperStub } from '@tests/unit/shared/Stubs/ErrorWrapperStub';
-import type { NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import { NodeDataValidatorStub, createNodeDataValidatorFactoryStub } from '@tests/unit/shared/Stubs/NodeDataValidatorStub';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
-import type { ScriptNodeErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
-import { createScriptCodeFactoryStub } from '@tests/unit/shared/Stubs/ScriptCodeFactoryStub';
-import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
-import { createScriptFactorySpy } from '@tests/unit/shared/Stubs/ScriptFactoryStub';
-import { expectExists } from '@tests/shared/Assertions/ExpectExists';
-import { itThrowsContextualError } from '../ContextualErrorTester';
-import { itAsserts, itValidatesDefinedData, itValidatesName } from '../NodeDataValidationTester';
-import { generateDataValidationTestScenarios } from '../DataValidationTestScenarioGenerator';
 
 describe('ScriptParser', () => {
   describe('parseScript', () => {
-    it('parses name correctly', () => {
+    it('parses name as expected', () => {
       // arrange
       const expected = 'test-expected-name';
-      const scriptData = createScriptDataWithCode()
+      const script = createScriptDataWithCode()
         .withName(expected);
-      const { scriptFactorySpy, getInitParameters } = createScriptFactorySpy();
       // act
-      const actualScript = new TestContext()
-        .withData(scriptData)
-        .withScriptFactory(scriptFactorySpy)
+      const actual = new TestBuilder()
+        .withData(script)
         .parseScript();
       // assert
-      const actualName = getInitParameters(actualScript)?.name;
-      expect(actualName).to.equal(expected);
+      expect(actual.name).to.equal(expected);
     });
-    it('parses docs correctly', () => {
+    it('parses docs as expected', () => {
       // arrange
-      const expectedDocs = ['https://expected-doc1.com', 'https://expected-doc2.com'];
-      const { scriptFactorySpy, getInitParameters } = createScriptFactorySpy();
-      const scriptData = createScriptDataWithCode()
-        .withDocs(expectedDocs);
-      const docsParser: DocsParser = (data) => data.docs as typeof expectedDocs;
+      const docs = ['https://expected-doc1.com', 'https://expected-doc2.com'];
+      const script = createScriptDataWithCode()
+        .withDocs(docs);
+      const expected = parseDocs(script);
       // act
-      const actualScript = new TestContext()
-        .withData(scriptData)
-        .withScriptFactory(scriptFactorySpy)
-        .withDocsParser(docsParser)
+      const actual = new TestBuilder()
+        .withData(script)
         .parseScript();
       // assert
-      const actualDocs = getInitParameters(actualScript)?.docs;
-      expect(actualDocs).to.deep.equal(expectedDocs);
-    });
-    it('gets script from the factory', () => {
-      // arrange
-      const expectedScript = new ScriptStub('expected-script');
-      const scriptFactory: ScriptFactory = () => expectedScript;
-      // act
-      const actualScript = new TestContext()
-        .withScriptFactory(scriptFactory)
-        .parseScript();
-      // assert
-      expect(actualScript).to.equal(expectedScript);
+      expect(actual.docs).to.deep.equal(expected);
     });
     describe('level', () => {
-      describe('generated `undefined` level if given absent value', () => {
+      describe('accepts absent level', () => {
         itEachAbsentStringValue((absentValue) => {
           // arrange
-          const expectedLevel = undefined;
-          const scriptData = createScriptDataWithCode()
+          const script = createScriptDataWithCode()
             .withRecommend(absentValue);
-          const { scriptFactorySpy, getInitParameters } = createScriptFactorySpy();
           // act
-          const actualScript = new TestContext()
-            .withData(scriptData)
-            .withScriptFactory(scriptFactorySpy)
+          const actual = new TestBuilder()
+            .withData(script)
             .parseScript();
           // assert
-          const actualLevel = getInitParameters(actualScript)?.level;
-          expect(actualLevel).to.equal(expectedLevel);
+          expect(actual.level).to.equal(undefined);
         }, { excludeNull: true });
       });
       it('parses level as expected', () => {
@@ -100,94 +66,63 @@ describe('ScriptParser', () => {
         const expectedLevel = RecommendationLevel.Standard;
         const expectedName = 'level';
         const levelText = 'standard';
-        const scriptData = createScriptDataWithCode()
+        const script = createScriptDataWithCode()
           .withRecommend(levelText);
         const parserMock = new EnumParserStub<RecommendationLevel>()
           .setup(expectedName, levelText, expectedLevel);
-        const { scriptFactorySpy, getInitParameters } = createScriptFactorySpy();
         // act
-        const actualScript = new TestContext()
-          .withData(scriptData)
+        const actual = new TestBuilder()
+          .withData(script)
           .withParser(parserMock)
-          .withScriptFactory(scriptFactorySpy)
           .parseScript();
         // assert
-        const actualLevel = getInitParameters(actualScript)?.level;
-        expect(actualLevel).to.equal(expectedLevel);
+        expect(actual.level).to.equal(expectedLevel);
       });
     });
     describe('code', () => {
-      it('creates from script code factory', () => {
+      it('parses "execute" as expected', () => {
         // arrange
-        const expectedCode = new ScriptCodeStub();
-        const scriptCodeFactory: ScriptCodeFactory = () => expectedCode;
-        const { scriptFactorySpy, getInitParameters } = createScriptFactorySpy();
+        const expected = 'expected-code';
+        const script = createScriptDataWithCode()
+          .withCode(expected);
         // act
-        const actualScript = new TestContext()
-          .withScriptCodeFactory(scriptCodeFactory)
-          .withScriptFactory(scriptFactorySpy)
+        const parsed = new TestBuilder()
+          .withData(script)
           .parseScript();
         // assert
-        const actualCode = getInitParameters(actualScript)?.code;
-        expect(expectedCode).to.equal(actualCode);
+        const actual = parsed.code.execute;
+        expect(actual).to.equal(expected);
       });
-      describe('parses code correctly', () => {
-        it('parses "execute" as expected', () => {
-          // arrange
-          const expectedCode = 'expected-code';
-          let actualCode: string | undefined;
-          const scriptCodeFactory: ScriptCodeFactory = (code) => {
-            actualCode = code;
-            return new ScriptCodeStub();
-          };
-          const scriptData = createScriptDataWithCode()
-            .withCode(expectedCode);
-          // act
-          new TestContext()
-            .withData(scriptData)
-            .withScriptCodeFactory(scriptCodeFactory)
-            .parseScript();
-          // assert
-          expect(actualCode).to.equal(expectedCode);
-        });
-        it('parses "revert" as expected', () => {
-          // arrange
-          const expectedRevertCode = 'expected-revert-code';
-          const scriptData = createScriptDataWithCode()
-            .withRevertCode(expectedRevertCode);
-          let actualRevertCode: string | undefined;
-          const scriptCodeFactory: ScriptCodeFactory = (_, revertCode) => {
-            actualRevertCode = revertCode;
-            return new ScriptCodeStub();
-          };
-          // act
-          new TestContext()
-            .withData(scriptData)
-            .withScriptCodeFactory(scriptCodeFactory)
-            .parseScript();
-          // assert
-          expect(actualRevertCode).to.equal(expectedRevertCode);
-        });
+      it('parses "revert" as expected', () => {
+        // arrange
+        const expected = 'expected-revert-code';
+        const script = createScriptDataWithCode()
+          .withRevertCode(expected);
+        // act
+        const parsed = new TestBuilder()
+          .withData(script)
+          .parseScript();
+        // assert
+        const actual = parsed.code.revert;
+        expect(actual).to.equal(expected);
       });
       describe('compiler', () => {
-        it('compiles the code through the compiler', () => {
+        it('gets code from compiler', () => {
           // arrange
-          const expectedCode = new ScriptCodeStub();
+          const expected = new ScriptCodeStub();
           const script = createScriptDataWithCode();
           const compiler = new ScriptCompilerStub()
-            .withCompileAbility(script, expectedCode);
+            .withCompileAbility(script, expected);
           const parseContext = new CategoryCollectionParseContextStub()
             .withCompiler(compiler);
-          const { scriptFactorySpy, getInitParameters } = createScriptFactorySpy();
           // act
-          const actualScript = new TestContext()
+          const parsed = new TestBuilder()
             .withData(script)
             .withContext(parseContext)
-            .withScriptFactory(scriptFactorySpy)
             .parseScript();
           // assert
-          const actualCode = getInitParameters(actualScript)?.code;
-          expect(actualCode).to.equal(expectedCode);
+          const actual = parsed.code;
+          expect(actual).to.equal(expected);
         });
       });
       describe('syntax', () => {
@@ -200,7 +135,7 @@ describe('ScriptParser', () => {
           const script = createScriptDataWithoutCallOrCodes()
             .withCode(duplicatedCode);
           // act
-          const act = () => new TestContext()
+          const act = () => new TestBuilder()
             .withData(script)
             .withContext(parseContext);
           // assert
@@ -214,26 +149,18 @@ describe('ScriptParser', () => {
             NoEmptyLines,
             NoDuplicatedLines,
           ];
-          const expectedCode = 'expected code to be validated';
-          const expectedRevertCode = 'expected revert code to be validated';
-          const expectedCodeCalls = [
-            expectedCode,
-            expectedRevertCode,
-          ];
           const validator = new CodeValidatorStub();
-          const scriptCodeFactory = createScriptCodeFactoryStub({
-            scriptCode: new ScriptCodeStub()
-              .withExecute(expectedCode)
-              .withRevert(expectedRevertCode),
-          });
+          const script = createScriptDataWithCode()
+            .withCode('expected code to be validated')
+            .withRevertCode('expected revert code to be validated');
           // act
-          new TestContext()
-            .withScriptCodeFactory(scriptCodeFactory)
+          new TestBuilder()
+            .withData(script)
             .withCodeValidator(validator)
             .parseScript();
           // assert
           validator.assertHistory({
-            validatedCodes: expectedCodeCalls,
+            validatedCodes: [script.code, script.revertCode],
             rules: expectedRules,
           });
         });
@@ -248,7 +175,7 @@ describe('ScriptParser', () => {
           const parseContext = new CategoryCollectionParseContextStub()
             .withCompiler(compiler);
           // act
-          new TestContext()
+          new TestBuilder()
             .withData(script)
             .withCodeValidator(validator)
             .withContext(parseContext)
@@ -261,250 +188,111 @@ describe('ScriptParser', () => {
         });
       });
     });
-    describe('validation', () => {
-      describe('validates for name', () => {
+    describe('invalid script data', () => {
+      describe('validates script data', () => {
         // arrange
-        const expectedName = 'expected script name to be validated';
-        const script = createScriptDataWithCall()
-          .withName(expectedName);
-        const expectedContext: ScriptNodeErrorContext = {
-          type: NodeDataType.Script,
-          selfNode: script,
-        };
-        itValidatesName((validatorFactory) => {
-          // act
-          new TestContext()
+        const createTest = (script: ScriptData): ITestScenario => ({
+          act: () => new TestBuilder()
             .withData(script)
-            .withValidatorFactory(validatorFactory)
-            .parseScript();
-          // assert
-          return {
-            expectedNameToValidate: expectedName,
-            expectedErrorContext: expectedContext,
-          };
+            .parseScript(),
+          expectedContext: {
+            type: NodeType.Script,
+            selfNode: script,
+          },
         });
-      });
-      describe('validates for defined data', () => {
-        // arrange
-        const expectedScript = createScriptDataWithCall();
-        const expectedContext: ScriptNodeErrorContext = {
-          type: NodeDataType.Script,
-          selfNode: expectedScript,
-        };
-        itValidatesDefinedData(
-          (validatorFactory) => {
-            // act
-            new TestContext()
-              .withData(expectedScript)
-              .withValidatorFactory(validatorFactory)
-              .parseScript();
-            // assert
-            return {
-              expectedDataToValidate: expectedScript,
-              expectedErrorContext: expectedContext,
-            };
-          },
-        );
-      });
-      describe('validates data', () => {
-        // arrange
-        const testScenarios = generateDataValidationTestScenarios<ScriptData>(
-          {
-            assertErrorMessage: 'Neither "call" or "code" is defined.',
-            expectFail: [{
-              description: 'with no call or code',
-              data: createScriptDataWithoutCallOrCodes(),
-            }],
-            expectPass: [
-              {
-                description: 'with call',
-                data: createScriptDataWithCall(),
-              },
-              {
-                description: 'with code',
-                data: createScriptDataWithCode(),
-              },
-            ],
-          },
-          {
-            assertErrorMessage: 'Both "call" and "revertCode" are defined.',
-            expectFail: [{
-              description: 'with both call and revertCode',
-              data: createScriptDataWithCall()
-                .withRevertCode('revert-code'),
-            }],
-            expectPass: [
-              {
-                description: 'with call, without revertCode',
-                data: createScriptDataWithCall()
-                  .withRevertCode(undefined),
-              },
-              {
-                description: 'with revertCode, without call',
-                data: createScriptDataWithCode()
-                  .withRevertCode('revert code'),
-              },
-            ],
-          },
-          {
-            assertErrorMessage: 'Both "call" and "code" are defined.',
-            expectFail: [{
-              description: 'with both call and code',
-              data: createScriptDataWithCall()
-                .withCode('code'),
-            }],
-            expectPass: [
-              {
-                description: 'with call, without code',
-                data: createScriptDataWithCall()
-                  .withCode(''),
-              },
-              {
-                description: 'with code, without call',
-                data: createScriptDataWithCode()
-                  .withCode('code'),
-              },
-            ],
-          },
-        );
-        testScenarios.forEach(({
-          description, expectedPass, data: scriptData, expectedMessage,
-        }) => {
-          describe(description, () => {
-            itAsserts({
-              expectedConditionResult: expectedPass,
-              test: (validatorFactory) => {
-                const expectedContext: ScriptNodeErrorContext = {
-                  type: NodeDataType.Script,
-                  selfNode: scriptData,
-                };
-                // act
-                new TestContext()
-                  .withData(scriptData)
-                  .withValidatorFactory(validatorFactory)
-                  .parseScript();
-                // assert
-                expectExists(expectedMessage);
-                return {
-                  expectedErrorMessage: expectedMessage,
-                  expectedErrorContext: expectedContext,
-                };
-              },
-            });
+        // act and assert
+        new NodeValidationTestRunner()
+          .testInvalidNodeName((invalidName) => {
+            return createTest(
+              createScriptDataWithCall().withName(invalidName),
+            );
+          })
+          .testMissingNodeData((node) => {
+            return createTest(node as ScriptData);
+          })
+          .runThrowingCase({
+            name: 'throws when both function call and code are defined',
+            scenario: createTest(
+              createScriptDataWithCall().withCode('code'),
+            ),
+            expectedMessage: 'Both "call" and "code" are defined.',
+          })
+          .runThrowingCase({
+            name: 'throws when both function call and revertCode are defined',
+            scenario: createTest(
+              createScriptDataWithCall().withRevertCode('revert-code'),
+            ),
+            expectedMessage: 'Both "call" and "revertCode" are defined.',
+          })
+          .runThrowingCase({
+            name: 'throws when neither call or revertCode are defined',
+            scenario: createTest(
+              createScriptDataWithoutCallOrCodes(),
+            ),
+            expectedMessage: 'Neither "call" or "code" is defined.',
           });
-        });
       });
-    });
-    describe('rethrows exception if script factory fails', () => {
-      // arrange
-      const givenData = createScriptDataWithCode();
-      const expectedContextMessage = 'Failed to parse script.';
-      const expectedError = new Error();
-      const validatorFactory: NodeDataValidatorFactory = () => {
-        const validatorStub = new NodeDataValidatorStub();
-        validatorStub.createContextualErrorMessage = (message) => message;
-        return validatorStub;
-      };
-      // act & assert
-      itThrowsContextualError({
-        throwingAction: (wrapError) => {
-          const factoryMock: ScriptFactory = () => {
-            throw expectedError;
-          };
-          new TestContext()
-            .withScriptFactory(factoryMock)
-            .withErrorWrapper(wrapError)
-            .withValidatorFactory(validatorFactory)
-            .withData(givenData)
-            .parseScript();
-        },
-        expectedWrappedError: expectedError,
-        expectedContextMessage,
+      it(`rethrows exception if ${Script.name} cannot be constructed`, () => {
+        // arrange
+        const expectedError = 'script creation failed';
+        const factoryMock: ScriptFactoryType = () => { throw new Error(expectedError); };
+        const data = createScriptDataWithCode();
+        // act
+        const act = () => new TestBuilder()
+          .withData(data)
+          .withFactory(factoryMock)
+          .parseScript();
+        // expect
+        expectThrowsNodeError({
+          act,
+          expectedContext: {
+            type: NodeType.Script,
+            selfNode: data,
+          },
+        }, expectedError);
       });
     });
   });
 });
 
-class TestContext {
+class TestBuilder {
   private data: ScriptData = createScriptDataWithCode();
 
   private context: ICategoryCollectionParseContext = new CategoryCollectionParseContextStub();
 
-  private levelParser: IEnumParser<RecommendationLevel> = new EnumParserStub<RecommendationLevel>()
+  private parser: IEnumParser<RecommendationLevel> = new EnumParserStub<RecommendationLevel>()
     .setupDefaultValue(RecommendationLevel.Standard);
 
-  private scriptFactory: ScriptFactory = createScriptFactorySpy().scriptFactorySpy;
+  private factory?: ScriptFactoryType = undefined;
 
   private codeValidator: ICodeValidator = new CodeValidatorStub();
 
-  private errorWrapper: ErrorWithContextWrapper = new ErrorWrapperStub().get();
-
-  private validatorFactory: NodeDataValidatorFactory = createNodeDataValidatorFactoryStub;
-
-  private docsParser: DocsParser = () => ['docs'];
-
-  private scriptCodeFactory: ScriptCodeFactory = createScriptCodeFactoryStub({
-    defaultCodePrefix: TestContext.name,
-  });
-
-  public withCodeValidator(codeValidator: ICodeValidator): this {
+  public withCodeValidator(codeValidator: ICodeValidator) {
     this.codeValidator = codeValidator;
     return this;
   }
 
-  public withData(data: ScriptData): this {
+  public withData(data: ScriptData) {
     this.data = data;
     return this;
   }
 
-  public withContext(context: ICategoryCollectionParseContext): this {
+  public withContext(context: ICategoryCollectionParseContext) {
     this.context = context;
     return this;
   }
 
-  public withParser(parser: IEnumParser<RecommendationLevel>): this {
-    this.levelParser = parser;
+  public withParser(parser: IEnumParser<RecommendationLevel>) {
+    this.parser = parser;
     return this;
   }
 
-  public withScriptFactory(scriptFactory: ScriptFactory): this {
-    this.scriptFactory = scriptFactory;
-    return this;
-  }
-
-  public withValidatorFactory(validatorFactory: NodeDataValidatorFactory): this {
-    this.validatorFactory = validatorFactory;
-    return this;
-  }
-
-  public withErrorWrapper(errorWrapper: ErrorWithContextWrapper): this {
-    this.errorWrapper = errorWrapper;
-    return this;
-  }
-
-  public withScriptCodeFactory(scriptCodeFactory: ScriptCodeFactory): this {
-    this.scriptCodeFactory = scriptCodeFactory;
-    return this;
-  }
-
-  public withDocsParser(docsParser: DocsParser): this {
-    this.docsParser = docsParser;
+  public withFactory(factory: ScriptFactoryType) {
+    this.factory = factory;
     return this;
   }
 
   public parseScript(): Script {
-    return parseScript(
-      this.data,
-      this.context,
-      {
-        levelParser: this.levelParser,
-        createScript: this.scriptFactory,
-        codeValidator: this.codeValidator,
-        wrapError: this.errorWrapper,
-        createValidator: this.validatorFactory,
-        createCode: this.scriptCodeFactory,
-        parseDocs: this.docsParser,
-      },
-    );
+    return parseScript(this.data, this.context, this.parser, this.factory, this.codeValidator);
   }
 }

tests/unit/application/Parser/Script/Validation/CodeValidator.spec.ts

@@ -2,13 +2,13 @@ import { describe, it, expect } from 'vitest';
 import { CodeValidator } from '@/application/Parser/Script/Validation/CodeValidator';
 import { CodeValidationRuleStub } from '@tests/unit/shared/Stubs/CodeValidationRuleStub';
 import { itEachAbsentCollectionValue, itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
+import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
 import type { ICodeLine } from '@/application/Parser/Script/Validation/ICodeLine';
 import type { ICodeValidationRule, IInvalidCodeLine } from '@/application/Parser/Script/Validation/ICodeValidationRule';
 
 describe('CodeValidator', () => {
   describe('instance', () => {
-    itIsSingletonFactory({
+    itIsSingleton({
       getter: () => CodeValidator.instance,
       expectedType: CodeValidator,
     });

tests/unit/domain/Category.spec.ts

@@ -3,68 +3,50 @@ import { Category } from '@/domain/Category';
 import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
-import type { ICategory, IScript } from '@/domain/ICategory';
 
 describe('Category', () => {
   describe('ctor', () => {
-    describe('throws error if name is absent', () => {
+    describe('throws when name is absent', () => {
       itEachAbsentStringValue((absentValue) => {
         // arrange
         const expectedError = 'missing name';
         const name = absentValue;
         // act
-        const construct = () => new CategoryBuilder()
-          .withName(name)
-          .build();
+        const construct = () => new Category(5, name, [], [new CategoryStub(5)], []);
         // assert
         expect(construct).to.throw(expectedError);
       }, { excludeNull: true, excludeUndefined: true });
     });
-    it('throws error if no children are present', () => {
-      // arrange
+    it('throws when has no children', () => {
       const expectedError = 'A category must have at least one sub-category or script';
-      const scriptChildren: readonly IScript[] = [];
-      const categoryChildren: readonly ICategory[] = [];
-      // act
-      const construct = () => new CategoryBuilder()
-        .withSubcategories(categoryChildren)
-        .withScripts(scriptChildren)
-        .build();
-      // assert
+      const construct = () => new Category(5, 'category', [], [], []);
       expect(construct).to.throw(expectedError);
     });
   });
   describe('getAllScriptsRecursively', () => {
-    it('retrieves direct child scripts', () => {
+    it('gets child scripts', () => {
       // arrange
-      const expectedScripts = [new ScriptStub('1'), new ScriptStub('2')];
-      const sut = new CategoryBuilder()
-        .withScripts(expectedScripts)
-        .build();
+      const expected = [new ScriptStub('1'), new ScriptStub('2')];
+      const sut = new Category(0, 'category', [], [], expected);
       // act
       const actual = sut.getAllScriptsRecursively();
       // assert
-      expect(actual).to.have.deep.members(expectedScripts);
+      expect(actual).to.have.deep.members(expected);
     });
-    it('retrieves scripts from direct child categories', () => {
+    it('gets child categories', () => {
       // arrange
       const expectedScriptIds = ['1', '2', '3', '4'];
       const categories = [
         new CategoryStub(31).withScriptIds('1', '2'),
         new CategoryStub(32).withScriptIds('3', '4'),
       ];
-      const sut = new CategoryBuilder()
-        .withScripts([])
-        .withSubcategories(categories)
-        .build();
+      const sut = new Category(0, 'category', [], categories, []);
       // act
-      const actualIds = sut
-        .getAllScriptsRecursively()
-        .map((s) => s.id);
+      const actualIds = sut.getAllScriptsRecursively().map((s) => s.id);
       // assert
       expect(actualIds).to.have.deep.members(expectedScriptIds);
     });
-    it('retrieves scripts from both direct children and child categories', () => {
+    it('gets child scripts and categories', () => {
       // arrange
       const expectedScriptIds = ['1', '2', '3', '4', '5', '6'];
       const categories = [
@@ -72,18 +54,13 @@ describe('Category', () => {
         new CategoryStub(32).withScriptIds('3', '4'),
       ];
       const scripts = [new ScriptStub('5'), new ScriptStub('6')];
-      const sut = new CategoryBuilder()
-        .withSubcategories(categories)
-        .withScripts(scripts)
-        .build();
+      const sut = new Category(0, 'category', [], categories, scripts);
       // act
-      const actualIds = sut
-        .getAllScriptsRecursively()
-        .map((s) => s.id);
+      const actualIds = sut.getAllScriptsRecursively().map((s) => s.id);
       // assert
       expect(actualIds).to.have.deep.members(expectedScriptIds);
     });
-    it('retrieves scripts from nested categories recursively', () => {
+    it('gets child categories recursively', () => {
       // arrange
       const expectedScriptIds = ['1', '2', '3', '4', '5', '6'];
       const categories = [
@@ -106,111 +83,45 @@ describe('Category', () => {
           ),
       ];
       // assert
-      const sut = new CategoryBuilder()
-        .withScripts([])
-        .withSubcategories(categories)
-        .build();
+      const sut = new Category(0, 'category', [], categories, []);
       // act
-      const actualIds = sut
-        .getAllScriptsRecursively()
-        .map((s) => s.id);
+      const actualIds = sut.getAllScriptsRecursively().map((s) => s.id);
       // assert
       expect(actualIds).to.have.deep.members(expectedScriptIds);
     });
   });
   describe('includes', () => {
-    it('returns false for scripts not included', () => {
+    it('return false when does not include', () => {
       // assert
-      const expectedResult = false;
       const script = new ScriptStub('3');
-      const childCategory = new CategoryStub(33)
-        .withScriptIds('1', '2');
-      const sut = new CategoryBuilder()
-        .withSubcategories([childCategory])
-        .build();
+      const sut = new Category(0, 'category', [], [new CategoryStub(33).withScriptIds('1', '2')], []);
       // act
       const actual = sut.includes(script);
       // assert
-      expect(actual).to.equal(expectedResult);
+      expect(actual).to.equal(false);
     });
-    it('returns true for scripts directly included', () => {
+    it('return true when includes as subscript', () => {
       // assert
-      const expectedResult = true;
       const script = new ScriptStub('3');
-      const childCategory = new CategoryStub(33)
-        .withScript(script)
-        .withScriptIds('non-related');
-      const sut = new CategoryBuilder()
-        .withSubcategories([childCategory])
-        .build();
+      const sut = new Category(0, 'category', [], [
+        new CategoryStub(33).withScript(script).withScriptIds('non-related'),
+      ], []);
       // act
       const actual = sut.includes(script);
       // assert
-      expect(actual).to.equal(expectedResult);
+      expect(actual).to.equal(true);
     });
-    it('returns true for scripts included in nested categories', () => {
+    it('return true when includes as nested category script', () => {
       // assert
-      const expectedResult = true;
       const script = new ScriptStub('3');
-      const childCategory = new CategoryStub(22)
+      const innerCategory = new CategoryStub(22)
         .withScriptIds('non-related')
         .withCategory(new CategoryStub(33).withScript(script));
-      const sut = new CategoryBuilder()
-        .withSubcategories([childCategory])
-        .build();
+      const sut = new Category(11, 'category', [], [innerCategory], []);
       // act
       const actual = sut.includes(script);
       // assert
-      expect(actual).to.equal(expectedResult);
+      expect(actual).to.equal(true);
     });
   });
 });
-
-class CategoryBuilder {
-  private id = 3264;
-
-  private name = 'test-script';
-
-  private docs: ReadonlyArray<string> = [];
-
-  private subcategories: ReadonlyArray<ICategory> = [];
-
-  private scripts: ReadonlyArray<IScript> = [
-    new ScriptStub(`[${CategoryBuilder.name}] script`),
-  ];
-
-  public withId(id: number): this {
-    this.id = id;
-    return this;
-  }
-
-  public withName(name: string): this {
-    this.name = name;
-    return this;
-  }
-
-  public withDocs(docs: ReadonlyArray<string>): this {
-    this.docs = docs;
-    return this;
-  }
-
-  public withScripts(scripts: ReadonlyArray<IScript>): this {
-    this.scripts = scripts;
-    return this;
-  }
-
-  public withSubcategories(subcategories: ReadonlyArray<ICategory>): this {
-    this.subcategories = subcategories;
-    return this;
-  }
-
-  public build(): Category {
-    return new Category({
-      id: this.id,
-      name: this.name,
-      docs: this.docs,
-      subcategories: this.subcategories,
-      scripts: this.scripts,
-    });
-  }
-}

tests/unit/domain/Script.spec.ts

@@ -8,7 +8,7 @@ import { ScriptCodeStub } from '@tests/unit/shared/Stubs/ScriptCodeStub';
 describe('Script', () => {
   describe('ctor', () => {
     describe('scriptCode', () => {
-      it('assigns code correctly', () => {
+      it('sets as expected', () => {
         // arrange
         const expected = new ScriptCodeStub();
         const sut = new ScriptBuilder()
@@ -43,7 +43,7 @@ describe('Script', () => {
       });
     });
     describe('level', () => {
-      it('throws when constructed with invalid level', () => {
+      it('cannot construct with invalid wrong value', () => {
         // arrange
         const invalidValue: RecommendationLevel = 55 as never;
         const expectedError = 'invalid level';
@@ -54,7 +54,7 @@ describe('Script', () => {
         // assert
         expect(construct).to.throw(expectedError);
       });
-      it('handles undefined level correctly', () => {
+      it('sets undefined as expected', () => {
         // arrange
         const expected = undefined;
         // act
@@ -64,7 +64,7 @@ describe('Script', () => {
         // assert
         expect(sut.level).to.equal(expected);
       });
-      it('correctly assigns valid recommendation levels', () => {
+      it('sets as expected', () => {
         // arrange
         for (const expected of getEnumValues(RecommendationLevel)) {
           // act
@@ -78,7 +78,7 @@ describe('Script', () => {
       });
     });
     describe('docs', () => {
-      it('correctly assigns docs', () => {
+      it('sets as expected', () => {
         // arrange
         const expected = ['doc1', 'doc2'];
         // act
@@ -130,11 +130,11 @@ class ScriptBuilder {
   }
 
   public build(): Script {
-    return new Script({
-      name: this.name,
-      code: this.code,
-      docs: this.docs,
-      level: this.level,
-    });
+    return new Script(
+      this.name,
+      this.code,
+      this.docs,
+      this.level,
+    );
   }
 }

tests/unit/domain/ScriptCodeFactory.spec.ts

@@ -1,52 +0,0 @@
-import { createScriptCode } from '@/domain/ScriptCodeFactory';
-
-describe('ScriptCodeFactory', () => {
-  describe('createScriptCode', () => {
-    it('generates script code with given `code`', () => {
-      // arrange
-      const expectedCode = 'expected code';
-      const context = new TestContext()
-        .withCode(expectedCode);
-      // act
-      const code = context.createScriptCode();
-      // assert
-      const actualCode = code.execute;
-      expect(actualCode).to.equal(expectedCode);
-    });
-
-    it('generates script code with given `revertCode`', () => {
-      // arrange
-      const expectedRevertCode = 'expected revert code';
-      const context = new TestContext()
-        .withRevertCode(expectedRevertCode);
-      // act
-      const code = context.createScriptCode();
-      // assert
-      const actualRevertCode = code.revert;
-      expect(actualRevertCode).to.equal(expectedRevertCode);
-    });
-  });
-});
-
-class TestContext {
-  private code = `[${TestContext}] code`;
-
-  private revertCode = `[${TestContext}] revertCode`;
-
-  public withCode(code: string): this {
-    this.code = code;
-    return this;
-  }
-
-  public withRevertCode(revertCode: string): this {
-    this.revertCode = revertCode;
-    return this;
-  }
-
-  public createScriptCode(): ReturnType<typeof createScriptCode> {
-    return createScriptCode(
-      this.code,
-      this.revertCode,
-    );
-  }
-}

tests/unit/infrastructure/EnvironmentVariables/EnvironmentVariablesFactory.ts

@@ -1,7 +1,7 @@
 import {
   describe,
 } from 'vitest';
-import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
+import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
 import { EnvironmentVariablesFactory, type EnvironmentVariablesValidator } from '@/infrastructure/EnvironmentVariables/EnvironmentVariablesFactory';
 import { ViteEnvironmentVariables } from '@/infrastructure/EnvironmentVariables/Vite/ViteEnvironmentVariables';
 import type { IEnvironmentVariables } from '@/infrastructure/EnvironmentVariables/IEnvironmentVariables';
@@ -9,7 +9,7 @@ import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
 describe('EnvironmentVariablesFactory', () => {
   describe('instance', () => {
-    itIsSingletonFactory({
+    itIsSingleton({
       getter: () => EnvironmentVariablesFactory.Current.instance,
       expectedType: ViteEnvironmentVariables,
     });

tests/unit/presentation/bootstrapping/DependencyProvider.spec.ts

@@ -3,9 +3,8 @@ import { VueDependencyInjectionApiStub } from '@tests/unit/shared/Stubs/VueDepen
 import { InjectionKeys } from '@/presentation/injectionSymbols';
 import { provideDependencies, type VueDependencyInjectionApi } from '@/presentation/bootstrapping/DependencyProvider';
 import { ApplicationContextStub } from '@tests/unit/shared/Stubs/ApplicationContextStub';
-import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
+import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
 import type { IApplicationContext } from '@/application/Context/IApplicationContext';
-import { itIsTransientFactory } from '@tests/unit/shared/TestCases/TransientFactoryTests';
 
 describe('DependencyProvider', () => {
   describe('provideDependencies', () => {
@@ -47,22 +46,19 @@ function createTransientTests() {
       const registeredObject = api.inject(injectionKey);
       expect(registeredObject).to.be.instanceOf(Function);
     });
-    describe('should return different instances for transient dependency', () => {
+    it('should return different instances for transient dependency', () => {
       // arrange
       const api = new VueDependencyInjectionApiStub();
+      // act
       new ProvideDependenciesBuilder()
         .withApi(api)
         .provideDependencies();
-      // act
-      const getFactoryResult = () => {
-        const registeredObject = api.inject(injectionKey);
-        const factory = registeredObject as () => unknown;
-        return factory();
-      };
-      // assert
-      itIsTransientFactory({
-        getter: getFactoryResult,
-      });
+      // expect
+      const registeredObject = api.inject(injectionKey);
+      const factory = registeredObject as () => unknown;
+      const firstResult = factory();
+      const secondResult = factory();
+      expect(firstResult).to.not.equal(secondResult);
     });
   };
 }
@@ -91,7 +87,7 @@ function createSingletonTests() {
       // act
       const getRegisteredInstance = () => api.inject(injectionKey);
       // assert
-      itIsSingletonFactory({
+      itIsSingleton({
         getter: getRegisteredInstance,
       });
     });

tests/unit/presentation/components/Scripts/View/Tree/NodeContent/Reverter/ReverterFactory.spec.ts

@@ -6,7 +6,8 @@ import { CategoryCollectionStub } from '@tests/unit/shared/Stubs/CategoryCollect
 import { CategoryStub } from '@tests/unit/shared/Stubs/CategoryStub';
 import { ScriptStub } from '@tests/unit/shared/Stubs/ScriptStub';
 import { getCategoryNodeId, getScriptNodeId } from '@/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter';
-import { type NodeMetadata, NodeType } from '@/presentation/components/Scripts/View/Tree/NodeContent/NodeMetadata';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
+import type { NodeMetadata } from '@/presentation/components/Scripts/View/Tree/NodeContent/NodeMetadata';
 
 describe('ReverterFactory', () => {
   describe('getReverter', () => {

tests/unit/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter.spec.ts

@@ -8,7 +8,7 @@ import {
   getCategoryId, getCategoryNodeId, getScriptId,
   getScriptNodeId, parseAllCategories, parseSingleCategory,
 } from '@/presentation/components/Scripts/View/Tree/TreeViewAdapter/CategoryNodeMetadataConverter';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
 import type { NodeMetadata } from '@/presentation/components/Scripts/View/Tree/NodeContent/NodeMetadata';
 import { expectExists } from '@tests/shared/Assertions/ExpectExists';
 
@@ -109,7 +109,7 @@ function isReversible(category: ICategory): boolean {
 }
 
 function expectSameCategory(node: NodeMetadata, category: ICategory): void {
-  expect(node.type).to.equal(NodeDataType.Category, getErrorMessage('type'));
+  expect(node.type).to.equal(NodeType.Category, getErrorMessage('type'));
   expect(node.id).to.equal(getCategoryNodeId(category), getErrorMessage('id'));
   expect(node.docs).to.equal(category.docs, getErrorMessage('docs'));
   expect(node.text).to.equal(category.name, getErrorMessage('name'));
@@ -136,7 +136,7 @@ function expectSameCategory(node: NodeMetadata, category: ICategory): void {
 }
 
 function expectSameScript(node: NodeMetadata, script: IScript): void {
-  expect(node.type).to.equal(NodeDataType.Script, getErrorMessage('type'));
+  expect(node.type).to.equal(NodeType.Script, getErrorMessage('type'));
   expect(node.id).to.equal(getScriptNodeId(script), getErrorMessage('id'));
   expect(node.docs).to.equal(script.docs, getErrorMessage('docs'));
   expect(node.text).to.equal(script.name, getErrorMessage('name'));

tests/unit/presentation/components/Shared/Hooks/Log/ClientLoggerFactory.spec.ts

@@ -3,14 +3,14 @@ import { describe, it } from 'vitest';
 import type { RuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironment';
 import type { Logger } from '@/application/Common/Log/Logger';
 import { RuntimeEnvironmentStub } from '@tests/unit/shared/Stubs/RuntimeEnvironmentStub';
-import { itIsSingletonFactory } from '@tests/unit/shared/TestCases/SingletonFactoryTests';
+import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
 import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
 import { ClientLoggerFactory, type LoggerCreationFunction, type WindowAccessor } from '@/presentation/components/Shared/Hooks/Log/ClientLoggerFactory';
 
 describe('ClientLoggerFactory', () => {
   describe('Current', () => {
     describe('singleton behavior', () => {
-      itIsSingletonFactory({
+      itIsSingleton({
         getter: () => ClientLoggerFactory.Current,
         expectedType: ClientLoggerFactory,
       });

tests/unit/shared/ExceptionCollector.ts

@@ -1,18 +1,12 @@
 export function collectExceptionMessage(action: () => unknown): string {
-  return collectException(action).message;
-}
-
-function collectException(
-  action: () => unknown,
-): Error {
-  let error: Error | undefined;
+  let message: string | undefined;
   try {
     action();
-  } catch (err) {
-    error = err;
+  } catch (e) {
+    message = e.message;
   }
-  if (!error) {
+  if (!message) {
     throw new Error('action did not throw');
   }
-  return error;
+  return message;
 }

tests/unit/shared/Stubs/CategoryFactoryStub.ts

@@ -1,19 +0,0 @@
-import type { CategoryFactory } from '@/application/Parser/CategoryParser';
-import type { CategoryInitParameters } from '@/domain/Category';
-import type { ICategory } from '@/domain/ICategory';
-import { CategoryStub } from './CategoryStub';
-
-export function createCategoryFactorySpy(): {
-  readonly categoryFactorySpy: CategoryFactory;
-  getInitParameters: (category: ICategory) => CategoryInitParameters | undefined;
-} {
-  const createdCategories = new Map<ICategory, CategoryInitParameters>();
-  return {
-    categoryFactorySpy: (parameters) => {
-      const category = new CategoryStub(55);
-      createdCategories.set(category, parameters);
-      return category;
-    },
-    getInitParameters: (category) => createdCategories.get(category),
-  };
-}

tests/unit/shared/Stubs/CodeValidatorStub.ts

@@ -19,16 +19,16 @@ export class CodeValidatorStub implements ICodeValidator {
     });
   }
 
-  public assertHistory(expectation: {
+  public assertHistory(expected: {
     validatedCodes: readonly (string | undefined)[],
     rules: readonly Constructible<ICodeValidationRule>[],
   }) {
-    expect(this.callHistory).to.have.lengthOf(expectation.validatedCodes.length);
+    expect(this.callHistory).to.have.lengthOf(expected.validatedCodes.length);
     const actualValidatedCodes = this.callHistory.map((args) => args.code);
-    expect(actualValidatedCodes.sort()).deep.equal([...expectation.validatedCodes].sort());
+    expect(actualValidatedCodes.sort()).deep.equal([...expected.validatedCodes].sort());
     for (const call of this.callHistory) {
       const actualRules = call.rules.map((rule) => rule.constructor);
-      expect(actualRules.sort()).to.deep.equal([...expectation.rules].sort());
+      expect(actualRules.sort()).to.deep.equal([...expected.rules].sort());
     }
   }
 }

tests/unit/shared/Stubs/ErrorWithContextWrapperStub.ts

@@ -1,4 +0,0 @@
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-
-export const errorWithContextWrapperStub
-: ErrorWithContextWrapper = (error, message) => new Error(`[stubbed error wrapper] ${error.message} + ${message}`);

tests/unit/shared/Stubs/ErrorWrapperStub.ts

@@ -1,67 +0,0 @@
-import type { ErrorWithContextWrapper } from '@/application/Parser/ContextualError';
-
-export class ErrorWrapperStub {
-  private errorToReturn: Error | undefined;
-
-  private parameters?: Parameters<ErrorWithContextWrapper>;
-
-  public get lastError(): Error | undefined {
-    if (!this.parameters) {
-      return undefined;
-    }
-    return getError(this.parameters);
-  }
-
-  public get lastContext(): string | undefined {
-    if (!this.parameters) {
-      return undefined;
-    }
-    return getAdditionalContext(this.parameters);
-  }
-
-  public withError(error: Error): this {
-    this.errorToReturn = error;
-    return this;
-  }
-
-  public get(): ErrorWithContextWrapper {
-    return (...args) => {
-      this.parameters = args;
-      if (this.errorToReturn) {
-        return this.errorToReturn;
-      }
-      return new Error(
-        `[${ErrorWrapperStub.name}] Error wrapped with additional context.`
-        + `\nAdditional context: ${getAdditionalContext(args)}`
-        + `\nWrapped error message: ${getError(args).message}`
-        + `\nWrapped error stack trace:\n${getLimitedStackTrace(getError(args), 5)}`,
-      );
-    };
-  }
-}
-
-function getAdditionalContext(
-  parameters: Parameters<ErrorWithContextWrapper>,
-): string {
-  return parameters[1];
-}
-
-function getError(
-  parameters: Parameters<ErrorWithContextWrapper>,
-): Error {
-  return parameters[0];
-}
-
-function getLimitedStackTrace(
-  error: Error,
-  limit: number,
-): string {
-  const { stack } = error;
-  if (!stack) {
-    return 'No stack trace available';
-  }
-  return stack
-    .split('\n')
-    .slice(0, limit + 1)
-    .join('\n');
-}

tests/unit/shared/Stubs/FunctionCallCompilerStub.ts

@@ -2,33 +2,22 @@ import type { CompiledCode } from '@/application/Parser/Script/Compiler/Function
 import type { FunctionCallCompiler } from '@/application/Parser/Script/Compiler/Function/Call/Compiler/FunctionCallCompiler';
 import type { ISharedFunctionCollection } from '@/application/Parser/Script/Compiler/Function/ISharedFunctionCollection';
 import type { FunctionCall } from '@/application/Parser/Script/Compiler/Function/Call/FunctionCall';
-import { CompiledCodeStub } from './CompiledCodeStub';
 
-interface FunctionCallCompilationTestScenario {
-  readonly calls: FunctionCall[];
-  readonly functions: ISharedFunctionCollection;
-  readonly result: CompiledCode;
+interface IScenario {
+  calls: FunctionCall[];
+  functions: ISharedFunctionCollection;
+  result: CompiledCode;
 }
 
 export class FunctionCallCompilerStub implements FunctionCallCompiler {
-  public scenarios = new Array<FunctionCallCompilationTestScenario>();
-
-  private defaultCompiledCode: CompiledCode = new CompiledCodeStub()
-    .withCode(`[${FunctionCallCompilerStub.name}] function code`)
-    .withRevertCode(`[${FunctionCallCompilerStub.name}] function revert code`);
+  public scenarios = new Array<IScenario>();
 
   public setup(
     calls: FunctionCall[],
     functions: ISharedFunctionCollection,
     result: CompiledCode,
-  ): this {
+  ) {
     this.scenarios.push({ calls, functions, result });
-    return this;
-  }
-
-  public withDefaultCompiledCode(defaultCompiledCode: CompiledCode): this {
-    this.defaultCompiledCode = defaultCompiledCode;
-    return this;
   }
 
   public compileFunctionCalls(
@@ -40,7 +29,10 @@ export class FunctionCallCompilerStub implements FunctionCallCompiler {
     if (predefined) {
       return predefined.result;
     }
-    return this.defaultCompiledCode;
+    return {
+      code: 'function code [FunctionCallCompilerStub]',
+      revertCode: 'function revert code [FunctionCallCompilerStub]',
+    };
   }
 }
 

tests/unit/shared/Stubs/FunctionParameterCollectionStub.ts

@@ -16,7 +16,7 @@ export class FunctionParameterCollectionStub implements IFunctionParameterCollec
   public withParameterName(parameterName: string, isOptional = true) {
     const parameter = new FunctionParameterStub()
       .withName(parameterName)
-      .withOptional(isOptional);
+      .withOptionality(isOptional);
     this.addParameter(parameter);
     return this;
   }

tests/unit/shared/Stubs/FunctionParameterStub.ts

@@ -10,7 +10,7 @@ export class FunctionParameterStub implements IFunctionParameter {
     return this;
   }
 
-  public withOptional(isOptional: boolean) {
+  public withOptionality(isOptional: boolean) {
     this.isOptional = isOptional;
     return this;
   }

tests/unit/shared/Stubs/NodeDataErrorContextStub.ts

@@ -1,11 +1,12 @@
-import type { NodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataErrorContext';
-import { NodeDataType } from '@/application/Parser/NodeValidation/NodeDataType';
+import type { NodeData } from '@/application/Parser/NodeValidation/NodeData';
+import type { INodeDataErrorContext } from '@/application/Parser/NodeValidation/NodeDataError';
+import { NodeType } from '@/application/Parser/NodeValidation/NodeType';
 import { CategoryDataStub } from './CategoryDataStub';
 
-export function createNodeDataErrorContextStub(): NodeDataErrorContext {
-  return {
-    type: NodeDataType.Category,
-    selfNode: new CategoryDataStub(),
-    parentNode: new CategoryDataStub(),
-  };
+export class NodeDataErrorContextStub implements INodeDataErrorContext {
+  public readonly type: NodeType = NodeType.Script;
+
+  public readonly selfNode: NodeData = new CategoryDataStub();
+
+  public readonly parentNode?: NodeData;
 }

tests/unit/shared/Stubs/NodeDataValidatorStub.ts

@@ -1,57 +0,0 @@
-import type { NodeData } from '@/application/Parser/NodeValidation/NodeData';
-import type { NodeDataValidator, NodeDataValidatorFactory } from '@/application/Parser/NodeValidation/NodeDataValidator';
-import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
-
-export const createNodeDataValidatorFactoryStub
-: NodeDataValidatorFactory = () => new NodeDataValidatorStub();
-
-export class NodeDataValidatorStub
-  extends StubWithObservableMethodCalls<NodeDataValidator>
-  implements NodeDataValidator {
-  private assertThrowsOnFalseCondition = true;
-
-  public withAssertThrowsOnFalseCondition(enableAssertThrows: boolean): this {
-    this.assertThrowsOnFalseCondition = enableAssertThrows;
-    return this;
-  }
-
-  public assertValidName(nameValue: string): this {
-    this.registerMethodCall({
-      methodName: 'assertValidName',
-      args: [nameValue],
-    });
-    return this;
-  }
-
-  public assertDefined(node: NodeData): this {
-    this.registerMethodCall({
-      methodName: 'assertDefined',
-      args: [node],
-    });
-    return this;
-  }
-
-  public assert(
-    validationPredicate: () => boolean,
-    errorMessage: string,
-  ): this {
-    this.registerMethodCall({
-      methodName: 'assert',
-      args: [validationPredicate, errorMessage],
-    });
-    if (this.assertThrowsOnFalseCondition) {
-      if (!validationPredicate()) {
-        throw new Error(`[${NodeDataValidatorStub.name}] Assert validation failed: ${errorMessage}`);
-      }
-    }
-    return this;
-  }
-
-  public createContextualErrorMessage(errorMessage: string): string {
-    this.registerMethodCall({
-      methodName: 'createContextualErrorMessage',
-      args: [errorMessage],
-    });
-    return `${NodeDataValidatorStub.name}: ${errorMessage}`;
-  }
-}

tests/unit/shared/Stubs/ScriptCodeFactoryStub.ts

@@ -1,22 +0,0 @@
-import type { ScriptCodeFactory } from '@/domain/ScriptCodeFactory';
-import type { IScriptCode } from '@/domain/IScriptCode';
-import { ScriptCodeStub } from './ScriptCodeStub';
-
-export function createScriptCodeFactoryStub(
-  options?: Partial<StubOptions>,
-): ScriptCodeFactory {
-  let defaultCodePrefix = 'createScriptCodeFactoryStub';
-  if (options?.defaultCodePrefix) {
-    defaultCodePrefix += ` > ${options?.defaultCodePrefix}`;
-  }
-  return (
-    () => options?.scriptCode ?? new ScriptCodeStub()
-      .withExecute(`[${defaultCodePrefix}] default code`)
-      .withRevert(`[${defaultCodePrefix}] revert code`)
-  );
-}
-
-interface StubOptions {
-  readonly scriptCode?: IScriptCode;
-  readonly defaultCodePrefix?: string;
-}

tests/unit/shared/Stubs/ScriptCodeStub.ts

@@ -1,9 +1,9 @@
 import type { IScriptCode } from '@/domain/IScriptCode';
 
 export class ScriptCodeStub implements IScriptCode {
-  public execute = `[${ScriptCodeStub.name}] default execute code`;
+  public execute = 'default execute code';
 
-  public revert = `[${ScriptCodeStub.name}] default revert code`;
+  public revert = 'default revert code';
 
   public withExecute(code: string) {
     this.execute = code;

tests/unit/shared/Stubs/ScriptFactoryStub.ts

@@ -1,19 +0,0 @@
-import type { ScriptFactory } from '@/application/Parser/Script/ScriptParser';
-import type { IScript } from '@/domain/IScript';
-import type { ScriptInitParameters } from '@/domain/Script';
-import { ScriptStub } from './ScriptStub';
-
-export function createScriptFactorySpy(): {
-  readonly scriptFactorySpy: ScriptFactory;
-  getInitParameters: (category: IScript) => ScriptInitParameters | undefined;
-} {
-  const createdScripts = new Map<IScript, ScriptInitParameters>();
-  return {
-    scriptFactorySpy: (parameters) => {
-      const script = new ScriptStub('script from factory stub');
-      createdScripts.set(script, parameters);
-      return script;
-    },
-    getInitParameters: (script) => createdScripts.get(script),
-  };
-}

tests/unit/shared/Stubs/ScriptParserStub.ts

@@ -1,37 +0,0 @@
-import type { ScriptParser } from '@/application/Parser/Script/ScriptParser';
-import type { IScript } from '@/domain/IScript';
-import type { ScriptData } from '@/application/collections/';
-import { ScriptStub } from './ScriptStub';
-
-export class ScriptParserStub {
-  private readonly parsedScripts = new Map<IScript, Parameters<ScriptParser>>();
-
-  private readonly setupScripts = new Map<ScriptData, IScript>();
-
-  public get(): ScriptParser {
-    return (...parameters) => {
-      const [scriptData] = parameters;
-      const script = this.setupScripts.get(scriptData)
-        ?? new ScriptStub(
-          `[${ScriptParserStub.name}] parsed script stub number ${this.parsedScripts.size + 1}`,
-        );
-      this.parsedScripts.set(script, parameters);
-      return script;
-    };
-  }
-
-  public getParseParameters(
-    script: IScript,
-  ): Parameters<ScriptParser> {
-    const parameters = this.parsedScripts.get(script);
-    if (!parameters) {
-      throw new Error('Script has never been parsed.');
-    }
-    return parameters;
-  }
-
-  public setupParsedResultForData(scriptData: ScriptData, parsedResult: IScript): this {
-    this.setupScripts.set(scriptData, parsedResult);
-    return this;
-  }
-}

tests/unit/shared/Stubs/StubWithObservableMethodCalls.ts

@@ -5,12 +5,12 @@ import type { FunctionKeys } from '@/TypeHelpers';
 export abstract class StubWithObservableMethodCalls<T> {
   public readonly callHistory = new Array<MethodCall<T>>();
 
-  private readonly notifiableMethodCalls = new EventSource<MethodCall<T>>();
-
   public get methodCalls(): IEventSource<MethodCall<T>> {
     return this.notifiableMethodCalls;
   }
 
+  private readonly notifiableMethodCalls = new EventSource<MethodCall<T>>();
+
   protected registerMethodCall(name: MethodCall<T>) {
     this.callHistory.push(name);
     this.notifiableMethodCalls.notify(name);

tests/unit/shared/TestCases/SingletonTests.ts

@@ -1,12 +1,12 @@
 import { it, expect } from 'vitest';
 import type { Constructible } from '@/TypeHelpers';
 
-interface SingletonTestData<T> {
+interface ISingletonTestData<T> {
   readonly getter: () => T;
   readonly expectedType?: Constructible<T>;
 }
 
-export function itIsSingletonFactory<T>(test: SingletonTestData<T>): void {
+export function itIsSingleton<T>(test: ISingletonTestData<T>): void {
   if (test.expectedType !== undefined) {
     it('gets the expected type', () => {
       // act

tests/unit/shared/TestCases/TransientFactoryTests.ts

@@ -1,24 +0,0 @@
-import type { Constructible } from '@/TypeHelpers';
-
-interface TransientFactoryTestData<T> {
-  readonly getter: () => T;
-  readonly expectedType?: Constructible<T>;
-}
-
-export function itIsTransientFactory<T>(test: TransientFactoryTestData<T>): void {
-  if (test.expectedType !== undefined) {
-    it('gets the expected type', () => {
-      // act
-      const instance = test.getter();
-      // assert
-      expect(instance).to.be.instanceOf(test.expectedType);
-    });
-  }
-  it('multiple calls get different instances', () => {
-    // act
-    const instance1 = test.getter();
-    const instance2 = test.getter();
-    // assert
-    expect(instance1).to.not.equal(instance2);
-  });
-}