binhend 1.2.0 → 1.2.2

package/bin/backend.js

@@ -0,0 +1,3 @@
+module.exports = () => {
+    console.log('Generate back-end structure...');
+};

package/bin/frontend.js

@@ -0,0 +1,3 @@
+module.exports = () => {
+    console.log('Generate front-end structure...');
+};

package/bin/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// console.log('Welcome to the binh!');
+// console.log('process.argv', process.argv);
+
+const argves = process.argv;
+const command = argves[2];
+
+// switch (command) {
+//     case 'backend':
+//         console.log('Generate back-end structure...');
+//         break;
+
+//     case 'frontend':
+//         console.log('Generate front-end structure...');
+//         break;
+
+//     default:
+//         console.log('Unknown command...');
+//         break;
+// }
+
+const map = {
+    backend: require('./backend'),
+    frontend: require('./frontend'),
+}
+
+const handler = map[command];
+
+if (handler) handler();
+else console.log('Unknown command...');
+

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "binhend",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "",
   "main": "index.js",
   "author": "Nguyen Duc Binh",
   "license": "UNLICENSED",
+  "bin": {
+    "binh": "./bin/index.js"
+  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "example-api": "node example_api PORT=5555",

package/src/binh.js

@@ -1,3 +1,4 @@
+const fs = require('fs');
 const path = require('path');
 const Crypto = require('./cryptography');
 
@@ -30,6 +31,15 @@ function Binh() {
         return rootpath;
     };
 
+    this.remove = function(path, callbackError) {
+        try {
+            fs.rmSync(path, { recursive: true, force: true, maxRetries: 3, retryDelay: 1000 });
+        }
+        catch (error) {
+            callbackError(error);
+        }
+    };
+
     function binh(modulePath) {
         return modulePath == undefined ? module.exports : require(path.join(rootpath, modulePath));
     };

package/src/binh.web.builder.js

@@ -101,39 +101,75 @@ function WebBuilder(binh, Binh) {
         this.alias = name;
     }
 
-    Binh.web = function(buildpath, sourcepath) {
-        if (typeof buildpath !== 'string') return this;
-
-        var rootpath = Binh.getRootpath(),
-            destination = path.join(rootpath, buildpath);
+    Binh.web = function(webPath, sourcePath, modulePath) {
+        switch (arguments.length) {
+            case 1:
+                Binh.webStatic(webPath);
+                break;
+
+            case 2:
+                Binh.webApp(sourcePath, webPath);
+                break;
         
-        if (typeof sourcepath === 'string') {
-            var source = path.join(rootpath, sourcepath);
-            Component.generate(source, destination);
+            default:
+                if (arguments.length > 2) {
+                    Binh.webApp(webPath, sourcePath, modulePath);
+                }
+                break;
         }
 
-        Binh.web.value = destination;
+        return Binh;
+    };
 
+    Binh.webStatic = function(webPath) {
+        if (!isString(webPath)) return Binh;
+        Binh.web.value = getAbsolutePaths(webPath).web;
         return Binh;
     };
 
-    Binh.web2 = function(buildpath, sourcepath) {
-        if (typeof buildpath !== 'string') return this;
+    Binh.webApp = function(sourcePath, webPath, modulePath) {
+        if (!isString(sourcePath)) return Binh;
 
-        var rootpath = Binh.getRootpath(),
-            destination = path.join(rootpath, buildpath);
+        modulePath = isString(modulePath) ? modulePath : isString(webPath) ? webPath : null;
+
+        var { source, web, module } = getAbsolutePaths(webPath, sourcePath, modulePath);
+
+        ComponentFormat.generate(source, module, () => ComponentBuild.generate(source, web, module));
+
+        Binh.web.value = web;
+
+        return Binh;
+    };
+
+    Binh.webModule = function(sourcePath, modulePath) {
+        if (!isString(sourcePath)) return Binh;
         
-        if (typeof sourcepath === 'string') {
-            var source = path.join(rootpath, sourcepath);
-            ComponentFormat.generate(source, destination, () => {
-                ComponentBuild.generate(source, destination);
-            });
-        }
+        var { source, module } = getAbsolutePaths(null, sourcePath, modulePath);
 
-        Binh.web.value = destination;
+        ComponentFormat.generate(source, module);
 
         return Binh;
     };
+
+    function getAbsolutePaths(webPath, sourcePath, modulePath) {
+        webPath = isString(webPath) ? webPath : 'web/app';
+        modulePath = isString(modulePath) ? modulePath : 'web/modules';
+
+        var rootpath = Binh.getRootpath(),
+        sourcePathAbsolute = isString(sourcePath) ? path.join(rootpath, sourcePath) : null,
+        webPathAbsolute = path.join(rootpath, webPath),
+        modulePathAbsolute = path.join(rootpath, modulePath);
+
+        return {
+            web: webPathAbsolute,
+            source: sourcePathAbsolute,
+            module: modulePathAbsolute
+        };
+    }
+
+    function isString(input) {
+        return typeof input === 'string';
+    }
 }
 
 module.exports = {

package/src/component.build.js

@@ -1,43 +1,40 @@
 
-const { writeFile } = require('fs');
 const { parse } = require('path');
-const { scanNestedFiles, cloneFile } = require('./component.file');
+const { scanNestedFiles, cloneFile, writeToFile } = require('./component.file');
 const CodeFormat = require('./code');
 const Component = require('./component');
 
 // TODO
 // [-] Able to minify/beautify generated files
 
-function generate(source, destination) {
-    if (source == undefined || destination == undefined) return;
-    console.info('[BINHEND][COMPONENT] Build web components from:', destination);
-    console.info('[BINHEND][COMPONENT] to:', destination);
+function generate(sourceRootPath, outputRootPath, stageRootPath) {
+    if (sourceRootPath == undefined || outputRootPath == undefined) return;
+    stageRootPath = stageRootPath || outputRootPath;
+    console.info('[BINHEND][COMPONENT] Build web components from:', stageRootPath);
+    console.info('[BINHEND][COMPONENT] to:', outputRootPath);
 
-    scanNestedFiles(destination, (file) => {
-        var sourcepath = file.path.replace(destination, source);
-        var outpath = file.path;
+    scanNestedFiles(stageRootPath, (file) => {
+        var fileSourcePath = file.path.replace(stageRootPath, sourceRootPath);
+        var fileOutputPath = file.path.replace(stageRootPath, outputRootPath);
+
+        if (parse(file.name).ext !== '.js') {
+            return cloneFile(fileSourcePath, fileOutputPath);
+        }
 
-        if (parse(file.name).ext !== '.js') return;
-        
         try {
             var component = require(file.path);
         }
         catch (error) {
-            return cloneFile(sourcepath, outpath);
+            return cloneFile(fileSourcePath, fileOutputPath);
         }
 
         if (!(component instanceof Function) || component.constructor !== Component) {
-            return cloneFile(sourcepath, outpath);
+            return cloneFile(fileSourcePath, fileOutputPath);
         }
 
-        var code = joinCodes(component, destination);
+        var code = joinCodes(component, outputRootPath);
 
-        writeFile(outpath, code, { encoding: 'utf8', flag: 'w' }, function(error) {
-            if (error) {
-                showError('Failed writing file', filepath, error);
-                return;
-            }
-        });
+        writeToFile(fileOutputPath, code);
     });
 }
 
@@ -50,11 +47,6 @@ function joinCodes(component, rootPath) {
     return fullcode;
 }
 
-function showError(message, id, error) {
-    console.log(`[BINHEND][COMPONENT] ${message}:`, id);
-    console.log('[BINHEND][COMPONENT] Error details:', error);
-}
-
 module.exports = {
     generate
 };

package/src/component.file.js

@@ -1,5 +1,5 @@
 
-const { readdir, statSync, copyFile } = require('fs');
+const { readdir, statSync, copyFile, writeFile } = require('fs');
 const { join } = require('path');
 
 // TODO
@@ -91,10 +91,25 @@ function cloneFile(filepath, outpath) {
     });
 }
 
+function writeToFile(fileOutputPath, content) {
+    writeFile(fileOutputPath, content, { encoding: 'utf8', flag: 'w' }, function(error) {
+        if (error) {
+            printError('Failed writing file', filepath, error);
+        }
+    });
+}
+
+function printError(message, id, error) {
+    console.error(`[BINHEND][COMPONENT] ${message}:`, id);
+    console.error('[BINHEND][COMPONENT] Error details:', error);
+}
+
 module.exports = {
     scanItems,
     scanNestedItems,
     scanFiles,
     scanNestedFiles,
-    cloneFile
+    cloneFile,
+    writeToFile,
+    printError
 };

package/src/component.format.js

@@ -1,7 +1,7 @@
 
 const { writeFileSync, existsSync, mkdirSync, readFileSync } = require('fs');
 const { dirname, parse } = require('path');
-const { scanNestedFiles, cloneFile } = require('./component.file');
+const { scanNestedFiles, cloneFile, printError } = require('./component.file');
 
 // TODO
 // [-] Enhance code by removing sync logics (except for existsSync, mkdirSync): readdir, readFileSync, (statSync?)
@@ -11,43 +11,39 @@ const PREFIX_CODE =
 binh.component(context, ui, service, style);
 var ui = null, service = null, style = null;\r\n`;
 
-function generate(source, destination, callbackDone) {
-    if (source == undefined || destination == undefined) return;
-    console.log('[BINHEND][COMPONENT] Formatting files from:', source);
-    console.log('[BINHEND][COMPONENT] to:', destination);
+function generate(sourceRootPath, outputRootPath, callbackDone) {
+    if (sourceRootPath == undefined || outputRootPath == undefined) return;
+    console.log('[BINHEND][COMPONENT] Format files from:', sourceRootPath);
+    console.log('[BINHEND][COMPONENT] to:', outputRootPath);
 
-    scanNestedFiles(source, (file, done) => {
+    scanNestedFiles(sourceRootPath, (file, done) => {
         if (done) return callbackDone instanceof Function ? callbackDone() : null;
 
-        var outpath = file.path.replace(source, destination);
+        var fileSourcePath = file.path;
+        var fileOutputPath = fileSourcePath.replace(sourceRootPath, outputRootPath);
 
-        ensureDirectoryExistence(outpath);
+        ensureDirectoryExistence(fileOutputPath);
 
         if (parse(file.name).ext !== '.js') {
-            return cloneFile(file.path, outpath);
+            return cloneFile(fileSourcePath, fileOutputPath);
         }
         
         try {
-            var content = readFileSync(file.path, { encoding: 'utf8', flag: 'r' });
-            var output = PREFIX_CODE + content + '\r\n;binh.final(module);';
-            writeFileSync(outpath, output, { encoding: 'utf8', flag: 'w' });
+            var content = readFileSync(fileSourcePath, { encoding: 'utf8', flag: 'r' });
+            var code = PREFIX_CODE + content + '\r\n;binh.final(module);';
+            writeFileSync(fileOutputPath, code, { encoding: 'utf8', flag: 'w' });
         }
         catch (error) {
-            showError('Failed building file:', file.path, error);
+            printError('Failed formatting file:', fileSourcePath, error);
         }
     });
 }
 
-function ensureDirectoryExistence(filepath) {
-    var dirpath = dirname(filepath);
-    if (existsSync(dirpath)) return true;
-    ensureDirectoryExistence(dirpath);
-    mkdirSync(dirpath);
-}
-
-function showError(message, id, error) {
-    console.log(`[BINHEND][COMPONENT] ${message}:`, id);
-    console.log('[BINHEND][COMPONENT] Error details:', error);
+function ensureDirectoryExistence(filePath) {
+    var dirPath = dirname(filePath);
+    if (existsSync(dirPath)) return true;
+    ensureDirectoryExistence(dirPath);
+    mkdirSync(dirPath);
 }
 
 module.exports = {