feature #525 Allow setOutputPath to create nested directories (Lyrkan)

This PR was merged into the master branch.

Discussion
----------

Allow setOutputPath to create nested directories

This PR changes the check that is currently made when calling `setOutputPath` in order to allow the creation of nested directories (closes #189).

Note that it doesn't remove it entirely since it still prevents the creation of more than one level when the output path is located outside of the context path.

For instance, given the context is `/home/foo/bar/`:

```js
// Will work
Encore.setOutputPath('build');

// Will work, even if "/home/foo/bar/public" does not exist
Encore.setOutputPath('public/build/output');

// Will work, even if "/home/foo/public" does not exist
Encore.setOutputPath('../public');

// Will work if only "/home/foo/public/build" does not exist
// ... but **won't** work if "/home/foo/public" does not exist
Encore.setOutputPath('../public/build');
```

Commits
-------

ff200af Allow setOutputPath to create nested directories

Author: weaverryan

lib/WebpackConfig.js

@@ -130,11 +130,23 @@ class WebpackConfig {
         }
 
         if (!fs.existsSync(outputPath)) {
-            // for safety, we won't recursively create directories
-            // this might be a sign that the user has specified
-            // an incorrect path
-            if (!fs.existsSync(path.dirname(outputPath))) {
-                throw new Error(`outputPath directory does not exist: ${outputPath}. Please check the path you're passing to setOutputPath() or create this directory`);
+            // If the parent of the output directory does not exist either
+            // check if it is located under the context directory before
+            // creating it and its parent.
+            const parentPath = path.dirname(outputPath);
+            if (!fs.existsSync(parentPath)) {
+                const context = path.resolve(this.getContext());
+                if (outputPath.indexOf(context) !== 0) {
+                    throw new Error(`outputPath directory "${outputPath}" does not exist and is not located under the context directory "${context}". Please check the path you're passing to setOutputPath() or create this directory.`);
+                }
+
+                parentPath.split(path.sep).reduce((previousPath, directory) => {
+                    const newPath = path.resolve(previousPath, directory);
+                    if (!fs.existsSync(newPath)) {
+                        fs.mkdirSync(newPath);
+                    }
+                    return newPath;
+                }, path.sep);
             }
 
             fs.mkdirSync(outputPath);

test/WebpackConfig.js

@@ -28,6 +28,32 @@ function createConfig() {
 describe('WebpackConfig object', () => {
 
     describe('setOutputPath', () => {
+        const removeDirectory = (targetPath) => {
+            if (fs.existsSync(targetPath)) {
+                const files = fs.readdirSync(targetPath);
+                for (const file of files) {
+                    const filePath = path.resolve(targetPath, file);
+                    if (fs.lstatSync(filePath).isDirectory()) {
+                        removeDirectory(filePath);
+                    } else {
+                        fs.unlinkSync(filePath);
+                    }
+                }
+
+                fs.rmdirSync(targetPath);
+            }
+        };
+
+        // Make sure the newly created directories are removed
+        // before and after each test
+        const cleanupNewDirectories = () => {
+            removeDirectory(path.resolve(__dirname, 'new_dir'));
+            removeDirectory(path.resolve(__dirname, '..', 'new_dir'));
+        };
+
+        beforeEach(cleanupNewDirectories);
+        afterEach(cleanupNewDirectories);
+
         it('use absolute, existent path', () => {
             const config = createConfig();
             config.setOutputPath(__dirname);
@@ -37,15 +63,12 @@ describe('WebpackConfig object', () => {
 
         it('relative path, becomes absolute', () => {
             const config = createConfig();
-            config.setOutputPath('assets');
+            config.setOutputPath('new_dir');
 
             // __dirname is the context
             expect(config.outputPath).to.equal(
-                path.join(__dirname, '/assets')
+                path.join(__dirname, '/new_dir')
             );
-
-            // cleanup!
-            fs.rmdirSync(path.join(__dirname, '/assets'));
         });
 
         it('non-existent path creates directory', () => {
@@ -56,23 +79,39 @@ describe('WebpackConfig object', () => {
 
             const config = createConfig();
             config.setOutputPath(targetPath);
+            expect(fs.existsSync(config.outputPath)).to.be.true;
+        });
 
+        it('non-existent directory, 3 levels deep is created correctly', () => {
+            var targetPath = path.join(__dirname, 'new_dir', 'subdir1', 'subdir2');
+            if (fs.existsSync(targetPath)) {
+                fs.rmdirSync(targetPath);
+            }
+
+            const config = createConfig();
+            config.setOutputPath(targetPath);
             expect(fs.existsSync(config.outputPath)).to.be.true;
+        });
+
+        it('non-existent path outside of the context directory works if only one directory has to be created', () => {
+            var targetPath = path.join(__dirname, '..', 'new_dir');
+            if (fs.existsSync(targetPath)) {
+                fs.rmdirSync(targetPath);
+            }
 
-            // cleanup!
-            fs.rmdirSync(targetPath);
+            const config = createConfig();
+            config.setOutputPath(targetPath);
+            expect(fs.existsSync(config.outputPath)).to.be.true;
         });
 
-        it('non-existent directory, 2 levels deep throws error', () => {
-            var targetPath = path.join(__dirname, 'new_dir', 'subdir');
+        it('non-existent path outside of the context directory throws an error if more than one directory has to be created', () => {
+            var targetPath = path.join(__dirname, '..', 'new_dir', 'subdir');
             if (fs.existsSync(targetPath)) {
                 fs.rmdirSync(targetPath);
             }
 
             const config = createConfig();
-            expect(() => {
-                config.setOutputPath(targetPath);
-            }).to.throw('create this directory');
+            expect(() => config.setOutputPath(targetPath)).to.throw('create this directory');
         });
     });