rigjs 1.0.33 → 2.0.0-alpha.0

package/lib/build/index.ts

@@ -0,0 +1,17 @@
+import fsHelper from '../utils/fsHelper';
+import CICD from '@/classes/cicd/CICD';
+import CICDCmd from '@/classes/cicd/CICDCmd';
+import shell from 'shelljs';
+
+export default async (cmd: any) => {
+	//create cicd object
+	const cicd = CICD.createByDefault(cmd);
+	//construct cmd object
+	const cicdCmd = new CICDCmd(cmd, cicd);
+	//build by cicdCmd and cicdConfig
+	console.log(cicdCmd.endpoints);
+	for (let i = 0; i < cicdCmd.endpoints.length; i++) {
+		const ep = cicdCmd.endpoints[i];
+		shell.exec(ep.build);
+	}
+}

package/lib/check/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace check {
+	const name: string;
+
+	function load(): void;
+}
+export default check;

package/lib/check/index.js

@@ -4,7 +4,6 @@
  * @author Wang Bo (ralwayne@163.com)
  * @date 2020/10/14 6:59 PM
  */
-const shell = require('shelljs');
 const fs = require('fs');
 const json5 = require('json5');
 const print = require('../print');

package/lib/classes/cicd/CICD.ts

@@ -0,0 +1,110 @@
+import DirLevel from '@/classes/cicd/DirLevel';
+import Endpoint, { EndpointDict} from '@/classes/cicd/Endpoint';
+import fs from 'fs';
+import {Dir} from 'fs';
+import fsHelper from '@/utils/fsHelper';
+import CICDCmd from '@/classes/cicd/CICDCmd';
+
+const JSON5 = require('json5');
+import qs from 'querystring';
+export enum CloudType {
+	alicloud = 'alicloud',
+}
+
+/**
+ * Bundle source
+ */
+interface DeploySource {
+	root_path: string
+}
+
+/**
+ * Deploy target
+ */
+interface DeployTarget {
+	id: string;
+	type: CloudType;
+	bucket: string;
+	access_key: string;
+	access_secret: string;
+	root_path: '/';
+}
+
+/**
+ * @interface DirGroup
+ * Only dynamic Dirlevel can use DirGroup
+ */
+export interface DirGroup {
+	name: string,
+	/**
+	 * Name in DirLevel,
+	 */
+	level: string,
+	includes: string[],
+}
+export interface Define{
+	[replace: string]: String;
+}
+export interface DefineDict{
+	[group: string]: Define;
+}
+
+/**
+ * Whole CI/CD config
+ */
+export interface CICDConfig {
+	tree_schema: string;
+	source: DeploySource;
+	target: DeployTarget | DeployTarget[];
+	endpoints: EndpointDict;
+	groups: DirGroup[];
+}
+
+
+class CICD {
+	/**
+	 * schema of the directory tree
+	 * @type {string}
+	 */
+	treeSchema: string;
+	/**
+	 * DirLevel shows every level of the directory structure
+	 * @type {DirLevel[]}
+	 */
+	schema: DirLevel[];
+	/**
+	 * endpoints contains build info and deploy info.
+	 * @type {Endpoint[]}
+	 */
+	endpoints: Endpoint[];
+	source: DeploySource;
+	target: DeployTarget | DeployTarget[];
+	groups: DirGroup[];
+
+	constructor(config: CICDConfig) {
+		this.treeSchema = config.tree_schema;
+		this.schema = DirLevel.createSchema(this.treeSchema);
+		this.endpoints = Endpoint.createEndpointArr(config,this.schema);
+		this.source = config.source;
+		this.target = config.target;
+		this.groups = config.groups;
+	}
+	static createByDefault(cmd:any){
+		//replace params
+		let cicdStr = fs.readFileSync(`${process.cwd()}/cicd.rig.json5`).toString();
+		const paramsStr = cmd.params;
+		const params = qs.parse(paramsStr);
+		Object.keys(params).forEach(key => {
+			const regStr = `\\$\\{${key}\\}`;
+			const regex = new RegExp(regStr, 'g');
+			cicdStr = cicdStr.replace(regex, params[key] as string);
+		});
+		return new CICD(JSON5.parse(cicdStr));
+	}
+
+	matchEndpoints(cmdDirStrArr: string[]) {
+
+	}
+}
+
+export default CICD;

package/lib/classes/cicd/CICDCmd.ts

