Release 1.5.1

Author: ui5manifestbot

package-lock.json

@@ -114,7 +114,8 @@
             "src/annotations/comparator/diffCase.ts",
             "src/annotations/transformers/transformer.ts",
             "src/model/configuration.ts",
-            "src/model/appVariantIdHierarchyItem.ts"
+            "src/model/appVariantIdHierarchyItem.ts",
+            "src/adapters/adapter.ts"
         ],
         "check-coverage": true,
         "statements": 85,

package.json

@@ -0,0 +1,15 @@
+import { IAdapter } from "./adapter.js";
+import { MergeCommandChain } from "./commands/command.js";
+import BaseApp from "../baseAppManager.js";
+import AppVariant from "../appVariantManager.js";
+import I18nPropertiesMergeCommand from "./commands/i18nPropertiesMergeCommand.js";
+
+
+export default class AbapAdapter implements IAdapter {
+    createMergeCommandChain(baseApp: BaseApp, appVariant: AppVariant): MergeCommandChain {
+        const manifestChanges = appVariant.getProcessedManifestChanges();
+        return new MergeCommandChain([
+            new I18nPropertiesMergeCommand(baseApp.i18nPath, appVariant.prefix, manifestChanges),
+        ]);
+    }
+}

src/adapters/abapAdapter.ts

@@ -0,0 +1,7 @@
+import AppVariant from "../appVariantManager.js";
+import BaseApp from "../baseAppManager.js";
+import { MergeCommandChain } from "./commands/command.js";
+
+export interface IAdapter {
+    createMergeCommandChain(baseApp: BaseApp, appVariant: AppVariant): MergeCommandChain;
+}

src/adapters/adapter.ts

@@ -0,0 +1,17 @@
+import BaseApp from "../baseAppManager.js";
+import AppVariant from "../appVariantManager.js";
+import { IAdapter } from "./adapter.js";
+import { MergeCommandChain } from "./commands/command.js";
+import I18nPropertiesMergeCommand from "./commands/i18nPropertiesMergeCommand.js";
+import XsAppJsonMergeCommand from "./commands/xsAppJsonMergeCommand.js";
+
+
+export default class CFAdapter implements IAdapter {
+    createMergeCommandChain(baseApp: BaseApp, appVariant: AppVariant): MergeCommandChain {
+        const manifestChanges = appVariant.getProcessedManifestChanges();
+        return new MergeCommandChain([
+            new I18nPropertiesMergeCommand(baseApp.i18nPath, appVariant.prefix, manifestChanges),
+            new XsAppJsonMergeCommand(),
+        ]);
+    }
+}

src/adapters/cfAdapter.ts

@@ -0,0 +1,41 @@
+export abstract class MergeCommand {
+    readonly commandType = "merge";
+    abstract accept(filename: string): boolean;
+    /**
+     * Executes the command on the specified file
+     * @param files - Map of all files being processed
+     * @param filename - The current file being processed
+     * @param appVariantContent - Content from the app variant
+     */
+    abstract execute(files: Map<string, string>, filename: string, appVariantContent: string): Promise<void>;
+}
+
+
+/**
+ * CommandChain implements the Chain of Responsibility pattern
+ * It manages a collection of commands and executes them in sequence
+ */
+export class MergeCommandChain {
+    constructor(private commands: MergeCommand[] = []) { }
+
+    /**
+     * Executes all commands in the chain that accept the given filename
+     * @param files - Map of all files being processed
+     * @param filename - The current file being processed
+     * @param appVariantContent - Content from the app variant
+     */
+    async execute(files: ReadonlyMap<string, string>, appVariantFiles: ReadonlyMap<string, string>): Promise<ReadonlyMap<string, string>> {
+        const filesCopy = new Map(files);
+        for (const [filename, appVariantContent] of appVariantFiles) {
+            const acceptedCommands = this.commands.filter(command => command.accept(filename));
+            if (acceptedCommands.length > 0) {
+                for (const command of acceptedCommands) {
+                    await command.execute(filesCopy, filename, appVariantContent);
+                }
+            } else {
+                filesCopy.set(filename, appVariantContent);
+            }
+        }
+        return filesCopy;
+    }
+}

