should-immutable/should-immutable.js at master · shouldjs/should-immutable · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
(function(root, factory) {
  if (typeof define === 'function' && define.amd) {
    define(['should', 'immutable'], factory);
  } else if (typeof module === 'object' && module.exports) {
    factory(require('should'), require('immutable'));
  } else {
    factory(root.should, root.Immutable);
  }
}(this, function(should, Immutable) {

var Iterable = Immutable.Iterable;
var Set = Immutable.Set;
var List = Immutable.Set;
var Map = Immutable.Set;

var t = should.modules.type;
var format = should.modules.format;
var eql = should.modules.equal;
var defaultTypeAdaptorStorage = should.config.typeAdaptors;


var IMMUTABLE_ITERABLE = new t.Type(t.OBJECT, 'immutable-iterable');
var IMMUTABLE_INDEXED = new t.Type(t.OBJECT, 'immutable-iterable', 'indexed');
var IMMUTABLE_KEYED = new t.Type(t.OBJECT, 'immutable-iterable', 'keyed');
var IMMUTABLE_SET = new t.Type(t.OBJECT, 'immutable-iterable', 'set');

t.checker.addBeforeFirstMatch(new List(), function(obj) {
  if (Iterable.isIndexed(obj)) {
    return IMMUTABLE_INDEXED;
  }
});

t.checker.addBeforeFirstMatch(new Map(), function(obj) {
  if (Iterable.isKeyed(obj)) {
    return IMMUTABLE_KEYED;
  }
});

t.checker.addBeforeFirstMatch(new Set(), function(obj) {
  if (Set.isSet(obj)) {
    return IMMUTABLE_SET;
  }
});

// must be last one
t.checker.addBeforeFirstMatch({}, function(obj) {
  if (Iterable.isIterable(obj)) {
    return IMMUTABLE_ITERABLE;
  }
});


defaultTypeAdaptorStorage.addType(IMMUTABLE_ITERABLE, {
  get: function(obj, key) {
    return obj.get(key);
  },

  has: function(obj, key) {
    return obj.has(key);
  },

  forEach: function(obj, f, context) {
    obj.forEach(f, context);
  },

  iterator: function(obj) {
    return obj.entries();
  },

  size: function(obj) {
    return obj.count();
  },

  isEmpty: function(obj) {
    return obj.isEmpty();
  }
});

format.Formatter.addType(IMMUTABLE_INDEXED, function(value) {
  return format.typeAdaptorForEachFormat.call(this, value, {
    formatKey: function() {
      return '';
    },
    brackets: ['[', ']']
  });
});

format.Formatter.addType(IMMUTABLE_KEYED, function(value) {
  return format.typeAdaptorForEachFormat.call(this, value, {
    keyValueSep: ' => '
  });
});

format.Formatter.addType(IMMUTABLE_SET, function(value) {
  return format.typeAdaptorForEachFormat.call(this, value, {
    formatKey: function() {
      return '';
    }
  });
});

eql.EQ.add(IMMUTABLE_ITERABLE.type, IMMUTABLE_ITERABLE.cls, function(a, b) {
  this.collectFail(!a.equals(b), 'Immutable iterables are not equal');
});

defaultTypeAdaptorStorage.addIterableType(IMMUTABLE_INDEXED);
defaultTypeAdaptorStorage.addIterableType(IMMUTABLE_SET);

}));