@@ -0,0 +1,65 @@
+import Endpoint from '@/classes/cicd/Endpoint';
+import CICD, {CICDConfig} from '@/classes/cicd/CICD';
+import qs, {ParsedUrlQuery} from 'querystring';
+import path from 'path'
+import fsHelper from '@/utils/fsHelper';
+
+/**
+ * @class CICDCmd
+ * @property dir string Original specific dir in cmd.
+ * @property dirArr array Splitted dir.
+ * @property endpoints array Tageted endpoints used to build,define or deploy
+ */
+class CICDCmd {
+	/**
+	 * @property dir string Whole directory
+	 * @type {string}
+	 */
+	dir: string;
+	/**
+	 *
+	 * @type {string[]}
+	 */
+	dirInSchemaStrArr: string[];
+	dirStrArr: string[];
+	endpoints: Endpoint[] = [];
+	cicd: CICD;
+
+	constructor(cmd: any, cicd: CICD) {
+		const cmdArgs = cmd.args;
+		this.dir = cmdArgs[0];
+		//获取需要被设置的schema变量
+		const schemaKeys = this.dir.match(/(?<=\{)[a-zA-Z]+(?=\})/g) || [];
+		//解析schema变量
+		let schema: ParsedUrlQuery = qs.parse(cmd.schema);
+		for (let key of schemaKeys) {
+			const val = schema[key];
+			if (val) {
+				this.dir = this.dir.replace(`{${key}}`, val as string);
+			} else {
+				throw new Error(`${key} is not set`);
+			}
+		}
+		//whole user's target dir
+		this.dirStrArr = this.dir.split('/').filter((dirStr, index) => dirStr.length > 0);
+		//dir within the schema
+		this.dirInSchemaStrArr = this.dir.split('/').filter((dirStr, index) => dirStr.length > 0 && index < cicd.schema.length);
+		this.cicd = cicd;
+		this.createTargetEndpoints();
+	}
+
+	private createTargetEndpoints() {
+		const allEndpints = this.cicd.endpoints;
+		this.endpoints = allEndpints.filter(endpoint => endpoint.matchCmd(this.dirInSchemaStrArr, this.cicd.groups));
+		if (this.dirStrArr.length > this.dirInSchemaStrArr.length) {
+			const sufDir = this.dirStrArr.slice(this.dirInSchemaStrArr.length, this.dirStrArr.length).join('/');
+			this.endpoints = this.endpoints.map(ep => {
+				ep.deployDir = path.join(ep.deployDir, sufDir);
+				return ep;
+			});
+		}
+
+	}
+}
+
+export default CICDCmd;

package/lib/classes/cicd/DirLevel.ts

@@ -0,0 +1,49 @@
+import regex from '../../utils/regex';
+
+/**
+ * contain attributes of every level in the directory schema
+ */
+class DirLevel {
+	/**
+	 * Means that is this level's name can be set dynamically.
+	 * @type {boolean}
+	 */
+	dynamic: boolean;
+	/**
+	 * The meaning of this level.Can be changed when [this.dynamic] is true.
+	 * % matches all dir name.
+	 * @type {string}
+	 */
+	name: string | '%';
+	/**
+	 * The level in the directory schema
+	 * @type {number}
+	 */
+	level: number;
+
+	constructor(dirName: string, level: number) {
+		this.dynamic = regex.dynamicDir.test(dirName);
+		this.name = dirName;
+		this.level = level;
+	}
+
+	static createSchema(treeSchema: string) {
+		let dirStrArr = treeSchema.split('/');
+		dirStrArr = dirStrArr.filter(dirStr => dirStr.length > 0);
+		return dirStrArr.map((dirStr, index) => {
+			return new DirLevel(dirStr, index);
+		});
+	}
+
+	static createDirArr(dir: string, schema: DirLevel[]) {
+		let dirStrArr = dir.split('/');
+		dirStrArr = dirStrArr.filter(dirStr => dirStr.length > 0);
+		return dirStrArr.map((dirStr, index) => {
+			const level = new DirLevel(dirStr, index);
+			level.dynamic = schema[index].dynamic;
+			return level;
+		});
+	}
+}
+
+export default DirLevel;

package/lib/classes/cicd/Endpoint.ts

