spyne-cli 0.3.0

package/src/spyne-file-prompt.js

@@ -0,0 +1,63 @@
+import enquirer from 'enquirer';
+const {prompt, Select} = enquirer;
+
+import {Data} from './spyne-template-prompts.js';
+const {promptInputHash} = Data;
+import GeneratePromptInputObject from './templates/generate-prompt-input-object.js';
+import GenerateFileString from './templates/generate-file-string.js';
+import {onSaveSpyneFileToDir} from './utils/file-utils.js';
+import {generatePromptOutput} from './templates/generate-prompt-output.js';
+
+export default class SpyneFilePrompt {
+
+  constructor(props) {
+
+  }
+
+  static getFilePromptPropertiesObj(fileType) {
+    return promptInputHash[fileType];
+
+  }
+
+  static getFilePrompt(fileType) {
+    const mapInputTypesToPrompObj = (inputType) => {
+      return new GeneratePromptInputObject(inputType,
+          fileType).getPrompObject();
+    };
+
+    const filePropsObj = SpyneFilePrompt.getFilePromptPropertiesObj(fileType);
+    const {props} = filePropsObj;
+    return props.map(mapInputTypesToPrompObj);
+  }
+
+  getSelectPromptObj() {
+    const promptGen = new GeneratePromptInputObject('selectFileType');
+    return promptGen.getPrompObject();
+
+  }
+
+  saveFileAndSendOutput(answers) {
+    const {fileType, fileName, fileDirectory} = answers;
+    const {fileString} = new GenerateFileString(fileType, answers);
+    const savedProps = onSaveSpyneFileToDir(fileString, fileName, fileDirectory);
+    const msgOutput = generatePromptOutput(answers, savedProps, fileString);
+    console.log(msgOutput);
+  }
+
+  async startPrompt() {
+    const selectPromptObj = this.getSelectPromptObj();
+    //console.log('select prompt obj is ',selectPromptObj);
+    const selectPrompt = new Select(selectPromptObj);
+    const onSelectComplete = async (fileType) => {
+      const filePromptArr = SpyneFilePrompt.getFilePrompt(fileType);
+      //console.log("promp arr is ",filePromptArr);
+      const filePrompt = await prompt(filePromptArr);
+      const answersObj = Object.assign({}, filePrompt, {fileType});
+      this.saveFileAndSendOutput(answersObj);
+    };
+
+    selectPrompt.run().then(onSelectComplete);
+
+  }
+
+};

package/src/spyne-template-prompts.js

@@ -0,0 +1,171 @@
+const Data = {
+  "debug": true,
+  "appPath": "./src/app/",
+  "init": {
+    "promptName": "fileType",
+    "type": "Select",
+    "message": "Select a file type",
+    "choices": [
+      "ViewStream",
+      "Channel",
+      "SpyneTrait",
+      "DomElement"
+    ]
+  },
+  "inputTypesArr": [
+    "selectFileType",
+    "fileName",
+    "className",
+    "fileDirectory",
+    "methodPrefix",
+    "channelName",
+    "replayLastPayload"
+  ],
+  "fileTypesArr": [
+    "ViewStream",
+    "DomElement",
+    "Channel",
+    "SpyneTrait"
+  ],
+  "fieldTypesArr": [
+    "type",
+    "name",
+    "format",
+    "result",
+    "resultFileName",
+    "message",
+    "choices",
+    "initial",
+    "hint",
+    "validate"
+  ],
+  "promptTypes": [
+    
+    {
+      "inputType" : "selectFileType",
+      "type" : "Select",
+      "fields" : [
+        "name", 
+        "message", 
+        "choices", 
+        "result"
+      ]
+      
+    },
+
+    {
+      "inputType": "fileName",
+      "fields": [
+        "name",
+        "format",
+        "result",
+        "initial",
+        "message",
+        "validate"
+      ]
+    },
+    {
+      "inputType": "className",
+      "fields": [
+        "name",
+        "format",
+        "result",
+        "initial",
+        "message"
+      ]
+    },
+    {
+      "inputType": "fileDirectory",
+      "fields": [
+        "name",
+        "format",
+        "result",
+        "initial",
+        "message",
+        "validate"
+      ]
+    },
+    {
+      "inputType": "channelName",
+      "fields": [
+        "name",
+        "format",
+        "result",
+        "initial",
+        "message"
+      ]
+    },
+    {
+      "inputType": "methodPrefix",
+      "fields": [
+        "name",
+        "format",
+        "result",
+        "initial",
+        "message"
+      ]
+    },
+    {
+      "inputType": "replayLastPayload",
+      "type" : "Confirm",
+      "fields": [
+        "name",
+        "format",
+        "result",
+        "message"
+      ]
+    }
+  ],
+  "promptProperties": {
+    "fileName": [],
+    "className": [],
+    "fileDirectory": [],
+    "methodPrefix": [],
+    "channelName": [],
+    "replayLastPayload": []
+  },
+  "promptInputHash": {
+    "ViewStream": {
+      "path": "components/",
+      "props": [
+        "fileName",
+        "className",
+        "fileDirectory"
+      ],
+      "promptArr": []
+    },
+    "DomElement": {
+      "path": "components/",
+      "props": [
+        "fileName",
+        "className",
+        "fileDirectory"
+      ],
+      "promptArr": []
+    },
+    "Channel": {
+      "path": "channels/",
+      "props": [
+        "fileName",
+        "className",
+        "channelName",
+        "replayLastPayload",
+        "fileDirectory"
+      ],
+      "promptArr": []
+    },
+    "SpyneTrait": {
+      "path": "traits/",
+      "props": [
+        "fileName",
+        "className",
+        "methodPrefix",
+        "fileDirectory"
+      ],
+      "promptArr": []
+    }
+  }
+}
+
+
+export {Data}

