feat(generation-options): changes in codefend options to add generation

src/__tests__/obfuscate.test.ts

@@ -33,13 +33,15 @@ describe("Obfuscate", () => {
         code,
         {},
         {
-          ignoredWords: ["l_predefined_and_ignored"],
-          predefinedWords: [
-            {
-              originalWord: "l_predefined_and_ignored",
-              targetWord: "l_predefined_target",
-            },
-          ],
+          obfuscationOptions: {
+            ignoredWords: ["l_predefined_and_ignored"],
+            predefinedWords: [
+              {
+                originalWord: "l_predefined_and_ignored",
+                targetWord: "l_predefined_target",
+              },
+            ],
+          },
         }
       );
       expect(output).toEqual(

src/cli/CodefendCLI.ts

@@ -56,8 +56,8 @@ export class CodefendCLI implements ICodefendCLI {
     console.log("Creating .codefendrc.json...");
     await this.delay(500);
     const options = { ...codefendDefaultOptions };
-    if (options.regexList?.length) {
-      options.regexList.forEach((regex) => {
+    if (options.obfuscationOptions.regexList?.length) {
+      options.obfuscationOptions.regexList.forEach((regex) => {
         delete regex._regExp;
       });
     }
@@ -94,7 +94,14 @@ export class CodefendCLI implements ICodefendCLI {
           ".codefendrc.json does not contains a valid json format"
         );
       } else {
-        configObj.regexList?.forEach((regexListOption) => {
+        if (!configObj.generationOptions) {
+          checkResults.errors.push(
+            ".codefendrc.json is missing generationOptions. please run codefend -i to create a new one"
+          );
+          return;
+        }
+
+        configObj.obfuscationOptions.regexList?.forEach((regexListOption) => {
           regexListOption._regExp =
             CodefendCore.parser.initializeRegex(regexListOption);
         });
@@ -126,8 +133,14 @@ export class CodefendCLI implements ICodefendCLI {
     }
     console.log("Obfuscation started...");
     await this.delay(500);
-    fileSystem.folderManager.removeFolder("./output");
-    fileSystem.folderManager.copyFolderSync("./input", "./output");
+    if (!config.generationOptions) {
+      return;
+    }
+    fileSystem.folderManager.removeFolder(config.generationOptions.outputDir);
+    fileSystem.folderManager.copyFolderSync(
+      config.generationOptions.inputDir,
+      config.generationOptions.outputDir
+    );
     console.log("Obfuscation completed.");
   }
 

src/core/mapper/CodefendMapper.ts

@@ -26,7 +26,7 @@ export class CodefendMapper implements ICodefendMapper {
     map: Record<string, string>,
     prefix?: string
   ) {
-    prefix = prefix ?? this.options.prefix;
+    prefix = prefix ?? this.options.obfuscationOptions.prefix;
     let sequence = Object.keys(map).length;
     words.forEach((word) => {
       if (map[word.value]) return;
@@ -48,7 +48,8 @@ export class CodefendMapper implements ICodefendMapper {
   }
 
   mapIgnoredWords(map: Record<string, string>, ignoredWords?: string[]) {
-    ignoredWords = ignoredWords ?? this.options.ignoredWords ?? [];
+    ignoredWords =
+      ignoredWords ?? this.options.obfuscationOptions.ignoredWords ?? [];
     ignoredWords.forEach((word: string) => {
       map[word] = word;
     });
@@ -59,7 +60,8 @@ export class CodefendMapper implements ICodefendMapper {
     map: Record<string, string>,
     predefinedWords?: ICodefendPredefinedWordOption[]
   ) {
-    predefinedWords = predefinedWords ?? this.options.predefinedWords ?? [];
+    predefinedWords =
+      predefinedWords ?? this.options.obfuscationOptions.predefinedWords ?? [];
     predefinedWords.forEach((predefinedWord) => {
       map[predefinedWord.originalWord] = predefinedWord.targetWord;
     });

src/core/options/ICodefendOptions.ts

@@ -1,9 +1,19 @@
 export interface ICodefendOptions {
+  generationOptions?: ICodefendGenerationOptions;
+  obfuscationOptions: ICodefendObfuscationOptions;
+  debug?: boolean;
+}
+
+export interface ICodefendGenerationOptions {
+  inputDir: string;
+  outputDir: string;
+}
+
+export interface ICodefendObfuscationOptions {
   prefix?: string;
   predefinedWords?: ICodefendPredefinedWordOption[];
   ignoredWords?: string[];
   regexList?: ICodefendRegexListOption[];
-  debug?: boolean;
 }
 
 export interface ICodefendPredefinedWordOption {
@@ -19,19 +29,26 @@ export interface ICodefendRegexListOption {
 }
 
 export const defaultOptions: ICodefendOptions = {
-  prefix: "Ox",
-  predefinedWords: [],
-  ignoredWords: [],
-  regexList: [
-    {
-      name: "main",
-      value: "([a-zA-Z]+(_[a-zA-Z0-9]+)+)",
-      flag: "g",
-    },
-    {
-      name: "file",
-      value: "((cmp|lib)+(-[a-zA-Z]+)+)",
-      flag: "g",
-    },
-  ],
+  generationOptions: {
+    inputDir: "codefend-input",
+    outputDir: "codefend-output",
+  },
+
+  obfuscationOptions: {
+    prefix: "Ox",
+    predefinedWords: [],
+    ignoredWords: [],
+    regexList: [
+      {
+        name: "main",
+        value: "([a-zA-Z]+(_[a-zA-Z0-9]+)+)",
+        flag: "g",
+      },
+      {
+        name: "file",
+        value: "((cmp|lib)+(-[a-zA-Z]+)+)",
+        flag: "g",
+      },
+    ],
+  },
 };

src/core/parser/CodefendParser.ts

@@ -23,7 +23,7 @@ export class CodefendParser implements ICodefendParser {
   }
 
   parse(code: string, regexList?: ICodefendRegexListOption[]) {
-    regexList = regexList ?? this.options.regexList;
+    regexList = regexList ?? this.options.obfuscationOptions.regexList;
     if (!regexList) {
       throw new Error("Codefend: regexList required for parser");
     }

src/fs/folder/CodefendFolderManager.ts

@@ -6,7 +6,12 @@ export class CodefendFolderManager implements ICodefendFolderManager {
   copyFolderSync(from: string, to: string) {
     if (!fs.existsSync(to)) fs.mkdirSync(to);
     fs.readdirSync(from).forEach((element) => {
-      if (element === "node_modules") return;
+      if (
+        ["node_modules", ".github", ".vscode", "codefend-output"].includes(
+          element
+        )
+      )
+        return;
       if (fs.lstatSync(path.join(from, element)).isFile()) {
         fs.copyFileSync(path.join(from, element), path.join(to, element));
       } else {

src/index.ts

@@ -1,4 +1,3 @@
-import { ICodefendFolderManager } from "./../build/src/fs/folder/ICodefendFolderManager.d";
 import { CodefendCLI } from "./cli/CodefendCLI";
 import { CodefendMapper } from "./core/mapper/CodefendMapper";
 import { ICodefendMapper } from "./core/mapper/ICodefendMapper";
@@ -15,6 +14,7 @@ import { ICodefendFileReader } from "./fs/file/reader/ICodefendFileReader";
 import { CodefendFileWriter } from "./fs/file/writer/CodefendFileWriter";
 import { ICodefendFileWriter } from "./fs/file/writer/ICodefendFileWriter";
 import { CodefendFolderManager } from "./fs/folder/CodefendFolderManager";
+import { ICodefendFolderManager } from "./fs/folder/ICodefendFolderManager";
 import { CodefendLogger } from "./logger/CodefendLogger";
 
 export const logger = new CodefendLogger(defaultOptions);
@@ -37,11 +37,20 @@ export function obfuscate(
   map: Record<string, string> = {},
   options?: ICodefendOptions
 ) {
-  const words = CodefendCore.parser.parse(code, options?.regexList);
-  CodefendCore.mapper.buildMap(words, map, options?.prefix);
+  const words = CodefendCore.parser.parse(
+    code,
+    options?.obfuscationOptions.regexList
+  );
+  CodefendCore.mapper.buildMap(words, map, options?.obfuscationOptions.prefix);
   map = CodefendCore.mapper.sortMap(map);
-  CodefendCore.mapper.mapPredefinedWords(map, options?.predefinedWords);
-  CodefendCore.mapper.mapIgnoredWords(map, options?.ignoredWords);
+  CodefendCore.mapper.mapPredefinedWords(
+    map,
+    options?.obfuscationOptions.predefinedWords
+  );
+  CodefendCore.mapper.mapIgnoredWords(
+    map,
+    options?.obfuscationOptions.ignoredWords
+  );
   const output = CodefendCore.replacer.replace(code, map);
   return output;
 }