mdarray-sol 0.1.0-java

data/node_modules/dc/spec/row-chart-spec.js

@@ -0,0 +1,362 @@
+/* global appendChartID, loadDateFixture, makeDate */
+describe('dc.rowChart', function () {
+    var id, chart;
+    var data, dimension, nvdimension;
+    var positiveGroupHolder = {groupType: 'positive signed'};
+    var negativeGroupHolder = {groupType: 'negative signed'};
+    var mixedGroupHolder = {groupType: 'mixed signed'};
+    var largerGroupHolder = {groupType: 'larger'};
+
+    beforeEach(function () {
+        data = crossfilter(loadDateFixture());
+        dimension = data.dimension(function (d) { return +d.value; });
+
+        positiveGroupHolder.group = dimension.group().reduceSum(function (d) {return Math.abs(+d.nvalue);});
+        positiveGroupHolder.dimension = dimension;
+        negativeGroupHolder.group = dimension.group().reduceSum(function (d) {return -Math.abs(+d.nvalue);});
+        negativeGroupHolder.dimension = dimension;
+        mixedGroupHolder.group = dimension.group().reduceSum(function (d) {return +d.nvalue;});
+        mixedGroupHolder.dimension = dimension;
+
+        nvdimension = data.dimension(function (d) { return +d.nvalue; });
+        largerGroupHolder.group = nvdimension.group().reduceSum(function (d) {return +d.value;});
+        largerGroupHolder.dimension = nvdimension;
+
+        id = 'row-chart';
+        appendChartID(id);
+
+        chart = dc.rowChart('#' + id);
+        chart.dimension(dimension)
+            .width(600).height(200).gap(10)
+            .transitionDuration(0);
+    });
+
+    describe('enabling the chart title and label with a value accessor', function () {
+        beforeEach(function () {
+            chart.group(mixedGroupHolder.group);
+            chart.valueAccessor(function (d) {
+                return d.value + 100;
+            }).renderLabel(true).renderTitle(true).render();
+        });
+
+        it('should use the default function to dynamically generate the label', function () {
+            expect(chart.select('text.row').text()).toBe('22');
+        });
+
+        it('should use the default function to dynamically generate the title', function () {
+            expect(chart.select('g.row title').text()).toBe('22: 108');
+        });
+    });
+
+    describe('with a logarithmic X axis and positive data', function () {
+        beforeEach(function () {
+            chart.group(positiveGroupHolder.group);
+            chart.elasticX(false);
+            chart.x(d3.scale.log());
+            chart.render();
+        });
+
+        it('should render valid rect widths', function () {
+            expect(chart.select('g.row rect').attr('width')).toBeWithinDelta(1, 0.5);
+        });
+    });
+
+    describe('with a fixedBarHeight', function () {
+        beforeEach(function () {
+            chart.group(positiveGroupHolder.group);
+            chart.elasticX(false);
+            chart.x(d3.scale.log());
+            chart.fixedBarHeight(10);
+            chart.render();
+        });
+
+        it('should render fixed rect height', function () {
+            expect(chart.select('g.row rect').attr('height')).toBeWithinDelta(10, 0.0);
+        });
+    });
+
+    describe('with renderTitleLabel', function () {
+        beforeEach(function () {
+            chart.group(positiveGroupHolder.group);
+            chart.x(d3.scale.linear());
+            chart.title(function () {
+                return 'test title';
+            });
+            chart.renderTitleLabel(true);
+            chart.render();
+        });
+
+        it('should render title label centered', function () {
+            expect(chart.select('g.row .titlerow').attr('dy')).toBeDefined();
+        });
+    });
+
+    function itShouldBehaveLikeARowChartWithGroup (groupHolder, N) {
+        describe('for ' + groupHolder.groupType + ' data', function () {
+            beforeEach(function () {
+                chart.group(groupHolder.group);
+            });
+
+            describe('rendering the row chart', function () {
+                beforeEach(function () {
+                    chart.render();
+                });
+
+                it('should create a root svg node', function () {
+                    expect(chart.select('svg').size()).toBe(1);
+                });
+
+                it('should create a row group for each datum', function () {
+                    expect(chart.selectAll('svg g g.row').size()).toBe(N);
+                });
+
+                it('should number each row sequentially with classes', function () {
+                    chart.selectAll('svg g g.row').each(function (r, i) {
+                        expect(d3.select(this).attr('class')).toBe('row _' + i);
+                    });
+                });
+
+                it('should fill each row rect with pre-defined colors', function () {
+                    expect(d3.select(chart.selectAll('g.row rect')[0][0]).attr('fill')).toBe('#3182bd');
+                    expect(d3.select(chart.selectAll('g.row rect')[0][1]).attr('fill')).toBe('#6baed6');
+                    expect(d3.select(chart.selectAll('g.row rect')[0][2]).attr('fill')).toBe('#9ecae1');
+                    expect(d3.select(chart.selectAll('g.row rect')[0][3]).attr('fill')).toBe('#c6dbef');
+                    expect(d3.select(chart.selectAll('g.row rect')[0][4]).attr('fill')).toBe('#e6550d');
+                });
+
+                it('should create a row label from the data for each row', function () {
+                    expect(chart.selectAll('svg text.row').size()).toBe(N);
+
+                    chart.selectAll('svg g text.row').call(function (t) {
+                        expect(+t.text()).toBe(t.datum().key);
+                    });
+                });
+
+                describe('row label vertical position', function () {
+                    var labels, rows;
+                    beforeEach(function () {
+                        labels = chart.selectAll('svg text.row');
+                        rows = chart.selectAll('g.row rect');
+                    });
+
+                    function itShouldVerticallyCenterLabelWithinRow (i) {
+                        it('should place label ' + i + ' within row ' + i, function () {
+                            var rowpos = rows[0][i].getBoundingClientRect(),
+                                textpos = labels[0][i].getBoundingClientRect();
+                            expect((textpos.top + textpos.bottom) / 2)
+                                .toBeWithinDelta((rowpos.top + rowpos.bottom) / 2, 2);
+                        });
+                    }
+                    for (var i = 0; i < N ; ++i) {
+                        itShouldVerticallyCenterLabelWithinRow(i);
+                    }
+                });
+
+                describe('re-rendering the chart', function () {
+                    beforeEach(function () {
+                        chart.render();
+                    });
+
+                    it('should leave a single instance of the chart', function () {
+                        expect(d3.selectAll('#row-chart svg').size()).toBe(1);
+                    });
+                });
+            });
+
+            describe('chart filters', function () {
+                beforeEach(function () {
+                    chart.render();
+                    d3.select('#' + id).append('span').classed('filter', true);
+                });
+
+                it('should not have filter by default', function () {
+                    expect(chart.hasFilter()).toBeFalsy();
+                });
+
+                it('should not modify the underlying crossfilter group', function () {
+                    var oldGroupData = chart.group().all().slice(0);
+                    chart.ordering(dc.pluck('value'));
+                    chart.filter('66').render();
+
+                    expect(chart.group().all().length).toBe(oldGroupData.length);
+                    for (var i = 0; i < oldGroupData.length; i++) {
+                        expect(chart.group().all()[i]).toBe(oldGroupData[i]);
+                    }
+                });
+
+                describe('filtering a row', function () {
+                    beforeEach(function () {
+                        chart.filter('66');
+                        chart.render();
+                    });
+
+                    it('should apply a filter to the chart', function () {
+                        expect(chart.filter()).toBe('66');
+                        expect(chart.hasFilter()).toBeTruthy();
+                    });
+
+                    it('should highlight any selected rows', function () {
+                        chart.filter('22');
+                        chart.render();
+                        chart.selectAll('g.row rect').each(function (d) {
+                            if (d.key === 66 || d.key === 22) {
+                                expect(d3.select(this).classed('selected')).toBeTruthy();
+                                expect(d3.select(this).classed('deselected')).toBeFalsy();
+                            } else {
+                                expect(d3.select(this).classed('deselected')).toBeTruthy();
+                                expect(d3.select(this).classed('selected')).toBeFalsy();
+                            }
+                        });
+                    });
+
+                    it('should generate filter info in a filter-classed element', function () {
+                        expect(chart.select('span.filter').style('display')).not.toBe('none');
+                        expect(chart.select('span.filter').text()).toBe('66');
+                    });
+
+                    describe('removing filters', function () {
+                        beforeEach(function () {
+                            chart.filterAll();
+                            chart.render();
+                        });
+
+                        it('should remove highlighting', function () {
+                            chart.selectAll('g.row rect').each(function (d) {
+                                expect(d3.select(this).classed('deselected')).toBeFalsy();
+                                expect(d3.select(this).classed('selected')).toBeFalsy();
+                            });
+                        });
+                    });
+                });
+            });
+
+            describe('filtering related dimensions', function () {
+                beforeEach(function () {
+                    chart.render();
+                    data.dimension(function (d) { return d.status; }).filter('E');
+                });
+
+                it('should preserve the labels', function () {
+                    chart.selectAll('svg g text.row').each(function () {
+                        expect(d3.select(this).text()).not.toBe('');
+                    });
+                });
+            });
+
+            describe('clicking on a row', function () {
+                beforeEach(function () {
+                    chart.render();
+                    chart.onClick(chart.group().all()[0]);
+                });
+
+                it('should filter the corresponding group', function () {
+                    expect(chart.filter()).toBe(chart.group().all()[0].key);
+                });
+
+                describe('clicking again', function () {
+                    beforeEach(function () {
+                        chart.onClick(chart.group().all()[0]);
+                    });
+
+                    it('should reset the filter', function () {
+                        expect(chart.filter()).toBe(null);
+                    });
+                });
+            });
+
+            describe('specifying a group ordering', function () {
+                beforeEach(function () {
+                    chart.render();
+                });
+
+                it('should order values when by value', function () {
+                    chart.ordering(dc.pluck('value'));
+                    expect(chart.data().map(dc.pluck('value')).sort(d3.ascending)).toEqual(chart.data().map(dc.pluck('value')));
+                });
+
+                it('should order keys when by keys', function () {
+                    chart.ordering(dc.pluck('key'));
+                    expect(chart.data().map(dc.pluck('key')).sort(d3.ascending)).toEqual(chart.data().map(dc.pluck('key')));
+                });
+            });
+
+            describe('redrawing after an empty selection', function () {
+                beforeEach(function () {
+                    chart.render();
+                    // fixme: huh?  this isn't even the right data type
+                    groupHolder.dimension.filter([makeDate(2010, 0, 1), makeDate(2010, 0, 3)]);
+                    chart.redraw();
+                    groupHolder.dimension.filter([makeDate(2012, 0, 1), makeDate(2012, 11, 30)]);
+                    chart.redraw();
+                });
+
+                it('should restore the row chart', function () {
+                    chart.selectAll('g.row rect').each(function (p) {
+                        expect(d3.select(this).attr('width').indexOf('NaN') < 0).toBeTruthy();
+                    });
+                });
+            });
+
+            describe('custom labels', function () {
+                beforeEach(function () {
+                    chart.label(function () {
+                        return 'custom label';
+                    }).render();
+                });
+
+                it('should render a label for each datum', function () {
+                    expect(chart.selectAll('text.row').size()).toBe(N);
+                });
+
+                it('should use the custom function for each label', function () {
+                    chart.selectAll('text.row').each(function () {
+                        expect(d3.select(this).text()).toBe('custom label');
+                    });
+                });
+
+                describe('with labels disabled', function () {
+                    beforeEach(function () {
+                        chart.renderLabel(false).render();
+                    });
+
+                    it('should not display labels', function () {
+                        expect(chart.selectAll('text.row').size()).toBe(0);
+                    });
+                });
+            });
+
+            describe('custom titles', function () {
+                beforeEach(function () {
+                    chart.title(function () {
+                        return 'custom title';
+                    }).render();
+                });
+
+                it('should render a title for each datum', function () {
+                    expect(chart.selectAll('g.row title').size()).toBe(N);
+                });
+
+                it('should use the custom function for each title', function () {
+                    chart.selectAll('g.row title').each(function () {
+                        expect(d3.select(this).text()).toBe('custom title');
+                    });
+                });
+
+                describe('with titles disabled', function () {
+                    beforeEach(function () {
+                        chart.renderTitle(false).render();
+                    });
+
+                    it('should not display labels', function () {
+                        expect(chart.selectAll('g.row title').size()).toBe(0);
+                    });
+                });
+            });
+        });
+    }
+
+    itShouldBehaveLikeARowChartWithGroup(positiveGroupHolder, 5);
+    itShouldBehaveLikeARowChartWithGroup(negativeGroupHolder, 5);
+    itShouldBehaveLikeARowChartWithGroup(mixedGroupHolder, 5);
+    itShouldBehaveLikeARowChartWithGroup(largerGroupHolder, 7);
+});

