Initial commit

Author: Malax

.babelrc

@@ -0,0 +1,3 @@
+{
+  "presets": ["es2015"]
+}

.gitignore

@@ -0,0 +1,2 @@
+/node_modules
+/.idea

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Manuel Fuchs
+
+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 @@
+# validate-redux-form

lib/index.js

@@ -0,0 +1,69 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validators = undefined;
+exports.validate = validate;
+
+var _lodash = require('lodash.pairs');
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _lodash3 = require('lodash.frompairs');
+
+var _lodash4 = _interopRequireDefault(_lodash3);
+
+var _lodash5 = require('lodash.isfunction');
+
+var _lodash6 = _interopRequireDefault(_lodash5);
+
+var _lodash7 = require('lodash.isobject');
+
+var _lodash8 = _interopRequireDefault(_lodash7);
+
+var _lodash9 = require('lodash.isempty');
+
+var _lodash10 = _interopRequireDefault(_lodash9);
+
+var _validators = require('./validators');
+
+var _validators2 = _interopRequireDefault(_validators);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var validators = exports.validators = _validators2.default;
+
+function validate(data, validationSpec) {
+  var pairs = (0, _lodash2.default)(validationSpec);
+
+  var errorPairs = pairs.reduce(function (acc, pair) {
+    var key = pair[0];
+    var value = pair[1];
+
+    if ((0, _lodash6.default)(value)) {
+      var validationResult = value(data[key]);
+      if (!validationResult) {
+        return acc;
+      } else {
+        return [].concat(_toConsumableArray(acc), [[key, validationResult]]);
+      }
+    }
+
+    if ((0, _lodash8.default)(value)) {
+      var _validationResult = validate(data[key] || {}, value);
+
+      if ((0, _lodash10.default)(_validationResult)) {
+        return acc;
+      } else {
+        return [].concat(_toConsumableArray(acc), [[key, _validationResult]]);
+      }
+    }
+
+    return acc;
+  }, []);
+
+  return (0, _lodash4.default)(errorPairs);
+}

lib/test.js

@@ -0,0 +1 @@
+"use strict";

lib/validators.js

@@ -0,0 +1,76 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.combine = combine;
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+
+var validatorFromFunction = exports.validatorFromFunction = function validatorFromFunction(validationFunction) {
+  return function (params) {
+    var _this = this;
+
+    var argumentsAsArray = [].slice.apply(arguments);
+    return function (message) {
+      return function (value) {
+        return validationFunction.apply(_this, [value].concat(_toConsumableArray(argumentsAsArray))) ? null : message;
+      };
+    };
+  };
+};
+
+function combine(validators) {
+  var _arguments = arguments;
+
+  return function (value) {
+    for (var i = 0; i < _arguments.length; i++) {
+      var result = _arguments[i](value);
+      if (result) {
+        return result;
+      }
+    }
+
+    return null;
+  };
+}
+
+var exists = exports.exists = validatorFromFunction(function (value) {
+  return !!value;
+});
+
+var length = exports.length = validatorFromFunction(function (string) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      min = _ref.min,
+      max = _ref.max;
+
+  if (min === undefined && max === undefined) {
+    throw new Error('length requires at least one parameter!');
+  }
+
+  var hasMinLength = min !== undefined ? string.length >= min : true;
+  var hasMaxLength = max !== undefined ? string.length <= max : true;
+  return hasMinLength && hasMaxLength;
+});
+
+var number = exports.number = validatorFromFunction(function (value) {
+  var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+      minValue = _ref2.minValue,
+      maxValue = _ref2.maxValue;
+
+  var isNumber = !isNaN(value);
+  var hasMinValue = minValue !== undefined ? parseInt(value) >= minValue : true;
+  var hasMaxValue = maxValue !== undefined ? parseInt(value) <= maxValue : true;
+  return isNumber && hasMinValue && hasMaxValue;
+});
+
+var regex = exports.regex = validatorFromFunction(function (value, pattern) {
+  return value.match(pattern) !== null;
+});
+
+exports.default = {
+  exists: exists,
+  length: length,
+  number: number,
+  regex: regex
+};

package.json

@@ -0,0 +1,28 @@
+{
+  "name": "validate-redux-form",
+  "version": "0.1.0",
+  "description": "",
+  "main": "compiled/index.js",
+  "scripts": {
+    "compile": "babel --presets es2015 -d lib/ src/",
+    "prepublish": "npm run compile",
+    "test": "npm run compile && mocha --compilers js:babel-core/register"
+  },
+  "author": "Manuel Fuchs ([email protected])",
+  "license": "MIT",
+  "devDependencies": {
+    "babel-cli": "^6.24.1",
+    "babel-core": "^6.24.1",
+    "babel-preset-es2015": "^6.24.1",
+    "chai": "^3.5.0",
+    "mocha": "^3.2.0"
+  },
+  "dependencies": {
+    "lodash": "^4.17.4",
+    "lodash.frompairs": "^4.0.1",
+    "lodash.isempty": "^4.4.0",
+    "lodash.isfunction": "^3.0.8",
+    "lodash.isobject": "^3.0.2",
+    "lodash.pairs": "^3.0.1"
+  }
+}

