mdarray-sol 0.1.0-java

data/node_modules/dc/spec/core-spec.js

@@ -0,0 +1,301 @@
+/* global loadDateFixture */
+describe('dc.core', function () {
+    var valueDimension, valueGroup;
+
+    beforeEach(function () {
+        var data = crossfilter(loadDateFixture());
+        valueDimension = data.dimension(function (d) {
+            return d.value;
+        });
+        valueGroup = valueDimension.group();
+    });
+
+    describe('version', function () {
+        it('should use semantic versions', function () {
+            // from https://raw.github.com/coolaj86/semver-utils/v1.0.3/semver-utils.js
+            //               |optional 'v'
+            //               | | 3 segment version
+            //               | |                    |optional release prefixed by '-'
+            //               | |                    |                                        |optional build prefixed by '+'
+            var reSemver = /^v?((\d+)\.(\d+)\.(\d+))(?:-([\dA-Za-z\-]+(?:\.[\dA-Za-z\-]+)*))?(?:\+([\dA-Za-z\-]+(?:\.[\dA-Za-z\-]+)*))?$/;
+            expect(dc.version).toMatch(reSemver);
+        });
+    });
+
+    describe('charts', function () {
+        var chart;
+        beforeEach(function () {
+            chart = dc.pieChart('#id')
+                    .dimension(valueDimension)
+                    .group(valueGroup);
+            spyOn(chart, 'filterAll');
+            spyOn(chart, 'render');
+            spyOn(chart, 'redraw');
+            return chart;
+        });
+
+        it('should register chart object', function () {
+            expect(dc.hasChart(chart)).toBeTruthy();
+        });
+
+        it('filterAll should invoke filter on each chart', function () {
+            dc.filterAll();
+            expect(chart.filterAll).toHaveBeenCalled();
+        });
+
+        it('renderAll should invoke filter on each chart', function () {
+            dc.renderAll();
+            expect(chart.render).toHaveBeenCalled();
+        });
+
+        it('should be gone after remove all', function () {
+            dc.deregisterAllCharts();
+            expect(dc.hasChart(chart)).toBeFalsy();
+        });
+    });
+
+    describe('chartsRegistry', function () {
+        var chart;
+        var chartGrouped;
+        var chartGroup = 'testChartGroup';
+        beforeEach(function () {
+            chart = dc.pieChart('#id')
+                    .dimension(valueDimension)
+                    .group(valueGroup);
+            chartGrouped = dc.pieChart('#id2',chartGroup)
+                    .dimension(valueDimension)
+                    .group(valueGroup);
+            return chart;
+        });
+
+        it('should register chart object', function () {
+            expect(dc.hasChart(chart)).toBeTruthy();
+        });
+
+        it('should not have ungrouped chart after remove', function () {
+            dc.deregisterChart(chart);
+            expect(dc.hasChart(chart)).toBeFalsy();
+        });
+
+        it('should not have grouped chart after remove', function () {
+            dc.deregisterChart(chartGrouped, chartGroup);
+            expect(dc.hasChart(chartGrouped)).toBeFalsy();
+        });
+
+        it('should have switched to an existing group', function () {
+            chart.chartGroup(chartGroup);
+            expect(dc.hasChart(chart)).toBeTruthy();
+            expect(dc.chartRegistry.list(chartGroup).indexOf(chart) > -1).toBeTruthy();
+            expect(dc.chartRegistry.list(null).indexOf(chart) > -1).toBeFalsy();
+        });
+
+        it('should have switched to the global group', function () {
+            chart.chartGroup(null);
+            expect(dc.hasChart(chart)).toBeTruthy();
+            expect(dc.chartRegistry.list(chartGroup).indexOf(chart) > -1).toBeFalsy();
+            expect(dc.chartRegistry.list(null).indexOf(chart) > -1).toBeTruthy();
+        });
+    });
+
+    describe('transition', function () {
+        var selections;
+
+        beforeEach(function () {
+            selections = {
+                transition: function () {
+                    return this;
+                },
+                duration: function () {
+                    return this;
+                }
+            };
+            spyOn(selections, 'transition').and.callThrough();
+            spyOn(selections, 'duration').and.callThrough();
+        });
+
+        describe('normal', function () {
+            it('transition should be activated with duration', function () {
+                dc.transition(selections, 100);
+                expect(selections.transition).toHaveBeenCalled();
+                expect(selections.duration).toHaveBeenCalled();
+            });
+
+            it('transition callback should be triggered', function () {
+                var triggered = false;
+                dc.transition(selections, 100, function () {
+                    triggered = true;
+                });
+                expect(triggered).toBeTruthy();
+            });
+        });
+
+        describe('skip', function () {
+            it('transition should not be activated with 0 duration', function () {
+                dc.transition(selections, 0);
+                expect(selections.transition).not.toHaveBeenCalled();
+                expect(selections.duration).not.toHaveBeenCalled();
+            });
+
+            it('transition callback should not be triggered', function () {
+                var triggered = false;
+                dc.transition(selections, 0, function () {
+                    triggered = true;
+                });
+                expect(triggered).toBeFalsy();
+            });
+        });
+    });
+
+    describe('units', function () {
+        describe('.integers', function () {
+            var result;
+            beforeEach(function () {
+                result = dc.units.integers(0, 100);
+            });
+            it('units should be based on subtraction', function () {
+                expect(result).toEqual(100);
+            });
+        });
+
+        describe('.float', function () {
+            var result;
+            beforeEach(function () {
+                result = dc.units.fp.precision(0.001)(0.49999, 1.0);
+            });
+            it('units should be generated according to the precision', function () {
+                expect(result).toEqual(501);
+            });
+        });
+
+        describe('.ordinal', function () {
+            var result;
+            beforeEach(function () {
+                result = dc.units.ordinal('a', 'd', ['a', 'b', 'c', 'd']);
+            });
+            it('units should be based on count', function () {
+                expect(result.length).toEqual(4);
+            });
+        });
+    });
+
+    describe('round', function () {
+        describe('.floor', function () {
+            var result;
+            beforeEach(function () {
+                result = dc.round.floor(0.33);
+            });
+            it('should floored number', function () {
+                expect(result).toEqual(0);
+            });
+        });
+    });
+
+    describe('override', function () {
+        var o;
+
+        beforeEach(function () {
+            o = {foo: function () {
+                return 'foo';
+            }, goo: function (i) {
+                return i;
+            }};
+        });
+
+        it('wo/ override function should work as expected', function () {
+            expect(o.foo()).toEqual('foo');
+        });
+
+        it('should expose existing function', function () {
+            dc.override(o, 'foo', function () {
+                return this._foo() + '2';
+            });
+
+            expect(o.foo()).toEqual('foo2');
+        });
+
+        it('should expose existing function with args', function () {
+            dc.override(o, 'goo', function (i) {
+                return this._goo(i) + 2;
+            });
+
+            expect(o.goo(1)).toEqual(3);
+        });
+    });
+
+    describe('charts w/ grouping', function () {
+        var chart;
+
+        beforeEach(function () {
+            chart = dc.pieChart('#a', 'groupA').dimension(valueDimension).group(valueGroup);
+            spyOn(chart, 'filterAll');
+            spyOn(chart, 'render');
+            dc.pieChart('#b', 'groupA').dimension(valueDimension).group(valueGroup);
+            dc.bubbleChart('#c', 'groupB').dimension(valueDimension).group(valueGroup);
+            dc.barChart('#b1', 'groupB').dimension(valueDimension).group(valueGroup);
+            dc.lineChart('#b2', 'groupB').dimension(valueDimension).group(valueGroup);
+            dc.dataCount('#b3', 'groupB').dimension(valueDimension).group(valueGroup);
+            dc.dataTable('#b4', 'groupB').dimension(valueDimension).group(valueGroup);
+            return chart;
+        });
+
+        it('should register chart object', function () {
+            expect(dc.hasChart(chart)).toBeTruthy();
+        });
+
+        it('filterAll by group should invoke filter on each chart within the group', function () {
+            dc.filterAll('groupA');
+            expect(chart.filterAll).toHaveBeenCalled();
+        });
+
+        it('renderAll by group should invoke filter on each chart within the group', function () {
+            dc.renderAll('groupA');
+            expect(chart.render).toHaveBeenCalled();
+        });
+
+        it('filterAll should not invoke filter on chart in groupA', function () {
+            dc.filterAll();
+            expect(chart.filterAll).not.toHaveBeenCalled();
+        });
+
+        it('renderAll should not invoke filter on chart in groupA', function () {
+            dc.renderAll();
+            expect(chart.render).not.toHaveBeenCalled();
+        });
+
+        it('should be gone after remove all', function () {
+            dc.deregisterAllCharts();
+            expect(dc.hasChart(chart)).toBeFalsy();
+        });
+    });
+
+    describe('render/redraw all call back', function () {
+        var result;
+
+        beforeEach(function () {
+            dc.renderlet(function (group) {
+                result.called = group ? group : true;
+            });
+            result = {called: false};
+        });
+
+        it('renderAll call back should be triggered', function () {
+            dc.renderAll();
+            expect(result.called).toBeTruthy();
+        });
+
+        it('redrawAll call back should be triggered', function () {
+            dc.redrawAll();
+            expect(result.called).toBeTruthy();
+        });
+
+        it('renderAll by group call back should be triggered', function () {
+            dc.renderAll('group');
+            expect('group').toEqual(result.called);
+        });
+
+        it('redrawAll by group call back should be triggered', function () {
+            dc.redrawAll('group');
+            expect('group').toEqual(result.called);
+        });
+    });
+});

