qtools-functional-library 1.1.10 → 1.1.11

package/README.md

@@ -20,4 +20,9 @@ Most of the functions included in this library (except, eg, qt.log()) are implem
 - qtools-to-key-value-array
 - qtools-to-string
 
+NEW:
+
+- qtools-select-properties
+- qtools-map-properties
+
 DESCRIPTION

package/lib/qtools-map-properties/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "qtools-map-properties",
+  "version": "1.0.0",
+  "description": " Transform and add properties to a javascript object or array of objects",
+  "main": "qtools-map-properties.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "TQ White II",
+  "license": "ISC"
+}

package/lib/qtools-map-properties/qtools-map-properties.js

@@ -0,0 +1,99 @@
+'use strict';
+//START OF moduleFunction() ============================================================
+var moduleFunction = function(args = {}) {
+	const { commonFunctions } = args;
+	
+	const addToPrototypeActual = functionObject => () =>
+		commonFunctions.universalAddToPrototype(commonFunctions, functionObject);
+	
+	
+	
+	//first method definition function ==========================
+	const firstMethodFunction = commonFunctions => {
+		const methodName = 'qtMapProperties';
+		const description = `operand.qtMapProperties() transforms and adds properties to a javascript object or array of objects`;
+		const supportedTypeList = [Array, Object];
+
+		const method = () =>
+			function(mappings = {}, options = {}) {
+				const mappingFunction = item => {
+					const outObj = item.qtClone();
+					const originalThis = item.qtClone();
+
+					// mappingElementFunction=(item, name, entire)=>{}; //note: synthetic elements have item==undefined
+
+					Object.keys(mappings).forEach(name => {
+						if (typeof mappings[name] == 'function') {
+							outObj[name] = mappings[name](
+								originalThis[name],
+								name,
+								originalThis
+							);
+						} else {
+							outObj[name] = mappings[name];
+						}
+					});
+					return outObj;
+				};
+
+				
+				
+				if (this instanceof Array) {
+					return this.map(item => mappingFunction(item));
+				} else {
+					return mappingFunction(this);
+				}
+				
+			};
+
+		const test = args => {
+			return require('./test.js')({
+				...args,
+				...{
+					moduleName: module.id.replace(module.path, '')
+				}
+			});
+		};
+
+		return {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		};
+	};
+	
+	
+	const functionObject = new Map(); // prettier-ignore
+	const addFunction = definition => {
+		const {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		} = definition;
+		functionObject.set(methodName, {
+			description,
+			supportedTypeList,
+			method,
+			test: args => {
+				return require('./test.js')({
+					...args,
+					...{
+						moduleName: module.id.replace(module.path, '')
+					}
+				});
+			}
+		});
+	};
+	
+	addFunction(firstMethodFunction());
+
+	this.addToPrototype = addToPrototypeActual(functionObject);
+	
+};
+//END OF moduleFunction() ============================================================
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();

package/lib/qtools-map-properties/test.js

