refactor(SymbolShim): export SymbolShim using factory

spec/util/SymbolShim-spec.js

@@ -0,0 +1,102 @@
+/* globals __root__ */
+var SymbolDefinition = require('../../dist/cjs/util/SymbolShim').SymbolDefinition;
+var Map = require('../../dist/cjs/util/Map').Map;
+var Rx = require('../../dist/cjs/Rx');
+
+describe('SymbolDefinition', function () {
+  it('should setup symbol if root does not have it', function () {
+    var root = {};
+
+    var result = new SymbolDefinition(root);
+    expect(root.Symbol).toBeDefined();
+    expect(result.observable).toBeDefined();
+    expect(result.iterator).toBeDefined();
+  });
+
+  it('should have observable, iterator symbols', function () {
+    var result = new SymbolDefinition(__root__);
+
+    expect(typeof result.observable).toBe('symbol');
+    expect(typeof result.iterator).toBe('symbol');
+  });
+
+  describe('when symbols exists on root', function () {
+    it('should use symbols from root', function () {
+      var root = {
+        Symbol: {
+          observable: {},
+          iterator: {}
+        }
+      };
+
+      var result = new SymbolDefinition(root);
+      expect(result.observable).toBe(root.Symbol.observable);
+      expect(result.iterator).toBe(root.Symbol.iterator);
+    });
+  });
+
+  describe('observable symbol', function () {
+    it('should patch root using for symbol if exist', function () {
+      var root = {
+        Symbol: {
+          for: function (x) { return x; }
+        }
+      };
+
+      var result = new SymbolDefinition(root);
+      expect(result.observable).toBe(root.Symbol.for('observable'));
+    });
+
+    it('should patch root if for symbol does not exist', function () {
+      var root = {};
+
+      var result = new SymbolDefinition(root);
+      expect(result.observable).toBe('@@observable');
+    });
+  });
+
+  describe('iterator symbol', function () {
+    it('should patch root using for symbol if exist', function () {
+      var root = {
+        Symbol: {
+          for: function (x) { return x; }
+        }
+      };
+
+      var result = new SymbolDefinition(root);
+      expect(result.iterator).toBe(root.Symbol.for('iterator'));
+    });
+
+    it('should patch root if for symbol does not exist', function () {
+      var root = {};
+
+      var result = new SymbolDefinition(root);
+      expect(result.iterator).toBe('@@iterator');
+    });
+
+    it('should patch using set for mozilla', function () {
+      var root = {
+        Set: function () {
+          var ret = {};
+          ret['@@iterator'] = function () {};
+          return ret;
+        }
+      };
+
+      var result = new SymbolDefinition(root);
+      expect(result.iterator).toBe('@@iterator');
+    });
+
+    it('should patch using map for es6-shim', function () {
+      var root = {
+        Map: Map
+      };
+
+      root.Map.prototype.key = 'iteratorValue';
+      root.Map.prototype.entries = 'iteratorValue';
+
+      var result = new SymbolDefinition(root);
+      expect(result.iterator).toBe('key');
+    });
+  });
+});

src/util/SymbolShim.ts

@@ -1,48 +1,57 @@
 import {root} from './root';
 
-if (!root.Symbol) {
-  root.Symbol = {};
-}
+export class SymbolDefinition {
+  observable: symbol = null;
+  iterator: symbol = null;
+
+  private applyObservable(): symbol {
+    const root = this.root;
+
+    if (!root.Symbol.observable) {
+      if (typeof root.Symbol.for === 'function') {
+        root.Symbol.observable = root.Symbol.for('observable');
+      } else {
+        root.Symbol.observable = '@@observable';
+      }
+    }
 
-if (!root.Symbol.observable) {
-  if (typeof root.Symbol.for === 'function') {
-    root.Symbol.observable = root.Symbol.for('observable');
-  } else {
-    root.Symbol.observable = '@@observable';
+    return root.Symbol.observable;
   }
-}
 
-if (!root.Symbol.iterator) {
-  if (typeof root.Symbol.for === 'function') {
-    root.Symbol.iterator = root.Symbol.for('iterator');
-  } else if (root.Set && typeof new root.Set()['@@iterator'] === 'function') {
-    // Bug for mozilla version
-    root.Symbol.iterator = '@@iterator';
-  } else if (root.Map) {
-    // es6-shim specific logic
-    let keys = Object.getOwnPropertyNames(root.Map.prototype);
-    for (let i = 0; i < keys.length; ++i) {
-      let key = keys[i];
-      if (key !== 'entries' && key !== 'size' && root.Map.prototype[key] === root.Map.prototype['entries']) {
-        root.Symbol.iterator = key;
-        break;
+  private applyIterator(): symbol {
+    const root = this.root;
+
+    if (!root.Symbol.iterator) {
+      if (typeof root.Symbol.for === 'function') {
+        root.Symbol.iterator = root.Symbol.for('iterator');
+      } else if (root.Set && typeof new root.Set()['@@iterator'] === 'function') {
+        // Bug for mozilla version
+        root.Symbol.iterator = '@@iterator';
+      } else if (root.Map) {
+        // es6-shim specific logic
+        let keys = Object.getOwnPropertyNames(root.Map.prototype);
+        for (let i = 0; i < keys.length; ++i) {
+          let key = keys[i];
+          if (key !== 'entries' && key !== 'size' && root.Map.prototype[key] === root.Map.prototype['entries']) {
+            root.Symbol.iterator = key;
+            break;
+          }
+        }
+      } else {
+        root.Symbol.iterator = '@@iterator';
       }
     }
-  } else {
-    root.Symbol.iterator = '@@iterator';
+
+    return root.Symbol.iterator;
   }
-}
 
-if (!root.Symbol.dispose) {
-  if (typeof root.Symbol.for === 'function') {
-    root.Symbol.dispose = root.Symbol.for('dispose');
-  } else {
-    root.Symbol.dispose = '@@dispose';
+  constructor(private root: any) {
+    if (!root.Symbol) {
+      root.Symbol = {};
+    }
+
+    this.observable = this.applyObservable();
+    this.iterator = this.applyIterator();
   }
 }
-
-export module SymbolShim {
-  export const observable: symbol = root.Symbol.observable;
-  export const iterator: symbol = root.Symbol.iterator;
-  export const dispose: symbol = root.Symbol.dispose;
-};
+export const SymbolShim = new SymbolDefinition(root);