spyne-cli 0.3.0

package/src/templates/generate-prompt-output.js

@@ -0,0 +1,109 @@
+import R from 'ramda';
+import boxen from 'boxen';
+import colors from 'ansi-colors';
+colors.alias('comment', colors.white);
+colors.alias('snippet', colors.yellow);
+colors.alias('code', colors.yellow);
+colors.alias('files', colors.green);
+
+let _answers;
+let _savedProps;
+let _fileStr;
+
+
+const createChannelRegisterSnippet = () => {
+  const {fileName, className, fileDirectory, channelName} = _answers;
+
+  const filePath = fileDirectory+fileName;
+  const importStr = colors.snippet(`import {${className}} from '${filePath}';`);
+
+  const registerStr = colors.snippet(`SpyneApp.registerChannel(new ${className}());`)
+
+  const padding = "       ";
+  const instx = colors.comment(`\n${padding}//ADD THE FOLLOWING SNIPPET TO YOUR SRC index.js FILE`)
+
+  const registerComment = colors.comment('//REGISTER CHANNEL AFTER SPYNE APP HAS BEEN INITIALIZED')
+
+
+  const commentLine = colors.comment("/*_______________________________________________________________________________*/\n\n");
+  const finalStr = `\n${commentLine}${padding}${importStr}\n\n${padding}${registerComment}\n${padding}${registerStr}\n\n${commentLine}`;
+
+  //return instx+boxen(finalStr, {padding: 1});
+  return instx+finalStr;
+
+}
+
+const outputFailedMessage = (e)=>{
+  const {fileType} = _answers;
+  const {fileDirPath, errorType} = _savedProps;
+  const fileDirPathFormatted = colors.files(`"${fileDirPath}"`)
+
+ // console.log('error is ',{e})
+ const defaultFailedInsertHash = {
+    "fileAlreadyExists" : ` already exists, and  `
+
+  }
+
+  let defaultFailedInsert = defaultFailedInsertHash[errorType] || "";
+
+
+  let defaultFailedText = `\n\nFile, ${fileDirPathFormatted},${defaultFailedInsert}is unable to be saved. `
+
+  let defaultFailedCopyInfo = `\n\nCopy and paste below:\n/*============ begin copy and paste ================*/\n\n${colors.code(_fileStr)}\n/*============ end copy and paste ================*/`
+
+
+  let defaultFailedOutput = defaultFailedText+defaultFailedCopyInfo;
+
+  if (fileType === "Channel"){
+    const channelSnippet = createChannelRegisterSnippet();
+    defaultFailedOutput = `${channelSnippet}\n${defaultFailedOutput}`;
+  }
+  return defaultFailedOutput;
+
+}
+
+
+const outputMessage = ()=>{
+  const {fileType} = _answers;
+  const {fileHasSaved, errorType} = _savedProps;
+
+  //console.log('error type is ',{errorType, fileHasSaved})
+
+  let messageOutput = '';
+
+  const defaultStr = colors.bgBlue(colors.black("File saved successfully."));
+  const messageHash = {
+
+    "ViewStream" : defaultStr,
+    "DomElement" : defaultStr,
+    "SpyneTrait" : defaultStr,
+    "Channel"    : `${defaultStr}\n${createChannelRegisterSnippet()}`
+  }
+
+  if (fileHasSaved){
+    messageOutput = messageHash[fileType];
+  } else {
+
+    messageOutput = outputFailedMessage();
+
+  }
+
+
+  return messageOutput;
+}
+
+
+
+const generatePromptOutput = (answers={}, savedProps={}, fileStr='')=>{
+
+  _answers = answers;
+  _savedProps = savedProps;
+  _fileStr = fileStr;
+
+
+  return outputMessage();
+
+}
+
+
+export {generatePromptOutput}

package/src/ui.js

