implab/implabjs-core Commit - r4:f88a0de08cfb

improved core/build.gradle script

cin -

r4:f88a0de08cfb default

parent child

Context file:

r4:f88a0de08cfb

Collapse all files

.eslintrc.json created 644 +27 0

@@ -0,0 +1,27
	1	{
	2	"env": {
	3	"browser": true,
	4	"commonjs": true,
	5	"amd": true,
	6	"node": true
	7	},
	8	"parserOptions": {
	9	"ecmaFeatures": {
	10	"jsx": true
	11	},
	12	"sourceType": "module"
	13	},
	14	"extends": "eslint:recommended",
	15	"rules": {
	16	"no-const-assign": "warn",
	17	"no-this-before-super": "warn",
	18	"no-undef": "error",
	19	"no-unreachable": "warn",
	20	"no-unused-vars": "warn",
	21	"constructor-super": "warn",
	22	"valid-typeof": "warn",
	23	"semi" : "warn",
	24	"no-invalid-this" : "error",
	25	"no-console": "off"
	26	}
	27	} No newline at end of file

build.gradle +43 -38

@@ -1,58 +1,63
1		1
2	println "version: $version"	2	println "version: $version"
3		3
4	String makePackageName(String group, String name, String ver) {	4	def distDir = "$buildDir/dist"
5	def sb = new StringBuilder();	5	def testDir = "$buildDir/test"
6	if(group)
7	sb
8	.append('@')
9	.append(group)
10	.append('/');
11
12	sb.append(name);
13		6
14	if (ver)	7	task clean {
15	sb.append('@').append(ver);	8	doLast {
16		9	delete buildDir
17	return sb.toString();	10	}
18	}
19
20	configurations {
21	compile
22	peer
23	dev
24	}	11	}
25		12
26	dependencies {	13	task cleanNpm {
27	compile ":eslint:1.x \|\| >=2.5.0 \|\| 5.0.0 - 7.2.3"	14	doLast {
28	compile (name: 'foo') {	15	delete 'node_modules'
29	ext.location = "http://some/package/location"
30	}	16	}
31	peer "dojo:core"
32	}	17	}
33		18
34	task prepare(type: Copy) {	19	task _npmInstall() {
35	from('src/js/')	20	inputs.file("package.json")
36	from('.') {	21	outputs.dir("node_modules")
37	include 'readme.md', 'license', 'history.md', 'package.json'	22	doLast {
38	}	23	exec {
39	into(buildDir)	24	commandLine 'npm', 'install'
40	}
41
42	task installDeps {
43	configurations.compile.allDependencies.forEach { d ->
44	println makePackageName(d.group, d.name, d.version);
45	if(d.hasProperty('location')) {
46	println d.location
47	}	25	}
48	}	26	}
49	}	27	}
50		28
51	task build(dependsOn: prepare) {	29	task _legacyJs(type:Copy) {
		30	from 'src/js/'
		31	into distDir
		32	}
		33
		34	task _packageMeta(type: Copy) {
		35	inputs.property("version", version)
		36	from('.') {
		37	include 'package.json', 'readme.md', 'license', 'history.md'
		38	}
		39	into distDir
		40	doLast {
		41	exec {
		42	workingDir distDir
		43	commandLine 'npm', 'version', version
		44	}
		45	}
		46	}
		47
		48	task build(dependsOn: [_npmInstall, _legacyJs, _packageMeta]) {
		49
		50	}
		51
		52	task _localInstall(dependsOn: build, type: Exec) {
		53	inputs.file("$distDir/package.json")
		54	outputs.upToDateWhen { true }
		55
		56	commandLine 'npm', 'install', '--no-save', '--force', distDir
52	}	57	}
53		58
54	task pack(dependsOn: build, type: Exec) {	59	task pack(dependsOn: build, type: Exec) {
55	workingDir = buildDir	60	workingDir = buildDir
56		61
57	commandLine 'npm', 'pack'	62	commandLine 'npm', 'pack'
58	} No newline at end of file	63	}

license +22 0

@@ -0,0 +1,22
	1	Copyright 2017-2018 Implab team
	2
	3	Redistribution and use in source and binary forms, with or without
	4	modification, are permitted provided that the following conditions are met:
	5
	6	1. Redistributions of source code must retain the above copyright notice, this
	7	list of conditions and the following disclaimer.
	8
	9	2. Redistributions in binary form must reproduce the above copyright notice,
	10	this list of conditions and the following disclaimer in the documentation
	11	and/or other materials provided with the distribution.
	12
	13	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	14	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	15	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	16	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	17	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	18	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	19	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	20	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	21	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	22	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. No newline at end of file

