Increase code coverage

pull/940/head
Rich Harris 7 years ago committed by GitHub
parent d590dbe165
commit 0a01aa0243
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -83,10 +83,6 @@ export default function visitWindow(
const associatedEvent = associatedEvents[attribute.name];
if (!associatedEvent) {
throw new Error(`Cannot bind to ${attribute.name} on <:Window>`);
}
if (!events[associatedEvent]) events[associatedEvent] = [];
events[associatedEvent].push(
`${attribute.value.name}: this.${attribute.name}`

@ -7,7 +7,4 @@ export default function isChildOfComponent(node: Node, generator: Generator) {
if (generator.components.has(node.name)) return true;
if (/-/.test(node.name)) return false;
}
// TODO do this in validation
throw new Error(`Element with a slot='...' attribute must be a descendant of a component or custom element`);
}

@ -1,4 +1,5 @@
import deindent from '../../../utils/deindent';
import list from '../../../utils/list';
import { CompileOptions, ModuleFormat, Node } from '../../../interfaces';
interface Dependency {
@ -65,7 +66,7 @@ export default function wrapModule(
if (format === 'umd') return umd(code, name, options, banner, dependencies);
if (format === 'eval') return expr(code, name, options, banner, dependencies);
throw new Error(`Not implemented: ${format}`);
throw new Error(`options.format is invalid (must be ${list(Object.keys(wrappers))})`);
}
function es(

@ -1,6 +1,6 @@
import * as namespaces from '../../utils/namespaces';
import validateEventHandler from './validateEventHandler';
import { Validator } from '../index';
import validate, { Validator } from '../index';
import { Node } from '../../interfaces';
const svg = /^(?:altGlyph|altGlyphDef|altGlyphItem|animate|animateColor|animateMotion|animateTransform|circle|clipPath|color-profile|cursor|defs|desc|discard|ellipse|feBlend|feColorMatrix|feComponentTransfer|feComposite|feConvolveMatrix|feDiffuseLighting|feDisplacementMap|feDistantLight|feDropShadow|feFlood|feFuncA|feFuncB|feFuncG|feFuncR|feGaussianBlur|feImage|feMerge|feMergeNode|feMorphology|feOffset|fePointLight|feSpecularLighting|feSpotLight|feTile|feTurbulence|filter|font|font-face|font-face-format|font-face-name|font-face-src|font-face-uri|foreignObject|g|glyph|glyphRef|hatch|hatchpath|hkern|image|line|linearGradient|marker|mask|mesh|meshgradient|meshpatch|meshrow|metadata|missing-glyph|mpath|path|pattern|polygon|polyline|radialGradient|rect|set|solidcolor|stop|switch|symbol|text|textPath|title|tref|tspan|unknown|use|view|vkern)$/;
@ -191,22 +191,7 @@ export default function validateElement(
}
if (attribute.name === 'slot' && !isComponent) {
let i = stack.length;
while (i--) {
const parent = stack[i];
if (parent.type === 'Element' && validator.components.has(parent.name)) break;
if (parent.type === 'IfBlock' || parent.type === 'EachBlock') {
const message = `Cannot place slotted elements inside an ${parent.type === 'IfBlock' ? 'if' : 'each'}-block`;
validator.error(message, attribute.start);
}
}
if (isDynamic(attribute)) {
validator.error(
`slot attribute cannot have a dynamic value`,
attribute.start
);
}
checkSlotAttribute(validator, node, attribute, stack);
}
}
});
@ -232,6 +217,32 @@ function checkTypeAttribute(validator: Validator, node: Node) {
return attribute.value[0].data;
}
function checkSlotAttribute(validator: Validator, node: Node, attribute: Node, stack: Node[]) {
if (isDynamic(attribute)) {
validator.error(
`slot attribute cannot have a dynamic value`,
attribute.start
);
}
let i = stack.length;
while (i--) {
const parent = stack[i];
if (parent.type === 'Element') {
// if we're inside a component or a custom element, gravy
if (validator.components.has(parent.name)) return;
if (/-/.test(parent.name)) return;
}
if (parent.type === 'IfBlock' || parent.type === 'EachBlock') {
const message = `Cannot place slotted elements inside an ${parent.type === 'IfBlock' ? 'if' : 'each'}-block`;
validator.error(message, attribute.start);
}
}
validator.error(`Element with a slot='...' attribute must be a descendant of a component or custom element`, attribute.start);
}
function isDynamic(attribute: Node) {
return attribute.value.length > 1 || attribute.value[0].type !== 'Text';
}

