spyne-cli 0.3.0

package/README.md

@@ -0,0 +1,3 @@
+## spyne-cli
+### Spyne Command Line Tool
+Generates spyne objects and saves them to standard spyne application directories.

package/index-cli.js

@@ -0,0 +1,56 @@
+#! /usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import fsPromises from "fs/promises";
+import R from 'ramda';
+
+
+const args = process.argv;
+
+const methodStr = args.length>=3 ? args[2] : 'empty';
+const undefinedFn = async ()=>console.log('params are undefined.');
+
+
+const deleteFile = async (filePath) => {
+  try {
+    await fsPromises.unlink(filePath);
+    //console.log('Successfully removed file!');
+  } catch (err) {
+    console.log(err);
+  }
+};
+
+function getFiles(dir) {
+  return fs.readdirSync(dir).flatMap((item) => {
+    const path = `${dir}/${item}`;
+    if (fs.statSync(path).isDirectory()) {
+      return getFiles(path);
+    }
+
+    return path;
+  });
+}
+
+const resetAppDir = ()=>{
+
+  const appDir = path.resolve('./', 'src/app');
+  const gitKeepRe = /(.*\/)(.gitkeep)/g;
+  const readFilesArr = R.compose(R.reject(R.test(gitKeepRe)))(getFiles(appDir));
+  readFilesArr.forEach(deleteFile);
+  console.log('app dir is reset');
+
+}
+
+
+
+const methodHash = {
+  resetAppDir
+}
+
+
+const methodFn = methodHash[methodStr] || undefinedFn;
+
+methodFn();
+
+

package/index.js

@@ -0,0 +1,14 @@
+#!/usr/bin/env node
+import  {SpyneCliUI} from './src/ui.js';
+import clear from 'clear';
+import SpyneFilePrompt from './src/spyne-file-prompt.js';
+
+const startPromptFn = async()=>{
+  clear();
+  SpyneCliUI.title();
+  const spyneFilePrompt = new SpyneFilePrompt();
+  await spyneFilePrompt.startPrompt();
+}
+
+startPromptFn();
+

