From 2cc073c99a682f290bb7f689c21baeefa625177b Mon Sep 17 00:00:00 2001 From: Mike Bostock Date: Thu, 7 Jan 2016 15:02:43 -0800 Subject: [PATCH] =?UTF-8?q?Prefix=20exported=20symbols=20with=20=E2=80=9Cs?= =?UTF-8?q?cale=E2=80=9D.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 94 ++++++++-------- index.js | 99 +++++++++++++---- test/band-test.js | 50 ++++----- test/category10-test.js | 10 +- test/category20-test.js | 10 +- test/category20b-test.js | 10 +- test/category20c-test.js | 10 +- test/identity-test.js | 57 +++++----- test/linear-test.js | 222 ++++++++++++++++++------------------- test/log-test.js | 84 +++++++------- test/ordinal-test.js | 44 ++++---- test/point-test.js | 20 ++-- test/pow-test.js | 234 +++++++++++++++++++-------------------- test/quantile-test.js | 34 +++--- test/quantize-test.js | 26 ++--- test/rainbow-test.js | 14 +-- test/threshold-test.js | 14 +-- test/time-test.js | 92 +++++++-------- test/utcTime-test.js | 180 +++++++++++++++--------------- test/viridis-test.js | 12 +- 20 files changed, 692 insertions(+), 624 deletions(-) diff --git a/README.md b/README.md index 53ef9ff..6aa389a 100644 --- a/README.md +++ b/README.md @@ -52,7 +52,7 @@ Continuous scales map a continuous, quantitative input [domain](#continuous_doma Given a *value* from the [domain](#continuous_domain), returns the corresponding value from the [range](#continuous_range). If the given *value* is outside the domain, and [clamping](#continuous_clamp) is not enabled, the mapping may be extrapolated such that the returned value is outside the range. For example, to apply a position encoding: ```js -var x = d3_scale.linear() +var x = d3.scaleLinear() .domain([10, 130]) .range([0, 960]); @@ -63,7 +63,7 @@ x(50); // 320 Or to apply a color encoding: ```js -var color = d3_scale.linear() +var color = d3.scaleLinear() .domain([10, 100]) .range(["brown", "steelblue"]); @@ -76,7 +76,7 @@ color(50); // "#7b5167" Given a *value* from the [range](#continuous_range), returns the corresponding value from the [domain](#continuous_domain). Inversion is useful for interaction, say to determine the data value corresponding to the position of the mouse. For example, to invert a position encoding: ```js -var x = d3_scale.linear() +var x = d3.scaleLinear() .domain([10, 130]) .range([0, 960]); @@ -95,7 +95,7 @@ If *domain* is specified, sets the scale’s domain to the specified array of nu Although continuous scales typically have two values each in their domain and range, specifying more than two values produces a piecewise scale. For example, to create a diverging color scale that interpolates between white and red for negative values, and white and green for positive values, say: ```js -var color = d3_scale.linear() +var color = d3.scaleLinear() .domain([-1, 0, 1]) .range(["red", "white", "green"]); @@ -126,7 +126,7 @@ The rounding interpolator is sometimes useful for avoiding antialiasing artifact If *clamp* is specified, enables or disables clamping accordingly. If clamping is disabled and the scale is passed a value outside the [domain](#continuous_domain), the scale may return a value outside the [range](#continuous_range) through extrapolation. If clamping is enabled, the return value of the scale is always within the scale’s range. Clamping similarly applies to [*continuous*.invert](#continuous_invert). For example: ```js -var x = d3_scale.linear() +var x = d3.scaleLinear() .domain([10, 130]) .range([0, 960]); @@ -147,7 +147,7 @@ If *interpolate* is specified, sets the scale’s [range](#continuous_range) int For example, consider a diverging color scale with three colors in the range: ```js -var color = d3_scale.linear() +var color = d3.scaleLinear() .domain([-100, 0, +100]) .range(["red", "white", "green"]); ``` @@ -162,7 +162,7 @@ var i0 = d3.interpolate("red", "white"), A common reason to specify a custom interpolator is to change the color space of interpolation. For example, to use [HCL](https://github.com/d3/d3-interpolate#interpolateHcl): ```js -var color = d3_scale.linear() +var color = d3.scaleLinear() .domain([10, 100]) .range(["brown", "steelblue"]) .interpolate(d3.interpolateHcl); @@ -181,7 +181,7 @@ Returns a [number format](https://github.com/d3/d3-format) function suitable for An optional *specifier* allows a [custom format](https://github.com/d3/d3-format#locale_format) where the precision of the format is automatically set by the scale as appropriate for the tick interval. For example, to format percentage change, you might say: ```js -var x = d3_scale.linear() +var x = d3.scaleLinear() .domain([-1, 1]) .range([0, 960]); @@ -201,7 +201,7 @@ Extends the [domain](#continuous_domain) so that it starts and ends on nice roun Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa. -# d3_scale.linear() +# d3.scaleLinear() Constructs a new [continuous scale](#continuous-scales) with the unit [domain](#continuous_domain) [0, 1], the unit [range](#continuous_range) [0, 1], the [default](https://github.com/d3/d3-interpolate#interpolate) [interpolator](#continuous_interpolate) and [clamping](#continuous_clamp) disabled. Linear scales are a good default choice for continuous quantitative data because they preserve proportional differences. Each range value *y* can be expressed as a function of the domain value *x*: *y* = *mx* + *b*. @@ -209,7 +209,7 @@ Constructs a new [continuous scale](#continuous-scales) with the unit [domain](# Power scales are similar to [linear scales](#linear), except an exponential transform is applied to the input domain value before the output range value is computed. Each range value *y* can be expressed as a function of the domain value *x*: *y* = *mx^k* + *b*, where *k* is the [exponent](#pow_exponent) value. Power scales also support negative domain values, in which case the input value and the resulting output value are multiplied by -1. -# d3_scale.pow() +# d3.scalePow() Constructs a new [continuous scale](#continuous-scales) with the unit [domain](#continuous_domain) [0, 1], the unit [range](#continuous_range) [0, 1], the [exponent](#pow_exponent) 1, the [default](https://github.com/d3/d3-interpolate#interpolate) [interpolator](#continuous_interpolate) and [clamping](#continuous_clamp) disabled. (Note that this is effectively a [linear](#linear) scale until you set a different exponent.) @@ -217,9 +217,9 @@ Constructs a new [continuous scale](#continuous-scales) with the unit [domain](# If *exponent* is specified, sets the current exponent to the given numeric value. If *exponent* is not specified, returns the current exponent, which defaults to 1. (Note that this is effectively a [linear](#linear) scale until you set a different exponent.) -# d3_scale.sqrt() +# d3.scaleSqrt() -Constructs a new [continuous](#continuous-scales) [power scale](#pow) with the unit [domain](#continuous_domain) [0, 1], the unit [range](#continuous_range) [0, 1], the [exponent](#pow_exponent) 0.5, the [default](https://github.com/d3/d3-interpolate#interpolate) [interpolator](#continuous_interpolate) and [clamping](#continuous_clamp) disabled. This is a convenience method equivalent to `d3_scale.pow().exponent(0.5)`. +Constructs a new [continuous](#continuous-scales) [power scale](#pow) with the unit [domain](#continuous_domain) [0, 1], the unit [range](#continuous_range) [0, 1], the [exponent](#pow_exponent) 0.5, the [default](https://github.com/d3/d3-interpolate#interpolate) [interpolator](#continuous_interpolate) and [clamping](#continuous_clamp) disabled. This is a convenience method equivalent to `d3.scalePow().exponent(0.5)`. #### Log Scales @@ -227,7 +227,7 @@ Log scales are similar to [linear scales](#linear), except a logarithmic transfo As log(0) = -∞, a log scale domain must be **strictly-positive or strictly-negative**; the domain must not include or cross zero. A log scale with a positive domain has a well-defined behavior for positive values, and a log scale with a negative domain has a well-defined behavior for negative values. (For a negative domain, input and output values are implicitly multiplied by -1.) The behavior of the scale is undefined if you pass a negative value to a log scale with a positive domain or vice versa. -# d3_scale.log() +# d3.scaleLog() Constructs a new [continuous scale](#continuous-scales) with the [domain](#continuous_domain) [1, 10], the unit [range](#continuous_range) [0, 1], the [base](#log_base) 10, the [default](https://github.com/d3/d3-interpolate#interpolate) [interpolator](#continuous_interpolate) and [clamping](#continuous_clamp) disabled. @@ -251,7 +251,7 @@ Like [*continuous*.tickFormat](#continuous_tickFormat), but customized for a log Identity scales are a special case of [linear scales](#linear) where the domain and range are identical; the scale and its invert method are thus the identity function. These scales are occasionally useful when working with pixel coordinates, say in conjunction with an axis or brush. Identity scales do not support [rangeRound](#continuous_rangeRound), [clamp](#continuous_clamp) or [interpolate](#continuous_interpolate). -# d3_scale.identity() +# d3.scaleIdentity() Constructs a new identity scale with the unit [domain](#continuous_domain) [0, 1] and the unit [range](#continuous_range) [0, 1]. @@ -262,7 +262,7 @@ Time scales are a variant of [linear scales](#linear) that have a temporal domai For example, to create a position encoding: ```js -var x = d3_scale.time() +var x = d3.scaleTime() .domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]) .range([0, 960]); @@ -274,7 +274,7 @@ x.invert(640); // Sat Jan 01 2000 16:00:00 GMT-0800 (PST) For a valid value *y* in the range, time(time.invert(y)) equals *y*; similarly, for a valid value *x* in the domain, time.invert(time(x)) equals *x*. The invert method is useful for interaction, say to determine the value in the domain that corresponds to the pixel location under the mouse. -# d3_scale.time() +# d3.scaleTime() Constructs a new time scale with the [domain](#continuous_domain) [2000-01-01, 2000-01-02], the unit [range](#continuous_range) [0, 1], the [default](https://github.com/d3/d3-interpolate#interpolate) [interpolator](#continuous_interpolate) and [clamping](#continuous_clamp) disabled. @@ -286,7 +286,7 @@ Returns representative dates from the scale’s [domain](#continuous_domain). Th An optional *count* may be specified to affect how many ticks are generated. If *count* is not specified, it defaults to 10. The specified *count* is only a hint; the scale may return more or fewer values depending on the domain. For example, to create ten default ticks, say: ```js -var x = d3_scale.time(); +var x = d3.scaleTime(); x.ticks(10); // [Sat Jan 01 2000 00:00:00 GMT-0800 (PST), @@ -310,13 +310,13 @@ The following time intervals are considered for automatic ticks: * 1- and 3-month. * 1-year. -In lieu of a *count*, a [time *interval*](https://github.com/d3/d3-time#intervals) may be explicitly specified. If an *interval* is specified, an optional *step* may also be specified to prune generated ticks. For example, `time.ticks(d3_time.minute, 15)` will generate ticks at 15-minute intervals: +In lieu of a *count*, a [time *interval*](https://github.com/d3/d3-time#intervals) may be explicitly specified. If an *interval* is specified, an optional *step* may also be specified to prune generated ticks. For example, `time.ticks(d3.timeMinute, 15)` will generate ticks at 15-minute intervals: ```js -var x = d3_scale.time() +var x = d3.scaleTime() .domain([new Date(2000, 0, 1, 0), new Date(2000, 0, 1, 2)]); -x.ticks(d3_time.minute, 15); +x.ticks(d3.timeMinute, 15); // [Sat Jan 01 2000 00:00:00 GMT-0800 (PST), // Sat Jan 01 2000 00:15:00 GMT-0800 (PST), // Sat Jan 01 2000 00:30:00 GMT-0800 (PST), @@ -331,7 +331,7 @@ x.ticks(d3_time.minute, 15); This is equivalent to using [minute](https://github.com/d3/d3-time#minute).[every](https://github.com/d3/d3-time#interval_every)(15), or minute.[filter](https://github.com/d3/d3-time#interval_filter) with the following test function: ```js -x.ticks(d3_time.minute.filter(function(d) { +x.ticks(d3.timeMinute.filter(function(d) { return d.getMinutes() % 15 === 0; })); ``` @@ -358,11 +358,11 @@ Although somewhat unusual, this default behavior has the benefit of providing bo Extends the [domain](#continuous_domain) so that it starts and ends on nice round values. This method typically modifies the scale’s domain, and may only extend the bounds to the nearest round value. -An optional tick *count* argument allows greater control over the step size used to extend the bounds, guaranteeing that the returned [ticks](#time_ticks) will exactly cover the domain. Alternatively, a [time *interval*](https://github.com/d3/d3-time#intervals) may be specified to explicitly set the ticks. If an *interval* is specified, an optional *step* may also be specified to skip some ticks. For example, `time.nice(d3_time.second, 10)` will extend the domain to an even ten seconds (0, 10, 20, etc.). See [*time*.ticks](#time_ticks) and [*interval*.every](https://github.com/d3/d3-time#interval_every) for further detail. +An optional tick *count* argument allows greater control over the step size used to extend the bounds, guaranteeing that the returned [ticks](#time_ticks) will exactly cover the domain. Alternatively, a [time *interval*](https://github.com/d3/d3-time#intervals) may be specified to explicitly set the ticks. If an *interval* is specified, an optional *step* may also be specified to skip some ticks. For example, `time.nice(d3.timeSecond, 10)` will extend the domain to an even ten seconds (0, 10, 20, etc.). See [*time*.ticks](#time_ticks) and [*interval*.every](https://github.com/d3/d3-time#interval_every) for further detail. Nicing is useful if the domain is computed from data, say using [extent](https://github.com/d3/d3-array#extent), and may be irregular. For example, for a domain of [2009-07-13T00:02, 2009-07-13T23:48], the nice domain is [2009-07-13, 2009-07-14]. If the domain has more than two values, nicing the domain only affects the first and last value. -# d3_scale.utcTime() +# d3.scaleUtcTime() Equivalent to [time](#time), but the returned time scale operates in [Coordinated Universal Time](https://en.wikipedia.org/wiki/Coordinated_Universal_Time) rather than local time. @@ -370,49 +370,49 @@ Equivalent to [time](#time), but the returned time scale operates in [Coordinate Sequential scales are similar to [continuous scales](#continuous-scales) in that they map a continuous, numeric input domain to a continuous output range. However, unlike continuous scales, the output range of a sequential color scale is fixed and not configurable. These scales do not expose [invert](#continuous_invert), [range](#continuous_range), [rangeRound](#continuous_rangeRound) and [interpolate](#continuous_interpolate) methods. -# d3_scale.viridis() +# d3.scaleViridis() viridis Constructs a new sequential scale with the unit [domain](#continuous_domain) [0, 1] and implementing the “viridis” perceptually-uniform color scheme designed by [van der Walt, Smith and Firing](https://bids.github.io/colormap/) for matplotlib. -# d3_scale.inferno() +# d3.scaleInferno() inferno Constructs a new sequential scale with the unit [domain](#continuous_domain) [0, 1] and implementing the “inferno” perceptually-uniform color scheme designed by [van der Walt and Smith](https://bids.github.io/colormap/) for matplotlib. -# d3_scale.magma() +# d3.scaleMagma() magma Constructs a new sequential scale with the unit [domain](#continuous_domain) [0, 1] and implementing the “magma” perceptually-uniform color scheme designed by [van der Walt and Smith](https://bids.github.io/colormap/) for matplotlib. -# d3_scale.plasma() +# d3.scalePlasma() plasma Constructs a new sequential scale with the unit [domain](#continuous_domain) [0, 1] and implementing the “plasma” perceptually-uniform color scheme designed by [van der Walt and Smith](https://bids.github.io/colormap/) for matplotlib. -# d3_scale.warm() +# d3.scaleWarm() warm Constructs a new sequential scale with the unit [domain](#continuous_domain) [0, 1] and approximately implementing a 180° rotation of [Niccoli’s perceptual rainbow](https://mycarta.wordpress.com/2013/02/21/perceptual-rainbow-palette-the-method/) color scheme using the Cubehelix color space. -# d3_scale.cool() +# d3.scaleCool() cool Constructs a new sequential scale with the unit [domain](#continuous_domain) [0, 1] and approximately implementing [Niccoli’s perceptual rainbow](https://mycarta.wordpress.com/2013/02/21/perceptual-rainbow-palette-the-method/) color scheme using the Cubehelix color space. -# d3_scale.rainbow() +# d3.scaleRainbow() rainbow Constructs a new sequential scale with the unit [domain](#continuous_domain) [0, 1] combining the [warm](#warm) scale from [0.0, 0.5] followed by the [cool](#cool) scale from [0.5, 1.0], thus implementing the cyclical [less-angry rainbow](http://bl.ocks.org/mbostock/310c99e53880faec2434) color scheme. -# d3_scale.cubehelix() +# d3.scaleCubehelix() cubehelix @@ -422,7 +422,7 @@ Constructs a new [linear scale](#linear) with the unit [domain](#continuous_doma Quantize scales are similar to [linear scales](#linear), except they use a discrete rather than continuous range. The continuous input domain is divided into uniform segments based on the number of values in (*i.e.*, the cardinality of) the output range. Each range value *y* can be expressed as a quantized linear function of the domain value *x*: *y* = *m round(x)* + *b*. See [bl.ocks.org/4060606](http://bl.ocks.org/mbostock/4060606) for an example. -# d3_scale.quantize() +# d3.scaleQuantize() Constructs a new quantize scale with the unit [domain](#quantize_domain) [0, 1] and the unit [range](#quantize_range) [0, 1]. Thus, the default quantize scale is equivalent to the [Math.round](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Math/round) function. @@ -431,7 +431,7 @@ Constructs a new quantize scale with the unit [domain](#quantize_domain) [0, 1] Given a *value* in the input [domain](#quantize_domain), returns the corresponding valuein the output [range](#quantize_range). For example, to apply a color encoding: ```js -var color = d3_scale.quantize() +var color = d3.scaleQuantize() .domain([0, 1]) .range(["brown", "steelblue"]); @@ -442,7 +442,7 @@ color(0.51); // "steelblue" Or dividing the domain into three equally-sized parts with different range values to compute an appropriate stroke width: ```js -var width = d3_scale.quantize() +var width = d3.scaleQuantize() .domain([10, 100]) .range([1, 2, 4]); @@ -456,7 +456,7 @@ width(80); // 4 Returns the extent of values in the [domain](#quantize_domain) [x0, x1] for the corresponding *value* in the [range](#quantize_range): the inverse of [*quantize*](#_quantize). This method is useful for interaction, say to determine the value in the domain that corresponds to the pixel location under the mouse. ```js -var width = d3_scale.quantize() +var width = d3.scaleQuantize() .domain([10, 100]) .range([1, 2, 4]); @@ -491,7 +491,7 @@ Returns an exact copy of this scale. Changes to this scale will not affect the r Quantile scales map a sampled input domain to a discrete range. The domain is considered continuous and thus the scale will accept any reasonable input value; however, the domain is specified as a discrete set of sample values. The number of values in (the cardinality of) the output range determines the number of quantiles that will be computed from the domain. To compute the quantiles, the domain is sorted, and treated as a [population of discrete values](https://en.wikipedia.org/wiki/Quantile#Quantiles_of_a_population); see d3-array’s [quantile](https://github.com/d3/d3-array#quantile). See [bl.ocks.org/8ca036b3505121279daf](http://bl.ocks.org/mbostock/8ca036b3505121279daf) for an example. -# d3_scale.quantile() +# d3.scaleQuantile() Constructs a new quantile scale with an empty [domain](#quantile_domain) and an empty [range](#quantile_range). The quantile scale is invalid until both a domain and range are specified. @@ -523,7 +523,7 @@ Returns an exact copy of this scale. Changes to this scale will not affect the r Threshold scales are similar to [quantize scales](#quantize-scales), except they allow you to map arbitrary subsets of the domain to discrete values in the range. The input domain is still continuous, and divided into slices based on a set of threshold values. See [bl.ocks.org/3306362](http://bl.ocks.org/mbostock/3306362) for an example. -# d3_scale.threshold() +# d3.scaleThreshold() Constructs a new threshold scale with the default [domain](#threshold_domain) [0.5] and the default [range](#threshold_range) [0, 1]. Thus, the default threshold scale is equivalent to the [Math.round](https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Math/round) function for numbers; for example threshold(0.49) returns 0, and threshold(0.51) returns 1. @@ -532,7 +532,7 @@ Constructs a new threshold scale with the default [domain](#threshold_domain) [0 Given a *value* in the input [domain](#threshold_domain), returns the corresponding value in the output [range](#threshold_range). For example: ```js -var color = d3_scale.threshold() +var color = d3.scaleThreshold() .domain([0, 1]) .range(["red", "white", "green"]); @@ -548,7 +548,7 @@ color(1000); // "green" Returns the extent of values in the [domain](#threshold_domain) [x0, x1] for the corresponding *value* in the [range](#threshold_range), representing the inverse mapping from range to domain. This method is useful for interaction, say to determine the value in the domain that corresponds to the pixel location under the mouse. For example: ```js -var color = d3_scale.threshold() +var color = d3.scaleThreshold() .domain([0, 1]) .range(["red", "white", "green"]); @@ -573,7 +573,7 @@ Returns an exact copy of this scale. Changes to this scale will not affect the r Unlike [continuous scales](#continuous-scales), ordinal scales have a discrete domain and range. For example, an ordinal scale might map a set of named categories to a set of colors, or determine the horizontal positions of columns in a column chart. -# d3_scale.ordinal() +# d3.scaleOrdinal() Constructs a new ordinal scale with an empty [domain](#ordinal_domain) and an empty [range](#ordinal_range). The ordinal scale always returns undefined until an output range is specified. @@ -599,7 +599,7 @@ If *value* is specified, sets the output value of the scale for unknown input va Returns an exact copy of this ordinal scale. Changes to this scale will not affect the returned scale, and vice versa. -# d3_scale.implicit +# d3.scaleImplicit A special value for [*ordinal*.unknown](#ordinal_unknown) that enables implicit domain construction: unknown values are implicitly added to the domain. @@ -609,7 +609,7 @@ Band scales are like [ordinal scales](#ordinal-scales) except the output range i band -# d3_scale.band() +# d3.scaleBand() Constructs a new band scale with the empty [domain](#band_domain), the unit [range](#band_range) [0, 1], no [padding](#band_padding), no [rounding](#band_round) and center [alignment](#band_align). @@ -675,7 +675,7 @@ Point scales are a variant of [band scales](#band-scales) with the bandwidth fix point -# d3_scale.point() +# d3.scalePoint() Constructs a new point scale with the empty [domain](#band_domain), the unit [range](#band_range) [0, 1], no [padding](#point_padding), no [rounding](#band_round) and center [alignment](#band_align). @@ -685,25 +685,25 @@ Equivalent to [*band*.paddingOuter](#band_paddingOuter). ### Categorical Color Scales -# d3_scale.category10() +# d3.scaleCategory10() category10 Constructs a new [ordinal scale](#ordinal) with a range of ten categorical colors. -# d3_scale.category20() +# d3.scaleCategory20() category20 Constructs a new [ordinal scale](#ordinal) with a range of twenty categorical colors. -# d3_scale.category20b() +# d3.scaleCategory20b() category20b Constructs a new [ordinal scale](#ordinal) with a range of twenty categorical colors. -# d3_scale.category20c() +# d3.scaleCategory20c() category20c diff --git a/index.js b/index.js index 619ff1c..81c6c30 100644 --- a/index.js +++ b/index.js @@ -1,19 +1,80 @@ -export {default as band, point} from "./src/band"; -export {default as identity} from "./src/identity"; -export {default as linear} from "./src/linear"; -export {default as log} from "./src/log"; -export {default as ordinal, implicit} from "./src/ordinal"; -export {default as pow, sqrt} from "./src/pow"; -export {default as quantile} from "./src/quantile"; -export {default as quantize} from "./src/quantize"; -export {default as threshold} from "./src/threshold"; -export {default as time} from "./src/time"; -export {default as utcTime} from "./src/utcTime"; - -export {default as category10} from "./src/category10"; -export {default as category20b} from "./src/category20b"; -export {default as category20c} from "./src/category20c"; -export {default as category20} from "./src/category20"; -export {default as cubehelix} from "./src/cubehelix"; -export {default as rainbow, warm, cool} from "./src/rainbow"; -export {default as viridis, magma, inferno, plasma} from "./src/viridis"; +export { + default as scaleBand, + point as scalePoint +} from "./src/band"; + +export { + default as scaleIdentity +} from "./src/identity"; + +export { + default as scaleLinear +} from "./src/linear"; + +export { + default as scaleLog +} from "./src/log"; + +export { + default as scaleOrdinal, + implicit as scaleImplicit +} from "./src/ordinal"; + +export { + default as scalePow, + sqrt as scaleSqrt +} from "./src/pow"; + +export { + default as scaleQuantile +} from "./src/quantile"; + +export { + default as scaleQuantize +} from "./src/quantize"; + +export { + default as scaleThreshold +} from "./src/threshold"; + +export { + default as scaleTime +} from "./src/time"; + +export { + default as scaleUtc +} from "./src/utcTime"; + +export { + default as scaleCategory10 +} from "./src/category10"; + +export { + default as scaleCategory20b +} from "./src/category20b"; + +export { + default as scaleCategory20c +} from "./src/category20c"; + +export { + default as scaleCategory20 +} from "./src/category20"; + +export { + default as scaleCubehelix +} from "./src/cubehelix"; + +export { + default as scaleRainbow, + warm as scaleWarm, + cool as scaleCool +} from "./src/rainbow"; + +export { + default as scaleViridis, + magma as scaleMagma, + inferno as scaleInferno, + plasma as scalePlasma +} from "./src/viridis"; + diff --git a/test/band-test.js b/test/band-test.js index 7cfb8c2..05d6c9f 100644 --- a/test/band-test.js +++ b/test/band-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("band() has the expected defaults", function(test) { - var s = scale.band(); +tape("scaleBand() has the expected defaults", function(test) { + var s = scale.scaleBand(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), [0, 1]); test.equal(s.bandwidth(), 1); @@ -15,7 +15,7 @@ tape("band() has the expected defaults", function(test) { }); tape("band(value) computes discrete bands in a continuous range", function(test) { - var s = scale.band().range([0, 960]); + var s = scale.scaleBand().range([0, 960]); test.equal(s("foo"), undefined); s.domain(["foo", "bar"]); test.equal(s("foo"), 0); @@ -30,7 +30,7 @@ tape("band(value) computes discrete bands in a continuous range", function(test) }); tape("band(value) returns undefined for values outside the domain", function(test) { - var s = scale.band().domain(["a", "b", "c"]); + var s = scale.scaleBand().domain(["a", "b", "c"]); test.equal(s("d"), undefined); test.equal(s("e"), undefined); test.equal(s("f"), undefined); @@ -38,7 +38,7 @@ tape("band(value) returns undefined for values outside the domain", function(tes }); tape("band(value) does not implicitly add values to the domain", function(test) { - var s = scale.band().domain(["a", "b", "c"]); + var s = scale.scaleBand().domain(["a", "b", "c"]); s("d"); s("e"); test.deepEqual(s.domain(), ["a", "b", "c"]); @@ -46,7 +46,7 @@ tape("band(value) does not implicitly add values to the domain", function(test) }); tape("band.step() returns the distance between the starts of adjacent bands", function(test) { - var s = scale.band().range([0, 960]); + var s = scale.scaleBand().range([0, 960]); test.equal(s.domain(["foo"]).step(), 960); test.equal(s.domain(["foo", "bar"]).step(), 480); test.equal(s.domain(["foo", "bar", "baz"]).step(), 320); @@ -57,7 +57,7 @@ tape("band.step() returns the distance between the starts of adjacent bands", fu }); tape("band.bandwidth() returns the width of the band", function(test) { - var s = scale.band().range([0, 960]); + var s = scale.scaleBand().range([0, 960]); test.equal(s.domain([]).bandwidth(), 960); test.equal(s.domain(["foo"]).bandwidth(), 960); test.equal(s.domain(["foo", "bar"]).bandwidth(), 480); @@ -70,7 +70,7 @@ tape("band.bandwidth() returns the width of the band", function(test) { }); tape("band.domain([]) computes reasonable band and step values", function(test) { - var s = scale.band().domain([]).range([0, 960]); + var s = scale.scaleBand().domain([]).range([0, 960]); test.equal(s.step(), 960); test.equal(s.bandwidth(), 960); s.padding(0.5); @@ -83,7 +83,7 @@ tape("band.domain([]) computes reasonable band and step values", function(test) }); tape("band.domain([value]) computes a reasonable singleton band, even with padding", function(test) { - var s = scale.band().domain(["foo"]).range([0, 960]); + var s = scale.scaleBand().domain(["foo"]).range([0, 960]); test.equal(s("foo"), 0); test.equal(s.step(), 960); test.equal(s.bandwidth(), 960); @@ -99,7 +99,7 @@ tape("band.domain([value]) computes a reasonable singleton band, even with paddi }); tape("band.domain(values) recomputes the bands", function(test) { - var s = scale.band().domain(["a", "b", "c"]).rangeRound([0, 100]); + var s = scale.scaleBand().domain(["a", "b", "c"]).rangeRound([0, 100]); test.deepEqual(s.domain().map(s), [1, 34, 67]); test.equal(s.bandwidth(), 33); s.domain(["a", "b", "c", "d"]); @@ -110,14 +110,14 @@ tape("band.domain(values) recomputes the bands", function(test) { tape("band.domain(values) makes a copy of the specified domain values", function(test) { var domain = ["red", "green"], - s = scale.band().domain(domain); + s = scale.scaleBand().domain(domain); domain.push("blue"); test.deepEqual(s.domain(), ["red", "green"]); test.end(); }); tape("band.domain() returns a copy of the domain", function(test) { - var s = scale.band().domain(["red", "green"]), + var s = scale.scaleBand().domain(["red", "green"]), domain = s.domain(); test.deepEqual(domain, ["red", "green"]); domain.push("blue"); @@ -126,7 +126,7 @@ tape("band.domain() returns a copy of the domain", function(test) { }); tape("band.range(values) can be descending", function(test) { - var s = scale.band().domain(["a", "b", "c"]).range([120, 0]); + var s = scale.scaleBand().domain(["a", "b", "c"]).range([120, 0]); test.deepEqual(s.domain().map(s), [80, 40, 0]); test.equal(s.bandwidth(), 40); s.padding(0.2); @@ -137,14 +137,14 @@ tape("band.range(values) can be descending", function(test) { tape("band.range(values) makes a copy of the specified range values", function(test) { var range = [1, 2], - s = scale.band().range(range); + s = scale.scaleBand().range(range); range.push("blue"); test.deepEqual(s.range(), [1, 2]); test.end(); }); tape("band.range() returns a copy of the range", function(test) { - var s = scale.band().range([1, 2]), + var s = scale.scaleBand().range([1, 2]), range = s.range(); test.deepEqual(range, [1, 2]); range.push("blue"); @@ -153,13 +153,13 @@ tape("band.range() returns a copy of the range", function(test) { }); tape("band.range(values) coerces values[0] and values[1] to numbers", function(test) { - var s = scale.band().range({0: "1.0", 1: "2.0", length: 2}); + var s = scale.scaleBand().range({0: "1.0", 1: "2.0", length: 2}); test.deepEqual(s.range(), [1, 2]); test.end(); }); tape("band.paddingInner(p) specifies the inner padding p", function(test) { - var s = scale.band().domain(["a", "b", "c"]).range([120, 0]).paddingInner(0.1).round(true); + var s = scale.scaleBand().domain(["a", "b", "c"]).range([120, 0]).paddingInner(0.1).round(true); test.deepEqual(s.domain().map(s), [83, 42, 1]); test.equal(s.bandwidth(), 37); s.paddingInner(0.2); @@ -169,7 +169,7 @@ tape("band.paddingInner(p) specifies the inner padding p", function(test) { }); tape("band.paddingInner(p) coerces p to a number in [0, 1]", function(test) { - var s = scale.band(); + var s = scale.scaleBand(); test.equal(s.paddingInner("1.0").paddingInner(), 1); test.equal(s.paddingInner("-1.0").paddingInner(), 0); test.equal(s.paddingInner("2.0").paddingInner(), 1); @@ -178,7 +178,7 @@ tape("band.paddingInner(p) coerces p to a number in [0, 1]", function(test) { }); tape("band.paddingOuter(p) specifies the outer padding p", function(test) { - var s = scale.band().domain(["a", "b", "c"]).range([120, 0]).paddingInner(0.2).paddingOuter(0.1); + var s = scale.scaleBand().domain(["a", "b", "c"]).range([120, 0]).paddingInner(0.2).paddingOuter(0.1); test.deepEqual(s.domain().map(s), [84, 44, 4]); test.equal(s.bandwidth(), 32); s.paddingOuter(1); @@ -188,7 +188,7 @@ tape("band.paddingOuter(p) specifies the outer padding p", function(test) { }); tape("band.paddingOuter(p) coerces p to a number in [0, 1]", function(test) { - var s = scale.band(); + var s = scale.scaleBand(); test.equal(s.paddingOuter("1.0").paddingOuter(), 1); test.equal(s.paddingOuter("-1.0").paddingOuter(), 0); test.equal(s.paddingOuter("2.0").paddingOuter(), 1); @@ -197,14 +197,14 @@ tape("band.paddingOuter(p) coerces p to a number in [0, 1]", function(test) { }); tape("band.rangeRound(values) is an alias for band.range(values).round(true)", function(test) { - var s = scale.band().domain(["a", "b", "c"]).rangeRound([0, 100]); + var s = scale.scaleBand().domain(["a", "b", "c"]).rangeRound([0, 100]); test.deepEqual(s.range(), [0, 100]); test.equal(s.round(), true); test.end(); }); tape("band.round(true) computes discrete rounded bands in a continuous range", function(test) { - var s = scale.band().domain(["a", "b", "c"]).range([0, 100]).round(true); + var s = scale.scaleBand().domain(["a", "b", "c"]).range([0, 100]).round(true); test.deepEqual(s.domain().map(s), [1, 34, 67]); test.equal(s.bandwidth(), 33); s.padding(0.2); @@ -214,7 +214,7 @@ tape("band.round(true) computes discrete rounded bands in a continuous range", f }); tape("band.copy() copies all fields", function(test) { - var s1 = scale.band().domain(["red", "green"]).range([1, 2]).round(true).paddingInner(0.1).paddingOuter(0.2), + var s1 = scale.scaleBand().domain(["red", "green"]).range([1, 2]).round(true).paddingInner(0.1).paddingOuter(0.2), s2 = s1.copy(); test.deepEqual(s2.domain(), s1.domain()); test.deepEqual(s2.range(), s1.range()); @@ -225,7 +225,7 @@ tape("band.copy() copies all fields", function(test) { }); tape("band.copy() isolates changes to the domain", function(test) { - var s1 = scale.band().domain(["foo", "bar"]).range([0, 2]), + var s1 = scale.scaleBand().domain(["foo", "bar"]).range([0, 2]), s2 = s1.copy(); s1.domain(["red", "blue"]); test.deepEqual(s2.domain(), ["foo", "bar"]); @@ -239,7 +239,7 @@ tape("band.copy() isolates changes to the domain", function(test) { }); tape("band.copy() isolates changes to the range", function(test) { - var s1 = scale.band().domain(["foo", "bar"]).range([0, 2]), + var s1 = scale.scaleBand().domain(["foo", "bar"]).range([0, 2]), s2 = s1.copy(); s1.range([3, 5]); test.deepEqual(s2.range(), [0, 2]); diff --git a/test/category10-test.js b/test/category10-test.js index 322fb21..fa15b05 100644 --- a/test/category10-test.js +++ b/test/category10-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("category10() is an ordinal scale", function(test) { - var s = scale.category10(); +tape("scaleCategory10() is an ordinal scale", function(test) { + var s = scale.scaleCategory10(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"]); test.equal(s(0), "#1f77b4"); @@ -16,9 +16,9 @@ tape("category10() is an ordinal scale", function(test) { test.end(); }); -tape("category10() returns an isolated instance", function(test) { - var s1 = scale.category10(), - s2 = scale.category10(); +tape("scaleCategory10() returns an isolated instance", function(test) { + var s1 = scale.scaleCategory10(), + s2 = scale.scaleCategory10(); test.equal(s1(1), "#1f77b4"); test.equal(s2(2), "#1f77b4"); test.equal(s2(1), "#ff7f0e"); diff --git a/test/category20-test.js b/test/category20-test.js index 93f48c3..e8e9536 100644 --- a/test/category20-test.js +++ b/test/category20-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("category20() is an ordinal scale", function(test) { - var s = scale.category20(); +tape("scaleCategory20() is an ordinal scale", function(test) { + var s = scale.scaleCategory20(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), ["#1f77b4", "#aec7e8", "#ff7f0e", "#ffbb78", "#2ca02c", "#98df8a", "#d62728", "#ff9896", "#9467bd", "#c5b0d5", "#8c564b", "#c49c94", "#e377c2", "#f7b6d2", "#7f7f7f", "#c7c7c7", "#bcbd22", "#dbdb8d", "#17becf", "#9edae5"]); test.equal(s(0), "#1f77b4"); @@ -16,9 +16,9 @@ tape("category20() is an ordinal scale", function(test) { test.end(); }); -tape("category20() returns an isolated instance", function(test) { - var s1 = scale.category20(), - s2 = scale.category20(); +tape("scaleCategory20() returns an isolated instance", function(test) { + var s1 = scale.scaleCategory20(), + s2 = scale.scaleCategory20(); test.equal(s1(1), "#1f77b4"); test.equal(s2(2), "#1f77b4"); test.equal(s2(1), "#aec7e8"); diff --git a/test/category20b-test.js b/test/category20b-test.js index 735bb1e..c838af4 100644 --- a/test/category20b-test.js +++ b/test/category20b-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("category20b() is an ordinal scale", function(test) { - var s = scale.category20b(); +tape("scaleCategory20b() is an ordinal scale", function(test) { + var s = scale.scaleCategory20b(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), ["#393b79", "#5254a3", "#6b6ecf", "#9c9ede", "#637939", "#8ca252", "#b5cf6b", "#cedb9c", "#8c6d31", "#bd9e39", "#e7ba52", "#e7cb94", "#843c39", "#ad494a", "#d6616b", "#e7969c", "#7b4173", "#a55194", "#ce6dbd", "#de9ed6"]); test.equal(s(0), "#393b79"); @@ -16,9 +16,9 @@ tape("category20b() is an ordinal scale", function(test) { test.end(); }); -tape("category20b() returns an isolated instance", function(test) { - var s1 = scale.category20b(), - s2 = scale.category20b(); +tape("scaleCategory20b() returns an isolated instance", function(test) { + var s1 = scale.scaleCategory20b(), + s2 = scale.scaleCategory20b(); test.equal(s1(1), "#393b79"); test.equal(s2(2), "#393b79"); test.equal(s2(1), "#5254a3"); diff --git a/test/category20c-test.js b/test/category20c-test.js index 2a6b083..335c2ab 100644 --- a/test/category20c-test.js +++ b/test/category20c-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("category20c() is an ordinal scale", function(test) { - var s = scale.category20c(); +tape("scaleCategory20c() is an ordinal scale", function(test) { + var s = scale.scaleCategory20c(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), ["#3182bd", "#6baed6", "#9ecae1", "#c6dbef", "#e6550d", "#fd8d3c", "#fdae6b", "#fdd0a2", "#31a354", "#74c476", "#a1d99b", "#c7e9c0", "#756bb1", "#9e9ac8", "#bcbddc", "#dadaeb", "#636363", "#969696", "#bdbdbd", "#d9d9d9"]); test.equal(s(0), "#3182bd"); @@ -16,9 +16,9 @@ tape("category20c() is an ordinal scale", function(test) { test.end(); }); -tape("category20c() returns an isolated instance", function(test) { - var s1 = scale.category20c(), - s2 = scale.category20c(); +tape("scaleCategory20c() returns an isolated instance", function(test) { + var s1 = scale.scaleCategory20c(), + s2 = scale.scaleCategory20c(); test.equal(s1(1), "#3182bd"); test.equal(s2(2), "#3182bd"); test.equal(s2(1), "#6baed6"); diff --git a/test/identity-test.js b/test/identity-test.js index b047f5f..1a1215c 100644 --- a/test/identity-test.js +++ b/test/identity-test.js @@ -1,8 +1,15 @@ var tape = require("tape"), scale = require("../"); +tape("scaleIdentity() has the expected defaults", function(test) { + var s = scale.scaleIdentity(); + test.deepEqual(s.domain(), [0, 1]); + test.deepEqual(s.range(), [0, 1]); + test.end(); +}); + tape("identity(x) is the identity function", function(test) { - var s = scale.identity().domain([1, 2]); + var s = scale.scaleIdentity().domain([1, 2]); test.equal(s(.5), .5); test.equal(s(1), 1); test.equal(s(1.5), 1.5); @@ -12,13 +19,13 @@ tape("identity(x) is the identity function", function(test) { }); tape("identity(x) coerces input to a number", function(test) { - var s = scale.identity().domain([1, 2]); + var s = scale.scaleIdentity().domain([1, 2]); test.equal(s("2"), 2); test.end(); }); tape("identity.invert(y) is the identity function", function(test) { - var s = scale.identity().domain([1, 2]); + var s = scale.scaleIdentity().domain([1, 2]); test.equal(s.invert(.5), .5); test.equal(s.invert(1), 1); test.equal(s.invert(1.5), 1.5); @@ -28,34 +35,34 @@ tape("identity.invert(y) is the identity function", function(test) { }); tape("identity.invert(y) coerces range value to numbers", function(test) { - var s = scale.identity().range(["0", "2"]); + var s = scale.scaleIdentity().range(["0", "2"]); test.equal(s.invert("1"), 1); - var s = scale.identity().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]); + var s = scale.scaleIdentity().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]); test.equal(s.invert(new Date(1990, 6, 2, 13)), +new Date(1990, 6, 2, 13)); - var s = scale.identity().range(["#000", "#fff"]); + var s = scale.scaleIdentity().range(["#000", "#fff"]); test.ok(isNaN(s.invert("#999"))); test.end(); }); tape("identity.invert(y) coerces input to a number", function(test) { - var s = scale.identity().domain([1, 2]); + var s = scale.scaleIdentity().domain([1, 2]); test.equal(s.invert("2"), 2); test.end(); }); tape("identity.domain() is an alias for scale.range()", function(test) { - var s = scale.identity(); + var s = scale.scaleIdentity(); test.equal(s.domain, s.range); test.deepEqual(s.domain(), s.range()); - var s = scale.identity().domain([-10, 0, 100]); + var s = scale.scaleIdentity().domain([-10, 0, 100]); test.deepEqual(s.range(), [-10, 0, 100]); - var s = scale.identity().range([-10, 0, 100]); + var s = scale.scaleIdentity().range([-10, 0, 100]); test.deepEqual(s.domain(), [-10, 0, 100]); test.end(); }); tape("identity.domain() defaults to [0, 1]", function(test) { - var s = scale.identity(); + var s = scale.scaleIdentity(); test.deepEqual(s.domain(), [0, 1]); test.deepEqual(s.range(), [0, 1]); test.equal(s(.5), .5); @@ -63,33 +70,33 @@ tape("identity.domain() defaults to [0, 1]", function(test) { }); tape("identity.domain() coerces values to numbers", function(test) { - var s = scale.identity().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]); + var s = scale.scaleIdentity().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]); test.equal(typeof s.domain()[0], "number"); test.equal(typeof s.domain()[1], "number"); test.equal(s.domain()[0], +new Date(1990, 0, 1)); test.equal(s.domain()[1], +new Date(1991, 0, 1)); test.equal(typeof s(new Date(1989, 09, 20)), "number"); test.equal(s(new Date(1989, 09, 20)), +new Date(1989, 09, 20)); - var s = scale.identity().domain(["0", "1"]); + var s = scale.scaleIdentity().domain(["0", "1"]); test.equal(typeof s.domain()[0], "number"); test.equal(typeof s.domain()[1], "number"); test.equal(s(.5), .5); - var s = scale.identity().domain([new Number(0), new Number(1)]); + var s = scale.scaleIdentity().domain([new Number(0), new Number(1)]); test.equal(typeof s.domain()[0], "number"); test.equal(typeof s.domain()[1], "number"); test.equal(s(.5), .5); - var s = scale.identity().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]); + var s = scale.scaleIdentity().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]); test.equal(typeof s.range()[0], "number"); test.equal(typeof s.range()[1], "number"); test.equal(s.range()[0], +new Date(1990, 0, 1)); test.equal(s.range()[1], +new Date(1991, 0, 1)); test.equal(typeof s(new Date(1989, 09, 20)), "number"); test.equal(s(new Date(1989, 09, 20)), +new Date(1989, 09, 20)); - var s = scale.identity().range(["0", "1"]); + var s = scale.scaleIdentity().range(["0", "1"]); test.equal(typeof s.range()[0], "number"); test.equal(typeof s.range()[1], "number"); test.equal(s(.5), .5); - var s = scale.identity().range([new Number(0), new Number(1)]); + var s = scale.scaleIdentity().range([new Number(0), new Number(1)]); test.equal(typeof s.range()[0], "number"); test.equal(typeof s.range()[1], "number"); test.equal(s(.5), .5); @@ -97,12 +104,12 @@ tape("identity.domain() coerces values to numbers", function(test) { }); tape("identity.domain() can specify a polyidentity domain and range", function(test) { - var s = scale.identity().domain([-10, 0, 100]); + var s = scale.scaleIdentity().domain([-10, 0, 100]); test.deepEqual(s.domain(), [-10, 0, 100]); test.equal(s(-5), -5); test.equal(s(50), 50); test.equal(s(75), 75); - var s = scale.identity().range([-10, 0, 100]); + var s = scale.scaleIdentity().range([-10, 0, 100]); test.deepEqual(s.range(), [-10, 0, 100]); test.equal(s(-5), -5); test.equal(s(50), 50); @@ -111,19 +118,19 @@ tape("identity.domain() can specify a polyidentity domain and range", function(t }); tape("identity.domain() does not affect the identity function", function(test) { - var s = scale.identity().domain([Infinity, NaN]); + var s = scale.scaleIdentity().domain([Infinity, NaN]); test.equal(s(42), 42); test.equal(s.invert(-42), -42); test.end(); }); tape("identity.ticks(count) generates ticks of varying degree", function(test) { - var s = scale.identity(); + var s = scale.scaleIdentity(); test.deepEqual(s.ticks(1).map(s.tickFormat(1)), ["0", "1"]); test.deepEqual(s.ticks(2).map(s.tickFormat(2)), ["0.0", "0.5", "1.0"]); test.deepEqual(s.ticks(5).map(s.tickFormat(5)), ["0.0", "0.2", "0.4", "0.6", "0.8", "1.0"]); test.deepEqual(s.ticks(10).map(s.tickFormat(10)), ["0.0", "0.1", "0.2", "0.3", "0.4", "0.5", "0.6", "0.7", "0.8", "0.9", "1.0"]); - var s = scale.identity().domain([1, 0]); + var s = scale.scaleIdentity().domain([1, 0]); test.deepEqual(s.ticks(1).map(s.tickFormat(1)), ["0", "1"].reverse()); test.deepEqual(s.ticks(2).map(s.tickFormat(2)), ["0.0", "0.5", "1.0"].reverse()); test.deepEqual(s.ticks(5).map(s.tickFormat(5)), ["0.0", "0.2", "0.4", "0.6", "0.8", "1.0"].reverse()); @@ -132,7 +139,7 @@ tape("identity.ticks(count) generates ticks of varying degree", function(test) { }); tape("identity.tickFormat(count) formats ticks with the appropriate precision", function(test) { - var s = scale.identity().domain([.123456789, 1.23456789]); + var s = scale.scaleIdentity().domain([.123456789, 1.23456789]); test.equal(s.tickFormat(1)(s.ticks(1)[0]), "1"); test.equal(s.tickFormat(2)(s.ticks(2)[0]), "0.5"); test.equal(s.tickFormat(4)(s.ticks(4)[0]), "0.2"); @@ -146,14 +153,14 @@ tape("identity.tickFormat(count) formats ticks with the appropriate precision", }); tape("identity.copy() isolates changes to the domain or range", function(test) { - var s1 = scale.identity(), + var s1 = scale.scaleIdentity(), s2 = s1.copy(); s1.domain([1, 2]); test.deepEqual(s2.domain(), [0, 1]); s2.domain([2, 3]); test.deepEqual(s1.domain(), [1, 2]); test.deepEqual(s2.domain(), [2, 3]); - var s1 = scale.identity(), s2 = s1.copy(); + var s1 = scale.scaleIdentity(), s2 = s1.copy(); s1.range([1, 2]); test.deepEqual(s2.range(), [0, 1]); s2.range([2, 3]); diff --git a/test/linear-test.js b/test/linear-test.js index cd6e348..5de3129 100644 --- a/test/linear-test.js +++ b/test/linear-test.js @@ -2,8 +2,8 @@ var tape = require("tape"), scale = require("../"), roundEpsilon = require("./roundEpsilon"); -tape("linear() has the expected defaults", function(test) { - var s = scale.linear(); +tape("scaleLinear() has the expected defaults", function(test) { + var s = scale.scaleLinear(); test.deepEqual(s.domain(), [0, 1]); test.deepEqual(s.range(), [0, 1]); test.equal(s.clamp(), false); @@ -12,30 +12,30 @@ tape("linear() has the expected defaults", function(test) { }); tape("linear(x) maps a domain value x to a range value y", function(test) { - test.equal(scale.linear().range([1, 2])(.5), 1.5); + test.equal(scale.scaleLinear().range([1, 2])(.5), 1.5); test.end(); }); tape("linear(x) ignores extra range values if the domain is smaller than the range", function(test) { - test.equal(scale.linear().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(-5), "#ff8080"); - test.equal(scale.linear().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(50), "#ffffff"); + test.equal(scale.scaleLinear().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(-5), "#ff8080"); + test.equal(scale.scaleLinear().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(50), "#ffffff"); test.end(); }); tape("linear(x) ignores extra domain values if the range is smaller than the domain", function(test) { - test.equal(scale.linear().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(-5), "#ff8080"); - test.equal(scale.linear().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(50), "#ffffff"); + test.equal(scale.scaleLinear().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(-5), "#ff8080"); + test.equal(scale.scaleLinear().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(50), "#ffffff"); test.end(); }); tape("linear(x) maps an empty domain to the range start", function(test) { - test.equal(scale.linear().domain([0, 0]).range([1, 2])(0), 1); - test.equal(scale.linear().domain([0, 0]).range([2, 1])(1), 2); + test.equal(scale.scaleLinear().domain([0, 0]).range([1, 2])(0), 1); + test.equal(scale.scaleLinear().domain([0, 0]).range([2, 1])(1), 2); test.end(); }); tape("linear(x) can map a bilinear domain with two values to the corresponding range", function(test) { - var s = scale.linear().domain([1, 2]); + var s = scale.scaleLinear().domain([1, 2]); test.deepEqual(s.domain(), [1, 2]); test.equal(s(0.5), -0.5); test.equal(s(1.0), 0.0); @@ -51,17 +51,17 @@ tape("linear(x) can map a bilinear domain with two values to the corresponding r }); tape("linear(x) can map a polylinear domain with more than two values to the corresponding range", function(test) { - var s = scale.linear().domain([-10, 0, 100]).range(["red", "white", "green"]); + var s = scale.scaleLinear().domain([-10, 0, 100]).range(["red", "white", "green"]); test.deepEqual(s.domain(), [-10, 0, 100]); test.equal(s(-5), "#ff8080"); test.equal(s(50), "#80c080"); test.equal(s(75), "#40a040"); - var s = scale.linear().domain([4, 2, 1]).range([1, 2, 4]); + var s = scale.scaleLinear().domain([4, 2, 1]).range([1, 2, 4]); test.equal(s(1.5), 3); test.equal(s(3), 1.5); test.equal(s.invert(1.5), 3); test.equal(s.invert(3), 1.5); - var s = scale.linear().domain([1, 2, 4]).range([4, 2, 1]); + var s = scale.scaleLinear().domain([1, 2, 4]).range([4, 2, 1]); test.equal(s(1.5), 3); test.equal(s(3), 1.5); test.equal(s.invert(1.5), 3); @@ -70,44 +70,44 @@ tape("linear(x) can map a polylinear domain with more than two values to the cor }); tape("linear.invert(y) maps a range value y to a domain value x", function(test) { - test.equal(scale.linear().range([1, 2]).invert(1.5), .5); + test.equal(scale.scaleLinear().range([1, 2]).invert(1.5), .5); test.end(); }); tape("linear.invert(y) maps an empty range to the domain start", function(test) { - test.equal(scale.linear().domain([1, 2]).range([0, 0]).invert(0), 1); - test.equal(scale.linear().domain([2, 1]).range([0, 0]).invert(1), 2); + test.equal(scale.scaleLinear().domain([1, 2]).range([0, 0]).invert(0), 1); + test.equal(scale.scaleLinear().domain([2, 1]).range([0, 0]).invert(1), 2); test.end(); }); tape("linear.invert(y) coerces range values to numbers", function(test) { - test.equal(scale.linear().range(["0", "2"]).invert("1"), .5); - test.equal(scale.linear().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]).invert(new Date(1990, 6, 2, 13)), .5); + test.equal(scale.scaleLinear().range(["0", "2"]).invert("1"), .5); + test.equal(scale.scaleLinear().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]).invert(new Date(1990, 6, 2, 13)), .5); test.end(); }); tape("linear.invert(y) returns NaN if the range is not coercible to number", function(test) { - test.ok(isNaN(scale.linear().range(["#000", "#fff"]).invert("#999"))); - test.ok(isNaN(scale.linear().range([0, "#fff"]).invert("#999"))); + test.ok(isNaN(scale.scaleLinear().range(["#000", "#fff"]).invert("#999"))); + test.ok(isNaN(scale.scaleLinear().range([0, "#fff"]).invert("#999"))); test.end(); }); tape("linear.domain(domain) accepts an array of numbers", function(test) { - test.deepEqual(scale.linear().domain([]).domain(), []); - test.deepEqual(scale.linear().domain([1, 0]).domain(), [1, 0]); - test.deepEqual(scale.linear().domain([1, 2, 3]).domain(), [1, 2, 3]); + test.deepEqual(scale.scaleLinear().domain([]).domain(), []); + test.deepEqual(scale.scaleLinear().domain([1, 0]).domain(), [1, 0]); + test.deepEqual(scale.scaleLinear().domain([1, 2, 3]).domain(), [1, 2, 3]); test.end(); }); tape("linear.domain(domain) coerces domain values to numbers", function(test) { - test.deepEqual(scale.linear().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]).domain(), [631180800000, 662716800000]); - test.deepEqual(scale.linear().domain(["0.0", "1.0"]).domain(), [0, 1]); - test.deepEqual(scale.linear().domain([new Number(0), new Number(1)]).domain(), [0, 1]); + test.deepEqual(scale.scaleLinear().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]).domain(), [631180800000, 662716800000]); + test.deepEqual(scale.scaleLinear().domain(["0.0", "1.0"]).domain(), [0, 1]); + test.deepEqual(scale.scaleLinear().domain([new Number(0), new Number(1)]).domain(), [0, 1]); test.end(); }); tape("linear.domain(domain) makes a copy of domain values", function(test) { - var d = [1, 2], s = scale.linear().domain(d); + var d = [1, 2], s = scale.scaleLinear().domain(d); test.deepEqual(s.domain(), [1, 2]); d.push(3); test.deepEqual(s.domain(), [1, 2]); @@ -116,7 +116,7 @@ tape("linear.domain(domain) makes a copy of domain values", function(test) { }); tape("linear.domain() returns a copy of domain values", function(test) { - var s = scale.linear(), d = s.domain(); + var s = scale.scaleLinear(), d = s.domain(); test.deepEqual(d, [0, 1]); d.push(3); test.deepEqual(s.domain(), [0, 1]); @@ -124,30 +124,30 @@ tape("linear.domain() returns a copy of domain values", function(test) { }); tape("linear.range(range) does not coerce range to numbers", function(test) { - var s = scale.linear().range(["0px", "2px"]); + var s = scale.scaleLinear().range(["0px", "2px"]); test.deepEqual(s.range(), ["0px", "2px"]); test.equal(s(.5), "1px"); test.end(); }); tape("linear.range(range) can accept range values as colors", function(test) { - test.equal(scale.linear().range(["red", "blue"])(.5), "#800080"); - test.equal(scale.linear().range(["#ff0000", "#0000ff"])(.5), "#800080"); - test.equal(scale.linear().range(["#f00", "#00f"])(.5), "#800080"); - test.equal(scale.linear().range(["rgb(255,0,0)", "hsl(240,100%,50%)"])(.5), "#800080"); - test.equal(scale.linear().range(["rgb(100%,0%,0%)", "hsl(240,100%,50%)"])(.5), "#800080"); - test.equal(scale.linear().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"])(.5), "#800080"); + test.equal(scale.scaleLinear().range(["red", "blue"])(.5), "#800080"); + test.equal(scale.scaleLinear().range(["#ff0000", "#0000ff"])(.5), "#800080"); + test.equal(scale.scaleLinear().range(["#f00", "#00f"])(.5), "#800080"); + test.equal(scale.scaleLinear().range(["rgb(255,0,0)", "hsl(240,100%,50%)"])(.5), "#800080"); + test.equal(scale.scaleLinear().range(["rgb(100%,0%,0%)", "hsl(240,100%,50%)"])(.5), "#800080"); + test.equal(scale.scaleLinear().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"])(.5), "#800080"); test.end(); }); tape("linear.range(range) can accept range values as arrays or objects", function(test) { - test.deepEqual(scale.linear().range([{color: "red"}, {color: "blue"}])(.5), {color: "#800080"}); - test.deepEqual(scale.linear().range([["red"], ["blue"]])(.5), ["#800080"]); + test.deepEqual(scale.scaleLinear().range([{color: "red"}, {color: "blue"}])(.5), {color: "#800080"}); + test.deepEqual(scale.scaleLinear().range([["red"], ["blue"]])(.5), ["#800080"]); test.end(); }); tape("linear.range(range) makes a copy of range values", function(test) { - var r = [1, 2], s = scale.linear().range(r); + var r = [1, 2], s = scale.scaleLinear().range(r); test.deepEqual(s.range(), [1, 2]); r.push(3); test.deepEqual(s.range(), [1, 2]); @@ -156,7 +156,7 @@ tape("linear.range(range) makes a copy of range values", function(test) { }); tape("linear.range() returns a copy of range values", function(test) { - var s = scale.linear(), r = s.range(); + var s = scale.scaleLinear(), r = s.range(); test.deepEqual(r, [0, 1]); r.push(3); test.deepEqual(s.range(), [0, 1]); @@ -164,96 +164,96 @@ tape("linear.range() returns a copy of range values", function(test) { }); tape("linear.rangeRound(range) is an alias for linear.range(range).interpolate(interpolateRound)", function(test) { - test.equal(scale.linear().rangeRound([0, 10])(.59), 6); + test.equal(scale.scaleLinear().rangeRound([0, 10])(.59), 6); test.end(); }); tape("linear.clamp() is false by default", function(test) { - test.equal(scale.linear().clamp(), false); - test.equal(scale.linear().range([10, 20])(2), 30); - test.equal(scale.linear().range([10, 20])(-1), 0); - test.equal(scale.linear().range([10, 20]).invert(30), 2); - test.equal(scale.linear().range([10, 20]).invert(0), -1); + test.equal(scale.scaleLinear().clamp(), false); + test.equal(scale.scaleLinear().range([10, 20])(2), 30); + test.equal(scale.scaleLinear().range([10, 20])(-1), 0); + test.equal(scale.scaleLinear().range([10, 20]).invert(30), 2); + test.equal(scale.scaleLinear().range([10, 20]).invert(0), -1); test.end(); }); tape("linear.clamp(true) restricts output values to the range", function(test) { - test.equal(scale.linear().clamp(true).range([10, 20])(2), 20); - test.equal(scale.linear().clamp(true).range([10, 20])(-1), 10); + test.equal(scale.scaleLinear().clamp(true).range([10, 20])(2), 20); + test.equal(scale.scaleLinear().clamp(true).range([10, 20])(-1), 10); test.end(); }); tape("linear.clamp(true) restricts input values to the domain", function(test) { - test.equal(scale.linear().clamp(true).range([10, 20]).invert(30), 1); - test.equal(scale.linear().clamp(true).range([10, 20]).invert(0), 0); + test.equal(scale.scaleLinear().clamp(true).range([10, 20]).invert(30), 1); + test.equal(scale.scaleLinear().clamp(true).range([10, 20]).invert(0), 0); test.end(); }); tape("linear.clamp(clamp) coerces the specified clamp value to a boolean", function(test) { - test.equal(scale.linear().clamp("true").clamp(), true); - test.equal(scale.linear().clamp(1).clamp(), true); - test.equal(scale.linear().clamp("").clamp(), false); - test.equal(scale.linear().clamp(0).clamp(), false); + test.equal(scale.scaleLinear().clamp("true").clamp(), true); + test.equal(scale.scaleLinear().clamp(1).clamp(), true); + test.equal(scale.scaleLinear().clamp("").clamp(), false); + test.equal(scale.scaleLinear().clamp(0).clamp(), false); test.end(); }); tape("linear.interpolate(interpolate) takes a custom interpolator factory", function(test) { function interpolate(a, b) { return function(t) { return [a, b, t]; }; } - var s = scale.linear().domain([10, 20]).range(["a", "b"]).interpolate(interpolate); + var s = scale.scaleLinear().domain([10, 20]).range(["a", "b"]).interpolate(interpolate); test.equal(s.interpolate(), interpolate); test.deepEqual(s(15), ["a", "b", .5]); test.end(); }); tape("linear.nice() is an alias for linear.nice(10)", function(test) { - test.deepEqual(scale.linear().domain([0, .96]).nice().domain(), [0, 1]); - test.deepEqual(scale.linear().domain([0, 96]).nice().domain(), [0, 100]); + test.deepEqual(scale.scaleLinear().domain([0, .96]).nice().domain(), [0, 1]); + test.deepEqual(scale.scaleLinear().domain([0, 96]).nice().domain(), [0, 100]); test.end(); }); tape("linear.nice(count) extends the domain to match the desired ticks", function(test) { - test.deepEqual(scale.linear().domain([0, .96]).nice(10).domain(), [0, 1]); - test.deepEqual(scale.linear().domain([0, 96]).nice(10).domain(), [0, 100]); - test.deepEqual(scale.linear().domain([.96, 0]).nice(10).domain(), [1, 0]); - test.deepEqual(scale.linear().domain([96, 0]).nice(10).domain(), [100, 0]); - test.deepEqual(scale.linear().domain([0, -.96]).nice(10).domain(), [0, -1]); - test.deepEqual(scale.linear().domain([0, -96]).nice(10).domain(), [0, -100]); - test.deepEqual(scale.linear().domain([-.96, 0]).nice(10).domain(), [-1, 0]); - test.deepEqual(scale.linear().domain([-96, 0]).nice(10).domain(), [-100, 0]); - test.deepEqual(scale.linear().domain([-0.1, 51.1]).nice(8).domain(), [-10, 60]); + test.deepEqual(scale.scaleLinear().domain([0, .96]).nice(10).domain(), [0, 1]); + test.deepEqual(scale.scaleLinear().domain([0, 96]).nice(10).domain(), [0, 100]); + test.deepEqual(scale.scaleLinear().domain([.96, 0]).nice(10).domain(), [1, 0]); + test.deepEqual(scale.scaleLinear().domain([96, 0]).nice(10).domain(), [100, 0]); + test.deepEqual(scale.scaleLinear().domain([0, -.96]).nice(10).domain(), [0, -1]); + test.deepEqual(scale.scaleLinear().domain([0, -96]).nice(10).domain(), [0, -100]); + test.deepEqual(scale.scaleLinear().domain([-.96, 0]).nice(10).domain(), [-1, 0]); + test.deepEqual(scale.scaleLinear().domain([-96, 0]).nice(10).domain(), [-100, 0]); + test.deepEqual(scale.scaleLinear().domain([-0.1, 51.1]).nice(8).domain(), [-10, 60]); test.end(); }); tape("linear.nice(count) nices the domain, extending it to round numbers", function(test) { - test.deepEqual(scale.linear().domain([1.1, 10.9]).nice(10).domain(), [1, 11]); - test.deepEqual(scale.linear().domain([10.9, 1.1]).nice(10).domain(), [11, 1]); - test.deepEqual(scale.linear().domain([.7, 11.001]).nice(10).domain(), [0, 12]); - test.deepEqual(scale.linear().domain([123.1, 6.7]).nice(10).domain(), [130, 0]); - test.deepEqual(scale.linear().domain([0, .49]).nice(10).domain(), [0, .5]); + test.deepEqual(scale.scaleLinear().domain([1.1, 10.9]).nice(10).domain(), [1, 11]); + test.deepEqual(scale.scaleLinear().domain([10.9, 1.1]).nice(10).domain(), [11, 1]); + test.deepEqual(scale.scaleLinear().domain([.7, 11.001]).nice(10).domain(), [0, 12]); + test.deepEqual(scale.scaleLinear().domain([123.1, 6.7]).nice(10).domain(), [130, 0]); + test.deepEqual(scale.scaleLinear().domain([0, .49]).nice(10).domain(), [0, .5]); test.end(); }); tape("linear.nice(count) has no effect on degenerate domains", function(test) { - test.deepEqual(scale.linear().domain([0, 0]).nice(10).domain(), [0, 0]); - test.deepEqual(scale.linear().domain([.5, .5]).nice(10).domain(), [.5, .5]); + test.deepEqual(scale.scaleLinear().domain([0, 0]).nice(10).domain(), [0, 0]); + test.deepEqual(scale.scaleLinear().domain([.5, .5]).nice(10).domain(), [.5, .5]); test.end(); }); tape("linear.nice(count) nicing a polylinear domain only affects the extent", function(test) { - test.deepEqual(scale.linear().domain([1.1, 1, 2, 3, 10.9]).nice(10).domain(), [1, 1, 2, 3, 11]); - test.deepEqual(scale.linear().domain([123.1, 1, 2, 3, -.9]).nice(10).domain(), [130, 1, 2, 3, -10]); + test.deepEqual(scale.scaleLinear().domain([1.1, 1, 2, 3, 10.9]).nice(10).domain(), [1, 1, 2, 3, 11]); + test.deepEqual(scale.scaleLinear().domain([123.1, 1, 2, 3, -.9]).nice(10).domain(), [130, 1, 2, 3, -10]); test.end(); }); tape("linear.nice(count) accepts a tick count to control nicing step", function(test) { - test.deepEqual(scale.linear().domain([12, 87]).nice(5).domain(), [0, 100]); - test.deepEqual(scale.linear().domain([12, 87]).nice(10).domain(), [10, 90]); - test.deepEqual(scale.linear().domain([12, 87]).nice(100).domain(), [12, 87]); + test.deepEqual(scale.scaleLinear().domain([12, 87]).nice(5).domain(), [0, 100]); + test.deepEqual(scale.scaleLinear().domain([12, 87]).nice(10).domain(), [10, 90]); + test.deepEqual(scale.scaleLinear().domain([12, 87]).nice(100).domain(), [12, 87]); test.end(); }); tape("linear.ticks(count) returns the expected ticks for an ascending domain", function(test) { - var s = scale.linear(); + var s = scale.scaleLinear(); test.deepEqual(s.ticks(10).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(9).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(8).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); @@ -279,7 +279,7 @@ tape("linear.ticks(count) returns the expected ticks for an ascending domain", f }); tape("linear.ticks(count) returns the expected ticks for a descending domain", function(test) { - var s = scale.linear().domain([1, 0]); + var s = scale.scaleLinear().domain([1, 0]); test.deepEqual(s.ticks(10).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0].reverse()); test.deepEqual(s.ticks(9).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0].reverse()); test.deepEqual(s.ticks(8).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0].reverse()); @@ -305,7 +305,7 @@ tape("linear.ticks(count) returns the expected ticks for a descending domain", f }); tape("linear.ticks(count) returns the expected ticks for a polylinear domain", function(test) { - var s = scale.linear().domain([0, 0.25, 0.9, 1]); + var s = scale.scaleLinear().domain([0, 0.25, 0.9, 1]); test.deepEqual(s.ticks(10).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(9).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(8).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); @@ -331,7 +331,7 @@ tape("linear.ticks(count) returns the expected ticks for a polylinear domain", f }); tape("linear.ticks(count) returns the empty array if count is not a positive integer", function(test) { - var s = scale.linear(); + var s = scale.scaleLinear(); test.deepEqual(s.ticks(NaN), []); test.deepEqual(s.ticks(0), []); test.deepEqual(s.ticks(-1), []); @@ -340,58 +340,58 @@ tape("linear.ticks(count) returns the empty array if count is not a positive int }); tape("linear.ticks() is an alias for linear.ticks(10)", function(test) { - var s = scale.linear(); + var s = scale.scaleLinear(); test.deepEqual(s.ticks(), s.ticks(10)); test.end(); }); tape("linear.tickFormat() is an alias for linear.tickFormat(10)", function(test) { - test.equal(scale.linear().tickFormat()(0.2), "0.2"); - test.equal(scale.linear().domain([-100, 100]).tickFormat()(-20), "-20"); + test.equal(scale.scaleLinear().tickFormat()(0.2), "0.2"); + test.equal(scale.scaleLinear().domain([-100, 100]).tickFormat()(-20), "-20"); test.end(); }); tape("linear.tickFormat(count) returns a format suitable for the ticks", function(test) { - test.equal(scale.linear().tickFormat(10)(0.2), "0.2"); - test.equal(scale.linear().tickFormat(20)(0.2), "0.20"); - test.equal(scale.linear().domain([-100, 100]).tickFormat(10)(-20), "-20"); + test.equal(scale.scaleLinear().tickFormat(10)(0.2), "0.2"); + test.equal(scale.scaleLinear().tickFormat(20)(0.2), "0.20"); + test.equal(scale.scaleLinear().domain([-100, 100]).tickFormat(10)(-20), "-20"); test.end(); }); tape("linear.tickFormat(count, specifier) sets the appropriate fixed precision if not specified", function(test) { - test.equal(scale.linear().tickFormat(10, "+f")(0.2), "+0.2"); - test.equal(scale.linear().tickFormat(20, "+f")(0.2), "+0.20"); - test.equal(scale.linear().tickFormat(10, "+%")(0.2), "+20%"); - test.equal(scale.linear().domain([0.19, 0.21]).tickFormat(10, "+%")(0.2), "+20.0%"); + test.equal(scale.scaleLinear().tickFormat(10, "+f")(0.2), "+0.2"); + test.equal(scale.scaleLinear().tickFormat(20, "+f")(0.2), "+0.20"); + test.equal(scale.scaleLinear().tickFormat(10, "+%")(0.2), "+20%"); + test.equal(scale.scaleLinear().domain([0.19, 0.21]).tickFormat(10, "+%")(0.2), "+20.0%"); test.end(); }); tape("linear.tickFormat(count, specifier) sets the appropriate round precision if not specified", function(test) { - test.equal(scale.linear().domain([0, 9]).tickFormat(10, "")(2.10), "2"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "")(2.01), "2"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "")(2.11), "2.1"); - test.equal(scale.linear().domain([0, 9]).tickFormat(10, "e")(2.10), "2e+0"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "e")(2.01), "2.0e+0"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "e")(2.11), "2.1e+0"); - test.equal(scale.linear().domain([0, 9]).tickFormat(10, "g")(2.10), "2"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "g")(2.01), "2.0"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "g")(2.11), "2.1"); - test.equal(scale.linear().domain([0, 9]).tickFormat(10, "r")(2.10e6), "2000000"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "r")(2.01e6), "2000000"); - test.equal(scale.linear().domain([0, 9]).tickFormat(100, "r")(2.11e6), "2100000"); - test.equal(scale.linear().domain([0, .9]).tickFormat(10, "p")(.210), "20%"); - test.equal(scale.linear().domain([.19, .21]).tickFormat(10, "p")(.201), "20.1%"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(10, "")(2.10), "2"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "")(2.01), "2"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "")(2.11), "2.1"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(10, "e")(2.10), "2e+0"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "e")(2.01), "2.0e+0"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "e")(2.11), "2.1e+0"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(10, "g")(2.10), "2"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "g")(2.01), "2.0"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "g")(2.11), "2.1"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(10, "r")(2.10e6), "2000000"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "r")(2.01e6), "2000000"); + test.equal(scale.scaleLinear().domain([0, 9]).tickFormat(100, "r")(2.11e6), "2100000"); + test.equal(scale.scaleLinear().domain([0, .9]).tickFormat(10, "p")(.210), "20%"); + test.equal(scale.scaleLinear().domain([.19, .21]).tickFormat(10, "p")(.201), "20.1%"); test.end(); }); tape("linear.tickFormat(count, specifier) sets the appropriate prefix precision if not specified", function(test) { - test.equal(scale.linear().domain([0, 1e6]).tickFormat(10, "$s")(0.51e6), "$0.5M"); - test.equal(scale.linear().domain([0, 1e6]).tickFormat(100, "$s")(0.501e6), "$0.50M"); + test.equal(scale.scaleLinear().domain([0, 1e6]).tickFormat(10, "$s")(0.51e6), "$0.5M"); + test.equal(scale.scaleLinear().domain([0, 1e6]).tickFormat(100, "$s")(0.501e6), "$0.50M"); test.end(); }); tape("linear.copy() returns a copy with changes to the domain are isolated", function(test) { - var x = scale.linear(), y = x.copy(); + var x = scale.scaleLinear(), y = x.copy(); x.domain([1, 2]); test.deepEqual(y.domain(), [0, 1]); test.equal(x(1), 0); @@ -409,7 +409,7 @@ tape("linear.copy() returns a copy with changes to the domain are isolated", fun }); tape("linear.copy() returns a copy with changes to the range are isolated", function(test) { - var x = scale.linear(), y = x.copy(); + var x = scale.scaleLinear(), y = x.copy(); x.range([1, 2]); test.equal(x.invert(1), 0); test.equal(y.invert(1), 1); @@ -423,7 +423,7 @@ tape("linear.copy() returns a copy with changes to the range are isolated", func }); tape("linear.copy() returns a copy with changes to the interpolator are isolated", function(test) { - var x = scale.linear().range(["red", "blue"]), + var x = scale.scaleLinear().range(["red", "blue"]), y = x.copy(), i0 = x.interpolate(), i1 = function(a, b) { return function(t) { return b; }; }; @@ -435,7 +435,7 @@ tape("linear.copy() returns a copy with changes to the interpolator are isolated }); tape("linear.copy() returns a copy with changes to clamping are isolated", function(test) { - var x = scale.linear().clamp(true), y = x.copy(); + var x = scale.scaleLinear().clamp(true), y = x.copy(); x.clamp(false); test.equal(x(2), 2); test.equal(y(2), 1); diff --git a/test/log-test.js b/test/log-test.js index 3cfc81f..4898d42 100644 --- a/test/log-test.js +++ b/test/log-test.js @@ -6,8 +6,8 @@ var tape = require("tape"), require("./inDelta"); -tape("log() has the expected defaults", function(test) { - var x = scale.log(); +tape("scaleLog() has the expected defaults", function(test) { + var x = scale.scaleLog(); test.deepEqual(x.domain(), [1, 10]); test.deepEqual(x.range(), [0, 1]); test.equal(x.clamp(), false); @@ -22,7 +22,7 @@ tape("log() has the expected defaults", function(test) { }); tape("log.domain(…) coerces values to numbers", function(test) { - var x = scale.log().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]); + var x = scale.scaleLog().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]); test.equal(typeof x.domain()[0], "number"); test.equal(typeof x.domain()[1], "number"); test.inDelta(x(new Date(1989, 09, 20)), -0.2061048); @@ -43,7 +43,7 @@ tape("log.domain(…) coerces values to numbers", function(test) { }); tape("log.domain(…) can take negative values", function(test) { - var x = scale.log().domain([-100, -1]); + var x = scale.scaleLog().domain([-100, -1]); test.deepEqual(x.ticks().map(x.tickFormat()), [ "-1e+2", "-9e+1", "-8e+1", "-7e+1", "-6e+1", "-5e+1", "-4e+1", "-3e+1", "-2e+1", "-1e+1", @@ -54,7 +54,7 @@ tape("log.domain(…) can take negative values", function(test) { }); tape("log.domain(…).range(…) can take more than two values", function(test) { - var x = scale.log().domain([0.1, 1, 100]).range(["red", "white", "green"]); + var x = scale.scaleLog().domain([0.1, 1, 100]).range(["red", "white", "green"]); test.equal(x(0.5), "#ffb2b2"); test.equal(x(50), "#269326"); test.equal(x(75), "#108810"); @@ -62,20 +62,20 @@ tape("log.domain(…).range(…) can take more than two values", function(test) }); tape("log.domain(…) preserves specified domain exactly, with no floating point error", function(test) { - var x = scale.log().domain([0.1, 1000]); + var x = scale.scaleLog().domain([0.1, 1000]); test.deepEqual(x.domain(), [0.1, 1000]); test.end(); }); tape("log.range(…) does not coerce values to numbers", function(test) { - var x = scale.log().range(["0", "2"]); + var x = scale.scaleLog().range(["0", "2"]); test.equal(typeof x.range()[0], "string"); test.equal(typeof x.range()[1], "string"); test.end(); }); tape("log.range(…) can take colors", function(test) { - var x = scale.log().range(["red", "blue"]); + var x = scale.scaleLog().range(["red", "blue"]); test.equal(x(5), "#4d00b2"); x.range(["#ff0000", "#0000ff"]); test.equal(x(5), "#4d00b2"); @@ -89,7 +89,7 @@ tape("log.range(…) can take colors", function(test) { }); tape("log.range(…) can take arrays or objects", function(test) { - var x = scale.log().range([{color: "red"}, {color: "blue"}]); + var x = scale.scaleLog().range([{color: "red"}, {color: "blue"}]); test.deepEqual(x(5), {color: "#4d00b2"}); x.range([["red"], ["blue"]]); test.deepEqual(x(5), ["#4d00b2"]); @@ -97,7 +97,7 @@ tape("log.range(…) can take arrays or objects", function(test) { }); tape("log.interpolate(f) sets the interpolator", function(test) { - var x = scale.log().range(["red", "blue"]); + var x = scale.scaleLog().range(["red", "blue"]); test.equal(x.interpolate(), interpolate.interpolate); test.equal(x(5), "#4d00b2"); x.interpolate(interpolate.interpolateHsl); @@ -106,7 +106,7 @@ tape("log.interpolate(f) sets the interpolator", function(test) { }); tape("log(x) does not clamp by default", function(test) { - var x = scale.log(); + var x = scale.scaleLog(); test.equal(x.clamp(), false); test.inDelta(x(0.5), -0.3010299); test.inDelta(x(15), 1.1760913); @@ -114,7 +114,7 @@ tape("log(x) does not clamp by default", function(test) { }); tape("log.clamp(true)(x) clamps to the domain", function(test) { - var x = scale.log().clamp(true); + var x = scale.scaleLog().clamp(true); test.inDelta(x(-1), 0); test.inDelta(x(5), 0.69897); test.inDelta(x(15), 1); @@ -126,7 +126,7 @@ tape("log.clamp(true)(x) clamps to the domain", function(test) { }); tape("log.clamp(true).invert(y) clamps to the range", function(test) { - var x = scale.log().clamp(true); + var x = scale.scaleLog().clamp(true); test.inDelta(x.invert(-0.1), 1); test.inDelta(x.invert(0.69897), 5); test.inDelta(x.invert(1.5), 10); @@ -138,7 +138,7 @@ tape("log.clamp(true).invert(y) clamps to the range", function(test) { }); tape("log(x) maps a number x to a number y", function(test) { - var x = scale.log().domain([1, 2]); + var x = scale.scaleLog().domain([1, 2]); test.inDelta(x(0.5), -1.0000000); test.inDelta(x(1.0), 0.0000000); test.inDelta(x(1.5), 0.5849625); @@ -148,7 +148,7 @@ tape("log(x) maps a number x to a number y", function(test) { }); tape("log.invert(y) maps a number y to a number x", function(test) { - var x = scale.log().domain([1, 2]); + var x = scale.scaleLog().domain([1, 2]); test.inDelta(x.invert(-1.0000000), 0.5); test.inDelta(x.invert( 0.0000000), 1.0); test.inDelta(x.invert( 0.5849625), 1.5); @@ -158,7 +158,7 @@ tape("log.invert(y) maps a number y to a number x", function(test) { }); tape("log.invert(y) coerces y to number", function(test) { - var x = scale.log().range(["0", "2"]); + var x = scale.scaleLog().range(["0", "2"]); test.inDelta(x.invert("1"), 3.1622777); x.range([new Date(1990, 0, 1), new Date(1991, 0, 1)]); test.inDelta(x.invert(new Date(1990, 6, 2, 13)), 3.1622777); @@ -168,14 +168,14 @@ tape("log.invert(y) coerces y to number", function(test) { }); tape("log.base(b) sets the log base, changing the ticks", function(test) { - var x = scale.log().domain([1, 32]); + var x = scale.scaleLog().domain([1, 32]); test.deepEqual(x.base(2).ticks().map(x.tickFormat()), ["1", "2", "4", "8", "16", "32"]); test.deepEqual(x.base(Math.E).ticks().map(x.tickFormat()), ["1", "2.71828182846", "7.38905609893", "20.0855369232"]); test.end(); }); tape("log.nice() nices the domain, extending it to powers of ten", function(test) { - var x = scale.log().domain([1.1, 10.9]).nice(); + var x = scale.scaleLog().domain([1.1, 10.9]).nice(); test.deepEqual(x.domain(), [1, 100]); x.domain([10.9, 1.1]).nice(); test.deepEqual(x.domain(), [100, 1]); @@ -193,7 +193,7 @@ tape("log.nice() nices the domain, extending it to powers of ten", function(test }); tape("log.nice() works on degenerate domains", function(test) { - var x = scale.log().domain([0, 0]).nice(); + var x = scale.scaleLog().domain([0, 0]).nice(); test.deepEqual(x.domain(), [0, 0]); x.domain([0.5, 0.5]).nice(); test.deepEqual(x.domain(), [0.1, 1]); @@ -201,7 +201,7 @@ tape("log.nice() works on degenerate domains", function(test) { }); tape("log.nice() on a polylog domain only affects the extent", function(test) { - var x = scale.log().domain([1.1, 1.5, 10.9]).nice(); + var x = scale.scaleLog().domain([1.1, 1.5, 10.9]).nice(); test.deepEqual(x.domain(), [1, 1.5, 100]); x.domain([-123.1, -1.5, -0.5]).nice(); test.deepEqual(x.domain(), [-1000, -1.5, -0.1]); @@ -209,7 +209,7 @@ tape("log.nice() on a polylog domain only affects the extent", function(test) { }); tape("log.copy() isolates changes to the domain", function(test) { - var x = scale.log(), y = x.copy(); + var x = scale.scaleLog(), y = x.copy(); x.domain([10, 100]); test.deepEqual(y.domain(), [1, 10]); test.inDelta(x(10), 0); @@ -223,7 +223,7 @@ tape("log.copy() isolates changes to the domain", function(test) { }); tape("log.copy() isolates changes to the domain via nice", function(test) { - var x = scale.log().domain([1.5, 50]), y = x.copy().nice(); + var x = scale.scaleLog().domain([1.5, 50]), y = x.copy().nice(); test.deepEqual(x.domain(), [1.5, 50]); test.inDelta(x(1.5), 0); test.inDelta(x(50), 1); @@ -238,7 +238,7 @@ tape("log.copy() isolates changes to the domain via nice", function(test) { }); tape("log.copy() isolates changes to the range", function(test) { - var x = scale.log(), y = x.copy(); + var x = scale.scaleLog(), y = x.copy(); x.range([1, 2]); test.inDelta(x.invert(1), 1); test.inDelta(y.invert(1), 10); @@ -252,7 +252,7 @@ tape("log.copy() isolates changes to the range", function(test) { }); tape("log.copy() isolates changes to the interpolator", function(test) { - var x = scale.log().range(["red", "blue"]), y = x.copy(); + var x = scale.scaleLog().range(["red", "blue"]), y = x.copy(); x.interpolate(interpolate.interpolateHsl); test.equal(x(5), "#9a00ff"); test.equal(y(5), "#4d00b2"); @@ -261,7 +261,7 @@ tape("log.copy() isolates changes to the interpolator", function(test) { }); tape("log.copy() isolates changes to clamping", function(test) { - var x = scale.log().clamp(true), y = x.copy(); + var x = scale.scaleLog().clamp(true), y = x.copy(); x.clamp(false); test.inDelta(x(0.5), -0.30103); test.inDelta(y(0.5), 0); @@ -274,7 +274,7 @@ tape("log.copy() isolates changes to clamping", function(test) { }); tape("log.ticks() generates the expected power-of-ten for ascending ticks", function(test) { - var s = scale.log(); + var s = scale.scaleLog(); test.deepEqual(s.domain([1e-1, 1e1]).ticks().map(round), [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); test.deepEqual(s.domain([1e-1, 1e0]).ticks().map(round), [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]); test.deepEqual(s.domain([-1e0, -1e-1]).ticks().map(round), [-1, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1]); @@ -283,7 +283,7 @@ tape("log.ticks() generates the expected power-of-ten for ascending ticks", func tape("log.ticks() generates the expected power-of-ten ticks for descending domains", function(test) { - var s = scale.log(); + var s = scale.scaleLog(); test.deepEqual(s.domain([-1e-1, -1e1]).ticks().map(round), [-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1].reverse()); test.deepEqual(s.domain([-1e-1, -1e0]).ticks().map(round), [-1, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1].reverse()); test.deepEqual(s.domain([1e0, 1e-1]).ticks().map(round), [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1].reverse()); @@ -291,7 +291,7 @@ tape("log.ticks() generates the expected power-of-ten ticks for descending domai }); tape("log.ticks() generates the expected power-of-ten ticks for small domains", function(test) { - var s = scale.log(); + var s = scale.scaleLog(); test.deepEqual(s.domain([1, 5]).ticks(), [1, 2, 3, 4, 5]); test.deepEqual(s.domain([5, 1]).ticks(), [5, 4, 3, 2, 1]); test.deepEqual(s.domain([-1, -5]).ticks(), [-1, -2, -3, -4, -5]); @@ -300,19 +300,19 @@ tape("log.ticks() generates the expected power-of-ten ticks for small domains", }); tape("log.base(base).ticks() generates the expected power-of-base ticks", function(test) { - var s = scale.log().base(Math.E); + var s = scale.scaleLog().base(Math.E); test.deepEqual(s.domain([0.1, 100]).ticks().map(round), [0.135335283237, 0.367879441171, 1, 2.718281828459, 7.389056098931, 20.085536923188, 54.598150033144]); test.end(); }); tape("log.tickFormat() returns the \".0e\" format", function(test) { - var s = scale.log(); + var s = scale.scaleLog(); test.deepEqual(s.domain([1e-1, 1e1]).ticks().map(s.tickFormat()), ["1e-1", "2e-1", "3e-1", "4e-1", "5e-1", "6e-1", "7e-1", "8e-1", "9e-1", "1e+0", "2e+0", "3e+0", "4e+0", "5e+0", "6e+0", "7e+0", "8e+0", "9e+0", "1e+1"]); test.end(); }); tape("log.tickFormat(count) returns a filtered \".0e\" format", function(test) { - var s = scale.log(), t = s.domain([1e-1, 1e1]).ticks(); + var s = scale.scaleLog(), t = s.domain([1e-1, 1e1]).ticks(); test.deepEqual(t.map(s.tickFormat(10)), ["1e-1", "2e-1", "3e-1", "4e-1", "5e-1", "", "", "", "", "1e+0", "2e+0", "3e+0", "4e+0", "5e+0", "", "", "", "", "1e+1"]); test.deepEqual(t.map(s.tickFormat(5)), ["1e-1", "2e-1", "", "", "", "", "", "", "", "1e+0", "2e+0", "", "", "", "", "", "", "", "1e+1"]); test.deepEqual(t.map(s.tickFormat(1)), ["1e-1", "", "", "", "", "", "", "", "", "1e+0", "", "", "", "", "", "", "", "", "1e+1"]); @@ -321,19 +321,19 @@ tape("log.tickFormat(count) returns a filtered \".0e\" format", function(test) { }); tape("log.tickFormat(count, format) returns the specified format, filtered", function(test) { - var s = scale.log(), t = s.domain([1e-1, 1e1]).ticks(); + var s = scale.scaleLog(), t = s.domain([1e-1, 1e1]).ticks(); test.deepEqual(t.map(s.tickFormat(10, "+")), ["+0.1", "+0.2", "+0.3", "+0.4", "+0.5", "", "", "", "", "+1", "+2", "+3", "+4", "+5", "", "", "", "", "+10"]); test.end(); }); tape("log.base(base).tickFormat() returns the \",\" format", function(test) { - var s = scale.log().base(Math.E); + var s = scale.scaleLog().base(Math.E); test.deepEqual(s.domain([1e-1, 1e1]).ticks().map(s.tickFormat()), ["0.135335283237", "0.367879441171", "1", "2.71828182846", "7.38905609893"]); test.end(); }); tape("log.base(base).tickFormat(count) returns a filtered \",\" format", function(test) { - var s = scale.log().base(16), t = s.domain([1e-1, 1e1]).ticks(); + var s = scale.scaleLog().base(16), t = s.domain([1e-1, 1e1]).ticks(); test.deepEqual(t.map(s.tickFormat(10)), ["0.125", "0.1875", "0.25", "0.3125", "0.375", "", "", "", "", "", "", "", "", "", "1", "2", "3", "4", "5", "6", "", "", "", ""]); test.deepEqual(t.map(s.tickFormat(5)), ["0.125", "0.1875", "", "", "", "", "", "", "", "", "", "", "", "", "1", "2", "3", "", "", "", "", "", "", ""]); test.deepEqual(t.map(s.tickFormat(1)), ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "1", "", "", "", "", "", "", "", "", ""]); @@ -341,7 +341,7 @@ tape("log.base(base).tickFormat(count) returns a filtered \",\" format", functio }); tape("log.ticks() generates log ticks", function(test) { - var x = scale.log(); + var x = scale.scaleLog(); test.deepEqual(x.ticks().map(x.tickFormat()), [ "1e+0", "2e+0", "3e+0", "4e+0", "5e+0", "6e+0", "7e+0", "8e+0", "9e+0", "1e+1" @@ -366,7 +366,7 @@ tape("log.ticks() generates log ticks", function(test) { }); tape("log.tickFormat(count) filters ticks to about count", function(test) { - var x = scale.log(); + var x = scale.scaleLog(); test.deepEqual(x.ticks().map(x.tickFormat(5)), [ "1e+0", "2e+0", "3e+0", "4e+0", "5e+0", "", "", "", "", "1e+1" @@ -381,7 +381,7 @@ tape("log.tickFormat(count) filters ticks to about count", function(test) { }); tape("log.ticks(count) filters powers-of-ten ticks for huge domains", function(test) { - var x = scale.log().domain([1e10, 1]); + var x = scale.scaleLog().domain([1e10, 1]); test.deepEqual(x.ticks().map(x.tickFormat()), ["1e+0", "1e+1", "1e+2", "1e+3", "1e+4", "1e+5", "1e+6", "1e+7", "1e+8", "1e+9", "1e+10"]); x.domain([1e-29, 1e-1]); test.deepEqual(x.ticks().map(x.tickFormat()), ["1e-28", "1e-26", "1e-24", "1e-22", "1e-20", "1e-18", "1e-16", "1e-14", "1e-12", "1e-10", "1e-8", "1e-6", "1e-4", "1e-2"]); @@ -389,7 +389,7 @@ tape("log.ticks(count) filters powers-of-ten ticks for huge domains", function(t }); tape("log.ticks() generates ticks that cover the domain", function(test) { - var x = scale.log().domain([0.01, 10000]); + var x = scale.scaleLog().domain([0.01, 10000]); test.deepEqual(x.ticks(20).map(x.tickFormat(20)), [ "1e-2", "2e-2", "3e-2", "", "", "", "", "", "", "1e-1", "2e-1", "3e-1", "", "", "", "", "", "", @@ -403,7 +403,7 @@ tape("log.ticks() generates ticks that cover the domain", function(test) { }); tape("log.ticks() generates ticks that cover the niced domain", function(test) { - var x = scale.log().domain([0.0124123, 1230.4]).nice(); + var x = scale.scaleLog().domain([0.0124123, 1230.4]).nice(); test.deepEqual(x.ticks(20).map(x.tickFormat(20)), [ "1e-2", "2e-2", "3e-2", "", "", "", "", "", "", "1e-1", "2e-1", "3e-1", "", "", "", "", "", "", @@ -417,7 +417,7 @@ tape("log.ticks() generates ticks that cover the niced domain", function(test) { }); tape("log.tickFormat(count, format) returns a filtered format", function(test) { - var x = scale.log().domain([1000.1, 1]); + var x = scale.scaleLog().domain([1000.1, 1]); test.deepEqual(x.ticks().map(x.tickFormat(10, format.format("+,d"))), [ "+1,000", "", "", "", "", "", "", "+300", "+200", "+100", @@ -428,7 +428,7 @@ tape("log.tickFormat(count, format) returns a filtered format", function(test) { }); tape("log.tickFormat(count, specifier) returns a filtered format", function(test) { - var x = scale.log().domain([1000.1, 1]); + var x = scale.scaleLog().domain([1000.1, 1]); test.deepEqual(x.ticks().map(x.tickFormat(10, ".1s")), [ "1k", "", "", "", "", "", "", "300", "200", "100", @@ -439,7 +439,7 @@ tape("log.tickFormat(count, specifier) returns a filtered format", function(test }); tape("log.ticks() returns the empty array when the domain is degenerate", function(test) { - var x = scale.log(); + var x = scale.scaleLog(); test.deepEqual(x.domain([0, 1]).ticks(), []); test.deepEqual(x.domain([1, 0]).ticks(), []); test.deepEqual(x.domain([0, -1]).ticks(), []); diff --git a/test/ordinal-test.js b/test/ordinal-test.js index cc08286..a5f1959 100644 --- a/test/ordinal-test.js +++ b/test/ordinal-test.js @@ -1,21 +1,21 @@ var tape = require("tape"), scale = require("../"); -tape("ordinal() has the expected defaults", function(test) { - var s = scale.ordinal(); +tape("scaleOrdinal() has the expected defaults", function(test) { + var s = scale.scaleOrdinal(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), []); test.equal(s(0), undefined); - test.equal(s.unknown(), scale.implicit); + test.equal(s.unknown(), scale.scaleImplicit); test.deepEqual(s.domain(), [0]); test.end(); }); tape("ordinal(x) maps a unique name x in the domain to the corresponding value y in the range", function(test) { - var s = scale.ordinal().domain([0, 1]).range(["foo", "bar"]); + var s = scale.scaleOrdinal().domain([0, 1]).range(["foo", "bar"]); test.equal(s(0), "foo"); test.equal(s(1), "bar"); - var s = scale.ordinal().range(["a", "b", "c"]); + var s = scale.scaleOrdinal().range(["a", "b", "c"]); test.equal(s(0), "a"); test.equal(s("0"), "a"); test.equal(s([0]), "a"); @@ -26,7 +26,7 @@ tape("ordinal(x) maps a unique name x in the domain to the corresponding value y }); tape("ordinal(x) implicitly extends the domain when a range is explicitly specified", function(test) { - var s = scale.ordinal().range(["foo", "bar"]); + var s = scale.scaleOrdinal().range(["foo", "bar"]); test.deepEqual(s.domain(), []); test.equal(s(0), "foo"); test.deepEqual(s.domain(), [0]); @@ -39,14 +39,14 @@ tape("ordinal(x) implicitly extends the domain when a range is explicitly specif tape("ordinal.domain(x) makes a copy of the domain", function(test) { var domain = ["red", "green"], - s = scale.ordinal().domain(domain); + s = scale.scaleOrdinal().domain(domain); domain.push("blue"); test.deepEqual(s.domain(), ["red", "green"]); test.end(); }); tape("ordinal.domain() returns a copy of the domain", function(test) { - var s = scale.ordinal().domain(["red", "green"]), + var s = scale.scaleOrdinal().domain(["red", "green"]), domain = s.domain(); s("blue"); test.deepEqual(domain, ["red", "green"]); @@ -54,7 +54,7 @@ tape("ordinal.domain() returns a copy of the domain", function(test) { }); tape("ordinal.domain() replaces previous domain values", function(test) { - var s = scale.ordinal().range(["foo", "bar"]); + var s = scale.scaleOrdinal().range(["foo", "bar"]); test.equal(s(1), "foo"); test.equal(s(0), "bar"); test.deepEqual(s.domain(), [1, 0]); @@ -66,7 +66,7 @@ tape("ordinal.domain() replaces previous domain values", function(test) { }); tape("ordinal.domain() uniqueness is based on string coercion", function(test) { - var s = scale.ordinal().domain(["foo"]).range([42, 43, 44]); + var s = scale.scaleOrdinal().domain(["foo"]).range([42, 43, 44]); test.equal(s(new String("foo")), 42); test.equal(s({toString: function() { return "foo"; }}), 42); test.equal(s({toString: function() { return "bar"; }}), 43); @@ -74,7 +74,7 @@ tape("ordinal.domain() uniqueness is based on string coercion", function(test) { }); tape("ordinal.domain() does not coerce domain values to strings", function(test) { - var s = scale.ordinal().domain([0, 1]); + var s = scale.scaleOrdinal().domain([0, 1]); test.deepEqual(s.domain(), [0, 1]); test.equal(typeof s.domain()[0], "number"); test.equal(typeof s.domain()[1], "number"); @@ -82,7 +82,7 @@ tape("ordinal.domain() does not coerce domain values to strings", function(test) }); tape("ordinal.domain() does not barf on object built-ins", function(test) { - var s = scale.ordinal().domain(["__proto__", "hasOwnProperty"]).range([42, 43]); + var s = scale.scaleOrdinal().domain(["__proto__", "hasOwnProperty"]).range([42, 43]); test.equal(s("__proto__"), 42); test.equal(s("hasOwnProperty"), 43); test.deepEqual(s.domain(), ["__proto__", "hasOwnProperty"]); @@ -90,7 +90,7 @@ tape("ordinal.domain() does not barf on object built-ins", function(test) { }); tape("ordinal.domain() is ordered by appearance", function(test) { - var s = scale.ordinal(); + var s = scale.scaleOrdinal(); s("foo"); s("bar"); s("baz"); @@ -109,14 +109,14 @@ tape("ordinal.domain() is ordered by appearance", function(test) { tape("ordinal.range(x) makes a copy of the range", function(test) { var range = ["red", "green"], - s = scale.ordinal().range(range); + s = scale.scaleOrdinal().range(range); range.push("blue"); test.deepEqual(s.range(), ["red", "green"]); test.end(); }); tape("ordinal.range() returns a copy of the range", function(test) { - var s = scale.ordinal().range(["red", "green"]), + var s = scale.scaleOrdinal().range(["red", "green"]), range = s.range(); test.deepEqual(range, ["red", "green"]); range.push("blue"); @@ -125,7 +125,7 @@ tape("ordinal.range() returns a copy of the range", function(test) { }); tape("ordinal.range(values) does not discard implicit domain associations", function(test) { - var s = scale.ordinal(); + var s = scale.scaleOrdinal(); test.equal(s(0), undefined); test.equal(s(1), undefined); s.range(["foo", "bar"]); @@ -135,7 +135,7 @@ tape("ordinal.range(values) does not discard implicit domain associations", func }); tape("ordinal(value) recycles values when exhausted", function(test) { - var s = scale.ordinal().range(["a", "b", "c"]); + var s = scale.scaleOrdinal().range(["a", "b", "c"]); test.equal(s(0), "a"); test.equal(s(1), "b"); test.equal(s(2), "c"); @@ -149,7 +149,7 @@ tape("ordinal(value) recycles values when exhausted", function(test) { }); tape("ordinal.unknown(x) sets the output value for unknown inputs", function(test) { - var s = scale.ordinal().domain(["foo", "bar"]).unknown("gray").range(["red", "blue"]); + var s = scale.scaleOrdinal().domain(["foo", "bar"]).unknown("gray").range(["red", "blue"]); test.equal(s("foo"), "red"); test.equal(s("bar"), "blue"); test.equal(s("baz"), "gray"); @@ -158,14 +158,14 @@ tape("ordinal.unknown(x) sets the output value for unknown inputs", function(tes }); tape("ordinal.unknown(x) prevents implicit domain extension if x is not implicit", function(test) { - var s = scale.ordinal().domain(["foo", "bar"]).unknown(undefined).range(["red", "blue"]); + var s = scale.scaleOrdinal().domain(["foo", "bar"]).unknown(undefined).range(["red", "blue"]); test.equal(s("baz"), undefined); test.deepEqual(s.domain(), ["foo", "bar"]); test.end(); }); tape("ordinal.copy() copies all fields", function(test) { - var s1 = scale.ordinal().domain([1, 2]).range(["red", "green"]).unknown("gray"), + var s1 = scale.scaleOrdinal().domain([1, 2]).range(["red", "green"]).unknown("gray"), s2 = s1.copy(); test.deepEqual(s2.domain(), s1.domain()); test.deepEqual(s2.range(), s1.range()); @@ -174,7 +174,7 @@ tape("ordinal.copy() copies all fields", function(test) { }); tape("ordinal.copy() changes to the domain are isolated", function(test) { - var s1 = scale.ordinal().range(["foo", "bar"]), + var s1 = scale.scaleOrdinal().range(["foo", "bar"]), s2 = s1.copy(); s1.domain([1, 2]); test.deepEqual(s2.domain(), []); @@ -189,7 +189,7 @@ tape("ordinal.copy() changes to the domain are isolated", function(test) { }); tape("ordinal.copy() changes to the range are isolated", function(test) { - var s1 = scale.ordinal().range(["foo", "bar"]), + var s1 = scale.scaleOrdinal().range(["foo", "bar"]), s2 = s1.copy(); s1.range(["bar", "foo"]); test.equal(s1(1), "bar"); diff --git a/test/point-test.js b/test/point-test.js index cef04af..b61831d 100644 --- a/test/point-test.js +++ b/test/point-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("point() has the expected defaults", function(test) { - var s = scale.point(); +tape("scalePoint() has the expected defaults", function(test) { + var s = scale.scalePoint(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), [0, 1]); test.equal(s.bandwidth(), 0); @@ -13,16 +13,16 @@ tape("point() has the expected defaults", function(test) { test.end(); }); -tape("point() does not expose paddingInner and paddingOuter", function(test) { - var s = scale.point(); +tape("scalePoint() does not expose paddingInner and paddingOuter", function(test) { + var s = scale.scalePoint(); test.equal(s.paddingInner, undefined); test.equal(s.paddingOuter, undefined); test.end(); }); -tape("point() is similar to band().paddingInner(1)", function(test) { - var p = scale.point().domain(["foo", "bar"]).range([0, 960]), - b = scale.band().domain(["foo", "bar"]).range([0, 960]).paddingInner(1); +tape("scalePoint() is similar to scaleBand().paddingInner(1)", function(test) { + var p = scale.scalePoint().domain(["foo", "bar"]).range([0, 960]), + b = scale.scaleBand().domain(["foo", "bar"]).range([0, 960]).paddingInner(1); test.deepEqual(p.domain().map(p), b.domain().map(b)); test.equal(p.bandwidth(), b.bandwidth()); test.equal(p.step(), b.step()); @@ -30,8 +30,8 @@ tape("point() is similar to band().paddingInner(1)", function(test) { }); tape("point.padding(p) sets the band outer padding to p", function(test) { - var p = scale.point().domain(["foo", "bar"]).range([0, 960]).padding(0.5), - b = scale.band().domain(["foo", "bar"]).range([0, 960]).paddingInner(1).paddingOuter(0.5); + var p = scale.scalePoint().domain(["foo", "bar"]).range([0, 960]).padding(0.5), + b = scale.scaleBand().domain(["foo", "bar"]).range([0, 960]).paddingInner(1).paddingOuter(0.5); test.deepEqual(p.domain().map(p), b.domain().map(b)); test.equal(p.bandwidth(), b.bandwidth()); test.equal(p.step(), b.step()); @@ -39,7 +39,7 @@ tape("point.padding(p) sets the band outer padding to p", function(test) { }); tape("point.copy() returns a copy", function(test) { - var s = scale.point(); + var s = scale.scalePoint(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), [0, 1]); test.equal(s.bandwidth(), 0); diff --git a/test/pow-test.js b/test/pow-test.js index f5c9870..2527fcb 100644 --- a/test/pow-test.js +++ b/test/pow-test.js @@ -4,8 +4,8 @@ var tape = require("tape"), require("./inDelta"); -tape("pow() has the expected defaults", function(test) { - var s = scale.pow(); +tape("scalePow() has the expected defaults", function(test) { + var s = scale.scalePow(); test.deepEqual(s.domain(), [0, 1]); test.deepEqual(s.range(), [0, 1]); test.equal(s.clamp(), false); @@ -15,30 +15,30 @@ tape("pow() has the expected defaults", function(test) { }); tape("pow(x) maps a domain value x to a range value y", function(test) { - test.equal(scale.pow().exponent(.5)(.5), Math.SQRT1_2); + test.equal(scale.scalePow().exponent(.5)(.5), Math.SQRT1_2); test.end(); }); tape("pow(x) ignores extra range values if the domain is smaller than the range", function(test) { - test.equal(scale.pow().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(-5), "#ff8080"); - test.equal(scale.pow().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(50), "#ffffff"); + test.equal(scale.scalePow().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(-5), "#ff8080"); + test.equal(scale.scalePow().domain([-10, 0]).range(["red", "white", "green"]).clamp(true)(50), "#ffffff"); test.end(); }); tape("pow(x) ignores extra domain values if the range is smaller than the domain", function(test) { - test.equal(scale.pow().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(-5), "#ff8080"); - test.equal(scale.pow().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(50), "#ffffff"); + test.equal(scale.scalePow().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(-5), "#ff8080"); + test.equal(scale.scalePow().domain([-10, 0, 100]).range(["red", "white"]).clamp(true)(50), "#ffffff"); test.end(); }); tape("pow(x) maps an empty domain to the range start", function(test) { - test.equal(scale.pow().domain([0, 0]).range([1, 2])(0), 1); - test.equal(scale.pow().domain([0, 0]).range([2, 1])(1), 2); + test.equal(scale.scalePow().domain([0, 0]).range([1, 2])(0), 1); + test.equal(scale.scalePow().domain([0, 0]).range([2, 1])(1), 2); test.end(); }); tape("pow(x) can map a bipow domain with two values to the corresponding range", function(test) { - var s = scale.pow().domain([1, 2]); + var s = scale.scalePow().domain([1, 2]); test.deepEqual(s.domain(), [1, 2]); test.equal(s(0.5), -0.5); test.equal(s(1.0), 0.0); @@ -54,17 +54,17 @@ tape("pow(x) can map a bipow domain with two values to the corresponding range", }); tape("pow(x) can map a polypow domain with more than two values to the corresponding range", function(test) { - var s = scale.pow().domain([-10, 0, 100]).range(["red", "white", "green"]); + var s = scale.scalePow().domain([-10, 0, 100]).range(["red", "white", "green"]); test.deepEqual(s.domain(), [-10, 0, 100]); test.equal(s(-5), "#ff8080"); test.equal(s(50), "#80c080"); test.equal(s(75), "#40a040"); - var s = scale.pow().domain([4, 2, 1]).range([1, 2, 4]); + var s = scale.scalePow().domain([4, 2, 1]).range([1, 2, 4]); test.equal(s(1.5), 3); test.equal(s(3), 1.5); test.equal(s.invert(1.5), 3); test.equal(s.invert(3), 1.5); - var s = scale.pow().domain([1, 2, 4]).range([4, 2, 1]); + var s = scale.scalePow().domain([1, 2, 4]).range([4, 2, 1]); test.equal(s(1.5), 3); test.equal(s(3), 1.5); test.equal(s.invert(1.5), 3); @@ -73,40 +73,40 @@ tape("pow(x) can map a polypow domain with more than two values to the correspon }); tape("pow.invert(y) maps a range value y to a domain value x", function(test) { - test.equal(scale.pow().range([1, 2]).invert(1.5), .5); + test.equal(scale.scalePow().range([1, 2]).invert(1.5), .5); test.end(); }); tape("pow.invert(y) maps an empty range to the domain start", function(test) { - test.equal(scale.pow().domain([1, 2]).range([0, 0]).invert(0), 1); - test.equal(scale.pow().domain([2, 1]).range([0, 0]).invert(1), 2); + test.equal(scale.scalePow().domain([1, 2]).range([0, 0]).invert(0), 1); + test.equal(scale.scalePow().domain([2, 1]).range([0, 0]).invert(1), 2); test.end(); }); tape("pow.invert(y) coerces range values to numbers", function(test) { - test.equal(scale.pow().range(["0", "2"]).invert("1"), .5); - test.equal(scale.pow().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]).invert(new Date(1990, 6, 2, 13)), .5); + test.equal(scale.scalePow().range(["0", "2"]).invert("1"), .5); + test.equal(scale.scalePow().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]).invert(new Date(1990, 6, 2, 13)), .5); test.end(); }); tape("pow.invert(y) returns NaN if the range is not coercible to number", function(test) { - test.ok(isNaN(scale.pow().range(["#000", "#fff"]).invert("#999"))); - test.ok(isNaN(scale.pow().range([0, "#fff"]).invert("#999"))); + test.ok(isNaN(scale.scalePow().range(["#000", "#fff"]).invert("#999"))); + test.ok(isNaN(scale.scalePow().range([0, "#fff"]).invert("#999"))); test.end(); }); tape("pow.exponent(exponent) sets the exponent to the specified value", function(test) { - var x = scale.pow().exponent(.5).domain([1, 2]); + var x = scale.scalePow().exponent(.5).domain([1, 2]); test.inDelta(x(1), 0, 1e-6); test.inDelta(x(1.5), 0.5425821, 1e-6); test.inDelta(x(2), 1, 1e-6); test.equal(x.exponent(), .5); - var x = scale.pow().exponent(2).domain([1, 2]); + var x = scale.scalePow().exponent(2).domain([1, 2]); test.inDelta(x(1), 0, 1e-6); test.inDelta(x(1.5), .41666667, 1e-6); test.inDelta(x(2), 1, 1e-6); test.equal(x.exponent(), 2); - var x = scale.pow().exponent(-1).domain([1, 2]); + var x = scale.scalePow().exponent(-1).domain([1, 2]); test.inDelta(x(1), 0, 1e-6); test.inDelta(x(1.5), .6666667, 1e-6); test.inDelta(x(2), 1, 1e-6); @@ -115,7 +115,7 @@ tape("pow.exponent(exponent) sets the exponent to the specified value", function }); tape("pow.exponent(exponent) changing the exponent does not change the domain or range", function(test) { - var x = scale.pow().domain([1, 2]).range([3, 4]); + var x = scale.scalePow().domain([1, 2]).range([3, 4]); x.exponent(.5); test.deepEqual(x.domain(), [1, 2]); test.deepEqual(x.range(), [3, 4]); @@ -129,21 +129,21 @@ tape("pow.exponent(exponent) changing the exponent does not change the domain or }); tape("pow.domain(domain) accepts an array of numbers", function(test) { - test.deepEqual(scale.pow().domain([]).domain(), []); - test.deepEqual(scale.pow().domain([1, 0]).domain(), [1, 0]); - test.deepEqual(scale.pow().domain([1, 2, 3]).domain(), [1, 2, 3]); + test.deepEqual(scale.scalePow().domain([]).domain(), []); + test.deepEqual(scale.scalePow().domain([1, 0]).domain(), [1, 0]); + test.deepEqual(scale.scalePow().domain([1, 2, 3]).domain(), [1, 2, 3]); test.end(); }); tape("pow.domain(domain) coerces domain values to numbers", function(test) { - test.deepEqual(scale.pow().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]).domain(), [631180800000, 662716800000]); - test.deepEqual(scale.pow().domain(["0.0", "1.0"]).domain(), [0, 1]); - test.deepEqual(scale.pow().domain([new Number(0), new Number(1)]).domain(), [0, 1]); + test.deepEqual(scale.scalePow().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]).domain(), [631180800000, 662716800000]); + test.deepEqual(scale.scalePow().domain(["0.0", "1.0"]).domain(), [0, 1]); + test.deepEqual(scale.scalePow().domain([new Number(0), new Number(1)]).domain(), [0, 1]); test.end(); }); tape("pow.domain(domain) makes a copy of domain values", function(test) { - var d = [1, 2], s = scale.pow().domain(d); + var d = [1, 2], s = scale.scalePow().domain(d); test.deepEqual(s.domain(), [1, 2]); d.push(3); test.deepEqual(s.domain(), [1, 2]); @@ -152,7 +152,7 @@ tape("pow.domain(domain) makes a copy of domain values", function(test) { }); tape("pow.domain() returns a copy of domain values", function(test) { - var s = scale.pow(), d = s.domain(); + var s = scale.scalePow(), d = s.domain(); test.deepEqual(d, [0, 1]); d.push(3); test.deepEqual(s.domain(), [0, 1]); @@ -160,30 +160,30 @@ tape("pow.domain() returns a copy of domain values", function(test) { }); tape("pow.range(range) does not coerce range to numbers", function(test) { - var s = scale.pow().range(["0px", "2px"]); + var s = scale.scalePow().range(["0px", "2px"]); test.deepEqual(s.range(), ["0px", "2px"]); test.equal(s(.5), "1px"); test.end(); }); tape("pow.range(range) can accept range values as colors", function(test) { - test.equal(scale.pow().range(["red", "blue"])(.5), "#800080"); - test.equal(scale.pow().range(["#ff0000", "#0000ff"])(.5), "#800080"); - test.equal(scale.pow().range(["#f00", "#00f"])(.5), "#800080"); - test.equal(scale.pow().range(["rgb(255,0,0)", "hsl(240,100%,50%)"])(.5), "#800080"); - test.equal(scale.pow().range(["rgb(100%,0%,0%)", "hsl(240,100%,50%)"])(.5), "#800080"); - test.equal(scale.pow().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"])(.5), "#800080"); + test.equal(scale.scalePow().range(["red", "blue"])(.5), "#800080"); + test.equal(scale.scalePow().range(["#ff0000", "#0000ff"])(.5), "#800080"); + test.equal(scale.scalePow().range(["#f00", "#00f"])(.5), "#800080"); + test.equal(scale.scalePow().range(["rgb(255,0,0)", "hsl(240,100%,50%)"])(.5), "#800080"); + test.equal(scale.scalePow().range(["rgb(100%,0%,0%)", "hsl(240,100%,50%)"])(.5), "#800080"); + test.equal(scale.scalePow().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"])(.5), "#800080"); test.end(); }); tape("pow.range(range) can accept range values as arrays or objects", function(test) { - test.deepEqual(scale.pow().range([{color: "red"}, {color: "blue"}])(.5), {color: "#800080"}); - test.deepEqual(scale.pow().range([["red"], ["blue"]])(.5), ["#800080"]); + test.deepEqual(scale.scalePow().range([{color: "red"}, {color: "blue"}])(.5), {color: "#800080"}); + test.deepEqual(scale.scalePow().range([["red"], ["blue"]])(.5), ["#800080"]); test.end(); }); tape("pow.range(range) makes a copy of range values", function(test) { - var r = [1, 2], s = scale.pow().range(r); + var r = [1, 2], s = scale.scalePow().range(r); test.deepEqual(s.range(), [1, 2]); r.push(3); test.deepEqual(s.range(), [1, 2]); @@ -192,7 +192,7 @@ tape("pow.range(range) makes a copy of range values", function(test) { }); tape("pow.range() returns a copy of range values", function(test) { - var s = scale.pow(), r = s.range(); + var s = scale.scalePow(), r = s.range(); test.deepEqual(r, [0, 1]); r.push(3); test.deepEqual(s.range(), [0, 1]); @@ -200,95 +200,95 @@ tape("pow.range() returns a copy of range values", function(test) { }); tape("pow.rangeRound(range) is an alias for pow.range(range).interpolate(interpolateRound)", function(test) { - test.equal(scale.pow().rangeRound([0, 10])(.59), 6); + test.equal(scale.scalePow().rangeRound([0, 10])(.59), 6); test.end(); }); tape("pow.clamp() is false by default", function(test) { - test.equal(scale.pow().clamp(), false); - test.equal(scale.pow().range([10, 20])(2), 30); - test.equal(scale.pow().range([10, 20])(-1), 0); - test.equal(scale.pow().range([10, 20]).invert(30), 2); - test.equal(scale.pow().range([10, 20]).invert(0), -1); + test.equal(scale.scalePow().clamp(), false); + test.equal(scale.scalePow().range([10, 20])(2), 30); + test.equal(scale.scalePow().range([10, 20])(-1), 0); + test.equal(scale.scalePow().range([10, 20]).invert(30), 2); + test.equal(scale.scalePow().range([10, 20]).invert(0), -1); test.end(); }); tape("pow.clamp(true) restricts output values to the range", function(test) { - test.equal(scale.pow().clamp(true).range([10, 20])(2), 20); - test.equal(scale.pow().clamp(true).range([10, 20])(-1), 10); + test.equal(scale.scalePow().clamp(true).range([10, 20])(2), 20); + test.equal(scale.scalePow().clamp(true).range([10, 20])(-1), 10); test.end(); }); tape("pow.clamp(true) restricts input values to the domain", function(test) { - test.equal(scale.pow().clamp(true).range([10, 20]).invert(30), 1); - test.equal(scale.pow().clamp(true).range([10, 20]).invert(0), 0); + test.equal(scale.scalePow().clamp(true).range([10, 20]).invert(30), 1); + test.equal(scale.scalePow().clamp(true).range([10, 20]).invert(0), 0); test.end(); }); tape("pow.clamp(clamp) coerces the specified clamp value to a boolean", function(test) { - test.equal(scale.pow().clamp("true").clamp(), true); - test.equal(scale.pow().clamp(1).clamp(), true); - test.equal(scale.pow().clamp("").clamp(), false); - test.equal(scale.pow().clamp(0).clamp(), false); + test.equal(scale.scalePow().clamp("true").clamp(), true); + test.equal(scale.scalePow().clamp(1).clamp(), true); + test.equal(scale.scalePow().clamp("").clamp(), false); + test.equal(scale.scalePow().clamp(0).clamp(), false); test.end(); }); tape("pow.interpolate(interpolate) takes a custom interpolator factory", function(test) { function interpolate(a, b) { return function(t) { return [a, b, t]; }; } - var s = scale.pow().domain([10, 20]).range(["a", "b"]).interpolate(interpolate); + var s = scale.scalePow().domain([10, 20]).range(["a", "b"]).interpolate(interpolate); test.equal(s.interpolate(), interpolate); test.deepEqual(s(15), ["a", "b", .5]); test.end(); }); tape("pow.nice() is an alias for pow.nice(10)", function(test) { - test.deepEqual(scale.pow().domain([0, .96]).nice().domain(), [0, 1]); - test.deepEqual(scale.pow().domain([0, 96]).nice().domain(), [0, 100]); + test.deepEqual(scale.scalePow().domain([0, .96]).nice().domain(), [0, 1]); + test.deepEqual(scale.scalePow().domain([0, 96]).nice().domain(), [0, 100]); test.end(); }); tape("pow.nice(count) extends the domain to match the desired ticks", function(test) { - test.deepEqual(scale.pow().domain([0, .96]).nice(10).domain(), [0, 1]); - test.deepEqual(scale.pow().domain([0, 96]).nice(10).domain(), [0, 100]); - test.deepEqual(scale.pow().domain([.96, 0]).nice(10).domain(), [1, 0]); - test.deepEqual(scale.pow().domain([96, 0]).nice(10).domain(), [100, 0]); - test.deepEqual(scale.pow().domain([0, -.96]).nice(10).domain(), [0, -1]); - test.deepEqual(scale.pow().domain([0, -96]).nice(10).domain(), [0, -100]); - test.deepEqual(scale.pow().domain([-.96, 0]).nice(10).domain(), [-1, 0]); - test.deepEqual(scale.pow().domain([-96, 0]).nice(10).domain(), [-100, 0]); + test.deepEqual(scale.scalePow().domain([0, .96]).nice(10).domain(), [0, 1]); + test.deepEqual(scale.scalePow().domain([0, 96]).nice(10).domain(), [0, 100]); + test.deepEqual(scale.scalePow().domain([.96, 0]).nice(10).domain(), [1, 0]); + test.deepEqual(scale.scalePow().domain([96, 0]).nice(10).domain(), [100, 0]); + test.deepEqual(scale.scalePow().domain([0, -.96]).nice(10).domain(), [0, -1]); + test.deepEqual(scale.scalePow().domain([0, -96]).nice(10).domain(), [0, -100]); + test.deepEqual(scale.scalePow().domain([-.96, 0]).nice(10).domain(), [-1, 0]); + test.deepEqual(scale.scalePow().domain([-96, 0]).nice(10).domain(), [-100, 0]); test.end(); }); tape("pow.nice(count) nices the domain, extending it to round numbers", function(test) { - test.deepEqual(scale.pow().domain([1.1, 10.9]).nice(10).domain(), [1, 11]); - test.deepEqual(scale.pow().domain([10.9, 1.1]).nice(10).domain(), [11, 1]); - test.deepEqual(scale.pow().domain([.7, 11.001]).nice(10).domain(), [0, 12]); - test.deepEqual(scale.pow().domain([123.1, 6.7]).nice(10).domain(), [130, 0]); - test.deepEqual(scale.pow().domain([0, .49]).nice(10).domain(), [0, .5]); + test.deepEqual(scale.scalePow().domain([1.1, 10.9]).nice(10).domain(), [1, 11]); + test.deepEqual(scale.scalePow().domain([10.9, 1.1]).nice(10).domain(), [11, 1]); + test.deepEqual(scale.scalePow().domain([.7, 11.001]).nice(10).domain(), [0, 12]); + test.deepEqual(scale.scalePow().domain([123.1, 6.7]).nice(10).domain(), [130, 0]); + test.deepEqual(scale.scalePow().domain([0, .49]).nice(10).domain(), [0, .5]); test.end(); }); tape("pow.nice(count) has no effect on degenerate domains", function(test) { - test.deepEqual(scale.pow().domain([0, 0]).nice(10).domain(), [0, 0]); - test.deepEqual(scale.pow().domain([.5, .5]).nice(10).domain(), [.5, .5]); + test.deepEqual(scale.scalePow().domain([0, 0]).nice(10).domain(), [0, 0]); + test.deepEqual(scale.scalePow().domain([.5, .5]).nice(10).domain(), [.5, .5]); test.end(); }); tape("pow.nice(count) nicing a polypow domain only affects the extent", function(test) { - test.deepEqual(scale.pow().domain([1.1, 1, 2, 3, 10.9]).nice(10).domain(), [1, 1, 2, 3, 11]); - test.deepEqual(scale.pow().domain([123.1, 1, 2, 3, -.9]).nice(10).domain(), [130, 1, 2, 3, -10]); + test.deepEqual(scale.scalePow().domain([1.1, 1, 2, 3, 10.9]).nice(10).domain(), [1, 1, 2, 3, 11]); + test.deepEqual(scale.scalePow().domain([123.1, 1, 2, 3, -.9]).nice(10).domain(), [130, 1, 2, 3, -10]); test.end(); }); tape("pow.nice(count) accepts a tick count to control nicing step", function(test) { - test.deepEqual(scale.pow().domain([12, 87]).nice(5).domain(), [0, 100]); - test.deepEqual(scale.pow().domain([12, 87]).nice(10).domain(), [10, 90]); - test.deepEqual(scale.pow().domain([12, 87]).nice(100).domain(), [12, 87]); + test.deepEqual(scale.scalePow().domain([12, 87]).nice(5).domain(), [0, 100]); + test.deepEqual(scale.scalePow().domain([12, 87]).nice(10).domain(), [10, 90]); + test.deepEqual(scale.scalePow().domain([12, 87]).nice(100).domain(), [12, 87]); test.end(); }); tape("pow.ticks(count) returns the expected ticks for an ascending domain", function(test) { - var s = scale.pow(); + var s = scale.scalePow(); test.deepEqual(s.ticks(10).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(9).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(8).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); @@ -314,7 +314,7 @@ tape("pow.ticks(count) returns the expected ticks for an ascending domain", func }); tape("pow.ticks(count) returns the expected ticks for a descending domain", function(test) { - var s = scale.pow().domain([1, 0]); + var s = scale.scalePow().domain([1, 0]); test.deepEqual(s.ticks(10).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0].reverse()); test.deepEqual(s.ticks(9).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0].reverse()); test.deepEqual(s.ticks(8).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0].reverse()); @@ -340,7 +340,7 @@ tape("pow.ticks(count) returns the expected ticks for a descending domain", func }); tape("pow.ticks(count) returns the expected ticks for a polypow domain", function(test) { - var s = scale.pow().domain([0, 0.25, 0.9, 1]); + var s = scale.scalePow().domain([0, 0.25, 0.9, 1]); test.deepEqual(s.ticks(10).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(9).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); test.deepEqual(s.ticks(8).map(roundEpsilon), [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]); @@ -366,7 +366,7 @@ tape("pow.ticks(count) returns the expected ticks for a polypow domain", functio }); tape("pow.ticks(count) returns the empty array if count is not a positive integer", function(test) { - var s = scale.pow(); + var s = scale.scalePow(); test.deepEqual(s.ticks(NaN), []); test.deepEqual(s.ticks(0), []); test.deepEqual(s.ticks(-1), []); @@ -375,58 +375,58 @@ tape("pow.ticks(count) returns the empty array if count is not a positive intege }); tape("pow.ticks() is an alias for pow.ticks(10)", function(test) { - var s = scale.pow(); + var s = scale.scalePow(); test.deepEqual(s.ticks(), s.ticks(10)); test.end(); }); tape("pow.tickFormat() is an alias for pow.tickFormat(10)", function(test) { - test.equal(scale.pow().tickFormat()(0.2), "0.2"); - test.equal(scale.pow().domain([-100, 100]).tickFormat()(-20), "-20"); + test.equal(scale.scalePow().tickFormat()(0.2), "0.2"); + test.equal(scale.scalePow().domain([-100, 100]).tickFormat()(-20), "-20"); test.end(); }); tape("pow.tickFormat(count) returns a format suitable for the ticks", function(test) { - test.equal(scale.pow().tickFormat(10)(0.2), "0.2"); - test.equal(scale.pow().tickFormat(20)(0.2), "0.20"); - test.equal(scale.pow().domain([-100, 100]).tickFormat(10)(-20), "-20"); + test.equal(scale.scalePow().tickFormat(10)(0.2), "0.2"); + test.equal(scale.scalePow().tickFormat(20)(0.2), "0.20"); + test.equal(scale.scalePow().domain([-100, 100]).tickFormat(10)(-20), "-20"); test.end(); }); tape("pow.tickFormat(count, specifier) sets the appropriate fixed precision if not specified", function(test) { - test.equal(scale.pow().tickFormat(10, "+f")(0.2), "+0.2"); - test.equal(scale.pow().tickFormat(20, "+f")(0.2), "+0.20"); - test.equal(scale.pow().tickFormat(10, "+%")(0.2), "+20%"); - test.equal(scale.pow().domain([0.19, 0.21]).tickFormat(10, "+%")(0.2), "+20.0%"); + test.equal(scale.scalePow().tickFormat(10, "+f")(0.2), "+0.2"); + test.equal(scale.scalePow().tickFormat(20, "+f")(0.2), "+0.20"); + test.equal(scale.scalePow().tickFormat(10, "+%")(0.2), "+20%"); + test.equal(scale.scalePow().domain([0.19, 0.21]).tickFormat(10, "+%")(0.2), "+20.0%"); test.end(); }); tape("pow.tickFormat(count, specifier) sets the appropriate round precision if not specified", function(test) { - test.equal(scale.pow().domain([0, 9]).tickFormat(10, "")(2.10), "2"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "")(2.01), "2"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "")(2.11), "2.1"); - test.equal(scale.pow().domain([0, 9]).tickFormat(10, "e")(2.10), "2e+0"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "e")(2.01), "2.0e+0"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "e")(2.11), "2.1e+0"); - test.equal(scale.pow().domain([0, 9]).tickFormat(10, "g")(2.10), "2"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "g")(2.01), "2.0"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "g")(2.11), "2.1"); - test.equal(scale.pow().domain([0, 9]).tickFormat(10, "r")(2.10e6), "2000000"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "r")(2.01e6), "2000000"); - test.equal(scale.pow().domain([0, 9]).tickFormat(100, "r")(2.11e6), "2100000"); - test.equal(scale.pow().domain([0, .9]).tickFormat(10, "p")(.210), "20%"); - test.equal(scale.pow().domain([.19, .21]).tickFormat(10, "p")(.201), "20.1%"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(10, "")(2.10), "2"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "")(2.01), "2"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "")(2.11), "2.1"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(10, "e")(2.10), "2e+0"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "e")(2.01), "2.0e+0"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "e")(2.11), "2.1e+0"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(10, "g")(2.10), "2"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "g")(2.01), "2.0"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "g")(2.11), "2.1"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(10, "r")(2.10e6), "2000000"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "r")(2.01e6), "2000000"); + test.equal(scale.scalePow().domain([0, 9]).tickFormat(100, "r")(2.11e6), "2100000"); + test.equal(scale.scalePow().domain([0, .9]).tickFormat(10, "p")(.210), "20%"); + test.equal(scale.scalePow().domain([.19, .21]).tickFormat(10, "p")(.201), "20.1%"); test.end(); }); tape("pow.tickFormat(count, specifier) sets the appropriate prefix precision if not specified", function(test) { - test.equal(scale.pow().domain([0, 1e6]).tickFormat(10, "$s")(0.51e6), "$0.5M"); - test.equal(scale.pow().domain([0, 1e6]).tickFormat(100, "$s")(0.501e6), "$0.50M"); + test.equal(scale.scalePow().domain([0, 1e6]).tickFormat(10, "$s")(0.51e6), "$0.5M"); + test.equal(scale.scalePow().domain([0, 1e6]).tickFormat(100, "$s")(0.501e6), "$0.50M"); test.end(); }); tape("pow.copy() returns a copy with changes to the domain are isolated", function(test) { - var x = scale.pow(), y = x.copy(); + var x = scale.scalePow(), y = x.copy(); x.domain([1, 2]); test.deepEqual(y.domain(), [0, 1]); test.equal(x(1), 0); @@ -444,7 +444,7 @@ tape("pow.copy() returns a copy with changes to the domain are isolated", functi }); tape("pow.copy() returns a copy with changes to the range are isolated", function(test) { - var x = scale.pow(), y = x.copy(); + var x = scale.scalePow(), y = x.copy(); x.range([1, 2]); test.equal(x.invert(1), 0); test.equal(y.invert(1), 1); @@ -458,7 +458,7 @@ tape("pow.copy() returns a copy with changes to the range are isolated", functio }); tape("pow.copy() returns a copy with changes to the interpolator are isolated", function(test) { - var x = scale.pow().range(["red", "blue"]), + var x = scale.scalePow().range(["red", "blue"]), y = x.copy(), i0 = x.interpolate(), i1 = function(a, b) { return function(t) { return b; }; }; @@ -470,7 +470,7 @@ tape("pow.copy() returns a copy with changes to the interpolator are isolated", }); tape("pow.copy() returns a copy with changes to clamping are isolated", function(test) { - var x = scale.pow().clamp(true), y = x.copy(); + var x = scale.scalePow().clamp(true), y = x.copy(); x.clamp(false); test.equal(x(2), 2); test.equal(y(2), 1); @@ -483,14 +483,14 @@ tape("pow.copy() returns a copy with changes to clamping are isolated", function }); tape("pow().clamp(true).invert(x) cannot return a value outside the domain", function(test) { - var x = scale.pow().exponent(0.5).domain([1, 20]).clamp(true); + var x = scale.scalePow().exponent(0.5).domain([1, 20]).clamp(true); test.equal(x.invert(0), 1); test.equal(x.invert(1), 20); test.end(); }); -tape("sqrt() is an alias for pow().exponent(0.5)", function(test) { - var s = scale.sqrt(); +tape("scaleSqrt() is an alias for pow().exponent(0.5)", function(test) { + var s = scale.scaleSqrt(); test.equal(s.exponent(), 0.5); test.inDelta(s(0.5), Math.SQRT1_2, 1e-6); test.inDelta(s.invert(Math.SQRT1_2), 0.5, 1e-6); diff --git a/test/quantile-test.js b/test/quantile-test.js index 5398c33..4895641 100644 --- a/test/quantile-test.js +++ b/test/quantile-test.js @@ -1,20 +1,20 @@ var tape = require("tape"), scale = require("../"); -tape("quantile() has the expected default", function(test) { - var s = scale.quantile(); +tape("scaleQuantile() has the expected default", function(test) { + var s = scale.scaleQuantile(); test.deepEqual(s.domain(), []); test.deepEqual(s.range(), []); test.end(); }); tape("quantile(x) uses the R-7 algorithm to compute quantiles", function(test) { - var s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); test.deepEqual([3, 6, 6.9, 7, 7.1].map(s), [0, 0, 0, 0, 0]); test.deepEqual([8, 8.9].map(s), [1, 1]); test.deepEqual([9, 9.1, 10, 13].map(s), [2, 2, 2, 2]); test.deepEqual([14.9, 15, 15.1, 16, 20].map(s), [3, 3, 3, 3, 3]); - var s = scale.quantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); test.deepEqual([3, 6, 6.9, 7, 7.1].map(s), [0, 0, 0, 0, 0]); test.deepEqual([8, 8.9].map(s), [1, 1]); test.deepEqual([9, 9.1, 10, 13].map(s), [2, 2, 2, 2]); @@ -23,45 +23,45 @@ tape("quantile(x) uses the R-7 algorithm to compute quantiles", function(test) { }); tape("quantile(x) returns undefined if the input value is NaN", function(test) { - var s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); test.equal(s(NaN), undefined); test.end(); }); tape("quantile.domain() values are sorted in ascending order", function(test) { - var s = scale.quantile().domain([6, 3, 7, 8, 8, 13, 20, 15, 16, 10]); + var s = scale.scaleQuantile().domain([6, 3, 7, 8, 8, 13, 20, 15, 16, 10]); test.deepEqual(s.domain(), [3, 6, 7, 8, 8, 10, 13, 15, 16, 20]); test.end(); }); tape("quantile.domain() values are coerced to numbers", function(test) { - var s = scale.quantile().domain(["6", "13", "20"]); + var s = scale.scaleQuantile().domain(["6", "13", "20"]); test.deepEqual(s.domain(), [6, 13, 20]); test.end(); }); tape("quantile.domain() values are allowed to be zero", function(test) { - var s = scale.quantile().domain([1, 2, 0, 0, null]); + var s = scale.scaleQuantile().domain([1, 2, 0, 0, null]); test.deepEqual(s.domain(), [0, 0, 1, 2]); test.end(); }); tape("quantile.domain() non-numeric values are ignored", function(test) { - var s = scale.quantile().domain([6, 3, NaN, undefined, 7, 8, 8, 13, null, 20, 15, 16, 10, NaN]); + var s = scale.scaleQuantile().domain([6, 3, NaN, undefined, 7, 8, 8, 13, null, 20, 15, 16, 10, NaN]); test.deepEqual(s.domain(), [3, 6, 7, 8, 8, 10, 13, 15, 16, 20]); test.end(); }); tape("quantile.quantiles() returns the inner thresholds", function(test) { - var s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); test.deepEqual(s.quantiles(), [7.25, 9, 14.5]); - var s = scale.quantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); test.deepEqual(s.quantiles(), [7.5, 9, 14]); test.end(); }); tape("quantile.range() cardinality determines the number of quantiles", function(test) { - var s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]); test.deepEqual(s.range([0, 1, 2, 3]).quantiles(), [7.25, 9, 14.5]); test.deepEqual(s.range([0, 1]).quantiles(), [9]); test.deepEqual(s.range([,,,,,]).quantiles(), [6.8, 8, 11.2, 15.2]); @@ -73,7 +73,7 @@ tape("quantile.range() values are arbitrary", function(test) { var a = {}, b = {}, c = {}, - s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([a, b, c, a]); + s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([a, b, c, a]); test.deepEqual([3, 6, 6.9, 7, 7.1].map(s), [a, a, a, a, a]); test.deepEqual([8, 8.9].map(s), [b, b]); test.deepEqual([9, 9.1, 10, 13].map(s), [c, c, c, c]); @@ -82,7 +82,7 @@ tape("quantile.range() values are arbitrary", function(test) { }); tape("quantile.invertExtent() maps a value in the range to a domain extent", function(test) { - var s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]); test.deepEqual(s.invertExtent(0), [3, 7.25]); test.deepEqual(s.invertExtent(1), [7.25, 9]); test.deepEqual(s.invertExtent(2), [9, 14.5]); @@ -93,14 +93,14 @@ tape("quantile.invertExtent() maps a value in the range to a domain extent", fun tape("quantile.invertExtent() allows arbitrary range values", function(test) { var a = {}, b = {}, - s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([a, b]); + s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([a, b]); test.deepEqual(s.invertExtent(a), [3, 9]); test.deepEqual(s.invertExtent(b), [9, 20]); test.end(); }); tape("quantile.invertExtent() returns [NaN, NaN] when the given value is not in the range", function(test) { - var s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]); test.ok(s.invertExtent(-1).every(isNaN)); test.ok(s.invertExtent(.5).every(isNaN)); test.ok(s.invertExtent(2).every(isNaN)); @@ -109,7 +109,7 @@ tape("quantile.invertExtent() returns [NaN, NaN] when the given value is not in }); tape("quantile.invertExtent() returns the first match if duplicate values exist in the range", function(test) { - var s = scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 0]); + var s = scale.scaleQuantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 0]); test.deepEqual(s.invertExtent(0), [3, 7.25]); test.deepEqual(s.invertExtent(1), [7.25, 9]); test.deepEqual(s.invertExtent(2), [9, 14.5]); diff --git a/test/quantize-test.js b/test/quantize-test.js index 1f0a46f..68fa368 100644 --- a/test/quantize-test.js +++ b/test/quantize-test.js @@ -4,8 +4,8 @@ var tape = require("tape"), require("./inDelta"); -tape("quantize() has the expected defaults", function(test) { - var s = scale.quantize(); +tape("scaleQuantize() has the expected defaults", function(test) { + var s = scale.scaleQuantize(); test.deepEqual(s.domain(), [0, 1]); test.deepEqual(s.range(), [0, 1]); test.equal(s(0.25), 0); @@ -14,7 +14,7 @@ tape("quantize() has the expected defaults", function(test) { }); tape("quantize(value) maps a number to a discrete value in the range", function(test) { - var s = scale.quantize().range([0, 1, 2]); + var s = scale.scaleQuantize().range([0, 1, 2]); test.equal(s(0.0), 0); test.equal(s(0.2), 0); test.equal(s(0.4), 1); @@ -28,14 +28,14 @@ tape("quantize(value) clamps input values to the domain", function(test) { var a = {}, b = {}, c = {}, - s = scale.quantize().range([a, b, c]); + s = scale.scaleQuantize().range([a, b, c]); test.equal(s(-0.5), a); test.equal(s(+1.5), c); test.end(); }); tape("quantize.domain() coerces domain values to numbers", function(test) { - var s = scale.quantize().domain(["-1.20", "2.40"]); + var s = scale.scaleQuantize().domain(["-1.20", "2.40"]); test.deepEqual(s.domain(), [-1.2, 2.4]); test.equal(s(-1.2), 0); test.equal(s( 0.5), 0); @@ -45,13 +45,13 @@ tape("quantize.domain() coerces domain values to numbers", function(test) { }); tape("quantize.domain() only considers the first and second element of the domain", function(test) { - var s = scale.quantize().domain([-1, 100, 200]); + var s = scale.scaleQuantize().domain([-1, 100, 200]); test.deepEqual(s.domain(), [-1, 100]); test.end(); }); tape("quantize.range() cardinality determines the degree of quantization", function(test) { - var s = scale.quantize(); + var s = scale.scaleQuantize(); test.inDelta(s.range(array.range(0, 1.001, 0.001))(1/3), 0.333, 1e-6); test.inDelta(s.range(array.range(0, 1.010, 0.010))(1/3), 0.330, 1e-6); test.inDelta(s.range(array.range(0, 1.100, 0.100))(1/3), 0.300, 1e-6); @@ -66,7 +66,7 @@ tape("quantize.range() values are arbitrary", function(test) { var a = {}, b = {}, c = {}, - s = scale.quantize().range([a, b, c]); + s = scale.scaleQuantize().range([a, b, c]); test.equal(s(0.0), a); test.equal(s(0.2), a); test.equal(s(0.4), b); @@ -77,7 +77,7 @@ tape("quantize.range() values are arbitrary", function(test) { }); tape("quantize.invertExtent() maps a value in the range to a domain extent", function(test) { - var s = scale.quantize().range([0, 1, 2, 3]); + var s = scale.scaleQuantize().range([0, 1, 2, 3]); test.deepEqual(s.invertExtent(0), [0.00, 0.25]); test.deepEqual(s.invertExtent(1), [0.25, 0.50]); test.deepEqual(s.invertExtent(2), [0.50, 0.75]); @@ -88,14 +88,14 @@ tape("quantize.invertExtent() maps a value in the range to a domain extent", fun tape("quantize.invertExtent() allows arbitrary range values", function(test) { var a = {}, b = {}, - s = scale.quantize().range([a, b]); + s = scale.scaleQuantize().range([a, b]); test.deepEqual(s.invertExtent(a), [0.0, 0.5]); test.deepEqual(s.invertExtent(b), [0.5, 1.0]); test.end(); }); tape("quantize.invertExtent() returns [NaN, NaN] when the given value is not in the range", function(test) { - var s = scale.quantize(); + var s = scale.scaleQuantize(); test.ok(s.invertExtent(-1).every(Number.isNaN)); test.ok(s.invertExtent(0.5).every(Number.isNaN)); test.ok(s.invertExtent(2).every(Number.isNaN)); @@ -104,14 +104,14 @@ tape("quantize.invertExtent() returns [NaN, NaN] when the given value is not in }); tape("quantize.invertExtent() returns the first match if duplicate values exist in the range", function(test) { - var s = scale.quantize().range([0, 1, 2, 0]); + var s = scale.scaleQuantize().range([0, 1, 2, 0]); test.deepEqual(s.invertExtent(0), [0.00, 0.25]); test.deepEqual(s.invertExtent(1), [0.25, 0.50]); test.end(); }); tape("quantize.invertExtent(y) is exactly consistent with quantize(x)", function(test) { - var s = scale.quantize().domain([4.2, 6.2]).range(array.range(10)); + var s = scale.scaleQuantize().domain([4.2, 6.2]).range(array.range(10)); s.range().forEach(function(y) { var e = s.invertExtent(y); test.equal(s(e[0]), y); diff --git a/test/rainbow-test.js b/test/rainbow-test.js index 5de98c0..5a7f8c9 100644 --- a/test/rainbow-test.js +++ b/test/rainbow-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("rainbow() has the expected defaults", function(test) { - var s = scale.rainbow(); +tape("scaleRainbow() has the expected defaults", function(test) { + var s = scale.scaleRainbow(); test.deepEqual(s.domain(), [0, 1]); test.equal(s.clamp(), false); test.equal(s(0.0), "#6e40aa"); @@ -12,7 +12,7 @@ tape("rainbow() has the expected defaults", function(test) { }); tape("rainbow(value) cycles by default", function(test) { - var s = scale.rainbow(); + var s = scale.scaleRainbow(); for (var i = -2; i < 3; ++i) { test.equal(s(i + 0.0), "#6e40aa"); test.equal(s(i + 0.5), "#aff05b"); @@ -22,7 +22,7 @@ tape("rainbow(value) cycles by default", function(test) { }); tape("rainbow.clamp(true) enables clamping", function(test) { - var s = scale.rainbow().clamp(true); + var s = scale.scaleRainbow().clamp(true); test.equal(s.clamp(), true); test.equal(s(-0.5), "#6e40aa"); test.equal(s( 0.0), "#6e40aa"); @@ -33,7 +33,7 @@ tape("rainbow.clamp(true) enables clamping", function(test) { }); tape("rainbow.domain() coerces domain values to numbers", function(test) { - var s = scale.rainbow().domain(["-1.20", "2.40"]); + var s = scale.scaleRainbow().domain(["-1.20", "2.40"]); test.deepEqual(s.domain(), [-1.2, 2.4]); test.equal(s(-1.2), "#6e40aa"); test.equal(s( 0.6), "#aff05b"); @@ -42,13 +42,13 @@ tape("rainbow.domain() coerces domain values to numbers", function(test) { }); tape("rainbow.domain() only considers the first and second element of the domain", function(test) { - var s = scale.rainbow().domain([-1, 100, 200]); + var s = scale.scaleRainbow().domain([-1, 100, 200]); test.deepEqual(s.domain(), [-1, 100]); test.end(); }); tape("rainbow.copy() returns an isolated copy of the scale", function(test) { - var s1 = scale.rainbow().domain([1, 3]).clamp(true), + var s1 = scale.scaleRainbow().domain([1, 3]).clamp(true), s2 = s1.copy(); test.deepEqual(s2.domain(), [1, 3]); test.equal(s2.clamp(), true); diff --git a/test/threshold-test.js b/test/threshold-test.js index c195af9..c1bfe53 100644 --- a/test/threshold-test.js +++ b/test/threshold-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("threshold() has the expected defaults", function(test) { - var x = scale.threshold(); +tape("scaleThreshold() has the expected defaults", function(test) { + var x = scale.scaleThreshold(); test.deepEqual(x.domain(), [0.5]); test.deepEqual(x.range(), [0, 1]); test.equal(x(0.50), 1); @@ -11,7 +11,7 @@ tape("threshold() has the expected defaults", function(test) { }); tape("threshold(x) maps a number to a discrete value in the range", function(test) { - var x = scale.threshold().domain([1/3, 2/3]).range(["a", "b", "c"]); + var x = scale.scaleThreshold().domain([1/3, 2/3]).range(["a", "b", "c"]); test.equal(x(0), "a"); test.equal(x(0.2), "a"); test.equal(x(0.4), "b"); @@ -22,7 +22,7 @@ tape("threshold(x) maps a number to a discrete value in the range", function(tes }); tape("threshold(x) returns undefined if the specified value x is not orderable", function(test) { - var x = scale.threshold().domain([1/3, 2/3]).range(["a", "b", "c"]); + var x = scale.scaleThreshold().domain([1/3, 2/3]).range(["a", "b", "c"]); test.equal(x(), undefined); test.equal(x(undefined), undefined); test.equal(x(NaN), undefined); @@ -31,7 +31,7 @@ tape("threshold(x) returns undefined if the specified value x is not orderable", }); tape("threshold.domain(…) supports arbitrary orderable values", function(test) { - var x = scale.threshold().domain(["10", "2"]).range([0, 1, 2]); + var x = scale.scaleThreshold().domain(["10", "2"]).range([0, 1, 2]); test.strictEqual(x.domain()[0], "10"); test.strictEqual(x.domain()[1], "2"); test.equal(x("0"), 0); @@ -41,7 +41,7 @@ tape("threshold.domain(…) supports arbitrary orderable values", function(test) }); tape("threshold.range(…) supports arbitrary values", function(test) { - var a = {}, b = {}, c = {}, x = scale.threshold().domain([1/3, 2/3]).range([a, b, c]); + var a = {}, b = {}, c = {}, x = scale.scaleThreshold().domain([1/3, 2/3]).range([a, b, c]); test.equal(x(0), a); test.equal(x(0.2), a); test.equal(x(0.4), b); @@ -52,7 +52,7 @@ tape("threshold.range(…) supports arbitrary values", function(test) { }); tape("threshold.invertExtent(y) returns the domain extent for the specified range value", function(test) { - var a = {}, b = {}, c = {}, x = scale.threshold().domain([1/3, 2/3]).range([a, b, c]); + var a = {}, b = {}, c = {}, x = scale.scaleThreshold().domain([1/3, 2/3]).range([a, b, c]); test.deepEqual(x.invertExtent(a), [undefined, 1/3]); test.deepEqual(x.invertExtent(b), [1/3, 2/3]); test.deepEqual(x.invertExtent(c), [2/3, undefined]); diff --git a/test/time-test.js b/test/time-test.js index c91b872..7040ba2 100644 --- a/test/time-test.js +++ b/test/time-test.js @@ -5,38 +5,38 @@ var tape = require("tape"), date = require("./date"); tape("time.nice() is an alias for time.nice(10)", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1, 0, 17), date.local(2009, 0, 1, 23, 42)]); + var x = scale.scaleTime().domain([date.local(2009, 0, 1, 0, 17), date.local(2009, 0, 1, 23, 42)]); test.deepEqual(x.nice().domain(), [date.local(2009, 0, 1), date.local(2009, 0, 2)]); test.end(); }); tape("time.nice() can nice sub-second domains", function(test) { - var x = scale.time().domain([date.local(2013, 0, 1, 12, 0, 0, 0), date.local(2013, 0, 1, 12, 0, 0, 128)]); + var x = scale.scaleTime().domain([date.local(2013, 0, 1, 12, 0, 0, 0), date.local(2013, 0, 1, 12, 0, 0, 128)]); test.deepEqual(x.nice().domain(), [date.local(2013, 0, 1, 12, 0, 0, 0), date.local(2013, 0, 1, 12, 0, 0, 130)]); test.end(); }); tape("time.nice() can nice multi-year domains", function(test) { - var x = scale.time().domain([date.local(2001, 0, 1), date.local(2138, 0, 1)]); + var x = scale.scaleTime().domain([date.local(2001, 0, 1), date.local(2138, 0, 1)]); test.deepEqual(x.nice().domain(), [date.local(2000, 0, 1), date.local(2140, 0, 1)]); test.end(); }); tape("time.nice() can nice empty domains", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 0, 12)]); + var x = scale.scaleTime().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 0, 12)]); test.deepEqual(x.nice().domain(), [date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 0, 12)]); test.end(); }); tape("time.nice(count) nices using the specified tick count", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1, 0, 17), date.local(2009, 0, 1, 23, 42)]); + var x = scale.scaleTime().domain([date.local(2009, 0, 1, 0, 17), date.local(2009, 0, 1, 23, 42)]); test.deepEqual(x.nice(100).domain(), [date.local(2009, 0, 1, 0, 15), date.local(2009, 0, 1, 23, 45)]); test.deepEqual(x.nice(10).domain(), [date.local(2009, 0, 1), date.local(2009, 0, 2)]); test.end(); }); tape("time.nice(interval) nices using the specified time interval", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 23, 48)]); + var x = scale.scaleTime().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 23, 48)]); test.deepEqual(x.nice(time.timeDay).domain(), [date.local(2009, 0, 1), date.local(2009, 0, 2)]); test.deepEqual(x.nice(time.timeWeek).domain(), [date.local(2008, 11, 28), date.local(2009, 0, 4)]); test.deepEqual(x.nice(time.timeMonth).domain(), [date.local(2008, 11, 1), date.local(2009, 1, 1)]); @@ -45,19 +45,19 @@ tape("time.nice(interval) nices using the specified time interval", function(tes }); tape("time.nice(interval) can nice empty domains", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 0, 12)]); + var x = scale.scaleTime().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 0, 12)]); test.deepEqual(x.nice(time.timeDay).domain(), [date.local(2009, 0, 1), date.local(2009, 0, 2)]); test.end(); }); tape("time.nice(interval) can nice a polylinear domain, only affecting its extent", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 23, 48), date.local(2009, 0, 2, 23, 48)]).nice(time.timeDay); + var x = scale.scaleTime().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 23, 48), date.local(2009, 0, 2, 23, 48)]).nice(time.timeDay); test.deepEqual(x.domain(), [date.local(2009, 0, 1), date.local(2009, 0, 1, 23, 48), date.local(2009, 0, 3)]); test.end(); }); tape("time.nice(interval, step) nices using the specified time interval and step", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 23, 48)]); + var x = scale.scaleTime().domain([date.local(2009, 0, 1, 0, 12), date.local(2009, 0, 1, 23, 48)]); test.deepEqual(x.nice(time.timeDay, 3).domain(), [date.local(2009, 0, 1), date.local(2009, 0, 4)]); test.deepEqual(x.nice(time.timeWeek, 2).domain(), [date.local(2008, 11, 21), date.local(2009, 0, 4)]); test.deepEqual(x.nice(time.timeMonth, 3).domain(), [date.local(2008, 9, 1), date.local(2009, 3, 1)]); @@ -66,7 +66,7 @@ tape("time.nice(interval, step) nices using the specified time interval and step }); tape("time.copy() isolates changes to the domain", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]), y = x.copy(); + var x = scale.scaleTime().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]), y = x.copy(); x.domain([date.local(2010, 0, 1), date.local(2011, 0, 1)]); test.deepEqual(y.domain(), [date.local(2009, 0, 1), date.local(2010, 0, 1)]); test.equal(x(date.local(2010, 0, 1)), 0); @@ -80,7 +80,7 @@ tape("time.copy() isolates changes to the domain", function(test) { }); tape("time.copy() isolates changes to the range", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]), y = x.copy(); + var x = scale.scaleTime().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]), y = x.copy(); x.range([1, 2]); test.deepEqual(x.invert(1), date.local(2009, 0, 1)); test.deepEqual(y.invert(1), date.local(2010, 0, 1)); @@ -94,7 +94,7 @@ tape("time.copy() isolates changes to the range", function(test) { }); tape("time.copy() isolates changes to the interpolator", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]).range(["red", "blue"]), + var x = scale.scaleTime().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]).range(["red", "blue"]), i = x.interpolate(), y = x.copy(); x.interpolate(interpolate.interpolateHsl); @@ -105,7 +105,7 @@ tape("time.copy() isolates changes to the interpolator", function(test) { }); tape("time.copy() isolates changes to clamping", function(test) { - var x = scale.time().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]).clamp(true), y = x.copy(); + var x = scale.scaleTime().domain([date.local(2009, 0, 1), date.local(2010, 0, 1)]).clamp(true), y = x.copy(); x.clamp(false); test.equal(x(date.local(2011, 0, 1)), 2); test.equal(y(date.local(2011, 0, 1)), 1); @@ -118,7 +118,7 @@ tape("time.copy() isolates changes to clamping", function(test) { }); tape("time.clamp(true).invert(value) never returns a value outside the domain", function(test) { - var x = scale.time().clamp(true); + var x = scale.scaleTime().clamp(true); test.ok(x.invert(0) instanceof Date); test.ok(x.invert(0) !== x.invert(0)); // returns a distinct copy test.equal(+x.invert(-1), +x.domain()[0]); @@ -129,7 +129,7 @@ tape("time.clamp(true).invert(value) never returns a value outside the domain", }); tape("time.ticks(interval) observes the specified tick interval", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 1, 0), date.local(2011, 0, 1, 12, 4, 4)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 1, 0), date.local(2011, 0, 1, 12, 4, 4)]); test.deepEqual(x.ticks(time.timeMinute), [ date.local(2011, 0, 1, 12, 1), date.local(2011, 0, 1, 12, 2), @@ -140,7 +140,7 @@ tape("time.ticks(interval) observes the specified tick interval", function(test) }); tape("time.ticks(interval, step) observes the specified tick interval and step", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 33, 4)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 33, 4)]); test.deepEqual(x.ticks(time.timeMinute, 10), [ date.local(2011, 0, 1, 12, 0), date.local(2011, 0, 1, 12, 10), @@ -151,7 +151,7 @@ tape("time.ticks(interval, step) observes the specified tick interval and step", }); tape("time.ticks(count) can generate sub-second ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 1)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 1)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 0, 0, 0), date.local(2011, 0, 1, 12, 0, 0, 200), @@ -164,7 +164,7 @@ tape("time.ticks(count) can generate sub-second ticks", function(test) { }); tape("time.ticks(count) can generate 1-second ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 4)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 4)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 1), @@ -176,7 +176,7 @@ tape("time.ticks(count) can generate 1-second ticks", function(test) { }); tape("time.ticks(count) can generate 5-second ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 20)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 20)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 5), @@ -188,7 +188,7 @@ tape("time.ticks(count) can generate 5-second ticks", function(test) { }); tape("time.ticks(count) can generate 15-second ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 50)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 50)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 15), @@ -199,7 +199,7 @@ tape("time.ticks(count) can generate 15-second ticks", function(test) { }); tape("time.ticks(count) can generate 30-second ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 1, 50)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 1, 50)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 0, 0), date.local(2011, 0, 1, 12, 0, 30), @@ -210,7 +210,7 @@ tape("time.ticks(count) can generate 30-second ticks", function(test) { }); tape("time.ticks(count) can generate 1-minute ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 0, 27), date.local(2011, 0, 1, 12, 4, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 0, 27), date.local(2011, 0, 1, 12, 4, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 1), date.local(2011, 0, 1, 12, 2), @@ -221,7 +221,7 @@ tape("time.ticks(count) can generate 1-minute ticks", function(test) { }); tape("time.ticks(count) can generate 5-minute ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 3, 27), date.local(2011, 0, 1, 12, 21, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 3, 27), date.local(2011, 0, 1, 12, 21, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 5), date.local(2011, 0, 1, 12, 10), @@ -232,7 +232,7 @@ tape("time.ticks(count) can generate 5-minute ticks", function(test) { }); tape("time.ticks(count) can generate 15-minute ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 8, 27), date.local(2011, 0, 1, 13, 4, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 8, 27), date.local(2011, 0, 1, 13, 4, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 15), date.local(2011, 0, 1, 12, 30), @@ -243,7 +243,7 @@ tape("time.ticks(count) can generate 15-minute ticks", function(test) { }); tape("time.ticks(count) can generate 30-minute ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 28, 27), date.local(2011, 0, 1, 14, 4, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 28, 27), date.local(2011, 0, 1, 14, 4, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 12, 30), date.local(2011, 0, 1, 13, 0), @@ -254,7 +254,7 @@ tape("time.ticks(count) can generate 30-minute ticks", function(test) { }); tape("time.ticks(count) can generate 1-hour ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 12, 28, 27), date.local(2011, 0, 1, 16, 34, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 12, 28, 27), date.local(2011, 0, 1, 16, 34, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 13, 0), date.local(2011, 0, 1, 14, 0), @@ -265,7 +265,7 @@ tape("time.ticks(count) can generate 1-hour ticks", function(test) { }); tape("time.ticks(count) can generate 3-hour ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 14, 28, 27), date.local(2011, 0, 2, 1, 34, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 14, 28, 27), date.local(2011, 0, 2, 1, 34, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 15, 0), date.local(2011, 0, 1, 18, 0), @@ -276,7 +276,7 @@ tape("time.ticks(count) can generate 3-hour ticks", function(test) { }); tape("time.ticks(count) can generate 6-hour ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 2, 14, 34, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 2, 14, 34, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 18, 0), date.local(2011, 0, 2, 0, 0), @@ -287,7 +287,7 @@ tape("time.ticks(count) can generate 6-hour ticks", function(test) { }); tape("time.ticks(count) can generate 12-hour ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 3, 21, 34, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 3, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 2, 0, 0), date.local(2011, 0, 2, 12, 0), @@ -298,7 +298,7 @@ tape("time.ticks(count) can generate 12-hour ticks", function(test) { }); tape("time.ticks(count) can generate 1-day ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 5, 21, 34, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 5, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 2, 0, 0), date.local(2011, 0, 3, 0, 0), @@ -309,7 +309,7 @@ tape("time.ticks(count) can generate 1-day ticks", function(test) { }); tape("time.ticks(count) can generate 2-day ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 2, 16, 28, 27), date.local(2011, 0, 9, 21, 34, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 2, 16, 28, 27), date.local(2011, 0, 9, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 3, 0, 0), date.local(2011, 0, 5, 0, 0), @@ -320,7 +320,7 @@ tape("time.ticks(count) can generate 2-day ticks", function(test) { }); tape("time.ticks(count) can generate 1-week ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 23, 21, 34, 12)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 1, 16, 28, 27), date.local(2011, 0, 23, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 2, 0, 0), date.local(2011, 0, 9, 0, 0), @@ -331,7 +331,7 @@ tape("time.ticks(count) can generate 1-week ticks", function(test) { }); tape("time.ticks(count) can generate 1-month ticks", function(test) { - var x = scale.time().domain([date.local(2011, 0, 18), date.local(2011, 4, 2)]); + var x = scale.scaleTime().domain([date.local(2011, 0, 18), date.local(2011, 4, 2)]); test.deepEqual(x.ticks(4), [ date.local(2011, 1, 1, 0, 0), date.local(2011, 2, 1, 0, 0), @@ -342,7 +342,7 @@ tape("time.ticks(count) can generate 1-month ticks", function(test) { }); tape("time.ticks(count) can generate 3-month ticks", function(test) { - var x = scale.time().domain([date.local(2010, 11, 18), date.local(2011, 10, 2)]); + var x = scale.scaleTime().domain([date.local(2010, 11, 18), date.local(2011, 10, 2)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 0, 0), date.local(2011, 3, 1, 0, 0), @@ -353,7 +353,7 @@ tape("time.ticks(count) can generate 3-month ticks", function(test) { }); tape("time.ticks(count) can generate 1-year ticks", function(test) { - var x = scale.time().domain([date.local(2010, 11, 18), date.local(2014, 2, 2)]); + var x = scale.scaleTime().domain([date.local(2010, 11, 18), date.local(2014, 2, 2)]); test.deepEqual(x.ticks(4), [ date.local(2011, 0, 1, 0, 0), date.local(2012, 0, 1, 0, 0), @@ -364,7 +364,7 @@ tape("time.ticks(count) can generate 1-year ticks", function(test) { }); tape("time.ticks(count) can generate multi-year ticks", function(test) { - var x = scale.time().domain([date.local(0, 11, 18), date.local(2014, 2, 2)]); + var x = scale.scaleTime().domain([date.local(0, 11, 18), date.local(2014, 2, 2)]); test.deepEqual(x.ticks(6), [ date.local( 500, 0, 1, 0, 0), date.local(1000, 0, 1, 0, 0), @@ -375,20 +375,20 @@ tape("time.ticks(count) can generate multi-year ticks", function(test) { }); tape("time.ticks(count) returns no ticks for an empty domain", function(test) { - var x = scale.time().domain([date.local(2014, 2, 2), date.local(2014, 2, 2)]); + var x = scale.scaleTime().domain([date.local(2014, 2, 2), date.local(2014, 2, 2)]); test.deepEqual(x.ticks(6), []); test.end(); }); tape("time.ticks() returns descending ticks for a descending domain", function(test) { - var x = scale.time(); + var x = scale.scaleTime(); test.deepEqual(x.domain([date.local(2014, 2, 2), date.local(2010, 11, 18)]).ticks(4), [date.local(2014, 0, 1, 0, 0), date.local(2013, 0, 1, 0, 0), date.local(2012, 0, 1, 0, 0), date.local(2011, 0, 1, 0, 0)]); test.deepEqual(x.domain([date.local(2011, 10, 2), date.local(2010, 11, 18)]).ticks(4), [date.local(2011, 9, 1, 0, 0), date.local(2011, 6, 1, 0, 0), date.local(2011, 3, 1, 0, 0), date.local(2011, 0, 1, 0, 0)]); test.end(); }); tape("time.tickFormat()(date) formats year on New Year's", function(test) { - var f = scale.time().tickFormat(); + var f = scale.scaleTime().tickFormat(); test.equal(f(date.local(2011, 0, 1)), "2011"); test.equal(f(date.local(2012, 0, 1)), "2012"); test.equal(f(date.local(2013, 0, 1)), "2013"); @@ -396,7 +396,7 @@ tape("time.tickFormat()(date) formats year on New Year's", function(test) { }); tape("time.tickFormat()(date) formats month on the 1st of each month", function(test) { - var f = scale.time().tickFormat(); + var f = scale.scaleTime().tickFormat(); test.equal(f(date.local(2011, 1, 1)), "February"); test.equal(f(date.local(2011, 2, 1)), "March"); test.equal(f(date.local(2011, 3, 1)), "April"); @@ -404,7 +404,7 @@ tape("time.tickFormat()(date) formats month on the 1st of each month", function( }); tape("time.tickFormat()(date) formats week on Sunday midnight", function(test) { - var f = scale.time().tickFormat(); + var f = scale.scaleTime().tickFormat(); test.equal(f(date.local(2011, 1, 6)), "Feb 06"); test.equal(f(date.local(2011, 1, 13)), "Feb 13"); test.equal(f(date.local(2011, 1, 20)), "Feb 20"); @@ -412,7 +412,7 @@ tape("time.tickFormat()(date) formats week on Sunday midnight", function(test) { }); tape("time.tickFormat()(date) formats date on midnight", function(test) { - var f = scale.time().tickFormat(); + var f = scale.scaleTime().tickFormat(); test.equal(f(date.local(2011, 1, 2)), "Wed 02"); test.equal(f(date.local(2011, 1, 3)), "Thu 03"); test.equal(f(date.local(2011, 1, 4)), "Fri 04"); @@ -420,7 +420,7 @@ tape("time.tickFormat()(date) formats date on midnight", function(test) { }); tape("time.tickFormat()(date) formats hour on minute zero", function(test) { - var f = scale.time().tickFormat(); + var f = scale.scaleTime().tickFormat(); test.equal(f(date.local(2011, 1, 2, 11)), "11 AM"); test.equal(f(date.local(2011, 1, 2, 12)), "12 PM"); test.equal(f(date.local(2011, 1, 2, 13)), "01 PM"); @@ -428,7 +428,7 @@ tape("time.tickFormat()(date) formats hour on minute zero", function(test) { }); tape("time.tickFormat()(date) formats minute on second zero", function(test) { - var f = scale.time().tickFormat(); + var f = scale.scaleTime().tickFormat(); test.equal(f(date.local(2011, 1, 2, 11, 59)), "11:59"); test.equal(f(date.local(2011, 1, 2, 12, 1)), "12:01"); test.equal(f(date.local(2011, 1, 2, 12, 2)), "12:02"); @@ -436,7 +436,7 @@ tape("time.tickFormat()(date) formats minute on second zero", function(test) { }); tape("time.tickFormat()(date) otherwise, formats second", function(test) { - var f = scale.time().tickFormat(); + var f = scale.scaleTime().tickFormat(); test.equal(f(date.local(2011, 1, 2, 12, 1, 9)), ":09"); test.equal(f(date.local(2011, 1, 2, 12, 1, 10)), ":10"); test.equal(f(date.local(2011, 1, 2, 12, 1, 11)), ":11"); @@ -444,7 +444,7 @@ tape("time.tickFormat()(date) otherwise, formats second", function(test) { }); tape("time.tickFormat(specifier) returns a time format for the specified specifier", function(test) { - var f = scale.time().tickFormat("%c"); + var f = scale.scaleTime().tickFormat("%c"); test.equal(f(date.local(2011, 1, 2, 12)), "Wed Feb 2 12:00:00 2011"); test.end(); }); diff --git a/test/utcTime-test.js b/test/utcTime-test.js index 51505d5..372aeb7 100644 --- a/test/utcTime-test.js +++ b/test/utcTime-test.js @@ -4,39 +4,39 @@ var tape = require("tape"), scale = require("../"), date = require("./date"); -tape("utcTime.nice() is an alias for utcTime.nice(10)", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1, 0, 17), date.utc(2009, 0, 1, 23, 42)]); +tape("scaleUtc.nice() is an alias for scaleUtc.nice(10)", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1, 0, 17), date.utc(2009, 0, 1, 23, 42)]); test.deepEqual(x.nice().domain(), [date.utc(2009, 0, 1), date.utc(2009, 0, 2)]); test.end(); }); -tape("utcTime.nice() can nice sub-second domains", function(test) { - var x = scale.utcTime().domain([date.utc(2013, 0, 1, 12, 0, 0, 0), date.utc(2013, 0, 1, 12, 0, 0, 128)]); +tape("scaleUtc.nice() can nice sub-second domains", function(test) { + var x = scale.scaleUtc().domain([date.utc(2013, 0, 1, 12, 0, 0, 0), date.utc(2013, 0, 1, 12, 0, 0, 128)]); test.deepEqual(x.nice().domain(), [date.utc(2013, 0, 1, 12, 0, 0, 0), date.utc(2013, 0, 1, 12, 0, 0, 130)]); test.end(); }); -tape("utcTime.nice() can nice multi-year domains", function(test) { - var x = scale.utcTime().domain([date.utc(2001, 0, 1), date.utc(2138, 0, 1)]); +tape("scaleUtc.nice() can nice multi-year domains", function(test) { + var x = scale.scaleUtc().domain([date.utc(2001, 0, 1), date.utc(2138, 0, 1)]); test.deepEqual(x.nice().domain(), [date.utc(2000, 0, 1), date.utc(2140, 0, 1)]); test.end(); }); -tape("utcTime.nice() can nice empty domains", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 0, 12)]); +tape("scaleUtc.nice() can nice empty domains", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 0, 12)]); test.deepEqual(x.nice().domain(), [date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 0, 12)]); test.end(); }); -tape("utcTime.nice(count) nices using the specified tick count", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1, 0, 17), date.utc(2009, 0, 1, 23, 42)]); +tape("scaleUtc.nice(count) nices using the specified tick count", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1, 0, 17), date.utc(2009, 0, 1, 23, 42)]); test.deepEqual(x.nice(100).domain(), [date.utc(2009, 0, 1, 0, 15), date.utc(2009, 0, 1, 23, 45)]); test.deepEqual(x.nice(10).domain(), [date.utc(2009, 0, 1), date.utc(2009, 0, 2)]); test.end(); }); -tape("utcTime.nice(interval) nices using the specified time interval", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 23, 48)]); +tape("scaleUtc.nice(interval) nices using the specified time interval", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 23, 48)]); test.deepEqual(x.nice(time.utcDay).domain(), [date.utc(2009, 0, 1), date.utc(2009, 0, 2)]); test.deepEqual(x.nice(time.utcWeek).domain(), [date.utc(2008, 11, 28), date.utc(2009, 0, 4)]); test.deepEqual(x.nice(time.utcMonth).domain(), [date.utc(2008, 11, 1), date.utc(2009, 1, 1)]); @@ -44,20 +44,20 @@ tape("utcTime.nice(interval) nices using the specified time interval", function( test.end(); }); -tape("utcTime.nice(interval) can nice empty domains", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 0, 12)]); +tape("scaleUtc.nice(interval) can nice empty domains", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 0, 12)]); test.deepEqual(x.nice(time.utcDay).domain(), [date.utc(2009, 0, 1), date.utc(2009, 0, 2)]); test.end(); }); -tape("utcTime.nice(interval) can nice a polylinear domain, only affecting its extent", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 23, 48), date.utc(2009, 0, 2, 23, 48)]).nice(time.utcDay); +tape("scaleUtc.nice(interval) can nice a polylinear domain, only affecting its extent", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 23, 48), date.utc(2009, 0, 2, 23, 48)]).nice(time.utcDay); test.deepEqual(x.domain(), [date.utc(2009, 0, 1), date.utc(2009, 0, 1, 23, 48), date.utc(2009, 0, 3)]); test.end(); }); -tape("utcTime.nice(interval, step) nices using the specified time interval and step", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 23, 48)]); +tape("scaleUtc.nice(interval, step) nices using the specified time interval and step", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1, 0, 12), date.utc(2009, 0, 1, 23, 48)]); test.deepEqual(x.nice(time.utcDay, 3).domain(), [date.utc(2009, 0, 1), date.utc(2009, 0, 4)]); test.deepEqual(x.nice(time.utcWeek, 2).domain(), [date.utc(2008, 11, 21), date.utc(2009, 0, 4)]); test.deepEqual(x.nice(time.utcMonth, 3).domain(), [date.utc(2008, 9, 1), date.utc(2009, 3, 1)]); @@ -65,8 +65,8 @@ tape("utcTime.nice(interval, step) nices using the specified time interval and s test.end(); }); -tape("utcTime.copy() isolates changes to the domain", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]), y = x.copy(); +tape("scaleUtc.copy() isolates changes to the domain", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]), y = x.copy(); x.domain([date.utc(2010, 0, 1), date.utc(2011, 0, 1)]); test.deepEqual(y.domain(), [date.utc(2009, 0, 1), date.utc(2010, 0, 1)]); test.equal(x(date.utc(2010, 0, 1)), 0); @@ -79,8 +79,8 @@ tape("utcTime.copy() isolates changes to the domain", function(test) { test.end(); }); -tape("utcTime.copy() isolates changes to the range", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]), y = x.copy(); +tape("scaleUtc.copy() isolates changes to the range", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]), y = x.copy(); x.range([1, 2]); test.deepEqual(x.invert(1), date.utc(2009, 0, 1)); test.deepEqual(y.invert(1), date.utc(2010, 0, 1)); @@ -93,8 +93,8 @@ tape("utcTime.copy() isolates changes to the range", function(test) { test.end(); }); -tape("utcTime.copy() isolates changes to the interpolator", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]).range(["red", "blue"]), +tape("scaleUtc.copy() isolates changes to the interpolator", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]).range(["red", "blue"]), i = x.interpolate(), y = x.copy(); x.interpolate(interpolate.interpolateHsl); @@ -104,8 +104,8 @@ tape("utcTime.copy() isolates changes to the interpolator", function(test) { test.end(); }); -tape("utcTime.copy() isolates changes to clamping", function(test) { - var x = scale.utcTime().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]).clamp(true), y = x.copy(); +tape("scaleUtc.copy() isolates changes to clamping", function(test) { + var x = scale.scaleUtc().domain([date.utc(2009, 0, 1), date.utc(2010, 0, 1)]).clamp(true), y = x.copy(); x.clamp(false); test.equal(x(date.utc(2011, 0, 1)), 2); test.equal(y(date.utc(2011, 0, 1)), 1); @@ -117,8 +117,8 @@ tape("utcTime.copy() isolates changes to clamping", function(test) { test.end(); }); -tape("utcTime.ticks(interval) observes the specified tick interval", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 1, 0), date.utc(2011, 0, 1, 12, 4, 4)]); +tape("scaleUtc.ticks(interval) observes the specified tick interval", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 1, 0), date.utc(2011, 0, 1, 12, 4, 4)]); test.deepEqual(x.ticks(time.utcMinute), [ date.utc(2011, 0, 1, 12, 1), date.utc(2011, 0, 1, 12, 2), @@ -128,8 +128,8 @@ tape("utcTime.ticks(interval) observes the specified tick interval", function(te test.end(); }); -tape("utcTime.ticks(interval) observes the specified named tick interval", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 1, 0), date.utc(2011, 0, 1, 12, 4, 4)]); +tape("scaleUtc.ticks(interval) observes the specified named tick interval", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 1, 0), date.utc(2011, 0, 1, 12, 4, 4)]); test.deepEqual(x.ticks(time.utcMinute), [ date.utc(2011, 0, 1, 12, 1), date.utc(2011, 0, 1, 12, 2), @@ -139,8 +139,8 @@ tape("utcTime.ticks(interval) observes the specified named tick interval", funct test.end(); }); -tape("utcTime.ticks(interval, step) observes the specified tick interval and step", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 33, 4)]); +tape("scaleUtc.ticks(interval, step) observes the specified tick interval and step", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 33, 4)]); test.deepEqual(x.ticks(time.utcMinute, 10), [ date.utc(2011, 0, 1, 12, 0), date.utc(2011, 0, 1, 12, 10), @@ -150,8 +150,8 @@ tape("utcTime.ticks(interval, step) observes the specified tick interval and ste test.end(); }); -tape("utcTime.ticks(count) can generate sub-second ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 1)]); +tape("scaleUtc.ticks(count) can generate sub-second ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 1)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 0, 0, 0), date.utc(2011, 0, 1, 12, 0, 0, 200), @@ -163,8 +163,8 @@ tape("utcTime.ticks(count) can generate sub-second ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 1-second ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 4)]); +tape("scaleUtc.ticks(count) can generate 1-second ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 4)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 1), @@ -175,8 +175,8 @@ tape("utcTime.ticks(count) can generate 1-second ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 5-second ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 20)]); +tape("scaleUtc.ticks(count) can generate 5-second ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 20)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 5), @@ -187,8 +187,8 @@ tape("utcTime.ticks(count) can generate 5-second ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 15-second ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 50)]); +tape("scaleUtc.ticks(count) can generate 15-second ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 50)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 15), @@ -198,8 +198,8 @@ tape("utcTime.ticks(count) can generate 15-second ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 30-second ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 1, 50)]); +tape("scaleUtc.ticks(count) can generate 30-second ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 1, 50)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 0, 0), date.utc(2011, 0, 1, 12, 0, 30), @@ -209,8 +209,8 @@ tape("utcTime.ticks(count) can generate 30-second ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 1-minute ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 0, 27), date.utc(2011, 0, 1, 12, 4, 12)]); +tape("scaleUtc.ticks(count) can generate 1-minute ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 0, 27), date.utc(2011, 0, 1, 12, 4, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 1), date.utc(2011, 0, 1, 12, 2), @@ -220,8 +220,8 @@ tape("utcTime.ticks(count) can generate 1-minute ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 5-minute ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 3, 27), date.utc(2011, 0, 1, 12, 21, 12)]); +tape("scaleUtc.ticks(count) can generate 5-minute ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 3, 27), date.utc(2011, 0, 1, 12, 21, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 5), date.utc(2011, 0, 1, 12, 10), @@ -231,8 +231,8 @@ tape("utcTime.ticks(count) can generate 5-minute ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 15-minute ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 8, 27), date.utc(2011, 0, 1, 13, 4, 12)]); +tape("scaleUtc.ticks(count) can generate 15-minute ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 8, 27), date.utc(2011, 0, 1, 13, 4, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 15), date.utc(2011, 0, 1, 12, 30), @@ -242,8 +242,8 @@ tape("utcTime.ticks(count) can generate 15-minute ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 30-minute ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 28, 27), date.utc(2011, 0, 1, 14, 4, 12)]); +tape("scaleUtc.ticks(count) can generate 30-minute ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 28, 27), date.utc(2011, 0, 1, 14, 4, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 12, 30), date.utc(2011, 0, 1, 13, 0), @@ -253,8 +253,8 @@ tape("utcTime.ticks(count) can generate 30-minute ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 1-hour ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 12, 28, 27), date.utc(2011, 0, 1, 16, 34, 12)]); +tape("scaleUtc.ticks(count) can generate 1-hour ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 12, 28, 27), date.utc(2011, 0, 1, 16, 34, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 13, 0), date.utc(2011, 0, 1, 14, 0), @@ -264,8 +264,8 @@ tape("utcTime.ticks(count) can generate 1-hour ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 3-hour ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 14, 28, 27), date.utc(2011, 0, 2, 1, 34, 12)]); +tape("scaleUtc.ticks(count) can generate 3-hour ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 14, 28, 27), date.utc(2011, 0, 2, 1, 34, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 15, 0), date.utc(2011, 0, 1, 18, 0), @@ -275,8 +275,8 @@ tape("utcTime.ticks(count) can generate 3-hour ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 6-hour ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 2, 14, 34, 12)]); +tape("scaleUtc.ticks(count) can generate 6-hour ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 2, 14, 34, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 18, 0), date.utc(2011, 0, 2, 0, 0), @@ -286,8 +286,8 @@ tape("utcTime.ticks(count) can generate 6-hour ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 12-hour ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 3, 21, 34, 12)]); +tape("scaleUtc.ticks(count) can generate 12-hour ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 3, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 2, 0, 0), date.utc(2011, 0, 2, 12, 0), @@ -297,8 +297,8 @@ tape("utcTime.ticks(count) can generate 12-hour ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 1-day ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 5, 21, 34, 12)]); +tape("scaleUtc.ticks(count) can generate 1-day ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 5, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 2, 0, 0), date.utc(2011, 0, 3, 0, 0), @@ -308,8 +308,8 @@ tape("utcTime.ticks(count) can generate 1-day ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 2-day ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 2, 16, 28, 27), date.utc(2011, 0, 9, 21, 34, 12)]); +tape("scaleUtc.ticks(count) can generate 2-day ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 2, 16, 28, 27), date.utc(2011, 0, 9, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 3, 0, 0), date.utc(2011, 0, 5, 0, 0), @@ -319,8 +319,8 @@ tape("utcTime.ticks(count) can generate 2-day ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 1-week ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 23, 21, 34, 12)]); +tape("scaleUtc.ticks(count) can generate 1-week ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 1, 16, 28, 27), date.utc(2011, 0, 23, 21, 34, 12)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 2, 0, 0), date.utc(2011, 0, 9, 0, 0), @@ -330,8 +330,8 @@ tape("utcTime.ticks(count) can generate 1-week ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 1-month ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2011, 0, 18), date.utc(2011, 4, 2)]); +tape("scaleUtc.ticks(count) can generate 1-month ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2011, 0, 18), date.utc(2011, 4, 2)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 1, 1, 0, 0), date.utc(2011, 2, 1, 0, 0), @@ -341,8 +341,8 @@ tape("utcTime.ticks(count) can generate 1-month ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 3-month ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2010, 11, 18), date.utc(2011, 10, 2)]); +tape("scaleUtc.ticks(count) can generate 3-month ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2010, 11, 18), date.utc(2011, 10, 2)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 0, 0), date.utc(2011, 3, 1, 0, 0), @@ -352,8 +352,8 @@ tape("utcTime.ticks(count) can generate 3-month ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate 1-year ticks", function(test) { - var x = scale.utcTime().domain([date.utc(2010, 11, 18), date.utc(2014, 2, 2)]); +tape("scaleUtc.ticks(count) can generate 1-year ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(2010, 11, 18), date.utc(2014, 2, 2)]); test.deepEqual(x.ticks(4), [ date.utc(2011, 0, 1, 0, 0), date.utc(2012, 0, 1, 0, 0), @@ -363,8 +363,8 @@ tape("utcTime.ticks(count) can generate 1-year ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) can generate multi-year ticks", function(test) { - var x = scale.utcTime().domain([date.utc(0, 11, 18), date.utc(2014, 2, 2)]); +tape("scaleUtc.ticks(count) can generate multi-year ticks", function(test) { + var x = scale.scaleUtc().domain([date.utc(0, 11, 18), date.utc(2014, 2, 2)]); test.deepEqual(x.ticks(6), [ date.utc( 500, 0, 1, 0, 0), date.utc(1000, 0, 1, 0, 0), @@ -374,70 +374,70 @@ tape("utcTime.ticks(count) can generate multi-year ticks", function(test) { test.end(); }); -tape("utcTime.ticks(count) returns no ticks for an empty domain", function(test) { - var x = scale.utcTime().domain([date.utc(2014, 2, 2), date.utc(2014, 2, 2)]); +tape("scaleUtc.ticks(count) returns no ticks for an empty domain", function(test) { + var x = scale.scaleUtc().domain([date.utc(2014, 2, 2), date.utc(2014, 2, 2)]); test.deepEqual(x.ticks(6), []); test.end(); }); -tape("utcTime.tickFormat()(date) formats year on New Year's", function(test) { - var f = scale.utcTime().tickFormat(); +tape("scaleUtc.tickFormat()(date) formats year on New Year's", function(test) { + var f = scale.scaleUtc().tickFormat(); test.equal(f(date.utc(2011, 0, 1)), "2011"); test.equal(f(date.utc(2012, 0, 1)), "2012"); test.equal(f(date.utc(2013, 0, 1)), "2013"); test.end(); }); -tape("utcTime.tickFormat()(date) formats month on the 1st of each month", function(test) { - var f = scale.utcTime().tickFormat(); +tape("scaleUtc.tickFormat()(date) formats month on the 1st of each month", function(test) { + var f = scale.scaleUtc().tickFormat(); test.equal(f(date.utc(2011, 1, 1)), "February"); test.equal(f(date.utc(2011, 2, 1)), "March"); test.equal(f(date.utc(2011, 3, 1)), "April"); test.end(); }); -tape("utcTime.tickFormat()(date) formats week on Sunday midnight", function(test) { - var f = scale.utcTime().tickFormat(); +tape("scaleUtc.tickFormat()(date) formats week on Sunday midnight", function(test) { + var f = scale.scaleUtc().tickFormat(); test.equal(f(date.utc(2011, 1, 6)), "Feb 06"); test.equal(f(date.utc(2011, 1, 13)), "Feb 13"); test.equal(f(date.utc(2011, 1, 20)), "Feb 20"); test.end(); }); -tape("utcTime.tickFormat()(date) formats date on midnight", function(test) { - var f = scale.utcTime().tickFormat(); +tape("scaleUtc.tickFormat()(date) formats date on midnight", function(test) { + var f = scale.scaleUtc().tickFormat(); test.equal(f(date.utc(2011, 1, 2)), "Wed 02"); test.equal(f(date.utc(2011, 1, 3)), "Thu 03"); test.equal(f(date.utc(2011, 1, 4)), "Fri 04"); test.end(); }); -tape("utcTime.tickFormat()(date) formats hour on minute zero", function(test) { - var f = scale.utcTime().tickFormat(); +tape("scaleUtc.tickFormat()(date) formats hour on minute zero", function(test) { + var f = scale.scaleUtc().tickFormat(); test.equal(f(date.utc(2011, 1, 2, 11)), "11 AM"); test.equal(f(date.utc(2011, 1, 2, 12)), "12 PM"); test.equal(f(date.utc(2011, 1, 2, 13)), "01 PM"); test.end(); }); -tape("utcTime.tickFormat()(date) formats minute on second zero", function(test) { - var f = scale.utcTime().tickFormat(); +tape("scaleUtc.tickFormat()(date) formats minute on second zero", function(test) { + var f = scale.scaleUtc().tickFormat(); test.equal(f(date.utc(2011, 1, 2, 11, 59)), "11:59"); test.equal(f(date.utc(2011, 1, 2, 12, 1)), "12:01"); test.equal(f(date.utc(2011, 1, 2, 12, 2)), "12:02"); test.end(); }); -tape("utcTime.tickFormat()(date) otherwise, formats second", function(test) { - var f = scale.utcTime().tickFormat(); +tape("scaleUtc.tickFormat()(date) otherwise, formats second", function(test) { + var f = scale.scaleUtc().tickFormat(); test.equal(f(date.utc(2011, 1, 2, 12, 1, 9)), ":09"); test.equal(f(date.utc(2011, 1, 2, 12, 1, 10)), ":10"); test.equal(f(date.utc(2011, 1, 2, 12, 1, 11)), ":11"); test.end(); }); -tape("utcTime.tickFormat(specifier) returns a time format for the specified specifier", function(test) { - var f = scale.utcTime().tickFormat("%c"); +tape("scaleUtc.tickFormat(specifier) returns a time format for the specified specifier", function(test) { + var f = scale.scaleUtc().tickFormat("%c"); test.equal(f(date.utc(2011, 1, 2, 12)), "Wed Feb 2 12:00:00 2011"); test.end(); }); diff --git a/test/viridis-test.js b/test/viridis-test.js index dea98a5..3c407a0 100644 --- a/test/viridis-test.js +++ b/test/viridis-test.js @@ -1,8 +1,8 @@ var tape = require("tape"), scale = require("../"); -tape("viridis() has the expected defaults", function(test) { - var s = scale.viridis(); +tape("scaleViridis() has the expected defaults", function(test) { + var s = scale.scaleViridis(); test.deepEqual(s.domain(), [0, 1]); test.equal(s(0.0), "#440154"); test.equal(s(0.5), "#21918c"); @@ -11,7 +11,7 @@ tape("viridis() has the expected defaults", function(test) { }); tape("viridis(value) always clamps", function(test) { - var s = scale.viridis(); + var s = scale.scaleViridis(); test.ok(!("clamp" in s)); test.equal(s(-0.5), "#440154"); test.equal(s( 0.0), "#440154"); @@ -22,7 +22,7 @@ tape("viridis(value) always clamps", function(test) { }); tape("viridis.domain() coerces domain values to numbers", function(test) { - var s = scale.viridis().domain(["-1.20", "2.40"]); + var s = scale.scaleViridis().domain(["-1.20", "2.40"]); test.deepEqual(s.domain(), [-1.2, 2.4]); test.equal(s(-1.2), "#440154"); test.equal(s( 0.6), "#21918c"); @@ -31,13 +31,13 @@ tape("viridis.domain() coerces domain values to numbers", function(test) { }); tape("viridis.domain() only considers the first and second element of the domain", function(test) { - var s = scale.viridis().domain([-1, 100, 200]); + var s = scale.scaleViridis().domain([-1, 100, 200]); test.deepEqual(s.domain(), [-1, 100]); test.end(); }); tape("viridis.copy() returns an isolated copy of the scale", function(test) { - var s1 = scale.viridis().domain([1, 3]), + var s1 = scale.scaleViridis().domain([1, 3]), s2 = s1.copy(); test.deepEqual(s2.domain(), [1, 3]); s1.domain([-1, 2]);