| 1 | var assert = require('assert');
|
| 2 | var Traverse = require('../');
|
| 3 | var deepEqual = require('./lib/deep_equal');
|
| 4 |
|
| 5 | exports.mutate = function () {
|
| 6 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 7 | var res = Traverse(obj).forEach(function (x) {
|
| 8 | if (typeof x === 'number' && x % 2 === 0) {
|
| 9 | this.update(x * 10);
|
| 10 | }
|
| 11 | });
|
| 12 | assert.deepEqual(obj, res);
|
| 13 | assert.deepEqual(obj, { a : 1, b : 20, c : [ 3, 40 ] });
|
| 14 | };
|
| 15 |
|
| 16 | exports.mutateT = function () {
|
| 17 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 18 | var res = Traverse.forEach(obj, function (x) {
|
| 19 | if (typeof x === 'number' && x % 2 === 0) {
|
| 20 | this.update(x * 10);
|
| 21 | }
|
| 22 | });
|
| 23 | assert.deepEqual(obj, res);
|
| 24 | assert.deepEqual(obj, { a : 1, b : 20, c : [ 3, 40 ] });
|
| 25 | };
|
| 26 |
|
| 27 | exports.map = function () {
|
| 28 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 29 | var res = Traverse(obj).map(function (x) {
|
| 30 | if (typeof x === 'number' && x % 2 === 0) {
|
| 31 | this.update(x * 10);
|
| 32 | }
|
| 33 | });
|
| 34 | assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
|
| 35 | assert.deepEqual(res, { a : 1, b : 20, c : [ 3, 40 ] });
|
| 36 | };
|
| 37 |
|
| 38 | exports.mapT = function () {
|
| 39 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 40 | var res = Traverse.map(obj, function (x) {
|
| 41 | if (typeof x === 'number' && x % 2 === 0) {
|
| 42 | this.update(x * 10);
|
| 43 | }
|
| 44 | });
|
| 45 | assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
|
| 46 | assert.deepEqual(res, { a : 1, b : 20, c : [ 3, 40 ] });
|
| 47 | };
|
| 48 |
|
| 49 | exports.clone = function () {
|
| 50 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 51 | var res = Traverse(obj).clone();
|
| 52 | assert.deepEqual(obj, res);
|
| 53 | assert.ok(obj !== res);
|
| 54 | obj.a ++;
|
| 55 | assert.deepEqual(res.a, 1);
|
| 56 | obj.c.push(5);
|
| 57 | assert.deepEqual(res.c, [ 3, 4 ]);
|
| 58 | };
|
| 59 |
|
| 60 | exports.cloneT = function () {
|
| 61 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 62 | var res = Traverse.clone(obj);
|
| 63 | assert.deepEqual(obj, res);
|
| 64 | assert.ok(obj !== res);
|
| 65 | obj.a ++;
|
| 66 | assert.deepEqual(res.a, 1);
|
| 67 | obj.c.push(5);
|
| 68 | assert.deepEqual(res.c, [ 3, 4 ]);
|
| 69 | };
|
| 70 |
|
| 71 | exports.reduce = function () {
|
| 72 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 73 | var res = Traverse(obj).reduce(function (acc, x) {
|
| 74 | if (this.isLeaf) acc.push(x);
|
| 75 | return acc;
|
| 76 | }, []);
|
| 77 | assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
|
| 78 | assert.deepEqual(res, [ 1, 2, 3, 4 ]);
|
| 79 | };
|
| 80 |
|
| 81 | exports.reduceInit = function () {
|
| 82 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 83 | var res = Traverse(obj).reduce(function (acc, x) {
|
| 84 | if (this.isRoot) assert.fail('got root');
|
| 85 | return acc;
|
| 86 | });
|
| 87 | assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
|
| 88 | assert.deepEqual(res, obj);
|
| 89 | };
|
| 90 |
|
| 91 | exports.remove = function () {
|
| 92 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 93 | Traverse(obj).forEach(function (x) {
|
| 94 | if (this.isLeaf && x % 2 == 0) this.remove();
|
| 95 | });
|
| 96 |
|
| 97 | assert.deepEqual(obj, { a : 1, c : [ 3 ] });
|
| 98 | };
|
| 99 |
|
| 100 | exports.removeNoStop = function() {
|
| 101 | var obj = { a : 1, b : 2, c : { d: 3, e: 4 }, f: 5 };
|
| 102 |
|
| 103 | var keys = [];
|
| 104 | Traverse(obj).forEach(function (x) {
|
| 105 | keys.push(this.key)
|
| 106 | if (this.key == 'c') this.remove();
|
| 107 | });
|
| 108 |
|
| 109 | assert.deepEqual(keys, [undefined, 'a', 'b', 'c', 'd', 'e', 'f'])
|
| 110 | }
|
| 111 |
|
| 112 | exports.removeStop = function() {
|
| 113 | var obj = { a : 1, b : 2, c : { d: 3, e: 4 }, f: 5 };
|
| 114 |
|
| 115 | var keys = [];
|
| 116 | Traverse(obj).forEach(function (x) {
|
| 117 | keys.push(this.key)
|
| 118 | if (this.key == 'c') this.remove(true);
|
| 119 | });
|
| 120 |
|
| 121 | assert.deepEqual(keys, [undefined, 'a', 'b', 'c', 'f'])
|
| 122 | }
|
| 123 |
|
| 124 | exports.removeMap = function () {
|
| 125 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 126 | var res = Traverse(obj).map(function (x) {
|
| 127 | if (this.isLeaf && x % 2 == 0) this.remove();
|
| 128 | });
|
| 129 |
|
| 130 | assert.deepEqual(obj, { a : 1, b : 2, c : [ 3, 4 ] });
|
| 131 | assert.deepEqual(res, { a : 1, c : [ 3 ] });
|
| 132 | };
|
| 133 |
|
| 134 | exports.delete = function () {
|
| 135 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 136 | Traverse(obj).forEach(function (x) {
|
| 137 | if (this.isLeaf && x % 2 == 0) this.delete();
|
| 138 | });
|
| 139 |
|
| 140 | assert.ok(!deepEqual(
|
| 141 | obj, { a : 1, c : [ 3, undefined ] }
|
| 142 | ));
|
| 143 |
|
| 144 | assert.ok(deepEqual(
|
| 145 | obj, { a : 1, c : [ 3 ] }
|
| 146 | ));
|
| 147 |
|
| 148 | assert.ok(!deepEqual(
|
| 149 | obj, { a : 1, c : [ 3, null ] }
|
| 150 | ));
|
| 151 | };
|
| 152 |
|
| 153 | exports.deleteNoStop = function() {
|
| 154 | var obj = { a : 1, b : 2, c : { d: 3, e: 4 } };
|
| 155 |
|
| 156 | var keys = [];
|
| 157 | Traverse(obj).forEach(function (x) {
|
| 158 | keys.push(this.key)
|
| 159 | if (this.key == 'c') this.delete();
|
| 160 | });
|
| 161 |
|
| 162 | assert.deepEqual(keys, [undefined, 'a', 'b', 'c', 'd', 'e'])
|
| 163 | }
|
| 164 |
|
| 165 | exports.deleteStop = function() {
|
| 166 | var obj = { a : 1, b : 2, c : { d: 3, e: 4 } };
|
| 167 |
|
| 168 | var keys = [];
|
| 169 | Traverse(obj).forEach(function (x) {
|
| 170 | keys.push(this.key)
|
| 171 | if (this.key == 'c') this.delete(true);
|
| 172 | });
|
| 173 |
|
| 174 | assert.deepEqual(keys, [undefined, 'a', 'b', 'c'])
|
| 175 | }
|
| 176 |
|
| 177 | exports.deleteRedux = function () {
|
| 178 | var obj = { a : 1, b : 2, c : [ 3, 4, 5 ] };
|
| 179 | Traverse(obj).forEach(function (x) {
|
| 180 | if (this.isLeaf && x % 2 == 0) this.delete();
|
| 181 | });
|
| 182 |
|
| 183 | assert.ok(!deepEqual(
|
| 184 | obj, { a : 1, c : [ 3, undefined, 5 ] }
|
| 185 | ));
|
| 186 |
|
| 187 | assert.ok(deepEqual(
|
| 188 | obj, { a : 1, c : [ 3 ,, 5 ] }
|
| 189 | ));
|
| 190 |
|
| 191 | assert.ok(!deepEqual(
|
| 192 | obj, { a : 1, c : [ 3, null, 5 ] }
|
| 193 | ));
|
| 194 |
|
| 195 | assert.ok(!deepEqual(
|
| 196 | obj, { a : 1, c : [ 3, 5 ] }
|
| 197 | ));
|
| 198 | };
|
| 199 |
|
| 200 | exports.deleteMap = function () {
|
| 201 | var obj = { a : 1, b : 2, c : [ 3, 4 ] };
|
| 202 | var res = Traverse(obj).map(function (x) {
|
| 203 | if (this.isLeaf && x % 2 == 0) this.delete();
|
| 204 | });
|
| 205 |
|
| 206 | assert.ok(deepEqual(
|
| 207 | obj,
|
| 208 | { a : 1, b : 2, c : [ 3, 4 ] }
|
| 209 | ));
|
| 210 |
|
| 211 | var xs = [ 3, 4 ];
|
| 212 | delete xs[1];
|
| 213 |
|
| 214 | assert.ok(deepEqual(
|
| 215 | res, { a : 1, c : xs }
|
| 216 | ));
|
| 217 |
|
| 218 | assert.ok(deepEqual(
|
| 219 | res, { a : 1, c : [ 3, ] }
|
| 220 | ));
|
| 221 |
|
| 222 | assert.ok(deepEqual(
|
| 223 | res, { a : 1, c : [ 3 ] }
|
| 224 | ));
|
| 225 | };
|
| 226 |
|
| 227 | exports.deleteMapRedux = function () {
|
| 228 | var obj = { a : 1, b : 2, c : [ 3, 4, 5 ] };
|
| 229 | var res = Traverse(obj).map(function (x) {
|
| 230 | if (this.isLeaf && x % 2 == 0) this.delete();
|
| 231 | });
|
| 232 |
|
| 233 | assert.ok(deepEqual(
|
| 234 | obj,
|
| 235 | { a : 1, b : 2, c : [ 3, 4, 5 ] }
|
| 236 | ));
|
| 237 |
|
| 238 | var xs = [ 3, 4, 5 ];
|
| 239 | delete xs[1];
|
| 240 |
|
| 241 | assert.ok(deepEqual(
|
| 242 | res, { a : 1, c : xs }
|
| 243 | ));
|
| 244 |
|
| 245 | assert.ok(!deepEqual(
|
| 246 | res, { a : 1, c : [ 3, 5 ] }
|
| 247 | ));
|
| 248 |
|
| 249 | assert.ok(deepEqual(
|
| 250 | res, { a : 1, c : [ 3 ,, 5 ] }
|
| 251 | ));
|
| 252 | };
|