Added more tests for directory compilation and fixed some logic.

README.md

@@ -252,6 +252,7 @@ Following options are available for the JS Obfuscator:
     debugProtection: false,
     debugProtectionInterval: false,
     disableConsoleOutput: false,
+    domainLock: [],
     log: false,
     mangle: false,
     renameGlobals: false,
@@ -286,10 +287,11 @@ Following options are available for the JS Obfuscator:
     --debugProtection <boolean>
     --debugProtectionInterval <boolean>
     --disableConsoleOutput <boolean>
+    --domainLock '<list>' (comma separated)
     --log <boolean>
     --mangle <boolean>
     --renameGlobals <boolean>
-    --reservedNames <list> (comma separated)
+    --reservedNames '<list>' (comma separated)
     --rotateStringArray <boolean>
     --seed <number>
     --selfDefending <boolean>

src/cli/JavaScriptObfuscatorCLI.ts

@@ -24,6 +24,23 @@ import { JavaScriptObfuscator } from '../JavaScriptObfuscatorFacade';
 import { SourceCodeReader } from './utils/SourceCodeReader';
 
 export class JavaScriptObfuscatorCLI implements IInitializable {
+    /**
+     * @type {string[]}
+     */
+    public static readonly availableInputExtensions: string[] = [
+        '.js'
+    ];
+
+    /**
+     * @type {BufferEncoding}
+     */
+    public static readonly encoding: BufferEncoding = 'utf8';
+
+    /**
+     * @type {string}
+     */
+    public static obfuscatedFilePrefix: string = '-obfuscated';
+
     /**
      * @type {string[]}
      */
@@ -295,8 +312,9 @@ export class JavaScriptObfuscatorCLI implements IInitializable {
     private configureHelp (): void {
         this.commands.on('--help', () => {
             console.log('  Examples:\n');
-            console.log('    %> javascript-obfuscator in.js --compact true --selfDefending false');
-            console.log('    %> javascript-obfuscator in.js --output out.js --compact true --selfDefending false');
+            console.log('    %> javascript-obfuscator input_file_name.js --compact true --selfDefending false');
+            console.log('    %> javascript-obfuscator input_file_name.js --output output_file_name.js --compact true --selfDefending false');
+            console.log('    %> javascript-obfuscator input_directory_name --compact true --selfDefending false');
             console.log('');
         });
     }

src/cli/utils/CLIUtils.ts

@@ -6,12 +6,9 @@ import { TObject } from '../../types/TObject';
 
 import { IPackageConfig } from '../../interfaces/cli/IPackageConfig';
 
-export class CLIUtils {
-    /**
-     * @type {BufferEncoding}
-     */
-    private static readonly encoding: BufferEncoding = 'utf8';
+import { JavaScriptObfuscatorCLI } from '../JavaScriptObfuscatorCLI';
 
+export class CLIUtils {
     /**
      * @param {string} inputPath
      * @returns {string}
@@ -20,7 +17,7 @@ export class CLIUtils {
         return inputPath
             .split('.')
             .map((value: string, index: number) => {
-                return index === 0 ? `${value}-obfuscated` : value;
+                return index === 0 ? `${value}${JavaScriptObfuscatorCLI.obfuscatedFilePrefix}` : value;
             })
             .join('.');
     }
@@ -58,7 +55,7 @@ export class CLIUtils {
                     ),
                     '../package.json'
                 ),
-                CLIUtils.encoding
+                JavaScriptObfuscatorCLI.encoding
             )
         );
     }
@@ -91,7 +88,7 @@ export class CLIUtils {
         mkdirp.sync(path.dirname(outputPath));
 
         fs.writeFileSync(outputPath, data, {
-            encoding: CLIUtils.encoding
+            encoding: JavaScriptObfuscatorCLI.encoding
         });
     }
 }

src/cli/utils/SourceCodeReader.ts

@@ -5,19 +5,9 @@ import { TSourceCodeData } from '../../types/cli/TSourceCodeData';
 
 import { IFileData } from '../../interfaces/cli/IFileData';
 
-export class SourceCodeReader {
-    /**
-     * @type {string[]}
-     */
-    private static readonly availableInputExtensions: string[] = [
-        '.js'
-    ];
-
-    /**
-     * @type {BufferEncoding}
-     */
-    private static readonly encoding: BufferEncoding = 'utf8';
+import { JavaScriptObfuscatorCLI } from '../JavaScriptObfuscatorCLI';
 
+export class SourceCodeReader {
     /**
      * @param {string} inputPath
      * @returns {TSourceCodeData}
@@ -63,11 +53,11 @@ export class SourceCodeReader {
      * @returns {IFileData[]}
      */
     private static readDirectory (directoryPath: string): IFileData[] {
-        return fs.readdirSync(directoryPath, SourceCodeReader.encoding)
+        return fs.readdirSync(directoryPath, JavaScriptObfuscatorCLI.encoding)
             .filter(SourceCodeReader.isValidFile)
             .map((fileName: string) => {
                 const filePath: string = `${directoryPath}/${fileName}`;
-                const content: string = fs.readFileSync(filePath, SourceCodeReader.encoding);
+                const content: string = fs.readFileSync(filePath, JavaScriptObfuscatorCLI.encoding);
 
                 return { filePath, content };
             });
@@ -82,7 +72,7 @@ export class SourceCodeReader {
             throw new ReferenceError(`Input file must have .js extension`);
         }
 
-        return fs.readFileSync(filePath, SourceCodeReader.encoding);
+        return fs.readFileSync(filePath, JavaScriptObfuscatorCLI.encoding);
     }
 
     /**
@@ -90,6 +80,7 @@ export class SourceCodeReader {
      * @returns {boolean}
      */
     private static isValidFile (filePath: string): boolean {
-        return SourceCodeReader.availableInputExtensions.includes(path.extname(filePath));
+        return JavaScriptObfuscatorCLI.availableInputExtensions.includes(path.extname(filePath))
+            && !filePath.includes(JavaScriptObfuscatorCLI.obfuscatedFilePrefix);
     }
 }

test/fixtures/directory-obfuscation/bar.js

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

test/fixtures/directory-obfuscation/baz.ts

@@ -0,0 +1 @@
+var baz = 3;

test/fixtures/directory-obfuscation/foo.js

@@ -0,0 +1 @@
+var foo = 1;

test/functional-tests/cli/JavaScriptObfuscatorCLI.spec.ts

@@ -27,105 +27,154 @@ describe('JavaScriptObfuscatorCLI', function (): void {
             mkdirp.sync(outputDirName);
         });
 
-        describe('`--output` option is set', () => {
-            let isFileExist: boolean;
-
-            before(() => {
-                JavaScriptObfuscator.runCLI([
-                    'node',
-                    'javascript-obfuscator',
-                    fixtureFilePath,
-                    '--output',
-                    outputFilePath,
-                    '--compact',
-                    'true',
-                    '--selfDefending',
-                    '0'
-                ]);
-
-                isFileExist = fs.existsSync(outputFilePath);
-            });
-
-            it('should create file with obfuscated code in `--output` directory', () => {
-                assert.equal(isFileExist, true);
-            });
-
-            after(() => {
-                fs.unlinkSync(outputFilePath);
-            });
-        });
-
-        describe('`--output` option isn\'t set', () => {
-            describe('variant #1: default behaviour', () => {
-                let outputFixturesFilePath: string,
-                    isFileExist: boolean;
+        describe('Variant #1: obfuscation of single file', () => {
+            describe('`--output` option is set', () => {
+                let isFileExist: boolean;
 
                 before(() => {
-                    outputFixturesFilePath = `${fixturesDirName}/${outputFileName}`;
-
                     JavaScriptObfuscator.runCLI([
                         'node',
                         'javascript-obfuscator',
-                        fixtureFilePath
+                        fixtureFilePath,
+                        '--output',
+                        outputFilePath,
+                        '--compact',
+                        'true',
+                        '--selfDefending',
+                        '0'
                     ]);
 
-                    isFileExist = fs.existsSync(outputFixturesFilePath);
+                    isFileExist = fs.existsSync(outputFilePath);
                 });
 
-                it(`should create file \`${outputFileName}\` with obfuscated code in \`${fixturesDirName}\` directory`, () => {
+                it('should create file with obfuscated code in `--output` directory', () => {
                     assert.equal(isFileExist, true);
                 });
 
                 after(() => {
-                    fs.unlinkSync(outputFixturesFilePath);
+                    fs.unlinkSync(outputFilePath);
                 });
             });
 
-            describe('variant #2: invalid input file path', () => {
-                const expectedError: ReferenceErrorConstructor = ReferenceError;
+            describe('`--output` option isn\'t set', () => {
+                describe('variant #1: default behaviour', () => {
+                    let outputFixturesFilePath: string,
+                        isFileExist: boolean;
 
-                let testFunc: () => void;
+                    before(() => {
+                        outputFixturesFilePath = `${fixturesDirName}/${outputFileName}`;
 
-                before(() => {
-                    testFunc = () => JavaScriptObfuscator.runCLI([
-                        'node',
-                        'javascript-obfuscator',
-                        'wrong/file/path'
-                    ]);
-                });
+                        JavaScriptObfuscator.runCLI([
+                            'node',
+                            'javascript-obfuscator',
+                            fixtureFilePath
+                        ]);
+
+                        isFileExist = fs.existsSync(outputFixturesFilePath);
+                    });
 
-                it(`should throw an error`, () => {
-                    assert.throws(testFunc, expectedError);
+                    it(`should create file \`${outputFileName}\` with obfuscated code in \`${fixturesDirName}\` directory`, () => {
+                        assert.equal(isFileExist, true);
+                    });
+
+                    after(() => {
+                        fs.unlinkSync(outputFixturesFilePath);
+                    });
                 });
-            });
 
-            describe('variant #3: input file extension isn\'t `.js`', () => {
-                const expectedError: ReferenceErrorConstructor = ReferenceError;
-                const outputFileName: string = 'sample-obfuscated.ts';
-                const outputFilePath: string = `${outputDirName}/${outputFileName}`;
+                describe('variant #2: invalid input file path', () => {
+                    const expectedError: ReferenceErrorConstructor = ReferenceError;
 
-                let testFunc: () => void;
+                    let testFunc: () => void;
 
-                before(() => {
-                    fs.writeFileSync(outputFilePath, 'data');
+                    before(() => {
+                        testFunc = () => JavaScriptObfuscator.runCLI([
+                            'node',
+                            'javascript-obfuscator',
+                            'wrong/file/path'
+                        ]);
+                    });
 
-                    testFunc = () => JavaScriptObfuscator.runCLI([
-                        'node',
-                        'javascript-obfuscator',
-                        outputFilePath
-                    ]);
+                    it(`should throw an error`, () => {
+                        assert.throws(testFunc, expectedError);
+                    });
                 });
 
-                it(`should throw an error`, () => {
-                    assert.throws(testFunc, expectedError);
-                });
+                describe('variant #3: input file extension isn\'t `.js`', () => {
+                    const expectedError: ReferenceErrorConstructor = ReferenceError;
+                    const outputFileName: string = 'sample-obfuscated.ts';
+                    const outputFilePath: string = `${outputDirName}/${outputFileName}`;
 
-                after(() => {
-                    fs.unlinkSync(outputFilePath);
+                    let testFunc: () => void;
+
+                    before(() => {
+                        fs.writeFileSync(outputFilePath, 'data');
+
+                        testFunc = () => JavaScriptObfuscator.runCLI([
+                            'node',
+                            'javascript-obfuscator',
+                            outputFilePath
+                        ]);
+                    });
+
+                    it(`should throw an error`, () => {
+                        assert.throws(testFunc, expectedError);
+                    });
+
+                    after(() => {
+                        fs.unlinkSync(outputFilePath);
+                    });
                 });
             });
         });
 
+        describe('Variant #2: obfuscation of directory', () => {
+            const directoryPath: string = `${fixturesDirName}/directory-obfuscation`;
+            const outputFileName1: string = 'foo-obfuscated.js';
+            const outputFileName2: string = 'bar-obfuscated.js';
+            const outputFileName3: string = 'baz-obfuscated.js';
+
+            let outputFixturesFilePath1: string,
+                outputFixturesFilePath2: string,
+                outputFixturesFilePath3: string,
+                isFileExist1: boolean,
+                isFileExist2: boolean,
+                isFileExist3: boolean;
+
+            before(() => {
+                outputFixturesFilePath1 = `${directoryPath}/${outputFileName1}`;
+                outputFixturesFilePath2 = `${directoryPath}/${outputFileName2}`;
+                outputFixturesFilePath3 = `${directoryPath}/${outputFileName3}`;
+
+                JavaScriptObfuscator.runCLI([
+                    'node',
+                    'javascript-obfuscator',
+                    directoryPath
+                ]);
+
+                isFileExist1 = fs.existsSync(outputFixturesFilePath1);
+                isFileExist2 = fs.existsSync(outputFixturesFilePath2);
+                isFileExist3 = fs.existsSync(outputFixturesFilePath3);
+            });
+
+            it(`should create file \`${outputFileName1}\` with obfuscated code in \`${fixturesDirName}\` directory`, () => {
+                assert.equal(isFileExist1, true);
+            });
+
+            it(`should create file \`${outputFileName2}\` with obfuscated code in \`${fixturesDirName}\` directory`, () => {
+                assert.equal(isFileExist2, true);
+            });
+
+            it(`shouldn't create file \`${outputFileName3}\` in \`${fixturesDirName}\` directory`, () => {
+                assert.equal(isFileExist3, false);
+            });
+
+            after(() => {
+                fs.unlinkSync(outputFixturesFilePath1);
+                fs.unlinkSync(outputFixturesFilePath2);
+            });
+        });
+
         describe('`--sourceMap` option is set', () => {
             const outputSourceMapPath: string = `${outputFilePath}.map`;
 

test/unit-tests/cli/utils/SourceCodeReader.spec.ts

@@ -77,9 +77,11 @@ describe('SourceCodeReader', () => {
                 const tmpFileName1: string = 'foo.js';
                 const tmpFileName2: string = 'bar.js';
                 const tmpFileName3: string = 'baz.png';
+                const tmpFileName4: string = 'bark-obfuscated.js';
                 const filePath1: string = `${tmpDir}/${tmpFileName1}`;
                 const filePath2: string = `${tmpDir}/${tmpFileName2}`;
                 const filePath3: string = `${tmpDir}/${tmpFileName3}`;
+                const filePath4: string = `${tmpDir}/${tmpFileName4}`;
 
                 const expectedResult: IFileData[] = [
                     {
@@ -98,6 +100,7 @@ describe('SourceCodeReader', () => {
                     fs.writeFileSync(filePath1, fileContent);
                     fs.writeFileSync(filePath2, fileContent);
                     fs.writeFileSync(filePath3, fileContent);
+                    fs.writeFileSync(filePath4, fileContent);
                     result = SourceCodeReader.readSourceCode(tmpDir);
                 });
 
@@ -109,6 +112,7 @@ describe('SourceCodeReader', () => {
                     fs.unlinkSync(filePath1);
                     fs.unlinkSync(filePath2);
                     fs.unlinkSync(filePath3);
+                    fs.unlinkSync(filePath4);
                 });
             });