package/lib/ansi.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const isTerm = process.env.TERM_PROGRAM === 'Apple_Terminal';
+const colors = require('ansi-colors');
+const utils = require('./utils');
+const ansi = module.exports = exports;
+const ESC = '\u001b[';
+const BEL = '\u0007';
+let hidden = false;
+
+const code = ansi.code = {
+  bell: BEL,
+  beep: BEL,
+  beginning: `${ESC}G`,
+  down: `${ESC}J`,
+  esc: ESC,
+  getPosition: `${ESC}6n`,
+  hide: `${ESC}?25l`,
+  line: `${ESC}2K`,
+  lineEnd: `${ESC}K`,
+  lineStart: `${ESC}1K`,
+  restorePosition: ESC + (isTerm ? '8' : 'u'),
+  savePosition: ESC + (isTerm ? '7' : 's'),
+  screen: `${ESC}2J`,
+  show: `${ESC}?25h`,
+  up: `${ESC}1J`
+};
+
+const cursor = ansi.cursor = {
+  get hidden() {
+    return hidden;
+  },
+
+  hide() {
+    hidden = true;
+    return code.hide;
+  },
+  show() {
+    hidden = false;
+    return code.show;
+  },
+
+  forward: (count = 1) => `${ESC}${count}C`,
+  backward: (count = 1) => `${ESC}${count}D`,
+  nextLine: (count = 1) => `${ESC}E`.repeat(count),
+  prevLine: (count = 1) => `${ESC}F`.repeat(count),
+
+  up: (count = 1) => count ? `${ESC}${count}A` : '',
+  down: (count = 1) => count ? `${ESC}${count}B` : '',
+  right: (count = 1) => count ? `${ESC}${count}C` : '',
+  left: (count = 1) => count ? `${ESC}${count}D` : '',
+
+  to(x, y) {
+    return y ? `${ESC}${y + 1};${x + 1}H` : `${ESC}${x + 1}G`;
+  },
+
+  move(x = 0, y = 0) {
+    let res = '';
+    res += (x < 0) ? cursor.left(-x) : (x > 0) ? cursor.right(x) : '';
+    res += (y < 0) ? cursor.up(-y) : (y > 0) ? cursor.down(y) : '';
+    return res;
+  },
+
+  restore(state = {}) {
+    let { after, cursor, initial, input, prompt, size, value } = state;
+    initial = utils.isPrimitive(initial) ? String(initial) : '';
+    input = utils.isPrimitive(input) ? String(input) : '';
+    value = utils.isPrimitive(value) ? String(value) : '';
+
+    if (size) {
+      let codes = ansi.cursor.up(size) + ansi.cursor.to(prompt.length);
+      let diff = input.length - cursor;
+      if (diff > 0) {
+        codes += ansi.cursor.left(diff);
+      }
+      return codes;
+    }
+
+    if (value || after) {
+      let pos = (!input && !!initial) ? -initial.length : -input.length + cursor;
+      if (after) pos -= after.length;
+      if (input === '' && initial && !prompt.includes(initial)) {
+        pos += initial.length;
+      }
+      return ansi.cursor.move(pos);
+    }
+  }
+};
+
+const erase = ansi.erase = {
+  screen: code.screen,
+  up: code.up,
+  down: code.down,
+  line: code.line,
+  lineEnd: code.lineEnd,
+  lineStart: code.lineStart,
+  lines(n) {
+    let str = '';
+    for (let i = 0; i < n; i++) {
+      str += ansi.erase.line + (i < n - 1 ? ansi.cursor.up(1) : '');
+    }
+    if (n) str += ansi.code.beginning;
+    return str;
+  }
+};
+
+ansi.clear = (input = '', columns = process.stdout.columns) => {
+  if (!columns) return erase.line + cursor.to(0);
+  let width = str => [...colors.unstyle(str)].length;
+  let lines = input.split(/\r?\n/);
+  let rows = 0;
+  for (let line of lines) {
+    rows += 1 + Math.floor(Math.max(width(line) - 1, 0) / columns);
+  }
+  return (erase.line + cursor.prevLine()).repeat(rows - 1) + erase.line + cursor.to(0);
+};

package/lib/combos.js

@@ -0,0 +1,75 @@
+'use strict';
+
+/**
+ * Actions are mappings from keypress event names to method names
+ * in the prompts.
+ */
+
+exports.ctrl = {
+  a: 'first',
+  b: 'backward',
+  c: 'cancel',
+  d: 'deleteForward',
+  e: 'last',
+  f: 'forward',
+  g: 'reset',
+  i: 'tab',
+  k: 'cutForward',
+  l: 'reset',
+  n: 'newItem',
+  m: 'cancel',
+  j: 'submit',
+  p: 'search',
+  r: 'remove',
+  s: 'save',
+  u: 'undo',
+  w: 'cutLeft',
+  x: 'toggleCursor',
+  v: 'paste'
+};
+
+exports.shift = {
+  up: 'shiftUp',
+  down: 'shiftDown',
+  left: 'shiftLeft',
+  right: 'shiftRight',
+  tab: 'prev'
+};
+
+exports.fn = {
+  up: 'pageUp',
+  down: 'pageDown',
+  left: 'pageLeft',
+  right: 'pageRight',
+  delete: 'deleteForward'
+};
+
+// <alt> on Windows
+exports.option = {
+  b: 'backward',
+  f: 'forward',
+  d: 'cutRight',
+  left: 'cutLeft',
+  up: 'altUp',
+  down: 'altDown'
+};
+
+exports.keys = {
+  pageup: 'pageUp', // <fn>+<up> (mac), <Page Up> (windows)
+  pagedown: 'pageDown', // <fn>+<down> (mac), <Page Down> (windows)
+  home: 'home', // <fn>+<left> (mac), <home> (windows)
+  end: 'end', // <fn>+<right> (mac), <end> (windows)
+  cancel: 'cancel',
+  delete: 'deleteForward',
+  backspace: 'delete',
+  down: 'down',
+  enter: 'submit',
+  escape: 'cancel',
+  left: 'left',
+  space: 'space',
+  number: 'number',
+  return: 'submit',
+  right: 'right',
+  tab: 'next',
+  up: 'up'
+};