@@ -0,0 +1,16 @@
+import figlet from 'figlet';
+import chalk from 'chalk';
+
+export class SpyneCliUI {
+
+  constructor() {}
+  static title(){
+    const figletTxt = figlet.textSync('spyne-cli', {
+      horizontalLayout: 'universal smushing'
+    })
+    const chalkOutput = chalk.blue(figletTxt);
+    return console.log(chalkOutput);
+
+  }
+
+}

package/src/utils/color-utils.js

@@ -0,0 +1,36 @@
+import c from 'ansi-colors';
+
+const colorsArr = [c.black, c.cyan,  c.red,   c.green, c.greenBright, c.yellow,  c.yellowBright, c.blue,   c.blueBright, c.magenta,  c.magentaBright, c.cyan,  c.cyanBright, c.white, c.whiteBright, c.gray]
+
+const bgColorsArr = [c.bgBlack, c.bgBlackBright, c.bgRed, c.bgRedBright, c.bgGreen,
+  c.bgGreenBright, c.bgYellow, c.bgYellowBright, c.bgBlue, c.bgBlueBright, c.bgMagenta, c.bgMagentaBright, c.cyan, c.cyanBright, c.bgWhite, c.bgWhiteBright]
+
+
+
+const addColorToStr =  (str)=>(cFn)=>cFn(str);
+
+
+const viewAllColors =(str="File saved successfully.")=>{
+  const testColor = (cFn)=>{
+    const coloredStr = cFn(str);
+    console.log(coloredStr);
+
+  }
+
+  const testBgColors = (bgFn)=>{
+    const strToColor = addColorToStr(str);
+    const mappedAll = colorsArr.map(strToColor);
+    const nestColors = (cFn)=>{
+      const nestedColor = bgFn(cFn);
+      console.log(nestedColor);
+    }
+    mappedAll.forEach(nestColors)
+
+  }
+
+  colorsArr.forEach(testColor)
+  bgColorsArr.forEach(testBgColors);
+
+}
+
+export {viewAllColors}

package/src/utils/error-logger.js

@@ -0,0 +1,15 @@
+import {Data} from '../spyne-template-prompts.js';
+const {debug} = Data;
+
+export default class ErrorLogger {
+
+    constructor() {
+
+    }
+
+    static log(msg, type='generic'){
+      if (debug){
+        console.log(`spyne-util warning: type:${type}, msg: ${msg}`);
+      }
+    }
+}

package/src/utils/file-utils.js

@@ -0,0 +1,69 @@
+
+import {Data} from '../spyne-template-prompts.js';
+const {appPath,promptInputHash} = Data;
+import ErrorLogger  from '../utils/error-logger.js';
+import stringify from 'json-stringify-safe';
+
+import path from 'path';
+import fs from 'fs';
+import c from 'ansi-colors';
+import R  from 'ramda';;
+
+
+const checkIfFileExists = (fileLoc) => fs.existsSync(fileLoc)
+
+
+const onSaveSpyneFileToDir =  (fileStr, fileName,  fileDirectory) =>{
+  const fileDirPath = fileDirectory+fileName;
+  const fileExists = checkIfFileExists(fileDirPath);
+  let fileHasSaved = false;
+  let errorType;
+
+  if (fileExists){
+   // console.warn('file already exists');
+    const errObj = {fileDirPath}
+    errorType = 'fileAlreadyExists';
+
+    //ErrorLogger.log(JSON.stringify(errObj), errorType);
+
+  } else {
+    try {
+      const data = fs.writeFileSync(fileDirPath, fileStr)
+      //file written successfully
+      fileHasSaved = true;
+
+    } catch (err) {
+      errorType='generic';
+
+      ErrorLogger.log(err, 'onSaveSpyneFileToDir');
+    }
+  }
+
+  return {fileExists, fileHasSaved,fileDirPath, errorType}
+
+};
+
+
+
+const getLocalFileDirectory = (_fileType)=>{
+  let dirPath="";
+  const fileTypePath = R.path([_fileType, 'path'])(promptInputHash)
+
+  try{
+    dirPath = fs.existsSync(appPath) ? appPath+fileTypePath : './';
+  } catch(e){
+    ErrorLogger.log(e, 'getFileDirectory')
+  }
+
+  return dirPath;
+
+}
+
+
+const validateFileDirectory = (value)=>{
+  const isValid = fs.existsSync(value);
+  return isValid || 'File directory needs to exist.';
+}
+
+
+export {getLocalFileDirectory, validateFileDirectory, onSaveSpyneFileToDir}

