@fishawack/lab-env 1.6.3

package/commands/artisan.js

@@ -0,0 +1,15 @@
+const _ = require('../globals.js');
+
+const execSync = require('child_process').execSync;
+
+module.exports = [
+    ['artisan [command...]', 'art'],
+    'run artisan command',
+    yargs => {
+        yargs.positional('command', {
+                describe: 'command to run',
+                default: ''
+            });
+    },
+    argv => execSync(`${_.docker} ${_.method} php bash -lc "php artisan ${argv.command.join(' ')}"`, _.opts)
+];

package/commands/check.js

@@ -0,0 +1,16 @@
+const _ = require('../globals.js');
+
+const execSync = require('child_process').execSync;
+
+module.exports = [
+    'check',
+    'check if node modules are missing or outdated',
+    yargs => {
+        yargs.option('verbose', {
+                alias: 'v',
+                describe: 'Show breakdown of packages',
+                type: 'boolean'
+            });
+    },
+    argv => execSync(`${_.docker} ${_.run}c "check-dependencies ${argv.v ? '' : '&>/dev/null'} && echo -e '\\033[0;32mDeps OK\\033[0m' || { echo -e '\\033[0;31mDeps missing or outdated\\033[0m'; }"`, _.opts)
+];

package/commands/clean.js

@@ -0,0 +1,16 @@
+const _ = require('../globals.js');
+
+const execSync = require('child_process').execSync;
+
+module.exports = [
+    'clean',
+    'cleans out dependencies',
+    yargs => {},
+    argv => {
+        execSync(`${_.docker} ${_.run}c "git clean -xfd node_modules/ 2>/dev/null || true"`, _.opts);
+
+        if(_.platform === "laravel"){
+            execSync(`${_.docker} ${_.method} php bash -lc "git clean -xfd vendor/ 2>/dev/null || true"`, _.opts);
+        }
+    }
+];

package/commands/composer.js

@@ -0,0 +1,15 @@
+const _ = require('../globals.js');
+
+const execSync = require('child_process').execSync;
+
+module.exports = [
+    'composer [command...]',
+    'run composer command',
+    yargs => {
+        yargs.positional('command', {
+                describe: 'command to run',
+                default: ''
+            });
+    },
+    argv => execSync(`${_.docker} ${_.method} php bash -lc "composer ${argv.command.join(' ')}"`, _.opts)
+];

package/commands/connect.js

@@ -0,0 +1,15 @@
+const _ = require('../globals.js');
+
+const execSync = require('child_process').execSync;
+
+module.exports = [
+    'connect [container]',
+    'jump into container',
+    yargs => {
+        yargs.positional('container', {
+                describe: 'container to connect to',
+                default: 'core'
+            });
+    },
+    argv => execSync(`${_.docker} ${_.method} ${argv.container} bash -l`, _.opts)
+];

package/commands/content.js

@@ -0,0 +1,10 @@
+const _ = require('../globals.js');
+
+const execSync = require('child_process').execSync;
+
+module.exports = [
+    'content', 
+    'pulls any external content and assets into the repo', 
+    yargs => {}, 
+    argv => execSync(`${_.docker} ${_.run}c "npm run content"`, _.opts)
+];

package/commands/create/cmds/delete.js

@@ -0,0 +1,27 @@
+const bitbucket = require('../services/bitbucket');
+const utils = require('../libs/utilities');
+
+module.exports = [
+    'delete <name>',
+    'Deletes a repository',
+    yargs => {
+        yargs.positional('name', {
+                describe: 'name of repo'
+            });
+
+        yargs.option('confirm', {
+                alias: 'y',
+                describe: 'Confirm you want to run this command',
+                type: 'boolean'
+            });
+    },
+    async argv => {
+        if(argv.y){
+            if(await bitbucket.exists(argv.name)){
+                await bitbucket.remove(argv.name);
+            }
+        } else {
+            console.log(utils.colorize('-y flag must be passed to confirm (this process cannot be undone)', 'info'));
+        }
+    }
+];

package/commands/create/cmds/diagnose.js

