From 24810302b2cc77a41bb08f9ba618832602162c76 Mon Sep 17 00:00:00 2001 From: Sebastian Seedorf Date: Wed, 27 May 2020 19:16:48 +0200 Subject: [PATCH] Added number range --- validators/number.test.ts | 93 ++++++++++++++++++++++++++++++++++++++- validators/number.ts | 80 +++++++++++++++++++++++++++++++++ 2 files changed, 172 insertions(+), 1 deletion(-) diff --git a/validators/number.test.ts b/validators/number.test.ts index 862dc9a..5053ca6 100644 --- a/validators/number.test.ts +++ b/validators/number.test.ts @@ -1,4 +1,4 @@ -import { isNumber, isInteger } from "./number.ts"; +import { isNumber, isInteger, isInRange, hasParity } from "./number.ts"; import { validate } from "../mod.ts"; import { assertEquals, @@ -79,3 +79,94 @@ Deno.test("isInteger (no match)", async () => { String(NaN), ); }); + +Deno.test("isInRange (match)", async () => { + const values: [number[], object][] = [ + [[10.5, 11], { greaterThan: 10 }], + [[10, 10.5, 11], { greaterThanOrEqualTo: 10 }], + [[10], { equalTo: 10 }], + [[9.5, 9], { lessThan: 10 }], + [[10, 9.5, 9], { lessThanOrEqualTo: 10 }], + [[11, 11.5], { greaterThan: 10, lessThan: 12 }], + [[10, 11, 11.5], { greaterThanOrEqualTo: 10, lessThan: 12 }], + [[NaN], { allowNaN: true }], + ]; + for (const [vals, options] of values) { + for (const value of vals) { + assertEquals( + await validate(value, isInRange(options)), + [], + `${String(value)} - ${JSON.stringify(options)}`, + ); + } + } +}); + +Deno.test("isInRange (no match)", async () => { + const values: [number[], any][] = [ + [[8.5, 9, 10], { greaterThan: 10 }], + [[8.5, 9], { greaterThanOrEqualTo: 10 }], + [[9, 9.5, 11], { equalTo: 10 }], + [[10, 10.5, 11], { lessThan: 10 }], + [[10.5, 11], { lessThanOrEqualTo: 10 }], + [[9.5, 10, 12, 13], { greaterThan: 10, lessThan: 12 }], + [[9.5, 12, 13], { greaterThanOrEqualTo: 10, lessThan: 12 }], + [[NaN], { allowNaN: false }], + [[NaN], {}], + ]; + for (const [vals, options] of values) { + for (const value of vals) { + assertNotEquals( + await validate(value, isInRange(options)), + [], + `${String(value)} - ${JSON.stringify(options)}`, + ); + } + } +}); + +Deno.test("hasParity (match)", async () => { + const values: [number[], object][] = [ + [[-2, -1, 0, 1, 2, 3, 4, 5, 6], {}], + [[-2, 0, 2, 4, 6], { odd: false }], + [[-1, 1, 3, 5], { even: false }], + [[0, 3, 6], { divisibleBy: 3 }], + [[], { odd: false, even: false }], + [[0, 6], { odd: false, divisibleBy: 3 }], + [[3], { even: false, divisibleBy: 3 }], + [[NaN], { allowNaN: true }], + ]; + for (const [vals, options] of values) { + for (const value of vals) { + assertEquals( + await validate(value, hasParity(options)), + [], + `${String(value)} - ${JSON.stringify(options)}`, + ); + } + } +}); + +Deno.test("hasParity (no match)", async () => { + const values: [number[], any][] = [ + [[], {}], + [[-1, 1, 3, 5], { odd: false }], + [[-2, 0, 2, 4, 6], { even: false }], + [[-2, -1, 1, 2, 4, 5], { divisibleBy: 3 }], + [[-2, -1, 0, 1, 2, 3, 4, 5, 6], { odd: false, even: false }], + [[-2, -1, 1, 2, 3, 4, 5], { odd: false, divisibleBy: 3 }], + [[-2, -1, 0, 1, 2, 4, 5, 6], { even: false, divisibleBy: 3 }], + [[NaN], { allowNaN: false }], + [[NaN], {}], + [[0.5], {}], + ]; + for (const [vals, options] of values) { + for (const value of vals) { + assertNotEquals( + await validate(value, hasParity(options)), + [], + `${String(value)} - ${JSON.stringify(options)}`, + ); + } + } +}); diff --git a/validators/number.ts b/validators/number.ts index 45c570e..5fbb862 100644 --- a/validators/number.ts +++ b/validators/number.ts @@ -35,3 +35,83 @@ export function isInteger( }, }; } + +export function isInRange( + { + allowNaN = false, + greaterThan = undefined, + greaterThanOrEqualTo = undefined, + equalTo = undefined, + lessThan = undefined, + lessThanOrEqualTo = undefined, + }: { + allowNaN?: boolean; + greaterThan?: number; + greaterThanOrEqualTo?: number; + equalTo?: number; + lessThan?: number; + lessThanOrEqualTo?: number; + } = {}, +): Validator { + return { + type: "isInRange", + extends: [isNumber({ allowNaN })], + check: (value: any) => { + if (value === null || value === undefined) return; + if (allowNaN && Number.isNaN(value)) return; + if (greaterThan !== undefined && value <= greaterThan) { + return { range: "greaterThan" }; + } + if (greaterThanOrEqualTo !== undefined && value < greaterThanOrEqualTo) { + return { range: "greaterThanOrEqualTo" }; + } + if (equalTo !== undefined && value !== equalTo) { + return { range: "equalTo" }; + } + if (lessThan !== undefined && value >= lessThan) { + return { range: "lessThan" }; + } + if (lessThanOrEqualTo !== undefined && value > lessThanOrEqualTo) { + return { range: "lessThanOrEqualTo" }; + } + }, + message: (value: any, args?: Args) => { + return `This value is not in the given range.`; + }, + }; +} + +export function hasParity( + { + allowNaN = false, + odd = true, + even = true, + divisibleBy = undefined, + }: { + allowNaN?: boolean; + odd?: boolean; + even?: boolean; + divisibleBy?: number; + } = {}, +): Validator { + return { + type: "hasParity", + extends: [isInteger({ allowNaN })], + check: (value: any) => { + if (value === null || value === undefined) return; + if (allowNaN && Number.isNaN(value)) return; + if (!odd && Math.abs(value % 2) == 1) { + return { partity: "odd" }; + } + if (!even && value % 2 == 0) { + return { partity: "even" }; + } + if (divisibleBy !== undefined && (value % divisibleBy !== 0)) { + return { divisibleBy: "divisibleBy" }; + } + }, + message: (value: any, args?: Args) => { + return `This value is not in the given range.`; + }, + }; +}