src/adapters/commands/command.ts

@@ -0,0 +1,93 @@
+import { escapeRegex, trimExtension } from "../../util/commonUtil.js";
+import { IChange } from "../../model/types.js";
+import { posix as path } from "path";
+import { MergeCommand } from "./command.js";
+
+export default class I18nPropertiesMergeCommand extends MergeCommand {
+
+    private mergePaths: RegExp[];
+    private copyPaths: RegExp[];
+
+    constructor(private i18nPath: string, private prefix: string, manifestChanges: ReadonlyArray<IChange>) {
+        super();
+        const { mergePaths, copyPaths } = this.analyzeAppVariantManifestChanges(manifestChanges);
+        this.mergePaths = mergePaths;
+        this.copyPaths = copyPaths;
+    }
+
+    accept = (filename: string) => filename.endsWith(".properties");
+
+    
+    private analyzeAppVariantManifestChanges(manifestChanges: ReadonlyArray<IChange>) {
+        // check which files need to be copied and which files need to be merged and copied
+        // this is necessary because lrep does not support multiple enhanceWith with multiple locations
+        const TRANSLATION_REGEX_PATTERN = "((_[a-z]{2,3})?(_[a-zA-Z]{2,3}(_[a-zA-Z]{2,20})?)?)\.properties$";
+        const mergePaths = new Set<RegExp>();
+        const copyPaths = new Set<RegExp>();
+        manifestChanges.forEach((change) => {
+            const i18nPathWithExtension = change.content?.bundleUrl || change.texts?.i18n;
+            if (i18nPathWithExtension) {
+                // build regex to match specific + language related files
+                const i18nPath = trimExtension(i18nPathWithExtension);
+                const regex = new RegExp("^" + escapeRegex(i18nPath) + TRANSLATION_REGEX_PATTERN);
+                if (change.changeType.includes("addNewModelEnhanceWith")) {
+                    copyPaths.add(regex);
+                } else {
+                    mergePaths.add(regex);
+                }
+            }
+        });
+        return { mergePaths: Array.from(mergePaths), copyPaths: Array.from(copyPaths) };
+    }
+    
+    
+    async execute(files: Map<string, string>, filename: string, appVariantContent: string): Promise<void> {
+        // merge/copy logic
+        // check if file matches with regex in merge/copy
+        const mergePathMatch = this.mergePaths.map(path => filename.match(path)).find(match => match);
+        const copyPathMatch = this.copyPaths.map(path => filename.match(path)).find(match => match);
+        if (mergePathMatch) {
+            this.mergePropertiesFiles(files, this.i18nPath, appVariantContent, mergePathMatch[1]);
+        }
+        if (copyPathMatch) {
+            files.set(path.join(this.prefix, filename), appVariantContent);
+        }
+    }
+
+    /**
+     * Filters out specific lines from the given string.
+     * Removes lines matching:
+     * - __ldi.translation.uuid\s*=\s*(.*)
+     * - ABAP_TRANSLATION
+     * - SAPUI5 TRANSLATION-KEY
+     */
+    private filterTranslationMetaLines(content: string): string {
+        const lines = content.split('\n');
+        const filtered = lines.filter(
+            line =>
+                !/^# __ldi\.translation\.uuid\s*=/.test(line) &&
+                !line.startsWith("# ABAP_TRANSLATION") &&
+                !line.startsWith("# SAPUI5 TRANSLATION-KEY")
+        );
+        return filtered.join('\n');
+    }
+
+    /**
+     *  Merge/Append base property file with property file from app variant
+     * FIXME Currently merge could duplicate keys which causes undefined
+     * behavior => Existing keys which are in merge content must be removed =>
+     * Actually only descriptor texts are relevant for merge which always have
+     * app variant Id as prefix => If we filter on them we do not need to remove
+     * existing overwritten keys (as there should be none)
+     */
+    private mergePropertiesFiles(files: Map<string, string>, i18nPath: string, appVariantFileContent: string, language: string = "") {
+        const baseAppI18nPath = i18nPath + language + ".properties";
+        const baseAppFileContent = files.get(baseAppI18nPath);
+        const filteredBaseContent = baseAppFileContent ? this.filterTranslationMetaLines(baseAppFileContent) : "";
+        const content = filteredBaseContent
+            ? `${filteredBaseContent}\n\n#App variant specific text file\n\n${appVariantFileContent}`
+            : appVariantFileContent;
+        files.set(baseAppI18nPath, content);
+    }
+
+}