@@ -0,0 +1,87 @@
+import {CICDConfig, DefineDict, DirGroup} from './CICD';
+import {mkdirSync} from 'fs';
+import DirLevel from '@/classes/cicd/DirLevel';
+
+interface EndpointInfo {
+	build: string;
+	target: string;
+	domain: string;
+	define: DefineDict;
+}
+
+export interface EndpointDict {
+	[dir: string]: EndpointInfo;
+}
+
+class Endpoint {
+	dir: string;
+	dirStrArr: string[];
+	dirArr: DirLevel[];
+	target: string;
+	build: string;
+	domain: string;
+	deployDir: string;
+	define: DefineDict;
+
+
+	constructor(dir: string, info: EndpointInfo, schema: DirLevel[]) {
+		this.dir = dir;
+		this.deployDir = dir;
+		this.dirStrArr = dir.split('/').filter(d => d.length > 0);
+		this.dirArr = DirLevel.createDirArr(dir, schema);
+		this.target = info.target;
+		this.build = info.build;
+		this.domain = info.domain;
+		this.define = info.define;
+	}
+
+	static createEndpointArr(cicdConfig: CICDConfig, schema: DirLevel[]) {
+		const endpointDict = cicdConfig.endpoints;
+		return Object.keys(endpointDict).map(dir => {
+			const info = endpointDict[dir];
+			return new Endpoint(dir, info, schema);
+		});
+	}
+
+	matchCmd(dirSchemaStrArr: string[], groups: DirGroup[]) {
+		if (this.dirStrArr.length < dirSchemaStrArr.length) {
+			return false;
+		}
+		for (let i = 0; i < dirSchemaStrArr.length; i++) {
+			const cmdDir = dirSchemaStrArr[i];
+			const dir = this.dirStrArr[i];
+			const dirLevel = this.dirArr[i];
+			//check if dir is wildcard
+			if (cmdDir !== '%') {
+				//not wildcard
+				//check if dir is group alias
+				if (cmdDir.indexOf('%') === 0) {
+					//dir is group
+					//find group
+					const group = groups.find(g => g.name === cmdDir);
+					if (group) {
+						//group found
+						//check if group includes this dir
+						if (group.includes.indexOf(dir) < 0) {
+							//not include
+							return false;
+						}
+					} else {
+						return false;
+					}
+
+				} else {
+					//cmdDir is not group
+					if (cmdDir !== dir) {
+						return false;
+					}
+				}
+			} else {
+				if (!dirLevel.dynamic) return false;
+			}
+		}
+		return true;
+	}
+}
+
+export default Endpoint;

package/lib/define/index.ts

@@ -0,0 +1,47 @@
+import fsHelper from '../utils/fsHelper';
+import CICD, {Define} from '@/classes/cicd/CICD';
+import CICDCmd from '@/classes/cicd/CICDCmd';
+import fs from 'fs';
+import path from 'path';
+const replaceDefine = (target:string,define?:Define)=>{
+	const dirs = fs.readdirSync(target);
+	for (let dir of dirs){
+		const stat = fs.statSync(path.join(target, dir));
+		if (stat.isDirectory()){
+			replaceDefine(path.join(target, dir),define);
+		}else{
+			if (define){
+				const namePieces = dir.split('.');
+				const fileType = namePieces[namePieces.length - 1];
+				if (['js','json','json5','yml','ts'].indexOf(fileType)>=0){
+					let file = fs.readFileSync(path.join(target, dir)).toString();
+					const replaceArr = Object.keys(define);
+					for (let replace of replaceArr){
+						file = file.replace(new RegExp(replace,'g'),define[replace] as string);
+					}
+					fs.writeFileSync(path.join(target, dir),file);
+				}
+			}
+		}
+	}
+}
+export default async (cmd: any) => {
+	// let phase = 'start define';
+	// try{
+	// 	const cicdConfigJson = fsHelper.readCICDConfig();
+	// 	const cicdConfig = new CICD(cicdConfigJson);
+	// 	const args: string[] = cmd.args;
+	// 	const define = cicdConfig.defines[args[1]];
+	// 	//construct cmd object
+	// 	const cicdCmd = new CICDCmd(cmd, cicdConfig);
+	// 	console.log(cicdCmd);
+	// 	//define by cicdCmd and cicdConfig
+	// 	phase = 'start replacement';
+	// 	for (let i = 0; i < cicdCmd.endpoints.length; i++) {
+	// 		const ep = cicdCmd.endpoints[i];
+	// 		replaceDefine(path.join(cicdConfig.source.root_path, ep.dir),define);
+	// 	}
+	// }catch (e) {
+	// 	throw new Error(`${phase}:${e.message}`)
+	// }
+}