@@ -0,0 +1,118 @@
+'use strict';
+
+//START OF moduleFunction() ============================================================
+
+const moduleFunction = function(args) {
+	//this module is initialized with parameters spec'd in the main function module
+	
+	const completeStepActual = ({verbose=false, logErrors=false, moduleName}) => (
+		methodName,
+		thisStepMessage,
+		thisStepResult,
+		thisStepEvalFunction
+	) => {
+
+		const thisStepPass = thisStepEvalFunction(thisStepResult);
+		
+		if (logErrors && !thisStepPass) {
+			console.log(`FAIL TEST: ${thisStepMessage} in ...${moduleName}`);
+		}
+		if (verbose) {
+			console.log(`Result for: ${methodName} (${thisStepPass?'PASS':'FAIL'}):`);
+			console.dir(thisStepResult);
+			console.log('\n\n');
+		}
+		
+		return passingTests && thisStepPass;
+	};
+
+	const completeStep = completeStepActual(args);
+
+	let passingTests = true;
+
+	let thisStepMessage;
+	let thisStepResult;
+	let thisStepEvalFunction;
+	let methodName;
+
+	//TESTS ============================================================
+
+	
+	
+	const testObject={
+		one: 1,
+		two: 2
+	}
+	
+	const testArray=[
+	{
+		alpha: 11,
+		beta: 12
+	},{
+		alpha: 21,
+		beta: 22
+	}
+	];
+	
+	const testOneArgument={
+		one: (item, name, entire)=>item*1000
+	}
+	const testTwoArgument={
+		one: (item, name, entire)=>item*1000,
+		addedValue:(item, name, entire)=>`${name} says, item:${item} becomes ${Object.keys(entire).join(', ')}`
+	}
+	const testThreeArgument={
+		alpha: (item, name, entire)=>item*1000,
+		addedValue:(item, name, entire)=>`${name} says, item:${item} becomes ${Object.keys(entire).join(', ')}`
+	}
+// map one object 
+// map one with added property
+// map array 
+
+
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtMapProperties'
+	thisStepMessage = "did not get map one object ";
+	thisStepResult = testObject[methodName](testOneArgument);
+	thisStepEvalFunction = item => (item.one==1000 && item.two==2);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtMapProperties'
+	thisStepMessage = "did not map one with added property";
+	thisStepResult = testObject[methodName](testTwoArgument);
+	thisStepEvalFunction = item => (item.one==1000 && item.two==2 && item.addedValue=='addedValue says, item:undefined becomes one, two');
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtMapProperties'
+	thisStepMessage = "did not map array woth added property";
+	thisStepResult = testArray[methodName](testThreeArgument);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11000 &&
+		item[0].beta==12 &&
+		item[0].addedValue=='addedValue says, item:undefined becomes alpha, beta' &&
+		item[1].alpha==21000 &&
+		item[1].beta==22 &&
+		item[1].addedValue=='addedValue says, item:undefined becomes alpha, beta'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+	
+	return passingTests;
+};
+
+//END OF moduleFunction() ============================================================
+
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();
+

package/lib/qtools-merge/test.js

@@ -123,10 +123,6 @@ const moduleFunction = function(args) {
 	methodName='qtMerge'
 	thisStepMessage = "Failed to replace base type with complex one or vice versa";
 	thisStepResult = arrayTestA[methodName](arrayTestE, {mergeNonExistent:true});
-thisStepResult.qtDump({label:"thisStepResult"});
-
-
-
 	thisStepEvalFunction = item => 
 		item.qtGetSurePath('c.arrayOfBasicTypes[0]')=='replacesFirst' &&
 		item.qtGetSurePath('c.arrayOfBasicTypes[1]')=='second';

package/lib/qtools-select-properties/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "qtools-select-properties",
+  "version": "1.0.0",
+  "description": "Create new objects (or list of objects) containing only the enumerated properties. Allows defaults to be supplied for missing properties. If an enumerated property name does not exist at all, a property with the default value is created.",
+  "main": "qtools-select-properties.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "TQ White II",
+  "license": "ISC"
+}

package/lib/qtools-select-properties/qtools-select-properties.js

