597fec2007d5efffba0c6f07e4a8646ec7a6d409
[fnpeditor.git] / modules / documentCanvas / canvas / canvas.test3.js
1 define([
2 'libs/chai',
3 'modules/documentCanvas/canvas/canvas',
4 'modules/documentCanvas/canvas/documentElement'
5 ], function(chai, canvas, documentElement) {
6     
7 'use strict';
8
9 var expect = chai.expect;
10
11
12 describe('Canvas', function() {
13
14     describe('Internal HTML representation of a sample document', function() {
15         it('works', function() {
16             var c = canvas.fromXML('\
17                 <section>\
18                     This is some text without its own wrapping tag.\
19                     <div class="p.subclass">\
20                         This is a paragraph.\
21                     </div>\
22                     <div>\
23                         This is text in a div <span>with some inline text</span>.\
24                     </div>\
25                     This is some text without its own wrapping tag.\
26                 </section>\
27             ');
28             var expected = '<div wlxml-tag="section">'
29                             + 'This is some text without its own wrapping tag.'
30                             + '<div wlxml-tag="div" wlxml-class="p-subclass">This is a paragraph.</div>'
31                             + '<div wlxml-tag="div">This is text in a div <div wlxml-tag="span">with some inline text</div>.</div>'
32                             + 'This is some text without its own wrapping tag.'
33                             + '</div>';
34             expect(c.doc().dom()[0].isEqualNode($(expected)[0])).to.be.true;
35         });
36     });
37
38     describe('Internal HTML representation of a DocumentNodeElement', function() {
39         it('is always a div tag', function() {
40             ['section', 'header', 'span', 'aside', 'figure'].forEach(function(tagName) {
41                 var dom = canvas.fromXML('<' + tagName + '></' + tagName + '>').doc().dom();
42                 expect(dom.prop('tagName')).to.equal('DIV', tagName + ' is represented as div');
43             });
44         });
45         it('has wlxml tag put into wlxml-tag attribute', function() {
46             var dom = canvas.fromXML('<section></section>').doc().dom();
47             expect(dom.attr('wlxml-tag')).to.equal('section');
48         });
49         it('has wlxml class put into wlxml-class, dots replaced with dashes', function() {
50             var dom = canvas.fromXML('<section class="some.class"></section>').doc().dom();
51             expect(dom.attr('wlxml-class')).to.equal('some-class');
52         });
53     });
54
55     describe('Internal HTML representation of a DocumentTextElement', function() {
56         it('is just a TextNode', function() {
57             var dom = canvas.fromXML('<section>Alice</section>').doc().children()[0].dom();
58             expect(dom[0].nodeType === Node.TEXT_NODE);
59         });
60     });
61
62     describe('basic properties', function() {
63         it('renders empty document when canvas created from empty XML', function() {
64             var c = canvas.fromXML('');
65             expect(c.doc()).to.equal(null);
66         });
67
68         it('gives access to its document root node', function() {
69             var c = canvas.fromXML('<section></section>');
70             expect(c.doc().wlxmlTag).to.equal('section');
71         });
72
73         describe('DocumentTextElement', function() {
74             it('can have its content set', function() {
75                 var c = canvas.fromXML('<section>Alice</section>'),
76                     root = c.doc(),
77                     text = root.children()[0];
78                 
79                 text.setText('a cat');
80                 expect(root.children()[0].getText()).to.equal('a cat');
81             });
82         });
83
84         describe('DocumentNodeElement', function() {
85             it('knows index of its child', function() {
86                 var c = canvas.fromXML('<section><div></div><header></header><span></span></section>'),
87                     root = c.doc(),
88                     child = root.children()[1];
89                 expect(root.childIndex(child)).to.equal(1);
90             });
91
92             it('knows WLXML tag it renders', function(){
93                 var c = canvas.fromXML('<section></section>'),
94                     section = c.doc();
95                 expect(section.getWlxmlTag()).to.equal('section', 'initial tag is section');
96                 section.setWlxmlTag('header');
97                 expect(section.getWlxmlTag()).to.equal('header', 'tag is changed to header');
98             });
99
100             it('knows WLXML class of a WLXML tag it renders', function(){
101                 var c = canvas.fromXML('<section class="some.class"></section>'),
102                     section = c.doc();
103                 expect(section.getWlxmlClass()).to.equal('some.class');
104                 section.setWlxmlClass('some.other.class');
105                 expect(section.getWlxmlClass()).to.equal('some.other.class');
106                 section.setWlxmlClass(null);
107                 expect(section.getWlxmlClass()).to.be.undefined;
108             });
109         });
110     });
111
112
113
114     describe('document representation api', function() {
115         describe('document root element', function() {
116             var c = canvas.fromXML('<section></section>');
117             it('exists', function() {
118                 expect(c.doc()).to.be.instanceOf(documentElement.DocumentElement);
119             });
120             it('is of type DocumentNodeElement', function() {
121                 expect(c.doc()).to.be.instanceOf(documentElement.DocumentNodeElement);
122             });
123         });
124
125         describe('DocumentElements comparison', function() {
126             it('reports dwo DocumentElements to be the same when they represent the same wlxml document element', function() {
127                 var c = canvas.fromXML('<section><div></div><div></div></section>'),
128                     first_div1 = c.doc().children()[0],
129                     first_div2 = c.doc().children()[0],
130                     second_div = c.doc().children()[1];
131                 expect(first_div1.sameNode(first_div1)).to.be.true;
132                 expect(first_div1.sameNode(first_div2)).to.be.true;
133                 expect(first_div1.sameNode(second_div)).to.be.false;
134             });
135         });
136
137         describe('traversing', function() {
138             it('reports element nodes', function() {
139                 var c = canvas.fromXML('<section><div></div></section>'),
140                     children = c.doc().children();
141                 expect(children.length).to.equal(1);
142                 expect(children[0]).to.be.instanceOf(documentElement.DocumentNodeElement);
143
144                 c = canvas.fromXML('<section><div></div><div></div></section>'),
145                     children = c.doc().children();
146                 expect(children.length).to.equal(2);
147                 expect(children[0]).to.be.instanceOf(documentElement.DocumentNodeElement);
148                 expect(children[1]).to.be.instanceOf(documentElement.DocumentNodeElement);
149             });
150             
151             it('reports text nodes', function() {
152                 var c = canvas.fromXML('<section>Alice</section>'),
153                     children = c.doc().children();
154                 expect(children.length).to.equal(1);
155                 expect(children[0]).to.be.instanceOf(documentElement.DocumentTextElement);
156             });
157
158             describe('accessing parents', function() {
159                 it('returns DocumentNodeElement representing parent in wlxml document as DocumentNodeElement parent', function() {
160                     var c = canvas.fromXML('<section><div></div></section>'),
161                         div = c.doc().children()[0];
162                     expect(div.parent().sameNode(c.doc())).to.be.true;
163                 });
164                 it('returns DocumentNodeElement representing parent in wlxml document as DocumentTextElement parent', function() {
165                     var c = canvas.fromXML('<section>Alice</section>'),
166                         text = c.doc().children()[0];
167                     expect(text.parent().sameNode(c.doc())).to.be.true;
168                 });
169             });
170
171             describe('free text handling', function() {
172                     it('sees free text', function() {
173                         var c = canvas.fromXML('<section>Alice <span>has</span> a cat</section>'),
174                             children = c.doc().children();
175                         expect(children.length).to.equal(3);
176                         expect(children[0]).to.be.instanceOf(documentElement.DocumentTextElement);
177                         expect(children[1]).to.be.instanceOf(documentElement.DocumentNodeElement);
178                         expect(children[2]).to.be.instanceOf(documentElement.DocumentTextElement);
179                     });
180             });
181             
182             describe('white characters handling', function() {
183                 it('says empty element node has no children', function() {
184                     var c = canvas.fromXML('<section></section>');
185                     expect(c.doc().children().length).to.equal(0);
186                 });
187                 it('says element node with one space has one DocumentTextElement', function() {
188                     var c = canvas.fromXML('<section> </section>');
189                     expect(c.doc().children().length).to.equal(1);
190                     expect(c.doc().children()[0]).to.be.instanceOf(documentElement.DocumentTextElement);
191                     expect(c.doc().children()[0].getText()).to.equal(' ');
192                 });
193                 it('ignores white space surrounding block elements', function() {
194                     var c = canvas.fromXML('<section> <div></div> </section>');
195                     var children = c.doc().children();
196                     expect(children.length).to.equal(1);
197                     expect(children[0]).to.be.instanceOf(documentElement.DocumentNodeElement);
198                 });
199                 it('ignores white space between block elements', function() {
200                     var c = canvas.fromXML('<section><div></div> <div></div></section>');
201                     var children = c.doc().children();
202                     expect(children.length === 2);
203                     [0,1].forEach(function(idx) {
204                         expect(children[idx]).to.be.instanceOf(documentElement.DocumentNodeElement);
205                     });
206                 });
207
208                 it('trims white space from the beginning and the end of the block elements', function() {
209                     var c = canvas.fromXML('<section> Alice <span>has</span> a cat </section>');
210                     expect(c.doc().children()[0].getText()).to.equal('Alice ');
211                     expect(c.doc().children()[2].getText()).to.equal(' a cat');
212                 });
213
214                 it('normalizes string of white characters to one space at the inline element boundries', function() {
215                     var c = canvas.fromXML('<span>   Alice has a cat   </span>');
216                     expect(c.doc().children()[0].getText()).to.equal(' Alice has a cat ');
217                 });
218
219                 it('normalizes string of white characters to one space before inline element', function() {
220                     var c = canvas.fromXML('<div>Alice has  <span>a cat</span></div>');
221                     expect(c.doc().children()[0].getText()).to.equal('Alice has ');
222                 });
223                 
224                 it('normalizes string of white characters to one space after inline element', function() {
225                     var c = canvas.fromXML('<div>Alice has <span>a</span>  cat</div>');
226                     expect(c.doc().children()[2].getText()).to.equal(' cat');
227                 });
228             });
229         });
230
231         describe('manipulation api', function() {
232
233             describe('Basic Element inserting', function() {
234                 it('can put new NodeElement at the end', function() {
235                     var c = canvas.fromXML('<section></section>'),
236                         appended = c.doc().append({tag: 'header', klass: 'some.class'}),
237                         children = c.doc().children();
238
239                     expect(children.length).to.equal(1);
240                     expect(children[0].sameNode(appended));
241                 });
242
243                 it('can put new TextElement at the end', function() {
244                     var c = canvas.fromXML('<section></section>'),
245                         appended = c.doc().append({text: 'Alice'}),
246                         children = c.doc().children();
247
248                     expect(children.length).to.equal(1);
249                     expect(children[0].sameNode(appended));
250                     expect(children[0].getText()).to.equal('Alice');
251                 });
252
253                 it('can put new NodeElement after another NodeElement', function() {
254                     var c = canvas.fromXML('<section><div></div></section>'),
255                         div = c.doc().children()[0],
256                         added = div.after({tag: 'header', klass: 'some.class'}),
257                         children = c.doc().children();
258                     expect(children.length).to.equal(2);
259                     expect(children[1].sameNode(added));
260                 });
261
262                 it('can put new Nodeelement before another element', function() {
263                     var c = canvas.fromXML('<section><div></div></section>'),
264                         div = c.doc().children()[0],
265                         added = div.before({tag: 'header', klass: 'some.class'}),
266                         children = c.doc().children();
267                     expect(children.length).to.equal(2);
268                     expect(children[0].sameNode(added));
269                 });
270
271                 it('can put new DocumentNodeElement after DocumentTextElement', function() {
272                     var c = canvas.fromXML('<section>Alice</section>'),
273                         text = c.doc().children()[0],
274                         added = text.after({tag: 'p'}),
275                         children = c.doc().children();
276
277                     expect(children.length).to.equal(2);
278                     expect(children[0]).to.be.instanceOf(documentElement.DocumentTextElement);
279                     expect(children[0].getText()).to.equal('Alice');
280                     expect(children[1]).to.be.instanceOf(documentElement.DocumentNodeElement);
281                     expect(children[1].sameNode(added)).to.be.true;
282                 });
283                 it('can put new DocumentNodeElement before DocumentTextElement', function() {
284                     var c = canvas.fromXML('<section>Alice</section>'),
285                         text = c.doc().children()[0],
286                         added = text.before({tag: 'p'}),
287                         children = c.doc().children();
288
289                     expect(children.length).to.equal(2);
290                     expect(children[0]).to.be.instanceOf(documentElement.DocumentNodeElement);
291                     expect(children[0].sameNode(added)).to.be.true;
292                     expect(children[1]).to.be.instanceOf(documentElement.DocumentTextElement);
293                     expect(children[1].getText()).to.equal('Alice');
294                 });
295             });
296
297             describe('Splitting text', function() {
298                 
299                 it('splits DocumentTextElement\'s parent into two DocumentNodeElements of the same type', function() {
300                     var c = canvas.fromXML('<section><header>Some header</header></section>'),
301                         section = c.doc(),
302                         text = section.children()[0].children()[0];
303
304                     text.split({offset: 5});
305                     expect(section.children().length).to.equal(2, 'section has two children');
306                     
307                     var header1 = section.children()[0];
308                     var header2 = section.children()[1];
309
310                     expect(header1.wlxmlTag).to.equal('header', 'first section child represents wlxml header');
311                     expect(header1.children().length).to.equal(1, 'first header has one text child');
312                     expect(header1.children()[0].getText()).to.equal('Some ', 'first header has correct content');
313                     expect(header2.wlxmlTag).to.equal('header', 'second section child represents wlxml header');
314                     expect(header2.children().length).to.equal(1, 'second header has one text child');
315                     expect(header2.children()[0].getText()).to.equal('header', 'second header has correct content');
316                 });
317
318                 it('keeps DocumentTextElement\'s parent\'s children elements intact', function() {
319                     var c = canvas.fromXML('\
320                             <section>\
321                                 <header>\
322                                     A <span>fancy</span> and <span>nice</span> header\
323                                 </header>\
324                             </section>'),
325                         section = c.doc(),
326                         header = section.children()[0],
327                         textAnd = header.children()[2];
328
329                     textAnd.split({offset: 2});
330                     
331                     var sectionChildren = section.children();
332                     expect(sectionChildren.length).to.equal(2, 'Section has two children');
333                     expect(sectionChildren[0].wlxmlTag).to.equal('header', 'First section element is a wlxml header');
334                     expect(sectionChildren[1].wlxmlTag).to.equal('header', 'Second section element is a wlxml header');
335
336                     var firstHeaderChildren = sectionChildren[0].children();
337                     expect(firstHeaderChildren.length).to.equal(3, 'First header has three children');
338                     expect(firstHeaderChildren[0].getText()).to.equal('A ', 'First header starts with a text');
339                     expect(firstHeaderChildren[1].wlxmlTag).to.equal('span', 'First header has span in the middle');
340                     expect(firstHeaderChildren[2].getText()).to.equal(' a', 'First header ends with text');
341
342                     var secondHeaderChildren = sectionChildren[1].children();
343                     expect(secondHeaderChildren.length).to.equal(3, 'Second header has three children');
344                     expect(secondHeaderChildren[0].getText()).to.equal('nd ', 'Second header starts with text');
345                     expect(secondHeaderChildren[1].wlxmlTag).to.equal('span', 'Second header has span in the middle');
346                     expect(secondHeaderChildren[2].getText()).to.equal(' header', 'Second header ends with text');
347                 });
348             });
349
350             describe('wrapping', function() {
351                 it('wraps DocumentNodeElement', function() {
352                     var c = canvas.fromXML('<section><div></div></section>'),
353                         div = c.doc().children()[0];
354                     
355                     var returned = div.wrapWithNodeElement({tag: 'header', klass: 'some.class'}),
356                         parent = div.parent(),
357                         parent2 = c.doc().children()[0];
358
359                     expect(returned.sameNode(parent)).to.be.true;
360                     expect(returned.sameNode(parent2)).to.be.true;
361                 });
362                 it('wraps DocumentTextElement', function() {
363                     var c = canvas.fromXML('<section>Alice</section>'),
364                         text = c.doc().children()[0];
365                     
366                     var returned = text.wrapWithNodeElement({tag: 'header', klass: 'some.class'}),
367                         parent = text.parent(),
368                         parent2 = c.doc().children()[0];
369
370                     expect(returned.sameNode(parent)).to.be.true;
371                     expect(returned.sameNode(parent2)).to.be.true;
372                 });
373                 
374                 it('wraps part of DocumentTextElement', function() {
375                     var c = canvas.fromXML('<section>Alice has a cat</section>'),
376                         text = c.doc().children()[0];
377                     
378                     var returned = text.wrapWithNodeElement({tag: 'header', klass: 'some.class', start: 5, end: 12}),
379                         children = c.doc().children();
380
381                     expect(children.length).to.equal(3);
382                     
383                     expect(children[0]).to.be.instanceOf(documentElement.DocumentTextElement);
384                     expect(children[0].getText()).to.equal('Alice');
385
386                     expect(children[1].sameNode(returned)).to.be.true;
387                     expect(children[1].children().length).to.equal(1);
388                     expect(children[1].children()[0].getText()).to.equal(' has a ');
389
390                     expect(children[2]).to.be.instanceOf(documentElement.DocumentTextElement);
391                     expect(children[2].getText()).to.equal('cat');
392                 });
393
394                 it('wraps text spanning multiple sibling DocumentTextNodes', function() {
395                     var c = canvas.fromXML('<section>Alice has a <span>small</span> cat</section>'),
396                         section = c.doc(),
397                         wrapper = c.wrapText({
398                             inside: section, 
399                             _with: {tag: 'span', klass: 'some.class'},
400                             offsetStart: 6,
401                             offsetEnd: 4,
402                             textNodeIdx: [0,2]
403                         });
404
405                     expect(section.children().length).to.equal(2);
406                     expect(section.children()[0]).to.be.instanceOf(documentElement.DocumentTextElement);
407                     expect(section.children()[0].getText()).to.equal('Alice ');
408
409                     var wrapper2 = section.children()[1];
410                     expect(wrapper2.sameNode(wrapper)).to.be.true;
411
412                     var wrapperChildren = wrapper.children();
413                     expect(wrapperChildren.length).to.equal(3);
414                     expect(wrapperChildren[0].getText()).to.equal('has a ');
415
416                     expect(wrapperChildren[1]).to.be.instanceOf(documentElement.DocumentNodeElement);
417                     expect(wrapperChildren[1].children().length).to.equal(1);
418                     expect(wrapperChildren[1].children()[0].getText()).to.equal('small');
419
420                     expect(wrapperChildren[2].getText()).to.equal(' cat');
421                 });
422             });
423         });
424
425         describe('Lists api', function() {
426             it('allows creation of a list from existing sibling DocumentElements', function() {
427                 var c = canvas.fromXML('\
428                     <section>\
429                         Alice\
430                         <div>has</div>\
431                         a\
432                         <div>cat</div>\
433                     </section>'),
434                     section = c.doc(),
435                     textAlice = section.children()[0],
436                     divCat = section.children()[3]
437                 
438                 c.list.create({element1: textAlice, element2: divCat});
439
440                 expect(section.children().length).to.equal(1, 'section has one child element');
441
442                 var list = section.children()[0];
443                 expect(list.is('list')).to.equal(true, 'section\'s only child is a list');
444                 expect(list.children().length).to.equal(4, 'list contains four elements');
445                 list.children().forEach(function(child) {
446                     expect(child.getWlxmlClass()).to.equal('item', 'list childs have wlxml class of item');
447                 });
448             });
449
450             it('allows extracting continuous list of list items from its list', function() {
451                 var c = canvas.fromXML('\
452                     <section>\
453                         <div class="list.items">\
454                             <div class="item">0</div>\
455                             <div class="item">1</div>\
456                             <div class="item">2</div>\
457                             <div class="item">3</div>\
458                         </div>\
459                     </section>'),
460                     list = c.doc().children()[0],
461                     item1 = list.children()[1],
462                     item2 = list.children()[2];
463
464                 c.list.extractItems({element1: item1, element2: item2});
465
466                 var section = c.doc(),
467                     list1 = section.children()[0],
468                     oldItem1 = section.children()[1],
469                     oldItem2 = section.children()[2],
470                     list2 = section.children()[3];
471
472                 expect(section.children().length).to.equal(4, 'section contains four children');
473                 
474                 expect(list1.is('list')).to.equal(true, 'first section child is a list');
475                 expect(list1.children().length).to.equal(1, 'first list has one child');
476                 expect(list1.children()[0].children()[0].getText()).to.equal('0', 'first item of the first list is a first item of the original list');
477
478                 expect(oldItem1.children()[0].getText()).to.equal('1', 'first item got extracted');
479                 expect(oldItem1.getWlxmlClass() === undefined).to.equal(true, 'first extracted element has no wlxml class');
480
481                 expect(oldItem2.children()[0].getText()).to.equal('2', 'second item got extracted');
482                 expect(oldItem2.getWlxmlClass() === undefined).to.equal(true, 'second extracted element has no wlxml class');
483
484                 expect(list2.is('list')).to.equal(true, 'last section child is a list');
485                 expect(list2.children().length).to.equal(1, 'second list has one child');
486                 expect(list2.children()[0].children()[0].getText()).to.equal('3', 'first item of the second list is a last item of the original list');
487             });
488
489             it('removes list if all its items are extracted', function() {
490                 var c = canvas.fromXML('\
491                     <section>\
492                         <div class="list.items">\
493                             <div class="item">some item</div>\
494                         </div>\
495                     </section>'),
496                     list = c.doc().children()[0],
497                     item = list.children()[0];
498
499                 c.list.extractItems({element1: item, element2: item});
500
501                 var section = c.doc(),
502                     list1 = section.children()[0],
503                     oldItem1 = section.children()[1],
504                     oldItem2 = section.children()[2],
505                     list2 = section.children()[3];
506
507                 expect(section.children().length).to.equal(1, 'section contains one child');
508             });
509         });
510
511     });
512 });
513
514
515 });