package/tests/generate-file-prompt.test.js

@@ -0,0 +1,47 @@
+import SpyneFilePrompt from '../src/spyne-file-prompt.js';
+import chai from 'chai';
+const {expect, assert} = chai;
+
+
+
+describe('should test spyne file prompt', () => {
+
+  const spyneFilePrompt = new SpyneFilePrompt();
+
+  it('SpyneFilePrompt should exist', () => {
+   expect(SpyneFilePrompt).to.exist;
+
+  });
+
+
+  it('should get the initial select prompt ',()=>{
+
+    const selectPrompt = spyneFilePrompt.getSelectPromptObj();
+
+    //console.log('spyne file prompt is ',{selectPrompt})
+
+    expect(selectPrompt.type).to.equal('Select');
+    expect(selectPrompt).to.be.an('object');
+
+  })
+
+  it('should get file type obj from json data',()=>{
+
+    const fileType = 'ViewStream';
+    const viewStreamObj = SpyneFilePrompt.getFilePromptPropertiesObj(fileType);
+    expect(viewStreamObj.props).to.deep.equal([ 'fileName', 'className', 'fileDirectory' ])
+
+  })
+
+  it('should get prompt array from file type', ()=>{
+    const fileType = 'Channel';
+    const promptArr = SpyneFilePrompt.getFilePrompt(fileType);
+
+    //console.log('prompt arr is ',{promptArr})
+
+    return true;
+
+  })
+
+
+});

package/tests/generate-file-string.test.js

@@ -0,0 +1,68 @@
+import chai from 'chai';
+const {expect, assert} = chai;
+import GenerateFileString from '../src/templates/generate-file-string.js';
+
+describe('should test file string generator', () => {
+
+  it('file string generator should exist', () => {
+
+    expect(GenerateFileString).to.exist;
+
+  });
+
+  it('should generate string for ViewStream file', ()=>{
+    const props = {
+      fileName: 'my-viewstream-file.js',
+      className: 'MyViewstreamClass'
+    }
+    const fileStrGen = new GenerateFileString('ViewStream', props);
+    const fileString = fileStrGen.fileString;
+    const classNameAdded = fileString.indexOf('class MyViewstreamClass ') >= 0;
+   // console.log('view stream file str is ',{classNameAdded}, fileString)
+    expect(classNameAdded).to.be.true;
+  });
+
+  it('should generate string for DomElement file', ()=>{
+    const props = {
+      fileName: 'my-dom-element-file.js',
+      className: 'MyDomElementClass'
+    }
+    const fileStrGen = new GenerateFileString('DomElement', props);
+    const fileString = fileStrGen.fileString;
+    const classNameAdded = fileString.indexOf('class MyDomElementClass ') >= 0;
+    //console.log('DomElement file str is ',{classNameAdded}, fileString)
+    expect(classNameAdded).to.be.true;
+  });
+
+
+  it('should generate string for Channel file', ()=>{
+    const props = {
+      fileName: 'my-channel-file.js',
+      className: 'MyChannelClass',
+      channelName: 'MY_CUSTOM_CHANNEL',
+      replayLastPayload: true
+    }
+    const fileStrGen = new GenerateFileString('Channel', props);
+    const fileString = fileStrGen.fileString;
+    const classNameAdded = fileString.indexOf('class MyChannelClass ') >= 0;
+     //console.log('channel file str is ',{classNameAdded}, fileString)
+    expect(classNameAdded).to.be.true;
+  });
+
+
+  it('should generate string for SpyneTrait file', ()=>{
+    const props = {
+      fileName: 'my-spynetrait-file.js',
+      className: 'MySpyneTrait',
+      methodPrefix: 'myTrait$'
+    }
+    const fileStrGen = new GenerateFileString('SpyneTrait', props);
+    const fileString = fileStrGen.fileString;
+    const classNameAdded = fileString.indexOf('class MySpyneTrait ') >= 0;
+    //console.log('channel file str is ',{classNameAdded}, fileString)
+    expect(classNameAdded).to.be.true;
+
+  });
+
+
+});