src/index.js

@@ -0,0 +1,40 @@
+import toPairs from 'lodash.pairs'
+import fromPairs from 'lodash.frompairs'
+import isFunction from 'lodash.isfunction'
+import isObject from 'lodash.isobject'
+import isEmpty from 'lodash.isempty'
+import importedValidators from './validators'
+
+export const validators = importedValidators
+
+export function validate (data, validationSpec) {
+  const pairs = toPairs(validationSpec)
+
+  const errorPairs = pairs.reduce((acc, pair) => {
+    const key = pair[0]
+    const value = pair[1]
+
+    if (isFunction(value)) {
+      const validationResult = value(data[key])
+      if (!validationResult) {
+        return acc
+      } else {
+        return [...acc, [key, validationResult]]
+      }
+    }
+
+    if (isObject(value)) {
+      const validationResult = validate(data[key] || {}, value)
+
+      if (isEmpty(validationResult)) {
+        return acc
+      } else {
+        return [...acc, [key, validationResult]]
+      }
+    }
+
+    return acc
+  }, [])
+
+  return fromPairs(errorPairs)
+}

src/validators.js

@@ -0,0 +1,47 @@
+export const validatorFromFunction = (validationFunction) => {
+  return function (params) {
+    const argumentsAsArray = [].slice.apply(arguments)
+    return (message) => (value) => validationFunction.apply(this, [value, ...argumentsAsArray]) ? null : message
+  }
+}
+
+export function combine (validators) {
+  return (value) => {
+    for (let i = 0; i < arguments.length; i++) {
+      const result = arguments[i](value)
+      if (result) {
+        return result
+      }
+    }
+
+    return null
+  }
+}
+
+export const exists = validatorFromFunction(value => !!value)
+
+export const length = validatorFromFunction((string, {min, max} = {}) => {
+  if (min === undefined && max === undefined) {
+    throw new Error('length requires at least one parameter!')
+  }
+
+  const hasMinLength = min !== undefined ? string.length >= min : true
+  const hasMaxLength = max !== undefined ? string.length <= max : true
+  return hasMinLength && hasMaxLength
+})
+
+export const number = validatorFromFunction((value, {minValue, maxValue} = {}) => {
+  const isNumber = !isNaN(value)
+  const hasMinValue = minValue !== undefined ? parseInt(value) >= minValue : true
+  const hasMaxValue = maxValue !== undefined ? parseInt(value) <= maxValue : true
+  return isNumber && hasMinValue && hasMaxValue
+})
+
+export const regex = validatorFromFunction((value, pattern) => value.match(pattern) !== null)
+
+export default {
+  exists,
+  length,
+  number,
+  regex
+}

test/index.spec.js

@@ -0,0 +1,69 @@
+import { expect } from 'chai'
+import { validate } from '../src/index'
+
+describe('validate-redux-form', function () {
+  describe('validate', function () {
+    it('should be a function', function () {
+      expect(validate).to.be.a('function')
+    })
+
+    it('should return an object', function () {
+      expect(validate({}, {})).to.be.an('object')
+    })
+
+    it('should work with a flat object', function () {
+      const validation = { foo: (value) => 'error' }
+      expect(validate({}, validation)).to.have.property('foo', 'error')
+    })
+
+    it('should work with a nested object', function () {
+      const validation = {
+        foo: (value) => 'error',
+        bar: {
+          baz: (value) => 'errorbaz'
+        }
+      }
+
+      const result = validate({}, validation)
+      expect(result).to.have.property('foo', 'error')
+      expect(result).to.have.deep.property('bar.baz', 'errorbaz')
+    })
+
+    it('should omit properties that yield no errors', function () {
+      const validation = {
+        foo: (value) => null
+      }
+
+      expect(validate({}, validation)).to.not.have.property('foo')
+    })
+
+    it('should omit nesed objects that contain no errors', function () {
+      const validation = {
+        foo: {
+          bar: (value) => null,
+          baz: (value) => null
+        }
+      }
+
+      expect(validate({}, validation)).to.not.have.property('foo')
+    })
+
+    it('should work with deeply nested objects', function () {
+      const validation = {
+        foo: {
+          bar: {
+            baz: {
+              qoo: {
+                quu: {
+                  test: (value) => 'failed'
+                }
+              }
+            }
+          }
+        }
+      }
+
+      expect(validate({}, validation)).to.have.deep.property('foo.bar.baz.qoo.quu.test', 'failed')
+    })
+  })
+})