package/lib/completer.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const unique = arr => arr.filter((v, i) => arr.lastIndexOf(v) === i);
+const compact = arr => unique(arr).filter(Boolean);
+
+module.exports = (action, data = {}, value = '') => {
+  let { past = [], present = '' } = data;
+  let rest, prev;
+
+  switch (action) {
+    case 'prev':
+    case 'undo':
+      rest = past.slice(0, past.length - 1);
+      prev = past[past.length - 1] || '';
+      return {
+        past: compact([value, ...rest]),
+        present: prev
+      };
+
+    case 'next':
+    case 'redo':
+      rest = past.slice(1);
+      prev = past[0] || '';
+      return {
+        past: compact([...rest, value]),
+        present: prev
+      };
+
+    case 'save':
+      return {
+        past: compact([...past, value]),
+        present: ''
+      };
+
+    case 'remove':
+      prev = compact(past.filter(v => v !== value));
+      present = '';
+
+      if (prev.length) {
+        present = prev.pop();
+      }
+
+      return {
+        past: prev,
+        present
+      };
+
+    default: {
+      throw new Error(`Invalid action: "${action}"`);
+    }
+  }
+};

package/lib/interpolate.js

@@ -0,0 +1,266 @@
+'use strict';
+
+const colors = require('ansi-colors');
+const clean = (str = '') => {
+  return typeof str === 'string' ? str.replace(/^['"]|['"]$/g, '') : '';
+};
+
+/**
+ * This file contains the interpolation and rendering logic for
+ * the Snippet prompt.
+ */
+
+class Item {
+  constructor(token) {
+    this.name = token.key;
+    this.field = token.field || {};
+    this.value = clean(token.initial || this.field.initial || '');
+    this.message = token.message || this.name;
+    this.cursor = 0;
+    this.input = '';
+    this.lines = [];
+  }
+}
+
+const tokenize = async(options = {}, defaults = {}, fn = token => token) => {
+  let unique = new Set();
+  let fields = options.fields || [];
+  let input = options.template;
+  let tabstops = [];
+  let items = [];
+  let keys = [];
+  let line = 1;
+
+  if (typeof input === 'function') {
+    input = await input();
+  }
+
+  let i = -1;
+  let next = () => input[++i];
+  let peek = () => input[i + 1];
+  let push = token => {
+    token.line = line;
+    tabstops.push(token);
+  };
+
+  push({ type: 'bos', value: '' });
+
+  while (i < input.length - 1) {
+    let value = next();
+
+    if (/^[^\S\n ]$/.test(value)) {
+      push({ type: 'text', value });
+      continue;
+    }
+
+    if (value === '\n') {
+      push({ type: 'newline', value });
+      line++;
+      continue;
+    }
+
+    if (value === '\\') {
+      value += next();
+      push({ type: 'text', value });
+      continue;
+    }
+
+    if ((value === '$' || value === '#' || value === '{') && peek() === '{') {
+      let n = next();
+      value += n;
+
+      let token = { type: 'template', open: value, inner: '', close: '', value };
+      let ch;
+
+      while ((ch = next())) {
+        if (ch === '}') {
+          if (peek() === '}') ch += next();
+          token.value += ch;
+          token.close = ch;
+          break;
+        }
+
+        if (ch === ':') {
+          token.initial = '';
+          token.key = token.inner;
+        } else if (token.initial !== void 0) {
+          token.initial += ch;
+        }
+
+        token.value += ch;
+        token.inner += ch;
+      }
+
+      token.template = token.open + (token.initial || token.inner) + token.close;
+      token.key = token.key || token.inner;
+
+      if (defaults.hasOwnProperty(token.key)) {
+        token.initial = defaults[token.key];
+      }
+
+      token = fn(token);
+      push(token);
+
+      keys.push(token.key);
+      unique.add(token.key);
+
+      let item = items.find(item => item.name === token.key);
+      token.field = fields.find(ch => ch.name === token.key);
+
+      if (!item) {
+        item = new Item(token);
+        items.push(item);
+      }
+
+      item.lines.push(token.line - 1);
+      continue;
+    }
+
+    let last = tabstops[tabstops.length - 1];
+    if (last.type === 'text' && last.line === line) {
+      last.value += value;
+    } else {
+      push({ type: 'text', value });
+    }
+  }
+
+  push({ type: 'eos', value: '' });
+  return { input, tabstops, unique, keys, items };
+};
+
+module.exports = async prompt => {
+  let options = prompt.options;
+  let required = new Set(options.required === true ? [] : (options.required || []));
+  let defaults = { ...options.values, ...options.initial };
+  let { tabstops, items, keys } = await tokenize(options, defaults);
+
+  let result = createFn('result', prompt, options);
+  let format = createFn('format', prompt, options);
+  let isValid = createFn('validate', prompt, options, true);
+  let isVal = prompt.isValue.bind(prompt);
+
+  return async(state = {}, submitted = false) => {
+    let index = 0;
+
+    state.required = required;
+    state.items = items;
+    state.keys = keys;
+    state.output = '';
+
+    let validate = async(value, state, item, index) => {
+      let error = await isValid(value, state, item, index);
+      if (error === false) {
+        return 'Invalid field ' + item.name;
+      }
+      return error;
+    };
+
+    for (let token of tabstops) {
+      let value = token.value;
+      let key = token.key;
+
+      if (token.type !== 'template') {
+        if (value) state.output += value;
+        continue;
+      }
+
+      if (token.type === 'template') {
+        let item = items.find(ch => ch.name === key);
+
+        if (options.required === true) {
+          state.required.add(item.name);
+        }
+
+        let val = [item.input, state.values[item.value], item.value, value].find(isVal);
+        let field = item.field || {};
+        let message = field.message || token.inner;
+
+        if (submitted) {
+          let error = await validate(state.values[key], state, item, index);
+          if ((error && typeof error === 'string') || error === false) {
+            state.invalid.set(key, error);
+            continue;
+          }
+
+          state.invalid.delete(key);
+          let res = await result(state.values[key], state, item, index);
+          state.output += colors.unstyle(res);
+          continue;
+        }
+
+        item.placeholder = false;
+
+        let before = value;
+        value = await format(value, state, item, index);
+
+        if (val !== value) {
+          state.values[key] = val;
+          value = prompt.styles.typing(val);
+          state.missing.delete(message);
+
+        } else {
+          state.values[key] = void 0;
+          val = `<${message}>`;
+          value = prompt.styles.primary(val);
+          item.placeholder = true;
+
+          if (state.required.has(key)) {
+            state.missing.add(message);
+          }
+        }
+
+        if (state.missing.has(message) && state.validating) {
+          value = prompt.styles.warning(val);
+        }
+
+        if (state.invalid.has(key) && state.validating) {
+          value = prompt.styles.danger(val);
+        }
+
+        if (index === state.index) {
+          if (before !== value) {
+            value = prompt.styles.underline(value);
+          } else {
+            value = prompt.styles.heading(colors.unstyle(value));
+          }
+        }
+
+        index++;
+      }
+
+      if (value) {
+        state.output += value;
+      }
+    }
+
+    let lines = state.output.split('\n').map(l => ' ' + l);
+    let len = items.length;
+    let done = 0;
+
+    for (let item of items) {
+      if (state.invalid.has(item.name)) {
+        item.lines.forEach(i => {
+          if (lines[i][0] !== ' ') return;
+          lines[i] = state.styles.danger(state.symbols.bullet) + lines[i].slice(1);
+        });
+      }
+
+      if (prompt.isValue(state.values[item.name])) {
+        done++;
+      }
+    }
+
+    state.completed = ((done / len) * 100).toFixed(0);
+    state.output = lines.join('\n');
+    return state.output;
+  };
+};
+
+function createFn(prop, prompt, options, fallback) {
+  return (value, state, item, index) => {
+    if (typeof item.field[prop] === 'function') {
+      return item.field[prop].call(prompt, value, state, item, index);
+    }
+    return [fallback, value].find(v => prompt.isValue(v));
+  };
+}