ft(folder structure): create and automate folder and directory structure

[Delivers #7]

lib/Inquire.js

@@ -14,10 +14,12 @@ class Inquire {
     this.questions = [];
     this.validate = {
       notEmpty(value) {
-        return (value && value.length && value.length > 0) ? true : 'Please enter a value';
+        return (value && value.length && value.length > 0) ?
+          true : 'Please enter a value';
       },
       yesNo(value) {
-        return (value && ['y', 'n', 'yes', 'no'].indexOf(value.toLowerCase()) !== -1) ?
+        return (value &&
+          ['y', 'n', 'yes', 'no'].indexOf(value.toLowerCase()) !== -1) ?
           true : 'Invalid input to yes/no question';
       }
     };
@@ -45,7 +47,8 @@ class Inquire {
 
   /**
    * Combine and ask all the questions in the questions property
-   * @param {Function} callback - function to run after user is done with questions
+   * @param {Function} callback - function to run after user is done
+   * with questions
    * @returns {Void} - returns nothing
    * @memberOf Inquire
    */

lib/ReactRaise.js

@@ -1,5 +1,7 @@
 const Inquire = require('./Inquire');
 const Generate = require('./Generate');
+const Structure = require('./Structure');
+
 /**
  * ReactRaise class
  * @class ReactRaise
@@ -43,19 +45,27 @@ class ReactRaise {
 
   /**
    * initialize command and ask setup questions
-   * @param {Function} callback - function to execute after answers has been given
+   * @param {Function} callback - function to execute after answers
+   * has been given
    * @returns {Void} returns nothing
    * @memberOf ReactRaise
    */
   init(callback) {
-    const g = new Generate();
+    const configGenerate = new Generate();
+    const fileStructure = new Structure();
     const startInquire = new Inquire();
-    startInquire.question('description', 'input', 'Can you describe your app[optional]');
+    startInquire.question(
+      'description',
+      'input',
+      'Can you describe your app[optional]');
     startInquire.question(
       'main',
       'input',
       'What is the main entry file of your app[Default: index.js]');
-    startInquire.question('author', 'input', 'What is your name[optional]');
+    startInquire.question(
+      'author',
+      'input',
+      'What is your name[optional]');
     startInquire.question(
       'license',
       'input',
@@ -73,7 +83,8 @@ class ReactRaise {
       if (callback) {
         callback();
       }
-      g.all(answers);
+      configGenerate.all(answers);
+      fileStructure.build();
     });
   }
 }

lib/Structure.js

@@ -0,0 +1,71 @@
+const mkdirp = require('mkdirp');
+const path = require('path');
+const fs = require('fs');
+const structureSchema = require('../sample/folder-schema');
+const baseDir = require('./baseDir');
+
+/**
+ * Define and build the application folder structure
+ * @class Structure
+ */
+class Structure {
+
+  /**
+   * Creates an instance of Structure.
+   * @param {string} extend - path to add to current working drectory
+   * @param {any} schema - folder structure schema
+   * @memberOf Structure
+   */
+  constructor(extend = '', schema) {
+    this.schema = schema || structureSchema;
+    this.filepath = `${baseDir.getCurrentWorkingDir()}/${extend}`;
+  }
+
+  /**
+   * Move through the folder schema and create folders and files
+   * @param {Array} dir - current directory to iterate through
+   * @param {Array} pathname - contains each individual parent
+   * folders name
+   * @returns {Void} returns nothing
+   * @memberOf Structure
+   */
+  traverse(dir, pathname) {
+    if (!pathname) {
+      pathname = [];
+    }
+    dir.forEach((root, index, parent) => {
+      if (typeof root === 'object') {
+        pathname.push(Object.keys(root)[0]);
+        mkdirp.sync(
+          path.join(this.filepath, `/example/${pathname.join('/')}`));
+        this.traverse(root[Object.keys(root)[0]], pathname);
+      } else {
+        fs.writeFile(
+          path.join(
+            this.filepath,
+            `/example/${pathname.join('/')}/${root}`),
+          '');
+        if (index === parent.length - 1) {
+          pathname.pop();
+        }
+      }
+    });
+  }
+
+  /**
+   * Build the folder structure based off the provided schema
+   * @returns {Promise} resolves promise when directories have been created
+   * @memberOf Structure
+   */
+  build() {
+    return new Promise((resolve) => {
+      this.traverse(this.schema);
+      if (baseDir.directoryExists(
+        path.join(this.filepath, '/example/test/helper.js'))) {
+        resolve(this.schema);
+      }
+    });
+  }
+}
+
+module.exports = Structure;

lib/baseDir.js

@@ -10,9 +10,15 @@ module.exports = {
     return process.cwd();
   },
 
+  /**
+   * check if a file or directory exists
+   * @param {String} filePath - file path to check
+   * @returns {Boolean} if exists return true else return false
+   */
   directoryExists(filePath) {
     try {
-      return fs.statSync(filePath).isDirectory() || fs.statSync(filePath).isFile();
+      return fs.statSync(filePath).isDirectory()
+        || fs.statSync(filePath).isFile();
     } catch (err) {
       return false;
     }

sample/folder-schema.js

@@ -24,5 +24,14 @@ module.exports = [
       { images: ['images.txt'] },
       'index.html'
     ]
+  },
+  {
+    test: [
+      { actions: ['actionTypes.spec.js'] },
+      { reducers: ['root.reducer.spec.js'] },
+      { components: ['Home.component.spec.js'] },
+      { e2e: ['e2e.txt'] },
+      'helper.js'
+    ]
   }
 ];

test/lib/Generate.spec.js

@@ -192,4 +192,4 @@ describe('Generate', () => {
       });
     });
 
-});
+});

test/lib/Structure.spec.js

@@ -0,0 +1,60 @@
+const mkdirp = require('mkdirp');
+const path = require('path');
+const fs = require('fs');
+const exec = require('child_process').exec;
+
+const Structure = require('../../lib/Structure');
+const baseDir = require('../../lib/baseDir');
+const scheme = require('../../sample/folder-schema');
+
+describe('Structure', () => {
+    let structure;
+    const folderScheme = [
+      { new: ['text.txt'] },
+      { old: [{ red: ['red.txt'] }] }
+    ];
+
+    beforeEach((done) => {
+      structure = new Structure('test/lib');
+      mkdirp.sync(path.join(__dirname, `example`));
+      done();
+    });
+
+    afterEach((done) => {
+      const filepath = path.join(__dirname, 'example');
+      exec('rm -r ' + filepath, (err, stdout, stderr) => {
+        return done(err);
+      });
+    });
+
+    it('Should create an instance of Structure class', () => {
+      structure = new Structure();
+      expect(structure).to.be.instanceOf(Structure);
+    });
+
+    describe('traverse', () => {
+      it('should traverse a folder schema and create directories and files', (done) => {
+        structure.traverse(folderScheme);
+        setTimeout(() => {
+          expect(baseDir.directoryExists(
+            path.join(__dirname, '/example/new/text.txt'))).to.eql(true);
+          expect(baseDir.directoryExists(
+            path.join(__dirname, '/example/old/red/red.txt'))).to.eql(true);
+          done();
+        }, 900);
+      });
+    });
+
+    describe('build', () => {
+      it('should build the file directory from the supplied schema', (done) => {
+        structure.build(scheme);
+        setTimeout(() => {
+          expect(baseDir.directoryExists(
+            path.join(__dirname, '/example/test/helper.js'))).to.eql(true);
+          expect(baseDir.directoryExists(
+            path.join(__dirname, '/example/src/store.js'))).to.eql(true);
+          done();
+        }, 900);
+      });
+    });
+});