spyne 0.19.0 → 0.20.0

package/src/spyne/utils/spyne-plugins-methods.js

@@ -1,97 +1,72 @@
-const _pluginMethodsObj = Object.create({});
+import { allPass, compose, is, keys, not, prop } from 'ramda'
 
-_pluginMethodsObj['foo'] = ()=>console.log("used for testing purposes.");
+const _pluginMethodsObj = Object.create({})
 
-import {allPass, compose, is, isEmpty, keys, not, prop} from 'ramda';
-
-
-const isNotArr = compose(not, is(Array));
-const isNotEmpty = compose(not, isEmpty);
-const isNonEmptyStr = allPass([is(String), isNotEmpty]);
-const isNonEmptyArr = allPass([is(Array), isNotEmpty]);
+const isNotArr = compose(not, is(Array))
+// const isNotEmpty = compose(not, isEmpty)
+// const isNonEmptyStr = allPass([is(String), isNotEmpty])
+// const isNonEmptyArr = allPass([is(Array), isNotEmpty])
 const isObjectFn = compose(allPass([isNotArr, is(Object)]))
-const isNonEmptyObjectFn = compose(allPass([isNotEmpty, isNotArr, is(Object)]))
-
-
-export class SpynePluginsMethods{
-
-
-  constructor(){
-
-
+// const isNonEmptyObjectFn = compose(allPass([isNotEmpty, isNotArr, is(Object)]))
 
+export class SpynePluginsMethods {
+  constructor() {
+    _pluginMethodsObj.foo = () => console.log('used for testing purposes.')
   }
 
-
-
-  addMethod(key, fn, test=false){
-
-    if (Object.prototype.hasOwnProperty.call(_pluginMethodsObj, key)===true){
-      const warnStr = `Spyne Warning: the method name, ${key}, already exists.`;
-      if (test){
-        return warnStr;
+  addMethod(key, fn, test = false) {
+    if (Object.prototype.hasOwnProperty.call(_pluginMethodsObj, key) === true) {
+      const warnStr = `Spyne Warning: the method name, ${key}, already exists.`
+      if (test) {
+        return warnStr
       }
-      console.warn(warnStr);
+      console.warn(warnStr)
     } else {
-      _pluginMethodsObj[key] = fn;
+      _pluginMethodsObj[key] = fn
     }
-
   }
 
+  addMethods(methodsObj = {}, test = false) {
+    let warnStr
 
-  addMethods(methodsObj={}, test=false){
-
-    let warnStr;
+    const isObj = isObjectFn(methodsObj)
 
-    const isObj = isObjectFn(methodsObj);
-
-    if (isObj === false){
+    if (isObj === false) {
       warnStr = `Spyne Warning: the pluginMethods property, ${JSON.stringify(methodsObj)} needs to be an object.`
-      if (test){
-        return warnStr;
+      if (test) {
+        return warnStr
       }
-      console.warn(warnStr);
-      return;
-
+      console.warn(warnStr)
+      return
     }
 
     const checkEachKeyForValidMethod = (keyStr) => {
-      const methodVal = prop(keyStr, methodsObj);
-
-      const isFunction = typeof(methodVal) === 'function';
+      const methodVal = prop(keyStr, methodsObj)
 
+      const isFunction = typeof (methodVal) === 'function'
 
-      if (isFunction){
-        this.addMethod(keyStr, methodVal, test);
-      } else{
+      if (isFunction) {
+        this.addMethod(keyStr, methodVal, test)
+      } else {
         warnStr = `the value for ${keyStr} is not a valid function.`
-        if (test){
-          return warnStr;
+        if (test) {
+          return warnStr
         } else {
-          console.warn(warnStr);
+          console.warn(warnStr)
         }
       }
-
     }
 
-    const methodKeys = keys(methodsObj);
-
-    return methodKeys.map(checkEachKeyForValidMethod).join(',');
+    const methodKeys = keys(methodsObj)
 
+    return methodKeys.map(checkEachKeyForValidMethod).join(',')
   }
 
-  checkIfMethodExists(key){
+  checkIfMethodExists(key) {
 
   }
 
-
-  get pluginMethodsObj(){
-    return _pluginMethodsObj;
+  get pluginMethodsObj() {
+    return _pluginMethodsObj
   }
-
-
-
-
-
-
 }

package/src/spyne/utils/spyne-trait.js

@@ -1,5 +1,5 @@
-import { getAllMethodNames } from './frp-tools';
-import {reject, curryN, __, map} from 'ramda';
+import { getAllMethodNames } from './frp-tools'
+import { reject, curryN, __, map } from 'ramda'
 
 export class SpyneTrait {
   /**
@@ -17,72 +17,72 @@ export class SpyneTrait {
    */
 
   constructor(parentContext, prefix = '', autoInit = true) {
-    this.parentContext = parentContext;
+    this.parentContext = parentContext
     this.omittedMethods = [
       'autoBinder',
       'initAutoBinder',
       'getEnhancerMethods',
       'checkForMalformedMethods',
-        'caller',
-        'arguments',
-      'bindParentViewStream'];
+      'caller',
+      'arguments',
+      'bindParentViewStream']
 
-    this.prefix = prefix;
+    this.prefix = prefix
 
     if (autoInit === true) {
-      this.autoBinder();
+      this.autoBinder()
     }
-    return this.allMethodsList;
+    return this.allMethodsList
   }
 
   initAutoBinder() {
-     this.autoBinder();
+    this.autoBinder()
   }
 
   getEnhancerMethods() {
-    return getAllMethodNames(this, this.omittedMethods);
+    return getAllMethodNames(this, this.omittedMethods)
   }
 
   checkForMalformedMethods(methodsArr) {
     if (this.prefix === '') {
-      console.warn(`SPYNE WARNING: The following SpyneTrait ${this.constructor.name} needs a prefix`);
-      return;
+      console.warn(`SPYNE WARNING: The following SpyneTrait ${this.constructor.name} needs a prefix`)
+      return
     }
-    //let reStr = `^(${this.prefix})(.*)$`;
-    //let re = new RegExp(reStr);
-    const hasPrefix = (str)=>str.indexOf(this.prefix)===0;
+    // let reStr = `^(${this.prefix})(.*)$`;
+    // let re = new RegExp(reStr);
+    const hasPrefix = (str) => str.indexOf(this.prefix) === 0
 
-    let malformedMethodsArr = reject(hasPrefix, methodsArr);
+    const malformedMethodsArr = reject(hasPrefix, methodsArr)
     if (malformedMethodsArr.length >= 1) {
-      let warningStr = `Spyne Warning: The following method(s) in ${this.constructor.name} require the prefix, "${this.prefix}": [${malformedMethodsArr.join(', ')}];`;
-      console.warn(warningStr);
+      const warningStr = `Spyne Warning: The following method(s) in ${this.constructor.name} require the prefix, "${this.prefix}": [${malformedMethodsArr.join(', ')}];`
+      console.warn(warningStr)
     }
   }
 
   bindParentViewStream(methodsObj, context) {
-    this.checkForMalformedMethods(methodsObj.allMethods);
-      let obj = {};
+    this.checkForMalformedMethods(methodsObj.allMethods)
+    const obj = {}
     const bindMethodsToParentViewStream = (str, isStatic = false) => {
-      let constructorType = isStatic === true ? this.constructor : this;
-      let propertyType = typeof (constructorType[str]);
+      const constructorType = isStatic === true ? this.constructor : this
+      const propertyType = typeof (constructorType[str])
       if (propertyType === 'function') {
-         obj[str] = context[str] = constructorType[str].bind(context);
+        obj[str] = context[str] = constructorType[str].bind(context)
       }
-    };
+    }
 
-    const bindCurry = curryN(2, bindMethodsToParentViewStream);
-    const bindStaticMethodsToParentViewStream = bindCurry(__, true);
+    const bindCurry = curryN(2, bindMethodsToParentViewStream)
+    const bindStaticMethodsToParentViewStream = bindCurry(__, true)
     // MAP STATIC METHODS
-    map(bindStaticMethodsToParentViewStream, methodsObj.staticMethods);
+    map(bindStaticMethodsToParentViewStream, methodsObj.staticMethods)
     // MAP MAIN METHODS
-    map(bindMethodsToParentViewStream, methodsObj.methods);
-    return obj;
+    map(bindMethodsToParentViewStream, methodsObj.methods)
+    return obj
   }
 
   autoBinder() {
-    let allMethods = this.getEnhancerMethods();
+    const allMethods = this.getEnhancerMethods()
     // console.log('all ',allMethods);
-    this.allMethodsList = this.bindParentViewStream(allMethods, this.parentContext);
-    return this.allMethodsList;
+    this.allMethodsList = this.bindParentViewStream(allMethods, this.parentContext)
+    return this.allMethodsList
   }
 }