@@ -0,0 +1,132 @@
+'use strict';
+//START OF moduleFunction() ============================================================
+var moduleFunction = function(args = {}) {
+	const { commonFunctions } = args;
+	
+	const addToPrototypeActual = functionObject => () =>
+		commonFunctions.universalAddToPrototype(commonFunctions, functionObject);
+	
+	
+	
+	//first method definition function ==========================
+	const firstMethodFunction = commonFunctions => {
+		const methodName = 'qtSelectProperties';
+		const description = `operand.qtSelectProperties(value) create snew objects (or list of objects) containing only the enumerated properties. Allows defaults to be supplied for missing properties. If an enumerated property name does not exist at all, a property with the default value is created.`;
+		const supportedTypeList = [Array, Object];
+
+		const method = () =>
+			function(keepers, options = {}) {
+				
+				const {
+					moreDefaultValues = {},
+					omitUndefined = true,
+					excludeMode = false
+				} = options;
+
+				if (!(keepers instanceof Object)) {
+					throw new Error(
+						'qtSelectProperties() argument one must be instance of Object or Array'
+					);
+				}
+
+				let inclusions = keepers;
+				let defaultValues = {};
+				if (!(keepers instanceof Array)) {
+					inclusions = Object.keys(keepers);
+					defaultValues = keepers;
+				}
+				
+				Object.keys(moreDefaultValues).forEach(
+					name => (defaultValues[name] = moreDefaultValues[name])
+				);
+
+				const selectingFunction = currentObject => {
+					const getDefault = (currentObject, keeperName) =>
+						typeof defaultValues[keeperName] == 'function'
+							? defaultValues[keeperName](currentObject.qtClone(), keeperName)
+							: defaultValues[keeperName];
+
+					// defaultFunction=(currentObject, elementName)=>{}
+
+					let outObj = {};
+
+					if (!excludeMode) {
+						inclusions.forEach(keeperName => {
+							const newValue =
+								typeof currentObject[keeperName] != 'undefined'
+									? currentObject[keeperName]
+									: getDefault(currentObject, keeperName);
+							if (typeof newValue != 'undefined' || !omitUndefined) {
+								outObj[keeperName] = newValue;
+							}
+						});
+					} else {
+						outObj = currentObject;
+						inclusions.forEach(keeperName => {
+							if (typeof (outObj[keeperName] == 'undefined')) {
+								delete outObj[keeperName];
+							}
+						});
+					}
+
+					return outObj;
+				};
+				
+
+				if (this instanceof Array) {
+					return this.map(item => selectingFunction(item));
+				} else {
+					return selectingFunction(this);
+				}
+			};
+
+		const test = args => {
+			return require('./test.js')({
+				...args,
+				...{
+					moduleName: module.id.replace(module.path, '')
+				}
+			});
+		};
+
+		return {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		};
+	};
+	
+	const functionObject = new Map(); // prettier-ignore
+	const addFunction = definition => {
+		const {
+			methodName,
+			description,
+			supportedTypeList,
+			method,
+			test
+		} = definition;
+		functionObject.set(methodName, {
+			description,
+			supportedTypeList,
+			method,
+			test: args => {
+				return require('./test.js')({
+					...args,
+					...{
+						moduleName: module.id.replace(module.path, '')
+					}
+				});
+			}
+		});
+	};
+	
+	addFunction(firstMethodFunction());
+
+	this.addToPrototype = addToPrototypeActual(functionObject);
+	
+};
+//END OF moduleFunction() ============================================================
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();

package/lib/qtools-select-properties/test.js

