@makano/rew 1.1.0 → 1.1.12

package/README.md

@@ -1,5 +1,5 @@
 <h3 align="center">
-<img src="https://raw.githubusercontent.com/kevinJ045/rew/main/assets/logo.png" width="100" />
+<img src="https://raw.githubusercontent.com/kevinJ045/rew-docs/main/assets/logo.png" width="100" />
 <br/>
 Rew
 <br/>

package/lib/rew/cli/cli.js

@@ -3,9 +3,11 @@
 const yargs = require('yargs/yargs');
 const path = require('path');
 const { hideBin } = require('yargs/helpers');
-const { fork } = require('child_process');
+const { fork, exec } = require('child_process');
 const { watch } = require('chokidar');
 const utils = require('./utils');
+const { existsSync } = require('fs');
+const { log } = require('./log');
 
 yargs(hideBin(process.argv))
   .command(
@@ -25,6 +27,10 @@ yargs(hideBin(process.argv))
     },
     (argv) => {
       const filePath = path.resolve(process.cwd(), argv.file);
+      if(!existsSync(filePath)){
+        log('File not found:', argv.file, ':end');
+        return;
+      }
       const watching = [];
       const watchIt = (file) => {
         if(watching.includes(file)) return;
@@ -104,6 +110,18 @@ yargs(hideBin(process.argv))
       utils.runApp(argv.path);
     }
   )
