testaro 18.2.0 → 18.4.0

package/aslint/utils/env.test.ts

@@ -0,0 +1,14 @@
+import { Env } from './env';
+
+describe('Utils', () => {
+
+  describe('Env', () => {
+
+    describe('#isTest', () => {
+      it('should identify Jest runtime environment properly', () => {
+        expect(Env.isTest).toBe(true);
+      });
+    });
+
+  });
+});

package/aslint/utils/env.ts

@@ -0,0 +1,8 @@
+declare let jest: any;
+export class Env {
+
+  public static get isTest(): boolean {
+    return typeof jest !== 'undefined';
+  }
+
+}

package/aslint/utils/func.test.ts

@@ -0,0 +1,160 @@
+import { Global } from './global';
+import { Func } from './func';
+
+describe('Func', () => {
+
+  describe('#extend', () => {
+    let objectToExtend: { defaultProperty?: any; defaultMethod?: any; o?: any },
+      objectExtendDefault: { defaultProperty: number; defaultMethod: () => any },
+      objectExtendDeep: { defaultProperty: number; defaultMethod: () => any; o: { arr: any[] } };
+
+    beforeEach(() => {
+      objectToExtend = {};
+
+      objectExtendDefault = {
+        defaultMethod: () => {
+          return null;
+        },
+        defaultProperty: 1
+      };
+
+      objectExtendDeep = {
+        defaultMethod: () => {
+          return null;
+        },
+        defaultProperty: 1,
+        o: {
+          arr: []
+        }
+      };
+    });
+
+    it('extend empty object with default values', () => {
+      Func.mixin(objectToExtend, objectExtendDefault);
+      expect(objectToExtend.defaultProperty).toBe(1);
+      expect(typeof objectToExtend.defaultMethod).toBe('function');
+    });
+
+    it('extend filled object with default values, overwrite values', () => {
+      objectToExtend.defaultProperty = 2;
+      Func.mixin(objectToExtend, objectExtendDefault);
+      expect(objectToExtend.defaultProperty).toBe(1);
+      expect(typeof objectToExtend.defaultMethod).toBe('function');
+    });
+
+    it('deep extend filled object with default values, overwrite values', () => {
+      Func.mixin(objectToExtend, objectExtendDeep);
+      expect(objectToExtend.defaultProperty).toBe(1);
+      expect(typeof objectToExtend.defaultMethod).toBe('function');
+      expect(typeof objectToExtend.o).toBe('object');
+    });
+
+  });
+
+  describe('#defaults', () => {
+
+    let target: { str: any; num: any; bool: any; arr: any; obj: any; und: any; nul: any; a?: any; zero?: any };
+
+    beforeEach(() => {
+      target = {
+        arr: [1, 2, 3],
+        bool: true,
+        nul: null,
+        num: 42,
+        obj: {
+          bar: 'bar',
+          foo: 'foo'
+        },
+        str: 'str',
+        und: undefined
+      };
+    });
+
+    afterEach(() => {
+      target = undefined;
+    });
+
+    it('add properties to the target object if the property is not previously defined', () => {
+      Func.defaults(target, {
+        a: 'a',
+        und: 'defined',
+        zero: 0
+      });
+
+      expect(target.str).toBe('str');
+      expect(target.num).toBe(42);
+      expect(target.bool).toBe(true);
+      expect(target.arr).toEqual([1, 2, 3]);
+      expect(target.obj).toEqual({
+        bar: 'bar',
+        foo: 'foo'
+      });
+      expect(target.und).toBe('defined');
+      expect(target.nul).toBe(null);
+      expect(target.a).toBe('a');
+      expect(target.zero).toBe(0);
+    });
+
+    it('does not add a property to the target object if it is already defined', () => {
+      Func.defaults(target, {
+        nul: 'null',
+        str: 'newstr',
+        und: 'defined'
+      });
+      expect(target.str).toBe('str');
+      expect(target.nul).toBe(null);
+    });
+
+    it('returns a new object with all merged defaults if target is null or undefined', () => {
+      const defaulted = Func.defaults(null, {
+        a: 'a',
+        zero: 0
+      });
+
+      expect(defaulted).toEqual({
+        a: 'a',
+        zero: 0
+      });
+      expect(defaulted).not.toBe({
+        a: 'a',
+        zero: 0
+      });
+    });
+  });
+
+  describe('#namespace', () => {
+    const ns = 'Test.Foo.Bar.Baz';
+
+    beforeEach(() => {
+      expect(Global.context.Test).toBeUndefined();
+    });
+
+    afterEach(() => {
+      delete Global.context.Test;
+    });
+
+    it('returns the global object if it exists for the given namespace', () => {
+      Global.context.Test = {
+        Already: 'here'
+      };
+
+      const baz = Func.namespace(ns);
+
+      expect(Global.context.Test).toBeDefined();
+      expect(Global.context.Test.Already).toBe('here');
+      expect(Global.context.Test.Foo.Bar).toBeDefined();
+      expect(Global.context.Test.Foo.Bar.Baz).toBeDefined();
+      expect(Global.context.Test.Foo.Bar.Baz).toBe(baz);
+    });
+
+    it('returns a new object if no global object exists for the given namespace', () => {
+      const baz = Func.namespace(ns);
+
+      expect(Global.context.Test.Foo).toBeDefined();
+      expect(Global.context.Test.Foo.Bar).toBeDefined();
+      expect(Global.context.Test.Foo.Bar.Baz).toBeDefined();
+      expect(Global.context.Test.Foo.Bar.Baz).toBe(baz);
+    });
+  });
+
+});

