iop
/
superset
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactor: remove unused code (#8300)

This commit is contained in:
Krist Wongsuphasawat 2019-09-30 16:57:35 -07:00 committed by Grace Guo
parent 25e2517dcb
commit d55fe54198
13 changed files with 11 additions and 502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
superset/assets/package.json
View File

@ -144,7 +144,6 @@
"redux-undo": "^1.0.0-beta9-9-7",
"regenerator-runtime": "^0.13.3",
"shortid": "^2.2.6",
"underscore": "^1.8.3",
"urijs": "^1.18.10"
},
"devDependencies": {

47
superset/assets/spec/javascripts/modules/colors_spec.jsx
View File

@ -1,47 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import { hexToRGB } from '../../../src/modules/colors';
describe('hexToRGB', () => {
it('is a function', () => {
expect(typeof hexToRGB).toBe('function');
});
it('hexToRGB converts properly', () => {
expect(hexToRGB('#FFFFFF')).toEqual(expect.arrayContaining([255, 255, 255, 255]));
expect(hexToRGB('#000000')).toEqual(expect.arrayContaining([0, 0, 0, 255]));
expect(hexToRGB('#FF0000')).toEqual(expect.arrayContaining([255, 0, 0, 255]));
expect(hexToRGB('#00FF00')).toEqual(expect.arrayContaining([0, 255, 0, 255]));
expect(hexToRGB('#0000FF')).toEqual(expect.arrayContaining([0, 0, 255, 255]));
});
it('works with falsy values', () => {
expect(hexToRGB()).toEqual([0, 0, 0, 255]);
/* eslint-disable quotes */
[false, 0, -0, 0.0, '', "", ``, null, undefined, NaN].forEach((value) => {
expect(hexToRGB(value)).toEqual(expect.arrayContaining([0, 0, 0, 255]));
});
});
it('takes and alpha argument', () => {
expect(hexToRGB('#FF0000', 128)).toEqual(expect.arrayContaining([255, 0, 0, 128]));
expect(hexToRGB('#000000', 100)).toEqual(expect.arrayContaining([0, 0, 0, 100]));
expect(hexToRGB('#ffffff', 0)).toEqual(expect.arrayContaining([255, 255, 255, 0]));
});
});

42
superset/assets/spec/javascripts/modules/geo_spec.jsx
View File

@ -1,42 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import { unitToRadius } from '../../../src/modules/geo';
const METER_TO_MILE = 1609.34;
describe('unitToRadius', () => {
it('converts to square meters', () => {
expect(unitToRadius('square_m', 4 * Math.PI)).toBe(2);
});
it('converts to square kilometers', () => {
expect(unitToRadius('square_km', 25 * Math.PI)).toBe(5000);
});
it('converts to radius meters', () => {
expect(unitToRadius('radius_m', 1000)).toBe(1000);
});
it('converts to radius km', () => {
expect(unitToRadius('radius_km', 1)).toBe(1000);
});
it('converts to radius miles', () => {
expect(unitToRadius('radius_miles', 1)).toBe(METER_TO_MILE);
});
it('converts to square miles', () => {
expect(unitToRadius('square_miles', 25 * Math.PI)).toBe(5000 * (METER_TO_MILE / 1000));
});
});

32
superset/assets/spec/javascripts/modules/sandbox_spec.jsx
View File

@ -1,32 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import sandboxedEval from '../../../src/modules/sandbox';
describe('sandboxedEval', () => {
it('works like a basic eval', () => {
expect(sandboxedEval('100')).toBe(100);
expect(sandboxedEval('v => v * 2')(5)).toBe(10);
});
it('d3 is in context and works', () => {
expect(sandboxedEval("l => _.find(l, s => s === 'bar')")(['foo', 'bar'])).toBe('bar');
});
it('passes context as expected', () => {
expect(sandboxedEval('foo', { foo: 'bar' })).toBe('bar');
});
});

99
superset/assets/spec/javascripts/modules/time_spec.js
View File

@ -1,99 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import moment from 'moment';
import { getPlaySliderParams, truncate } from '../../../src/modules/time';
describe('truncate', () => {
it('truncates timestamps', () => {
const timestamp = moment('2018-03-03T03:03:03.333');
const isoDurations = [
// basic units
[moment.duration('PT1S'), moment('2018-03-03T03:03:03')],
[moment.duration('PT1M'), moment('2018-03-03T03:03:00')],
[moment.duration('PT1H'), moment('2018-03-03T03:00:00')],
[moment.duration('P1D'), moment('2018-03-03T00:00:00')],
[moment.duration('P1M'), moment('2018-03-01T00:00:00')],
[moment.duration('P1Y'), moment('2018-01-01T00:00:00')],
// durations that are multiples
[moment.duration('PT2H'), moment('2018-03-03T02:00:00')],
[moment.duration('P2D'), moment('2018-03-03T00:00:00')],
];
let result;
isoDurations.forEach(([step, expected]) => {
result = truncate(timestamp, step);
expect(result.format()).toBe(expected.format());
});
});
});
describe('getPlaySliderParams', () => {
it('is a function', () => {
expect(typeof getPlaySliderParams).toBe('function');
});
it('handles durations', () => {
const timestamps = [
moment('2018-01-01T00:00:00'),
moment('2018-01-02T00:00:00'),
moment('2018-01-03T00:00:00'),
moment('2018-01-04T00:00:00'),
moment('2018-01-05T00:00:00'),
moment('2018-01-06T00:00:00'),
moment('2018-01-07T00:00:00'),
moment('2018-01-08T00:00:00'),
moment('2018-01-09T00:00:00'),
moment('2018-01-10T00:00:00'),
].map(d => parseInt(d.format('x'), 10));
const { start, end, getStep, values, disabled } = getPlaySliderParams(timestamps, 'P2D');
expect(moment(start).format()).toBe(moment('2018-01-01T00:00:00').format());
expect(moment(end).format()).toBe(moment('2018-01-11T00:00:00').format());
expect(getStep(start)).toBe(2 * 24 * 60 * 60 * 1000);
expect(values.map(v => moment(v).format())).toEqual([
moment('2018-01-01T00:00:00').format(),
moment('2018-01-03T00:00:00').format(),
]);
expect(disabled).toBe(false);
});
it('handles intervals', () => {
const timestamps = [
moment('2018-01-01T00:00:00'),
moment('2018-01-02T00:00:00'),
moment('2018-01-03T00:00:00'),
moment('2018-01-04T00:00:00'),
moment('2018-01-05T00:00:00'),
moment('2018-01-06T00:00:00'),
moment('2018-01-07T00:00:00'),
moment('2018-01-08T00:00:00'),
moment('2018-01-09T00:00:00'),
moment('2018-01-10T00:00:00'),
].map(d => parseInt(d.format('x'), 10));
// 1970-01-03 was a Saturday
const { start, end, getStep, values, disabled } = getPlaySliderParams(timestamps, 'P1W/1970-01-03T00:00:00Z');
expect(moment(start).format()).toBe(moment('2017-12-30T00:00:00Z').format()); // Saturday
expect(moment(end).format()).toBe(moment('2018-01-13T00:00:00Z').format()); // Saturday
expect(getStep(start)).toBe(7 * 24 * 60 * 60 * 1000);
expect(values.map(v => moment(v).format())).toEqual([
moment('2017-12-30T00:00:00Z').format(),
moment('2018-01-06T00:00:00Z').format(),
]);
expect(disabled).toBe(false);
});
});

8
superset/assets/spec/javascripts/modules/utils_spec.jsx
View File

@ -19,7 +19,6 @@
import {
formatSelectOptionsForRange,
mainMetric,
roundDecimal,
} from '../../../src/modules/utils';
describe('utils', () => {
@ -66,11 +65,4 @@ describe('utils', () => {
expect(mainMetric(metrics)).toBe('foo');
});
});
describe('roundDecimal', () => {
it('rounding method to limit the number of decimal digits', () => {
expect(roundDecimal(1.139, 2)).toBe(1.14);
expect(roundDecimal(1.13929, 3)).toBe(1.139);
expect(roundDecimal(1.13929)).toBe(1);
});
});
});

