Refactoring, option rename on `forceTransformStrings`

CHANGELOG.md

@@ -2,7 +2,7 @@ Change Log
 
 v2.4.0
 ---
-* **New option:** `forceTransformedStrings` allows force transform strings even if by `stringArrayThreshold` (or possible other thresholds in the future) they shouldn't be transformed. Implemented https://github.com/javascript-obfuscator/javascript-obfuscator/issues/657
+* **New option:** `forceTransformStrings` allows force transform strings even if by `stringArrayThreshold` (or possible other thresholds in the future) they shouldn't be transformed. Implemented https://github.com/javascript-obfuscator/javascript-obfuscator/issues/657
 
 v2.3.1
 ---

README.md

@@ -339,7 +339,7 @@ Following options are available for the JS Obfuscator:
     debugProtectionInterval: false,
     disableConsoleOutput: false,
     domainLock: [],
-    forceTransformedStrings: [],
+    forceTransformStrings: [],
     identifierNamesGenerator: 'hexadecimal',
     identifiersDictionary: [],
     identifiersPrefix: '',
@@ -392,7 +392,7 @@ Following options are available for the JS Obfuscator:
     --disable-console-output <boolean>
     --domain-lock '<list>' (comma separated)
     --exclude '<list>' (comma separated)
-    --force-transformed-strings '<list>' (comma separated)
+    --force-transform-strings '<list>' (comma separated)
     --identifier-names-generator <string> [dictionary, hexadecimal, mangled, mangled-shuffled]
     --identifiers-dictionary '<list>' (comma separated)
     --identifiers-prefix <string>
@@ -658,7 +658,7 @@ Type: `string[]` Default: `[]`
 
 A file names or globs which indicates files to exclude from obfuscation. 
 
-### `forceTransformedStrings`
+### `forceTransformStrings`
 Type: `string[]` Default: `[]`
 
 Enables force transformation of string literals, which being matched by passed RegExp patterns.