package/src/templates/generate-file-string.js

@@ -0,0 +1,131 @@
+const _viewStreamTemplate = (props)=> {
+ return `import {ViewStream} from 'spyne';
+
+export class ${props.className} extends ViewStream {
+    
+    constructor(props={}) {
+        
+        super(props);
+    }
+    
+    addActionListeners() {
+        // return nexted array(s)
+        return [];
+    }
+    
+    broadcastEvents() {
+        // return nexted array(s)
+        return [];
+    }
+   
+    onRendered() {
+    
+    }
+    
+}
+
+`
+}
+
+const _domElementTemplate = (props) => {
+  return `import {DomElement} from 'spyne';
+  
+export class ${props.className} extends DomElement {
+  
+  constructor(props={}) {
+        
+    super(props);
+  }
+  
+}
+
+`
+}
+
+
+const _channelTemplate = (props)=> {
+  return `import {Subject} from 'rxjs';
+import {Channel} from 'spyne';
+
+export class ${props.className} extends Channel{
+
+  constructor(name, props={}) {
+    name="${props.channelName}";
+    props.sendCachedPayload = ${props.replayLastPayload};
+    
+    super(name, props);
+  }
+
+  onRegistered(){
+    
+  }
+
+  addRegisteredActions() {
+    
+    return [];
+  }
+
+  onViewStreamInfo(obj) {
+    let data = obj.props();
+  }
+  
+}
+
+`
+}
+
+const _spyneTraitTemplate = (props)=>{
+  return `import {SpyneTrait} from 'spyne';
+
+export class ${props.className} extends SpyneTrait {
+
+  constructor(context){
+    let traitPrefix = "${props.methodPrefix}";
+    
+    super(context, traitPrefix);
+  }
+  
+  static ${props.methodPrefix}HelloWorld(){
+    return "Hello World";
+  }
+  
+}
+
+`
+}
+
+
+
+
+export default class GenerateFileString {
+
+  constructor(fileTypeName, fileProps) {
+    this._fileTypeName = fileTypeName;
+    this._fileProps = fileProps;
+  }
+
+  get fileString(){
+
+    const methodFn = GenerateFileString.getFileTemplate(this._fileTypeName)
+     this._fileStr = methodFn(this._fileProps);
+    return this._fileStr;
+  }
+
+
+  static getFileTemplate(str){
+
+    const fileTypeHashObj = {
+      ViewStream: _viewStreamTemplate,
+      DomElement: _domElementTemplate,
+      Channel: _channelTemplate,
+      SpyneTrait: _spyneTraitTemplate
+    }
+
+    return fileTypeHashObj[str];
+
+  }
+
+
+
+
+}

package/src/templates/generate-prompt-input-fields.js