@ -1,5 +1,5 @@
import flattenReference from '../../utils/flattenReference';
import list from '../utils/list';
import list from '../../utils/list';
import { Validator } from '../index';
import validCalleeObjects from '../../utils/validCalleeObjects';
import { Node } from '../../interfaces';

@ -1,6 +1,6 @@
import flattenReference from '../../utils/flattenReference';
import fuzzymatch from '../utils/fuzzymatch';
import list from '../utils/list';
import list from '../../utils/list';
import validateEventHandler from './validateEventHandler';
import { Validator } from '../index';
import { Node } from '../../interfaces';

@ -10,7 +10,6 @@ export default function components(validator: Validator, prop: Node) {
`The 'components' property must be an object literal`,
prop.start
);
return;
}
checkForDupes(validator, prop.value.properties);

@ -14,7 +14,6 @@ export default function computed(validator: Validator, prop: Node) {
`The 'computed' property must be an object literal`,
prop.start
);
return;
}
checkForDupes(validator, prop.value.properties);
@ -26,7 +25,6 @@ export default function computed(validator: Validator, prop: Node) {
`Computed properties can be function expressions or arrow function expressions`,
computation.value.start
);
return;
}
const params = computation.value.params;
@ -36,7 +34,6 @@ export default function computed(validator: Validator, prop: Node) {
`A computed value must depend on at least one property`,
computation.value.start
);
return;
}
params.forEach((param: Node) => {

@ -9,7 +9,6 @@ export default function events(validator: Validator, prop: Node) {
`The 'events' property must be an object literal`,
prop.start
);
return;
}
checkForDupes(validator, prop.value.properties);

@ -10,7 +10,6 @@ export default function helpers(validator: Validator, prop: Node) {
`The 'helpers' property must be an object literal`,
prop.start
);
return;
}
checkForDupes(validator, prop.value.properties);

@ -14,7 +14,6 @@ export default function methods(validator: Validator, prop: Node) {
`The 'methods' property must be an object literal`,
prop.start
);
return;
}
checkForAccessors(validator, prop.value.properties, 'Methods');

@ -9,7 +9,6 @@ export default function transitions(validator: Validator, prop: Node) {
`The 'transitions' property must be an object literal`,
prop.start
);
return;
}
checkForDupes(validator, prop.value.properties);

@ -157,6 +157,51 @@ describe("formats", () => {
return testIife(code, "Foo", { answer: 42 }, `<div>42</div>`);
});
it('requires options.name', () => {
assert.throws(() => {
svelte.compile('', {
format: 'iife'
});
}, /Missing required 'name' option for IIFE export/);
});
it('suggests using options.globals for default imports', () => {
const warnings = [];
svelte.compile(`
<script>
import _ from 'lodash';
</script>
`,
{
format: 'iife',
name: 'App',
onwarn: warning => {
warnings.push(warning);
}
}
);
assert.deepEqual(warnings, [{
message: `No name was supplied for imported module 'lodash'. Guessing '_', but you should use options.globals`
}]);
});
it('insists on options.globals for named imports', () => {
assert.throws(() => {
svelte.compile(`
<script>
import { fade } from 'svelte-transitions';
</script>
`,
{
format: 'iife',
name: 'App'
}
);
}, /Could not determine name for imported module 'svelte-transitions' use options.globals/);
});
});
describe("umd", () => {
@ -190,6 +235,14 @@ describe("formats", () => {
testCjs(code, { answer: 42 }, `<div>42</div>`);
testIife(code, "Foo", { answer: 42 }, `<div>42</div>`);
});
it('requires options.name', () => {
assert.throws(() => {
svelte.compile('', {
format: 'umd'
});
}, /Missing required 'name' option for UMD export/);
});
});
describe("eval", () => {
@ -218,4 +271,14 @@ describe("formats", () => {
return testEval(code, "Foo", { answer: 42 }, `<div>42</div>`);
});
});
describe('unknown format', () => {
it('throws an error', () => {
assert.throws(() => {
svelte.compile('', {
format: 'nope'
});
}, /options.format is invalid \(must be es, amd, cjs, iife, umd or eval\)/);
});
});
});