+  .command('install <path>',  'Install an app', (yargs) => {
+    yargs
+      .positional('path', {
+        describe: 'Path of the app to install',
+        type: 'string',
+      });
+    },
+    async (argv) => {
+      if(argv.path.startsWith('github:')) utils.installApp(await utils.cloneGit(argv.path), true, true);
+      else utils.installApp(argv.path);
+    }
+  )
   .command('build <file>', 'Build the specified file', (yargs) => {
     yargs
       .positional('file', {

package/lib/rew/cli/utils.js

@@ -4,8 +4,9 @@ const conf = require('../pkgs/conf');
 const jsYaml = require('js-yaml');
 const readline = require('readline');
 const { log, logget } = require('./log');
-const { execSync } = require('child_process');
+const { execSync, exec } = require('child_process');
 const { run } = require('../main');
+const { generateRandomID } = require('../functions/id');
 
 const npm_package_name = '@makano/rew';
 
@@ -68,6 +69,7 @@ module.exports = {
       fs.writeFileSync(confPath, jsYaml.dump({ package: project.package, entry: 'main.coffee' }));
       fs.writeFileSync(entryFile, `print("Hello World!")`);
       if(project.git) {
+        fs.writeFileSync(path.join(projectPath, '.gitignore'), `node_modules/\npackage-lock.json`);
         execSync('cd '+projectPath+' && git init .');
       }
       log('Installing '+npm_package_name);
@@ -104,7 +106,14 @@ module.exports = {
     const runAppRoot = (root, confPath) => {
       const c = jsYaml.load(fs.readFileSync(confPath, { encoding: 'utf-8' }));
       if(c.entry){
-        run(path.resolve(root, c.entry));
+        const r = path.resolve(root, c.entry);
+        const mod_path = path.resolve(root, 'node_modules/@makano/rew');
+        const mod_path_lib = path.join(mod_path, 'lib/rew/cli');
+        if(fs.existsSync(mod_path) && __dirname !== mod_path_lib){
+          const mod_path_utilsjs = path.join(mod_path_lib, '../main.js');
+          require(mod_path_utilsjs)
+          .run(r);
+        } else run(r);
       }
     }
 
@@ -112,11 +121,70 @@ module.exports = {
       runAppRoot(apppath, appConfpath);
     } else {
       const con = conf({});
-      const apppath = path.resolve(con.CONFIG_PATH, pathOrPackage, '$app');
+      const apppath = path.resolve(con.CONFIG_PATH, pathOrPackage, 'app');
       const appConfpath = path.join(apppath, 'app.yaml');
       if(fs.existsSync(apppath) && fs.existsSync(appConfpath)){
         runAppRoot(apppath, appConfpath);
       }
     }
+  },
+  installApp(pathname, rmidir, rmidiri){
+    if(!pathname){
+      return;
+    }
+    const apppath = path.resolve(process.cwd(), pathname);
+    const appConfpath = path.join(apppath, 'app.yaml');
+    const appPackagepath = path.join(apppath, 'package.json');
+    if(fs.existsSync(apppath) && fs.existsSync(appConfpath)){
+      const c = jsYaml.load(fs.readFileSync(appConfpath, { encoding: 'utf-8' }));
+      const p = JSON.parse(fs.readFileSync(appPackagepath, { encoding: 'utf-8' }));
+      const pname = c.package;
+      const installPath = path.join(conf({}).create(pname).root, 'app');
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });    
+      log('Installing '+pname);
+      log("Package: "+p.name+'@'+p.version);
+      if(p.description){
+        log("Description: "+p.description);
+      }
+      rl.question(logget('Install '+pname+'? (y/N)'), (f) => {
+        if(f.toLowerCase() == 'y'){
+          if(fs.existsSync(installPath)){
+            execSync(`rm -r ${installPath}`);
+          }
+          execSync(`cp -r ${apppath} ${installPath}`);
+          if(rmidir){
+            execSync(`rm -r ${apppath}`);
+          }
+          log('Installed '+pname, ':end');
+          rl.close();
+        } else {
+          if(rmidiri){
+            execSync(`rm -r ${apppath}`);
+          }
+          log('Canceled install', ':end');
+          rl.close();
+        }
+      });
+    } else {
+      log('Path is not a rew app', ':end');
+    }
+  },
+  async cloneGit(gitpath){
+    const p = gitpath.split('github:')[1];
+    const url = `https://github.com/${p}`;
+    const apiurl = `https://api.github.com/repos/${p}`;
+    return await fetch(apiurl)
+    .then((r) => {
+      if(r.status !== 200) return log('Repo not found', ':end');
+      const tempPath = '/tmp/rew-git-clone-'+p.replace(/\//g, '_')+'-'+generateRandomID();
+      execSync(`git clone ${url} ${tempPath}`);
+      console.log('Installing deps...');
+      execSync(`cd ${tempPath} && npm i`);
+      return tempPath;
+    })
+    .catch(r => null);
   }
 }

package/lib/rew/functions/future.js

@@ -14,9 +14,10 @@ module.exports = function future(callback, timeout = 0, defData = null) {
   });
   return {
     pipe: (callback) => promise.then(callback),
-    pipex: (callback) => promise.finally(callback),
+    last: (callback) => promise.finally(callback),
     catch: (callback) => promise.catch(callback),
     resolve: (data) => listener.emit("resolve", data),
     reject: (data) => listener.emit("reject", data),
+    wait: async () => await promise 
   };
 };

package/lib/rew/functions/import.js

@@ -2,6 +2,23 @@ const path = require("path");
 const { getFile, file } = require("../modules/fs");
 const { importYaml } = require("../modules/yaml");
 const { findPackage, getPackage } = require("../pkgs/pkgs");
+const { existsSync, readFileSync } = require("fs");
+const conf = require("../pkgs/conf");
+const jsYaml = require("js-yaml");
+
+const lookUpInOtherApps = (fullPath) => {
+  const con = conf({});
+  const name = fullPath.indexOf('/') ? fullPath.split('/')[0] : fullPath;
+  let dpath = fullPath.indexOf('/') ? fullPath.split('/')[1] : '';
+  let ppath = path.join(con.CONFIG_PATH, name, 'app');
+  if(!existsSync(ppath)) return null;
+  if(!dpath){
+    dpath = jsYaml.load(readFileSync(path.join(ppath, 'app.yaml'), 'utf-8')).entry;
+  }
+  ppath = path.join(ppath, dpath);
+  if(existsSync(ppath)) return ppath;
+  else return null;
+}
 
 module.exports.imp = function (runPath, context) {
   return function (filename, options = {}) {
@@ -9,10 +26,16 @@ module.exports.imp = function (runPath, context) {
     let exports,
       ispkg = findPackage(filename);
 
-    const filepath = path.resolve(path.dirname(context.module.filepath), filename);
+    let filepath = path.resolve(path.dirname(context.module.filepath), filename);
 
     // console.log(typeof runPath);
 
+    if(!ispkg && !existsSync(filepath)){
+      const otherPath = lookUpInOtherApps(filename);
+      if(!otherPath) throw new Error('Module "'+filename+'" not found');
+      else filepath = otherPath;
+    }
+
     if (ispkg) {
       exports = getPackage(filename)(context);
     } else if (type == "coffee") {

package/lib/rew/pkgs/modules/threads/worker.js

@@ -0,0 +1,37 @@
+const { parentPort, workerData } = require('worker_threads');
+const { exec } = require('../../../modules/runtime');
+
+const target = {};
+target.events = [];
+target.on = (e, cb) => {
+  target.events.push({ e, cb });
+}
+target.off = (e) => {
+  target.events = target.events.filter(i => i.e !== e);
+}
+target.emit = (e, data) => {
+  target.events.filter(i => i.e == e).forEach(i => i.cb(data));
+}
+
+parentPort.on('message', (data) => {
+  if (data.type === 'event') {
+    target.emit(data.event, data.data);
+  } else if (data.type === 'start') {
+    (async () => {
+      try {
+        exec(`(${workerData.cb}).call({ process }, context)`, { print: (...a) => console.log(...a), process: {
+          on: (e, cb) => { target.on(e, cb) },
+          off: (e) => { target.off(e) },
+          emit: (e) => { parentPort.postMessage({ type: 'event', event: e, data }) },
+          exit: (code) => process.exit(code),
+          finish: (data) => {
+            parentPort.postMessage({ type: 'result', result: data });
+            process.exit(0)
+          }
+        }, context: workerData.context })
+      } catch (e) {
+        parentPort.postMessage({ type: 'error', error: e.message });
+      }
+    })();
+  }
+});

package/lib/rew/pkgs/threads.js

@@ -0,0 +1,67 @@
+const { Worker } = require('worker_threads');
+const emitter = require('../functions/emitter');
+const future = require('../functions/future');
+const { struct } = require('../models/struct');
+const path = require('path');
+
+module.exports = (context) => ({
+  thread: (cb) => {
+    const workers = [];
+
+    const stopWorker = (worker) => {
+      workers.splice(workers.indexOf(worker), 1);
+      worker.terminate()
+    };
+
+    const athread = {
+      stopAll: () => {
+        if (!run) return;
+        workers.forEach(stopWorker);
+      },
+      start: (context) => {
+        let dataResult = future(() => {}), listener = emitter();
+        const worker = new Worker(path.resolve(__dirname, './modules/threads/worker.js'), {
+          workerData: { context, cb: cb.toString() }
+        });
+        workers.push(worker);
+
+        const stop = () => stopWorker(worker);
+
+        worker.on('message', (data) => {
+          if (data.type === 'result') {
+            dataResult.resolve(data.result);
+            stop();
+          } else if (data.type === 'error') {
+            reject(new Error(data.error));
+            stop();
+          } else if (data.type === 'event') {
+            listener.emit(data.event, data.data);
+          }
+        });
+
+        worker.on('error', (error) => {
+          console.log(error);
+          stop();
+        });
+
+        worker.on('exit', (code) => {
+          stop();
+          if (code !== 0) {
+            throw new Error(`Worker stopped with exit code ${code}`);
+          }
+        });
+
+        worker.postMessage({ type: 'start' });
+
+        return {
+          on: (e, cb) => listener.on(e, cb),
+          off: (e, cb) => listener.off(e, cb),
+          emit: (e, data) => worker?.postMessage({ type: 'event', event: e, data }),
+          get: () => dataResult.wait()
+        };
+      }
+    };
+
+    return athread;
+  }
+});

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "@makano/rew",
-  "version": "1.1.0",
+  "version": "1.1.12",
   "description": "A simple coffescript runtime",
   "main": "lib/rew/main.js",
   "directories": {
     "lib": "lib"
   },
   "scripts": {
-    "test": "node test/test.js",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs"
+    "test": "node test/test.js"
   },
   "files": [
     "lib/",
@@ -32,7 +29,6 @@
     "chokidar": "^3.6.0",
     "js-yaml": "^4.1.0",
     "vm": "^0.1.0",
-    "ws": "^8.17.0",
     "yargs": "^17.7.2"
   },
   "devDependencies": {