');
143 | validatePropertyType('emptyObject', 'any');
144 |
145 | done();
146 | }).catch(e => {
147 | done(e);
148 | });
149 | });
150 | });
151 |
--------------------------------------------------------------------------------
/test/svelte2/integration/data/data.typeFromDescription.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/test/svelte2/integration/data/data.typeFromValue.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/test/svelte2/integration/events/event.markup.fire.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/test/svelte2/integration/events/event.markup.modificators.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
--------------------------------------------------------------------------------
/test/svelte2/integration/events/event.markup.propogate.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
7 |
8 |
--------------------------------------------------------------------------------
/test/svelte2/integration/events/event.method.fire.identifier.svelte:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/test/svelte2/integration/events/event.method.fire.svelte:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/test/svelte2/integration/events/events.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc - Events', () => {
8 | it('Fired events in markup should be parsed', (done) => {
9 | parser.parse({
10 | version: 2,
11 | filename: path.resolve(__dirname, 'event.markup.fire.svelte'),
12 | features: ['events'],
13 | ignoredVisibilities: []
14 | }).then((doc) => {
15 | expect(doc, 'Document should be provided').to.exist;
16 | expect(doc.events, 'Document events should be parsed').to.exist;
17 |
18 | expect(doc.events.length).to.equal(1);
19 | const event = doc.events[0];
20 |
21 | expect(event, 'Event should be a valid entity').to.exist;
22 | expect(event.name).to.equal('click');
23 | expect(event.visibility).to.equal('public');
24 | expect(event.parent).to.be.null;
25 | expect(event.description).to.equal('Event fired when user clicked on button.');
26 |
27 | done();
28 | }).catch(e => {
29 | done(e);
30 | });
31 | });
32 |
33 | it('Fired events in component methods should be parsed', (done) => {
34 | parser.parse({
35 | version: 2,
36 | filename: path.resolve(__dirname, 'event.method.fire.svelte'),
37 | features: ['events'],
38 | ignoredVisibilities: []
39 | }).then((doc) => {
40 | expect(doc, 'Document should be provided').to.exist;
41 | expect(doc.events, 'Document events should be parsed').to.exist;
42 |
43 | expect(doc.events.length).to.equal(1);
44 | const event = doc.events[0];
45 |
46 | expect(event, 'Event should be a valid entity').to.exist;
47 | expect(event.name).to.equal('click');
48 | expect(event.visibility).to.equal('public');
49 | expect(event.parent).to.be.null;
50 | expect(event.description).to.equal('Event fired when user clicked on button.');
51 |
52 | done();
53 | }).catch(e => {
54 | done(e);
55 | });
56 | });
57 |
58 | it('Fired events with identifier event name in component methods should be parsed', (done) => {
59 | parser.parse({
60 | version: 2,
61 | filename: path.resolve(__dirname, 'event.method.fire.identifier.svelte'),
62 | features: ['events'],
63 | ignoredVisibilities: []
64 | }).then((doc) => {
65 | expect(doc, 'Document should be provided').to.exist;
66 | expect(doc.events, 'Document events should be parsed').to.exist;
67 |
68 | expect(doc.events.length).to.equal(2);
69 | const event = doc.events[0];
70 |
71 | expect(event, 'Event should be a valid entity').to.exist;
72 | expect(event.name).to.equal('click');
73 | expect(event.visibility).to.equal('public');
74 | expect(event.parent).to.be.null;
75 | expect(event.description).to.equal('Event fired when user clicked on button.');
76 |
77 | const event2 = doc.events[1];
78 |
79 | expect(event2, 'Event should be a valid entity').to.exist;
80 | expect(event2.name).to.equal('press');
81 | expect(event2.visibility).to.equal('public');
82 | expect(event2.parent).to.be.null;
83 | expect(event2.description).to.equal('Event fired when user pressed on button.');
84 |
85 | done();
86 | }).catch(e => {
87 | done(e);
88 | });
89 | });
90 |
91 | it('Propogated events in markup should be parsed', (done) => {
92 | parser.parse({
93 | version: 2,
94 | filename: path.resolve(__dirname, 'event.markup.propogate.svelte'),
95 | features: ['events'],
96 | ignoredVisibilities: []
97 | }).then((doc) => {
98 | expect(doc, 'Document should be provided').to.exist;
99 | expect(doc.events, 'Document events should be parsed').to.exist;
100 |
101 | expect(doc.events.length).to.equal(1);
102 | const event = doc.events[0];
103 |
104 | expect(event, 'Event should be a valid entity').to.exist;
105 | expect(event.name).to.equal('click');
106 | expect(event.visibility).to.equal('public');
107 | expect(event.parent).to.be.equal('button');
108 | expect(event.description).to.equal('Event fired when user clicked on button.');
109 |
110 | done();
111 | }).catch(e => {
112 | done(e);
113 | });
114 | });
115 |
116 | it('Markup events with modificators should be parsed', (done) => {
117 | parser.parse({
118 | version: 2,
119 | filename: path.resolve(__dirname, 'event.markup.modificators.svelte'),
120 | features: ['events'],
121 | ignoredVisibilities: []
122 | }).then((doc) => {
123 | expect(doc, 'Document should be provided').to.exist;
124 | expect(doc.events, 'Document events should be parsed').to.exist;
125 |
126 | expect(doc.events.length).to.equal(1);
127 | const event = doc.events[0];
128 |
129 | expect(event, 'Event should be a valid entity').to.exist;
130 | expect(event.name).to.equal('click');
131 | expect(event.visibility).to.equal('public');
132 | expect(event.parent).to.be.equal('button');
133 | expect(event.description).to.equal('Event fired when user clicked on button.');
134 |
135 | expect(event.modificators).to.eql([
136 | 'once', 'preventDefault'
137 | ]);
138 |
139 | done();
140 | }).catch(e => {
141 | done(e);
142 | });
143 | });
144 | });
145 |
--------------------------------------------------------------------------------
/test/svelte2/integration/failure/failure.invalid.js.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte2/integration/failure/failure.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc - Failure', () => {
8 | it('Component have invalid JS syntax should fall into catch block', (done) => {
9 | parser.parse({
10 | version: 2,
11 | filename: path.resolve(__dirname, 'failure.invalid.js.svelte'),
12 | ignoredVisibilities: []
13 | }).then(() => {
14 | done(new Error('Should not be parsed'));
15 | }).catch(e => {
16 | expect(e).is.not.null;
17 |
18 | done();
19 | });
20 | });
21 | });
22 |
--------------------------------------------------------------------------------
/test/svelte2/integration/locations/locations.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc - Source locations', () => {
8 | it('Source locations for component data properties should be extracted', (done) => {
9 | parser.parse({
10 | version: 2,
11 | includeSourceLocations: true,
12 | filename: path.resolve(__dirname, 'main.svelte'),
13 | features: ['data'],
14 | ignoredVisibilities: []
15 | }).then((doc) => {
16 | expect(doc.data.length).is.equals(1);
17 | const property = doc.data[0];
18 |
19 | expect(property.locations).to.deep.equal([{
20 | start: 166,
21 | end: 176
22 | }]);
23 |
24 | done();
25 | }).catch(e => {
26 | done(e);
27 | });
28 | });
29 |
30 | it('Source locations for component methods should be extracted', (done) => {
31 | parser.parse({
32 | version: 2,
33 | includeSourceLocations: true,
34 | filename: path.resolve(__dirname, 'main.svelte'),
35 | features: ['methods'],
36 | ignoredVisibilities: []
37 | }).then((doc) => {
38 | expect(doc.methods.length).is.equals(1);
39 | const method = doc.methods[0];
40 |
41 | expect(method.locations).to.deep.equal([{
42 | start: 221,
43 | end: 226
44 | }]);
45 |
46 | done();
47 | }).catch(e => {
48 | done(e);
49 | });
50 | });
51 |
52 | it('Source locations for component refs should be extracted', (done) => {
53 | parser.parse({
54 | version: 2,
55 | includeSourceLocations: true,
56 | filename: path.resolve(__dirname, 'main.svelte'),
57 | features: ['refs'],
58 | ignoredVisibilities: []
59 | }).then((doc) => {
60 | expect(doc.refs.length).is.equals(1);
61 | const ref = doc.refs[0];
62 |
63 | expect(ref.locations).to.deep.equal([{
64 | start: 4,
65 | end: 15
66 | }]);
67 |
68 | done();
69 | }).catch(e => {
70 | done(e);
71 | });
72 | });
73 |
74 | it('Source locations for component slots should be extracted', (done) => {
75 | parser.parse({
76 | version: 2,
77 | includeSourceLocations: true,
78 | filename: path.resolve(__dirname, 'main.svelte'),
79 | features: ['slots'],
80 | ignoredVisibilities: []
81 | }).then((doc) => {
82 | expect(doc.slots.length).is.equals(1);
83 | const slot = doc.slots[0];
84 |
85 | expect(slot.locations).to.deep.equal([{
86 | start: 64,
87 | end: 81
88 | }]);
89 |
90 | done();
91 | }).catch(e => {
92 | done(e);
93 | });
94 | });
95 |
96 | it('Source locations for component events should be extracted', (done) => {
97 | parser.parse({
98 | version: 2,
99 | includeSourceLocations: true,
100 | filename: path.resolve(__dirname, 'main.svelte'),
101 | features: ['events'],
102 | ignoredVisibilities: []
103 | }).then((doc) => {
104 | expect(doc.events.length).is.equals(3);
105 | const markupPropogatedEvent = doc.events.find(e => e.name === 'mousemove');
106 |
107 | expect(markupPropogatedEvent).is.not.empty;
108 | expect(markupPropogatedEvent.locations).to.deep.equal([{
109 | start: 44,
110 | end: 58
111 | }]);
112 |
113 | const codeEvent = doc.events.find(e => e.name === 'codeEvent');
114 |
115 | expect(codeEvent).is.not.empty;
116 | expect(codeEvent.locations).to.deep.equal([{
117 | start: 287,
118 | end: 298
119 | }]);
120 |
121 | const markupEvent = doc.events.find(e => e.name === 'markupEvent');
122 |
123 | expect(markupEvent).is.not.empty;
124 | expect(markupEvent.locations).to.deep.equal([{
125 | start: 15,
126 | end: 44
127 | }]);
128 |
129 | done();
130 | }).catch(e => {
131 | done(e);
132 | });
133 | });
134 |
135 | it('Source locations for component helpers should be extracted', (done) => {
136 | parser.parse({
137 | version: 2,
138 | includeSourceLocations: true,
139 | filename: path.resolve(__dirname, 'main.svelte'),
140 | features: ['helpers'],
141 | ignoredVisibilities: []
142 | }).then((doc) => {
143 | expect(doc.helpers.length).is.equals(2);
144 | const firstHelper = doc.helpers.find(h => h.name === 'window');
145 | const secondHelper = doc.helpers.find(h => h.name === 'helperFunc');
146 |
147 | expect(firstHelper.locations).to.deep.equal([{
148 | start: 341,
149 | end: 347
150 | }]);
151 |
152 | expect(secondHelper.locations).to.deep.equal([{
153 | start: 357,
154 | end: 367
155 | }]);
156 |
157 | done();
158 | }).catch(e => {
159 | done(e);
160 | });
161 | });
162 | });
163 |
--------------------------------------------------------------------------------
/test/svelte2/integration/locations/main.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/test/svelte2/integration/overall/main.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
7 |
8 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
2 |
{$ApplicationName}
3 |
4 |
5 |
--------------------------------------------------------------------------------
/test/svelte2/integration/store/store.markup.svelte:
--------------------------------------------------------------------------------
1 |
2 |
{$ApplicationName}
3 |
4 |
5 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/test/svelte2/integration/store/store.set.markup.svelte:
--------------------------------------------------------------------------------
1 |
2 |
5 |
6 |
7 |
--------------------------------------------------------------------------------
/test/svelte2/integration/store/store.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | xdescribe('SvelteDoc - Store', () => {
8 | it('Reading store properties in markup should be parsed', (done) => {
9 | parser.parse({
10 | version: 2,
11 | filename: path.resolve(__dirname, 'store.get.markup.svelte'),
12 | features: ['store'],
13 | ignoredVisibilities: []
14 | }).then((doc) => {
15 | expect(doc, 'Document should be provided').to.exist;
16 | expect(doc.store, 'Store information should be provided').to.exist;
17 |
18 | const storeDoc = doc.store;
19 |
20 | expect(storeDoc.length).to.equal(1);
21 | const storeProperty = storeDoc[0];
22 |
23 | expect(storeProperty).to.exist;
24 | expect(storeProperty.name).to.equal('ApplicationName');
25 | expect(storeProperty.read).is.true;
26 | expect(storeProperty.write).is.false;
27 |
28 | done();
29 | }).catch(e => {
30 | done(e);
31 | });
32 | });
33 |
34 | it('Changing store properties in markup should be parsed', (done) => {
35 | parser.parse({
36 | version: 2,
37 | filename: path.resolve(__dirname, 'store.set.markup.svelte'),
38 | features: ['store'],
39 | ignoredVisibilities: []
40 | }).then((doc) => {
41 | expect(doc, 'Document should be provided').to.exist;
42 | expect(doc.store, 'Store information should be provided').to.exist;
43 |
44 | const storeDoc = doc.store;
45 |
46 | expect(storeDoc.length).to.equal(1);
47 | const storeProperty = storeDoc[0];
48 |
49 | expect(storeProperty).to.exist;
50 | expect(storeProperty.name).to.equal('ApplicationName');
51 | expect(storeProperty.read).is.false;
52 | expect(storeProperty.write).is.true;
53 |
54 | done();
55 | }).catch(e => {
56 | done(e);
57 | });
58 | });
59 |
60 | it('Reading & changing store properties in markup should be parsed', (done) => {
61 | parser.parse({
62 | version: 2,
63 | filename: path.resolve(__dirname, 'store.set.markup.svelte'),
64 | features: ['store'],
65 | ignoredVisibilities: []
66 | }).then((doc) => {
67 | expect(doc, 'Document should be provided').to.exist;
68 | expect(doc.store, 'Store information should be provided').to.exist;
69 |
70 | const storeDoc = doc.store;
71 |
72 | expect(storeDoc.length).to.equal(1);
73 | const storeProperty = storeDoc[0];
74 |
75 | expect(storeProperty).to.exist;
76 | expect(storeProperty.name).to.equal('ApplicationName');
77 | expect(storeProperty.read).is.true;
78 | expect(storeProperty.write).is.true;
79 |
80 | done();
81 | }).catch(e => {
82 | done(e);
83 | });
84 | });
85 | });
86 |
--------------------------------------------------------------------------------
/test/svelte3/integration/basic/basic.name.svelte:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/KatChaotic/sveltedoc-parser/7b7d0ff777731ce8ed35ddead97eaa85afe9e82f/test/svelte3/integration/basic/basic.name.svelte
--------------------------------------------------------------------------------
/test/svelte3/integration/basic/basic.name.wc.svelte:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/test/svelte3/integration/basic/basic.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc v3 - Basic', () => {
8 | it('If name is not provided for component, name should be read from file name', (done) => {
9 | parser.parse({
10 | version: 3,
11 | filename: path.resolve(__dirname, 'basic.name.svelte'),
12 | features: ['name'],
13 | ignoredVisibilities: []
14 | }).then((doc) => {
15 | expect(doc, 'Document should be provided').to.exist;
16 | expect(doc.name, 'Document should have proper name').to.equal('BasicName');
17 |
18 | done();
19 | }).catch(e => {
20 | done(e);
21 | });
22 | });
23 |
24 | it('should read name from options-tag when compiling as a custom element', (done) => {
25 | parser.parse({
26 | version: 3,
27 | filename: path.resolve(__dirname, 'basic.name.wc.svelte'),
28 | features: ['name'],
29 | ignoredVisibilities: []
30 | }).then((doc) => {
31 | expect(doc, 'Document should be provided').to.exist;
32 | expect(doc.name, 'Document should have proper name').to.equal('tag-name');
33 |
34 | done();
35 | }).catch(e => {
36 | done(e);
37 | });
38 | });
39 | });
40 |
--------------------------------------------------------------------------------
/test/svelte3/integration/bind/bind.declared.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/test/svelte3/integration/bind/bind.exported.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/test/svelte3/integration/bind/bind.multiple.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/test/svelte3/integration/bind/bind.named.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/test/svelte3/integration/bind/bind.simple.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/test/svelte3/integration/bind/bind.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc v3 - Bind', () => {
8 | it('Bind simple definition should be parsed', (done) => {
9 | parser.parse({
10 | version: 3,
11 | filename: path.resolve(__dirname, 'bind.simple.svelte'),
12 | features: ['data'],
13 | ignoredVisibilities: []
14 | }).then((doc) => {
15 | expect(doc, 'Document should be provided').to.exist;
16 | expect(doc.data, 'Document data should be parsed').to.exist;
17 |
18 | expect(doc.data.length).to.equal(1);
19 | const item = doc.data[0];
20 |
21 | expect(item, 'Bind item should be a valid entity').to.exist;
22 | expect(item.name).to.equal('totalCost');
23 | expect(item.visibility).to.equal('private');
24 | expect(item.kind, 'Kind should not be specified, because variable is not declared').to.not.exist;
25 | expect(item.bind, 'Bind information should be presented').to.exist;
26 | expect(item.bind.length, 'Bind should be an array').to.be.equal(1);
27 | expect(item.bind[0].source).to.equal('ShopingCart');
28 | expect(item.bind[0].property).to.equal('totalCost');
29 |
30 | done();
31 | }).catch(e => {
32 | done(e);
33 | });
34 | });
35 |
36 | it('Bind named definition should be parsed', (done) => {
37 | parser.parse({
38 | version: 3,
39 | filename: path.resolve(__dirname, 'bind.named.svelte'),
40 | features: ['data'],
41 | ignoredVisibilities: []
42 | }).then((doc) => {
43 | expect(doc, 'Document should be provided').to.exist;
44 | expect(doc.data, 'Document data should be parsed').to.exist;
45 |
46 | expect(doc.data.length, 'Found following data items - ' + doc.data.map(d => d.name).join(', ')).to.equal(1);
47 | const item = doc.data[0];
48 |
49 | expect(item, 'Bind item should be a valid entity').to.exist;
50 | expect(item.name).to.equal('cost');
51 | expect(item.visibility).to.equal('private');
52 | expect(item.bind, 'Bind information should be presented').to.exist;
53 | expect(item.bind.length, 'Bind should be an array').to.be.equal(1);
54 | expect(item.bind[0].source).to.equal('ShopingCart');
55 | expect(item.bind[0].property).to.equal('totalCost');
56 |
57 | done();
58 | }).catch(e => {
59 | done(e);
60 | });
61 | });
62 |
63 | it('Bind declared definition should be parsed', (done) => {
64 | parser.parse({
65 | version: 3,
66 | filename: path.resolve(__dirname, 'bind.declared.svelte'),
67 | features: ['data'],
68 | ignoredVisibilities: []
69 | }).then((doc) => {
70 | expect(doc, 'Document should be provided').to.exist;
71 | expect(doc.data, 'Document data should be parsed').to.exist;
72 |
73 | expect(doc.data.length).to.equal(1);
74 | const item = doc.data[0];
75 |
76 | expect(item, 'Bind item should be a valid entity').to.exist;
77 | expect(item.name).to.equal('totalCost');
78 | expect(item.visibility).to.equal('private');
79 | expect(item.kind).to.equal('let');
80 | expect(item.bind, 'Bind information should be presented').to.exist;
81 | expect(item.bind.length, 'Bind should be an array').to.be.equal(1);
82 | expect(item.bind[0].source).to.equal('ShopingCart');
83 | expect(item.bind[0].property).to.equal('totalCost');
84 |
85 | done();
86 | }).catch(e => {
87 | done(e);
88 | });
89 | });
90 |
91 | it('Multiple bind to one variable should be parsed correctly', (done) => {
92 | parser.parse({
93 | version: 3,
94 | filename: path.resolve(__dirname, 'bind.multiple.svelte'),
95 | features: ['data'],
96 | ignoredVisibilities: []
97 | }).then((doc) => {
98 | expect(doc, 'Document should be provided').to.exist;
99 | expect(doc.data, 'Document data should be parsed').to.exist;
100 |
101 | expect(doc.data.length, 'Found following data items - ' + doc.data.map(d => d.name).join(', ')).to.equal(1);
102 | const item = doc.data[0];
103 |
104 | expect(item, 'Bind item should be a valid entity').to.exist;
105 | expect(item.name).to.equal('number');
106 | expect(item.visibility).to.equal('private');
107 | expect(item.bind, 'Bind information should be presented').to.exist;
108 | expect(item.bind.length, 'Bind should be an array').to.be.equal(2);
109 |
110 | const bindInput = item.bind.find(b => b.source === 'input');
111 |
112 | expect(bindInput.source).to.equal('input');
113 | expect(bindInput.property).to.equal('value');
114 |
115 | const bindControl = item.bind.find(b => b.source === 'PlusMinusControl');
116 |
117 | expect(bindControl.source).to.equal('PlusMinusControl');
118 | expect(bindControl.property).to.equal('numberValue');
119 |
120 | done();
121 | }).catch(e => {
122 | done(e);
123 | });
124 | });
125 |
126 | it('Bind declared and exported definition should be parsed', (done) => {
127 | parser.parse({
128 | version: 3,
129 | filename: path.resolve(__dirname, 'bind.exported.svelte'),
130 | features: ['data', 'description'],
131 | ignoredVisibilities: []
132 | }).then((doc) => {
133 | expect(doc, 'Document should be provided').to.exist;
134 | expect(doc.data, 'Document data should be parsed').to.exist;
135 |
136 | expect(doc.data.length).to.equal(1);
137 | const item = doc.data[0];
138 |
139 | expect(item, 'Bind item should be a valid entity').to.exist;
140 | expect(item.name).to.equal('totalCost');
141 | expect(item.visibility).to.equal('public');
142 | expect(item.description).to.equal('The comment of public binded property.');
143 | expect(item.bind, 'Bind information should be presented').to.exist;
144 | expect(item.bind.length, 'Bind should be an array').to.be.equal(1);
145 | expect(item.bind[0].source).to.equal('ShopingCart');
146 | expect(item.bind[0].property).to.equal('totalCost');
147 |
148 | done();
149 | }).catch(e => {
150 | done(e);
151 | });
152 | });
153 | });
154 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.import.aliace.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.import.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.importStar.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.importable.js:
--------------------------------------------------------------------------------
1 | export const X = 1;
2 |
3 | export const y = 2;
4 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.lowercase.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.nested.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.notdefault.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/components/components.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc v3 - Components', () => {
8 | it('Import with upper case default should be parsed as component', (done) => {
9 | parser.parse({
10 | version: 3,
11 | filename: path.resolve(__dirname, 'components.import.svelte'),
12 | features: ['components'],
13 | includeSourceLocations: true,
14 | ignoredVisibilities: []
15 | }).then((doc) => {
16 | // Document
17 | expect(doc, 'Document should be provided').to.exist;
18 | expect(doc.components, 'Document components should be parsed').to.exist;
19 | expect(doc.components.length).to.equal(1);
20 |
21 | // Component
22 | const component = doc.components[0];
23 |
24 | expect(component.name).to.equal('Nested');
25 | expect(component.importPath).to.equal('./components.nested.svelte');
26 | expect(component.visibility).to.equal('private');
27 | expect(component.description).to.equal('The nested component.');
28 | expect(component.locations, 'Code location should be included').to.be.exist;
29 | expect(component.locations.length).to.equal(1);
30 |
31 | // Location
32 | const location = component.locations[0];
33 |
34 | expect(location, 'Location should be correctly identified').is.deep.equal({ start: 53, end: 59 });
35 |
36 | done();
37 | }).catch(e => {
38 | done(e);
39 | });
40 | });
41 |
42 | it('Import with upper case in aliace by default should not be parsed as component', (done) => {
43 | parser.parse({
44 | version: 3,
45 | filename: path.resolve(__dirname, 'components.import.aliace.svelte'),
46 | features: ['components'],
47 | ignoredVisibilities: []
48 | }).then((doc) => {
49 | expect(doc, 'Document should be provided').to.exist;
50 | expect(doc.components, 'Document components should be parsed').to.exist;
51 |
52 | expect(doc.components.length).to.equal(0);
53 | done();
54 | }).catch(e => {
55 | done(e);
56 | });
57 | });
58 |
59 | it('Import with upper case not default should not be parsed as component', (done) => {
60 | parser.parse({
61 | version: 3,
62 | filename: path.resolve(__dirname, 'components.notdefault.svelte'),
63 | features: ['components'],
64 | ignoredVisibilities: []
65 | }).then((doc) => {
66 | expect(doc, 'Document should be provided').to.exist;
67 | expect(doc.components, 'Document components should be parsed').to.exist;
68 |
69 | expect(doc.components.length).to.equal(0);
70 | done();
71 | }).catch(e => {
72 | done(e);
73 | });
74 | });
75 |
76 | it('Import with lowercase case default should not be parsed as component', (done) => {
77 | parser.parse({
78 | version: 3,
79 | filename: path.resolve(__dirname, 'components.lowercase.svelte'),
80 | features: ['components'],
81 | ignoredVisibilities: []
82 | }).then((doc) => {
83 | expect(doc, 'Document should be provided').to.exist;
84 | expect(doc.components, 'Document components should be parsed').to.exist;
85 |
86 | expect(doc.components.length).to.equal(0);
87 | done();
88 | }).catch(e => {
89 | done(e);
90 | });
91 | });
92 |
93 | it('Import with start and alias should not be parsed as component', (done) => {
94 | parser.parse({
95 | version: 3,
96 | filename: path.resolve(__dirname, 'components.importStar.svelte'),
97 | features: ['components'],
98 | ignoredVisibilities: []
99 | }).then((doc) => {
100 | expect(doc, 'Document should be provided').to.exist;
101 | expect(doc.components, 'Document components should be parsed').to.exist;
102 |
103 | expect(doc.components.length).to.equal(0);
104 | done();
105 | }).catch(e => {
106 | done(e);
107 | });
108 | });
109 | });
110 |
--------------------------------------------------------------------------------
/test/svelte3/integration/computed/computed.declaration.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/computed/computed.expression.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/computed/computed.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc v3 - Computed', () => {
8 | it('Private computed without let should be parsed with comment and additional metadata', (done) => {
9 | parser.parse({
10 | version: 3,
11 | filename: path.resolve(__dirname, 'computed.expression.svelte'),
12 | features: ['computed'],
13 | includeSourceLocations: true,
14 | ignoredVisibilities: []
15 | }).then((doc) => {
16 | expect(doc, 'Document should be provided').to.exist;
17 | expect(doc.computed, 'Document computed should be parsed').to.exist;
18 |
19 | expect(doc.computed.length).to.equal(1);
20 | const prop = doc.computed[0];
21 |
22 | expect(prop.name).to.equal('area');
23 | expect(prop.visibility).to.equal('private');
24 | expect(prop.static).to.be.false;
25 |
26 | expect(prop.description).to.equal('The area of rectangle.');
27 |
28 | expect(prop.type).to.exist;
29 | expect(prop.type).to.eql({ kind: 'type', text: 'number', type: 'number' });
30 |
31 | expect(prop.locations, 'Code location should be included').to.be.exist;
32 | expect(prop.locations.length).to.be.equal(1);
33 |
34 | const location = prop.locations[0];
35 |
36 | expect(location, 'Location should be correct identified').is.deep.equals({ start: 124, end: 128 });
37 |
38 | done();
39 | }).catch(e => {
40 | done(e);
41 | });
42 | });
43 |
44 | it('Private computed should be parsed with comment and additional metadata', (done) => {
45 | parser.parse({
46 | version: 3,
47 | filename: path.resolve(__dirname, 'computed.declaration.svelte'),
48 | features: ['computed'],
49 | ignoredVisibilities: []
50 | }).then((doc) => {
51 | expect(doc, 'Document should be provided').to.exist;
52 | expect(doc.computed, 'Document computed should be parsed').to.exist;
53 |
54 | expect(doc.computed.length).to.equal(1);
55 | const prop = doc.computed[0];
56 |
57 | expect(prop.name).to.equal('area');
58 | expect(prop.visibility).to.equal('private');
59 | expect(prop.static).to.be.false;
60 |
61 | expect(prop.description).to.equal('The area of rectangle.');
62 |
63 | expect(prop.type).to.exist;
64 | expect(prop.type).to.eql({ kind: 'type', text: 'number', type: 'number' });
65 |
66 | done();
67 | }).catch(e => {
68 | done(e);
69 | });
70 | });
71 | });
72 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/const.importable.js:
--------------------------------------------------------------------------------
1 | const x = 1;
2 |
3 | export default x;
4 |
5 | export const y = 1;
6 |
7 | export const z = 1;
8 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.const.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.export.aliace.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.export.functionExpression.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.export.many.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.exportNamed.many.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.import.aliace.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.import.default.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.import.many.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.multiple.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.objectPattern.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.private.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.public.svelte:
--------------------------------------------------------------------------------
1 |
10 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.static.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/data/data.types.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.arrayIdentifier.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.custom.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.customConstructor.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.default.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.externalCallback.svelte:
--------------------------------------------------------------------------------
1 |
11 |
12 |
13 | Simple component
14 |
15 |
16 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.identifier.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.importedIdentifier.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.insideMethod.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.dispatcher.markup.svelte:
--------------------------------------------------------------------------------
1 |
6 |
7 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.markup.dispatcher.custom.svelte:
--------------------------------------------------------------------------------
1 |
6 |
7 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.markup.dispatcher.customConstructor.svelte:
--------------------------------------------------------------------------------
1 |
6 |
7 |
10 |
11 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.markup.dispatcher.default.function.svelte:
--------------------------------------------------------------------------------
1 |
6 |
7 |
10 |
11 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.markup.dispatcher.default.svelte:
--------------------------------------------------------------------------------
1 |
6 |
7 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.markup.handleAndPropogate.svelte:
--------------------------------------------------------------------------------
1 |
6 |
7 |
8 |
9 |
12 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.markup.modificators.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/event.markup.propogate.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
6 |
--------------------------------------------------------------------------------
/test/svelte3/integration/events/sharedEvents.importable.js:
--------------------------------------------------------------------------------
1 | export const EVENT = {
2 | SIGNAL: {
3 | NOTIFY: 'notify',
4 | },
5 | };
6 |
7 | export const SIMPLE_EVENT = 'plain-notify';
8 |
--------------------------------------------------------------------------------
/test/svelte3/integration/globalComment/globalComment.markup.svelte:
--------------------------------------------------------------------------------
1 |
8 |
9 |
12 |
13 |
21 |
22 |
Header {identifier}
23 |
24 |
--------------------------------------------------------------------------------
/test/svelte3/integration/globalComment/globalComment.nested.svelte:
--------------------------------------------------------------------------------
1 |
17 |
18 |
30 |
31 |
Header {identifier}
32 |
33 |
--------------------------------------------------------------------------------
/test/svelte3/integration/globalComment/globalComment.noComment.svelte:
--------------------------------------------------------------------------------
1 |
4 |
5 |
6 |
Header {identifier}
7 |
8 |
--------------------------------------------------------------------------------
/test/svelte3/integration/globalComment/globalComment.script.svelte:
--------------------------------------------------------------------------------
1 |
14 |
--------------------------------------------------------------------------------
/test/svelte3/integration/globalComment/globalComment.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc v3 - Global component', () => {
8 | it('Global component data should be parsed with HTML comment', (done) => {
9 | parser.parse({
10 | version: 3,
11 | filename: path.resolve(__dirname, 'globalComment.markup.svelte'),
12 | features: ['description', 'keywords'],
13 | includeSourceLocations: true,
14 | ignoredVisibilities: []
15 | }).then((doc) => {
16 | expect(doc, 'Document should be provided').to.exist;
17 | expect(doc.description, 'Document description should be parsed').to.exist;
18 | expect(doc.keywords, 'Document keywords should be parsed').to.exist;
19 |
20 | expect(doc.description, 'Document description text').to.equal('The component description');
21 | expect(doc.keywords, 'Document keywords length').to.have.length(2);
22 | expect(doc.keywords, 'Document keywords content').to.eql([
23 | { name: 'component', description: 'ComponentName' },
24 | { name: 'example', description: '' }
25 | ]);
26 | done();
27 | }).catch(done);
28 | });
29 |
30 | it('Global component data should be parsed with JS comment', (done) => {
31 | parser.parse({
32 | version: 3,
33 | filename: path.resolve(__dirname, 'globalComment.script.svelte'),
34 | features: ['description', 'keywords'],
35 | includeSourceLocations: true,
36 | ignoredVisibilities: []
37 | }).then((doc) => {
38 | expect(doc, 'Document should be provided').to.exist;
39 | expect(doc.description, 'Document description should be parsed').to.exist;
40 | expect(doc.keywords, 'Document keywords should be parsed').to.exist;
41 |
42 | expect(doc.description, 'Document description text').to.equal('The component description');
43 | expect(doc.keywords, 'Document keywords length').to.have.length(2);
44 | expect(doc.keywords, 'Document keywords content').to.eql([
45 | { name: 'component', description: 'ComponentName' },
46 | { name: 'example', description: '' }
47 | ]);
48 | done();
49 | }).catch(done);
50 | });
51 |
52 | it('Global component data should NOT be parsed when not top level', (done) => {
53 | parser.parse({
54 | version: 3,
55 | filename: path.resolve(__dirname, 'globalComment.nested.svelte'),
56 | features: ['description', 'keywords'],
57 | includeSourceLocations: true,
58 | ignoredVisibilities: []
59 | }).then((doc) => {
60 | expect(doc, 'Document').to.exist;
61 | expect(doc.description, 'Document description').to.not.exist;
62 | expect(doc.keywords, 'Document keywords').to.be.empty;
63 |
64 | done();
65 | }).catch(done);
66 | });
67 |
68 | it('Global component data should NOT be parsed when no comment exist', (done) => {
69 | parser.parse({
70 | version: 3,
71 | filename: path.resolve(__dirname, 'globalComment.noComment.svelte'),
72 | features: ['description', 'keywords'],
73 | includeSourceLocations: true,
74 | ignoredVisibilities: []
75 | }).then((doc) => {
76 | expect(doc, 'Document').to.exist;
77 | expect(doc.description, 'Document description').to.not.exist;
78 | expect(doc.keywords, 'Document keywords').to.be.empty;
79 |
80 | done();
81 | }).catch(done);
82 | });
83 | });
84 |
--------------------------------------------------------------------------------
/test/svelte3/integration/locations/locations.multiscripts.svelte:
--------------------------------------------------------------------------------
1 | Template header
2 | Template text
3 |
4 |
7 |
8 |
--------------------------------------------------------------------------------
/test/svelte3/integration/locations/locations.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | function assertDataItemLocation(dataItem, expectedLocationStart, expectedLocationEnd) {
8 | expect(dataItem.locations, `Code location for data item should be included for "${dataItem.name}"`).to.be.exist;
9 | expect(dataItem.locations.length, `Code location for data item have values for "${dataItem.name}"`).to.be.equal(1);
10 | const location = dataItem.locations[0];
11 |
12 | expect(location, `Location should be correct identified for "${dataItem.name}"`).is.deep.equals({ start: expectedLocationStart, end: expectedLocationEnd });
13 | }
14 |
15 | describe('SvelteDoc v3 - Locations', () => {
16 | it('Locations for multiple scripts should be found correct', (done) => {
17 | parser.parse({
18 | version: 3,
19 | filename: path.resolve(__dirname, 'locations.multiscripts.svelte'),
20 | features: ['data'],
21 | includeSourceLocations: true,
22 | ignoredVisibilities: []
23 | }).then((doc) => {
24 | expect(doc, 'Document should be provided').to.exist;
25 | expect(doc.data, 'Document events should be parsed').to.exist;
26 |
27 | const staticVariable = doc.data.find(p => p.name === 'staticVariable');
28 |
29 | expect(staticVariable, '"staticVariable" should be presented in data items of the doc').to.exist;
30 | expect(staticVariable.static).to.be.true;
31 | assertDataItemLocation(staticVariable, 81, 95);
32 |
33 | const local = doc.data.find(p => p.name === 'variable');
34 |
35 | expect(local, '"variable" should be presented in data items of the doc').to.exist;
36 | expect(local.static).to.be.false;
37 | assertDataItemLocation(local, 129, 137);
38 |
39 | done();
40 | }).catch(e => {
41 | done(e);
42 | });
43 | });
44 | });
45 |
--------------------------------------------------------------------------------
/test/svelte3/integration/methods/method.private.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/methods/method.public.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/methods/method.typeInference.svelte:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/test/svelte3/integration/methods/methods.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc v3 - Methods', () => {
8 | it('Private method should be parsed with comment and additional metadata', (done) => {
9 | parser.parse({
10 | version: 3,
11 | filename: path.resolve(__dirname, 'method.private.svelte'),
12 | features: ['methods'],
13 | includeSourceLocations: true,
14 | ignoredVisibilities: []
15 | }).then((doc) => {
16 | expect(doc, 'Document should be provided').to.exist;
17 | expect(doc.methods, 'Document methods should be parsed').to.exist;
18 |
19 | expect(doc.methods.length).to.equal(1);
20 | const method = doc.methods[0];
21 |
22 | expect(method.name).to.equal('privateMethod');
23 | expect(method.visibility).to.equal('private');
24 | expect(method.static).to.be.false;
25 |
26 | expect(method.params, 'Method arguments should be parsed').to.exist;
27 | expect(method.params.length).to.equal(2);
28 | expect(method.params[0].name).to.equal('param1');
29 | expect(method.params[1].name).to.equal('param2');
30 |
31 | expect(method.description).to.equal('The method comment.');
32 |
33 | expect(method.return, 'Method return keyword should be parsed').to.exist;
34 | expect(method.return.type).to.exist;
35 | expect(method.return.type.type).to.equal('number');
36 | expect(method.return.description).to.equal('return value description');
37 |
38 | expect(method.locations, 'Code location should be included').to.be.exist;
39 | expect(method.locations.length).to.be.equal(1);
40 |
41 | const location = method.locations[0];
42 |
43 | expect(location, 'Location should be correct identified').is.deep.equals({ start: 117, end: 130 });
44 |
45 | done();
46 | }).catch(e => {
47 | done(e);
48 | });
49 | });
50 |
51 | it('Public method should be parsed with comment and additional metadata', (done) => {
52 | parser.parse({
53 | version: 3,
54 | filename: path.resolve(__dirname, 'method.public.svelte'),
55 | features: ['methods', 'description'],
56 | ignoredVisibilities: []
57 | }).then((doc) => {
58 | expect(doc, 'Document should be provided').to.exist;
59 |
60 | expect(doc.methods, 'Document methods should be parsed').to.exist;
61 | expect(doc.methods.length).to.equal(1);
62 |
63 | const method = doc.methods[0];
64 |
65 | expect(method.name).to.equal('publicMethod');
66 | expect(method.visibility).to.equal('public');
67 | expect(method.static).to.be.false;
68 | expect(method.description).to.equal('The method comment.');
69 |
70 | // @param keywords
71 | expect(method.params, 'Method arguments should be parsed').to.exist;
72 | expect(method.params.length).to.equal(2);
73 |
74 | const param0 = method.params[0];
75 |
76 | expect(param0.name).to.equal('param1');
77 | expect(param0.description).to.equal('the first parameter');
78 | expect(param0.optional).to.be.false;
79 |
80 | const param1 = method.params[1];
81 |
82 | expect(param1.name).to.equal('param2');
83 | expect(param1.description).to.equal('the second parameter');
84 | expect(param1.optional).to.be.true;
85 |
86 | // @returns keyword
87 | expect(method.return, 'Method return keyword should be parsed').to.exist;
88 | expect(method.return.type).to.exist;
89 | expect(method.return.type.type).to.equal('number');
90 | expect(method.return.description).to.equal('return value description');
91 |
92 | done();
93 | }).catch(e => {
94 | done(e);
95 | });
96 | });
97 |
98 | it('Method argument types should be inferred from assignment patterns, and enhanced with additional metadata', (done) => {
99 | parser.parse({
100 | version: 3,
101 | filename: path.resolve(__dirname, 'method.typeInference.svelte'),
102 | features: ['methods', 'description'],
103 | ignoredVisibilities: []
104 | }).then((doc) => {
105 | expect(doc, 'Document should be provided').to.exist;
106 |
107 | expect(doc.methods, 'Document methods should be parsed').to.exist;
108 | expect(doc.methods.length).to.equal(1);
109 |
110 | const method = doc.methods[0];
111 |
112 | expect(method.name).to.equal('publicMethod');
113 | expect(method.visibility).to.equal('public');
114 | expect(method.static).to.be.false;
115 | expect(method.description).to.equal('The method comment.');
116 |
117 | // @param keywords
118 | expect(method.params, 'Method arguments should be parsed').to.exist;
119 | expect(method.params.length).to.equal(7);
120 |
121 | const param0 = method.params[0];
122 |
123 | expect(param0.name).to.equal('param1');
124 | expect(param0.description).to.equal('the first parameter');
125 | expect(param0.type.type).to.equal('string');
126 | expect(param0.defaultValue).to.be.undefined;
127 | expect(param0.optional).to.be.false;
128 |
129 | const param1 = method.params[1];
130 |
131 | expect(param1.name).to.equal('param2');
132 | expect(param1.description).to.equal('the second parameter');
133 | expect(param1.type.type).to.equal('boolean');
134 | expect(param1.defaultValue).to.equal('false');
135 | expect(param1.optional).to.be.true;
136 |
137 | const param2 = method.params[2];
138 |
139 | expect(param2.name).to.equal('param3');
140 | expect(param2.description).to.equal('the third parameter of type number');
141 | expect(param2.type.type).to.equal('number');
142 | expect(param2.defaultValue).to.equal('1');
143 | expect(param2.optional).to.be.true;
144 |
145 | const param3 = method.params[3];
146 |
147 | expect(param3.name).to.equal('param4');
148 | expect(param3.description).to.be.null;
149 | expect(param3.type.type).to.equal('array');
150 | expect(param3.defaultValue).to.be.undefined;
151 | expect(param3.optional).to.be.true;
152 |
153 | const param4 = method.params[4];
154 |
155 | expect(param4.name).to.equal('param5');
156 | expect(param4.description).to.be.null;
157 | expect(param4.type.type).to.equal('object');
158 | expect(param4.defaultValue).to.be.undefined;
159 | expect(param4.optional).to.be.true;
160 |
161 | const param5 = method.params[5];
162 |
163 | expect(param5.name).to.equal('param6');
164 | expect(param5.description).to.be.null;
165 | expect(param5.type.type).to.equal('boolean');
166 | expect(param5.defaultValue).to.equal('true');
167 | expect(param5.optional).to.be.true;
168 |
169 | const param6 = method.params[6];
170 |
171 | expect(param6.name).to.equal('param7');
172 | expect(param6.description).to.be.null;
173 | expect(param6.type.type).to.equal('any');
174 | expect(param6.defaultValue).to.be.undefined;
175 | expect(param6.optional).to.be.false;
176 |
177 | // @returns keyword
178 | expect(method.return, 'Method return keyword should be parsed').to.exist;
179 | expect(method.return.type).to.exist;
180 | expect(method.return.type.type).to.equal('number');
181 | expect(method.return.description).to.equal('return value description');
182 |
183 | done();
184 | }).catch(e => {
185 | done(e);
186 | });
187 | });
188 | });
189 |
--------------------------------------------------------------------------------
/test/svelte3/integration/refs/ref.component.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/test/svelte3/integration/refs/ref.declared.svelte:
--------------------------------------------------------------------------------
1 |
2 | Header
3 |
4 |
5 |
--------------------------------------------------------------------------------
/test/svelte3/integration/refs/ref.simple.svelte:
--------------------------------------------------------------------------------
1 |
2 | The header
3 |
--------------------------------------------------------------------------------
/test/svelte3/integration/refs/refs.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const parser = require('../../../../index');
6 |
7 | describe('SvelteDoc v3 - Refs', () => {
8 | it('Ref to non declared variable', (done) => {
9 | parser.parse({
10 | version: 3,
11 | filename: path.resolve(__dirname, 'ref.simple.svelte'),
12 | features: ['refs'],
13 | ignoredVisibilities: []
14 | }).then((doc) => {
15 | expect(doc, 'Document should be provided').to.exist;
16 | expect(doc.refs, 'Document refs should be parsed').to.exist;
17 |
18 | expect(doc.refs.length).to.equal(1);
19 | const ref = doc.refs[0];
20 |
21 | expect(ref, 'Ref should be a valid entity').to.exist;
22 | expect(ref.name).to.equal('header');
23 | expect(ref.parent).to.equal('div');
24 | expect(ref.visibility).to.equal('private');
25 |
26 | done();
27 | }).catch(e => {
28 | done(e);
29 | });
30 | });
31 |
32 | it('Ref to declared variable', (done) => {
33 | parser.parse({
34 | version: 3,
35 | filename: path.resolve(__dirname, 'ref.declared.svelte'),
36 | features: ['refs'],
37 | ignoredVisibilities: []
38 | }).then((doc) => {
39 | expect(doc, 'Document should be provided').to.exist;
40 | expect(doc.refs, 'Document refs should be parsed').to.exist;
41 |
42 | expect(doc.refs.length).to.equal(1);
43 | const ref = doc.refs[0];
44 |
45 | expect(ref, 'Ref should be a valid entity').to.exist;
46 | expect(ref.name).to.equal('header');
47 | expect(ref.parent).to.equal('div');
48 | expect(ref.visibility).to.equal('private');
49 |
50 | done();
51 | }).catch(e => {
52 | done(e);
53 | });
54 | });
55 |
56 | it('Ref to component', (done) => {
57 | parser.parse({
58 | version: 3,
59 | filename: path.resolve(__dirname, 'ref.component.svelte'),
60 | features: ['refs'],
61 | ignoredVisibilities: []
62 | }).then((doc) => {
63 | expect(doc, 'Document should be provided').to.exist;
64 | expect(doc.refs, 'Document refs should be parsed').to.exist;
65 |
66 | expect(doc.refs.length).to.equal(1);
67 | const ref = doc.refs[0];
68 |
69 | expect(ref, 'Ref should be a valid entity').to.exist;
70 | expect(ref.name).to.equal('cart');
71 | expect(ref.parent).to.equal('ShopingCart');
72 | expect(ref.visibility).to.equal('private');
73 |
74 | done();
75 | }).catch(e => {
76 | done(e);
77 | });
78 | });
79 | });
80 |
--------------------------------------------------------------------------------
/test/svelte3/integration/slots/slot.comments.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
2 |
3 | Default slot
4 |
5 |
--------------------------------------------------------------------------------
/test/svelte3/integration/slots/slot.named.svelte:
--------------------------------------------------------------------------------
1 |
2 |
3 | Default title
4 |
5 |
6 | Default body content
7 |
8 |
--------------------------------------------------------------------------------
/test/svelte3/integration/slots/slot.parameters.svelte:
--------------------------------------------------------------------------------
1 |
2 | {#each items as item}
3 | -
4 |
8 |
9 |
10 | {/each}
11 |
12 |
13 |
--------------------------------------------------------------------------------
/test/svelte3/integration/slots/slots.spec.js:
--------------------------------------------------------------------------------
1 | const path = require('path');
2 | const chai = require('chai');
3 | const expect = chai.expect;
4 |
5 | const packageConfig = require('../../../../package.json');
6 | const parser = require('../../../../index');
7 |
8 | describe('SvelteDoc v3 - Slots', () => {
9 | it('Default slot should be found', (done) => {
10 | parser.parse({
11 | version: 3,
12 | filename: path.resolve(__dirname, 'slot.default.svelte'),
13 | features: ['slots'],
14 | ignoredVisibilities: []
15 | }).then((doc) => {
16 | expect(doc, 'Document should be provided').to.exist;
17 | expect(doc.slots, 'Document slots should be parsed').to.exist;
18 |
19 | expect(doc.slots.length).to.equal(1);
20 | const slot = doc.slots[0];
21 |
22 | expect(slot, 'Slot should be a valid entity').to.exist;
23 | expect(slot.name).to.equal('default');
24 | expect(slot.visibility).to.equal('public');
25 |
26 | done();
27 | }).catch(e => {
28 | done(e);
29 | });
30 | });
31 |
32 | it('Slot parameters should be exposed', (done) => {
33 | parser.parse({
34 | version: 3,
35 | filename: path.resolve(__dirname, 'slot.parameters.svelte'),
36 | features: ['slots'],
37 | ignoredVisibilities: []
38 | }).then((doc) => {
39 | expect(doc, 'Document should be provided').to.exist;
40 | expect(doc.slots, 'Document slots should be parsed').to.exist;
41 |
42 | expect(doc.slots.length).to.equal(1);
43 | const slot = doc.slots[0];
44 |
45 | expect(slot, 'Slot should be a valid entity').to.exist;
46 | expect(slot.name).to.equal('item');
47 | expect(slot.visibility).to.equal('public');
48 |
49 | const parameters = slot.params;
50 |
51 | expect(parameters).to.exist;
52 | expect(parameters.length).to.equal(1);
53 |
54 | const parameter = parameters[0];
55 |
56 | expect(parameter).to.exist;
57 | expect(parameter.name).to.equal('item');
58 | expect(parameter.description).to.equal('The slot parameter description.');
59 | expect(parameter.type).to.deep.eq({
60 | kind: 'type',
61 | type: 'string',
62 | text: 'string'
63 | });
64 |
65 | // TODO: 5.* | Backward compatibility test
66 | if (packageConfig.version.startsWith('5.')) {
67 | expect(slot.parameters, 'parameters field should be removed').undefined;
68 | } else {
69 | expect(slot.parameters, 'Should be backward compatable until 5.* version').to.deep.eq(slot.params);
70 | }
71 |
72 | done();
73 | }).catch(e => {
74 | done(e);
75 | });
76 | });
77 |
78 | it('Named slots should be found', (done) => {
79 | parser.parse({
80 | version: 3,
81 | filename: path.resolve(__dirname, 'slot.named.svelte'),
82 | features: ['slots'],
83 | ignoredVisibilities: []
84 | }).then((doc) => {
85 | expect(doc, 'Document should be provided').to.exist;
86 | expect(doc.slots, 'Document slots should be parsed').to.exist;
87 |
88 | expect(doc.slots.length).to.equal(2);
89 |
90 | expect(doc.slots[0], 'Slot should be a valid entity').to.exist;
91 | expect(doc.slots[0].name).to.equal('title');
92 | expect(doc.slots[0].visibility).to.equal('public');
93 |
94 | expect(doc.slots[1], 'Slot should be a valid entity').to.exist;
95 | expect(doc.slots[1].name).to.equal('body');
96 | expect(doc.slots[1].visibility).to.equal('public');
97 |
98 | done();
99 | }).catch(e => {
100 | done(e);
101 | });
102 | });
103 |
104 | it('Slot comments should be correctly parsed', done => {
105 | parser.parse({
106 | version: 3,
107 | filename: path.resolve(__dirname, 'slot.comments.svelte'),
108 | features: ['slots', 'events'],
109 | ignoredVisibilities: []
110 | }).then(doc => {
111 | expect(doc, 'Document should be provided').to.exist;
112 | expect(doc.slots, 'Document slots should be parsed').to.exist;
113 |
114 | expect(doc.slots).to.have.length(3);
115 |
116 | const firstSlot = doc.slots.find(slot => slot.name === 'first');
117 | const defaultSlot = doc.slots.find(slot => slot.name === 'default');
118 | const secondSlot = doc.slots.find(slot => slot.name === 'second');
119 |
120 | expect(firstSlot.description).to.equal('The first slot description.');
121 | expect(defaultSlot.description).to.empty;
122 | expect(secondSlot.description).to.equal('The second slot description.');
123 |
124 | expect(doc.events).to.have.length(1);
125 |
126 | const event = doc.events[0];
127 |
128 | expect(event.description).to.be.empty;
129 |
130 | done();
131 | }).catch(e => {
132 | done(e);
133 | });
134 | });
135 | });
136 |
--------------------------------------------------------------------------------
/test/unit/helpers/helpers.spec.js:
--------------------------------------------------------------------------------
1 | const chai = require('chai');
2 | const expect = chai.expect;
3 |
4 | const helpers = require('../../../lib/helpers');
5 |
6 | describe('Helpers parser module tests', () => {
7 | describe('helpers.extractHtmlBlock', () => {
8 | it('When html block exists should be provide a correct result', () => {
9 | const content = `
10 | Some content here
11 |
14 | `;
15 |
16 | const result = helpers.extractHtmlBlock(content, 'script');
17 |
18 | expect(result).is.exist;
19 | const block = result.block;
20 |
21 | expect(block).is.exist;
22 | expect(block.content).is.eq('\nlet variable = 1;\n');
23 | expect(block.offset).is.eq(34);
24 | expect(block.outerPosition).is.exist;
25 | expect(block.outerPosition.start).is.eq(26);
26 | expect(block.outerPosition.end).is.eq(62);
27 | expect(block.attributes).is.empty;
28 | });
29 |
30 | it('When html block have attribute, should be correct extracted', () => {
31 | const content = `
32 | Some content here
33 |
36 | `;
37 |
38 | const result = helpers.extractHtmlBlock(content, 'script');
39 |
40 | expect(result).is.exist;
41 | const block = result.block;
42 |
43 | expect(block).is.exist;
44 | expect(block.attributes).is.eq(' context="module"');
45 | });
46 |
47 | it('When startIndex are specified, should be skip first content and provide the next item', () => {
48 | const content = `
49 | Some content here
50 |
53 |
56 | `;
57 |
58 | const result = helpers.extractHtmlBlock(content, 'script', 62);
59 |
60 | expect(result).is.exist;
61 | const block = result.block;
62 |
63 | expect(block).is.exist;
64 | expect(block.content).is.eq('\nlet variable = 2;\n');
65 | expect(block.offset).is.eq(71);
66 | expect(block.outerPosition).is.exist;
67 | expect(block.outerPosition.start).is.eq(63);
68 | expect(block.outerPosition.end).is.eq(99);
69 | expect(block.attributes).is.empty;
70 | });
71 | });
72 |
73 | describe('helpers.extractAllHtmlBlocks', () => {
74 | it('Extract one script block', () => {
75 | const content = `
76 | Some content here
77 |
80 | `;
81 | const result = helpers.extractAllHtmlBlocks(content, 'script');
82 |
83 | expect(result).is.exist;
84 | expect(result.blocks).is.exist;
85 | expect(result.blocks.length).is.eq(1);
86 |
87 | const block = result.blocks[0];
88 |
89 | expect(block).is.exist;
90 | expect(block.offset).is.eq(34);
91 | expect(block.content).is.eq('\nlet variable = 1;\n');
92 | expect(block.attributes).is.empty;
93 | });
94 |
95 | it('Extract two script blocks', () => {
96 | const content = `
97 | Some content here
98 |
101 |
104 | `;
105 | const result = helpers.extractAllHtmlBlocks(content, 'script');
106 |
107 | expect(result).is.exist;
108 | expect(result.blocks).is.exist;
109 | expect(result.blocks.length).is.eq(2);
110 |
111 | let block = result.blocks[0];
112 |
113 | expect(block).is.exist;
114 | expect(block.offset).is.eq(34);
115 | expect(block.content).is.eq('\nlet variable = 1;\n');
116 | expect(block.attributes).is.empty;
117 |
118 | block = result.blocks[1];
119 | expect(block).is.exist;
120 | expect(block.offset).is.eq(71);
121 | expect(block.content).is.eq('\nlet variable = 2;\n');
122 | expect(block.attributes).is.empty;
123 | });
124 |
125 | // TODO Re-enable for following issue: https://github.com/alexprey/sveltedoc-parser/issues/58
126 | xit('When html block contains complex markup with escaping and string usages should provide a correct result', () => {
127 | const content = `
128 |
131 |
132 |
133 |
134 | Active tab: {activeTab1[0].title}
135 |
136 |
137 |
138 |
139 | {@html highlight(
140 | ' \n\n' +
148 | '')}
149 |
150 |
151 | `;
152 |
153 | const result = helpers.extractAllHtmlBlocks(content, 'script');
154 |
155 | expect(result).is.exist;
156 | expect(result.blocks).is.exist;
157 | expect(result.blocks.length).is.eq(1);
158 |
159 | const block = result.blocks[0];
160 |
161 | expect(block).is.exist;
162 | expect(block.offset).is.eq(9);
163 | expect(block.content).is.eq('\nexport let items = [];\n');
164 | expect(block.attributes).is.empty;
165 | });
166 | });
167 | });
168 |
--------------------------------------------------------------------------------
/test/unit/helpers/utils.spec.js:
--------------------------------------------------------------------------------
1 | const utils = require('../../../lib/utils');
2 |
3 | const espree = require('espree');
4 | const { expect } = require('chai');
5 |
6 | describe('"utils.js" module', () => {
7 | describe('"buildCamelCase" method', () => {
8 | it('when input is already camel cased then should return same value', () => {
9 | const result = utils.buildCamelCase('CamelCasedTestMethodName12');
10 |
11 | expect(result).to.equal('CamelCasedTestMethodName12');
12 | });
13 |
14 | it('when spaces used in name then should remove them and make next char uppercased', () => {
15 | const result = utils.buildCamelCase('Spaces In the name');
16 |
17 | expect(result).to.equal('SpacesInTheName');
18 | });
19 |
20 | it('when first letter is lowercased then should be changed to upper case', () => {
21 | const result = utils.buildCamelCase('lowercasedFirstLetter');
22 |
23 | expect(result).to.equal('LowercasedFirstLetter');
24 | });
25 |
26 | it('when illegal chars in name then should remove then and make next char uppercased', () => {
27 | const result = utils.buildCamelCase('Illegal-chars-In-the-name');
28 |
29 | expect(result).to.equal('IllegalCharsInTheName');
30 | });
31 | });
32 |
33 | describe('buildPropertyAccessorChainFromTokens', () => {
34 | describe('should return an accessor chain when', () => {
35 | it('tokens represent a single identifier', () => {
36 | const expectedChain = ['NOTIFY'];
37 | const script = `
38 | callee(${expectedChain.join('.')});
39 | `;
40 | const tokens = espree.tokenize(script);
41 | const identifierTokens = tokens.slice(2);
42 |
43 | const chain = utils.buildPropertyAccessorChainFromTokens(identifierTokens);
44 |
45 | expect(chain).to.deep.equal(expectedChain);
46 | });
47 |
48 | it('tokens represent chained identifiers using dot notation', () => {
49 | const expectedChain = ['EVENT', 'SIGNAL', 'NOTIFY'];
50 | const script = `
51 | callee(${expectedChain.join('.')});
52 | `;
53 | const tokens = espree.tokenize(script);
54 | const identifierTokens = tokens.slice(2);
55 |
56 | const chain = utils.buildPropertyAccessorChainFromTokens(identifierTokens);
57 |
58 | expect(chain).to.deep.equal(expectedChain);
59 | });
60 |
61 | it('tokens represent chained identifiers using mixed notation', () => {
62 | const expectedChain = ['EVENT', 'SIGNAL', 'NOTIFY'];
63 | const script = `
64 | callee(${expectedChain[0]}['${expectedChain[1]}'].${expectedChain[2]});
65 | `;
66 | const tokens = espree.tokenize(script);
67 | const identifierTokens = tokens.slice(2);
68 |
69 | const chain = utils.buildPropertyAccessorChainFromTokens(identifierTokens);
70 |
71 | expect(chain).to.deep.equal(expectedChain);
72 | });
73 | it('tokens represent chained identifiers using only bracket notation', () => {
74 | const expectedChain = ['EVENT', '"SIGNAL"', "'NOTIFY'"];
75 | const script = `
76 | callee(${expectedChain[0]}['${expectedChain[1]}']["${expectedChain[2]}"]);
77 | `;
78 | const tokens = espree.tokenize(script);
79 | const identifierTokens = tokens.slice(2);
80 |
81 | const chain = utils.buildPropertyAccessorChainFromTokens(identifierTokens);
82 |
83 | expect(chain).to.deep.equal(expectedChain);
84 | });
85 | });
86 | });
87 |
88 | describe('buildPropertyAccessorChainFromAst', () => {
89 | describe('should return an accessor chain when', () => {
90 | it('AST has a single identifier', () => {
91 | const expectedChain = ['NOTIFY'];
92 | const script = `
93 | callee(${expectedChain.join('.')});
94 | `;
95 | const ast = espree.parse(script);
96 | const node = ast.body[0].expression.arguments[0];
97 | const chain = utils.buildPropertyAccessorChainFromAst(node);
98 |
99 | expect(chain).to.deep.equal(expectedChain);
100 | });
101 |
102 | it('AST has a nested "MemberExpression" node', () => {
103 | const expectedChain = ['EVENT', 'SIGNAL', 'NOTIFY'];
104 | const script = `
105 | callee(${expectedChain.join('.')});
106 | `;
107 | const ast = espree.parse(script);
108 | const node = ast.body[0].expression.arguments[0];
109 | const chain = utils.buildPropertyAccessorChainFromAst(node);
110 |
111 | expect(chain).to.deep.equal(expectedChain);
112 | });
113 |
114 | it('AST has a nested computed "MemberExpression" node', () => {
115 | const expectedChain = ['EVENT', 'SIGNAL', 'NOTIFY'];
116 | const script = `
117 | callee(${expectedChain[0]}['${expectedChain[1]}'].${expectedChain[2]});
118 | `;
119 | const ast = espree.parse(script);
120 | const node = ast.body[0].expression.arguments[0];
121 | const chain = utils.buildPropertyAccessorChainFromAst(node);
122 |
123 | expect(chain).to.deep.equal(expectedChain);
124 | });
125 |
126 | it('AST has only nested computed "MemberExpression" nodes', () => {
127 | const expectedChain = ['EVENT', 'SIGNAL', 'NOTIFY'];
128 | const script = `
129 | callee(${expectedChain[0]}['${expectedChain[1]}']["${expectedChain[2]}"]);
130 | `;
131 | const ast = espree.parse(script);
132 | const node = ast.body[0].expression.arguments[0];
133 | const chain = utils.buildPropertyAccessorChainFromAst(node);
134 |
135 | expect(chain).to.deep.equal(expectedChain);
136 | });
137 | });
138 | });
139 |
140 | describe('buildObjectFromObjectExpression', () => {
141 | it('should build an object from an AST containing a nested "ObjectExpression" node', () => {
142 | const expectedObject = {
143 | SIGNAL: {
144 | NOTIFY: 'notify'
145 | }
146 | };
147 | const script = `
148 | var EVENT = {
149 | SIGNAL: {
150 | NOTIFY: 'notify'
151 | }
152 | }`;
153 | const ast = espree.parse(script);
154 | const node = ast.body[0].declarations[0].init;
155 | const object = utils.buildObjectFromObjectExpression(node);
156 |
157 | expect(object).to.deep.equal(expectedObject);
158 | });
159 |
160 | it('should ignore unsupported node types', () => {
161 | const expectedObject = {
162 | SIGNAL: {
163 | NOTIFY: 'notify'
164 | },
165 | LITERAL: true,
166 | };
167 | const script = `
168 | var EVENT = {
169 | SIGNAL: {
170 | NOTIFY: 'notify'
171 | },
172 | OTHER: ['notify'],
173 | LITERAL: true,
174 | }`;
175 | const ast = espree.parse(script);
176 | const node = ast.body[0].declarations[0].init;
177 | const object = utils.buildObjectFromObjectExpression(node);
178 |
179 | expect(object).to.deep.equal(expectedObject);
180 | });
181 | });
182 |
183 | describe('getValueForPropertyAccessorChain', () => {
184 | it('should return the default value when value is unreachable', () => {
185 | const script = `
186 | var EVENT = {
187 | SIGNAL: {}
188 | }`;
189 | const ast = espree.parse(script);
190 | const node = ast.body[0].declarations[0].init;
191 | const container = {
192 | EVENT: node
193 | };
194 | const chain = ['EVENT', 'SIGNAL', 'NOTIFY'];
195 | const value = utils.getValueForPropertyAccessorChain(container, chain);
196 |
197 | expect(value).to.equal(utils.UNHANDLED_EVENT_NAME);
198 | });
199 |
200 | it('should return the default value when visiting an unsupported node', () => {
201 | const script = `
202 | var EVENT = {
203 | SIGNAL: ['notify']
204 | }`;
205 | const ast = espree.parse(script);
206 | const node = ast.body[0].declarations[0].init;
207 | const container = {
208 | EVENT: node
209 | };
210 | const chain = ['EVENT', 'SIGNAL', '0'];
211 | const value = utils.getValueForPropertyAccessorChain(container, chain);
212 |
213 | expect(value).to.equal(utils.UNHANDLED_EVENT_NAME);
214 | });
215 |
216 | it('should return the correct value when searching an object', () => {
217 | const expectedValue = 'notify';
218 | const script = `
219 | var EVENT = {
220 | SIGNAL: {
221 | NOTIFY: 'notify'
222 | }
223 | }`;
224 | const ast = espree.parse(script);
225 | const node = ast.body[0].declarations[0].init;
226 | const container = {
227 | EVENT: node
228 | };
229 | const chain = ['EVENT', 'SIGNAL', 'NOTIFY'];
230 | const value = utils.getValueForPropertyAccessorChain(container, chain);
231 |
232 | expect(value).to.equal(expectedValue);
233 | });
234 | });
235 | });
236 |
--------------------------------------------------------------------------------
/test/unit/options/options.spec.js:
--------------------------------------------------------------------------------
1 | const expect = require('chai').expect;
2 |
3 | const {
4 | validate,
5 | validateFeatures,
6 | retrieveFileOptions,
7 | OptionsError,
8 | ParserError
9 | } = require('../../../lib/options');
10 |
11 | const baseOptions = { filename: 'empty.svelte' };
12 |
13 | describe('Options Module', () => {
14 | describe('options.validate', () => {
15 | describe('Should throw when', () => {
16 | it('options object is missing', () => {
17 | expect(() => validate()).to.throw(OptionsError.OptionsRequired);
18 | });
19 |
20 | it('input is missing, not a string, or an empty filename', () => {
21 | expect(() => validate({})).to.throw(OptionsError.InputRequired);
22 | expect(() => validate({ filename: {} })).to.throw(OptionsError.InputRequired);
23 | expect(() => validate({ filename: '' })).to.throw(OptionsError.InputRequired);
24 | expect(() => validate({ fileContent: {} })).to.throw(OptionsError.InputRequired);
25 | });
26 |
27 | it('encoding is not a string', () => {
28 | const options = { ...baseOptions, encoding: true };
29 |
30 | expect(() => validate(options)).to.throw(OptionsError.EncodingFormat);
31 | });
32 |
33 | it('encoding is not supported', () => {
34 | const unsupported = 'l33t-enc';
35 | const options = { ...baseOptions, encoding: unsupported };
36 |
37 | expect(() => validate(options)).to.throw(
38 | OptionsError.EncodingNotSupported(unsupported)
39 | );
40 | });
41 |
42 | it('ignoreVisibilities is not an array', () => {
43 | const unsupported = 'unsupported';
44 | const mixed = ['private', unsupported];
45 | const options = { ...baseOptions, ignoredVisibilities: mixed };
46 |
47 | expect(() => validate(options)).to.throw(
48 | OptionsError.IgnoredVisibilitiesNotSupported([unsupported])
49 | );
50 | });
51 |
52 | it('ignoreVisibilities contains at least one unsupported visibility', () => {
53 | const unsupported = 'unsupported';
54 | const mixed = ['private', unsupported];
55 | const options = { ...baseOptions, ignoredVisibilities: mixed };
56 |
57 | expect(() => validate(options)).to.throw(
58 | OptionsError.IgnoredVisibilitiesNotSupported([unsupported])
59 | );
60 | });
61 |
62 | it('includeSourceLocations is not a boolean', () => {
63 | const options = { ...baseOptions, includeSourceLocations: 'true' };
64 |
65 | expect(() => validate(options)).to.throw(
66 | OptionsError.IncludeSourceLocationsFormat
67 | );
68 | });
69 | });
70 |
71 | describe('Should pass when', () => {
72 | it('just filename is present', () => {
73 | expect(() => validate(baseOptions)).to.not.throw();
74 | });
75 |
76 | it('just fileContent is present', () => {
77 | expect(() => validate({ fileContent: 'content' })).to.not.throw();
78 | });
79 |
80 | it('fileContent is empty', () => {
81 | expect(() => validate({ fileContent: '' })).to.not.throw();
82 | });
83 |
84 | it('ignoreVisibilities is an empty array', () => {
85 | const options = { ...baseOptions, ignoredVisibilities: [] };
86 |
87 | expect(() => validate(options)).to.not.throw();
88 | });
89 |
90 | it('ignoreVisibilities is an array of supported visibilities', () => {
91 | const options = {
92 | ...baseOptions,
93 | ignoredVisibilities: ['protected', 'public']
94 | };
95 |
96 | expect(() => validate(options)).to.not.throw();
97 | });
98 |
99 | it('includeSourceLocations is a boolean', () => {
100 | const options1 = { ...baseOptions, includeSourceLocations: false };
101 | const options2 = { ...baseOptions, includeSourceLocations: true };
102 |
103 | expect(() => validate(options1)).to.not.throw();
104 | expect(() => validate(options2)).to.not.throw();
105 | });
106 | });
107 | });
108 |
109 | describe('options.validateFeatures', () => {
110 | describe('Should pass when', () => {
111 | it('only supported features are present', () => {
112 | const supported = ['something', 'else'];
113 |
114 | const single = ['something'];
115 | const options1 = { features: single };
116 |
117 | expect(() => validateFeatures(options1, supported)).to.not.throw();
118 |
119 | const all = ['else', 'something'];
120 | const options2 = { features: all };
121 |
122 | expect(() => validateFeatures(options2, supported)).to.not.throw();
123 | });
124 | });
125 |
126 | describe('Should throw when', () => {
127 | it('features is not an array', () => {
128 | expect(() => validateFeatures({ features: {} }, []))
129 | .to.throw(ParserError.FeaturesFormat);
130 |
131 | expect(() => validateFeatures({ features: true }, []))
132 | .to.throw(ParserError.FeaturesFormat);
133 |
134 | expect(() => validateFeatures({ features: 'something' }, []))
135 | .to.throw(ParserError.FeaturesFormat);
136 | });
137 |
138 | it('features is an empty array', () => {
139 | const supported = ['something', 'else'];
140 |
141 | expect(() => validateFeatures({ features: [] }, supported))
142 | .to.throw(ParserError.FeaturesEmpty(supported));
143 | });
144 |
145 | it('one or more features are not supported', () => {
146 | const supported = ['something', 'else'];
147 |
148 | const notSupported1 = ['other'];
149 | const options1 = { features: notSupported1 };
150 |
151 | expect(() => validateFeatures(options1, supported)).to.throw(
152 | ParserError.FeaturesNotSupported(notSupported1, supported)
153 | );
154 |
155 | const notSupported2 = ['other', 'bad', 'trash'];
156 | const options2 = { features: notSupported2 };
157 |
158 | expect(() => validateFeatures(options2, supported)).to.throw(
159 | ParserError.FeaturesNotSupported(notSupported2, supported)
160 | );
161 | });
162 |
163 | it('some features are not supported', () => {
164 | const supported = ['something', 'else', 'stuff'];
165 | const notSupported = ['other', 'thing'];
166 |
167 | const mixed = ['stuff', ...notSupported, 'something'];
168 | const options2 = { features: mixed };
169 |
170 | expect(() => validateFeatures(options2, supported)).to.throw(
171 | ParserError.FeaturesNotSupported(notSupported, supported)
172 | );
173 | });
174 | });
175 | });
176 |
177 | describe('options.retrieveFileOptions', () => {
178 | it('Should return all file-related keys from options', () => {
179 | expect(retrieveFileOptions(baseOptions)).to.have.keys(
180 | 'filename', 'fileContent', 'structure', 'encoding'
181 | );
182 | });
183 | });
184 | });
185 |
--------------------------------------------------------------------------------