data/node_modules/dc/spec/data-addition-spec.js

@@ -0,0 +1,122 @@
+/* global appendChartID, loadDateFixture, loadDateFixture2, makeDate */
+describe('Dynamic data addition in crossfilter', function () {
+    var width = 200;
+    var height = 200;
+    var radius = 100;
+    var baseData, moreData;
+
+    beforeEach(function () {
+        baseData = crossfilter(loadDateFixture());
+        moreData = loadDateFixture2();
+    });
+
+    function occurrences (str, value) {
+        return (str.split(value)).length - 1;
+    }
+
+    describe('pie chart slice addition', function () {
+        var valueDimension, valueGroup;
+        var chart;
+        function buildPieChart (id) {
+            var div = appendChartID(id);
+            div.append('a').attr('class', 'reset').style('display', 'none');
+            div.append('span').attr('class', 'filter').style('display', 'none');
+            var chart = dc.pieChart('#' + id);
+            chart.dimension(valueDimension).group(valueGroup)
+                .width(width)
+                .height(height)
+                .radius(radius)
+                .transitionDuration(0);
+            chart.render();
+            baseData.add(moreData);
+            chart.expireCache();
+            return chart;
+        }
+        beforeEach(function () {
+            valueDimension = baseData.dimension(function (d) {
+                return d.value;
+            });
+            valueGroup = valueDimension.group();
+            chart = buildPieChart('pie-chart');
+            chart.redraw();
+        });
+        it('slice g should be created with class', function () {
+            expect(chart.selectAll('svg g g.pie-slice').data().length).toEqual(7);
+        });
+        it('slice path should be created', function () {
+            expect(chart.selectAll('svg g g.pie-slice path').data().length).toEqual(7);
+        });
+        it('default function should be used to dynamically generate label', function () {
+            expect(d3.select(chart.selectAll('text.pie-slice')[0][0]).text()).toEqual('11');
+        });
+        it('pie chart slices should be in numerical order', function () {
+            expect(chart.selectAll('text.pie-slice').data().map(function (slice) { return slice.data.key; }))
+                .toEqual(['11','22','33','44','55','66','76']);
+        });
+        it('default function should be used to dynamically generate title', function () {
+            expect(d3.select(chart.selectAll('g.pie-slice title')[0][0]).text()).toEqual('11: 1');
+        });
+        afterEach(function () {
+            valueDimension.filterAll();
+        });
+    });
+    describe('line chart segment addition', function () {
+        var timeDimension, timeGroup;
+        var chart;
+        function buildLineChart (id) {
+            appendChartID(id);
+            var chart = dc.lineChart('#' + id);
+            chart.dimension(timeDimension).group(timeGroup)
+                .width(width).height(height)
+                .x(d3.time.scale.utc().domain([makeDate(2012, 4, 20), makeDate(2012, 7, 15)]))
+                .transitionDuration(0)
+                .xUnits(d3.time.days.utc)
+                .brushOn(false)
+                .renderArea(true)
+                .renderTitle(true);
+            chart.render();
+            baseData.add(moreData);
+            chart.expireCache();
+            return chart;
+        }
+        beforeEach(function () {
+            timeDimension = baseData.dimension(function (d) {
+                return d.dd;
+            });
+            timeGroup = timeDimension.group();
+            chart = buildLineChart('line-chart');
+            chart.render();
+        });
+        it('number of dots should equal the size of the group', function () {
+            expect(chart.selectAll('circle.dot')[0].length).toEqual(timeGroup.size());
+        });
+        it('number of line segments should equal the size of the group', function () {
+            var path = chart.selectAll('path.line').attr('d');
+            expect(occurrences(path, 'L') + 1).toEqual(timeGroup.size());
+        });
+        it('number of area segments should equal twice the size of the group', function () {
+            var path = chart.selectAll('path.area').attr('d');
+            expect(occurrences(path, 'L') + 1).toEqual(timeGroup.size() * 2);
+        });
+
+        describe('resetting line chart with fewer data points', function () {
+            beforeEach(function () {
+                var chart = buildLineChart('stackable-line-chart');
+                chart.render();
+
+                timeDimension.filterAll();
+                baseData.remove();
+                baseData.add(moreData);
+                chart.render();
+            });
+
+            it('it should not contain stale data points', function () {
+                expect(chart.data()[0].values.length).toEqual(2);
+            });
+        });
+
+        afterEach(function () {
+            timeDimension.filterAll();
+        });
+    });
+});