@@ -0,0 +1,256 @@
+import {Data} from '../spyne-template-prompts.js';
+import ErrorLogger  from '../utils/error-logger.js';
+
+const {
+  appPath,
+  promptInputHash,
+  inputTypesArr,
+  fileTypesArr,
+  fieldTypesArr,
+} = Data;
+
+import enquirer from 'enquirer';
+const {prompt, Select} = enquirer;
+
+import c from 'ansi-colors';
+import R  from 'ramda';
+import {getLocalFileDirectory, validateFileDirectory} from '../utils/file-utils.js';
+import changeCase from 'change-case';
+
+const {
+  camelCase,
+  capitalCase,
+  constantCase,
+  dotCase,
+  headerCase,
+  noCase,
+  paramCase,
+  pascalCase,
+  pathCase,
+  sentenceCase,
+  snakeCase,
+} = changeCase;
+
+const validateFieldFn = R.curry((arr, type, value) => {
+  const isValid = arr.indexOf(value) >= 0;
+  if (isValid) {
+    return value;
+  } else if (_inputType !== 'selectFileType') {
+    ErrorLogger.log(`value, ${value}, for ${type} is not valid`,
+        'validateProps');
+  }
+
+});
+
+const isInitSelect = () => _inputType === 'selectFileType';
+
+const validateInputType = validateFieldFn(inputTypesArr, 'inputType');
+const validateFileType = validateFieldFn(fileTypesArr, 'fileType') ||
+    isInitSelect();
+const validateFieldType = validateFieldFn(fieldTypesArr, 'fieldType');
+const messageColor = c.blueBright;
+const answerColor = c.greenBright;
+
+const messageMapColor = (m) => c.blueBright(m);
+const choicesMapColor = (choice) => {
+  return c.greenBright(choice)
+};
+
+
+const choicesResultParseFileName = (choice) => {
+  const fileNameIsValid = validteJsSuffix(choice);
+  choice = fileNameIsValid === true ? choice : choice+".js";
+  return c.unstyle(c.greenBright(choice))
+};
+
+const choicesResultParse = (choice, args) => {
+  return c.unstyle(c.greenBright(choice))
+};
+const validatorLength = value => String(value).length > 3;
+
+let _inputType;
+let _fileType;
+let _fieldType;
+let _type = 'input';
+let _name;
+let _message;
+let _format;
+let _result;
+let _initial;
+let _hint;
+let _validateMethod;
+let _options;
+
+let _field;
+
+const generateName = () => {
+  return 'thename';
+};
+
+const pathProp = (arr) => R.path(arr);
+
+const dataProp = (prop) => pathProp(['enquirer', 'answers', prop]);
+
+const toPascalCase = (str) => {
+  const fileNoSuffix = String(str).replace(/^(.*)(.js)$/, '$1');
+  return pascalCase(fileNoSuffix);
+};
+
+const toConstantCase = (data) => {
+  let classNameStr = dataProp('className')(data);
+  if (String(classNameStr).toLowerCase().indexOf('channel') !== 0) {
+    classNameStr = 'Channel' + classNameStr;
+  }
+  return constantCase(classNameStr);
+};
+
+const generateMethodPrefix = (data) => {
+  let classNameAnswer = dataProp('className')(data);
+  const classNameSentence = sentenceCase(classNameAnswer);
+  const classNameArr = String(classNameSentence).split(' ');
+  const len = classNameArr.length >= 2 ? 2 : 1;
+  const splitArr = R.slice(0, len, classNameArr);
+  return `${camelCase(splitArr.join('-'))}$`;
+};
+
+const generateInitialFileName = () => {
+  const initialFileNameHash = {
+    ViewStream: 'my-ui-el-view.js',
+    DomElement: 'my-dom-element.js',
+    Channel: 'channel-custom.js',
+    SpyneTrait: 'my-custom-trait.js',
+  };
+
+  return initialFileNameHash[_fileType];
+
+};
+
+const validteJsSuffix = (value) => {
+  const isValid = /(.*)(.js)/.test(value);
+  return isValid || 'file needs to end in .js';
+};
+
+const generateValidatorFn = () => {
+  const inputTypeHash = {
+    fileName: validteJsSuffix,
+    fileDirectory: validateFileDirectory,
+
+  };
+  const fn = inputTypeHash[_inputType];
+  return fn;
+};
+
+const generateInitial = () => {
+  const inputTypeHash = {
+
+    fileName: generateInitialFileName(),
+    className: R.compose(toPascalCase, dataProp('fileName')),
+    fileDirectory: getLocalFileDirectory(_fileType),
+    methodPrefix: generateMethodPrefix,
+    channelName: toConstantCase,
+
+  };
+
+  const fn = inputTypeHash[_inputType];
+
+  return fn;
+
+};
+
+const generateChoices = () => {
+  const inputTypeHash = {
+    selectFileType: fileTypesArr.map(choicesMapColor),
+
+  };
+
+  const fn = inputTypeHash[_inputType];
+  return fn;
+
+};
+
+const generateMesage = () => {
+
+  const defaultMsgFn = messageColor(`Enter the ${_fileType} file name`);
+
+  const inputTypeHash = {
+    selectFileType: messageColor(`Select file type`),
+    fileName: defaultMsgFn,
+    className: messageColor(`Enter the ${_fileType} class name`),
+    fileDirectory: messageColor(`Enter where you would like to save the ${_fileType} file`),
+    methodPrefix: messageColor(`Enter the string to be prepended to all trait methods`),
+    channelName: (d) => messageColor(R.compose(R.concat('Enter the channel name for '), R.path(['answers', 'className']))(d)),
+    replayLastPayload: messageColor(`This property determines if new subscribers receive the previous payload`),
+  };
+
+  const fn = inputTypeHash[_inputType];
+  return fn;
+};
+
+const getType = () => 'input';
+const getName = () => _inputType;
+const getFormatFn = () => choicesMapColor;
+const getResultFn =       () =>   choicesResultParse;
+const getResultFileNameFn = () => choicesResultParseFileName;
+const getInitial = () => 'initial options';
+const getHint = () => 'custom hint';
+const getMessage = () => generateMesage();
+const getValidattionFn = () => generateValidatorFn();
+
+
+
+export default class PromptInputField {
+
+  constructor(inputType, fileType, fieldType, options = {}) {
+    _inputType = validateInputType(inputType);
+    _fileType = validateFileType(fileType);
+    _fieldType = validateFieldType(fieldType);
+    _options = options;
+    //console.log('intput type is ', {_inputType, _fileType, _fieldType, inputTypesArr})
+    this.generateField();
+  }
+
+
+
+  generateField() {
+
+    const checkForCustomFileNameResult = ()=>{
+      const isFileNameInput =    _inputType === 'fileName';
+      const isResultMethodType = _fieldType === 'result';
+      const isCustomFileNameResult = isFileNameInput && isResultMethodType;
+      _fieldType = isCustomFileNameResult ? "resultFileName" : _fieldType;
+    }
+
+
+
+    const fieldMethodHash = {
+      type: getType,
+      name: getName,
+      format: getFormatFn,
+      result: getResultFn,
+      resultFileName: getResultFileNameFn,
+      message: getMessage,
+      initial: generateInitial,
+      hint: getHint,
+      choices: generateChoices,
+      validate: getValidattionFn,
+    };
+
+    //checkForCustomFileNameResult();
+
+    const fieldMethod = fieldMethodHash[_fieldType];
+    _field = fieldMethod();
+
+  }
+
+  get field() {
+    return _field;
+  }
+
+};
+
+
+
+
+
+
+

