mirror of
https://gerrit.wikimedia.org/r/mediawiki/extensions/VisualEditor
synced 2024-11-24 22:35:41 +00:00
b1d9c83b5d
* For the most common case:
- replace ve.extendClass with ve.inheritClass (chose slightly
different names to detect usage of the old/new one, and I
like 'inherit' better).
- move it up to below the constructor, see doc block for why.
* Cases where more than 2 arguments were passed to
ve.extendClass are handled differently depending on the case.
In case of a longer inheritance tree, the other arguments
could be omitted (like in "ve.ce.FooBar, ve.FooBar,
ve.Bar". ve.ce.FooBar only needs to inherit from ve.FooBar,
because ve.ce.FooBar inherits from ve.Bar).
In the case of where it previously had two mixins with
ve.extendClass(), either one becomes inheritClass and one
a mixin, both to mixinClass().
No visible changes should come from this commit as the
instances still all have the same visible properties in the
end. No more or less than before.
* Misc.:
- Be consistent in calling parent constructors in the
same order as the inheritance.
- Add missing @extends and @param documentation.
- Replace invalid {Integer} type hint with {Number}.
- Consistent doc comments order:
@class, @abstract, @constructor, @extends, @params.
- Fix indentation errors
A fairly common mistake was a superfluous space before the
identifier on the assignment line directly below the
documentation comment.
$ ack "^ [^*]" --js modules/ve
- Typo "Inhertiance" -> "Inheritance".
- Replacing the other confusing comment "Inheritance" (inside
the constructor) with "Parent constructor".
- Add missing @abstract for ve.ui.Tool.
- Corrected ve.FormatDropdownTool to ve.ui.FormatDropdownTool.js
- Add function names to all @constructor functions. Now that we
have inheritance it is important and useful to have these
functions not be anonymous.
Example of debug shot: http://cl.ly/image/1j3c160w3D45
Makes the difference between
< documentNode;
> ve_dm_DocumentNode
...
: ve_dm_BranchNode
...
: ve_dm_Node
...
: ve_dm_Node
...
: Object
...
without names (current situation):
< documentNode;
> Object
...
: Object
...
: Object
...
: Object
...
: Object
...
though before this commit, it really looks like this
(flattened since ve.extendClass really did a mixin):
< documentNode;
> Object
...
...
...
Pattern in Sublime (case-sensitive) to find nameless
constructor functions:
"^ve\..*\.([A-Z])([^\.]+) = function \("
Change-Id: Iab763954fb8cf375900d7a9a92dec1c755d5407e
139 lines
3.2 KiB
JavaScript
139 lines
3.2 KiB
JavaScript
/**
|
|
* VisualEditor Range class.
|
|
*
|
|
* @copyright 2011-2012 VisualEditor Team and others; see AUTHORS.txt
|
|
* @license The MIT License (MIT); see LICENSE.txt
|
|
*/
|
|
|
|
/**
|
|
* Range of content.
|
|
*
|
|
* @class
|
|
* @constructor
|
|
* @param from {Number} Starting offset
|
|
* @param [to=from] {Number} Ending offset
|
|
* @property from {Number} Starting offset
|
|
* @property to {Number} Ending offset
|
|
* @property start {Number} Normalized starting offset
|
|
* @property end {Number} Normalized ending offset
|
|
*/
|
|
ve.Range = function veRange( from, to ) {
|
|
this.from = from || 0;
|
|
this.to = typeof to === 'undefined' ? this.from : to;
|
|
this.normalize();
|
|
};
|
|
|
|
/**
|
|
* Creates a new ve.Range object that's a translated version of another.
|
|
*
|
|
* @method
|
|
* @param {ve.Range} range Range to base new range on
|
|
* @param {Number} distance Distance to move range by
|
|
* @returns {ve.Range} New translated range
|
|
*/
|
|
ve.Range.newFromTranslatedRange = function ( range, distance ) {
|
|
return new ve.Range( range.from + distance, range.to + distance );
|
|
};
|
|
|
|
/**
|
|
* Creates a new ve.Range object that covers all of the given ranges
|
|
*
|
|
* @method
|
|
* @param {Array} ranges Array of ve.Range objects (at least one)
|
|
* @returns {ve.Range} Range that spans all of the given ranges
|
|
*/
|
|
ve.Range.newCoveringRange = function ( ranges ) {
|
|
var minStart, maxEnd, i;
|
|
if ( !ranges || ranges.length === 0 ) {
|
|
throw new Error( 'newCoveringRange() requires at least one range' );
|
|
}
|
|
minStart = ranges[0].start;
|
|
maxEnd = ranges[0].end;
|
|
for ( i = 1; i < ranges.length; i++ ) {
|
|
if ( ranges[i].start < minStart ) {
|
|
minStart = ranges[i].start;
|
|
}
|
|
if ( ranges[i].end > maxEnd ) {
|
|
maxEnd = ranges[i].end;
|
|
}
|
|
}
|
|
return new ve.Range( minStart, maxEnd );
|
|
};
|
|
|
|
/* Methods */
|
|
|
|
/**
|
|
* Gets a clone of this object.
|
|
*
|
|
* @method
|
|
* @returns {ve.Range} Clone of range
|
|
*/
|
|
ve.Range.prototype.clone = function () {
|
|
return new ve.Range( this.from, this.to );
|
|
};
|
|
|
|
/**
|
|
* Checks if an offset is within this range.
|
|
*
|
|
* @method
|
|
* @param offset {Number} Offset to check
|
|
* @returns {Boolean} If offset is within this range
|
|
*/
|
|
ve.Range.prototype.containsOffset = function ( offset ) {
|
|
this.normalize();
|
|
return offset >= this.start && offset < this.end;
|
|
};
|
|
|
|
/**
|
|
* Gets the length of the range.
|
|
*
|
|
* @method
|
|
* @returns {Number} Length of range
|
|
*/
|
|
ve.Range.prototype.getLength = function () {
|
|
return Math.abs( this.from - this.to );
|
|
};
|
|
|
|
/**
|
|
* Sets start and end properties, ensuring start is always before end.
|
|
*
|
|
* This should always be called before using the start or end properties. Do not call this unless
|
|
* you are about to use these properties.
|
|
*
|
|
* @method
|
|
*/
|
|
ve.Range.prototype.normalize = function () {
|
|
if ( this.from < this.to ) {
|
|
this.start = this.from;
|
|
this.end = this.to;
|
|
} else {
|
|
this.start = this.to;
|
|
this.end = this.from;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Swaps from and to values, effectively changing the direction.
|
|
*
|
|
* The range will also be normalized when this is called.
|
|
*
|
|
* @method
|
|
*/
|
|
ve.Range.prototype.flip = function () {
|
|
var from = this.from;
|
|
this.from = this.to;
|
|
this.to = from;
|
|
this.normalize();
|
|
};
|
|
|
|
/**
|
|
* Determines if two Ranges are equal. Direction counts.
|
|
*
|
|
* @method
|
|
* @param {ve.Range}
|
|
* @returns {Boolean}
|
|
*/
|
|
ve.Range.prototype.equals = function ( other ) {
|
|
return this.from === other.from && this.to === other.to;
|
|
};
|