src/adapters/commands/i18nPropertiesMergeCommand.ts

@@ -0,0 +1,20 @@
+import { merge } from "../../util/cf/xsAppJsonUtil.js";
+import { MergeCommand } from "./command.js";
+
+export default class XsAppJsonMergeCommand extends MergeCommand {
+
+    accept = (filename: string) => filename === "xs-app.json";
+
+    async execute(files: Map<string, string>, filename: string, appVariantContent: string): Promise<void> {
+        const baseContent = files.get(filename);
+        const xsAppJsonFiles = [
+            appVariantContent,
+            baseContent // base app xs-app.json comes last
+        ].filter(file => file !== undefined) as string[];
+        const result = merge(xsAppJsonFiles);
+        if (result) {
+            files.set(filename, result);
+        }
+    }
+
+}

src/adapters/commands/xsAppJsonMergeCommand.ts

@@ -4,7 +4,6 @@ import { logBuilderVersion } from "./util/commonUtil.js";
 
 import AppVariant from "./appVariantManager.js";
 import BaseApp from "./baseAppManager.js";
-import I18nMerger from "./util/i18nMerger.js";
 import { ITaskParameters } from "./model/types.js";
 import ResourceUtil from "./util/resourceUtil.js";
 import { determineProcessor } from "./processors/processor.js";
@@ -21,6 +20,7 @@ export default ({ workspace, options, taskUtil }: ITaskParameters) => {
         logBuilderVersion();
 
         const processor = determineProcessor(options.configuration);
+        const adapter = processor.getAdapter();
 
         const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
         const appVariantIdHierarchy = await processor.getAppVariantIdHierarchy(adaptationProject.reference);
@@ -46,7 +46,9 @@ export default ({ workspace, options, taskUtil }: ITaskParameters) => {
             }
             appVariants.push(appVariant);
             const adaptedFiles = await baseApp.adapt(appVariant, processor);
-            return I18nMerger.merge(adaptedFiles, baseApp.i18nPath, appVariant);
+            const mergeCommandChain = adapter.createMergeCommandChain(baseApp, appVariant);
+            const mergedFiles = await mergeCommandChain.execute(adaptedFiles, appVariant.getProcessedFiles());
+            return mergedFiles;
         }
 
         let files = await fetchFilesPromises.reduce(async (previousFiles, currentFiles) =>

src/index.ts

@@ -6,6 +6,8 @@ import IProcessor from "./processor.js";
 import Language from "../model/language.js";
 import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
+import { IAdapter } from "../adapters/adapter.js";
+import AbapAdapter from "../adapters/abapAdapter.js";
 
 export default class AbapProcessor implements IProcessor {
 
@@ -26,6 +28,10 @@ export default class AbapProcessor implements IProcessor {
         return this.abapRepoManager.getAppVariantIdHierarchy(appId);
     }
 
+    getAdapter(): IAdapter {
+        return new AbapAdapter();
+    }
+
 
     @cached()
     fetch(repoName: string, _cachebusterToken: string): Promise<Map<string, string>> {