@ -0,0 +1,256 @@
function noop() {}
function assign(target) {
var k,
source,
i = 1,
len = arguments.length;
for (; i < len; i++) {
source = arguments[i];
for (k in source) target[k] = source[k];
}
return target;
}
function appendNode(node, target) {
target.appendChild(node);
}
function insertNode(node, target, anchor) {
target.insertBefore(node, anchor);
}
function detachNode(node) {
node.parentNode.removeChild(node);
}
function createElement(name) {
return document.createElement(name);
}
function createText(data) {
return document.createTextNode(data);
}
function blankObject() {
return Object.create(null);
}
function destroy(detach) {
this.destroy = noop;
this.fire('destroy');
this.set = this.get = noop;
if (detach !== false) this._fragment.u();
this._fragment.d();
this._fragment = this._state = null;
}
function differs(a, b) {
return a !== b || ((a && typeof a === 'object') || typeof a === 'function');
}
function dispatchObservers(component, group, changed, newState, oldState) {
for (var key in group) {
if (!changed[key]) continue;
var newValue = newState[key];
var oldValue = oldState[key];
var callbacks = group[key];
if (!callbacks) continue;
for (var i = 0; i < callbacks.length; i += 1) {
var callback = callbacks[i];
if (callback.__calling) continue;
callback.__calling = true;
callback.call(component, newValue, oldValue);
callback.__calling = false;
}
}
}
function fire(eventName, data) {
var handlers =
eventName in this._handlers && this._handlers[eventName].slice();
if (!handlers) return;
for (var i = 0; i < handlers.length; i += 1) {
handlers[i].call(this, data);
}
}
function get(key) {
return key ? this._state[key] : this._state;
}
function init(component, options) {
component.options = options;
component._observers = { pre: blankObject(), post: blankObject() };
component._handlers = blankObject();
component._root = options._root || component;
component._bind = options._bind;
}
function observe(key, callback, options) {
var group = options && options.defer
? this._observers.post
: this._observers.pre;
(group[key] || (group[key] = [])).push(callback);
if (!options || options.init !== false) {
callback.__calling = true;
callback.call(this, this._state[key]);
callback.__calling = false;
}
return {
cancel: function() {
var index = group[key].indexOf(callback);
if (~index) group[key].splice(index, 1);
}
};
}
function on(eventName, handler) {
if (eventName === 'teardown') return this.on('destroy', handler);
var handlers = this._handlers[eventName] || (this._handlers[eventName] = []);
handlers.push(handler);
return {
cancel: function() {
var index = handlers.indexOf(handler);
if (~index) handlers.splice(index, 1);
}
};
}
function set(newState) {
this._set(assign({}, newState));
if (this._root._lock) return;
this._root._lock = true;
callAll(this._root._beforecreate);
callAll(this._root._oncreate);
callAll(this._root._aftercreate);
this._root._lock = false;
}
function _set(newState) {
var oldState = this._state,
changed = {},
dirty = false;
for (var key in newState) {
if (differs(newState[key], oldState[key])) changed[key] = dirty = true;
}
if (!dirty) return;
this._state = assign({}, oldState, newState);
this._recompute(changed, this._state);
if (this._bind) this._bind(changed, this._state);
if (this._fragment) {
dispatchObservers(this, this._observers.pre, changed, this._state, oldState);
this._fragment.p(changed, this._state);
dispatchObservers(this, this._observers.post, changed, this._state, oldState);
}
}
function callAll(fns) {
while (fns && fns.length) fns.pop()();
}
function _mount(target, anchor) {
this._fragment.m(target, anchor);
}
function _unmount() {
this._fragment.u();
}
var proto = {
destroy: destroy,
get: get,
fire: fire,
observe: observe,
on: on,
set: set,
teardown: destroy,
_recompute: noop,
_set: _set,
_mount: _mount,
_unmount: _unmount
};
/* generated by Svelte vX.Y.Z */
function create_main_fragment(state, component) {
var window_updating = false, text, p, text_1, text_2;
function onwindowscroll(event) {
window_updating = true;
component.set({
y: this.scrollY
});
window_updating = false;
}
window.addEventListener("scroll", onwindowscroll);
component.observe("y", function(y) {
if (window_updating) return;
window.scrollTo(window.scrollX, y);
});
return {
c: function create() {
text = createText("\n\n");
p = createElement("p");
text_1 = createText("scrolled to ");
text_2 = createText(state.y);
},
m: function mount(target, anchor) {
insertNode(text, target, anchor);
insertNode(p, target, anchor);
appendNode(text_1, p);
appendNode(text_2, p);
},
p: function update(changed, state) {
if (changed.y) {
text_2.data = state.y;
}
},
u: function unmount() {
detachNode(text);
detachNode(p);
},
d: function destroy$$1() {
window.removeEventListener("scroll", onwindowscroll);
}
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._state.y = window.scrollY;
this._fragment = create_main_fragment(this._state, this);
if (options.target) {
this._fragment.c();
this._fragment.m(options.target, options.anchor || null);
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;

@ -0,0 +1,68 @@
/* generated by Svelte vX.Y.Z */
import { appendNode, assign, createElement, createText, detachNode, init, insertNode, proto } from "svelte/shared.js";
function create_main_fragment(state, component) {
var window_updating = false, text, p, text_1, text_2;
function onwindowscroll(event) {
window_updating = true;
component.set({
y: this.scrollY
});
window_updating = false;
};
window.addEventListener("scroll", onwindowscroll);
component.observe("y", function(y) {
if (window_updating) return;
window.scrollTo(window.scrollX, y);
});
return {
c: function create() {
text = createText("\n\n");
p = createElement("p");
text_1 = createText("scrolled to ");
text_2 = createText(state.y);
},
m: function mount(target, anchor) {
insertNode(text, target, anchor);
insertNode(p, target, anchor);
appendNode(text_1, p);
appendNode(text_2, p);
},
p: function update(changed, state) {
if (changed.y) {
text_2.data = state.y;
}
},
u: function unmount() {
detachNode(text);
detachNode(p);
},
d: function destroy() {
window.removeEventListener("scroll", onwindowscroll);
}
};
}
function SvelteComponent(options) {
init(this, options);
this._state = assign({}, options.data);
this._state.y = window.scrollY;
this._fragment = create_main_fragment(this._state, this);
if (options.target) {
this._fragment.c();
this._fragment.m(options.target, options.anchor || null);
}
}
assign(SvelteComponent.prototype, proto);
export default SvelteComponent;

@ -0,0 +1,3 @@
<:Window bind:scrollY=y/>
<p>scrolled to {{y}}</p>

@ -0,0 +1,8 @@
[{
"message": "'type' attribute must be specified",
"loc": {
"line": 1,
"column": 24
},
"pos": 24
}]

@ -0,0 +1,8 @@
[{
"message": "Invalid namespace 'lol'",
"pos": 29,
"loc": {
"line": 3,
"column": 2
}
}]

@ -0,0 +1,5 @@
<script>
export default {
namespace: 'lol'
};
</script>

@ -0,0 +1,8 @@
[{
"message": "The 'namespace' property must be a string literal representing a valid namespace",
"pos": 79,
"loc": {
"line": 5,
"column": 2
}
}]

@ -0,0 +1,7 @@
<script>
const namespace = 'http://www.w3.org/1999/svg';
export default {
namespace
};
</script>

@ -0,0 +1,8 @@
[{
"message": "The 'components' property must be an object literal",
"loc": {
"line": 3,
"column": 2
},
"pos": 29
}]

@ -0,0 +1,5 @@
<script>
export default {
components: 'not an object literal'
};
</script>

@ -0,0 +1,8 @@
[{
"message": "The 'events' property must be an object literal",
"loc": {
"line": 3,
"column": 2
},
"pos": 29
}]

@ -0,0 +1,5 @@
<script>
export default {
events: 'not an object literal'
};
</script>

@ -0,0 +1,8 @@
[{
"message": "The 'helpers' property must be an object literal",
"loc": {
"line": 3,
"column": 2
},
"pos": 29
}]

@ -0,0 +1,5 @@
<script>
export default {
helpers: 'not an object literal'
};
</script>

@ -0,0 +1,8 @@
[{
"message": "The 'methods' property must be an object literal",
"loc": {
"line": 3,
"column": 2
},
"pos": 29
}]

@ -0,0 +1,5 @@
<script>
export default {
methods: 'not an object literal'
};
</script>

@ -0,0 +1,8 @@
[{
"message": "The 'transitions' property must be an object literal",
"loc": {
"line": 3,
"column": 2
},
"pos": 29
}]

@ -0,0 +1,5 @@
<script>
export default {
transitions: 'not an object literal'
};
</script>

@ -0,0 +1,8 @@
[{
"message": "Element with a slot='...' attribute must be a descendant of a component or custom element",
"loc": {
"line": 1,
"column": 5
},
"pos": 5
}]

@ -0,0 +1,8 @@
[{
"message": "tag name must be two or more words joined by the '-' character",
"loc": {
"line": 3,
"column": 7
},
"pos": 34
}]

@ -0,0 +1,5 @@
<script>
export default {
tag: 'invalid'
};
</script>

@ -0,0 +1,8 @@
[{
"message": "'tag' must be a string literal",
"loc": {
"line": 3,
"column": 7
},
"pos": 34
}]

@ -0,0 +1,5 @@
<script>
export default {
tag: 42
};
</script>
Loading…
Cancel
Save