feat(util): add limitFn and range utility functions

Ovidiu Barabula · Ovidiu Barabula · commit b919d1adba18 · 2018-03-14T13:39:50.000+02:00
diff --git a/src/util/utility-functions.spec.ts b/src/util/utility-functions.spec.ts
@@ -1,6 +1,6 @@
 import { assert, expect } from 'chai';
 import 'mocha';
-import { hasNested } from './utility-functions';
+import { ERRORS, hasNested, limitFn, range } from './utility-functions';
 
 describe('Utility Functions', () => {
   describe('hasNested', () => {
@@ -49,4 +49,104 @@ describe('Utility Functions', () => {
       expect(hasNested({}, '')).to.be.false;
     });
   });
+
+
+  describe('limitFn', () => {
+    it('returns a function', () => {
+      const fn = () => true;
+      expect(limitFn(fn)).to.be.a('function');
+    });
+
+
+    it('returns original function\'s return value', () => {
+      const fn = () => true;
+      expect(limitFn(fn)()).to.be.true;
+    });
+
+
+    it('limits the number of calls a function can take', () => {
+      const fn = () => true;
+      const limited = limitFn(fn);
+      limited();
+      expect(limited()).to.be.undefined;
+    });
+
+
+    it('takes custom limit argument', () => {
+      const fn = () => true;
+      const limited = limitFn(fn, 5);
+      for (const i of range(1, 5)) {
+        expect(limited()).to.be.true;
+      }
+      expect(limited()).to.be.undefined;
+    });
+
+
+    it('passes the function arguments to the limited limited function', () => {
+      const add = (x: number, y: number) => x + y;
+      const limited = limitFn(add);
+      expect(limited(1, 3)).to.equal(4);
+      expect(limited(2, 2)).to.be.undefined;
+    });
+
+
+    it('throws if passed limit argument is not a number', () => {
+      const fn = () => true;
+      assert.throws(() => limitFn(fn, '1'), ERRORS.LIMIT_NOT_A_NUMBER);
+    });
+
+
+    it('throws if argument is not a function', () => {
+      assert.throws(() => limitFn(1), ERRORS.NOT_A_FUNCTION);
+    });
+  });
+
+
+  describe('range', () => {
+    it('creates an array from 1 to 5', () => {
+      const subject = range(1, 5);
+      expect(subject).to.be.an('array');
+      expect(subject[0]).to.equal(1);
+      expect(subject[subject.length - 1]).to.equal(5);
+    });
+
+
+    it('creates an array from -1 to 5', () => {
+      const subject = range(-1, 5);
+      expect(subject).to.be.an('array');
+      expect(subject[0]).to.equal(-1);
+      expect(subject[subject.length - 1]).to.equal(5);
+    });
+
+
+    it('creates an array from 5 to 1', () => {
+      const subject = range(5, 1);
+      expect(subject).to.be.an('array');
+      expect(subject[0]).to.equal(5);
+      expect(subject[subject.length - 1]).to.equal(1);
+    });
+
+
+    it('creates an array from -5 to 1', () => {
+      const subject = range(-5, 1);
+      expect(subject).to.be.an('array');
+      expect(subject[0]).to.equal(-5);
+      expect(subject[subject.length - 1]).to.equal(1);
+    });
+
+
+    it('throws if arguments are missing', () => {
+      assert.throws(() => range(1), ERRORS.RANGE_NEEDS_TWO_PARAMS);
+    });
+
+
+    it('throws if arguments are not numbers', () => {
+      assert.throws(() => range('1', '5'), ERRORS.RANGE_NEEDS_NUMBERS);
+    });
+
+
+    it('throws if limit arguments are equal', () => {
+      assert.throws(() => range(2, 2), ERRORS.RANGE_LIMITS_EQUAL);
+    });
+  });
 });
diff --git a/src/util/utility-functions.ts b/src/util/utility-functions.ts
@@ -9,6 +9,17 @@ interface NestedObject {
   [key: string]: any;
 }
 
+type AnyFunction = (...args: any[]) => any;
+
+
+export const ERRORS = {
+  LIMIT_NOT_A_NUMBER: 'Limit argument must be a number',
+  NOT_A_FUNCTION: 'Passed argument is not a function',
+  RANGE_LIMITS_EQUAL: 'Range limits cannot be equal',
+  RANGE_NEEDS_NUMBERS: 'Range limit arguments must be numbers',
+  RANGE_NEEDS_TWO_PARAMS: 'Range requires two number parameters',
+};
+
 
 /**
  * Check object for path
@@ -34,3 +45,63 @@ export function hasNested(object: NestedObject, path: string | string[]): boolea
     return false;
   }
 }
+
+
+/**
+ * Limit a function's number of available calls
+ * @param fn Any function
+ * @param limit Maximum numbers of calls
+ */
+export function limitFn(fn: AnyFunction | void, limit: number = 1): AnyFunction {
+  if (typeof fn !== 'function') {
+    throw new Error(ERRORS.NOT_A_FUNCTION);
+  }
+
+  if (typeof limit !== 'number') {
+    throw new Error(ERRORS.LIMIT_NOT_A_NUMBER);
+  }
+
+  return function (...args) {
+    if (fn && limit > 0) {
+      limit -= 1;
+      return fn(...args);
+    }
+    fn = undefined;
+    return undefined;
+  };
+}
+
+
+/**
+ * Create an array of numbers between passed in limits
+ * @param from Starting number
+ * @param to End number
+ */
+export function range(from: number, to: number): number[] {
+  if (typeof to === 'undefined') {
+    throw new Error(ERRORS.RANGE_NEEDS_TWO_PARAMS);
+  }
+
+  if (typeof from !== 'number' || typeof to !== 'number') {
+    throw new Error(ERRORS.RANGE_NEEDS_NUMBERS);
+  }
+
+  if (from === to) {
+    throw new Error(ERRORS.RANGE_LIMITS_EQUAL);
+  }
+
+  const direction: number = from < to ? +1 : -1;
+  // Swich the values if we need to go from right to left
+  if (direction < 0) {
+    [from, to] = [to, from];
+  }
+
+  const array: number[] = [];
+  for (let i = from; i <= to; i++) {
+    array.push(i);
+  }
+
+  // If right to left, reverse the array
+  // This keeps the above loop the same in both cases
+  return direction > 0 ? array : array.reverse();
+}