package/aslint/utils/func.ts

@@ -0,0 +1,70 @@
+export class Func {
+
+  /**
+   * Deep object mixin, extending destination object with properties of source object
+   * @method
+   * @param {Object} destination object with original values/ new object
+   * @param {Object} source object with default values
+   * @return {Object} extended object
+   */
+  public static mixin(targetObject: any, ...sources: any[]): any {
+    const target: any = targetObject ? targetObject : {};
+
+    const processSources = (src: any): any => {
+      if (src) {
+        const copyValue = (key: string): any => {
+          target[key] = src[key];
+        };
+
+        Object.keys(src).forEach(copyValue);
+      }
+    };
+
+    sources.forEach(processSources);
+
+    return target;
+  }
+
+  /**
+   * similar to mixin, but only adds to the target the properties which are undefined
+   * @param {object} targetObject - the object to extend
+   * @param {...object} sources - an object(s) with properties to be added to the target if the property doesn't exist on the target or on a previous source
+   * @returns {object} modified target with added defaults
+   */
+  public static defaults(targetObject: any, sources: any): any {
+    let target: any = {};
+
+    if (targetObject) {
+      target = targetObject;
+    }
+
+    if (sources) {
+      const processSrc = (key: string): void => {
+        if (typeof target[key] === 'undefined') {
+          target[key] = sources[key];
+        }
+      };
+
+      Object.keys(sources).forEach(processSrc);
+    }
+
+    return target;
+  }
+
+  public static namespace(namespace: any, context?: any): any {
+    const parts: string[] = namespace.split('.');
+    const len: number = parts.length;
+    let parent: any = context || global;
+
+    for (let i = 0; i < len; i += 1) {
+      if (parent[parts[i]] === undefined) {
+        parent[parts[i]] = {};
+      }
+
+      parent = parent[parts[i]];
+    }
+
+    return parent;
+  }
+
+}

package/aslint/utils/global.test.ts

@@ -0,0 +1,12 @@
+import { Global } from './global';
+
+describe('Utils', () => {
+
+  describe('Global', () => {
+
+    it('should indicate that class exists', () => {
+      expect(Global).toBeDefined();
+    });
+
+  });
+});

package/aslint/utils/global.ts

@@ -0,0 +1,25 @@
+/* eslint-disable */
+export class Global {
+
+  public static get context(): any {
+    return (function (): any {
+      if (typeof globalThis === 'object') {
+        return globalThis;
+      }
+
+      Object.defineProperty(Object.prototype, '__magic__', {
+        configurable: true,
+        get: function () {
+          return this;
+        }
+      });
+
+      /* @ts-ignore */
+      __magic__.globalThis = __magic__;
+
+      /* @ts-ignore */
+      delete Object.prototype.__magic__;
+    }());
+  }
+
+}