11
superset/assets/src/explore/components/controls/ViewportControl.jsx
View File

@ -23,7 +23,14 @@ import { decimal2sexagesimal } from 'geolib';
import TextControl from './TextControl';
import ControlHeader from '../ControlHeader';
import { defaultViewport } from '../../../modules/geo';
export const DEFAULT_VIEWPORT = {
longitude: 6.85236157047845,
latitude: 31.222656842808707,
zoom: 1,
bearing: 0,
pitch: 0,
};
const PARAMS = [
'longitude',
@ -49,7 +56,7 @@ const propTypes = {
const defaultProps = {
onChange: () => {},
default: { type: 'fix', value: 5 },
value: defaultViewport,
value: DEFAULT_VIEWPORT,
};
export default class ViewportControl extends React.Component {

4
superset/assets/src/explore/controls.jsx
View File

@ -66,9 +66,9 @@ import {
mainMetric,
} from '../modules/utils';
import * as v from './validators';
import { defaultViewport } from '../modules/geo';
import ColumnOption from '../components/ColumnOption';
import OptionDescription from '../components/OptionDescription';
import { DEFAULT_VIEWPORT } from '../explore/components/controls/ViewportControl';
const categoricalSchemeRegistry = getCategoricalSchemeRegistry();
const sequentialSchemeRegistry = getSequentialSchemeRegistry();
@ -1866,7 +1866,7 @@ export const controls = {
renderTrigger: false,
description: t('Parameters related to the view and perspective on the map'),
// default is whole world mostly centered
default: defaultViewport,
default: DEFAULT_VIEWPORT,
// Viewport changes shouldn't prompt user to re-run query
dontRefreshOnChange: true,
},

27
superset/assets/src/modules/colors.js
View File

@ -1,27 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import { rgb } from 'd3-color';
export function hexToRGB(hex, alpha = 255) {
if (!hex) {
return [0, 0, 0, alpha];
}
const { r, g, b } = rgb(hex);
return [r, g, b, alpha];
}

57
superset/assets/src/modules/geo.js
View File

@ -1,57 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import { roundDecimal } from '../modules/utils';
export const defaultViewport = {
longitude: 6.85236157047845,
latitude: 31.222656842808707,
zoom: 1,
bearing: 0,
pitch: 0,
};
const METER_TO_MILE = 1609.34;
export function unitToRadius(unit, num) {
if (unit === 'square_m') {
return Math.sqrt(num / Math.PI);
} else if (unit === 'radius_m') {
return num;
} else if (unit === 'radius_km') {
return num * 1000;
} else if (unit === 'radius_miles') {
return num * METER_TO_MILE;
} else if (unit === 'square_km') {
return Math.sqrt(num / Math.PI) * 1000;
} else if (unit === 'square_miles') {
return Math.sqrt(num / Math.PI) * METER_TO_MILE;
}
return null;
}
export const EARTH_CIRCUMFERENCE_KM = 40075.16;
export const MILES_PER_KM = 1.60934;
export function kmToPixels(kilometers, latitude, zoomLevel) {
// Algorithm from: https://wiki.openstreetmap.org/wiki/Zoom_levels
const latitudeRad = latitude * (Math.PI / 180);
// Seems like the zoomLevel is off by one
const kmPerPixel = (EARTH_CIRCUMFERENCE_KM * Math.cos(latitudeRad)) / Math.pow(2, zoomLevel + 9);
return roundDecimal(kilometers / kmPerPixel, 2);
}

51
superset/assets/src/modules/sandbox.js
View File

@ -1,51 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
// A safe alternative to JS's eval
import vm from 'vm';
import _ from 'underscore';
import * as d3array from 'd3-array';
import * as colors from './colors';
// Objects exposed here should be treated like a public API
// if `underscore` had backwards incompatible changes in a future release, we'd
// have to be careful about bumping the library as those changes could break user charts
const GLOBAL_CONTEXT = {
console,
_,
colors,
d3array,
};
// Copied/modified from https://github.com/hacksparrow/safe-eval/blob/master/index.js
export default function sandboxedEval(code, context, opts) {
const sandbox = {};
const resultKey = 'SAFE_EVAL_' + Math.floor(Math.random() * 1000000);
sandbox[resultKey] = {};
const codeToEval = resultKey + '=' + code;
const sandboxContext = { ...GLOBAL_CONTEXT, ...context };
Object.keys(sandboxContext).forEach(function (key) {
sandbox[key] = sandboxContext[key];
});
try {
vm.runInNewContext(codeToEval, sandbox, opts);
return sandbox[resultKey];
} catch (error) {
return () => error;
}
}

124
superset/assets/src/modules/time.js
View File

@ -1,124 +0,0 @@
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
import moment from 'moment';
// array with the minimum values of each part of a timestamp -- note that
// months are zero-indexed in Javascript
const truncatePartTo = [
1, // year
0, // month
1, // day
0, // hour
0, // minute
0, // second
0, // millisecond
];
export function truncate(timestamp, step) {
/*
* Truncate timestamp down to duration resolution.
*/
const lowerBound = moment(timestamp).subtract(step);
const explodedTimestamp = timestamp.toArray();
const explodedLowerBound = lowerBound.toArray();
const firstDiffIndex = explodedTimestamp
.map((part, i) => (explodedLowerBound[i] !== part))
.indexOf(true);
const dateParts = explodedTimestamp.map((part, i) => {
if (i === firstDiffIndex) {
// truncate down to closest `truncatePartTo[i] + n * step`
const difference = part - explodedLowerBound[i];
return part - ((part - truncatePartTo[i]) % difference);
} else if (i < firstDiffIndex || firstDiffIndex === -1) {
return part;
}
return truncatePartTo[i];
});
return moment(dateParts);
}
function getStepSeconds(step, start) {
/* Return number of seconds in a step.
*
* The step might be ambigous, eg, "1 month" has a variable number of
* seconds, which is why we need to know the start time.
*/
const startMillliseconds = parseInt(moment(start).format('x'), 10);
const endMilliseconds = parseInt(moment(start).add(step).format('x'), 10);
return endMilliseconds - startMillliseconds;
}
export const getPlaySliderParams = function (timestamps, timeGrain) {
const minTimestamp = moment(Math.min(...timestamps));
const maxTimestamp = moment(Math.max(...timestamps));
let step;
let reference;
if (timeGrain.indexOf('/') !== -1) {
// Here, time grain is a time interval instead of a simple duration, either
// `reference/duration` or `duration/reference`. We need to parse the
// duration and make sure that start and end are in the right places. For
// example, if `reference` is a Saturday and `duration` is 1 week (P1W)
// then both start and end should be Saturdays.
const parts = timeGrain.split('/', 2);
if (parts[0].endsWith('Z')) { // ISO string
reference = moment(parts[0]);
step = moment.duration(parts[1]);
} else {
reference = moment(parts[1]);
step = moment.duration(parts[0]);
}
} else {
step = moment.duration(timeGrain);
reference = truncate(minTimestamp, step);
}
// find the largest `reference + n * step` smaller than the minimum timestamp
const start = moment(reference);
while (start < minTimestamp) {
start.add(step);
}
while (start > minTimestamp) {
start.subtract(step);
}
// find the smallest `reference + n * step` larger than the maximum timestamp
const end = moment(reference);
while (end > maxTimestamp) {
end.subtract(step);
}
while (end < maxTimestamp) {
end.add(step);
}
const values = timeGrain != null ? [start, moment(start).add(step)] : [start, end];
const disabled = timestamps.every(timestamp => timestamp === null);
return {
start: parseInt(start.format('x'), 10),
end: parseInt(end.format('x'), 10),
getStep: getStepSeconds.bind(this, step),
values: values.map(v => parseInt(v.format('x'), 10)),
disabled,
};
};

10
superset/assets/src/modules/utils.js
View File

@ -86,13 +86,3 @@ export function mainMetric(savedMetrics) {
}
return metric;
}
export function roundDecimal(number, precision) {
let roundedNumber;
if (precision) {
roundedNumber = Math.round(number * (precision = Math.pow(10, precision))) / precision;
} else {
roundedNumber = Math.round(number);
}
return roundedNumber;
}