Fixed README.md, webpack config, test pages. Add MIT license.

Author: uid11

.gitignore

@@ -0,0 +1 @@
+node_modules

LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2016 uid-11222
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,137 @@
+# is-pure-function #
+
+  [![NPM version][npm-image]][npm-url] ![dependencies][dependencies-image] [![License MIT][license-image]](LICENSE)
+
+  Simple and fast ES3-check that function is pure.
+
+```js
+/** 
+ * @param {function} fn
+ * @param {*} thisArg
+ * @param {Array} args
+ * @return {boolean}
+ */
+function isPureFunction(fn, thisArg, args) {};
+```
+
+*fn* is pure, if not throw when called with *thisArg* as this and *args* as arguments in global scope.
+
+Pure function cannot use closures, but can use exists global vars (Array, Object, setTimeout, etc.).
+Pure function should not have side effects, and cannot throw exceptions.
+Arrow function may be pure, but then it should not contain 'this' and 'arguments' words.
+Generators could not be pure (always product new iterator).
+Result of Function.prototype.bind() could not be pure (because we can not substitute the required value of this).
+
+It is supposed to use in reactive libraries.
+
+## Examples
+```js
+var isPureFunction = require('is-pure-function');
+
+function f(a, b) {
+  return a + b;
+}
+// true
+isPureFunction(f, null, [1, 2]);
+
+
+var g = function(a) {
+  return function(b) {
+    return a + b;
+  }
+}(1);
+// false (use closure var)
+isPureFunction(g, {}, [1, 2]);
+
+
+function getIndex(str, char) {
+  return str.indexOf(char);
+}
+// false (wrong type of arguments)
+isPureFunction(getIndex, null, [1, 2]);
+// true
+isPureFunction(getIndex, null, ['str', 'c']);
+
+
+var f1 = function(a) {return a;}
+// false (extra arguments)
+isPureFunction(f1, undefined, [1, 2]);
+// false (not enough arguments)
+isPureFunction(f1, undefined, []);
+// true
+isPureFunction(f1, undefined, [1]);
+// throw ReferenceError, missing argument
+isPureFunction(f1, undefined);
+// false (not a function at all)
+isPureFunction({}, undefined, []);
+
+
+var getThisA = function() {
+  return this.a;
+}
+// false (ReferenceError)
+isPureFunction(getThisA, null, []);
+// true (this -- context-argument of function)
+isPureFunction(getThisA, {}, []);
+
+
+function* generator() {
+  return yield null;
+}
+// false
+isPureFunction(generator, 0, []);
+
+
+var arrow = (a, b) => a + b;
+// true
+isPureFunction(arrow, '', [1, 2]);
+
+
+var arrowThis = () => this;
+// false (this bound in arrow functions)
+isPureFunction(arrowThis, 0, []);
+
+// but
+var arrowStr = () => 'this';
+//true
+isPureFunction(arrowStr, 0, []);
+
+
+var arrowArgs = () => arguments;
+// false (this bound in arrow functions)
+isPureFunction(arrowArgs, null, []);
+
+// but
+var arrowComment = () => {
+  // arguments
+  return 3;
+}
+// true
+isPureFunction(arrowComment, null, []);
+
+
+var boundFn = function() {}.bind();
+// false (can not substitute the required value of this)
+isPureFunction(boundFn, 0, []);
+
+// it is unlikely you will need
+isPureFunction.clearCache();
+```
+
+Use pure functions for FRP (the best way is arrow functions, without this and arguments object, with a fixed number of arguments).
+
+## Tests
+Standalone pages test/es3.html && test/es6.html (via Mocha). Install webpack and opener, build scripts, than run tests:
+```bash
+$ npm install
+$ npm run build
+$ npm test
+```
+
+## License ##
+  [MIT](LICENSE)
+
+[license-image]: https://img.shields.io/badge/license-MIT-blue.svg "license-image"
+[dependencies-image]: https://img.shields.io/gemnasium/mathiasbynens/he.svg?maxAge=2592000 "dependencies-image"
+[npm-image]: https://img.shields.io/npm/v/is-pure-function.svg "npm-image"
+[npm-url]: https://www.npmjs.com/package/is-pure-function "is-pure-function"

build/build.js

@@ -0,0 +1,32 @@
+{
+  "name": "is-pure-function",
+  "version": "0.1.6",
+  "description": "Return true, if function is pure.",
+  "main": "src/is-pure-function.js",
+  "scripts": {
+    "build": "./node_modules/webpack/bin/webpack.js",
+    "test": "./node_modules/opener/opener.js ./test/es3.html && ./node_modules/opener/opener.js ./test/es6.html"
+  },
+  "keywords": [
+    "check",
+    "pure",
+    "function",
+    "reactive",
+    "model"
+  ],
+  "dependencies": {},
+  "devDependencies": {
+    "webpack": ">=1.0.0",
+    "opener": "*"
+  },
+  "author": "uid-11222",
+  "bugs": {
+    "url": "https://github.com/uid-11222/is-pure-function/issues"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/uid-11222/is-pure-function",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/uid-11222/is-pure-function"
+  }
+}

build/build.js.map

@@ -0,0 +1,70 @@
+'use strict';
+
+module.exports = isPureFunction;
+
+var cache = {},
+  toString = isPureFunction.toString,
+  Function = isPureFunction.constructor,
+  reFunction = /^\s*function\b/,
+  reGenerator = /^\s*(function)?\s*\*/,
+  reBoundWords = /\bthis\b|\barguments\b/,
+  reStringsOrComments =
+    /"[^"]*"|'[^']*'|`[^`]*`|\/\/.*\s|\/\*.*\*\//g;
+
+/**
+ * Return true, if call fn.apply(thisArg, args)
+ * in global scope does not throw exception.
+ * 
+ * @param {function} fn
+ * @param {*} thisArg
+ * @param {Array} args
+ * @return {boolean}
+ */
+function isPureFunction(fn, thisArg, args) {
+  var code, pureFn;
+
+  if (args.length !==  fn.length) return false;
+  if (typeof fn   !== 'function') return false;
+
+  try { code = toString.call(fn); }
+  catch (e) { return false; }
+
+  pureFn = cache[code];
+  if (!pureFn) {
+    /* Maybe fn already cached as not a pure. */
+    if (pureFn === null) return false;
+    try {
+
+      if (reFunction.test(code)) {
+        /* Generators could not be pure. */
+        if (reGenerator.test(code)) return false;
+      } else {
+        /* Arrow function could not contain bound words. */
+        if (reBoundWords.test(
+              code.replace(reStringsOrComments, '')
+          )) return false;
+      }
+
+      pureFn = Function (
+        '"use strict";return(' + code + ')'
+      )();
+
+    } catch (e) { return false; }
+    finally {
+      cache[code] = pureFn || null;
+    }
+  }
+
+  try { pureFn.apply(thisArg, args); }
+  catch (e) { return false; }
+
+  return true;
+}
+
+/**
+ * Сlear cache and delete links to all functions.
+ * @memberof isPureFunction
+ */
+isPureFunction.clearCache = function clearCache() {
+  for (var key in cache) cache[key] = undefined;
+};