github
/
d3
зеркало из
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Use _ to disambiguate local vs. global d3.

This commit is contained in:
Mike Bostock 2013-03-14 15:14:12 -07:00
Родитель 2b3abf606f
Коммит 0d7c6c55e7
31 изменённых файлов: 193 добавлений и 192 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

4
test/arrays/max-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -39,7 +39,7 @@ suite.addBatch({
assert.isUndefined(max([NaN, NaN]));
},
"applies the optional accessor function": function(max) {
assert.equal(max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.min(d); }), 2);
assert.equal(max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.min(d); }), 2);
assert.equal(max([1, 2, 3, 4, 5], function(d, i) { return i; }), 4);
}
}

4
test/arrays/min-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -38,7 +38,7 @@ suite.addBatch({
assert.isUndefined(min([NaN, NaN]));
},
"applies the optional accessor function": function(min) {
assert.equal(min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.max(d); }), 5);
assert.equal(min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.max(d); }), 5);
assert.equal(min([1, 2, 3, 4, 5], function(d, i) { return i; }), 0);
}
}

46
test/arrays/nest-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -13,7 +13,7 @@ suite.addBatch({
.key(function(d) { return d.foo; })
.entries([{foo: 1}, {foo: 1}, {foo: 2}])
.map(function(d) { return d.key; })
.sort(d3.ascending);
.sort(_.ascending);
assert.deepEqual(keys, ["1", "2"]);
},
"each entry is a key-values object, with values in input order": function(nest) {
@ -27,7 +27,7 @@ suite.addBatch({
},
"keys can be sorted using an optional comparator": function(nest) {
var keys = nest()
.key(function(d) { return d.foo; }).sortKeys(d3.descending)
.key(function(d) { return d.foo; }).sortKeys(_.descending)
.entries([{foo: 1}, {foo: 1}, {foo: 2}])
.map(function(d) { return d.key; });
assert.deepEqual(keys, ["2", "1"]);
@ -45,7 +45,7 @@ suite.addBatch({
"values can be aggregated using an optional rollup": function(nest) {
var entries = nest()
.key(function(d) { return d.foo; })
.rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
.rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
.entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
assert.deepEqual(entries, [
{key: "1", values: 3},
@ -54,8 +54,8 @@ suite.addBatch({
},
"multiple key functions can be specified": function(nest) {
var entries = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
.key(function(d) { return d[0]; }).sortKeys(_.ascending)
.key(function(d) { return d[1]; }).sortKeys(_.ascending)
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
assert.deepEqual(entries, [
{key: "0", values: [
@ -70,8 +70,8 @@ suite.addBatch({
},
"the rollup function only applies to leaf values": function(nest) {
var entries = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
.key(function(d) { return d[0]; }).sortKeys(_.ascending)
.key(function(d) { return d[1]; }).sortKeys(_.ascending)
.rollup(function(values) { return values.length; })
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
assert.deepEqual(entries, [
@ -87,8 +87,8 @@ suite.addBatch({
},
"the value comparator only applies to leaf values": function(nest) {
var entries = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
.key(function(d) { return d[0]; }).sortKeys(_.ascending)
.key(function(d) { return d[1]; }).sortKeys(_.ascending)
.sortValues(function(a, b) { return a[2] - b[2]; })
.entries([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
assert.deepEqual(entries, [
@ -104,8 +104,8 @@ suite.addBatch({
},
"the key comparator only applies to the last-specified key": function(nest) {
var entries = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
.key(function(d) { return d[1]; }).sortKeys(d3.descending)
.key(function(d) { return d[0]; }).sortKeys(_.ascending)
.key(function(d) { return d[1]; }).sortKeys(_.descending)
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
assert.deepEqual(entries, [
{key: "0", values: [
@ -118,8 +118,8 @@ suite.addBatch({
]}
]);
var entries = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.descending)
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
.key(function(d) { return d[0]; }).sortKeys(_.descending)
.key(function(d) { return d[1]; }).sortKeys(_.ascending)
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
assert.deepEqual(entries, [
{key: "1", values: [
@ -164,7 +164,7 @@ suite.addBatch({
"values can be aggregated using an optional rollup": function(nest) {
var map = nest()
.key(function(d) { return d.foo; })
.rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
.rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
.map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
assert.deepEqual(map, {
"1": 3,
@ -173,8 +173,8 @@ suite.addBatch({
},
"multiple key functions can be specified": function(nest) {
var map = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
.key(function(d) { return d[0]; }).sortKeys(_.ascending)
.key(function(d) { return d[1]; }).sortKeys(_.ascending)
.map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
assert.deepEqual(map, {
"0": {
@ -189,8 +189,8 @@ suite.addBatch({
},
"the rollup function only applies to leaf values": function(nest) {
var map = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
.key(function(d) { return d[0]; }).sortKeys(_.ascending)
.key(function(d) { return d[1]; }).sortKeys(_.ascending)
.rollup(function(values) { return values.length; })
.map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
assert.deepEqual(map, {
@ -206,8 +206,8 @@ suite.addBatch({
},
"the value comparator only applies to leaf values": function(nest) {
var map = nest()
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
.key(function(d) { return d[0]; }).sortKeys(_.ascending)
.key(function(d) { return d[1]; }).sortKeys(_.ascending)
.sortValues(function(a, b) { return a[2] - b[2]; })
.map([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
assert.deepEqual(map, {
@ -234,7 +234,7 @@ suite.addBatch({
"a custom map implementation can be specified": function(nest) {
var map = nest()
.key(String)
.map(["hasOwnProperty", "__proto__"], d3.map);
.map(["hasOwnProperty", "__proto__"], _.map);
assert.deepEqual(map.entries(), [
{key: "hasOwnProperty", value: ["hasOwnProperty"]},
{key: "__proto__", value: ["__proto__"]}
@ -244,7 +244,7 @@ suite.addBatch({
var map = nest()
.key(function(d) { return d.foo; })
.key(function(d) { return d.bar; })
.map([{foo: 42, bar: "red"}], d3.map);
.map([{foo: 42, bar: "red"}], _.map);
assert.deepEqual(map.keys(), ["42"]);
assert.deepEqual(map.get("42").keys(), ["red"]);
assert.deepEqual(map.get("42").values(), [[{foo: 42, bar: "red"}]]);

10
test/arrays/set-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("assert");
@ -36,19 +36,19 @@ suite.addBatch({
},
"values are returned in arbitrary order": function(set) {
var s = set(["foo", "bar"]);
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
var s = set(["bar", "foo"]);
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
},
"observes changes via add and remove": function(set) {
var s = set(["foo", "bar"]);
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
s.remove("foo");
assert.deepEqual(s.values(), ["bar"]);
s.add("bar");
assert.deepEqual(s.values(), ["bar"]);
s.add("foo");
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
assert.deepEqual(s.values().sort(_.ascending), ["bar", "foo"]);
s.remove("bar");
assert.deepEqual(s.values(), ["foo"]);
s.remove("foo");

10
test/color/hcl-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -46,7 +46,7 @@ suite.addBatch({
assertHclEqual(hcl("rgb(102, 102, 0)"), 102.85124420310271, 49.44871600399321, 41.73251953866431);
},
"can convert from RGB": function(hcl) {
assertHclEqual(hcl(d3.rgb(12, 34, 56)), -89.58282792342067, 16.833655998102003, 12.65624852526134);
assertHclEqual(hcl(_.rgb(12, 34, 56)), -89.58282792342067, 16.833655998102003, 12.65624852526134);
},
"can convert from HSL": function(hcl) {
assertHclEqual(hcl(hcl(20, .8, .3)), 20, 0.8, 0.3);
@ -67,13 +67,13 @@ suite.addBatch({
assert.strictEqual(hcl(hcl(60, -4, 32)) + "", "#454c51");
},
"roundtrip to HSL is idempotent": function(hcl) {
assert.hslEqual(d3.hsl(hcl("steelblue")), d3.hsl("steelblue"));
assert.hslEqual(_.hsl(hcl("steelblue")), _.hsl("steelblue"));
},
"roundtrip to RGB is idempotent": function(hcl) {
assert.hslEqual(d3.rgb(hcl("steelblue")), d3.rgb("steelblue"));
assert.hslEqual(_.rgb(hcl("steelblue")), _.rgb("steelblue"));
},
"roundtrip to Lab is idempotent": function(hcl) {
assert.hslEqual(d3.lab(hcl("steelblue")), d3.lab("steelblue"));
assert.hslEqual(_.lab(hcl("steelblue")), _.lab("steelblue"));
}
}
});

4
test/color/hsl-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -49,7 +49,7 @@ suite.addBatch({
assert.hslEqual(hsl("rgb(102, 102, 0)"), 60, 1, .2);
},
"can convert from RGB": function(hsl) {
assert.hslEqual(hsl(d3.rgb(12, 34, 56)), 210, .647058, .133333);
assert.hslEqual(hsl(_.rgb(12, 34, 56)), 210, .647058, .133333);
},
"can convert from HSL": function(hsl) {
assert.hslEqual(hsl(hsl(20, .8, .3)), 20, .8, .3);

10
test/color/lab-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -46,7 +46,7 @@ suite.addBatch({
assertLabEqual(lab("rgb(102, 102, 0)"), 41.73251953866431, -10.998411255098816, 48.21006600604577);
},
"can convert from RGB": function(lab) {
assertLabEqual(lab(d3.rgb(12, 34, 56)), 12.65624852526134, 0.12256520883417721, -16.833209795877284);
assertLabEqual(lab(_.rgb(12, 34, 56)), 12.65624852526134, 0.12256520883417721, -16.833209795877284);
},
"can convert from HSL": function(lab) {
assertLabEqual(lab(lab(20, .8, .3)), 20, 0.8, 0.3);
@ -67,13 +67,13 @@ suite.addBatch({
assert.strictEqual(lab(lab(60, -4, -32)) + "", "#5d95c8");
},
"roundtrip to HSL is idempotent": function(lab) {
assert.hslEqual(d3.hsl(lab("steelblue")), d3.hsl("steelblue"));
assert.hslEqual(_.hsl(lab("steelblue")), _.hsl("steelblue"));
},
"roundtrip to RGB is idempotent": function(lab) {
assert.hslEqual(d3.rgb(lab("steelblue")), d3.rgb("steelblue"));
assert.hslEqual(_.rgb(lab("steelblue")), _.rgb("steelblue"));
},
"roundtrip to HCL is idempotent": function(lab) {
assert.hslEqual(d3.hcl(lab("steelblue")), d3.hcl("steelblue"));
assert.hslEqual(_.hcl(lab("steelblue")), _.hcl("steelblue"));
}
}
});

6
test/color/rgb-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -60,7 +60,7 @@ suite.addBatch({
assert.rgbEqual(rgb(rgb(12, 34, 56)), 12, 34, 56);
},
"can convert from HSL": function(rgb) {
assert.rgbEqual(rgb(d3.hsl(0, 1, .5)), 255, 0, 0);
assert.rgbEqual(rgb(_.hsl(0, 1, .5)), 255, 0, 0);
},
"can convert to HSL": function(rgb) {
assert.hslEqual(rgb("red").hsl(), 0, 1, .5);
@ -83,7 +83,7 @@ suite.addBatch({
assert.strictEqual(rgb("hsl(60, 100%, 20%)") + "", "#666600");
assert.strictEqual(rgb("rgb(12, 34, 56)") + "", "#0c2238");
assert.strictEqual(rgb(rgb(12, 34, 56)) + "", "#0c2238");
assert.strictEqual(rgb(d3.hsl(60, 1, .2)) + "", "#666600");
assert.strictEqual(rgb(_.hsl(60, 1, .2)) + "", "#666600");
}
}
});

5
test/geo/area-benchmark.js
Просмотреть файл

@ -1,5 +1,6 @@
var d3 = require("../../"),
formatNumber = d3.format(",.02r"),
var d3 = require("../../");
var formatNumber = d3.format(",.02r"),
o = d3.geo.circle().angle(30).precision(.1)(),
n = 1e3,
then = Date.now();

46
test/geo/area-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -53,51 +53,51 @@ suite.addBatch({
},
"graticule outline": {
"sphere": function(area) {
assert.inDelta(area(d3.geo.graticule().extent([[-180, -90], [180, 90]]).outline()), 4 * π, 1e-5);
assert.inDelta(area(_.geo.graticule().extent([[-180, -90], [180, 90]]).outline()), 4 * π, 1e-5);
},
"hemisphere": function(area) {
assert.inDelta(area(d3.geo.graticule().extent([[-180, 0], [180, 90]]).outline()), 2 * π, 1e-5);
assert.inDelta(area(_.geo.graticule().extent([[-180, 0], [180, 90]]).outline()), 2 * π, 1e-5);
},
"semilune": function(area) {
assert.inDelta(area(d3.geo.graticule().extent([[0, 0], [90, 90]]).outline()), π / 2, 1e-5);
assert.inDelta(area(_.geo.graticule().extent([[0, 0], [90, 90]]).outline()), π / 2, 1e-5);
}
},
"circles": {
"hemisphere": function(area) {
assert.inDelta(area(d3.geo.circle().angle(90)()), 2 * π, 1e-5);
assert.inDelta(area(_.geo.circle().angle(90)()), 2 * π, 1e-5);
},
"60°": function(area) {
assert.inDelta(area(d3.geo.circle().angle(60).precision(.1)()), π, 1e-5);
assert.inDelta(area(_.geo.circle().angle(60).precision(.1)()), π, 1e-5);
},
"60° North": function(area) {
assert.inDelta(area(d3.geo.circle().angle(60).precision(.1).origin([0, 90])()), π, 1e-5);
assert.inDelta(area(_.geo.circle().angle(60).precision(.1).origin([0, 90])()), π, 1e-5);
},
"45°": function(area) {
assert.inDelta(area(d3.geo.circle().angle(45).precision(.1)()), π * (2 - Math.SQRT2), 1e-5);
assert.inDelta(area(_.geo.circle().angle(45).precision(.1)()), π * (2 - Math.SQRT2), 1e-5);
},
"45° North": function(area) {
assert.inDelta(area(d3.geo.circle().angle(45).precision(.1).origin([0, 90])()), π * (2 - Math.SQRT2), 1e-5);
assert.inDelta(area(_.geo.circle().angle(45).precision(.1).origin([0, 90])()), π * (2 - Math.SQRT2), 1e-5);
},
"45° South": function(area) {
assert.inDelta(area(d3.geo.circle().angle(45).precision(.1).origin([0, -90])()), π * (2 - Math.SQRT2), 1e-5);
assert.inDelta(area(_.geo.circle().angle(45).precision(.1).origin([0, -90])()), π * (2 - Math.SQRT2), 1e-5);
},
"135°": function(area) {
assert.inDelta(area(d3.geo.circle().angle(135).precision(.1)()), π * (2 + Math.SQRT2), 1e-5);
assert.inDelta(area(_.geo.circle().angle(135).precision(.1)()), π * (2 + Math.SQRT2), 1e-5);
},
"135° North": function(area) {
assert.inDelta(area(d3.geo.circle().angle(135).precision(.1).origin([0, 90])()), π * (2 + Math.SQRT2), 1e-5);
assert.inDelta(area(_.geo.circle().angle(135).precision(.1).origin([0, 90])()), π * (2 + Math.SQRT2), 1e-5);
},
"135° South": function(area) {
assert.inDelta(area(d3.geo.circle().angle(135).precision(.1).origin([0, -90])()), π * (2 + Math.SQRT2), 1e-5);
assert.inDelta(area(_.geo.circle().angle(135).precision(.1).origin([0, -90])()), π * (2 + Math.SQRT2), 1e-5);
},
"tiny": function(area) {
assert.inDelta(area(d3.geo.circle().angle(1e-6).precision(.1)()), 0, 1e-6);
assert.inDelta(area(_.geo.circle().angle(1e-6).precision(.1)()), 0, 1e-6);
},
"huge": function(area) {
assert.inDelta(area(d3.geo.circle().angle(180 - 1e-6).precision(.1)()), 4 * π, 1e-6);
assert.inDelta(area(_.geo.circle().angle(180 - 1e-6).precision(.1)()), 4 * π, 1e-6);
},
"60° with 45° hole": function(area) {
var circle = d3.geo.circle().precision(.1);
var circle = _.geo.circle().precision(.1);
assert.inDelta(area({
type: "Polygon",
coordinates: [
@ -107,7 +107,7 @@ suite.addBatch({
}), π * (Math.SQRT2 - 1), 1e-5);
},
"45° holes at [0°, 0°] and [0°, 90°]": function(area) {
var circle = d3.geo.circle().precision(.1).angle(45);
var circle = _.geo.circle().precision(.1).angle(45);
assert.inDelta(area({
type: "Polygon",
coordinates: [
@ -117,7 +117,7 @@ suite.addBatch({
}), π * 2 * Math.SQRT2, 1e-5);
},
"45° holes at [0°, 90°] and [0°, 0°]": function(area) {
var circle = d3.geo.circle().precision(.1).angle(45);
var circle = _.geo.circle().precision(.1).angle(45);
assert.inDelta(area({
type: "Polygon",
coordinates: [
@ -129,13 +129,13 @@ suite.addBatch({
},
"stripes": {
"45°, -45°": function(area) {
assert.inDelta(area(stripes(d3, 45, -45)), π * 2 * Math.SQRT2, 1e-5);
assert.inDelta(area(stripes(45, -45)), π * 2 * Math.SQRT2, 1e-5);
},
"-45°, 45°": function(area) {
assert.inDelta(area(stripes(d3, -45, 45)), π * 2 * (2 - Math.SQRT2), 1e-5);
assert.inDelta(area(stripes(-45, 45)), π * 2 * (2 - Math.SQRT2), 1e-5);
},
"45°, 30°": function(area) {
assert.inDelta(area(stripes(d3, 45, 30)), π * (Math.SQRT2 - 1), 1e-5);
assert.inDelta(area(stripes(45, 30)), π * (Math.SQRT2 - 1), 1e-5);
}
}
},
@ -164,9 +164,9 @@ suite.addBatch({
suite.export(module);
function stripes(d3, a, b) {
function stripes(a, b) {
return {type: "Polygon", coordinates: [a, b].map(function(d, i) {
var stripe = d3.range(-180, 180, .1).map(function(x) { return [x, d]; });
var stripe = _.range(-180, 180, .1).map(function(x) { return [x, d]; });
stripe.push(stripe[0]);
return i ? stripe.reverse() : stripe;
})};

6
test/geo/centroid-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -43,8 +43,8 @@ suite.addBatch({
},
"Polygon": function(centroid) {
assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -90], [0, 0], [0, 90], [1, 0], [0, -90]]]}), [.5, 0], 1e-6);
//assert.inDelta(centroid(d3.geo.circle().angle(5).origin([0, 45])()), [0, 45], 1e-6);
assert.equal(centroid({type: "Polygon", coordinates: [d3.range(-180, 180 + 1 / 2, 1).map(function(x) { return [x, -60]; })]})[1], -90);
assert.inDelta(centroid(_.geo.circle().angle(5).origin([0, 45])()), [0, 45], 1e-6);
assert.equal(centroid({type: "Polygon", coordinates: [_.range(-180, 180 + 1 / 2, 1).map(function(x) { return [x, -60]; })]})[1], -90);
assert.inDelta(centroid({type: "Polygon", coordinates: [[[0, -10], [0, 10], [10, 10], [10, -10], [0, -10]]]}), [5, 0], 1e-6);
},
"MultiPolygon": function(centroid) {

4
test/geo/circle-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -16,7 +16,7 @@ suite.addBatch({
"origin([0, 90])": function(circle) {
var o = circle().origin([0, 90])();
assert.equal(o.type, "Polygon");
assert.inDelta(o.coordinates, [d3.range(360, -1, -6).map(function(x) { return [x >= 180 ? x - 360 : x, 0]; })], 1e-6);
assert.inDelta(o.coordinates, [_.range(360, -1, -6).map(function(x) { return [x >= 180 ? x - 360 : x, 0]; })], 1e-6);
},
"origin([45, 45])": function(circle) {
var o = circle().origin([45, 45]).angle(0)();

8
test/geo/graticule-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -121,7 +121,7 @@ suite.addBatch({
.filter(function(line) { return line.coordinates[0][0] === line.coordinates[1][0]; })
.filter(function(line) { return Math.abs(line.coordinates[0][0] % 90) > ε; });
lines.forEach(function(line) {
assert.deepEqual(d3.extent(line.coordinates, function(p) { return p[1]; }), [-80 - ε, +80 + ε]);
assert.deepEqual(_.extent(line.coordinates, function(p) { return p[1]; }), [-80 - ε, +80 + ε]);
});
},
"default major longitude lines extend from 90°S to 90°N": function(graticule) {
@ -129,14 +129,14 @@ suite.addBatch({
.filter(function(line) { return line.coordinates[0][0] === line.coordinates[1][0]; })
.filter(function(line) { return Math.abs(line.coordinates[0][0] % 90) < ε; });
lines.forEach(function(line) {
assert.deepEqual(d3.extent(line.coordinates, function(p) { return p[1]; }), [-90 + ε, +90 - ε]);
assert.deepEqual(_.extent(line.coordinates, function(p) { return p[1]; }), [-90 + ε, +90 - ε]);
});
},
"default latitude lines extend from 180°W to 180°E": function(graticule) {
var lines = graticule().lines()
.filter(function(line) { return line.coordinates[0][1] === line.coordinates[1][1]; });
lines.forEach(function(line) {
assert.deepEqual(d3.extent(line.coordinates, function(p) { return p[0]; }), [-180, +180]);
assert.deepEqual(_.extent(line.coordinates, function(p) { return p[0]; }), [-180, +180]);
});
},
"returns an array of LineStrings": function(graticule) {

80
test/geo/path-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -13,7 +13,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.precision(0));
},
@ -261,7 +261,7 @@ suite.addBatch({
"with the default context (null) and an identity projection": {
topic: function(path) {
return path()
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.precision(0));
},
@ -307,7 +307,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([-180, -248])
.scale(900 / Math.PI)
.precision(0));
@ -320,7 +320,7 @@ suite.addBatch({
"projection": {
"returns the current projection when called with no arguments": function(path) {
var p = path(), projection = d3.geo.equirectangular();
var p = path(), projection = _.geo.equirectangular();
p.projection(projection);
assert.strictEqual(p.projection(), projection);
}
@ -351,7 +351,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.precision(0)
.clipAngle(90));
@ -385,22 +385,22 @@ suite.addBatch({
assert.equal(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }).length, 1);
},
"renders a small circle of 60°": function(p) {
p(d3.geo.circle().angle(60)());
p(_.geo.circle().angle(60)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 276, y: 493}]);
},
"renders a small circle of 120°": function(p) {
p(d3.geo.circle().angle(120)());
p(_.geo.circle().angle(120)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 87, y: 700}]);
}
},
"with an equirectangular projection clipped to 90° and rotated by [-17°, -451°]": {
"renders a polygon": function(path) {
var pole = d3.range(-180, 180, 10).map(function(x) { return [x, 70]; });
var pole = _.range(-180, 180, 10).map(function(x) { return [x, 70]; });
pole.push(pole[0]);
path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([-17, -451])
.scale(900 / Math.PI)
.precision(0)
@ -416,7 +416,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([71.03, 42.37])
.scale(900 / Math.PI)
.precision(0)
@ -424,7 +424,7 @@ suite.addBatch({
},
/*
"grid component": function(path) {
var yStepsBig = d3.range(-90, 90, 10);
var yStepsBig = _.range(-90, 90, 10);
path({type: "LineString", coordinates: yStepsBig.map(function(y) { return [110, y]; })});
assert.inDelta(testContext.buffer(), [[
[109.538009, -90],
@ -462,7 +462,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([-24, -175.5])
.scale(900 / Math.PI)
.precision(0)
@ -478,18 +478,18 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([90, 0])
.scale(900 / Math.PI)
.precision(0)
.clipAngle(90));
},
"renders a small circle of 60°": function(p) {
p(d3.geo.circle().angle(60)());
p(_.geo.circle().angle(60)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 930, y: 550}]);
},
"renders a small circle of 120°": function(p) {
p(d3.geo.circle().angle(120)());
p(_.geo.circle().angle(120)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 30, y: 550}]);
}
},
@ -498,18 +498,18 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([180, 0])
.scale(900 / Math.PI)
.precision(0)
.clipAngle(90));
},
"does not render a small circle of 60°": function(p) {
p(d3.geo.circle().angle(60)());
p(_.geo.circle().angle(60)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), []);
},
"renders a small circle of 120° in two parts": function(p) {
p(d3.geo.circle().angle(120)());
p(_.geo.circle().angle(120)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [
{type: "moveTo", x: 276, y: 493},
{type: "moveTo", x: 87, y: 700}
@ -521,18 +521,18 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([270, 0])
.scale(900 / Math.PI)
.precision(0)
.clipAngle(90));
},
"renders a small circle of 60°": function(p) {
p(d3.geo.circle().angle(60)());
p(_.geo.circle().angle(60)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 30, y: -50}]);
},
"renders a small circle of 120°": function(p) {
p(d3.geo.circle().angle(120)());
p(_.geo.circle().angle(120)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 930, y: -50}]);
}
},
@ -541,14 +541,14 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([210, 1])
.scale(900 / Math.PI)
.precision(0)
.clipAngle(90));
},
"renders a small circle of 120°": function(p) {
p(d3.geo.circle().angle(120)());
p(_.geo.circle().angle(120)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 930, y: 250}]);
}
},
@ -557,14 +557,14 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.rotate([-150, 60])
.scale(900 / Math.PI)
.precision(0)
.clipAngle(90));
},
"renders a small circle of 120°": function(p) {
p(d3.geo.circle().angle(120)());
p(_.geo.circle().angle(120)());
assert.deepEqual(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }), [{type: "moveTo", x: 30, y: -87}]);
},
"renders a sphere": function(p) {
@ -577,7 +577,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.precision(0)
.clipAngle(170));
@ -596,7 +596,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.rotate([0, -90])
.precision(0)
@ -615,7 +615,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.precision(0)
.clipAngle(30));
@ -633,7 +633,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.precision(0)
.clipAngle(150));
@ -653,7 +653,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.rotate([98, 0])
.precision(0));
@ -688,13 +688,13 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.rotate([330, 232])
.precision(0));
},
"renders degenerate points for a small circle of 30°": function(p) {
p(d3.geo.circle().angle(30)());
p(_.geo.circle().angle(30)());
assert.equal(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }).length, 2);
}
},
@ -703,14 +703,14 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.equirectangular()
.projection(_.geo.equirectangular()
.scale(900 / Math.PI)
.rotate([34.5, 90])
.precision(0));
},
"observes proper clip point ordering for lines": function(p) {
var line = d3.range(-90, 180, 10).map(function(x) { return [x, 20]; })
.concat(d3.range(170, -100, -10).map(function(x) { return [x, 0]; }))
var line = _.range(-90, 180, 10).map(function(x) { return [x, 20]; })
.concat(_.range(170, -100, -10).map(function(x) { return [x, 0]; }))
.concat([[-90, 20]]);
p({type: "Polygon", coordinates: [line]});
assert.equal(testContext.buffer().filter(function(d) { return d.type === "moveTo"; }).length, 3);
@ -721,7 +721,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.stereographic()
.projection(_.geo.stereographic()
.precision(1));
},
"correctly resamples points on antimeridian": function(p) {
@ -744,7 +744,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.albers()
.projection(_.geo.albers()
.scale(140)
.rotate([0, 0])
.precision(1));
@ -761,7 +761,7 @@ suite.addBatch({
topic: function(path) {
return path()
.context(testContext)
.projection(d3.geo.albers()
.projection(_.geo.albers()
.scale(140)
.rotate([11.5, 285])
.precision(1));
@ -786,7 +786,7 @@ var testContext = {
function stripes(a, b) {
return {type: "Polygon", coordinates: [a, b].map(function(d, i) {
var stripe = d3.range(-180, 180, 1).map(function(x) { return [x, d]; });
var stripe = _.range(-180, 180, 1).map(function(x) { return [x, d]; });
stripe.push(stripe[0]);
return i ? stripe.reverse() : stripe;
})};

4
test/geo/projection-test-suite.js
Просмотреть файл

@ -1,6 +1,6 @@
var assert = require("../assert"),
d3 = require("../../"),
format = d3.format("13.8f");
_ = require("../../"),
format = _.format("13.8f");
module.exports = function(suite, mapping) {

4
test/geom/polygon-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -81,7 +81,7 @@ suite.addBatch({
"large square": {
topic: function(polygon) {
var r = 1e8,
d = d3.range(0, r, r / 1e4);
d = _.range(0, r, r / 1e4);
return polygon(
d.map(function(y) { return [0, y]; }).concat(
d.map(function(x) { return [x, r]; })).concat(

8
test/scale/category-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -27,7 +27,7 @@ function category(category, n) {
var y = x.copy();
assert.deepEqual(y.domain(), x.domain());
assert.deepEqual(y.range(), x.range());
x.domain(d3.range(n));
x.domain(_.range(n));
for (var i = 0; i < n; ++i) assert.equal(x(i + n), x(i));
assert.equal(y(1), colors[0]);
assert.equal(y(2), colors[1]);
@ -56,7 +56,7 @@ function category(category, n) {
var x = scale[category]();
x.range().forEach(function(v) {
assert.match(v, /#[0-9a-f]{6}/);
v = d3.rgb(v);
v = _.rgb(v);
assert.isFalse(isNaN(v.r));
assert.isFalse(isNaN(v.g));
assert.isFalse(isNaN(v.b));
@ -65,7 +65,7 @@ function category(category, n) {
"no range values are very dark or very light": function(scale) {
var x = scale[category]();
x.range().forEach(function(v) {
var c = d3.hsl(v);
var c = _.hsl(v);
assert.isTrue(c.l >= .34, "expected " + v + " to be lighter (l = " + c.l + ")");
assert.isTrue(c.l <= .89, "expected " + v + " to be darker (l = " + c.l + ")");
});

16
test/scale/quantize-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -43,13 +43,13 @@ suite.addBatch({
},
"range cardinality determines the degree of quantization": function(quantize) {
var x = quantize();
assert.inDelta(x.range(d3.range(0, 1.001, .001))(1/3), .333, 1e-6);
assert.inDelta(x.range(d3.range(0, 1.01, .01))(1/3), .33, 1e-6);
assert.inDelta(x.range(d3.range(0, 1.1, .1))(1/3), .3, 1e-6);
assert.inDelta(x.range(d3.range(0, 1.2, .2))(1/3), .4, 1e-6);
assert.inDelta(x.range(d3.range(0, 1.25, .25))(1/3), .25, 1e-6);
assert.inDelta(x.range(d3.range(0, 1.5, .5))(1/3), .5, 1e-6);
assert.inDelta(x.range(d3.range(1))(1/3), 0, 1e-6);
assert.inDelta(x.range(_.range(0, 1.001, .001))(1/3), .333, 1e-6);
assert.inDelta(x.range(_.range(0, 1.01, .01))(1/3), .33, 1e-6);
assert.inDelta(x.range(_.range(0, 1.1, .1))(1/3), .3, 1e-6);
assert.inDelta(x.range(_.range(0, 1.2, .2))(1/3), .4, 1e-6);
assert.inDelta(x.range(_.range(0, 1.25, .25))(1/3), .25, 1e-6);
assert.inDelta(x.range(_.range(0, 1.5, .5))(1/3), .5, 1e-6);
assert.inDelta(x.range(_.range(1))(1/3), 0, 1e-6);
},
"range values are arbitrary": function(quantize) {
var a = {}, b = {}, c = {}, x = quantize().range([a, b, c]);

4
test/selection/attr-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
interpolateRgb = require("../../").interpolateRgb,
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -117,7 +117,7 @@ suite.addBatch({
assert.equal(div[0][1].getAttribute("bgcolor"), "coral");
},
"sets an attribute as a function of data": function(div) {
div.attr("bgcolor", interpolateRgb("brown", "steelblue"));
div.attr("bgcolor", _.interpolateRgb("brown", "steelblue"));
assert.equal(div[0][0].getAttribute("bgcolor"), "#a52a2a");
assert.equal(div[0][1].getAttribute("bgcolor"), "#4682b4");
},

4
test/selection/filter-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
merge = require("../../").merge,
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -23,7 +23,7 @@ suite.addBatch({
assert.isTrue(some[1][0] === span[1][0]);
},
"removes non-matching elements": function(span) {
var some = merge(span.filter(function(d, i) { return d & 1; }));
var some = _.merge(span.filter(function(d, i) { return d & 1; }));
assert.equal(some.indexOf(span[0][0]), -1);
assert.equal(some.indexOf(span[1][0]), -1);
},

4
test/selection/property-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
interpolateRgb = require("../../").interpolateRgb,
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -81,7 +81,7 @@ suite.addBatch({
assert.equal(div[0][1].opacity, "0.4");
},
"sets a property as a function": function(div) {
div.property("bgcolor", interpolateRgb("brown", "steelblue"));
div.property("bgcolor", _.interpolateRgb("brown", "steelblue"));
assert.equal(div[0][0].bgcolor, "#a52a2a");
assert.equal(div[0][1].bgcolor, "#4682b4");
},

4
test/selection/style-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
interpolateRgb = require("../../").interpolateRgb,
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -89,7 +89,7 @@ suite.addBatch({
assert.equal(div[0][1].style.getPropertyValue("opacity"), "0.5");
},
"sets a property as a function": function(div) {
div.style("background-color", interpolateRgb("orange", "yellow"));
div.style("background-color", _.interpolateRgb("orange", "yellow"));
assert.equal(div[0][0].style.getPropertyValue("background-color"), "#ffa500");
assert.equal(div[0][1].style.getPropertyValue("background-color"), "#ffff00");
},

4
test/svg/area-radial-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -180,7 +180,7 @@ suite.addBatch({
function testInterpolation(interpolate) {
var data = [[10, 0], [20, 1], [20, 2], [10, 3]];
var cartesian = d3.svg.area()
var cartesian = _.svg.area()
.x0(function(d) { return d[0] * Math.cos(d[1] - Math.PI / 2); })
.x1(function(d) { return 2 * d[0] * Math.cos(d[1] - Math.PI / 2); })
.y0(function(d) { return d[0] * Math.sin(d[1] - Math.PI / 2); })

6
test/svg/area-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -183,8 +183,8 @@ function testInterpolation(i0, i1) {
return function(area) {
var a = area().interpolate(i0),
d = [[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]],
l0 = d3.svg.line().interpolate(i1).x(a.x0()).y(a.y0()),
l1 = d3.svg.line().interpolate(i0).x(a.x1()).y(a.y1());
l0 = _.svg.line().interpolate(i1).x(a.x0()).y(a.y0()),
l1 = _.svg.line().interpolate(i0).x(a.x1()).y(a.y1());
assert.pathEqual(a(d), l1(d) + "L" + l0(d.reverse()).substring(1) + "Z");
};
}

20
test/svg/axis-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
ordinal = require("../../").scale.ordinal,
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -17,23 +17,23 @@ suite.addBatch({
assert.equal(x(0.5), 0.5);
},
"can be defined as a scale object": function(d3) {
var x = d3.scale.linear(), a = d3.svg.axis().scale(x);
var x = _.scale.linear(), a = d3.svg.axis().scale(x);
assert.equal(a.scale(), x);
},
"can be a polylinear scale": function(d3) {
var a = d3.svg.axis().scale(d3.scale.linear().domain([0, 1, 10]).range([2, 20, 200])),
var a = d3.svg.axis().scale(_.scale.linear().domain([0, 1, 10]).range([2, 20, 200])),
g = d3.select("body").html("").append("svg:g").call(a),
path = g.selectAll("path");
assert.equal(path.attr("d"), "M2,6V0H200V6");
},
"can be an ordinal scale": function(d3) {
var a = d3.svg.axis().scale(ordinal().domain(["A", "B", "C"]).rangeBands([10, 90])),
var a = d3.svg.axis().scale(_.scale.ordinal().domain(["A", "B", "C"]).rangeBands([10, 90])),
g = d3.select("body").html("").append("svg:g").call(a),
path = g.selectAll("path");
assert.equal(path.attr("d"), "M10,6V0H90V6");
},
"can be an ordinal scale with explicit range": function(d3) {
var a = d3.svg.axis().scale(ordinal().domain(["A", "B", "C"]).range([10, 50, 90])),
var a = d3.svg.axis().scale(_.scale.ordinal().domain(["A", "B", "C"]).range([10, 50, 90])),
g = d3.select("body").html("").append("svg:g").call(a),
path = g.selectAll("path");
assert.equal(path.attr("d"), "M10,6V0H90V6");
@ -205,7 +205,7 @@ suite.addBatch({
assert.equal(t.length, 2);
},
"passes any arguments to the scale's ticks function": function(d3) {
var x = d3.scale.linear(), b = {}, a = d3.svg.axis().ticks(b, "%").scale(x), aa = [],
var x = _.scale.linear(), b = {}, a = d3.svg.axis().ticks(b, "%").scale(x), aa = [],
g = d3.select("body").html("").append("svg:g");
x.ticks = function() { aa.push(arguments); return [42]; };
g.call(a);
@ -216,7 +216,7 @@ suite.addBatch({
},
"passes any arguments to the scale's tickFormat function": function(d3) {
var b = {},
x = d3.scale.linear(),
x = _.scale.linear(),
a = d3.svg.axis().scale(x).ticks(b, "%"),
g = d3.select("body").html("").append("svg:g"),
aa = [];
@ -265,7 +265,7 @@ suite.addBatch({
assert.equal(t.length, 2);
},
"does not change the arguments passed to the scale's tickFormat function": function(d3) {
var x = d3.scale.linear(),
var x = _.scale.linear(),
a = d3.svg.axis().scale(x).ticks(10).tickValues([1, 2, 3]),
g = d3.select("body").html("").append("svg:g"),
aa = [];
@ -316,7 +316,7 @@ suite.addBatch({
assert.isTrue(a.tickFormat() == null);
},
"when null, uses the scale's tick format": function(d3) {
var x = d3.scale.linear(), a = d3.svg.axis().scale(x),
var x = _.scale.linear(), a = d3.svg.axis().scale(x),
g = d3.select("body").html("").append("svg:g");
x.tickFormat = function() {
@ -361,7 +361,7 @@ suite.addBatch({
"generates new tick marks with labels": function(d3) {
var a = d3.svg.axis(),
g = d3.select("body").html("").append("svg:g").call(a),
x = d3.scale.linear(),
x = _.scale.linear(),
tick = g.selectAll("g"),
ticks = x.ticks(10),
tickFormat = x.tickFormat(10);

16
test/svg/brush-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
linear = require("../../").scale.linear,
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -26,33 +26,33 @@ suite.addBatch({
assert.isNull(brush().extent());
},
"returns a one-dimensional array if only x is defined": function(brush) {
var b = brush().x(linear());
var b = brush().x(_.scale.linear());
assert.deepEqual(b.extent(), [0, 0]);
},
"takes a one-dimensional array if only x is defined": function(brush) {
var b = brush().x(linear()).extent([0.1, 0.4]);
var b = brush().x(_.scale.linear()).extent([0.1, 0.4]);
assert.deepEqual(b.extent(), [0.1, 0.4]);
},
"returns a one-dimensional array if only y is defined": function(brush) {
var b = brush().y(linear());
var b = brush().y(_.scale.linear());
assert.deepEqual(b.extent(), [0, 0]);
},
"takes a one-dimensional array if only y is defined": function(brush) {
var b = brush().y(linear()).extent([0.1, 0.4]);
var b = brush().y(_.scale.linear()).extent([0.1, 0.4]);
assert.deepEqual(b.extent(), [0.1, 0.4]);
},
"returns a two-dimensional array if x and y are defined": function(brush) {
var b = brush().x(linear()).y(linear());
var b = brush().x(_.scale.linear()).y(_.scale.linear());
assert.deepEqual(b.extent(), [[0, 0], [0, 0]]);
},
"takes a two-dimensional array if x and y are defined": function(brush) {
var b = brush().x(linear()).y(linear()).extent([[0.1, 0.2], [0.3, 0.4]]);
var b = brush().x(_.scale.linear()).y(_.scale.linear()).extent([[0.1, 0.2], [0.3, 0.4]]);
assert.deepEqual(b.extent(), [[0.1, 0.2], [0.3, 0.4]]);
},
"preserves the set extent exactly": function(brush) {
var lo = new Number(0.1),
hi = new Number(0.3),
b = brush().x(linear()).extent([lo, hi]),
b = brush().x(_.scale.linear()).extent([lo, hi]),
extent = b.extent();
assert.strictEqual(extent[0], lo);
assert.strictEqual(extent[1], hi);

4
test/svg/line-radial-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert");
@ -108,7 +108,7 @@ suite.addBatch({
function testInterpolation(interpolate) {
var data = [[10, 0], [20, 1], [20, 2], [10, 3]];
var cartesian = d3.svg.line()
var cartesian = _.svg.line()
.x(function(d) { return d[0] * Math.cos(d[1] - Math.PI / 2); })
.y(function(d) { return d[0] * Math.sin(d[1] - Math.PI / 2); });

24
test/time/scale-test.js
Просмотреть файл

@ -1,5 +1,5 @@
var vows = require("vows"),
d3 = require("../../"),
_ = require("../../"),
load = require("../load"),
assert = require("../assert"),
time = require("./time"),
@ -15,17 +15,17 @@ suite.addBatch({
"nice": {
"rounds using the specified time interval": function(scale) {
var x = scale().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 23, 48)]);
assert.deepEqual(x.nice(d3.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
assert.deepEqual(x.nice(d3.time.week).domain(), [local(2008, 11, 28), local(2009, 0, 4)]);
assert.deepEqual(x.nice(d3.time.month).domain(), [local(2008, 11, 1), local(2009, 1, 1)]);
assert.deepEqual(x.nice(d3.time.year).domain(), [local(2008, 0, 1), local(2010, 0, 1)]);
assert.deepEqual(x.nice(_.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
assert.deepEqual(x.nice(_.time.week).domain(), [local(2008, 11, 28), local(2009, 0, 4)]);
assert.deepEqual(x.nice(_.time.month).domain(), [local(2008, 11, 1), local(2009, 1, 1)]);
assert.deepEqual(x.nice(_.time.year).domain(), [local(2008, 0, 1), local(2010, 0, 1)]);
},
"works on degenerate domains": function(scale) {
var x = scale().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 0, 12)]);
assert.deepEqual(x.nice(d3.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
assert.deepEqual(x.nice(_.time.day).domain(), [local(2009, 0, 1), local(2009, 0, 2)]);
},
"nicing a polylinear domain only affects the extent": function(linear) {
var x = linear().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 23, 48), local(2009, 0, 2, 23, 48)]).nice(d3.time.day);
var x = linear().domain([local(2009, 0, 1, 0, 12), local(2009, 0, 1, 23, 48), local(2009, 0, 2, 23, 48)]).nice(_.time.day);
assert.deepEqual(x.domain(), [local(2009, 0, 1), local(2009, 0, 1, 23, 48), local(2009, 0, 3)]);
}
},
@ -59,7 +59,7 @@ suite.addBatch({
var x = scale().domain([local(2009, 0, 1), local(2010, 0, 1)]).range(["red", "blue"]),
i = x.interpolate(),
y = x.copy();
x.interpolate(d3.interpolateHsl);
x.interpolate(_.interpolateHsl);
assert.equal(x(local(2009, 6, 1)), "#ff00fd");
assert.equal(y(local(2009, 6, 1)), "#81007e");
assert.equal(y.interpolate(), i);
@ -80,7 +80,7 @@ suite.addBatch({
"ticks": {
"observes explicit tick interval": function(scale) {
var x = scale().domain([local(2011, 0, 1, 12, 1, 0), local(2011, 0, 1, 12, 4, 4)]);
assert.deepEqual(x.ticks(d3.time.minutes), [
assert.deepEqual(x.ticks(_.time.minutes), [
local(2011, 0, 1, 12, 1),
local(2011, 0, 1, 12, 2),
local(2011, 0, 1, 12, 3),
@ -89,7 +89,7 @@ suite.addBatch({
},
"observes explicit tick interval and step": function(scale) {
var x = scale().domain([local(2011, 0, 1, 12, 0, 0), local(2011, 0, 1, 12, 33, 4)]);
assert.deepEqual(x.ticks(d3.time.minutes, 10), [
assert.deepEqual(x.ticks(_.time.minutes, 10), [
local(2011, 0, 1, 12, 0),
local(2011, 0, 1, 12, 10),
local(2011, 0, 1, 12, 20),
@ -332,7 +332,7 @@ suite.addBatch({
"ticks": {
"observes explicit tick interval": function(scale) {
var x = scale().domain([utc(2011, 0, 1, 12, 1, 0), utc(2011, 0, 1, 12, 4, 4)]);
assert.deepEqual(x.ticks(d3.time.minutes), [
assert.deepEqual(x.ticks(_.time.minutes), [
utc(2011, 0, 1, 12, 1),
utc(2011, 0, 1, 12, 2),
utc(2011, 0, 1, 12, 3),
@ -341,7 +341,7 @@ suite.addBatch({
},
"observes explicit tick interval and step": function(scale) {
var x = scale().domain([utc(2011, 0, 1, 12, 0, 0), utc(2011, 0, 1, 12, 33, 4)]);
assert.deepEqual(x.ticks(d3.time.minutes, 10), [
assert.deepEqual(x.ticks(_.time.minutes, 10), [
utc(2011, 0, 1, 12, 0),
utc(2011, 0, 1, 12, 10),
utc(2011, 0, 1, 12, 20),

12
test/transition/transition-test-attrTween.js
Просмотреть файл

@ -1,9 +1,9 @@
var assert = require("../assert"),
interpolateHsl = require("../../").interpolateHsl;
_ = require("../../");
module.exports = {
topic: function(d3) {
var cb = this.callback,
var callback = this.callback,
dd = [],
ii = [],
tt = [],
@ -21,7 +21,7 @@ module.exports = {
dd.push(d);
ii.push(i);
vv.push(v);
if (tt.push(this) >= 2) cb(null, {
if (tt.push(this) >= 2) callback(null, {
selection: s,
transition: t,
data: dd,
@ -29,7 +29,7 @@ module.exports = {
value: vv,
context: tt
});
return i && interpolateHsl(v, "blue");
return i && _.interpolateHsl(v, "blue");
}
},
@ -52,8 +52,8 @@ module.exports = {
"end": {
topic: function(result) {
var cb = this.callback;
result.transition.each("end", function(d, i) { if (i >= 1) cb(null, result); });
var callback = this.callback;
result.transition.each("end", function(d, i) { if (i >= 1) callback(null, result); });
},
"uses the returned interpolator": function(result) {
assert.equal(result.selection[0][1].getAttribute("color"), "#0000ff");

4
test/transition/transition-test-filter.js
Просмотреть файл

@ -1,5 +1,5 @@
var assert = require("../assert"),
merge = require("../../").merge;
_ = require("../../");
var datum = {};
@ -24,7 +24,7 @@ module.exports = {
assert.isTrue(some[1][0] === span[1][0]);
},
"removes non-matching elements": function(span) {
var some = merge(span.filter(function(d, i) { return d & 1; }));
var some = _.merge(span.filter(function(d, i) { return d & 1; }));
assert.equal(some.indexOf(span[0][0]), -1);
assert.equal(some.indexOf(span[1][0]), -1);
},

4
test/transition/transition-test-styleTween.js
Просмотреть файл

@ -1,5 +1,5 @@
var assert = require("../assert"),
interpolateHsl = require("../../").interpolateHsl;
_ = require("../../");
module.exports = {
topic: function(d3) {
@ -32,7 +32,7 @@ module.exports = {
context: tt,
fails: fails
});
return i && interpolateHsl(v, "blue");
return i && _.interpolateHsl(v, "blue");
}
},