@@ -0,0 +1,156 @@
+'use strict';
+
+//START OF moduleFunction() ============================================================
+
+const moduleFunction = function(args) {
+	//this module is initialized with parameters spec'd in the main function module
+	
+	const completeStepActual = ({verbose=false, logErrors=false, moduleName}) => (
+		methodName,
+		thisStepMessage,
+		thisStepResult,
+		thisStepEvalFunction
+	) => {
+
+		const thisStepPass = thisStepEvalFunction(thisStepResult);
+		
+		if (logErrors && !thisStepPass) {
+			console.log(`FAIL TEST: ${thisStepMessage} in ...${moduleName}`);
+		}
+		if (verbose) {
+			console.log(`Result for: ${methodName} (${thisStepPass?'PASS':'FAIL'}):`);
+			console.dir(thisStepResult);
+			console.log('\n\n');
+		}
+		
+		return passingTests && thisStepPass;
+	};
+
+	const completeStep = completeStepActual(args);
+
+	let passingTests = true;
+
+	let thisStepMessage;
+	let thisStepResult;
+	let thisStepEvalFunction;
+	let methodName;
+
+	//TESTS ============================================================
+
+	
+	const testObject={
+		one: 1,
+		two: 2
+	}
+	
+	const testArray=[
+	{
+		alpha: 11,
+		beta: 12,
+		gamma:13
+	},{
+		alpha: 21,
+		gamma:23
+	}
+	];
+	
+	const testOneArgument=[ 'one'];
+	const testTwoArgument=['alpha'];
+	
+	const testThreeArgument=['alpha', 'beta'];
+	const testThreeMoreValues={moreDefaultValues:{beta:(currentObject, elementName)=>`default function ${elementName} produces ${Object.keys(currentObject).join(', ')}`}}
+	
+	const testFourArgument={
+		alpha: (item, name, entire)=>item*1000,
+		addedValue:(item, name, entire)=>`${name} says, item:${item} becomes ${Object.keys(entire).join(', ')}`
+	}
+	
+	const testFiveArgument={
+		alpha: 'eleven',
+		beta: 'twelve'
+	}
+	
+// array of strings for one object 
+// array of strings for array of objects
+// array of strings for one object with moreDefaultValues
+// object with defaults for object 
+// EXCLUDE MODE
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get array of strings for one object ";
+	thisStepResult = testObject[methodName](testOneArgument);
+	thisStepEvalFunction = item => (item.one==1 && typeof(item.two)=='undefined');
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests; 
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get array of strings for array of objects";
+	thisStepResult = testArray[methodName](testTwoArgument);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11 &&
+		typeof(item[0].beta)=='undefined' &&
+		item[1].alpha==21 &&
+		typeof(item[1].beta)=='undefined'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests; 
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get array of strings for one object with moreDefaultValues";
+	thisStepResult = testArray[methodName](testThreeArgument, testThreeMoreValues);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11 &&
+		item[0].beta==12 &&
+		item[1].alpha==21 &&
+		item[1].beta=='default function beta produces alpha, gamma'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get object argument containing defaults";
+	thisStepResult = testArray[methodName](testFiveArgument);
+	thisStepEvalFunction = item => (
+		item[0].alpha==11 &&
+		item[0].beta==12 &&
+		item[1].alpha==21 &&
+		item[1].beta=='twelve'
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+
+	//TEST ITEM ------------------------------------------------------
+	methodName='qtSelectProperties'
+	thisStepMessage = "did not get EXCLUDE MODE";
+	thisStepResult = testArray[methodName](testThreeArgument, {excludeMode:true});
+	thisStepEvalFunction = item => (
+		typeof(item[0].alpha)=='undefined' &&
+		typeof(item[0].beta)=='undefined' &&
+		item[0].gamma==13 &&
+		typeof(item[1].alpha)=='undefined' &&
+		typeof(item[1].beta)=='undefined' &&
+		item[1].gamma==23
+	);
+	passingTests =
+		completeStep(methodName, thisStepMessage, thisStepResult, thisStepEvalFunction) &&
+		passingTests;
+	
+	
+	
+
+	return passingTests;
+};
+
+//END OF moduleFunction() ============================================================
+
+module.exports = moduleFunction;
+//module.exports = new moduleFunction();
+

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "qtools-functional-library",
-  "version": "1.1.10",
+  "version": "1.1.11",
   "description": "Useful additions to JS prototypes to facilliate chainable, functional (mostly) style. Also make life more convenient.\"",
   "main": "qtools-functional-library.js",
   "scripts": {
     "sample": "node test.js -listTests -logErrors -verbose --methodList=qtClone,qtToString,qtPop",
     "sample2": "node test.js -listTests -logErrors --methodList=qtClone,qtToString,qtPop",
     "logTest": "node --trace-uncaught test.js -listTests -logErrors --methodList=qtLog",
-    "test": "node test.js -verbose -logErrors",
+    "test": "node test.js -logErrors",
     "quiet": "node test.js -listTests -logErrors"
   },
   "repository": {

package/test.js

@@ -8,7 +8,6 @@ const verbose=process.argv.filter(item=>item.match(/verbose/i))[0]?true:false
 const logErrors=process.argv.filter(item=>item.match(/logErrors/i))[0]?true:false
 const listTests=process.argv.filter(item=>item.match(/listTests/i))[0]?true:false
 
-
 const methodList=process.argv
 	.qtClone() //create a deep copy so changes can't leak back to the source
 	.filter(item=>item.match(/^--methodList/)) //['--methodList=qtClone,qtToString,qtPop']
@@ -21,7 +20,28 @@ const methodList=process.argv
 
 const result=qt.test({logErrors, verbose, methodList, listTests});
 console.log(result?"PASSED ALL TESTS":"");
-console.log("note: npm test runs all tests. For subset, type, eg, node test.js -listTests -logErrors -verbose --methodList=qtNumberKeysToArray")
 
+const showAdditionalInfo=(verbose, result)=>{
+console.log(`result=${result}`);
+
+if (!verbose && result){
+	return;
+}
+console.log(`
+
+Additional Usage:
+npm logTest; #node --trace-uncaught test.js -listTests -logErrors --methodList=qtLog
+npm test; #node test.js -verbose -logErrors
+npm quiet; #node test.js -listTests -logErrors
+
+# -logErrors shows the message from any failing tests
+
+or find .../qtools-functional-library/test.js and execute, eg,
+    cd .../qtools-functional-library/test.js;
+    node test.js --methodList=qtMapProperties
+    `)
+    
+    }
+showAdditionalInfo(verbose, result)
 
 process.exit(result?0:1);