data/node_modules/dc/spec/scatter-plot-spec.js

@@ -0,0 +1,336 @@
+/* global appendChartID, comparePaths, loadDateFixture, makeDate */
+describe('dc.scatterPlot', function () {
+    var id, chart;
+    var data, group, dimension;
+
+    beforeEach(function () {
+        data = crossfilter(loadDateFixture());
+        dimension = data.dimension(function (d) { return [+d.value, +d.nvalue]; });
+        group = dimension.group();
+
+        id = 'scatter-plot';
+        appendChartID(id);
+
+        chart = dc.scatterPlot('#' + id);
+        chart.dimension(dimension)
+            .group(group)
+            .width(500).height(180)
+            .x(d3.scale.linear().domain([0, 70]))
+            .excludedColor('#ccc')
+            .excludedOpacity(0.25)
+            .transitionDuration(0);
+    });
+
+    describe('rendering the scatter plot', function () {
+        beforeEach(function () {
+            chart.render();
+        });
+
+        it('should create an svg', function () {
+            expect(chart.svg().empty()).toBeFalsy();
+        });
+
+        it('should create the correct number of symbols', function () {
+            expect(chart.group().all().length).toBe(chart.selectAll('path.symbol').size());
+        });
+
+        it('should correctly place the symbols', function () {
+            expect(nthSymbol(4).attr('transform')).toMatchTranslate(264,131);
+            expect(nthSymbol(5).attr('transform')).toMatchTranslate(264,75);
+            expect(nthSymbol(8).attr('transform')).toMatchTranslate(396,131);
+        });
+
+        it('should generate a default color fill for symbols', function () {
+            expect(nthSymbol(4).attr('fill')).toBe('#1f77b4');
+            expect(nthSymbol(5).attr('fill')).toBe('#1f77b4');
+            expect(nthSymbol(8).attr('fill')).toBe('#1f77b4');
+        });
+
+        describe('with a custom color', function () {
+            beforeEach(function () {
+                chart.colors('red').render();
+            });
+
+            it('should color the symbols to the provided color', function () {
+                expect(nthSymbol(4).attr('fill')).toBe('red');
+                expect(nthSymbol(5).attr('fill')).toBe('red');
+                expect(nthSymbol(8).attr('fill')).toBe('red');
+            });
+        });
+
+        function nthSymbol (i) {
+            return d3.select(chart.selectAll('path.symbol')[0][i]);
+        }
+
+        describe('filtering the chart', function () {
+            var otherDimension;
+
+            beforeEach(function () {
+                otherDimension = data.dimension(function (d) { return [+d.value, +d.nvalue]; });
+
+                chart.filterAll();
+                chart.filter([[22, -3], [44, 2]]);
+            });
+
+            it('should filter dimensions based on the same data', function () {
+                expect(otherDimension.top(Infinity).length).toBe(3);
+            });
+
+            describe('when filtering with null', function () {
+                beforeEach(function () {
+                    chart.filter(null);
+                });
+
+                it('should remove all filtering from the dimensions based on the same data', function () {
+                    expect(otherDimension.top(Infinity).length).toBe(10);
+                });
+
+            });
+        });
+
+        describe('filtering another dimension', function () {
+            var otherDimension;
+
+            beforeEach(function () {
+                otherDimension = data.dimension(function (d) { return [+d.value, +d.nvalue]; });
+                var ff = dc.filters.RangedTwoDimensionalFilter([[22, -3], [44, 2]]).isFiltered;
+                otherDimension.filterFunction(ff);
+                chart.redraw();
+            });
+
+            it('should show the included points', function () {
+                var shownPoints = symbolsOfRadius(chart.symbolSize());
+                expect(shownPoints.length).toBe(2);
+                expect(shownPoints[0].key).toEqual([22, -2]);
+                expect(shownPoints[1].key).toEqual([33, 1]);
+            });
+            it('should hide the excluded points', function () {
+                var hiddenPoints = symbolsOfRadius(chart.hiddenSize());
+                expect(hiddenPoints.length).toBe(7);
+            });
+        });
+
+        describe('brushing', function () {
+            var otherDimension;
+
+            beforeEach(function () {
+                otherDimension = data.dimension(function (d) { return [+d.value, +d.nvalue]; });
+
+                chart.brush().extent([[22, -3], [44, 2]]);
+                chart.brush().on('brush')();
+                chart.redraw();
+            });
+
+            it('should filter dimensions based on the same data', function () {
+                jasmine.clock().tick(100);
+                expect(otherDimension.top(Infinity).length).toBe(3);
+            });
+
+            it('should set the height of the brush to the height implied by the extent', function () {
+                expect(chart.select('g.brush rect.extent').attr('height')).toBe('46');
+            });
+
+            it('should not add handles to the brush', function () {
+                expect(chart.select('.resize path').empty()).toBeTruthy();
+            });
+
+            describe('excluded points', function () {
+                var selectedPoints;
+
+                beforeEach(function () {
+                    jasmine.clock().tick(100);
+                });
+
+                var isOpaque = function () {
+                    return +d3.select(this).attr('opacity') === 1;
+                }, isTranslucent = function () {
+                    return +d3.select(this).attr('opacity') === 0.25;
+                }, isBlue = function () {
+                    return d3.select(this).attr('fill') === '#1f77b4';
+                }, isGrey = function () {
+                    return d3.select(this).attr('fill') === '#ccc';
+                };
+
+                it('should not shrink the included points', function () {
+                    selectedPoints = symbolsOfRadius(chart.symbolSize());
+                    expect(selectedPoints.length).toBe(2);
+                    expect(selectedPoints[0].key).toEqual([22, -2]);
+                    expect(selectedPoints[1].key).toEqual([33, 1]);
+                });
+
+                it('should shrink the excluded points', function () {
+                    selectedPoints = symbolsOfRadius(chart.excludedSize());
+                    expect(selectedPoints.length).toBe(7);
+                    expect(selectedPoints[0].key).toEqual([22, 10]);
+                    expect(selectedPoints[1].key).toEqual([44, -3]);
+                });
+
+                it('should keep the included points opaque', function () {
+                    selectedPoints = symbolsMatching(isOpaque);
+                    expect(selectedPoints.length).toBe(2);
+                    expect(selectedPoints[0].key).toEqual([22, -2]);
+                    expect(selectedPoints[1].key).toEqual([33, 1]);
+                });
+
+                it('should make the excluded points translucent', function () {
+                    selectedPoints = symbolsMatching(isTranslucent);
+                    expect(selectedPoints.length).toBe(7);
+                    expect(selectedPoints[0].key).toEqual([22, 10]);
+                    expect(selectedPoints[1].key).toEqual([44, -3]);
+                });
+
+                it('should keep the included points blue', function () {
+                    selectedPoints = symbolsMatching(isBlue);
+                    expect(selectedPoints.length).toBe(2);
+                    expect(selectedPoints[0].key).toEqual([22, -2]);
+                    expect(selectedPoints[1].key).toEqual([33, 1]);
+                });
+
+                it('should make the excluded points grey', function () {
+                    selectedPoints = symbolsMatching(isGrey);
+                    expect(selectedPoints.length).toBe(7);
+                    expect(selectedPoints[0].key).toEqual([22, 10]);
+                    expect(selectedPoints[1].key).toEqual([44, -3]);
+                });
+
+                it('should restore sizes, colors, and opacity when the brush is empty', function () {
+                    chart.brush().extent([[22, 2], [22, -3]]);
+                    chart.brush().on('brush')();
+                    jasmine.clock().tick(100);
+
+                    selectedPoints = symbolsOfRadius(chart.symbolSize());
+                    expect(selectedPoints.length).toBe(9);
+
+                    selectedPoints = symbolsMatching(isBlue);
+                    expect(selectedPoints.length).toBe(9);
+
+                    selectedPoints = symbolsMatching(isOpaque);
+                    expect(selectedPoints.length).toBe(9);
+
+                    chart.redraw();
+
+                    selectedPoints = symbolsOfRadius(chart.symbolSize());
+                    expect(selectedPoints.length).toBe(9);
+
+                    selectedPoints = symbolsMatching(isBlue);
+                    expect(selectedPoints.length).toBe(9);
+
+                    selectedPoints = symbolsMatching(isOpaque);
+                    expect(selectedPoints.length).toBe(9);
+                });
+            });
+        });
+    });
+
+    function matchSymbolSize (r) {
+        return function () {
+            var symbol = d3.select(this);
+            var size = Math.pow(r, 2);
+            var path = d3.svg.symbol().size(size)();
+            var result = comparePaths(symbol.attr('d'), path);
+            return result.pass;
+        };
+    }
+
+    function symbolsMatching (pred) {
+        function getData (symbols) {
+            return symbols[0].map(function (symbol) {
+                return d3.select(symbol).datum();
+            });
+        }
+        return getData(chart.selectAll('path.symbol').filter(pred));
+    }
+
+    function symbolsOfRadius (r) {
+        return symbolsMatching(matchSymbolSize(r));
+    }
+
+    describe('legends', function () {
+        var compositeChart, id;
+        var subChart1, subChart2;
+        var firstItem;
+
+        beforeEach(function () {
+            id = 'scatter-plot-composite';
+            appendChartID(id);
+
+            compositeChart = dc.compositeChart('#' + id);
+            compositeChart
+                .dimension(dimension)
+                .x(d3.time.scale.utc().domain([makeDate(2012, 0, 1), makeDate(2012, 11, 31)]))
+                .transitionDuration(0)
+                .legend(dc.legend())
+                .compose([
+                    subChart1 = dc.scatterPlot(compositeChart).colors('red').group(group, 'Scatter 1'),
+                    subChart2 = dc.scatterPlot(compositeChart).colors('blue').group(group, 'Scatter 2')
+                ]).render();
+
+            firstItem = compositeChart.select('g.dc-legend g.dc-legend-item');
+        });
+
+        it('should provide a composite chart with corresponding legend data', function () {
+            expect(compositeChart.legendables()).toEqual([
+                {chart: subChart1, name: 'Scatter 1', color: 'red'},
+                {chart: subChart2, name: 'Scatter 2', color: 'blue'}
+            ]);
+        });
+
+        describe('hovering', function () {
+            beforeEach(function () {
+                firstItem.on('mouseover')(firstItem.datum());
+            });
+
+            describe('when a legend item is hovered over', function () {
+                it('should highlight corresponding plot', function () {
+                    nthChart(0).expectPlotSymbolsToHaveSize(chart.highlightedSize());
+
+                });
+
+                it('should fade out non-corresponding lines and areas', function () {
+                    nthChart(1).expectPlotSymbolsToHaveClass('fadeout');
+                });
+            });
+
+            describe('when a legend item is hovered out', function () {
+                beforeEach(function () {
+                    firstItem.on('mouseout')(firstItem.datum());
+                });
+
+                it('should remove highlighting from corresponding lines and areas', function () {
+                    nthChart(0).expectPlotSymbolsToHaveSize(chart.symbolSize());
+                });
+
+                it('should fade in non-corresponding lines and areas', function () {
+                    nthChart(1).expectPlotSymbolsNotToHaveClass('fadeout');
+                });
+            });
+        });
+
+        function nthChart (n) {
+            var subChart = d3.select(compositeChart.selectAll('g.sub')[0][n]);
+
+            subChart.expectPlotSymbolsToHaveClass = function (className) {
+                subChart.selectAll('path.symbol').each(function () {
+                    expect(d3.select(this).classed(className)).toBeTruthy();
+                });
+            };
+
+            subChart.expectPlotSymbolsToHaveSize = function (size) {
+                var highlightedSize = Math.pow(size, 2);
+                var highlightedPath = d3.svg.symbol().size(highlightedSize)();
+                subChart.selectAll('path.symbol').each(function () {
+                    expect(d3.select(this).attr('d')).toMatchPath(highlightedPath);
+                });
+            };
+
+            subChart.expectPlotSymbolsNotToHaveClass = function (className) {
+                subChart.selectAll('path.symbol').each(function () {
+                    expect(d3.select(this).classed(className)).toBeFalsy();
+                });
+            };
+
+            return subChart;
+        }
+    });
+});
+