package.json +4 -3

             {
               "name": "@implab/core",
-              "version": "1.0.1",
+              "version": "0.0.1-dev",
               "description": "Dependency injection, logging, simple and fast text template engine",
               "main": "main.js",
               "scripts": {
                 "test": "echo \"Error: no test specified\" && exit 1"
               },
               "keywords": [
                 "di",
                 "ioc",
                 "logging",
                 "template engine",
                 "dependency injection"
               ],
-              "author": "Sergey Smirnov",
+              "author": "Implab team",
-              "license": "MIT"
+              "license": "BSD",
+              "repository": "https://bitbucket.org/implab/implabjs"
             }

src/js/safe.js +1 -1

             define([],
                 function () {
                     var _create = Object.create,
                         _keys = Object.keys;
                     var safe = null;
                     safe = {
                         argumentNotNull: function (arg, name) {
                             if (arg === null || arg === undefined)
                                 throw new Error("The argument " + name + " can't be null or undefined");
                         },
                         argumentNotEmptyString: function (arg, name) {
                             if (typeof (arg) !== "string" || !arg.length)
                                 throw new Error("The argument '" + name + "' must be a not empty string");
                         },
                         argumentNotEmptyArray: function (arg, name) {
                             if (!(arg instanceof Array) || !arg.length)
                                 throw new Error("The argument '" + name + "' must be a not empty array");
                         },
                         argumentOfType: function (arg, type, name) {
                             if (!(arg instanceof type))
                                 throw new Error("The argument '" + name + "' type doesn't match");
                         },
                         isNull: function (arg) {
                             return (arg === null || arg === undefined);
                         },
                         isPrimitive: function (arg) {
                             return (arg === null || arg === undefined || typeof (arg) === "string" ||
                                 typeof (arg) === "number" || typeof (arg) === "boolean");
                         },
                         isInteger: function (arg) {
                             return parseInt(arg) == arg;
                         },
                         isNumber: function (arg) {
                             return parseFloat(arg) == arg;
                         },
                         isString: function (val) {
                             return typeof (val) == "string" || val instanceof String;
                         },
                         isNullOrEmptyString: function (str) {
                             if (str === null || str === undefined ||
                                 ((typeof (str) == "string" || str instanceof String) && str.length === 0))
                                 return true;
                         },
                         isNotEmptyArray: function (arg) {
                             return (arg instanceof Array && arg.length > 0);
                         },
                         /**
                          * Выполняет метод для каждого элемента массива, останавливается, когда
                          * либо достигнут конец массива, либо функция <c>cb</c> вернула
                          * значение.
                          *
                          * @param{Array | Object} obj массив элементов для просмотра
                          * @param{Function} cb функция, вызываемая для каждого элемента
                          * @param{Object} thisArg значение, которое будет передано в качестве
                          *                <c>this</c> в <c>cb</c>.
                          * @returns Результат вызова функции <c>cb</c>, либо <c>undefined</c>
                          *          если достигнут конец массива.
                          */
                         each: function (obj, cb, thisArg) {
                             safe.argumentNotNull(cb, "cb");
                             var i, x;
                             if (obj instanceof Array) {
                                 for (i = 0; i < obj.length; i++) {
                                     x = cb.call(thisArg, obj[i], i);
                                     if (x !== undefined)
                                         return x;
                                 }
                             } else {
                                 var keys = _keys(obj);
                                 for (i = 0; i < keys.length; i++) {
                                     var k = keys[i];
                                     x = cb.call(thisArg, obj[k], k);
                                     if (x !== undefined)
                                         return x;
                                 }
                             }
                         },
                         /**
                          * Копирует свойства одного объекта в другой.
                          *
                          * @param{Any} dest объект в который нужно скопировать значения
                          * @param{Any} src источник из которого будут копироваться значения
                          * @tmpl{Object|Array} tmpl шаблон по которому будет происходить
                          *                     копирование. Если шаблон является массивом
                          *                     (список свойств), тогда значения этого массива
                          *                     являются именами свойсвт которые будут
                          *                     скопированы. Если шаблон является объектом (карта
                          *                     преобразования имен свойств src->dst), тогда
                          *                     копирование будет осуществляться только
                          *                     собственных свойств источника, присутсвующих в
                          *                     шаблоне, при этом значение свойства шаблона
                          *                     является именем свойства в которое будет
                          *                     произведено коприрование
                          */
                         mixin: function (dest, src, tmpl) {
                             safe.argumentNotNull(dest, "dest");
                             if (!src)
                                 return dest;
                             var keys, i, p;
                             if (arguments.length < 3) {
                                 keys = _keys(src);
                                 for (i = 0; i < keys.length; i++) {
                                     p = keys[i];
                                     dest[p] = src[p];
                                 }
                             } else {
                                 if (tmpl instanceof Array) {
                                     for (i = 0; i < tmpl.length; i++) {
                                         p = tmpl[i];
                                         if (p in src)
                                             dest[p] = src[p];
                                     }
                                 } else {
                                     keys = _keys(src);
                                     for (i = 0; i < keys.length; i++) {
                                         p = keys[i];
                                         if (p in tmpl)
                                             dest[tmpl[p]] = src[p];
                                     }
                                 }
                             }
                             return dest;
                         },
                         /** Wraps the specified function to emulate an asynchronous execution.
                          * @param{Object} thisArg [Optional] Object which will be passed as 'this' to the function.
                          * @param{Function|String} fn [Required] Function wich will be wrapped.
                          */
                         async: function (fn, thisArg) {
                             if (arguments.length == 2 && !(fn instanceof Function))
                                 fn = thisArg[fn];
                             if (fn == null)
                                 throw new Error("The function must be specified");
                             function wrapresult(x, e) {
                                 if (e) {
                                     return {
                                         then: function (cb, eb) {
                                             try {
                                                 return eb ? wrapresult(eb(e)) : this;
                                             } catch (e2) {
                                                 return wrapresult(null, e2);
                                             }
                                         }
                                     };
                                 } else {
                                     if (x && x.then)
                                         return x;
                                     return {
                                         then : function(cb) {
                                             try {
                                                 return cb ? wrapresult(cb(x)) : this;
                                             } catch(e2) {
                                                 return wrapresult(e2);
                                             }
                                         }
                                     };
                                 }
                             }
                             try {
                                 return wrapresult(fn.apply(thisArg, arguments));
                             } catch (e) {
                                 return wrapresult(null, e);
-                            };
                         },
                         create: function () {
                             if (console && console.warn)
                                 console.warn("implab/safe::create is deprecated use Object.create instead");
                             _create.apply(this, arguments);
                         },
                         delegate: function (target, method) {
                             if (!(method instanceof Function)) {
                                 this.argumentNotNull(target, "target");
                                 method = target[method];
                             }
                             if (!(method instanceof Function))
                                 throw new Error("'method' argument must be a Function or a method name");
                             return function () {
                                 return method.apply(target, arguments);
                             };
                         },
                         /**
                          * Для каждого элемента массива вызывает указанную функцию и сохраняет
                          * возвращенное значение в массиве результатов.
                          *
                          * @remarks cb может выполняться асинхронно, при этом одновременно будет
                          *          только одна операция.
                          *
                          * @async
                          */
                         pmap: function (items, cb) {
                             safe.argumentNotNull(cb, "cb");
                             if (items && items.then instanceof Function)
                                 return items.then(function (data) {
                                     return safe.pmap(data, cb);
                                 });
                             if (safe.isNull(items) || !items.length)
                                 return items;
                             var i = 0,
                                 result = [];
                             function next() {
                                 var r, ri;
                                 function chain(x) {
                                     result[ri] = x;
                                     return next();
                                 }
                                 while (i < items.length) {
                                     r = cb(items[i], i);
                                     ri = i;
                                     i++;
                                     if (r && r.then) {
                                         return r.then(chain);
                                     } else {
                                         result[ri] = r;
                                     }
                                 }
                                 return result;
                             }
                             return next();
                         },
                         /**
                          * Для каждого элемента массива вызывает указанную функцию, результаты
                          * не сохраняются
                          *
                          * @remarks cb может выполняться асинхронно, при этом одновременно будет
                          *          только одна операция.
                          * @async
                          */
                         pfor: function (items, cb) {
                             safe.argumentNotNull(cb, "cb");
                             if (items && items.then instanceof Function)
                                 return items.then(function (data) {
                                     return safe.pmap(data, cb);
                                 });
                             if (safe.isNull(items) || !items.length)
                                 return items;
                             var i = 0;
                             function next() {
                                 while (i < items.length) {
                                     var r = cb(items[i], i);
                                     i++;
                                     if (r && r.then)
                                         return r.then(next);
                                 }
                             }
                             return next();
                         },
                         /**
                          * Выбирает первый элемент из последовательности, или обещания, если в
                          * качестве параметра используется обещание, оно должно вернуть массив.
                          *
                          * @param{Function} cb обработчик результата, ему будет передан первый
                          *                  элемент последовательности в случае успеха
                          * @param{Fucntion} err обработчик исключения, если массив пустой, либо
                          *                  не массив
                          *
                          * @remarks Если не указаны ни cb ни err, тогда функция вернет либо
                          *          обещание, либо первый элемент.
                          * @async
                          */
                         first: function (sequence, cb, err) {
                             if (sequence) {
                                 if (sequence.then instanceof Function) {
                                     return sequence.then(function (res) {
                                         return safe.first(res, cb, err);
                                     }, err);
                                 } else if (sequence && "length" in sequence) {
                                     if (sequence.length === 0) {
                                         if (err)
                                             return err(new Error("The sequence is empty"));
                                         else
                                             throw new Error("The sequence is empty");
                                     }
                                     return cb ? cb(sequence[0]) : sequence[0];
                                 }
                             }
                             if (err)
                                 return err(new Error("The sequence is required"));
                             else
                                 throw new Error("The sequence is required");
                         }
                     };
                     return safe;
                 });

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages