mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor
synced 2024-11-15 18:39:52 +00:00
2439c0149a
new static method looks for annotation in annotation object. ve2 Cleanup on annotate method and surface model. Partially revive UI tools by exchaning old method usage for ve2 methods. Change-Id: Id0ac58330292d76801bbcf1d71a919b493f8ab9e
1257 lines
32 KiB
JavaScript
1257 lines
32 KiB
JavaScript
module( 've.dm.Document' );
|
|
|
|
/* Tests */
|
|
|
|
test( 'constructor', 3, function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data );
|
|
deepEqual(
|
|
ve.example.getNodeTreeSummary( doc.getDocumentNode() ),
|
|
ve.example.getNodeTreeSummary( ve.dm.example.tree ),
|
|
'node tree matches example data'
|
|
);
|
|
raises(
|
|
function() {
|
|
doc = new ve.dm.Document( [
|
|
{ 'type': '/paragraph' },
|
|
{ 'type': 'paragraph' }
|
|
] );
|
|
},
|
|
/^Unbalanced input passed to document$/,
|
|
'unbalanced input causes exception'
|
|
);
|
|
|
|
// TODO data provider?
|
|
doc = new ve.dm.Document( [ 'a', 'b', 'c', 'd' ] );
|
|
deepEqual(
|
|
ve.example.getNodeTreeSummary( doc.getDocumentNode() ),
|
|
ve.example.getNodeTreeSummary( new ve.dm.DocumentNode( [ new ve.dm.TextNode( 4 ) ] ) ),
|
|
'plain text input is handled correctly'
|
|
);
|
|
} );
|
|
|
|
test( 'getData', 1, function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data );
|
|
deepEqual( doc.getData(), ve.dm.example.data );
|
|
} );
|
|
|
|
test( 'getOffsetMap', 61, function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data ),
|
|
actual = doc.getOffsetMap(),
|
|
expected = ve.dm.example.getOffsetMap( doc.getDocumentNode() );
|
|
ok( actual.length === expected.length, 'offset map lengths match' );
|
|
for ( var i = 0; i < actual.length; i++ ) {
|
|
ok( actual[i] === expected[i], 'reference at offset ' + i );
|
|
}
|
|
} );
|
|
|
|
test( 'getNodeFromOffset', 60, function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data ),
|
|
root = doc.getDocumentNode().getRoot(),
|
|
node,
|
|
expected = [
|
|
[], // 0 - document
|
|
[0], // 1 - heading
|
|
[0], // 2 - heading
|
|
[0], // 3 - heading
|
|
[0], // 4 - heading
|
|
[], // 5 - document
|
|
[1], // 6 - table
|
|
[1, 0], // 7 - tableRow
|
|
[1, 0, 0], // 8 - tableCell
|
|
[1, 0, 0, 0], // 9 - paragraph
|
|
[1, 0, 0, 0], // 10 - paragraph
|
|
[1, 0, 0], // 11 - tableCell
|
|
[1, 0, 0, 1], // 12 - list
|
|
[1, 0, 0, 1, 0], // 13 - listItem
|
|
[1, 0, 0, 1, 0, 0], // 14 - paragraph
|
|
[1, 0, 0, 1, 0, 0], // 15 - paragraph
|
|
[1, 0, 0, 1, 0], // 16 - listItem
|
|
[1, 0, 0, 1, 0, 1], // 17 - list
|
|
[1, 0, 0, 1, 0, 1, 0], // 18 - listItem
|
|
[1, 0, 0, 1, 0, 1, 0, 0], // 19 - paragraph
|
|
[1, 0, 0, 1, 0, 1, 0, 0], // 20 - paragraph
|
|
[1, 0, 0, 1, 0, 1, 0], // 21 - listItem
|
|
[1, 0, 0, 1, 0, 1], // 22 - list
|
|
[1, 0, 0, 1, 0], // 23 - listItem
|
|
[1, 0, 0, 1], // 24 - list
|
|
[1, 0, 0], // 25 - tableCell
|
|
[1, 0, 0, 2], // 26 - list
|
|
[1, 0, 0, 2, 0], // 27 - listItem
|
|
[1, 0, 0, 2, 0, 0], // 28 - paragraph
|
|
[1, 0, 0, 2, 0, 0], // 29 - paragraph
|
|
[1, 0, 0, 2, 0], // 30 - listItem
|
|
[1, 0, 0, 2], // 31 - list
|
|
[1, 0, 0], // 32 - tableCell
|
|
[1, 0], // 33 - tableRow
|
|
[1], // 34 - table
|
|
[], // 35- document
|
|
[2], // 36 - preformatted
|
|
[2], // 37 - preformatted
|
|
[2], // 38 - preformatted
|
|
[2], // 39 - preformatted
|
|
[2], // 40 - preformatted
|
|
[], // 41 - document
|
|
[3], // 42 - definitionList
|
|
[3, 0], // 43 - definitionListItem
|
|
[3, 0, 0], // 44 - paragraph
|
|
[3, 0, 0], // 45 - paragraph
|
|
[3, 0], // 46 - definitionListItem
|
|
[3], // 47 - definitionList
|
|
[3, 1], // 48 - definitionListItem
|
|
[3, 1, 0], // 49 - paragraph
|
|
[3, 1, 0], // 50 - paragraph
|
|
[3, 1], // 51 - definitionListItem
|
|
[3], // 52 - definitionList
|
|
[], // 53 - document
|
|
[4], // 54 - paragraph
|
|
[4], // 55 - paragraph
|
|
[], // 56 - document
|
|
[5], // 57 - paragraph
|
|
[5], // 58 - paragraph
|
|
[] // 59 - document
|
|
];
|
|
for ( var i = 0; i < expected.length; i++ ) {
|
|
node = root;
|
|
for ( var j = 0; j < expected[i].length; j++ ) {
|
|
node = node.children[expected[i][j]];
|
|
}
|
|
ok( node === doc.getNodeFromOffset( i ), 'reference at offset ' + i );
|
|
}
|
|
} );
|
|
|
|
test( 'getDataFromNode', 3, function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data );
|
|
deepEqual(
|
|
doc.getDataFromNode( doc.getDocumentNode().getChildren()[0] ),
|
|
ve.dm.example.data.slice( 1, 4 ),
|
|
'branch with leaf children'
|
|
);
|
|
deepEqual(
|
|
doc.getDataFromNode( doc.getDocumentNode().getChildren()[1] ),
|
|
ve.dm.example.data.slice( 6, 34 ),
|
|
'branch with branch children'
|
|
);
|
|
deepEqual(
|
|
doc.getDataFromNode( doc.getDocumentNode().getChildren()[2].getChildren()[1] ),
|
|
[],
|
|
'leaf without children'
|
|
);
|
|
} );
|
|
|
|
test( 'getAnnotationsFromOffset', 1, function() {
|
|
var doc,
|
|
range,
|
|
annotations,
|
|
expectCount = 0,
|
|
cases = [
|
|
{
|
|
'msg': ['bold #1', 'bold #2'],
|
|
'data': [
|
|
['a', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
['b', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }]
|
|
],
|
|
'expected': [
|
|
[{ 'type': 'textStyle/bold' }],
|
|
[{ 'type': 'textStyle/bold' }]
|
|
]
|
|
},
|
|
{
|
|
'msg': ['bold #3', 'italic #1'],
|
|
'data': [
|
|
['a', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
['b', { '{"type:"textStyle/italic"}': { 'type': 'textStyle/italic' } }]
|
|
],
|
|
'expected': [
|
|
[{ 'type': 'textStyle/bold' }],
|
|
[{ 'type': 'textStyle/italic' }]
|
|
]
|
|
},
|
|
{
|
|
'msg': ['bold, italic & underline'],
|
|
'data': [
|
|
['a',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'},
|
|
'{"type":"textStyle/underline"}': { 'type': 'textStyle/underline'}
|
|
}]
|
|
],
|
|
'expected': [
|
|
[{ 'type': 'textStyle/bold' }, { 'type': 'textStyle/italic' }, { 'type': 'textStyle/underline' }]
|
|
]
|
|
}
|
|
|
|
];
|
|
|
|
// Calculate expected assertion count
|
|
for ( var c = 0; c < cases.length; c++ ) {
|
|
expectCount += cases[c].data.length;
|
|
}
|
|
expect ( expectCount );
|
|
|
|
// Run tests
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
doc = new ve.dm.Document ( cases[i].data );
|
|
for ( var j = 0; j < doc.getData().length; j++ ) {
|
|
annotations = doc.getAnnotationsFromOffset( j );
|
|
deepEqual( annotations, cases[i].expected[j], cases[i].msg[j] );
|
|
}
|
|
}
|
|
} );
|
|
|
|
test( 'getAnnotationsFromRange', 1, function() {
|
|
var doc,
|
|
range,
|
|
annotations,
|
|
cases = [
|
|
{
|
|
'msg': 'all bold',
|
|
'data': [
|
|
['a', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } } ],
|
|
['b', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } } ]
|
|
],
|
|
'expected': [ { 'type': 'textStyle/bold' } ]
|
|
},
|
|
{
|
|
'msg': 'bold and italic',
|
|
'data': [
|
|
['a',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'}
|
|
}
|
|
],
|
|
['b',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'}
|
|
}
|
|
]
|
|
],
|
|
'expected': [ { 'type': 'textStyle/bold' }, { 'type': 'textStyle/italic' } ]
|
|
},
|
|
{
|
|
'msg': 'bold and italic',
|
|
'data': [
|
|
['a',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'}
|
|
}
|
|
],
|
|
['b',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'},
|
|
'{"type":"textStyle/underline"}': { 'type': 'textStyle/underline'}
|
|
}
|
|
]
|
|
],
|
|
'expected': [ { 'type': 'textStyle/bold' }, { 'type': 'textStyle/italic' } ]
|
|
},
|
|
{
|
|
'msg': 'none common, non annotated character at end',
|
|
'data': [
|
|
['a',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'}
|
|
}
|
|
],
|
|
['b',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'},
|
|
'{"type":"textStyle/underline"}': { 'type': 'textStyle/underline'}
|
|
}
|
|
],
|
|
['c']
|
|
],
|
|
'expected': []
|
|
},
|
|
{
|
|
'msg': 'none common, reverse of previous',
|
|
'data': [
|
|
['a'],
|
|
['b',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'},
|
|
'{"type":"textStyle/underline"}': { 'type': 'textStyle/underline'}
|
|
}
|
|
],
|
|
['c',
|
|
{
|
|
'{"type":"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'}
|
|
}
|
|
]
|
|
],
|
|
'expected': []
|
|
},
|
|
{
|
|
'msg': 'all different',
|
|
'data': [
|
|
['a', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } } ],
|
|
['b', { '{"type:"textStyle/italic"}': { 'type': 'textStyle/italic' } } ]
|
|
],
|
|
'expected': []
|
|
},
|
|
{
|
|
'msg': 'no annotations',
|
|
'data': ['a', 'b'],
|
|
'expected': []
|
|
}
|
|
];
|
|
|
|
expect( cases.length );
|
|
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
doc = new ve.dm.Document ( cases[i].data );
|
|
range = new ve.Range( 0, doc.getData().length );
|
|
annotations = doc.getAnnotationsFromRange( range );
|
|
deepEqual(
|
|
annotations, cases[i].expected, cases[i].msg
|
|
);
|
|
|
|
}
|
|
} );
|
|
|
|
test( 'offsetContainsAnnotation', 1, function(){
|
|
var doc,
|
|
cases = [
|
|
{
|
|
msg: 'contains no annotations',
|
|
data: [
|
|
'a'
|
|
],
|
|
lookFor: {'type': 'textStyle/bold'},
|
|
expected: false
|
|
},
|
|
{
|
|
msg: 'contains bold',
|
|
data: [
|
|
['a', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } } ]
|
|
],
|
|
lookFor: {'type': 'textStyle/bold'},
|
|
expected: true
|
|
},
|
|
{
|
|
msg: 'contains bold',
|
|
data: [
|
|
['a', {
|
|
'{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type":"textStyle/italic"}': { 'type': 'textStyle/italic'}
|
|
}
|
|
]
|
|
],
|
|
lookFor: {'type': 'textStyle/bold'},
|
|
expected: true
|
|
}
|
|
];
|
|
|
|
expect( cases.length );
|
|
|
|
for ( var i = 0;i < cases.length; i++ ) {
|
|
doc = new ve.dm.Document( cases[i].data );
|
|
deepEqual(
|
|
doc.offsetContainsAnnotation( 0, cases[i].lookFor ),
|
|
cases[i].expected,
|
|
cases[i].msg
|
|
);
|
|
}
|
|
});
|
|
|
|
test( 'getAnnotatedRangeFromOffset', 1, function(){
|
|
var doc,
|
|
cases = [
|
|
{
|
|
'msg': 'a bold word',
|
|
'data': [
|
|
// 0
|
|
'a',
|
|
// 1
|
|
['b', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 2
|
|
['o', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 3
|
|
['l', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 4
|
|
['d', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 5
|
|
'w',
|
|
// 6
|
|
'o',
|
|
// 7
|
|
'r',
|
|
// 8
|
|
'd'
|
|
],
|
|
'annotation': { 'type': 'textStyle/bold' },
|
|
'offset': 3,
|
|
'expected': new ve.Range( 1, 5 )
|
|
},
|
|
{
|
|
'msg': 'a linked',
|
|
'data': [
|
|
// 0
|
|
'x',
|
|
// 1
|
|
'x',
|
|
// 2
|
|
'x',
|
|
// 3
|
|
['l', { '{"type:"link/internal"}': { 'type': 'link/internal' } }],
|
|
// 4
|
|
['i', { '{"type:"link/internal"}': { 'type': 'link/internal' } }],
|
|
// 5
|
|
['n', { '{"type:"link/internal"}': { 'type': 'link/internal' } }],
|
|
// 6
|
|
['k', { '{"type:"link/internal"}': { 'type': 'link/internal' } }],
|
|
// 7
|
|
'x',
|
|
// 8
|
|
'x',
|
|
// 9
|
|
'x'
|
|
],
|
|
'annotation': { 'type': 'link/internal' },
|
|
'offset': 3,
|
|
'expected': new ve.Range( 3, 7 )
|
|
},
|
|
{
|
|
'msg': 'bold over an annotated leaf node',
|
|
'data': [
|
|
// 0
|
|
'h',
|
|
// 1
|
|
['b', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 2
|
|
['o', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 3
|
|
{
|
|
'type': 'image',
|
|
'attributes': { 'html/src': 'image.png' },
|
|
'annotations': {'{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' }}
|
|
},
|
|
// 4
|
|
{ 'type': '/image' },
|
|
// 5
|
|
['l', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 6
|
|
['d', { '{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' } }],
|
|
// 7
|
|
'i'
|
|
],
|
|
'annotation': { 'type': 'textStyle/bold' },
|
|
'offset': 3,
|
|
'expected': new ve.Range ( 1, 7 )
|
|
}
|
|
];
|
|
|
|
expect( cases.length );
|
|
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
doc = new ve.dm.Document( cases[i].data );
|
|
deepEqual(
|
|
doc.getAnnotatedRangeFromOffset(cases[i].offset, cases[i].annotation),
|
|
cases[i].expected,
|
|
cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'getMatchingAnnotationsFromOffset', 1, function() {
|
|
var cases = {
|
|
'finds two out of three': {
|
|
'pattern': /textStyle\/.*/,
|
|
'character': [
|
|
'a',
|
|
{
|
|
'{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type:"textStyle/italic"}': { 'type': 'textStyle/italic' },
|
|
'{"type:"link/internal"}': { 'type': 'link/internal' }
|
|
}
|
|
],
|
|
'expected': {
|
|
'{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type:"textStyle/italic"}': { 'type': 'textStyle/italic' }
|
|
}
|
|
},
|
|
'finds 3 out of 3': {
|
|
'pattern': /textStyle\/.*/,
|
|
'character': [
|
|
'a',
|
|
{
|
|
'{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type:"textStyle/italic"}': { 'type': 'textStyle/italic' },
|
|
'{"type:"textStyle/undeline"}': { 'type': 'textStyle/undeline' }
|
|
}
|
|
],
|
|
'expected': {
|
|
'{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type:"textStyle/italic"}': { 'type': 'textStyle/italic' },
|
|
'{"type:"textStyle/undeline"}': { 'type': 'textStyle/undeline' }
|
|
}
|
|
},
|
|
'finds none': {
|
|
'pattern': /link\/.*/,
|
|
'character': [
|
|
'a',
|
|
{
|
|
'{"type:"textStyle/bold"}': { 'type': 'textStyle/bold' },
|
|
'{"type:"textStyle/italic"}': { 'type': 'textStyle/italic' },
|
|
'{"type:"textStyle/undeline"}': { 'type': 'textStyle/undeline' }
|
|
}
|
|
],
|
|
'expected': {}
|
|
}
|
|
};
|
|
|
|
expect( ve.getObjectKeys( cases ).length );
|
|
|
|
for ( var msg in cases ) {
|
|
deepEqual(
|
|
( new ve.dm.Document( [cases[msg].character] ) )
|
|
.getMatchingAnnotationsFromOffset( 0, cases[msg].pattern ),
|
|
cases[msg].expected,
|
|
msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'getOuterLength', 1, function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data );
|
|
strictEqual(
|
|
doc.getDocumentNode().getOuterLength(),
|
|
ve.dm.example.data.length,
|
|
'document does not have elements around it'
|
|
);
|
|
} );
|
|
|
|
test( 'isContentOffset', function() {
|
|
var data = [
|
|
{ 'type': 'heading' },
|
|
'a',
|
|
{ 'type': 'image' },
|
|
{ 'type': '/image' },
|
|
'b',
|
|
'c',
|
|
{ 'type': '/heading' },
|
|
{ 'type': 'paragraph' },
|
|
{ 'type': '/paragraph' },
|
|
{ 'type': 'preformatted' },
|
|
{ 'type': 'image' },
|
|
{ 'type': '/image' },
|
|
{ 'type': '/preformatted' },
|
|
{ 'type': 'list' },
|
|
{ 'type': 'listItem' },
|
|
{ 'type': '/listItem' },
|
|
{ 'type': '/list' },
|
|
{ 'type': 'alienBlock' },
|
|
{ 'type': '/alienBlock' },
|
|
{ 'type': 'table' },
|
|
{ 'type': 'tableRow' },
|
|
{ 'type': 'tableCell' },
|
|
{ 'type': 'alienBlock' },
|
|
{ 'type': '/alienBlock' },
|
|
{ 'type': '/tableCell' },
|
|
{ 'type': '/tableRow' },
|
|
{ 'type': '/table' }
|
|
],
|
|
cases = [
|
|
{ 'msg': 'left of document', 'expected': false },
|
|
{ 'msg': 'begining of content branch', 'expected': true },
|
|
{ 'msg': 'left of non-text inline leaf', 'expected': true },
|
|
{ 'msg': 'inside non-text inline leaf', 'expected': false },
|
|
{ 'msg': 'right of non-text inline leaf', 'expected': true },
|
|
{ 'msg': 'between characters', 'expected': true },
|
|
{ 'msg': 'end of content branch', 'expected': true },
|
|
{ 'msg': 'between content branches', 'expected': false },
|
|
{ 'msg': 'inside emtpy content branch', 'expected': true },
|
|
{ 'msg': 'between content branches', 'expected': false },
|
|
{ 'msg': 'begining of content branch, left of inline leaf', 'expected': true },
|
|
{ 'msg': 'inside content branch with non-text inline leaf', 'expected': false },
|
|
{ 'msg': 'end of content branch, right of non-content leaf', 'expected': true },
|
|
{ 'msg': 'between content, non-content branches', 'expected': false },
|
|
{ 'msg': 'between parent, child branches, descending', 'expected': false },
|
|
{ 'msg': 'inside empty non-content branch', 'expected': false },
|
|
{ 'msg': 'between parent, child branches, ascending', 'expected': false },
|
|
{ 'msg': 'between non-content branch, non-content leaf', 'expected': false },
|
|
{ 'msg': 'inside non-content leaf', 'expected': false },
|
|
{ 'msg': 'between non-content branches', 'expected': false },
|
|
{ 'msg': 'between non-content branches', 'expected': false },
|
|
{ 'msg': 'between non-content branches', 'expected': false },
|
|
{ 'msg': 'inside non-content branch before non-content leaf', 'expected': false },
|
|
{ 'msg': 'inside non-content leaf', 'expected': false },
|
|
{ 'msg': 'inside non-content branch after non-content leaf', 'expected': false },
|
|
{ 'msg': 'between non-content branches', 'expected': false },
|
|
{ 'msg': 'between non-content branches', 'expected': false },
|
|
{ 'msg': 'right of document', 'expected': false }
|
|
];
|
|
expect( data.length + 1 );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
var left = data[i - 1] ? ( data[i - 1].type || data[i - 1][0] ) : '[start]',
|
|
right = data[i] ? ( data[i].type || data[i][0] ) : '[end]';
|
|
strictEqual(
|
|
ve.dm.Document.isContentOffset( data, i ),
|
|
cases[i].expected,
|
|
cases[i].msg + ' (' + left + '|' + right + ' @ ' + i + ')'
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'isStructuralOffset', function() {
|
|
var data = [
|
|
{ 'type': 'heading' },
|
|
'a',
|
|
{ 'type': 'image' },
|
|
{ 'type': '/image' },
|
|
'b',
|
|
'c',
|
|
{ 'type': '/heading' },
|
|
{ 'type': 'paragraph' },
|
|
{ 'type': '/paragraph' },
|
|
{ 'type': 'preformatted' },
|
|
{ 'type': 'image' },
|
|
{ 'type': '/image' },
|
|
{ 'type': '/preformatted' },
|
|
{ 'type': 'list' },
|
|
{ 'type': 'listItem' },
|
|
{ 'type': '/listItem' },
|
|
{ 'type': '/list' },
|
|
{ 'type': 'alienBlock' },
|
|
{ 'type': '/alienBlock' },
|
|
{ 'type': 'table' },
|
|
{ 'type': 'tableRow' },
|
|
{ 'type': 'tableCell' },
|
|
{ 'type': 'alienBlock' },
|
|
{ 'type': '/alienBlock' },
|
|
{ 'type': '/tableCell' },
|
|
{ 'type': '/tableRow' },
|
|
{ 'type': '/table' }
|
|
],
|
|
cases = [
|
|
{ 'msg': 'left of document', 'expected': [true, true] },
|
|
{ 'msg': 'begining of content branch', 'expected': [false, false] },
|
|
{ 'msg': 'left of non-text inline leaf', 'expected': [false, false] },
|
|
{ 'msg': 'inside non-text inline leaf', 'expected': [false, false] },
|
|
{ 'msg': 'right of non-text inline leaf', 'expected': [false, false] },
|
|
{ 'msg': 'between characters', 'expected': [false, false] },
|
|
{ 'msg': 'end of content branch', 'expected': [false, false] },
|
|
{ 'msg': 'between content branches', 'expected': [true, true] },
|
|
{ 'msg': 'inside emtpy content branch', 'expected': [false, false] },
|
|
{ 'msg': 'between content branches', 'expected': [true, true] },
|
|
{ 'msg': 'begining of content branch, left of inline leaf', 'expected': [false, false] },
|
|
{ 'msg': 'inside content branch with non-text inline leaf', 'expected': [false, false] },
|
|
{ 'msg': 'end of content branch, right of inline leaf', 'expected': [false, false] },
|
|
{ 'msg': 'between content, non-content branches', 'expected': [true, true] },
|
|
{ 'msg': 'between parent, child branches, descending', 'expected': [true, false] },
|
|
{ 'msg': 'inside empty non-content branch', 'expected': [true, true] },
|
|
{ 'msg': 'between parent, child branches, ascending', 'expected': [true, false] },
|
|
{ 'msg': 'between non-content branch, non-content leaf', 'expected': [true, true] },
|
|
{ 'msg': 'inside non-content leaf', 'expected': [false, false] },
|
|
{ 'msg': 'between non-content branches', 'expected': [true, true] },
|
|
{ 'msg': 'between non-content branches', 'expected': [true, false] },
|
|
{ 'msg': 'between non-content branches', 'expected': [true, false] },
|
|
{ 'msg': 'inside non-content branch before non-content leaf', 'expected': [true, true] },
|
|
{ 'msg': 'inside non-content leaf', 'expected': [false, false] },
|
|
{ 'msg': 'inside non-content branch after non-content leaf', 'expected': [true, true] },
|
|
{ 'msg': 'between non-content branches', 'expected': [true, false] },
|
|
{ 'msg': 'between non-content branches', 'expected': [true, false] },
|
|
{ 'msg': 'right of document', 'expected': [true, true] }
|
|
];
|
|
expect( ( data.length + 1 ) * 2 );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
var left = data[i - 1] ? ( data[i - 1].type || data[i - 1][0] ) : '[start]',
|
|
right = data[i] ? ( data[i].type || data[i][0] ) : '[end]';
|
|
strictEqual(
|
|
ve.dm.Document.isStructuralOffset( data, i ),
|
|
cases[i].expected[0],
|
|
cases[i].msg + ' (' + left + '|' + right + ' @ ' + i + ')'
|
|
);
|
|
strictEqual(
|
|
ve.dm.Document.isStructuralOffset( data, i, true ),
|
|
cases[i].expected[1],
|
|
cases[i].msg + ', unrestricted (' + left + '|' + right + ' @ ' + i + ')'
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'isElementData', 1, function() {
|
|
var data = [
|
|
{ 'type': 'heading' },
|
|
'a',
|
|
{ 'type': 'image' },
|
|
{ 'type': '/image' },
|
|
'b',
|
|
'c',
|
|
{ 'type': '/heading' },
|
|
{ 'type': 'paragraph' },
|
|
{ 'type': '/paragraph' },
|
|
{ 'type': 'preformatted' },
|
|
{ 'type': 'image' },
|
|
{ 'type': '/image' },
|
|
{ 'type': '/preformatted' },
|
|
{ 'type': 'list' },
|
|
{ 'type': 'listItem' },
|
|
{ 'type': '/listItem' },
|
|
{ 'type': '/list' },
|
|
{ 'type': 'alienBlock' },
|
|
{ 'type': '/alienBlock' }
|
|
],
|
|
cases = [
|
|
{ 'msg': 'left of document', 'expected': true },
|
|
{ 'msg': 'begining of content branch', 'expected': false },
|
|
{ 'msg': 'left of non-text inline leaf', 'expected': true },
|
|
{ 'msg': 'inside non-text inline leaf', 'expected': true },
|
|
{ 'msg': 'right of non-text inline leaf', 'expected': false },
|
|
{ 'msg': 'between characters', 'expected': false },
|
|
{ 'msg': 'end of content branch', 'expected': true },
|
|
{ 'msg': 'between content branches', 'expected': true },
|
|
{ 'msg': 'inside emtpy content branch', 'expected': true },
|
|
{ 'msg': 'between content branches', 'expected': true },
|
|
{ 'msg': 'begining of content branch, left of inline leaf', 'expected': true },
|
|
{ 'msg': 'inside content branch with non-text leaf', 'expected': true },
|
|
{ 'msg': 'end of content branch, right of inline leaf', 'expected': true },
|
|
{ 'msg': 'between content, non-content branches', 'expected': true },
|
|
{ 'msg': 'between parent, child branches, descending', 'expected': true },
|
|
{ 'msg': 'inside empty non-content branch', 'expected': true },
|
|
{ 'msg': 'between parent, child branches, ascending', 'expected': true },
|
|
{ 'msg': 'between non-content branch, non-content leaf', 'expected': true },
|
|
{ 'msg': 'inside non-content leaf', 'expected': true },
|
|
{ 'msg': 'right of document', 'expected': false }
|
|
];
|
|
expect( data.length + 1 );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
strictEqual( ve.dm.Document.isElementData( data, i ), cases[i].expected, cases[i].msg );
|
|
}
|
|
} );
|
|
|
|
test( 'containsElementData', 1, function() {
|
|
var cases = [
|
|
{
|
|
'msg': 'simple paragraph',
|
|
'data': [{ 'type': 'paragraph' }, 'a', { 'type': '/paragraph' }],
|
|
'expected': true
|
|
},
|
|
{
|
|
'msg': 'plain text',
|
|
'data': ['a', 'b', 'c'],
|
|
'expected': false
|
|
},
|
|
{
|
|
'msg': 'annotated text',
|
|
'data': [['a', { '{"type:"bold"}': { 'type': 'bold' } } ]],
|
|
'expected': false
|
|
},
|
|
{
|
|
'msg': 'non-text leaf',
|
|
'data': ['a', { 'type': 'image' }, { 'type': '/image' }, 'c'],
|
|
'expected': true
|
|
}
|
|
];
|
|
expect( cases.length );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
strictEqual(
|
|
ve.dm.Document.containsElementData( cases[i].data ), cases[i].expected, cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'isContentData', 1, function() {
|
|
var cases = [
|
|
{
|
|
'msg': 'simple paragraph',
|
|
'data': [{ 'type': 'paragraph' }, 'a', { 'type': '/paragraph' }],
|
|
'expected': false
|
|
},
|
|
{
|
|
'msg': 'plain text',
|
|
'data': ['a', 'b', 'c'],
|
|
'expected': true
|
|
},
|
|
{
|
|
'msg': 'annotated text',
|
|
'data': [['a', { '{"type:"bold"}': { 'type': 'bold' } } ]],
|
|
'expected': true
|
|
},
|
|
{
|
|
'msg': 'non-text leaf',
|
|
'data': ['a', { 'type': 'image' }, { 'type': '/image' }, 'c'],
|
|
'expected': true
|
|
}
|
|
];
|
|
expect( cases.length );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
strictEqual(
|
|
ve.dm.Document.isContentData( cases[i].data ), cases[i].expected, cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'rebuildNodes', function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data.slice( 0 ) ),
|
|
documentNode = doc.getDocumentNode();
|
|
// Rebuild without changes
|
|
doc.rebuildNodes( documentNode, 1, 1, 5, 30 );
|
|
deepEqual(
|
|
ve.example.getNodeTreeSummary( documentNode ),
|
|
ve.example.getNodeTreeSummary( ve.dm.example.tree ),
|
|
'rebuild without changes'
|
|
);
|
|
|
|
// XXX: Create a new document node tree from the old one
|
|
var tree = new ve.dm.DocumentNode( ve.dm.example.tree.getChildren() );
|
|
// Replace table with paragraph
|
|
doc.data.splice( 5, 30, { 'type': 'paragraph' }, 'a', 'b', 'c', { 'type': '/paragraph' } );
|
|
// Remove table from tree model
|
|
tree.splice( 1, 1, new ve.dm.ParagraphNode( [new ve.dm.TextNode( 3 )] ) );
|
|
// Rebuild with changes
|
|
doc.rebuildNodes( documentNode, 1, 1, 5, 5 );
|
|
deepEqual(
|
|
ve.example.getNodeTreeSummary( documentNode ),
|
|
ve.example.getNodeTreeSummary( tree ),
|
|
'replace table with paragraph'
|
|
);
|
|
} );
|
|
|
|
test( 'getRelativeOffset', function() {
|
|
var cases = [
|
|
{
|
|
'msg': 'document without any valid offsets returns -1',
|
|
'offset': 0,
|
|
'distance': 1,
|
|
'data': [],
|
|
'callback': function( data, offset ) {
|
|
return false;
|
|
},
|
|
'expected': -1
|
|
},
|
|
{
|
|
'msg': 'document with all valid offsets returns offset + distance',
|
|
'offset': 0,
|
|
'distance': 2,
|
|
'data': ['a', 'b'],
|
|
'callback': function( data, offset ) {
|
|
return true;
|
|
},
|
|
'expected': 2
|
|
}
|
|
];
|
|
expect( cases.length );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
var doc = new ve.dm.Document( cases[i].data );
|
|
strictEqual(
|
|
doc.getRelativeOffset.apply(
|
|
doc,
|
|
[
|
|
cases[i].offset,
|
|
cases[i].distance,
|
|
cases[i].callback
|
|
].concat( cases[i].args || [] )
|
|
),
|
|
cases[i].expected,
|
|
cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'getRelativeContentOffset', function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data ),
|
|
cases = [
|
|
{
|
|
'msg': 'invalid starting offset with zero distance gets corrected',
|
|
'offset': 0,
|
|
'distance': 0,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': 'invalid starting offset with zero distance gets corrected',
|
|
'offset': 59,
|
|
'distance': 0,
|
|
'expected': 58
|
|
},
|
|
{
|
|
'msg': 'valid offset with zero distance returns same offset',
|
|
'offset': 2,
|
|
'distance': 0,
|
|
'expected': 2
|
|
},
|
|
{
|
|
'msg': 'invalid starting offset gets corrected',
|
|
'offset': 0,
|
|
'distance': -1,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': 'invalid starting offset gets corrected',
|
|
'offset': 59,
|
|
'distance': 1,
|
|
'expected': 58
|
|
},
|
|
{
|
|
'msg': 'first content offset is farthest left',
|
|
'offset': 2,
|
|
'distance': -2,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': 'last content offset is farthest right',
|
|
'offset': 57,
|
|
'distance': 2,
|
|
'expected': 58
|
|
},
|
|
{
|
|
'msg': '1 right within text',
|
|
'offset': 1,
|
|
'distance': 1,
|
|
'expected': 2
|
|
},
|
|
{
|
|
'msg': '2 right within text',
|
|
'offset': 1,
|
|
'distance': 2,
|
|
'expected': 3
|
|
},
|
|
{
|
|
'msg': '1 left within text',
|
|
'offset': 2,
|
|
'distance': -1,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': '2 left within text',
|
|
'offset': 3,
|
|
'distance': -2,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': '1 right over elements',
|
|
'offset': 4,
|
|
'distance': 1,
|
|
'expected': 9
|
|
},
|
|
{
|
|
'msg': '2 right over elements',
|
|
'offset': 4,
|
|
'distance': 2,
|
|
'expected': 10
|
|
},
|
|
{
|
|
'msg': '1 left over elements',
|
|
'offset': 9,
|
|
'distance': -1,
|
|
'expected': 4
|
|
},
|
|
{
|
|
'msg': '2 left over elements',
|
|
'offset': 9,
|
|
'distance': -2,
|
|
'expected': 3
|
|
}
|
|
];
|
|
expect( cases.length );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
strictEqual(
|
|
doc.getRelativeContentOffset( cases[i].offset, cases[i].distance ),
|
|
cases[i].expected,
|
|
cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'getNearestContentOffset', function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data ),
|
|
cases = [
|
|
{
|
|
'msg': 'unspecified direction results in shortest distance',
|
|
'offset': 0,
|
|
'direction': 0,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': 'unspecified direction results in shortest distance',
|
|
'offset': 5,
|
|
'direction': 0,
|
|
'expected': 4
|
|
},
|
|
{
|
|
'msg': 'positive direction results in next valid offset to the right',
|
|
'offset': 5,
|
|
'direction': 1,
|
|
'expected': 9
|
|
},
|
|
{
|
|
'msg': 'negative direction results in next valid offset to the left',
|
|
'offset': 5,
|
|
'direction': -1,
|
|
'expected': 4
|
|
},
|
|
{
|
|
'msg': 'valid offset without direction returns same offset',
|
|
'offset': 1,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': 'valid offset with positive direction returns same offset',
|
|
'offset': 1,
|
|
'direction': 1,
|
|
'expected': 1
|
|
},
|
|
{
|
|
'msg': 'valid offset with negative direction returns same offset',
|
|
'offset': 1,
|
|
'direction': -1,
|
|
'expected': 1
|
|
}
|
|
];
|
|
expect( cases.length );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
strictEqual(
|
|
doc.getNearestContentOffset( cases[i].offset, cases[i].direction ),
|
|
cases[i].expected,
|
|
cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'getRelativeStructuralOffset', function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data ),
|
|
cases = [
|
|
{
|
|
'msg': 'invalid starting offset with zero distance gets corrected',
|
|
'offset': 1,
|
|
'distance': 0,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': 'invalid starting offset with zero distance gets corrected',
|
|
'offset': 58,
|
|
'distance': 0,
|
|
'expected': 59
|
|
},
|
|
{
|
|
'msg': 'valid offset with zero distance returns same offset',
|
|
'offset': 0,
|
|
'distance': 0,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'invalid starting offset gets corrected',
|
|
'offset': 2,
|
|
'distance': -1,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'invalid starting offset gets corrected',
|
|
'offset': 57,
|
|
'distance': 1,
|
|
'expected': 59
|
|
},
|
|
{
|
|
'msg': 'first structural offset is farthest left',
|
|
'offset': 5,
|
|
'distance': -2,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'last structural offset is farthest right',
|
|
'offset': 56,
|
|
'distance': 2,
|
|
'expected': 59
|
|
},
|
|
{
|
|
'msg': '1 right',
|
|
'offset': 0,
|
|
'distance': 1,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': '1 right, unrestricted',
|
|
'offset': 5,
|
|
'distance': 1,
|
|
'unrestricted': true,
|
|
'expected': 8
|
|
},
|
|
{
|
|
'msg': '2 right',
|
|
'offset': 0,
|
|
'distance': 2,
|
|
'expected': 6
|
|
},
|
|
{
|
|
'msg': '2 right, unrestricted',
|
|
'offset': 0,
|
|
'distance': 2,
|
|
'unrestricted': true,
|
|
'expected': 8
|
|
},
|
|
{
|
|
'msg': '1 left',
|
|
'offset': 59,
|
|
'distance': -1,
|
|
'expected': 56
|
|
},
|
|
{
|
|
'msg': '1 left, unrestricted',
|
|
'offset': 8,
|
|
'distance': -1,
|
|
'unrestricted': true,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': '2 left',
|
|
'offset': 59,
|
|
'distance': -2,
|
|
'expected': 53
|
|
},
|
|
{
|
|
'msg': '2 left, unrestricted',
|
|
'offset': 8,
|
|
'distance': -2,
|
|
'unrestricted': true,
|
|
'expected': 0
|
|
}
|
|
];
|
|
expect( cases.length );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
strictEqual(
|
|
doc.getRelativeStructuralOffset(
|
|
cases[i].offset, cases[i].distance, cases[i].unrestricted
|
|
),
|
|
cases[i].expected,
|
|
cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'getNearestStructuralOffset', function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data ),
|
|
cases = [
|
|
{
|
|
'msg': 'unspecified direction results in shortest distance',
|
|
'offset': 1,
|
|
'direction': 0,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'unspecified direction results in shortest distance',
|
|
'offset': 4,
|
|
'direction': 0,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': 'unspecified direction results in shortest distance, unrestricted',
|
|
'offset': 7,
|
|
'direction': 0,
|
|
'unrestricted': true,
|
|
'expected': 8
|
|
},
|
|
{
|
|
'msg': 'unspecified direction results in shortest distance, unrestricted',
|
|
'offset': 6,
|
|
'direction': 0,
|
|
'unrestricted': true,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': 'positive direction results in next valid offset to the right',
|
|
'offset': 1,
|
|
'direction': 1,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': 'positive direction results in next valid offset to the right',
|
|
'offset': 4,
|
|
'direction': 1,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': 'positive direction results in next valid offset to the right, unrestricted',
|
|
'offset': 6,
|
|
'direction': 1,
|
|
'unrestricted': true,
|
|
'expected': 8
|
|
},
|
|
{
|
|
'msg': 'negative direction results in next valid offset to the left',
|
|
'offset': 1,
|
|
'direction': -1,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'negative direction results in next valid offset to the left',
|
|
'offset': 4,
|
|
'direction': -1,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'negative direction results in next valid offset to the left, unrestricted',
|
|
'offset': 7,
|
|
'direction': -1,
|
|
'unrestricted': true,
|
|
'expected': 5
|
|
},
|
|
{
|
|
'msg': 'valid offset without direction returns same offset',
|
|
'offset': 0,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'valid offset with positive direction returns same offset',
|
|
'offset': 0,
|
|
'direction': 1,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'valid offset with negative direction returns same offset',
|
|
'offset': 0,
|
|
'direction': -1,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'valid offset without direction returns same offset, unrestricted',
|
|
'offset': 0,
|
|
'unrestricted': true,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'valid offset with positive direction returns same offset, unrestricted',
|
|
'offset': 0,
|
|
'direction': 1,
|
|
'unrestricted': true,
|
|
'expected': 0
|
|
},
|
|
{
|
|
'msg': 'valid offset with negative direction returns same offset, unrestricted',
|
|
'offset': 0,
|
|
'direction': -1,
|
|
'unrestricted': true,
|
|
'expected': 0
|
|
}
|
|
];
|
|
expect( cases.length );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
strictEqual(
|
|
doc.getNearestStructuralOffset(
|
|
cases[i].offset, cases[i].direction, cases[i].unrestricted
|
|
),
|
|
cases[i].expected,
|
|
cases[i].msg
|
|
);
|
|
}
|
|
} );
|
|
|
|
test( 'selectNodes', function() {
|
|
var doc = new ve.dm.Document( ve.dm.example.data ),
|
|
cases = ve.example.getSelectNodesCases( doc );
|
|
for ( var i = 0; i < cases.length; i++ ) {
|
|
deepEqual(
|
|
ve.example.getNodeSelectionSummary( cases[i].actual ),
|
|
ve.example.getNodeSelectionSummary( cases[i].expected ),
|
|
cases[i].msg
|
|
);
|
|
}
|
|
} );
|