@@ -668,7 +668,7 @@ Enables force transformation of string literals, which being matched by passed R
 Example:
 ```ts
 	{
-		forceTransformedStrings: [
+		forceTransformStrings: [
 			'some-important-value',
 			'some-string_\d'
 		]

src/analyzers/string-array-storage-analyzer/StringArrayStorageAnalyzer.ts

@@ -122,9 +122,9 @@ export class StringArrayStorageAnalyzer implements IStringArrayStorageAnalyzer {
      * @returns {boolean}
      */
     private shouldAddValueToStringArray (literalNode: ESTree.Literal & {value: string}): boolean {
-        const isForceObfuscatedNode: boolean = NodeMetadata.isForceObfuscatedNode(literalNode);
+        const isForceTransformNode: boolean = NodeMetadata.isForceTransformNode(literalNode);
 
-        if (isForceObfuscatedNode) {
+        if (isForceTransformNode) {
             return true;
         }
 

src/cli/JavaScriptObfuscatorCLI.ts

@@ -231,7 +231,7 @@ export class JavaScriptObfuscatorCLI implements IInitializable {
                 ArraySanitizer
             )
             .option(
-                '--force-transformed-strings <list> (comma separated, without whitespaces)',
+                '--force-transform-strings <list> (comma separated, without whitespaces)',
                 'Enables force transformation of string literals, which being matched by passed RegExp patterns (comma separated)',
                 ArraySanitizer
             )

src/container/modules/node-transformers/PreparingTransformersModule.ts

@@ -12,7 +12,7 @@ import { BlackListObfuscatingGuard } from '../../../node-transformers/preparing-
 import { ConditionalCommentObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard';
 import { CustomCodeHelpersTransformer } from '../../../node-transformers/preparing-transformers/CustomCodeHelpersTransformer';
 import { EvalCallExpressionTransformer } from '../../../node-transformers/preparing-transformers/EvalCallExpressionTransformer';
-import { ForceTransformedStringObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ForceTransformedStringObfuscatingGuard';
+import { ForceTransformStringObfuscatingGuard } from '../../../node-transformers/preparing-transformers/obfuscating-guards/ForceTransformStringObfuscatingGuard';
 import { MetadataTransformer } from '../../../node-transformers/preparing-transformers/MetadataTransformer';
 import { ObfuscatingGuardsTransformer } from '../../../node-transformers/preparing-transformers/ObfuscatingGuardsTransformer';
 import { ParentificationTransformer } from '../../../node-transformers/preparing-transformers/ParentificationTransformer';
@@ -57,9 +57,9 @@ export const preparingTransformersModule: interfaces.ContainerModule = new Conta
         .whenTargetNamed(ObfuscatingGuard.ConditionalCommentObfuscatingGuard);
 
     bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
-        .to(ForceTransformedStringObfuscatingGuard)
+        .to(ForceTransformStringObfuscatingGuard)
         .inSingletonScope()
-        .whenTargetNamed(ObfuscatingGuard.ForceTransformedStringObfuscatingGuard);
+        .whenTargetNamed(ObfuscatingGuard.ForceTransformStringObfuscatingGuard);
 
     bind<IObfuscatingGuard>(ServiceIdentifiers.INodeGuard)
         .to(ReservedStringObfuscatingGuard)

src/declarations/ESTree.d.ts

@@ -6,7 +6,7 @@ import * as eslintScope from 'eslint-scope';
 
 declare module 'estree' {
     export interface BaseNodeMetadata {
-        forceObfuscatedNode?: boolean;
+        forceTransformNode?: boolean;
         ignoredNode?: boolean;
     }
 

src/enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard.ts

@@ -1,6 +1,6 @@
 export enum ObfuscatingGuard {
     BlackListObfuscatingGuard = 'BlackListObfuscatingGuard',
     ConditionalCommentObfuscatingGuard = 'ConditionalCommentObfuscatingGuard',
-    ForceTransformedStringObfuscatingGuard = 'ForceTransformedStringObfuscatingGuard',
+    ForceTransformStringObfuscatingGuard = 'ForceTransformStringObfuscatingGuard',
     ReservedStringObfuscatingGuard = 'ReservedStringObfuscatingGuard'
 }

src/enums/node/ObfuscatingGuardResult.ts

@@ -1,5 +1,5 @@
 export enum ObfuscatingGuardResult {
-    ForceObfuscated = 'ForceObfuscated',
-    Ignored = 'Ignored',
-    Obfuscated = 'Obfuscated'
+    ForceTransform = 'ForceTransform',
+    Ignore = 'Ignore',
+    Obfuscate = 'Obfuscate'
 }

src/interfaces/options/IOptions.ts

@@ -18,7 +18,7 @@ export interface IOptions {
     readonly debugProtectionInterval: boolean;
     readonly disableConsoleOutput: boolean;
     readonly domainLock: string[];
-    readonly forceTransformedStrings: string[];
+    readonly forceTransformStrings: string[];
     readonly identifierNamesGenerator: TypeFromEnum<typeof IdentifierNamesGenerator>;
     readonly identifiersDictionary: string[];
     readonly identifiersPrefix: string;

src/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.ts

@@ -30,7 +30,7 @@ export class ObfuscatingGuardsTransformer extends AbstractNodeTransformer {
     private static readonly obfuscatingGuardsList: ObfuscatingGuard[] = [
         ObfuscatingGuard.BlackListObfuscatingGuard,
         ObfuscatingGuard.ConditionalCommentObfuscatingGuard,
-        ObfuscatingGuard.ForceTransformedStringObfuscatingGuard,
+        ObfuscatingGuard.ForceTransformStringObfuscatingGuard,
         ObfuscatingGuard.ReservedStringObfuscatingGuard
     ];
 
@@ -99,24 +99,14 @@ export class ObfuscatingGuardsTransformer extends AbstractNodeTransformer {
      * @param {ObfuscatingGuardResult[]} obfuscatingGuardResults
      */
     private setNodeMetadata (node: ESTree.Node, obfuscatingGuardResults: ObfuscatingGuardResult[]): void {
-        let ignoredNode: boolean = false;
-        let forceObfuscatedNode: boolean = false;
-
-        for (const obfuscatingGuardResult of obfuscatingGuardResults) {
-            if (obfuscatingGuardResult === ObfuscatingGuardResult.Ignored) {
-                ignoredNode = true;
-                forceObfuscatedNode = false;
-                break;
-            }
-
-            if (obfuscatingGuardResult === ObfuscatingGuardResult.ForceObfuscated) {
-                forceObfuscatedNode = true;
-            }
-        }
+        const forceTransformNode: boolean = obfuscatingGuardResults
+            .some((obfuscatingGuardResult: ObfuscatingGuardResult) => obfuscatingGuardResult === ObfuscatingGuardResult.ForceTransform);
+        const ignoredNode: boolean = !forceTransformNode && obfuscatingGuardResults
+            .some((obfuscatingGuardResult: ObfuscatingGuardResult) => obfuscatingGuardResult === ObfuscatingGuardResult.Ignore);
 
         NodeMetadata.set(node, {
-            ignoredNode: ignoredNode && !NodeGuards.isProgramNode(node),
-            forceObfuscatedNode: forceObfuscatedNode && !NodeGuards.isProgramNode(node)
+            forceTransformNode: forceTransformNode && !NodeGuards.isProgramNode(node),
+            ignoredNode: ignoredNode && !NodeGuards.isProgramNode(node)
         });
     }
 }

src/node-transformers/preparing-transformers/obfuscating-guards/BlackListObfuscatingGuard.ts

@@ -33,10 +33,10 @@ export class BlackListObfuscatingGuard implements IObfuscatingGuard {
     public check (node: ESTree.Node): ObfuscatingGuardResult {
         for (let i: number = 0; i < this.blackListGuardsLength; i++) {
             if (BlackListObfuscatingGuard.blackListGuards[i](node)) {
-                return ObfuscatingGuardResult.Ignored;
+                return ObfuscatingGuardResult.Ignore;
             }
         }
 
-        return ObfuscatingGuardResult.Obfuscated;
+        return ObfuscatingGuardResult.Obfuscate;
     }
 }

src/node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard.ts

@@ -48,8 +48,8 @@ export class ConditionalCommentObfuscatingGuard implements IObfuscatingGuard {
         }
 
         return this.obfuscationAllowed
-            ? ObfuscatingGuardResult.Obfuscated
-            : ObfuscatingGuardResult.Ignored;
+            ? ObfuscatingGuardResult.Obfuscate
+            : ObfuscatingGuardResult.Ignore;
     }
 
     /**

src/node-transformers/preparing-transformers/obfuscating-guards/ForceTransformedStringObfuscatingGuard.ts → src/node-transformers/preparing-transformers/obfuscating-guards/ForceTransformStringObfuscatingGuard.ts

@@ -12,7 +12,7 @@ import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 import { NodeGuards } from '../../../node/NodeGuards';
 
 @injectable()
-export class ForceTransformedStringObfuscatingGuard implements IObfuscatingGuard {
+export class ForceTransformStringObfuscatingGuard implements IObfuscatingGuard {
     /**
      * @type {IOptions}
      */
@@ -33,26 +33,26 @@ export class ForceTransformedStringObfuscatingGuard implements IObfuscatingGuard
      */
     public check (node: ESTree.Node): ObfuscatingGuardResult {
         if (
-            this.options.forceTransformedStrings.length
+            this.options.forceTransformStrings.length
             && NodeGuards.isLiteralNode(node)
             && typeof node.value === 'string'
         ) {
-            return !this.isForceTransformedString(node.value)
-                ? ObfuscatingGuardResult.Obfuscated
-                : ObfuscatingGuardResult.ForceObfuscated;
+            return !this.isForceTransformString(node.value)
+                ? ObfuscatingGuardResult.Obfuscate
+                : ObfuscatingGuardResult.ForceTransform;
         }
 
-        return ObfuscatingGuardResult.Obfuscated;
+        return ObfuscatingGuardResult.Obfuscate;
     }
 
     /**
      * @param {string} value
      * @returns {boolean}
      */
-    private isForceTransformedString (value: string): boolean {
-        return this.options.forceTransformedStrings
-            .some((forceTransformedString: string) => {
-                return new RegExp(forceTransformedString, 'g').exec(value) !== null;
+    private isForceTransformString (value: string): boolean {
+        return this.options.forceTransformStrings
+            .some((forceTransformString: string) => {
+                return new RegExp(forceTransformString, 'g').exec(value) !== null;
             });
     }
 }

src/node-transformers/preparing-transformers/obfuscating-guards/ReservedStringObfuscatingGuard.ts

@@ -38,11 +38,11 @@ export class ReservedStringObfuscatingGuard implements IObfuscatingGuard {
             && typeof node.value === 'string'
         ) {
             return !this.isReservedString(node.value)
-                ? ObfuscatingGuardResult.Obfuscated
-                : ObfuscatingGuardResult.Ignored;
+                ? ObfuscatingGuardResult.Obfuscate
+                : ObfuscatingGuardResult.Ignore;
         }
 
-        return ObfuscatingGuardResult.Obfuscated;
+        return ObfuscatingGuardResult.Obfuscate;
     }
 
     /**

src/node/NodeMetadata.ts

@@ -24,8 +24,8 @@ export class NodeMetadata {
      * @param {Node} node
      * @returns {boolean}
      */
-    public static isForceObfuscatedNode (node: ESTree.Node): boolean {
-        return NodeMetadata.get(node, 'forceObfuscatedNode') === true;
+    public static isForceTransformNode (node: ESTree.Node): boolean {
+        return NodeMetadata.get(node, 'forceTransformNode') === true;
     }
 
     /**

src/options/Options.ts

@@ -136,7 +136,7 @@ export class Options implements IOptions {
     @IsString({
         each: true
     })
-    public readonly forceTransformedStrings!: string[];
+    public readonly forceTransformStrings!: string[];
 
     /**
      * @type {IdentifierNamesGenerator}

src/options/presets/Default.ts

@@ -19,7 +19,7 @@ export const DEFAULT_PRESET: TInputOptions = Object.freeze({
     disableConsoleOutput: false,
     domainLock: [],
     exclude: [],
-    forceTransformedStrings: [],
+    forceTransformStrings: [],
     identifierNamesGenerator: IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator,
     identifiersPrefix: '',
     identifiersDictionary: [],

src/options/presets/NoCustomNodes.ts

@@ -17,7 +17,7 @@ export const NO_ADDITIONAL_NODES_PRESET: TInputOptions = Object.freeze({
     disableConsoleOutput: false,
     domainLock: [],
     exclude: [],
-    forceTransformedStrings: [],
+    forceTransformStrings: [],
     identifierNamesGenerator: IdentifierNamesGenerator.HexadecimalIdentifierNamesGenerator,
     identifiersPrefix: '',
     identifiersDictionary: [],

test/functional-tests/node-transformers/finalizing-transformers/escape-sequence-transformer/EscapeSequenceTransformer.spec.ts

@@ -136,30 +136,30 @@ describe('EscapeSequenceTransformer', function () {
         });
     });
 
-    describe('Variant #5: `forceTransformedStrings` option is enabled', () => {
+    describe('Variant #5: `forceTransformStrings` option is enabled', () => {
         const stringLiteralRegExp1: RegExp = /const foo *= *'foo';/;
         const stringLiteralRegExp2: RegExp = /const bar *= *'bar';/;
 
         let obfuscatedCode: string;
 
         before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/force-transformed-strings-option.js');
+            const code: string = readFileAsString(__dirname + '/fixtures/force-transform-strings-option.js');
 
             obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,
                 {
                     ...NO_ADDITIONAL_NODES_PRESET,
-                    forceTransformedStrings: ['bar'],
+                    forceTransformStrings: ['bar'],
                     unicodeEscapeSequence: false
                 }
             ).getObfuscatedCode();
         });
 
-        it('match #1: should not encode force transformed string with unicode escape sequence', () => {
+        it('match #1: should not encode force transform string with unicode escape sequence', () => {
             assert.match(obfuscatedCode, stringLiteralRegExp1);
         });
 
-        it('match #2: should not encode force transformed string with unicode escape sequence', () => {
+        it('match #2: should not encode force transform string with unicode escape sequence', () => {
             assert.match(obfuscatedCode, stringLiteralRegExp2);
         });
     });

test/functional-tests/node-transformers/preparing-transformers/obfuscating-guards/force-transform-string-obfuscating-guard/ForceTransformStringObfuscatingGuard.spec.ts

@@ -0,0 +1,69 @@
+import { assert } from 'chai';
+
+import { JavaScriptObfuscator } from '../../../../../../src/JavaScriptObfuscatorFacade';
+
+import { NO_ADDITIONAL_NODES_PRESET } from '../../../../../../src/options/presets/NoCustomNodes';
+
+import { IdentifierNamesGenerator } from '../../../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
+
+import { readFileAsString } from '../../../../../helpers/readFileAsString';
+
+describe('ForceTransformStringObfuscatingGuard', () => {
+    describe('check', () => {
+        describe('`forceTransformStrings` option is enabled', () => {
+            const obfuscatingGuardRegExp: RegExp = new RegExp(
+                'var foo *= *\'foo\';' +
+                'var bar *= *b\\(\'0x0\'\\);'
+            );
+
+            let obfuscatedCode: string;
+
+            beforeEach(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/base-behaviour.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        forceTransformStrings: ['bar'],
+                        identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator,
+                        stringArray: true,
+                        stringArrayThreshold: 0
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('match #1: should obfuscate force transform strings', () => {
+                assert.match(obfuscatedCode, obfuscatingGuardRegExp);
+            });
+        });
+
+        describe('`forceTransformStrings` option is disabled', () => {
+            const obfuscatingGuardRegExp: RegExp = new RegExp(
+                'var foo *= *\'foo\';' +
+                'var bar *= *\'bar\';'
+            );
+
+            let obfuscatedCode: string;
+
+            beforeEach(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/base-behaviour.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        forceTransformStrings: [],
+                        identifierNamesGenerator: IdentifierNamesGenerator.MangledIdentifierNamesGenerator,
+                        stringArray: true,
+                        stringArrayThreshold: 0
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('match #1: shouldn\'t obfuscate strings', () => {
+                assert.match(obfuscatedCode, obfuscatingGuardRegExp);
+            });
+        });
+    });
+});

test/functional-tests/node-transformers/preparing-transformers/obfuscating-guards/force-transform-string-obfuscating-guard/fixtures/base-behaviour.js

@@ -0,0 +1,2 @@
+var foo = 'foo';
+var bar = 'bar';

test/functional-tests/node-transformers/string-array-transformers/string-array-transformer/StringArrayTransformer.spec.ts

@@ -566,22 +566,22 @@ describe('StringArrayTransformer', function () {
         });
     });
 
-    describe('Variant #13: `forceTransformedStrings` option is enabled', () => {
-        describe('Variant #1: base `forceTransformedStrings` values', () => {
-            describe('Variant #1: single force transformed string value', () => {
+    describe('Variant #13: `forceTransformStrings` option is enabled', () => {
+        describe('Variant #1: base `forceTransformStrings` values', () => {
+            describe('Variant #1: single force transform string value', () => {
                 const stringLiteralRegExp1: RegExp = /const foo *= *'foo';/;
                 const stringLiteralRegExp2: RegExp = /const bar *= *_0x([a-f0-9]){4}\('0x0'\);/;
 
                 let obfuscatedCode: string;
 
                 before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/force-transformed-strings-option.js');
+                    const code: string = readFileAsString(__dirname + '/fixtures/force-transform-strings-option.js');
 
                     obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
-                            forceTransformedStrings: ['bar'],
+                            forceTransformStrings: ['bar'],
                             stringArray: true,
                             stringArrayThreshold: 0
                         }
@@ -592,56 +592,56 @@ describe('StringArrayTransformer', function () {
                     assert.match(obfuscatedCode, stringLiteralRegExp1);
                 });
 
-                it('match #2: should transform force transformed string', () => {
+                it('match #2: should transform force transform string', () => {
                     assert.match(obfuscatedCode, stringLiteralRegExp2);
                 });
             });
 
-            describe('Variant #2: two force transformed string values', () => {
+            describe('Variant #2: two force transform string values', () => {
                 const stringLiteralRegExp1: RegExp = /const foo *= *_0x([a-f0-9]){4}\('0x0'\);/;
                 const stringLiteralRegExp2: RegExp = /const bar *= *_0x([a-f0-9]){4}\('0x1'\);/;
 
                 let obfuscatedCode: string;
 
                 before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/force-transformed-strings-option.js');
+                    const code: string = readFileAsString(__dirname + '/fixtures/force-transform-strings-option.js');
 
                     obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
-                            forceTransformedStrings: ['foo', 'bar'],
+                            forceTransformStrings: ['foo', 'bar'],
                             stringArray: true,
                             stringArrayThreshold: 0
                         }
                     ).getObfuscatedCode();
                 });
 
-                it('match #1: should transform force transformed string', () => {
+                it('match #1: should transform force transform string', () => {
                     assert.match(obfuscatedCode, stringLiteralRegExp1);
                 });
 
-                it('match #2: should transform force transformed string', () => {
+                it('match #2: should transform force transform string', () => {
                     assert.match(obfuscatedCode, stringLiteralRegExp2);
                 });
             });
         });
 
-        describe('Variant #2: RegExp `forceTransformedStrings` values', () => {
-            describe('Variant #1: single force transformed string value', () => {
+        describe('Variant #2: RegExp `forceTransformStrings` values', () => {
+            describe('Variant #1: single force transform string value', () => {
                 const stringLiteralRegExp1: RegExp = /const foo *= *'foo'/;
                 const stringLiteralRegExp2: RegExp = /const bar *= *_0x([a-f0-9]){4}\('0x0'\);/;
 
                 let obfuscatedCode: string;
 
                 before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/force-transformed-strings-option.js');
+                    const code: string = readFileAsString(__dirname + '/fixtures/force-transform-strings-option.js');
 
                     obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
-                            forceTransformedStrings: ['ar$'],
+                            forceTransformStrings: ['ar$'],
                             stringArray: true,
                             stringArrayThreshold: 0
                         }
@@ -652,36 +652,36 @@ describe('StringArrayTransformer', function () {
                     assert.match(obfuscatedCode, stringLiteralRegExp1);
                 });
 
-                it('match #2: should transform force transformed string', () => {
+                it('match #2: should transform force transform string', () => {
                     assert.match(obfuscatedCode, stringLiteralRegExp2);
                 });
             });
 
-            describe('Variant #2: two force transformed string values', () => {
+            describe('Variant #2: two force transform string values', () => {
                 const stringLiteralRegExp1: RegExp = /const foo *= *_0x([a-f0-9]){4}\('0x0'\);/;
                 const stringLiteralRegExp2: RegExp = /const bar *= *_0x([a-f0-9]){4}\('0x1'\);/;
 
                 let obfuscatedCode: string;
 
                 before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/force-transformed-strings-option.js');
+                    const code: string = readFileAsString(__dirname + '/fixtures/force-transform-strings-option.js');
 
                     obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
-                            forceTransformedStrings: ['^fo', '.ar'],
+                            forceTransformStrings: ['^fo', '.ar'],
                             stringArray: true,
                             stringArrayThreshold: 1
                         }
                     ).getObfuscatedCode();
                 });
 
-                it('match #1: should transform force transformed string', () => {
+                it('match #1: should transform force transform string', () => {
                     assert.match(obfuscatedCode, stringLiteralRegExp1);
                 });
 
-                it('match #2: should transform force transformed string', () => {
+                it('match #2: should transform force transform string', () => {
                     assert.match(obfuscatedCode, stringLiteralRegExp2);
                 });
             });
@@ -695,13 +695,13 @@ describe('StringArrayTransformer', function () {
                 let obfuscatedCode: string;
 
                 before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/force-transformed-strings-option.js');
+                    const code: string = readFileAsString(__dirname + '/fixtures/force-transform-strings-option.js');
 
                     obfuscatedCode = JavaScriptObfuscator.obfuscate(
                         code,
                         {
                             ...NO_ADDITIONAL_NODES_PRESET,
-                            forceTransformedStrings: ['foo', 'bar'],
+                            forceTransformStrings: ['foo', 'bar'],
                             stringArray: false,
                             stringArrayThreshold: 0
                         }

test/index.spec.ts

@@ -100,6 +100,7 @@ import './functional-tests/node-transformers/initializing-transformers/comments-
 import './functional-tests/node-transformers/preparing-transformers/eval-call-expression-transformer/EvalCallExpressionTransformer.spec';
 import './functional-tests/node-transformers/preparing-transformers/obfuscating-guards/black-list-obfuscating-guard/BlackListObfuscatingGuard.spec';
 import './functional-tests/node-transformers/preparing-transformers/obfuscating-guards/conditional-comment-obfuscating-guard/ConditionalCommentObfuscatingGuard.spec';
+import './functional-tests/node-transformers/preparing-transformers/obfuscating-guards/force-transform-string-obfuscating-guard/ForceTransformStringObfuscatingGuard.spec';
 import './functional-tests/node-transformers/preparing-transformers/obfuscating-guards/reserved-string-obfuscating-guard/ReservedStringObfuscatingGuard.spec';
 import './functional-tests/node-transformers/preparing-transformers/variable-preserve-transformer/VariablePreserveTransformer.spec';
 import './functional-tests/node-transformers/rename-identifiers-transformers/identifier-replacer/IdentifierReplacer.spec';

test/unit-tests/analyzers/string-array-storage-analyzer/StringArrayStorageAnalyzer.spec.ts

@@ -254,11 +254,11 @@ describe('StringArrayStorageAnalyzer', () => {
             });
         });
 
-        describe('Analyzes of the AST tree with force obfuscated string literal nodes', () => {
+        describe('Analyzes of the AST tree with force transform string literal nodes', () => {
             describe('Variant #1: Force obfuscate string when threshold is `0`', () => {
                 const literalNode1: ESTree.Literal = NodeFactory.literalNode('foo');
                 const literalNode2: ESTree.Literal = NodeFactory.literalNode('bar');
-                NodeMetadata.set(literalNode2, {forceObfuscatedNode: true});
+                NodeMetadata.set(literalNode2, {forceTransformNode: true});
 
                 const expectedStringArrayStorageItemData1: undefined = undefined;
                 const expectedStringArrayStorageItemData2: IStringArrayStorageItemData = {
@@ -299,7 +299,7 @@ describe('StringArrayStorageAnalyzer', () => {
             describe('Variant #2: Force obfuscate string when string value shorter than allowed length', () => {
                 const literalNode1: ESTree.Literal = NodeFactory.literalNode('a');
                 const literalNode2: ESTree.Literal = NodeFactory.literalNode('b');
-                NodeMetadata.set(literalNode2, {forceObfuscatedNode: true});
+                NodeMetadata.set(literalNode2, {forceTransformNode: true});
 
                 const expectedStringArrayStorageItemData1: undefined = undefined;
                 const expectedStringArrayStorageItemData2: IStringArrayStorageItemData = {

test/unit-tests/node-transformers/preparing-transformers/ObfuscatingGuardsTransformer.spec.ts

@@ -17,8 +17,8 @@ import { NodeUtils } from '../../../../src/node/NodeUtils';
 
 describe('ObfuscatingGuardsTransformer', () => {
     describe('transformNode', () => {
-        const forceObfuscatedString: string = 'important string';
-        const ignoredAndForceObfuscatedString: string = 'important ignored string';
+        const forceTransformString: string = 'important string';
+        const ignoredAndForceTransformString: string = 'important ignored string';
 
         let inversifyContainerFacade: IInversifyContainerFacade,
             obfuscatingGuardsTransformer: INodeTransformer;
@@ -26,12 +26,12 @@ describe('ObfuscatingGuardsTransformer', () => {
         before(() => {
             inversifyContainerFacade = new InversifyContainerFacade();
             inversifyContainerFacade.load('', '', {
-                forceTransformedStrings: [
-                    forceObfuscatedString,
-                    ignoredAndForceObfuscatedString
+                forceTransformStrings: [
+                    forceTransformString,
+                    ignoredAndForceTransformString
                 ],
                 reservedStrings: [
-                    ignoredAndForceObfuscatedString
+                    ignoredAndForceTransformString
                 ]
             });
 
@@ -50,7 +50,7 @@ describe('ObfuscatingGuardsTransformer', () => {
                 identifier.parentNode = identifier;
 
                 NodeMetadata.set(expectedResult, {
-                    forceObfuscatedNode: false,
+                    forceTransformNode: false,
                     ignoredNode: false
                 });
 
@@ -78,7 +78,7 @@ describe('ObfuscatingGuardsTransformer', () => {
 
                 expectedResult.parentNode = expectedResult;
                 NodeMetadata.set(expectedResult, {
-                    forceObfuscatedNode: false,
+                    forceTransformNode: false,
                     ignoredNode: true
                 });
 
@@ -91,8 +91,8 @@ describe('ObfuscatingGuardsTransformer', () => {
             });
         });
 
-        describe('Variant #3: force obfuscated node', () => {
-            const literalNode: ESTree.Literal =  NodeFactory.literalNode(forceObfuscatedString);
+        describe('Variant #3: force transform node', () => {
+            const literalNode: ESTree.Literal =  NodeFactory.literalNode(forceTransformString);
 
             const expectedResult: ESTree.Literal = NodeUtils.clone(literalNode);
 
@@ -103,7 +103,7 @@ describe('ObfuscatingGuardsTransformer', () => {
 
                 expectedResult.parentNode = expectedResult;
                 NodeMetadata.set(expectedResult, {
-                    forceObfuscatedNode: true,
+                    forceTransformNode: true,
                     ignoredNode: false
                 });
 
@@ -111,13 +111,13 @@ describe('ObfuscatingGuardsTransformer', () => {
                     .transformNode(literalNode, literalNode);
             });
 
-            it('should add `forceObfuscatedNode` property with `true` value to given node', () => {
+            it('should add `forceTransformNode` property with `true` value to given node', () => {
                 assert.deepEqual(result, expectedResult);
             });
         });
 
-        describe('Variant #4: ignored node and force obfuscated node', () => {
-            const literalNode: ESTree.Literal = NodeFactory.literalNode(ignoredAndForceObfuscatedString);
+        describe('Variant #4: ignored node and force transform node', () => {
+            const literalNode: ESTree.Literal = NodeFactory.literalNode(ignoredAndForceTransformString);
 
             const expectedResult: ESTree.Literal = NodeUtils.clone(literalNode);
 
@@ -128,15 +128,15 @@ describe('ObfuscatingGuardsTransformer', () => {
 
                 expectedResult.parentNode = expectedResult;
                 NodeMetadata.set(expectedResult, {
-                    forceObfuscatedNode: false,
-                    ignoredNode: true
+                    forceTransformNode: true,
+                    ignoredNode: false
                 });
 
                 result = <ESTree.Literal>obfuscatingGuardsTransformer
                     .transformNode(literalNode, literalNode);
             });
 
-            it('should add `ignoredNode` property with `true` value to given node', () => {
+            it('should add correct metadata to given node', () => {
                 assert.deepEqual(result, expectedResult);
             });
         });

test/unit-tests/node/node-metadata/NodeMetadata.spec.ts

@@ -47,7 +47,7 @@ describe('NodeMetadata', () => {
         });
     });
 
-    describe('isForceObfuscatedNode', () => {
+    describe('isForceTransformNode', () => {
         const expectedValue: boolean = true;
 
         let node: ESTree.Identifier,
@@ -56,8 +56,8 @@ describe('NodeMetadata', () => {
         before(() => {
             node = NodeFactory.identifierNode('foo');
             node.metadata = {};
-            node.metadata.forceObfuscatedNode = true;
-            value = NodeMetadata.isForceObfuscatedNode(node);
+            node.metadata.forceTransformNode = true;
+            value = NodeMetadata.isForceTransformNode(node);
         });
 
         it('should return metadata value', () => {