package/lib/deploy/index.ts

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+import aliOSS from "ali-oss";
+import fsHelper from "../utils/fsHelper";
+import CICD from "@/classes/cicd/CICD";
+import CICDCmd from "@/classes/cicd/CICDCmd";
+//
+// const progress = (p: number, filePath: string, ossPath: string) => {
+//   // 上传进度。
+//   process.stdout.clearLine(-1);
+//   process.stdout.cursorTo(0);
+//   process.stdout.write(
+//     `progress: ${p.toFixed(2)}%, Upload '${filePath}' To OSS_PATH:${ossPath}`
+//   );
+// };
+//
+// let filesList: string[] = [];
+// const traverseFolder = (url: string) => {
+//   if (fs.existsSync(url)) {
+//     const files = fs.readdirSync(url);
+//     files.forEach((file) => {
+//       const curPath = path.join(url, file);
+//       if (fs.statSync(curPath).isDirectory()) {
+//         traverseFolder(curPath);
+//       } else {
+//         filesList.push(curPath);
+//       }
+//     });
+//   }
+// };
+//
+export default async (cmd: any) => {
+	try {
+		//create cicd object
+		const cicd = CICD.createByDefault(cmd);
+		//construct cmd object
+		const cicdCmd = new CICDCmd(cmd, cicd);
+	}catch (e) {
+		throw e;
+	}
+}

package/lib/deps/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace deps {
+	const name: string;
+
+	function load(): void;
+}
+export default deps;

package/lib/env/index.d.ts

@@ -0,0 +1,4 @@
+declare namespace env {
+	function load(): void;
+}
+export default env;

package/lib/info/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace info {
+	function load(): void;
+	function info(): void;
+
+}
+export default info;

package/lib/info/index.js