@@ -0,0 +1,77 @@
+const vars = require('../libs/vars');
+const bitbucket = require('../services/bitbucket');
+const egnyte = require("../services/egnyte");
+const gitlab = require("../services/gitlab");
+const guide = require("../services/guide");
+const test = require("../services/test");
+
+module.exports = [
+    ['diagnose', 'diag'],
+    'Check if environment is setup correctly',
+    yargs => {},
+    async argv => {
+        try{
+            let preset = await guide.preset();
+    
+            while(!await test.ssh()){
+                await guide.ssh();
+            };
+    
+            while(!await test.key()){
+                await guide.key();
+            }
+            
+            while(!await test.config()){
+                await guide.config();
+            };
+    
+            while(!await test.ignore()){
+                await guide.ignore();
+            };
+    
+            while(!await test.strict()){
+                await guide.strict();
+            };
+    
+            while(!await test.targets()){
+                await guide.targets();
+            }
+    
+            while(!await test.ftppass()){
+                await guide.ftppass();
+            }
+    
+            while(!await test.egnyte() || !await egnyte.check()){
+                await guide.egnyte();
+            };
+    
+            if(preset === "permanent"){
+                while(!await test.misc()){
+                    await guide.misc();
+                };
+    
+                while(!await test.bitbucket() || !await bitbucket.check()){
+                    await guide.bitbucket();
+                }
+    
+                while(!await test.gitlab() || !await gitlab.check()){
+                    await guide.gitlab();
+                }
+    
+                const userRepoName = vars.misc.bitbucket.username.split('@')[0].replace(/\./, '-');
+    
+                // Check ability to create and delete Bitbucket repos
+                if(!await bitbucket.exists(userRepoName)){
+                    await bitbucket.fork(userRepoName, {name: 'boilerplate'});
+                }
+    
+                await bitbucket.remove(userRepoName);
+            }
+        } catch(e){
+            if(e.message){
+                console.log(`\nError: ${e.message}`);
+                process.exit(1);
+            }
+        }
+    }
+];

package/commands/create/cmds/new.js

@@ -0,0 +1,48 @@
+const prompts = require('../libs/prompts');
+const utilities = require('../libs/utilities');
+const vars = require('../libs/vars');
+const bitbucket = require('../services/bitbucket');
+const execSync = require('child_process').execSync;
+
+module.exports = [
+    'new [name]',
+    'Creates a new repository',
+    yargs => {
+        yargs.positional('name', {
+                describe: 'name of repo'
+            });
+
+        yargs.option('template', {
+                alias: 't',
+                describe: 'Template to fork from',
+                type: 'string'
+            });
+    },
+    async argv => {
+        const answers = await prompts.generatePrompts(argv);
+
+        let template = vars.templates.find(d => d.name === answers.template);
+
+        if(!template){
+            console.log(utilities.colorize(`Template ${answers.template} not a valid template type`, 'error'));
+            return;
+        }
+
+        let name = `${template.prefix ? `${template.prefix}-` : ''}${answers.name}`;
+        
+        if(/^[a-zA-Z0-9-_.]+$/.test(name)){
+            // Create Remote Repositories
+            if(!await bitbucket.exists(name)){
+                if(await bitbucket.exists(template.name)){
+                    await bitbucket.fork(name, template);
+
+                    execSync(`echo "git clone ${vars.urls.bitbucketSSH}/${name}" | pbcopy`);
+                
+                    console.log(utilities.colorize(`git clone ${vars.urls.bitbucketSSH}/${name} (copied to clipboard)`, 'title'));
+                }
+            }
+        } else {
+            console.log(utilities.colorize(`Repo name can contain only letters, digits, '_', '-' and '.'`, 'helper'));
+        }
+    }
+];

package/commands/create/libs/prompts.js

@@ -0,0 +1,60 @@
+const inquirer = require('inquirer');
+
+const { templates } = require('./vars');
+
+const addPrompt = module.exports.addPrompt = (type, prompts, flags) => {
+    switch(type) {
+        case 'templateType':
+            return prompts.push({
+                type: 'list',
+                name: 'templateType',
+                message: 'Which template type do you need?',
+                choices: templates.reduce((a, b) => {
+                    if(a.indexOf(b.type) === -1){
+                        a.push(b.type);
+                    }
+                    return a;
+                }, []),
+                default: 'boilerplate'
+            });
+        case 'template':
+            return prompts.push({
+                type: 'list',
+                name: 'template',
+                message: 'What template do you need?',
+                choices: answers => templates.filter(d => d.type === answers.templateType),
+                default: 'boilerplate'
+            });
+        case 'name':
+            return prompts.push({
+                type: 'input',
+                name: 'name',
+                message: answers => {
+                    let template = templates.find(d => d.name === (answers.template || flags.template)) || {};
+
+                    return `What will the name of your new repo be?${template.prefix ? `\n (e.g. 'widaloo' becomes '${template.prefix}-widaloo')\n` : ''}`;
+                },
+                validate: input => input.length > 0
+            });
+        default:
+            return false;
+    }
+};
+
+module.exports.generatePrompts = async flags => {
+    const prompts = [];
+
+    // Push prompts to prompt array
+    flags.template || addPrompt('templateType', prompts, flags);
+    flags.template || addPrompt('template', prompts, flags);
+    flags.name || addPrompt('name', prompts, flags);
+
+    // Invoke prompts and retrieve answers
+    const answers = await inquirer.prompt(prompts);
+
+    // Return answer values, otherwise use default flag values
+    return {
+        ...flags,
+        ...answers
+    };
+};

