wikimedia/mediawiki-extensions-VisualEditor
1
0
Fork 0
mirror of https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor synced 2024-11-15 18:39:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
mediawiki-extensions-Visual.../modules/ve/test/dm/ve.dm.ModelRegistry.test.js

167 lines
8.5 KiB
JavaScript
Raw Normal View History

JSDuck: Generated code documentation! See CODING.md for how to run it. Mistakes fixed: * Warning: Unknown type function -> Function * Warning: Unknown type DOMElement -> HTMLElement * Warning: Unknown type DOM Node -> HTMLElement * Warning: Unknown type Integer -> Mixed * Warning: Unknown type Command -> ve.Command * Warning: Unknown type any -> number * Warning: Unknown type ve.Transaction -> ve.dm.Transaction * Warning: Unknown type ve.dm.AnnotationSet -> ve.AnnotationSet * Warning: Unknown type false -> boolean * Warning: Unknown type ve.dm.AlienNode ve.dm doesn't have a generic AlienNode like ve.ce -> Unknown type ve.dm.AlienInlineNode|ve.dm.AlienBlockNode * Warning: Unknown type ve.ve.Surface -> ve.ce.Surface * ve.example.lookupNode: -> Last @param should be @return * ve.dm.Transaction.prototype.pushReplace: -> @param {Array] should be @param {Array} * Warning: ve.BranchNode.js:27: {@link ve.Node#hasChildren} links to non-existing member -> (removed) * Warning: ve.LeafNode.js:21: {@link ve.Node#hasChildren} links to non-existing member -> (removed) Differences fixed: * Variadic arguments are like @param {Type...} [name] instead of @param {Type} [name...] * Convert all file headers from /** to /*! because JSDuck tries to parse all /** blocks and fails to parse with all sorts of errors for "Global property", "Unnamed property", and "Duplicate property". Find: \/\*\*([^@]+)(@copyright) Replace: /*!$1$2 * Indented blocks are considered code examples. A few methods had documentation with numbered lists that were indented, which have now been updated to not be intended. * The free-form text descriptions are parsed with Markdown, which requires lists to be separated from paragraphs by an empty line. And we should use `backticks` instead of {braces} for inline code in text paragraphs. * Doc blocks for classes and their constructor have to be in the correct order (@constructor, @param, @return must be before @class, @abstract, @extends etc.) * `@extends Class` must not have Class {wrapped} * @throws must start with a {Type} * @example means something else. It is used for an inline demo iframe, not code block. For that simply indent with spaces. * @member means something else. Non-function properties are marked with @property, not @member. * To create a link to a class or member, in most cases the name is enough to create a link. E.g. Foo, Foo.bar, Foo.bar#quux, where a hash stands for "instance member", so Foo.bar#quux, links to Foo.bar.prototype.quux (the is not supported, as "prototype" is considered an implementation detail, it only indexes class name and method name). If the magic linker doesn't work for some case, the verbose syntax is {@link #target label}. * @property can't have sub-properties (nested @param and @return values are supported, only @static @property can't be nested). We only have one case of this, which can be worked around by moving those in a new virtual class. The code is unaltered (only moved down so that it isn't with the scope of the main @class block). ve.dm.TransactionProcessor.processors. New: * @mixins: Classes mixed into the current class. * @event: Events that can be emitted by a class. These are also inherited by subclasses. (+ @param, @return and @preventable). So ve.Node#event-attach is inherited to ve.dm.BreakNode, just like @method is. * @singleton: Plain objects such as ve, ve.dm, ve.ce were missing documentation causing a tree error. Documented those as a JSDuck singleton, which they but just weren't documented yet. NB: Members of @singleton don't need @static (if present, triggers a compiler warning). * @chainable: Shorthand for "@return this". We were using "@return {classname}" which is ambiguous (returns the same instance or another instance?), @chainable is specifically for "@return this". Creates proper labels in the generated HTML pages. Removed: * @mixin: (not to be confused with @mixins). Not supported by JSDuck. Every class is standalone anyway. Where needed marked them @class + @abstract instead. Change-Id: I6a7c9e8ee8f995731bc205d666167874eb2ebe23
2013-01-04 08:54:17 +00:00
/*!
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
* VisualEditor ModelRegistry tests.
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
*
Bump copyright notice year range to -2013 over -2012 199 files touched. Whee! Change-Id: Id82ce4a32f833406db4a1cc585674f2bdb39ba0d
2013-02-19 23:37:34 +00:00
* @copyright 2011-2013 VisualEditor Team and others; see AUTHORS.txt
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
* @license The MIT License (MIT); see LICENSE.txt
*/
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
QUnit.module( 've.dm.ModelRegistry' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
/* Stubs */
function checkForPickMe( element ) {
return element.hasAttribute( 'pickme' );
}
ve.dm.StubNothingSetAnnotation = function VeDmStubNothingSetAnnotation( element ) {
ve.dm.Annotation.call( this, element );
};
ve.inheritClass( ve.dm.StubNothingSetAnnotation, ve.dm.Annotation );
ve.dm.StubNothingSetAnnotation.static.name = 'stubnothingset';
ve.dm.StubSingleTagAnnotation = function VeDmStubSingleTagAnnotation( element ) {
ve.dm.Annotation.call( this, element );
};
ve.inheritClass( ve.dm.StubSingleTagAnnotation, ve.dm.Annotation );
ve.dm.StubSingleTagAnnotation.static.name = 'stubsingletag';
ve.dm.StubSingleTagAnnotation.static.matchTagNames = ['a'];
ve.dm.StubSingleTypeAnnotation = function VeDmStubSingleTypeAnnotation( element ) {
ve.dm.Annotation.call( this, 'stubsingletype', element );
};
ve.inheritClass( ve.dm.StubSingleTypeAnnotation, ve.dm.Annotation );
ve.dm.StubSingleTypeAnnotation.static.name = 'stubsingletype';
ve.dm.StubSingleTypeAnnotation.static.matchRdfaTypes = ['mw:foo'];
ve.dm.StubSingleTagAndTypeAnnotation = function VeDmStubSingleTagAndTypeAnnotation( element ) {
ve.dm.Annotation.call( this, element );
};
ve.inheritClass( ve.dm.StubSingleTagAndTypeAnnotation, ve.dm.Annotation );
ve.dm.StubSingleTagAndTypeAnnotation.static.name = 'stubsingletagandtype';
ve.dm.StubSingleTagAndTypeAnnotation.static.matchTagNames = ['a'];
ve.dm.StubSingleTagAndTypeAnnotation.static.matchRdfaTypes = ['mw:foo'];
ve.dm.StubFuncAnnotation = function VeDmStubFuncAnnotation( element ) {
ve.dm.Annotation.call( this, element );
};
ve.inheritClass( ve.dm.StubFuncAnnotation, ve.dm.Annotation );
ve.dm.StubFuncAnnotation.static.name = 'stubfunc';
ve.dm.StubFuncAnnotation.static.matchFunction = checkForPickMe;
ve.dm.StubSingleTagAndFuncAnnotation = function VeDmStubSingleTagAndFuncAnnotation( element ) {
ve.dm.Annotation.call( this, element );
};
ve.inheritClass( ve.dm.StubSingleTagAndFuncAnnotation, ve.dm.Annotation );
ve.dm.StubSingleTagAndFuncAnnotation.static.name = 'stubsingletagandfunc';
ve.dm.StubSingleTagAndFuncAnnotation.static.matchTagNames = ['a'];
ve.dm.StubSingleTagAndFuncAnnotation.static.matchFunction = checkForPickMe;
ve.dm.StubSingleTypeAndFuncAnnotation = function VeDmStubSingleTypeAndFuncAnnotation( element ) {
ve.dm.Annotation.call( this, element );
};
ve.inheritClass( ve.dm.StubSingleTypeAndFuncAnnotation, ve.dm.Annotation );
ve.dm.StubSingleTypeAndFuncAnnotation.static.name = 'stubsingletypeandfunc';
ve.dm.StubSingleTypeAndFuncAnnotation.static.matchRdfaTypes = ['mw:foo'];
ve.dm.StubSingleTypeAndFuncAnnotation.static.matchFunction = checkForPickMe;
ve.dm.StubSingleTagAndTypeAndFuncAnnotation = function VeDmStubSingleTagAndTypeAndFuncAnnotation( element ) {
ve.dm.Annotation.call( this, element );
};
ve.inheritClass( ve.dm.StubSingleTagAndTypeAndFuncAnnotation, ve.dm.Annotation );
ve.dm.StubSingleTagAndTypeAndFuncAnnotation.static.name = 'stubsingletagandtypeandfunc';
ve.dm.StubSingleTagAndTypeAndFuncAnnotation.static.matchTagNames = ['a'];
ve.dm.StubSingleTagAndTypeAndFuncAnnotation.static.matchRdfaTypes = ['mw:foo'];
ve.dm.StubSingleTagAndTypeAndFuncAnnotation.static.matchFunction = checkForPickMe;
Add extension-specific types functionality to ModelRegistry Extension-specific types are RDFa types (or type regexes) that are registered with the ModelRegistry separately. If an element has a type that is extension-specific, then that element can only be matched by a rule that asserts one of its extension-specific types. For MediaWiki, we would call ve.dm.modelRegistry.registerExtensionSpecificType(/^mw:/ ) . So then an element like <span typeof="mw:foobar"> would either match a rule specifically for mw:foobar, if one exists, or no rule at all; even the rule for <span> would not match. The consequence of this is that elements with unrecognized mw:-prefixed RDFa types are alienated. Change-Id: Ia8ab1fe5dffb9f813689324372a168e8e4a3e0bc
2013-01-22 22:50:35 +00:00
ve.dm.StubBarNode = function VeDmStubBarNode( children, element ) {
Use static.name once for ce and dm nodes Add a static.name property to ce nodes and make sure both ce and dm nodes always use the static.name property in constructors and registration calls. The result of this is that any given node type should now only appear once in the code as a string. Bug: 45701 Change-Id: Ibf31de16ab28ad58209c1443cd74f93dda278998
2013-03-06 22:44:18 +00:00
ve.dm.BranchNode.call( this, children, element );
Add extension-specific types functionality to ModelRegistry Extension-specific types are RDFa types (or type regexes) that are registered with the ModelRegistry separately. If an element has a type that is extension-specific, then that element can only be matched by a rule that asserts one of its extension-specific types. For MediaWiki, we would call ve.dm.modelRegistry.registerExtensionSpecificType(/^mw:/ ) . So then an element like <span typeof="mw:foobar"> would either match a rule specifically for mw:foobar, if one exists, or no rule at all; even the rule for <span> would not match. The consequence of this is that elements with unrecognized mw:-prefixed RDFa types are alienated. Change-Id: Ia8ab1fe5dffb9f813689324372a168e8e4a3e0bc
2013-01-22 22:50:35 +00:00
};
ve.inheritClass( ve.dm.StubBarNode, ve.dm.BranchNode );
ve.dm.StubBarNode.static.name = 'stub-bar';
ve.dm.StubBarNode.static.matchRdfaTypes = ['bar'];
// HACK keep ve.dm.Converter happy for now
// TODO once ve.dm.Converter is rewritten, this can be removed
ve.dm.StubBarNode.static.toDataElement = function () {};
(bug 45062) Implement the new node API in the converter This changes the node API to work with multiple elements, so we can support about groups. Instead of passing in and returning single DOM elements, we use arrays of DOM elements. ve.dm.Converter: * Pass modelRegistry into the constructor * Remove onNodeRegister handler and its data * Remove getDataElementFromDomElement() and getDataAnnotationFromDomElement(). Most logic moved into getDataFromDom(), some into createDataElement() * Remove createAlien(), replaced with createDataElement( ve.dm.AlienNode, ... ) * Replace doAboutGrouping() (which wrapped about groups) with getAboutGroup() (which returns an array of the nodes in the group) * Put in a hack so <meta>/<link> elements with an mw: property aren't alienated * Remove about group wrapping behavior in favor of just outputting multiple nodes ve.dm.AlienNode.js: * For multi-element aliens, only choose inline if all elements are inline, not just the first one ve.dm.example.js: * Add html/0 stuff for meta nodes * Fix test case to reflect new alien behavior Change-Id: I40dcc27430f778bc00a44b91b7d824bfb2718be6
2013-02-16 02:37:50 +00:00
ve.dm.StubBarNode.static.toDomElements = function () {};
Add extension-specific types functionality to ModelRegistry Extension-specific types are RDFa types (or type regexes) that are registered with the ModelRegistry separately. If an element has a type that is extension-specific, then that element can only be matched by a rule that asserts one of its extension-specific types. For MediaWiki, we would call ve.dm.modelRegistry.registerExtensionSpecificType(/^mw:/ ) . So then an element like <span typeof="mw:foobar"> would either match a rule specifically for mw:foobar, if one exists, or no rule at all; even the rule for <span> would not match. The consequence of this is that elements with unrecognized mw:-prefixed RDFa types are alienated. Change-Id: Ia8ab1fe5dffb9f813689324372a168e8e4a3e0bc
2013-01-22 22:50:35 +00:00
Make string type matches override regex type matches Change-Id: Ic21e27c047d8cb1161a6613bb5232d0d19b37aa6
2013-02-20 17:22:50 +00:00
ve.dm.StubAbbrNode = function VeDmStubAbbrNode( children, element ) {
Use static.name once for ce and dm nodes Add a static.name property to ce nodes and make sure both ce and dm nodes always use the static.name property in constructors and registration calls. The result of this is that any given node type should now only appear once in the code as a string. Bug: 45701 Change-Id: Ibf31de16ab28ad58209c1443cd74f93dda278998
2013-03-06 22:44:18 +00:00
ve.dm.BranchNode.call( this, children, element );
Make string type matches override regex type matches Change-Id: Ic21e27c047d8cb1161a6613bb5232d0d19b37aa6
2013-02-20 17:22:50 +00:00
};
ve.inheritClass( ve.dm.StubAbbrNode, ve.dm.BranchNode );
ve.dm.StubAbbrNode.static.name = 'stub-abbr';
ve.dm.StubAbbrNode.static.matchTagNames = ['abbr'];
ve.dm.StubAbbrNode.static.matchRdfaTypes = ['mw:abbr'];
Support RDFa type regexes in ModelRegistry Change-Id: Id19c3a567140f9e27ba732b6e8d9e25bc7a28a4f
2013-02-20 16:43:09 +00:00
ve.dm.StubRegExpNode = function VeDmStubRegExpNode( children, element ) {
Use static.name once for ce and dm nodes Add a static.name property to ce nodes and make sure both ce and dm nodes always use the static.name property in constructors and registration calls. The result of this is that any given node type should now only appear once in the code as a string. Bug: 45701 Change-Id: Ibf31de16ab28ad58209c1443cd74f93dda278998
2013-03-06 22:44:18 +00:00
ve.dm.BranchNode.call( this, children, element );
Support RDFa type regexes in ModelRegistry Change-Id: Id19c3a567140f9e27ba732b6e8d9e25bc7a28a4f
2013-02-20 16:43:09 +00:00
};
ve.inheritClass( ve.dm.StubRegExpNode, ve.dm.BranchNode );
ve.dm.StubRegExpNode.static.name = 'stub-regexp';
ve.dm.StubRegExpNode.static.matchTagNames = ['abbr'];
ve.dm.StubRegExpNode.static.matchRdfaTypes = [ /^mw:/ ];
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
/* Tests */
Make string type matches override regex type matches Change-Id: Ic21e27c047d8cb1161a6613bb5232d0d19b37aa6
2013-02-20 17:22:50 +00:00
QUnit.test( 'matchElement', 20, function ( assert ) {
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
var registry = new ve.dm.ModelRegistry(), element;
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element = document.createElement( 'a' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), null, 'matchElement() returns null if registry empty' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
Drop name parameter from ModelRegistry.register(), use .static.name Change-Id: I74eeab1195455072ae48ac0655582f2bf01806d6
2013-01-18 21:46:20 +00:00
registry.register( ve.dm.StubNothingSetAnnotation );
registry.register( ve.dm.StubSingleTagAnnotation );
registry.register( ve.dm.StubSingleTypeAnnotation );
registry.register( ve.dm.StubSingleTagAndTypeAnnotation );
registry.register( ve.dm.StubFuncAnnotation );
registry.register( ve.dm.StubSingleTagAndFuncAnnotation );
registry.register( ve.dm.StubSingleTypeAndFuncAnnotation );
registry.register( ve.dm.StubSingleTagAndTypeAndFuncAnnotation );
Add extension-specific types functionality to ModelRegistry Extension-specific types are RDFa types (or type regexes) that are registered with the ModelRegistry separately. If an element has a type that is extension-specific, then that element can only be matched by a rule that asserts one of its extension-specific types. For MediaWiki, we would call ve.dm.modelRegistry.registerExtensionSpecificType(/^mw:/ ) . So then an element like <span typeof="mw:foobar"> would either match a rule specifically for mw:foobar, if one exists, or no rule at all; even the rule for <span> would not match. The consequence of this is that elements with unrecognized mw:-prefixed RDFa types are alienated. Change-Id: Ia8ab1fe5dffb9f813689324372a168e8e4a3e0bc
2013-01-22 22:50:35 +00:00
registry.register( ve.dm.StubBarNode );
Make string type matches override regex type matches Change-Id: Ic21e27c047d8cb1161a6613bb5232d0d19b37aa6
2013-02-20 17:22:50 +00:00
registry.register( ve.dm.StubAbbrNode );
Support RDFa type regexes in ModelRegistry Change-Id: Id19c3a567140f9e27ba732b6e8d9e25bc7a28a4f
2013-02-20 16:43:09 +00:00
registry.register( ve.dm.StubRegExpNode );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element = document.createElement( 'b' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubnothingset', 'nothingset matches anything' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element.setAttribute( 'rel', 'mw:foo' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubsingletype', 'type-only match' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element = document.createElement( 'a' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubsingletag', 'tag-only match' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element.setAttribute( 'rel', 'mw:foo' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubsingletagandtype', 'tag and type match' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element.setAttribute( 'pickme', 'true' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubsingletagandtypeandfunc', 'tag, type and func match' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element.setAttribute( 'rel', 'mw:bar' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubsingletagandfunc', 'tag and func match' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element = document.createElement( 'b' );
element.setAttribute( 'pickme', 'true' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubfunc', 'func-only match' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
element.setAttribute( 'rel', 'mw:foo' );
Move matching code from AnnotationFactory to ModelRegistry ModelRegistry registers both annotations and nodes, and performs matching on both at the same time. It also registers annotations with the AnnotationFactory, and nodes with the NodeFactory. Change-Id: I5e68e506a0e573cc0afe6304ccea058ffc20d1c8
2013-01-18 05:29:01 +00:00
assert.deepEqual( registry.matchElement( element ), 'stubsingletypeandfunc', 'type and func match' );
Support RDFa type regexes in ModelRegistry Change-Id: Id19c3a567140f9e27ba732b6e8d9e25bc7a28a4f
2013-02-20 16:43:09 +00:00
element = document.createElement( 'abbr' );
element.setAttribute( 'rel', 'mw:baz' );
assert.deepEqual( registry.matchElement( element ), 'stub-regexp', 'RegExp type match' );
Make string type matches override regex type matches Change-Id: Ic21e27c047d8cb1161a6613bb5232d0d19b37aa6
2013-02-20 17:22:50 +00:00
element.setAttribute( 'rel', 'mw:abbr' );
assert.deepEqual( registry.matchElement( element ), 'stub-abbr', 'String match overrides RegExp match' );
Add extension-specific types functionality to ModelRegistry Extension-specific types are RDFa types (or type regexes) that are registered with the ModelRegistry separately. If an element has a type that is extension-specific, then that element can only be matched by a rule that asserts one of its extension-specific types. For MediaWiki, we would call ve.dm.modelRegistry.registerExtensionSpecificType(/^mw:/ ) . So then an element like <span typeof="mw:foobar"> would either match a rule specifically for mw:foobar, if one exists, or no rule at all; even the rule for <span> would not match. The consequence of this is that elements with unrecognized mw:-prefixed RDFa types are alienated. Change-Id: Ia8ab1fe5dffb9f813689324372a168e8e4a3e0bc
2013-01-22 22:50:35 +00:00
registry.registerExtensionSpecificType( /^mw:/ );
registry.registerExtensionSpecificType( 'foo' );
element = document.createElement( 'a' );
element.setAttribute( 'rel', 'bar baz' );
assert.deepEqual( registry.matchElement( element ), 'stub-bar', 'incomplete non-extension-specific type match' );
element.setAttribute( 'pickme', 'true' );
assert.deepEqual( registry.matchElement( element ), 'stubsingletagandfunc', 'incomplete non-extension-specific type match is trumped by tag&func match' );
element.setAttribute( 'rel', 'mw:bogus' );
assert.deepEqual( registry.matchElement( element ), null, 'extension-specific type matching regex prevents tag-only and func-only matches' );
element.setAttribute( 'rel', 'foo' );
assert.deepEqual( registry.matchElement( element ), null, 'extension-specific type matching string prevents tag-only and func-only matches' );
element.setAttribute( 'rel', 'mw:bogus bar' );
assert.deepEqual( registry.matchElement( element ), null, 'extension-specific type matching regex prevents type match' );
element.setAttribute( 'rel', 'foo bar' );
assert.deepEqual( registry.matchElement( element ), null, 'extension-specific type matching string prevents type match' );
element.setAttribute( 'rel', 'foo bar mw:bogus' );
assert.deepEqual( registry.matchElement( element ), null, 'two extension-specific types prevent non-extension-specific type match' );
Support RDFa type regexes in ModelRegistry Change-Id: Id19c3a567140f9e27ba732b6e8d9e25bc7a28a4f
2013-02-20 16:43:09 +00:00
element = document.createElement( 'abbr' );
element.setAttribute( 'rel', 'mw:baz' );
assert.deepEqual( registry.matchElement( element ), 'stub-regexp', 'RegExp type match for extension-specific type' );
Make string type matches override regex type matches Change-Id: Ic21e27c047d8cb1161a6613bb5232d0d19b37aa6
2013-02-20 17:22:50 +00:00
element.setAttribute( 'rel', 'mw:abbr' );
assert.deepEqual( registry.matchElement( element ), 'stub-abbr', 'String match overrides RegExp match for extension-specific type' );
New annotation API: Annotation and AnnotationFactory classes Fleshes out ve.dm.Annotation to a class. Annotations in the linear model will be instances of a subclass of ve.dm.Annotation. Annotations are defined by subclassing ve.dm.Annotation and registering this subclass with ve.dm.AnnotationFactory. ve.dm.AnnotationFactory keeps track of which annotation classes are known, and has code to match an HTML element to an annotation class, for use in the converter. Change-Id: I68802bdb8736ced1f9e04ee49c623944b448141c
2012-08-31 19:34:18 +00:00
} );
Reference in a new issue Copy permalink