@@ -10,6 +10,7 @@ const json5 = require('json5');
 const print = require('../print');
 //加载命令控制器
 const info = () => {
+	console.log('process.platform');
 	print.info(`start checking modules|OS:${process.platform} `);
 	let rigJson5 = json5.parse(fs.readFileSync('package.rig.json5'));
 	for (let dep of rigJson5) {

package/lib/init/cicd.rig.json5

@@ -0,0 +1,9 @@
+{
+  tree_schema: '{app}/{env}/{oem}',
+  source: {
+    root_path: 'dist',
+  },
+  target: {},
+  endpoints: {},
+  groups: [],
+}

package/lib/init/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace init {
+	const name: string;
+
+	function load(): void;
+}
+export default init;

package/lib/init/index.js

@@ -4,24 +4,22 @@
  * @author Wang Bo (ralwayne@163.com)
  * @date 2020/10/9 6:14 PM
  */
-const shell = require('shelljs');
 const fs = require('fs');
-const path = require('path');
 const json5 = require('json5');
-const inquirer = require('inquirer');
 const chalk = require('chalk');
 let log = console.log;
 let green = chalk.green;
-let red = chalk.red;
 let redBright = chalk.redBright;
 
-let yellow = chalk.yellow;
-
 //加载命令控制器
 
-const load = async (cmd) => {
+const load = async () => {
   try {
     console.log(chalk.blue('exec init'));
+    const pkg = JSON.parse(fs.readFileSync(`${process.cwd()}/package.json`));
+
+
+
     //检查当前目录是否存在package.json
     if (!(fs.existsSync('package.json') && fs.lstatSync('package.json').isFile())) {
       console.log(chalk.red('Please run this in the root directory of project!Must have a validate package.json'));
@@ -32,7 +30,7 @@ const load = async (cmd) => {
       console.log(chalk.green('package.rig.json5 already exists~'));
     } else {
       //创建package.rig.json5.json5
-      let template =`[
+      let template = `[
 //  {
 //    name: "your project name",
 //    source: "git ssh url",
@@ -43,26 +41,43 @@ const load = async (cmd) => {
       console.log(chalk.green('create package.rig.json5'));
       fs.writeFileSync('./package.rig.json5', template);
     }
-    if (fs.existsSync('rig_helper.js')){
+    if (fs.existsSync(`${process.cwd()}/rig_helper.js`)) {
       console.log(chalk.green('rig_helper.js already exists~'));
-    }else{
-      let rigHelper = `const json5 = require('json5');
+    } else {
+      console.log(chalk.green('create rig_helper.js'));
+      let template = `const json5 = require('json5');
 const fs = require('fs');
 const getPkgs = () => {
-  let pkgArr = json5.parse(fs.readFileSync('./package.rig.json5'));
-  let flatPkgArr = pkgArr.map((item, index) => {
-    return item.name;
-  });
-  console.log(flatPkgArr);
-  return flatPkgArr;
+\tlet pkgArr = json5.parse(fs.readFileSync('./package.rig.json5'));
+\tlet flatPkgArr = pkgArr.map((item, index) => {
+\t\treturn item.name;
+\t});
+\tconsole.log(flatPkgArr);
+\treturn flatPkgArr;
 }
 
 module.exports = {
-  getPkgs
+\tgetPkgs
 }
 `
-      console.log(chalk.green('create rig_helper.js'));
-      fs.writeFileSync('./rig_helper.js', rigHelper);
+      fs.writeFileSync(`${process.cwd()}/rig_helper.js`, template);
+    }
+    if (fs.existsSync(`${process.cwd()}/cicd.rig.json5`)) {
+      console.log(chalk.green('cicd.rig.json5 already exists~'));
+    } else {
+      console.log(chalk.green('create cicd.rig.json5'));
+      let template = `{
+  tree_schema: '{app}/{env}/{oem}',
+  source: {
+    root_path: 'dist',
+  },
+  target: {},
+  endpoints: {},
+  groups: [],
+}
+`;
+      fs.writeFileSync(`${process.cwd()}/cicd.rig.json5`, template);
+
     }
     //检查rigs是否存在
     if (fs.existsSync('./rigs') && fs.lstatSync('./rigs').isDirectory()) {
@@ -111,21 +126,21 @@ module.exports = {
         "rigs/*",
         "rigs_dev/*"
       ],
-      scripts:{
-        preinstall:"rig preinstall",
-        postinstall:"rig postinstall",
+      scripts: {
+        preinstall: "rig preinstall",
+        postinstall: "rig postinstall",
       },
-      devDependencies:{
-        json5:'2.1.3'
+      devDependencies: {
+        json5: '2.1.3'
       }
     }
     pkgJSON.private = inserted.private;
     //初始化workspaces
     if (pkgJSON.workspaces && pkgJSON.workspaces instanceof Array) {
-      if (pkgJSON.workspaces.indexOf('rigs/*')===-1) {
+      if (pkgJSON.workspaces.indexOf('rigs/*') === -1) {
         pkgJSON.workspaces.push('rigs/*')
       }
-      if (pkgJSON.workspaces.indexOf('rigs_dev/*')===-1) {
+      if (pkgJSON.workspaces.indexOf('rigs_dev/*') === -1) {
         pkgJSON.workspaces.push('rigs_dev/*')
       }
 
@@ -134,26 +149,26 @@ module.exports = {
     }
     //初始化pre/post-install
     if (pkgJSON.scripts && pkgJSON.scripts instanceof Object) {
-      if (pkgJSON.scripts.preinstall && pkgJSON.scripts.preinstall.indexOf(inserted.scripts.preinstall)<0) {
+      if (pkgJSON.scripts.preinstall && pkgJSON.scripts.preinstall.indexOf(inserted.scripts.preinstall) < 0) {
         pkgJSON.scripts.preinstall = `${pkgJSON.scripts.preinstall} && ${inserted.scripts.preinstall}`
-      }else{
+      } else {
         pkgJSON.scripts.preinstall = inserted.scripts.preinstall;
       }
-      if (pkgJSON.scripts.postinstall && pkgJSON.scripts.postinstall.indexOf(inserted.scripts.postinstall)<0) {
+      if (pkgJSON.scripts.postinstall && pkgJSON.scripts.postinstall.indexOf(inserted.scripts.postinstall) < 0) {
         pkgJSON.scripts.postinstall = `${pkgJSON.scripts.postinstall} && ${inserted.scripts.postinstall}`
-      }else{
+      } else {
         pkgJSON.scripts.postinstall = inserted.scripts.postinstall;
       }
     } else {
       pkgJSON.scripts = inserted.scripts
     }
-    if (pkgJSON.devDependencies){
+    if (pkgJSON.devDependencies) {
       //TODO:可优化
       pkgJSON.devDependencies.json5 = inserted.devDependencies.json5;
-    }else{
+    } else {
       pkgJSON.devDependencies = inserted.devDependencies;
     }
-    fs.writeFileSync('package.json', JSON.stringify(pkgJSON,null,2));
+    fs.writeFileSync('package.json', JSON.stringify(pkgJSON, null, 2));
     log(green('package.json updated'))
   } catch (e) {
     log(redBright(e.message));

package/lib/init/rig_helper.js

@@ -0,0 +1,14 @@
+const json5 = require('json5');
+const fs = require('fs');
+const getPkgs = () => {
+	let pkgArr = json5.parse(fs.readFileSync('./package.rig.json5'));
+	let flatPkgArr = pkgArr.map((item, index) => {
+		return item.name;
+	});
+	console.log(flatPkgArr);
+	return flatPkgArr;
+}
+
+module.exports = {
+	getPkgs
+}

package/lib/install/index.d.ts

@@ -0,0 +1,5 @@
+declare namespace install {
+	function load(): void;
+
+}
+export default install;