package/commands/create/libs/utilities.js

@@ -0,0 +1,50 @@
+const chalk = require('chalk');
+const ora = require('ora');
+
+// Text
+module.exports.capitalize = str => str.charAt(0).toUpperCase() + str.slice(1);
+
+const colorize = module.exports.colorize = (str, type) => {
+    switch (type) {
+        case 'success':
+            return chalk.green(str);
+        case 'error':
+            return chalk.red(str);
+        case 'title':
+            return chalk.hex('#edb879').bold(str);
+        case 'helper':
+            return chalk.hex('#41B883').bold(str);
+        case 'info':
+            return chalk.hex('#61dafb').bold(str);
+        case 'divider':
+            return chalk.yellow.bold(str);
+        default:
+            return str;
+    }
+};
+
+module.exports.Spinner = class Spinner {
+    constructor(startMessage) {
+        this.ora = ora(colorize(startMessage, 'info')).start();
+    }
+
+    update(message, status) {
+        if (status === 'fail') {
+            this.ora.fail(colorize(message, 'error'));
+        } else if (status === 'info') {
+            this.ora.info(colorize(message, 'info'));
+        } else {
+            this.ora.succeed(colorize(message, status || 'success'));
+        }
+    }
+};
+
+module.exports.encode = (username, password) => {
+    const userPassBuffer = Buffer.from(`${username}:${password}`);
+    const base64data = userPassBuffer.toString('base64');
+
+    return {
+        "Content-Type": "application/json",
+        "Authorization": `Basic ${base64data}`
+    };
+}

package/commands/create/libs/vars.js

@@ -0,0 +1,95 @@
+const os = require('os');
+const path = require("path");
+const { encode } = require('./utilities');
+const fs = require("fs");
+
+var miscFile;
+
+try{
+    miscFile = JSON.parse(fs.readFileSync(path.join(os.homedir(), 'targets', 'misc.json')));
+} catch(e){
+    miscFile = {
+        bitbucket: {},
+        gitlab: {}
+    };
+}
+
+// Misc
+const misc = module.exports.misc = miscFile;
+
+var ftppassFile;
+
+try{
+    ftppassFile = JSON.parse(fs.readFileSync(path.join(os.homedir(), 'targets', '.ftppass'), { encoding: 'utf8' }));
+} catch(e){
+    ftppassFile = {};
+}
+
+// ftppass
+module.exports.ftppass = ftppassFile;
+
+// APIs
+const bitbucketApi = module.exports.bitbucketApi = 'https://api.bitbucket.org/2.0/repositories';
+
+module.exports.apis = {
+    bbWorkspaceAPI: `${bitbucketApi}/${misc.bitbucket.workspace}`
+};
+
+// URLs
+module.exports.urls = {
+    bitbucketSSH: `git@bitbucket.org:${misc.bitbucket.workspace}`
+};
+
+// Request Headers
+module.exports.headers = {
+    bbHeaders: encode(misc.bitbucket.username, misc.bitbucket.password)
+};
+
+module.exports.templates = [
+    {
+        "name": "boilerplate",
+        "type": "boilerplate"
+    },
+    {
+        "name": "boilerplate-vue",
+        "type": "boilerplate"
+    },
+    {
+        "name": "boilerplate-wordpress",
+        "type": "boilerplate"
+    },
+    {
+        "name": "boilerplate-laravel",
+        "type": "boilerplate"
+    },
+    {
+        "name": "sprinkle-base",
+        "type": "framework",
+        "project": "SPRINK",
+        "prefix": "banners"
+    },
+    {
+        "name": "stream",
+        "type": "framework",
+        "project": "STREAM",
+        "prefix": "stream"
+    },
+    {
+        "name": "torpedo",
+        "type": "framework",
+        "project": "TOR",
+        "prefix": "torpedo"
+    },
+    {
+        "name": "wave",
+        "type": "product",
+        "project": "WAVE",
+        "prefix": "wave"
+    },
+    {
+        "name": "plant",
+        "type": "product",
+        "project": "PLAN",
+        "prefix": "plant"
+    }
+];