package/src/templates/generate-prompt-input-object.js

@@ -0,0 +1,46 @@
+import {Data} from '../spyne-template-prompts.js';
+const {promptTypes} = Data;
+import PromptInputField from './generate-prompt-input-fields.js';
+
+import enquirer from 'enquirer';
+const {prompt} = enquirer;
+import R from 'ramda';
+import fs from 'fs';
+import color from 'ansi-colors';
+
+let _inputType;
+let _fileType;
+let _type = "input";
+let _promptObjSettings;
+let _promptObj;
+
+export default class GeneratePromptInputObject{
+
+  constructor(inputType, fileType, props={}) {
+    _inputType = inputType;
+    _fileType = fileType;
+    _promptObjSettings = GeneratePromptInputObject.getPromptObjSettings();
+    //console.log("PROMPT SETTINGS ",{_promptObjSettings,_inputType, promptTypes})
+  }
+
+  getPrompObject() {
+    const {fields, type} = _promptObjSettings;
+
+    const fieldsObj = {};
+    fieldsObj['type'] = type || 'input';
+
+    const reducer = (acc={}, key)=>{
+      acc[key]=  new PromptInputField(_inputType, _fileType, key).field;
+      return acc;
+    }
+
+    return _promptObjSettings.fields.reduce(reducer, fieldsObj);
+  }
+
+  static getPromptObjSettings(){
+   return R.compose(R.head, R.filter(R.propEq('inputType', _inputType)))(promptTypes);
+  }
+
+}
+
+