wikimedia/mediawiki-extensions-ParserFunctions
1
0
Fork 0
mirror of https://gerrit.wikimedia.org/r/mediawiki/extensions/ParserFunctions synced 2024-12-19 11:31:26 +00:00
Code Issues Packages Projects Releases Wiki Activity
mediawiki-extensions-Parser.../Convert.php

906 lines
29 KiB
PHP
Raw Blame History

<?php
if ( !defined( 'MEDIAWIKI' ) ) {
die( 'This file is a MediaWiki extension, it is not a valid entry point' );
}
class ConvertError extends MWException {
public function __construct( $msg /*...*/ ) {
$args = func_get_args();
array_shift( $args );
array_map( 'htmlspecialchars', $args );
$this->message = '<strong class="error">' . wfMsgForContent( "pfunc-convert-$msg", $args ) . '</strong>';
}
}
class ConvertParser {
# A regex which matches the body of the string and the source unit separately
const UNITS_REGEX = '/^(.+?)([a-z]+\^?\d?(?:\/\w+\^?\d?)*)$/i';
# A regex which matches a number
const NUM_REGEX = '/\b((?:\+|\-|&minus;|\x{2212})?(\d+(?:\.\d+)?)(?:E(?:\+|\-|&minus;|\x{2212})?\d+)?)\b/iu';
# A regex *FRAGMENT* which matches SI prefixes
const PREFIX_REGEX = '[YZEPTGMkh(da)dcm\x{03BC}\x{00B5}npfazy]?';
/**
* @var ConvertUnit
*/
protected $sourceUnit;
/**
* @var ConvertUnit
*/
protected $targetUnit;
# Whether to abbreviate the output unit
protected $abbreviate;
# Whether to link the output unit, if possible
protected $link;
# If set, don't output the unit or format the number
protected $raw;
# What precision to round to.
protected $decimalPlaces;
protected $significantFigures;
# What language to display the units in
# @var Language
protected $language;
# The last value converted, which will be used for PLURAL evaluation
protected $lastValue;
/**
* Reset the parser so it isn't contaminated by the results of previous parses
*/
public function clearState(){
# Make sure we break any references set up in the parameter passing below
unset( $this->sourceUnit );
unset( $this->targetUnit );
$this->sourceUnit = null;
$this->targetUnit = null;
$this->lastValue
= $this->link
= $this->precision
= $this->abbreviate
= $this->raw
= $this->significantFigures
= $this->decimalPlaces
= null;
$this->language = true; # prompts wfGetLangObj() to use $wgContLang
}
/**
* Evaluate a convert expression
* @param $args Array of the parameters passed to the original tag function
* @return String
* @throws ConvertError
*/
public function execute( $args ) {
$this->clearState();
array_shift( $args ); # Dump Parser object
if( count( $args ) == 0 ){
# that was easy
return '';
}
$string = trim( array_shift( $args ) );
# Process the rest of the args
static $magicWords = array(
'sourceunit' => null,
'targetunit' => null,
'linkunit' => null,
'decimalplaces' => null,
'significantfigures' => null,
'abbreviate' => null,
'rawsuffix' => null,
'language' => null,
);
if( !is_object( $magicWords ) ){
foreach( $magicWords as $key => &$val ){
$magicWords[$key] =& MagicWord::get( $key );
}
# The $magicWords[key]->function() syntax doesn't work, so cast to
# object so we can use $magicWords->key->function() instead
$magicWords = (object)$magicWords;
}
$n = 0; # Count of unnamed parameters
foreach ( $args as $arg ) {
$parts = array_map( 'trim', explode( '=', $arg, 2 ) );
if ( count( $parts ) == 2 ) {
# Found "="
if ( $magicWords->sourceunit->matchStartAndRemove( $parts[0] ) ) {
if( $magicWords->targetunit->matchStartAndRemove( $parts[1] ) ){
$this->targetUnit =& $this->sourceUnit;
} else {
$this->sourceUnit = new ConvertUnit( $parts[1] );
}
} elseif ( $magicWords->targetunit->matchStartAndRemove( $parts[0] ) ) {
if( $magicWords->sourceunit->matchStartAndRemove( $parts[1] ) ){
$this->targetUnit =& $this->sourceUnit;
} else {
$this->targetUnit = new ConvertUnit( $parts[1] );
}
} elseif( $magicWords->decimalplaces->matchStartAndRemove( $parts[0] ) ) {
$this->decimalPlaces = intval( $parts[1] );
} elseif( $magicWords->significantfigures->matchStartAndRemove( $parts[0] ) ) {
# It doesn't make any sense to have negative sig-figs
if( intval( $parts[1] ) > 0 ){
$this->significantFigures = intval( $parts[1] );
}
} elseif( $magicWords->language->matchStartAndRemove( $parts[0] ) ) {
# if this is an invalid code we'll get $wgContLang back
$this->language = Language::factory( $parts[1] );
}
} elseif( $magicWords->linkunit->matchStartAndRemove( $parts[0] ) ) {
$this->link = true;
} elseif( $magicWords->abbreviate->matchStartAndRemove( $parts[0] ) ) {
$this->abbreviate = true;
} elseif( $magicWords->rawsuffix->matchStartAndRemove( $parts[0] ) ) {
$this->raw = true;
} elseif( $parts[0] != '' && !$n++ && !$this->targetUnit instanceof ConvertUnit ){
# First unnamed parameter = output unit
$this->targetUnit = new ConvertUnit( $parts[0] );
}
}
# Get the source unit, if not already set. This throws ConvertError on failure
if ( !$this->sourceUnit instanceof ConvertUnit ){
$this->deduceSourceUnit( $string );
} else {
# The string has no unit on the end, so it's been trimmed to the end of the
# last digit, meaning the unit specified by #sourceunit won't have any space
$string .= ' ';
}
# Use the default unit (SI usually)
if( !$this->targetUnit instanceof ConvertUnit ){
$this->targetUnit = $this->sourceUnit->getDefaultUnit();
}
if( $this->targetUnit->dimension->value != $this->sourceUnit->dimension->value ){
throw new ConvertError(
'dimensionmismatch',
$this->sourceUnit->dimension->getLocalisedName(true),
$this->targetUnit->dimension->getLocalisedName(true)
);
}
# If the Language hasn't been deliberately specified, get it from the wiki's
# content language, but run it through a configurable map first
if( $this->language === true ){
global $wgContLang, $wgPFUnitLanguageVariants;
$code = $wgContLang->getCode();
if( isset( $wgPFUnitLanguageVariants[$code] ) ){
$this->language = Language::factory( $wgPFUnitLanguageVariants[$code] );
} else {
# Ok, actually *do* use $wgContLang
$this->language = true;
}
}
return $this->processString( $string );
}
/**
* Find the unit at the end of the string and load $this->sourceUnit with an appropriate
* ConvertUnit, or throw an exception if the unit is unrecognised.
* @param $string
*/
protected function deduceSourceUnit( $string ){
# Get the unit from the end of the string
$matches = array();
preg_match( self::UNITS_REGEX, $string, $matches );
if( count( $matches ) == 3 ){
$this->sourceUnit = new ConvertUnit( $matches[2] );
} else {
throw new ConvertError( 'nounit' );
}
}
/**
* Identify the values to be converted, and convert them
* @param $string String
* @return String
*/
protected function processString( $string ){
# Replace values
$string = preg_replace_callback(
self::NUM_REGEX,
array( $this, 'convert' ),
ltrim( preg_replace( self::UNITS_REGEX, '$1', $string ) )
);
if( $this->raw ){
return trim( $string );
} else {
return $this->targetUnit->getText(
$string,
$this->lastValue,
$this->link,
$this->abbreviate,
$this->language
);
}
}
/**
* Express a value in the $sourceUnit in terms of the $targetUnit, preserving
* an appropriate degree of accuracy.
* @param $value String
* @return String
*/
public function convert( $value ){
global $wgContLang;
$valueFloat = floatval( $value[1] );
$newValue = $valueFloat
* $this->sourceUnit->getConversion()
/ $this->targetUnit->getConversion();
if( $this->decimalPlaces !== null && $this->significantFigures !== null ){
# round to the required number of decimal places, or the required number
# of significant figures, whichever is the least precise
$dp = floor( $this->significantFigures - log10( abs( $newValue ) ) ); # Convert SF to DP
$newValue = round( $newValue, max( $dp, $this->decimalPlaces ) );
} elseif( $this->decimalPlaces !== null ){
$newValue = round( $newValue, $this->decimalPlaces );
} elseif( $this->significantFigures !== null ){
$dp = floor( $this->significantFigures - log10( abs( $newValue ) ) ); # Convert SF to DP
$newValue = round( $newValue, $dp );
} else {
# Need to round to a similar accuracy as the original value. To do that we
# select the accuracy which will as closely as possible preserve the maximum
# percentage error in the value. So 36ft = 36 ± 0.5 ft, so the uncertainty
# is ±0.5/36 = ±1.4%. In metres this is 10.9728 ± 1.4%, or 10.9728 ± 0.154
# we take the stance of choosing the limit which is *more* precise than the
# original value.
# Strip sign and exponent
$num = preg_replace( self::NUM_REGEX, '$2', $value[1] );
if( strpos( $num, '.' ) !== false ){
# If there is a decimal point, this is the number of digits after it.
$dpAfter = strlen( $num ) - strpos( $num, '.' ) - 1;
$error = pow( 10, -$dpAfter - 1 ) * 5;
} elseif( $num == 0 ) {
# The logarithms below will be unhappy, and it doesn't actually matter
# what error we come up with, zero is still zero
$error = 1;
} else {
# Number of digits before the point
$dpBefore = floor( log10( abs( $num ) ) );
# Number of digits if we reverse the string = number
# of digits excluding trailing zeros
$dpAfter = floor( log10( abs( strrev( $num ) ) ) );
# How many significant figures to consider numbers like "35000" to have
# is a tricky question. We say 2 here because if people want to ensure
# that the zeros are included, they could write it as 3.500E4
$error = pow( 10, $dpBefore - $dpAfter - 1 ) * 5;
}
$errorFraction = $error / $num;
$i = 10;
while( $i > -10 && ( round( $newValue, $i - 1 ) != 0 ) &&
# Rounding to 10dp avoids floating point errors in exact conversions,
# which are on the order of 1E-16
( round( 5 * pow( 10, -$i ) / round( $newValue, $i - 1 ), 10 ) <= round( $errorFraction, 10 ) ) )
{
$i--;
}
$newValue = round( $newValue, $i );
# We may need to stick significant zeros back onto the number
if( $i > 0 ){
if( strpos( $newValue, '.' ) !== false ){
$newValue = str_pad( $newValue, $i + strpos( $newValue, '.' ) + 1, '0' );
} else {
$newValue .= '.' . str_repeat( '0', $i );
}
}
}
# Store the last value for use in PLURAL later
$this->lastValue = $newValue;
return $this->raw
? $newValue
: $wgContLang->formatNum( $newValue );
}
}
/**
* A dimension
*/
class ConvertDimension {
const MASS = 1; # KILOGRAM
const LENGTH = 10; # METRE
const TIME = 100; # SECOND
const TEMPERATURE = 1E3; # KELVIN
const QUANTITY = 1E4; # MOLE
const CURRENT = 1E5; # AMPERE
const INTENSITY = 1E6; # CANDELA
# fuel efficiencies are ugly and horrible and dimensionally confused, and have the
# same dimensions as LENGTH or 1/LENGTH. But someone wanted to include them... so
# we have up to ten dimensions which can be identified by values of this.
# 0 = sane unit
# 1 = some sort of fuel efficiency
const UGLY_HACK_VALUE = 1E7;
/**
* Dimension constants. These are the values you'd get if you added the SI
* base units together with the weighting given above, also the output from
* getDimensionHash(). Cool thing is, you can add these together to get new
* compound dimensions.
*/
const DIM_DIMENSIONLESS = 0; # Numbers etc
const DIM_LENGTH = 10;
const DIM_AREA = 20;
const DIM_VOLUME = 30;
const DIM_TIME = 100;
const DIM_TIME_SQ = 200;
const DIM_MASS = 1;
const DIM_TEMPERATURE = 1000;
const DIM_SPEED = -90; # LENGTH / TIME
const DIM_ACCELERATION = -190; # LENGTH / TIME_SQ
const DIM_FORCE = -189; # MASS * LENGTH / TIME_SQ
const DIM_TORQUE = -179; # also MASS * AREA / TIME_SQ, but all units are single
const DIM_ENERGY = -179; # MASS * AREA / TIME_SQ, all units are compound
const DIM_PRESSURE = -209; # MASS / ( LENGTH * TIME_SQ )
const DIM_POWER = -79; # MASS * AREA / TIME
const DIM_DENSITY = -29; # MASS / VOLUME
const DIM_FUELEFFICIENCY_PVE = 10000020; # fuel efficiency in VOLUME / LENGTH
const DIM_FUELEFFICIENCY_NVE = 99999990; # fuel efficiency in LENGTH / VOLUME
# Map of dimension names to message keys. This also serves as a list of what
# dimensions will not throw an error when encountered.
public static $legalDimensions = array(
self::DIM_LENGTH => 'length',
self::DIM_AREA => 'area',
self::DIM_VOLUME => 'volume',
self::DIM_TIME => 'time',
self::DIM_TIME_SQ => 'timesquared',
self::DIM_MASS => 'mass',
self::DIM_TEMPERATURE => 'temperature',
self::DIM_SPEED => 'speed',
self::DIM_ACCELERATION => 'acceleration',
self::DIM_FORCE => 'force',
self::DIM_TORQUE => 'torque',
self::DIM_ENERGY => 'energy',
self::DIM_PRESSURE => 'pressure',
self::DIM_POWER => 'power',
self::DIM_DENSITY => 'density',
self::DIM_FUELEFFICIENCY_PVE => 'fuelefficiencypositive',
self::DIM_FUELEFFICIENCY_NVE => 'fuelefficiencynegative',
);
public $value;
protected $name;
/**
* Constructor
* @param $var ConvertDimension|Int a dimension constant or existing unit
* @param $var2 ConvertDimension|Int optionally another dimension constant for a compound unit $var/$var2
*/
public function __construct( $var, $var2=null ){
static $legalDimensionsFlip;
if( is_string( $var ) ){
if( $legalDimensionsFlip === null ){
$legalDimensionsFlip = array_flip( self::$legalDimensions );
}
if( isset( $legalDimensionsFlip[$var] ) ){
$dim = $legalDimensionsFlip[$var];
} else {
# Should be unreachable
throw new ConvertError( 'unknowndimension' );
}
} elseif( $var instanceof self ){
$dim = $var->value;
} else {
$dim = intval( $var );
}
if( $var2 === null ){
$this->value = $dim;
$this->name = $this->compoundName = self::$legalDimensions[$this->value];
} else {
if( is_string( $var2 ) ){
if( $legalDimensionsFlip === null ){
$legalDimensionsFlip = array_flip( self::$legalDimensions );
}
if( isset( $legalDimensionsFlip[$var2] ) ){
$dim2 = $legalDimensionsFlip[$var2];
} else {
# Should be unreachable
throw new ConvertError( 'unknowndimension' );
}
} elseif( $var2 instanceof self ){
$dim2 = $var2->value;
} else {
$dim2 = intval( $var2 );
}
$this->value = $dim - $dim2;
if( in_array( $this->value, array_keys( self::$legalDimensions ) ) ){
$this->name = self::$legalDimensions[$this->value];
$this->compoundName = array(
self::$legalDimensions[$dim],
self::$legalDimensions[$dim2],
);
} else {
# Some combinations of units are fine (carats per bushel is a perfectly good,
# if somewhat bizarre, measure of density, for instance). But others (like
# carats per miles-per-gallon) are definitely not.
# TODO: this allows compound units like <gigawatthours>/<pascal> as a unit
# of volume; is that a good thing or a bad thing?
throw new ConvertError( 'invalidcompoundunit', "$var/$var2" );
}
}
}
/**
* Convert to string. Magic in PHP 5.1 and above.
* @return String
*/
public function __toString(){
return strval( $this->name );
}
/**
* Get the name, or names, of the dimension
* @param $expandCompound Bool Whether to return a string instead of an array of strings in
* case of a compound unit
* @return String|Array of String
*/
public function getName( $expandCompound = false ){
return $expandCompound
? $this->name
: $this->compoundName;
}
/**
* Get the localised name of the dimension. Output is unescaped
* @return String
*/
public function getLocalisedName(){
return wfMsg( "pfunc-convert-dimension-{$this->name}" );
}
}
class ConvertUnit {
/**
* array(
* DIMENSION => array(
* UNIT => array(
* CONVERSION,
* REGEX,
* TAKES_SI_PREFIXES,
* )
* )
* )
*/
protected static $units = array(
ConvertDimension::DIM_LENGTH => array(
'metre' => array( 1, 'm', true ),
'angstrom' => array( 0.00000001, '\x{00C5}', false ),
'mile' => array( 1609.344, 'mi|miles?', false ),
'furlong' => array( 201.168, 'furlong', false ),
'chain' => array( 20.1168 , 'chain', false ),
'rod' => array( 5.0292, 'rod|pole|perch', false ),
'fathom' => array( 1.8288, 'fathom', false ),
'yard' => array( 0.9144, 'yards?|yd', false ),
'foot' => array( 0.3048, 'foot|feet|ft', false ),
'hand' => array( 0.1016, 'hands?', false ),
'inch' => array( 0.0254, 'inch|inches|in', false ),
'nauticalmile' => array( 1852, 'nauticalmiles?|nmi', false ),
'nauticalmileuk' => array( 1853.184, 'old[Uu][Kk]nmi|[Bb]rnmi|admi', false ),
'nauticalmileus' => array( 1853.24496, 'old[Uu][Ss]nmi', false ),
'parsec' => array( 3.0856775813057E16, 'parsecs?|pc', true ),
'lightyear' => array( 9.4607304725808E15, 'lightyears?|ly', true ),
'astronomicalunit' => array( 149597870700, 'astronomicalunits?|AU|au', false ),
),
ConvertDimension::DIM_AREA => array(
'squarekilometre' => array( 1E6, 'km2|km\^2', false ),
'squaremetre' => array( 1, 'm2|m\^2', false ),
'squarecentimetre' => array( 1E-4, 'cm2|cm\^2', false ),
'squaremillimetre' => array( 1E-6, 'mm2|mm\^2', false ),
'hectare' => array( 1E4, 'hectares?|ha', false ),
'squaremile' => array( 2589988.110336, 'sqmi|mi2|mi\^2', false ),
'acre' => array( 4046.856422, 'acres?', false ),
'squareyard' => array( 0.83612736, 'sqyd|yd2|yd\^2', false ),
'squarefoot' => array( 0.09290304, 'sqft|ft2|ft\^2', false ),
'squareinch' => array( 0.00064516, 'sqin|in2|in\^2', false ),
'squarenauticalmile' => array( 3429904, 'sqnmi|nmi2|nmi\^2', false ),
'dunam' => array( 1000, 'dunam', false ),
'tsubo' => array( 3.305785, 'tsubo', false ),
),
ConvertDimension::DIM_VOLUME => array(
'cubicmetre' => array( 1, 'm3|m\^3', false ),
'cubiccentimetre' => array( 1E-6, 'cm3|cm\^3', false ),
'cubicmillimetre' => array( 1E-9, 'mm3|mm\^3', false ),
'litre' => array( 1E-3 , 'l', true ),
'cubicyard' => array( 0.764554857984, 'cuyd|yd3|yd\^3', false ),
'cubicfoot' => array( 0.028316846592, 'cuft|ft3|ft\^3', false ),
'cubicinch' => array( 0.000016387064, 'cuin|in3|in\^3', false ),
'barrel' => array( 0.16365924, 'bbl|barrels?|impbbl', false ),
'bushel' => array( 0.03636872, 'bsh|bushels?|impbsh', false ),
'gallon' => array( 0.00454609, 'gal|gallons?|impgal', false ),
'quart' => array( 0.0011365225, 'qt|quarts?|impqt', false ),
'pint' => array( 0.00056826125, 'pt|pints?|imppt', false ),
'fluidounce' => array( 0.0000284130625, 'floz|impfloz', false ),
'barrelus' => array( 0.119240471196, 'usbbl', false ),
'barreloil' => array( 0.158987294928, 'oilbbl', false ),
'barrelbeer' => array( 0.117347765304, 'beerbbl', false ),
'usgallon' => array( 0.003785411784, 'usgal', false ),
'usquart' => array( 0.000946352946, 'usqt', false ),
'uspint' => array( 0.000473176473, 'uspt', false ),
'usfluidounce' => array( 0.0000295735295625, 'usfloz', false ),
'usdrybarrel' => array( 0.11562819898508, 'usdrybbl', false ),
'usbushel' => array( 0.03523907016688, 'usbsh', false ),
'usdrygallon' => array( 0.00440488377086, 'usdrygal', false ),
'usdryquart' => array( 0.001101220942715, 'usdryqt', false ),
'usdrypint' => array( 0.0005506104713575, 'usdrypt', false ),
),
ConvertDimension::DIM_TIME => array(
'year' => array( 31557600, 'yr', true ),
'day' => array( 86400, 'd|days?', false ),
'hour' => array( 3600, 'hours?|hr|h', false ),
'minute' => array( 60, 'minutes?|mins?', false ),
'second' => array( 1, 's', false ),
),
ConvertDimension::DIM_SPEED => array(
'knot' => array( 0.514444444, 'knot|kn', false ),
'speedoflight' => array( 2.9979E8, 'c', false ),
),
ConvertDimension::DIM_PRESSURE => array(
'pascal' => array( 1, 'Pa', true ),
'bar' => array( 100000, 'bar', false ),
'decibar' => array( 10000, 'dbar', false ),
'millibar' => array( 100 , 'mbar|mb', false ),
'kilobarye' => array( 100, 'kba', false ),
'barye' => array( 0.1, 'ba', false ),
'atmosphere' => array( 101325, 'atm|atmospheres?', false ),
'torr' => array( 133.32237, 'torr', false ),
'mmhg' => array( 133.322387415, 'mmHg', false ),
'inhg' => array( 3386.38864034, 'inHg', false ),
'psi' => array( 6894.757293, 'psi', false ),
),
# TODO: other dimensions as needed
);
/**
* array(
* PREFIX => array(
* CONVERSION,
* REGEX,
* )
* )
* They're out of order because this is the order in which they are tested, and
* some prefixes are much more likely to occur than others
*/
protected static $prefixes = array(
'kilo' => array( 1E3, 'k' ),
'milli' => array( 1E-3, 'm' ),
'centi' => array( 1E-2, 'c' ),
'giga' => array( 1E9, 'G' ),
'micro' => array( 1E-6, '(?:\x{03BC}|\x{00B5})' ), # There are two similar mu characters
'mega' => array( 1E6, 'M' ),
'nano' => array( 1E-9, 'n' ),
'hecto' => array( 1E2, 'h' ),
'deca' => array( 1E1, 'da' ),
'deci' => array( 1E-1, 'd' ),
'yotta' => array( 1E24, 'Y' ),
'zetta' => array( 1E21, 'Z' ),
'exa' => array( 1E18, 'E' ),
'peta' => array( 1E15, 'P' ),
'tera' => array( 1E12, 'T' ),
'pico' => array( 1E-12, 'p' ),
'femto' => array( 1E-15, 'f' ),
'atto' => array( 1E-18, 'a' ),
'zepto' => array( 1E-21, 'z' ),
'yocto' => array( 1E-24, 'y' ),
);
# Default units for each dimension
# TODO: this should ideally be localisable
protected static $defaultUnit = array(
ConvertDimension::DIM_LENGTH => 'metre',
ConvertDimension::DIM_AREA => 'squaremetre',
ConvertDimension::DIM_VOLUME => 'cubicmetre',
ConvertDimension::DIM_TIME => 'second',
ConvertDimension::DIM_SPEED => 'metre/second',
ConvertDimension::DIM_PRESSURE => 'pascal',
);
# An array of preprocessing conversions to apply to units
protected static $unitConversions = array(
'/^mph$/u' => 'mi/h',
);
# Map of UNIT => DIMENSION, created on construct
protected static $dimensionMap = false;
/***************** MEMBER VARIABLES *****************/
/**
* @var ConvertDimension
*/
public $dimension;
# What number you need to multiply this unit by to get the equivalent
# value in SI base units
protected $conversion = 1;
# A regex which matches the unit
protected $regex;
# The name of the unit (key into $units[$dimension] above
protected $unitName;
# The SI prefix, if applicable
protected $prefix = null;
/***************** MEMBER FUNCTIONS *****************/
/**
* Constructor
* @param $rawUnit String
*/
public function __construct( $rawUnit ){
if( self::$dimensionMap === false ){
self::$dimensionMap = array();
foreach( self::$units as $dimension => $arr ){
foreach( $arr as $unit => $val ){
self::$dimensionMap[$unit] = $dimension;
}
}
}
$this->parseUnit( $rawUnit );
}
/**
* Parse a raw unit string, and populate member variables
* @param $rawUnit String
*/
protected function parseUnit( $rawUnit ){
# Do mappings like 'mph' --> 'mi/h'
$rawUnit = preg_replace(
array_keys( self::$unitConversions ),
array_values( self::$unitConversions ),
$rawUnit
);
$parts = explode( '/', $rawUnit );
array_map( 'trim', $parts );
if( count( $parts ) == 1 ){
# Single unit
foreach( self::$units as $dimension => $units ){
foreach( $units as $unit => $data ){
if( $rawUnit == $unit
|| ( !$data[2] && preg_match( "/^({$data[1]})$/u", $parts[0] ) )
|| ( $data[2] && preg_match( "/^(" . ConvertParser::PREFIX_REGEX . ")(" . $data[1] . ")$/u", $parts[0] ) ) )
{
$this->dimension = new ConvertDimension( self::$dimensionMap[$unit] );
$this->conversion = $data[0];
$this->regex = $data[1];
$this->unitName = $unit;
# Grab the SI prefix, if it's allowed and there is one
if( $data[2] && !preg_match( "/^({$data[1]})$/u", $parts[0] ) ){
foreach( self::$prefixes as $prefix => $pdata ){
if( preg_match( "/^({$pdata[1]})({$data[1]})$/u", $parts[0] ) ){
$this->prefix = $prefix;
break;
}
}
}
return;
}
}
}
# Unknown unit
throw new ConvertError( 'unknownunit', $rawUnit );
} elseif( count( $parts ) == 2 ){
# Compound unit.
$top = new self( $parts[0] );
$bottom = new self( $parts[1] );
$this->dimension = new ConvertDimension( $top->dimension, $bottom->dimension );
$this->conversion = $top->conversion / $bottom->conversion;
$this->regex = "(?:{$top->regex})/(?:{$bottom->regex})";
$this->unitName = array( $top->unitName, $bottom->unitName );
$this->prefix = array( $top->prefix, $bottom->prefix );
return;
} else {
# Whaaat? Too many parts
throw new ConvertError( 'doublecompoundunit', $rawUnit );
}
}
/**
* Get the mathematical factor which will convert a measurement in this unit into a
* measurement in the SI base unit for the dimension
* @return double
*/
public function getConversion(){
return $this->conversion * $this->getPrefixConversion();
}
/**
* Get the conversion factor associated with the prefix(es) in the unit
* @return double
*/
public function getPrefixConversion(){
if( !$this->prefix ){
return 1;
} elseif( is_array( $this->prefix ) ){
$x = $this->prefix[0] !== null
? self::$prefixes[$this->prefix[0]][0]
: 1;
if( $this->prefix[1] !== null ){
$x *= self::$prefixes[$this->prefix[1]][0];
}
return $x;
} else {
return self::$prefixes[$this->prefix][0];
}
}
/**
* Get a regular expression which will match keywords for this unit
* @return String
*/
public function getRegex(){
return $this->regex;
}
/**
* Get the text of the unit
* @param $string String Original text, with the number converted
* @param $value String number for PLURAL support
* @param $link Bool
* @param $abbreviate Bool
* @param $language Language
* @return String
*/
public function getText( $string, $value, $link=false, $abbreviate=false, $language=null ){
global $wgContLang;
$value = $wgContLang->formatNum( $value );
if( !is_array( $this->unitName ) ){
$msgText = $this->getTextFromMessage(
$this->dimension->getName(),
$this->unitName,
$this->prefix,
$string, $value, $link, $abbreviate, $language
);
} elseif( !wfEmptyMsg( "pfunc-convert-unit-{$this->dimension->getName(true)}-{$this->unitName[0]}-{$this->unitName[1]}" ) ){
# A wiki has created, say, [[MediaWiki:pfunc-convert-unit-speed-metres-second]]
# so they can have it display "<metres per second>" rather than
# "<metres>/<second>"
$msgText = $this->getTextFromMessage(
$this->dimension->getName(true),
"{$this->unitName[0]}-{$this->unitName[1]}",
$this->prefix, # This will probably be rubbish, but it's the wiki users' problem, not ours
$string, $value, $link, $abbreviate, $language
);
} else {
$dimensionNames = $this->dimension->getName();
$msgText = $this->getTextFromMessage(
$dimensionNames[0],
$this->unitName[0],
$this->prefix[0],
$string, $value, $link, $abbreviate, $language
);
$msg2Text = $this->getTextFromMessage(
$dimensionNames[1],
$this->unitName[1],
$this->prefix[1],
'',
1, # Singular for denominator
$link, $abbreviate, $language
);
$msgText = "$msgText/$msg2Text";
}
return trim( $msgText );
}
/**
* Retrieve the unit text from actual messages
* @param $dimension String
* @param $unit String
* @param $prefix String
* @param $string String
* @param $number String the actual value (for {{PLURAL}} etc)
* @param $link Bool
* @param $abbreviate Bool
* @param $language Language|Bool|null
* @return String
*/
protected function getTextFromMessage( $dimension, $unit, $prefix, $string, $number, $link, $abbreviate, $language ){
$abbr = $abbreviate ? '-abbr' : '';
$prefix = $prefix === null
? ''
: wfMsgExt( "pfunc-convert-prefix-$prefix$abbr", array( 'parsemag', 'language' => $language ) );
$text = wfMsgExt(
"pfunc-convert-unit-$dimension-$unit$abbr",
array( 'parsemag', 'language' => $language ),
$string,
$number,
$prefix
);
if( $link && !wfEmptyMsg( "pfunc-convert-unit-$dimension-$unit-link" ) ){
$title = Title::newFromText(
wfMsgForContentNoTrans( "pfunc-convert-unit-$dimension-$unit-link" ),
$prefix
);
if( $title instanceof Title ){
$text = "[[{$title->getFullText()}|$text]]";
}
}
return $text;
}
/**
* Get the default (usually SI) unit associated with this particular dimension
* @return ConvertUnit
*/
public function getDefaultUnit(){
return new ConvertUnit( self::$defaultUnit[$this->dimension->value] );
}
}
Reference in a new issue View git blame Copy permalink