516b47cc972422b89d4eb2626ff759c6563feb41
[fnpeditor.git] / src / wlxml / wlxml.test.js
1 define([
2     'libs/chai',
3     './wlxml.js'
4 ], function(chai, wlxml) {
5     
6 'use strict';
7
8 /* jshint expr:true */
9 /* global it, describe, beforeEach */
10
11 var expect = chai.expect;
12
13 var nodeFromXML = function(xml) {
14     return wlxml.WLXMLElementNodeFromXML(xml);
15 };
16
17 var getDocumentFromXML = function(xml, options) {
18     return wlxml.WLXMLDocumentFromXML(xml, options || {});
19 };
20
21
22 describe('WLXMLDocument', function() {
23     
24     describe('Basic wlxml element node properties', function() {
25         it('returns its class', function() {
26             var node = nodeFromXML('<header class="class.subclass"></header>');
27             expect(node.getClass()).to.equal('class.subclass');
28         });
29
30         it('returns unregistered attributes', function() {
31             var testClasses = {
32                     'testClass': {
33                         attrs: {'attr1': {type: 'string'}}
34                     }
35                 },
36                 doc = getDocumentFromXML('<span class="testClass" attr="val" attr1="val1"></span>', {wlxmlClasses: testClasses});
37             expect(doc.root.getOtherAttributes()).to.eql({attr: {value:'val'}});
38         });
39     });
40
41     describe('WLXML node meta attributes', function() {
42
43         it('inherits keys from super classes', function() {
44             var testClasses = {
45                     '': {
46                         attrs: {'common': {type: 'string'}}
47                     },
48                     'a': {
49                         attrs: {'a_attr': {type: 'string'}}
50                     },
51                     'a.b': {
52                         attrs: {'a_b_attr': {type: 'string'}}
53                     },
54                     'a.b.c': {
55                         attrs: {'a_b_c_attr': {type: 'string'}}
56                     }
57                 },
58                 doc = getDocumentFromXML('<section></section>', {wlxmlClasses: testClasses}),
59                 section = doc.root;
60
61             expect(section.getMetaAttributes().keys()).to.eql(['common']);
62
63             section.setClass('a');
64             expect(section.getMetaAttributes().keys().sort()).to.eql(['common', 'a_attr'].sort());
65
66             section.setClass('a.b');
67             expect(section.getMetaAttributes().keys().sort()).to.eql(['common', 'a_attr', 'a_b_attr'].sort());
68
69             section.setClass('a.b.c');
70             expect(section.getMetaAttributes().keys().sort()).to.eql(['common', 'a_attr', 'a_b_attr', 'a_b_c_attr'].sort());
71         });
72
73         describe('api', function() {
74             it('returns meta attributes as a dict', function() {
75                 var testClasses = {
76                         'test': {
77                             attrs: {
78                                 attr1: {type: 'string'},
79                                 attr2: {type: 'date'}
80                             }
81                         }
82                     },
83                     node = getDocumentFromXML(
84                         '<span class="test" attr1="val1" attr2="2014-01-01"></span>',
85                         {wlxmlClasses: testClasses}
86                     ).root,
87                     attrs = node.getMetaAttributes();
88
89                 expect(attrs.keys().sort()).to.eql(['attr1', 'attr2'].sort());
90                 expect(attrs.attr1.value).to.equal('val1');
91                 expect(attrs.attr1.type).to.equal('string');
92                 expect(attrs.attr2.value).to.equal('2014-01-01');
93                 expect(attrs.attr2.type).to.equal('date');
94             });
95             it('returns undefined value if attribute is missing', function() {
96                 var testClasses = {
97                         'test': {
98                             attrs: {
99                                 attr1: {type: 'string'},
100                             }
101                         }
102                     },
103                     node = getDocumentFromXML('<span class="test"></span>', {wlxmlClasses: testClasses}).root,
104                     attrs = node.getMetaAttributes();
105                     expect(attrs.attr1.value).to.be.undefined;
106             });
107         });
108     });
109
110     describe('White space handling', function() {
111         /* globals Node */
112
113         it('ignores white space surrounding block elements', function() {
114             var node = nodeFromXML('<section> <div></div> </section>'),
115                 contents = node.contents();
116             expect(contents).to.have.length(1);
117             expect(contents[0].nodeType).to.equal(Node.ELEMENT_NODE);
118         });
119         it('ignores white space between block elements', function() {
120             var node = nodeFromXML('<section><div></div> <div></div></section>'),
121             contents = node.contents();
122             expect(contents).to.have.length(2);
123             [0,1].forEach(function(idx) {
124                 expect(contents[idx].nodeType).to.equal(Node.ELEMENT_NODE);
125             });
126         });
127         it('trims white space from the beginning and the end of the block elements', function() {
128             var node = nodeFromXML('<section> Alice <span>has</span> a cat </section>');
129             expect(node.contents()[0].getText()).to.equal('Alice ');
130             expect(node.contents()[2].getText()).to.equal(' a cat');
131         });
132         it('normalizes string of white characters to one space at the inline element boundries', function() {
133             var node = nodeFromXML('<span>   Alice has a cat   </span>');
134             expect(node.contents()[0].getText()).to.equal(' Alice has a cat ');
135         });
136         it('normalizes string of white characters to one space before inline element', function() {
137             var node = nodeFromXML('<div>Alice has  <span>a cat</span></div>');
138             expect(node.contents()[0].getText()).to.equal('Alice has ');
139         });
140         it('normalizes string of white characters to one space after inline element', function() {
141             var node = nodeFromXML('<div>Alice has <span>a</span>  cat</div>');
142             expect(node.contents()[2].getText()).to.equal(' cat');
143         });
144     });
145
146     describe('formatting output xml', function() {
147
148         /*jshint multistr: true */
149
150         it('keeps white space between XML nodes', function() {
151             var xmlIn = '<section>\n\n\n<div></div>\n\n\n<div></div>\n\n\n</section>',
152             doc = getDocumentFromXML(xmlIn),
153             xmlOut = doc.toXML();
154
155             var partsIn = xmlIn.split('\n\n\n'),
156                 partsOut = xmlOut.split('\n\n\n');
157
158             expect(partsIn).to.deep.equal(partsOut);
159         });
160
161         it('keeps white space between XML nodes - inline case', function() {
162             var xmlIn = '<section>\n\n\n<span></span>\n\n\n<span></span>\n\n\n</section>',
163                 doc = getDocumentFromXML(xmlIn),
164                 xmlOut = doc.toXML();
165
166             var partsIn = xmlIn.split('\n\n\n'),
167                 partsOut = xmlOut.split('\n\n\n');
168             expect(partsIn).to.deep.equal(partsOut);
169         });
170
171         it('keeps white space at the beginning of text', function() {
172             var xmlIn = '<section>    abc<div>some div</div>    abc</section>',
173                 doc = getDocumentFromXML(xmlIn),
174                 xmlOut = doc.toXML();
175
176             expect(xmlOut).to.equal(xmlIn);
177         });
178
179         // it('nests new children block elements', function() {
180         //     var doc = getDocumentFromXML('<section></section>');
181     
182         //     doc.root.append({tag: 'header'});
183
184         //     var xmlOut = doc.toXML();
185         //     expect(xmlOut.split('\n  ')[0]).to.equal('<section>', 'nesting start ok');
186         //     expect(xmlOut.split('\n').slice(-1)[0]).to.equal('</section>', 'nesting end ok');
187
188         // });
189
190         // it('doesn\'t nest new children inline elements', function() {
191         //     var doc = getDocumentFromXML('<section></section>');
192     
193         //     doc.root.append({tag: 'span'});
194
195         //     var xmlOut = doc.toXML();
196         //     expect(xmlOut).to.equal('<section><span></span></section>');
197         // });
198
199         it('keeps original white space at the end of text', function() {
200             
201             var xmlIn = '<header>    Some text ended with white space \
202             \
203             <span class="uri">Some text</span> some text\
204         \
205         </header>',
206                 doc = getDocumentFromXML(xmlIn),
207                 xmlOut = doc.toXML();
208         
209             expect(xmlOut).to.equal(xmlIn);
210         });
211
212         it('keeps white space around text node', function() {
213             var xmlIn = '<section>\
214             <header>header1</header>\
215             Some text surrounded by white space\
216             <header>header2</header>\
217         </section>',
218                 doc = getDocumentFromXML(xmlIn),
219                 xmlOut = doc.toXML();
220             expect(xmlOut).to.equal(xmlIn);
221         });
222
223         it('keeps white space around text node - last node case', function() {
224             var xmlIn = '<section>\
225             <header>header</header>\
226                 \
227             Some text surrounded by white space\
228                 \
229         </section>',
230                 doc = getDocumentFromXML(xmlIn),
231                 xmlOut = doc.toXML();
232
233             expect(xmlOut).to.equal(xmlIn);
234         });
235
236         it('keeps white space after detaching text element', function() {
237             var xmlIn = '<section><header>header</header>\n\
238                 \n\
239             text1\n\
240                 \n\
241         </section>',
242                 expectedXmlOut = '<section><header>header</header>\n\
243                 \n\
244             \n\
245                 \n\
246         </section>',
247                 doc = getDocumentFromXML(xmlIn),
248                 contents = doc.root.contents(),
249                 text = contents[contents.length-1];
250             
251             expect(text.getText()).to.equal('text1');
252
253             text.detach();
254
255             var xmlOut = doc.toXML();
256             expect(xmlOut).to.equal(expectedXmlOut);
257         });
258
259     });
260
261     describe('Extension', function() {
262         var doc, extension, elementNode, textNode, testClassNode;
263
264         beforeEach(function() {
265             doc = getDocumentFromXML('<section>Alice<div class="test_class"></div></section>');
266             elementNode = doc.root;
267             textNode = doc.root.contents()[0];
268             testClassNode = doc.root.contents('.test_class');
269             extension = {};
270             
271             expect(testClassNode.object).to.be.undefined;
272
273         });
274
275         it('allows adding method to an ElementNode of specific class', function() {
276             extension = {wlxmlClass: {test_class: {methods: {
277                 testMethod: function() { return this; }
278             }}}};
279             doc.registerExtension(extension);
280             testClassNode = doc.root.contents()[1];
281             expect(testClassNode.object.testMethod().sameNode(testClassNode)).to.equal(true, '1');
282         });
283
284         it('allows adding transformation to an ElementNode of specific class', function() {
285             extension = {wlxmlClass: {test_class: {transformations: {
286                 testTransformation: function() { return this; },
287                 testTransformation2: {impl: function() { return this; }}
288             }}}};
289             doc.registerExtension(extension);
290             testClassNode = doc.root.contents()[1];
291             expect(testClassNode.object.testTransformation().sameNode(testClassNode)).to.equal(true, '1');
292             expect(testClassNode.object.testTransformation2().sameNode(testClassNode)).to.equal(true, '1');
293         });
294
295
296     });
297
298 });
299
300 });