package/tests/generate-prompt-input-fields-methods.test.js

@@ -0,0 +1,178 @@
+import chai from 'chai';
+const {expect, assert} = chai;
+import PromptInputField from '../src/templates/generate-prompt-input-fields.js';
+import changeCase from 'change-case';
+
+const {
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  headerCase,
+  noCase,
+  paramCase,
+  pascalCase,
+  pathCase,
+  sentenceCase,
+  snakeCase,
+} = changeCase;
+
+
+import {MockData} from './mocks/enquirer-data.js';
+
+
+
+describe('should create all necessary prompt input initial, hint and validate fields', () => {
+
+  it('PromptInputField should exist', () => {
+    expect(PromptInputField).to.exist;
+  });
+
+
+  describe('it should generate all initial values ',()=>{
+
+    let inputType = "className";
+    let fileType = "ViewStream";
+
+    it('should generate initial file name values ',()=>{
+      const fileNameInputType = "fileName"
+      let fieldType = "initial";
+
+      const viewStreamInitialValue = new PromptInputField(fileNameInputType, 'ViewStream', fieldType).field;
+      const domElementInitialValue = new PromptInputField(fileNameInputType, 'DomElement', fieldType).field;
+      const channelInitialValue    = new PromptInputField(fileNameInputType, 'Channel', fieldType).field;
+      const spyneTraitInitialValue = new PromptInputField(fileNameInputType, 'SpyneTrait', fieldType).field;
+
+      const isValidFileName = (str)=>/(.*)(.js)/.test(str)===true;
+
+      /*console.log('view stream file name is ',{viewStreamInitialValue})
+      console.log('dom element file name is ',{domElementInitialValue})
+      console.log('channel file name is ',{channelInitialValue})
+      console.log('spyne trait file name is ',{spyneTraitInitialValue})
+*/
+
+
+      expect(isValidFileName(viewStreamInitialValue)).to.be.true;
+      expect(isValidFileName(domElementInitialValue)).to.be.true;
+      expect(isValidFileName(channelInitialValue)).to.be.true;
+      expect(isValidFileName(spyneTraitInitialValue)).to.be.true;
+
+    })
+
+
+    it('should generate initial value for className based on valid filename', ()=>{
+        MockData.enquirer.answers.fileName = 'my-viewstream.js';
+
+        const initialViewStreamClassNameFn = new PromptInputField(inputType, fileType, 'initial').field;
+        const initialViewStreamClassName = initialViewStreamClassNameFn(MockData);
+
+      MockData.enquirer.answers.fileName = 'my-dom-element.js';
+      const initialDomElementClassNameFn = new PromptInputField(inputType, fileType, 'initial').field;
+      const initialDomElementClassName = initialDomElementClassNameFn(MockData);
+
+      MockData.enquirer.answers.fileName = 'channel-custom.js';
+      const initialChannelClassNameFn = new PromptInputField(inputType, fileType, 'initial').field;
+      const initialChannelClassName = initialDomElementClassNameFn(MockData);
+
+      MockData.enquirer.answers.fileName = 'my-custom-trait.js';
+      const initialTraitClassNameFn = new PromptInputField(inputType, fileType, 'initial').field;
+      const initialTraitClassName = initialTraitClassNameFn(MockData);
+
+
+/*      console.log('initial class name is ',{initialViewStreamClassName})
+      console.log('initial dom element is ',{initialDomElementClassName})
+      console.log('initial channel is ',{initialChannelClassName})
+      console.log('initial trait is ',{initialTraitClassName})*/
+
+      expect(initialViewStreamClassName).to.equal('MyViewstream')
+      expect(initialDomElementClassName).to.equal('MyDomElement')
+      expect(initialChannelClassName).to.equal('ChannelCustom')
+      expect(initialTraitClassName).to.equal('MyCustomTrait')
+
+
+    })
+
+
+    it('it should generate initial value for directory based on app path', ()=>{
+      let inputType = 'fileDirectory';
+      const initialViewStreamFileDir = new PromptInputField(inputType,  fileType,     'initial').field;
+      const initialDomElementFileDir = new PromptInputField(inputType, 'DomElement',  'initial').field;
+      const initialChannelFileDir =    new PromptInputField(inputType, 'Channel',     'initial').field;
+      const initialSpyneTraitFileDir = new PromptInputField(inputType, 'SpyneTrait',  'initial').field;
+      //console.log('viewstream dir ',{initialViewStreamFileDir})
+      //console.log('domelement dir ',{initialDomElementFileDir})
+      //console.log('channel dir ',{initialChannelFileDir})
+      //console.log('spynetrait dir ',{initialSpyneTraitFileDir})
+
+
+
+      //console.log('process ',{initialFileDir})
+      expect(initialViewStreamFileDir).to.equal('./src/app/components/')
+      expect(initialDomElementFileDir).to.equal('./src/app/components/')
+      expect(initialChannelFileDir).to.equal('./src/app/channels/')
+      expect(initialSpyneTraitFileDir).to.equal('./src/app/traits/')
+
+    })
+
+    it('it should generate initial value for method prefix', ()=>{
+      MockData.enquirer.answers.className = 'MyCustomTrait';
+      fileType = "SpyneTrait";
+      inputType = "methodPrefix";
+      const initialMethodPrefixFn = new PromptInputField(inputType, fileType, 'initial').field;
+      const initialMethodPrefix = initialMethodPrefixFn(MockData);
+      expect(initialMethodPrefix).to.equal('myCustom$')
+
+
+    })
+
+    it('it should generate initial value for channel name', ()=>{
+      MockData.enquirer.answers.className = 'ChannelCustom';
+      fileType = "Channel";
+      inputType = "channelName";
+      const initialMethodPrefixFn = new PromptInputField(inputType, fileType, 'initial').field;
+      const initialMethodPrefix = initialMethodPrefixFn(MockData);
+
+      //console.log('channel name is ',initialMethodPrefix);
+      expect(initialMethodPrefix).to.equal('CHANNEL_CUSTOM')
+
+    })
+
+
+
+
+
+
+  })
+
+
+  describe('it should add proper validator for field',()=>{
+    const fieldType = 'validate';
+
+    it ('should generate validator for fileName ', ()=>{
+      const fileNameValidatorFn = new PromptInputField("fileName", "ViewStream", fieldType).field;
+      const fileNameValidator = fileNameValidatorFn('my-custom-viewstream.js');
+      //console.log('file name validator is ',{fileNameValidator})
+      expect(fileNameValidator).to.be.true;
+
+    })
+
+    it ('should generate validator for file directory', ()=>{
+      const fileDirectoryValidatorFn = new PromptInputField("fileDirectory", "ViewStream", fieldType).field;
+      const validPath = './src/app/components/'
+      const inValidPath = './src/stuff'
+      const isValidDir = fileDirectoryValidatorFn(validPath);
+      const isInvalidDir = fileDirectoryValidatorFn(inValidPath);
+      expect(isValidDir).to.be.true;
+      expect(isInvalidDir).to.equal("File directory needs to exist.")
+
+    })
+
+
+
+  })
+
+
+
+
+
+});