data/node_modules/dc/spec/data-count-spec.js

@@ -0,0 +1,180 @@
+/* global appendChartID, loadDateFixture */
+describe('dc.dataCount', function () {
+    var data, countryDimension, groupAll;
+    var chart;
+    beforeEach(function () {
+        data = crossfilter(loadDateFixture());
+        groupAll = data.groupAll();
+        countryDimension = data.dimension(function (d) {
+            return d.countrycode;
+        });
+        countryDimension.filter('CA');
+    });
+    function buildChart (id) {
+        var chart = dc.dataCount('#' + id)
+            .transitionDuration(0)
+            .dimension(data)
+            .group(groupAll);
+        chart.render();
+        d3.timer.flush();
+        return chart;
+    }
+    describe('creation', function () {
+        beforeEach(function () {
+            var id = 'data-count';
+            var div = appendChartID(id);
+            div.append('span').attr('class', 'filter-count');
+            div.append('span').attr('class', 'total-count');
+            chart = buildChart(id);
+        });
+        it('should generate something', function () {
+            expect(chart).not.toBeNull();
+        });
+        it('should be registered', function () {
+            expect(dc.hasChart(chart)).toBeTruthy();
+        });
+        it('should fill in the total count', function () {
+            expect(chart.select('span.total-count').text()).toEqual('10');
+        });
+        it('should fill in the filter count', function () {
+            expect(chart.select('span.filter-count').text()).toEqual('2');
+        });
+        describe('redraw', function () {
+            beforeEach(function () {
+                countryDimension.filterAll();
+                chart.redraw();
+                return chart;
+            });
+            it('should fill in the updated total count', function () {
+                expect(chart.select('span.total-count').text()).toEqual('10');
+            });
+            it('should fill in the updated filter count', function () {
+                expect(chart.select('span.filter-count').text()).toEqual('10');
+            });
+        });
+        afterEach(function () {
+            countryDimension.filterAll();
+        });
+    });
+
+    describe('creation with html attribute', function () {
+        beforeEach(function () {
+            var id = 'data-count';
+            var div = appendChartID(id);
+            div.append('span').attr('class', 'filter-count');
+            div.append('span').attr('class', 'total-count');
+            chart = buildChart(id);
+            chart.html({some: '%filter-count selected from %total-count',all: 'All Records Selected'});
+            chart.redraw();
+        });
+        it('should generate something', function () {
+            expect(chart).not.toBeNull();
+        });
+        it('should be registered', function () {
+            expect(dc.hasChart(chart)).toBeTruthy();
+        });
+        it('should fill the element replacing %filter-count and %total-count', function () {
+            expect(chart.root().text()).toEqual('2 selected from 10');
+        });
+        describe('when all selected', function () {
+            beforeEach(function () {
+                countryDimension.filterAll();
+                chart.redraw();
+                return chart;
+            });
+            it('should use html.all', function () {
+                expect(chart.root().text()).toEqual('All Records Selected');
+            });
+        });
+        afterEach(function () {
+            countryDimension.filterAll();
+        });
+    });
+
+    describe('creation with just html.some attribute', function () {
+        beforeEach(function () {
+            var id = 'data-count';
+            var div = appendChartID(id);
+            div.append('span').attr('class', 'filter-count');
+            div.append('span').attr('class', 'total-count');
+            chart = buildChart(id);
+            chart.html({some: '%filter-count selected from %total-count'});
+            chart.redraw();
+        });
+        it('should fill the element replacing %filter-count and %total-count', function () {
+            expect(chart.root().text()).toEqual('2 selected from 10');
+        });
+        describe('when all selected', function () {
+            beforeEach(function () {
+                countryDimension.filterAll();
+                chart.redraw();
+                return chart;
+            });
+            it('should use html.some for all', function () {
+                expect(chart.root().text()).toEqual('10 selected from 10');
+            });
+        });
+        afterEach(function () {
+            countryDimension.filterAll();
+        });
+    });
+
+    describe('creation with just html.all attribute', function () {
+        beforeEach(function () {
+            var id = 'data-count';
+            var div = appendChartID(id);
+            div.append('span').attr('class', 'filter-count');
+            div.append('span').attr('class', 'total-count');
+            chart = buildChart(id);
+            chart.html({all: 'All Records Selected'});
+            chart.redraw();
+        });
+        it('should fill in the total count', function () {
+            expect(chart.select('span.total-count').text()).toEqual('10');
+        });
+        it('should fill in the filter count', function () {
+            expect(chart.select('span.filter-count').text()).toEqual('2');
+        });
+        describe('when all selected', function () {
+            beforeEach(function () {
+                countryDimension.filterAll();
+                chart.redraw();
+                return chart;
+            });
+            it('should use html.all for all', function () {
+                expect(chart.root().text()).toEqual('All Records Selected');
+            });
+        });
+        afterEach(function () {
+            countryDimension.filterAll();
+        });
+    });
+
+    describe('creation with formatNumber attribute', function () {
+        beforeEach(function () {
+            var id = 'data-count';
+            var div = appendChartID(id);
+            div.append('span').attr('class', 'filter-count');
+            div.append('span').attr('class', 'total-count');
+            chart = buildChart(id);
+            chart.formatNumber(d3.format('04.1g'));
+            chart.redraw();
+        });
+        it('should generate something', function () {
+            expect(chart).not.toBeNull();
+        });
+        it('should be registered', function () {
+            expect(dc.hasChart(chart)).toBeTruthy();
+        });
+        it('should fill in the formatted total count', function () {
+            expect(chart.select('span.total-count').text()).toEqual('1e+1');
+        });
+        it('should fill in the formatted filter count', function () {
+            expect(chart.select('span.filter-count').text()).toEqual('0002');
+        });
+        afterEach(function () {
+            countryDimension.filterAll();
+        });
+    });
+
+});