/**
  * @param string|null $typeBase
  * @param string|null $typeLocal
  */
 public function __construct($typeBase, $typeLocal)
 {
     Assert::parameterType('string|null', $typeBase, '$typeBase');
     Assert::parameterType('string|null', $typeLocal, '$typeLocal');
     $this->typeBase = $typeBase;
     $this->typeLocal = $typeLocal;
 }
Пример #2
0
 public function merge(MergeableUpdate $update)
 {
     /** @var SiteStatsUpdate $update */
     Assert::parameterType(__CLASS__, $update, '$update');
     foreach (self::$counters as $field) {
         $this->{$field} += $update->{$field};
     }
 }
 /**
  * @param string $format One of the SnakFormatter::FORMAT_... constants.
  * @param SnakFormatter $formatter A formatter returning plain text.
  * @param callable $escapeCallback A callable taking plain text and returning escaped text.
  *
  * @throws ParameterTypeException
  */
 public function __construct($format, SnakFormatter $formatter, $escapeCallback)
 {
     Assert::parameterType('string', $format, '$format');
     Assert::parameterType('callable', $escapeCallback, '$escapeCallback');
     $this->format = $format;
     $this->formatter = $formatter;
     $this->escapeCallback = $escapeCallback;
 }
 public function setServices(HttpClient $httpClient, $siteMatrix, $outputFile)
 {
     Assert::parameterType('string', $siteMatrix, '$siteMatrix');
     Assert::parameterType('string', $outputFile, '$outputFile');
     $this->httpClient = $httpClient;
     $this->siteMatrix = $siteMatrix;
     $this->outputFile = $outputFile;
 }
Пример #5
0
 public function __construct($sitesFile)
 {
     Assert::parameterType('string', $sitesFile, '$sitesFile');
     if (!is_readable($sitesFile)) {
         throw new \InvalidArgumentException('$sitesFile ' . $sitesFile . ' is not readable');
     }
     $this->sitesFile = $sitesFile;
 }
 /**
  * Overrides the default new for categorization callback
  * This is intended for use while testing and will fail if MW_PHPUNIT_TEST is not defined.
  *
  * @param callable $callback
  * @see RecentChange::newForCategorization for callback signiture
  *
  * @throws MWException
  */
 public function overrideNewForCategorizationCallback($callback)
 {
     if (!defined('MW_PHPUNIT_TEST')) {
         throw new MWException('Cannot override newForCategorization callback in operation.');
     }
     Assert::parameterType('callable', $callback, '$callback');
     $this->newForCategorizationCallback = $callback;
 }
 /**
  * @param Term $matchedTerm
  * @param string $matchedTermType
  * @param EntityId $entityId
  * @param Term|null $displayLabel
  * @param Term|null $displayDescription
  */
 public function __construct(Term $matchedTerm, $matchedTermType, EntityId $entityId, Term $displayLabel = null, Term $displayDescription = null)
 {
     Assert::parameterType('string', $matchedTermType, '$matchedTermType');
     $this->matchedTerm = $matchedTerm;
     $this->matchedTermType = $matchedTermType;
     $this->entityId = $entityId;
     $this->displayLabel = $displayLabel;
     $this->displayDescription = $displayDescription;
 }
 /**
  * Saves the change to a database table.
  *
  * @note Only supports Change objects that are derived from ChangeRow.
  *
  * @param Change $change
  *
  * @throws DBQueryError
  */
 public function saveChange(Change $change)
 {
     Assert::parameterType('Wikibase\\ChangeRow', $change, '$change');
     if ($change->getId() === null) {
         $this->insertChange($change);
     } else {
         $this->updateChange($change);
     }
 }
 public function __construct(HttpClient $httpClient, $siteMatrixUrl, $outputFile)
 {
     Assert::parameterType('string', $siteMatrixUrl, '$siteMatrixUrl');
     Assert::parameterType('string', $outputFile, '$outputFile');
     $this->dumper = new Dumper();
     $this->httpClient = $httpClient;
     $this->siteMatrixUrl = $siteMatrixUrl;
     $this->outputFile = $outputFile;
 }
 /**
  * @param int $revisionId
  * @param string $mode One of the self::FROM_... constants.
  *
  * @return Change|null
  */
 public function loadByRevisionId($revisionId, $mode = self::FROM_SLAVE)
 {
     Assert::parameterType('integer', $revisionId, '$revisionId');
     $change = $this->loadChanges(array('change_revision_id' => $revisionId), array('LIMIT' => 1), __METHOD__, $mode === self::FROM_MASTER ? DB_MASTER : DB_SLAVE);
     if (isset($change[0])) {
         return $change[0];
     } else {
         return null;
     }
 }
 /**
  * @param string $format The output format generated by this formatter. All SnakFormatters
  *  provided via $formattersBySnakType and $formattersByDataType must be safe for this
  *  output format. This is checked by comparing the $format with what each SnakFormatter
  *  returns from getFormat(). MIME parameters are ignored for this check, so FORMAT_HTML
  *  is considered compatible with FORMAT_HTML_DIFF, etc.
  * @param PropertyDataTypeLookup $dataTypeLookup
  * @param SnakFormatter[] $formattersBySnakType An associative array mapping snak types
  *  to SnakFormatter objects. If no formatter is defined for the a given snak type,
  *  $formattersByDataType will be checked for a SnakFormatter for the snak's data type.
  * @param SnakFormatter[] $formattersByDataType An associative array mapping data types
  *  to SnakFormatter objects. If no formatter is defined for the a given data type,
  *  the "*" key in this array is checked for a default formatter.
  *
  * @throws InvalidArgumentException If any of the given formatters is incompatible
  *         with $format. Formats are assumed to be represented by MIME types,
  *         MIME parameters are ignored.
  */
 public function __construct($format, PropertyDataTypeLookup $dataTypeLookup, array $formattersBySnakType, array $formattersByDataType)
 {
     Assert::parameterType('string', $format, '$format');
     $this->assertFormatterArray($format, $formattersBySnakType);
     $this->assertFormatterArray($format, $formattersByDataType);
     $this->format = $format;
     $this->dataTypeLookup = $dataTypeLookup;
     $this->formattersBySnakType = $formattersBySnakType;
     $this->formattersByDataType = $formattersByDataType;
 }
 /**
  * @param string $fileName File name, without the File: prefix.
  *
  * @return string|null The normalized file name or null if the page does not exist
  * @throws InvalidArgumentException
  */
 public function lookupFileName($fileName)
 {
     Assert::parameterType('string', $fileName, '$pageName');
     $cachedValue = $this->cache->get($this->getCacheKey($fileName));
     if ($cachedValue !== false) {
         return $cachedValue;
     }
     $actualFileName = $this->doLookup($fileName);
     $this->cacheResult($fileName, $actualFileName);
     return $actualFileName;
 }
 /**
  * Adds data type definitions. The new definitions are merged with the existing definitions.
  * If a data type in $dataTypeDefinitions was already defined, the old definition is not
  * replaced but the definitions are merged.
  *
  * @param array[] $dataTypeDefinitions An associative array mapping property data type ids
  * (with the prefix "PT:") and value types (with the prefix "VT:") to data type definitions.
  * Each data type definitions are associative arrays, refer to the class level documentation
  * for details.
  */
 public function registerDataTypes(array $dataTypeDefinitions)
 {
     Assert::parameterElementType('array', $dataTypeDefinitions, '$dataTypeDefinitions');
     foreach ($dataTypeDefinitions as $id => $def) {
         Assert::parameter(strpos($id, ':'), "\$dataTypeDefinitions[{$id}]", 'Key must start with a prefix like "PT:" or "VT:".');
         if (isset($this->dataTypeDefinitions[$id])) {
             $this->dataTypeDefinitions[$id] = array_merge($this->dataTypeDefinitions[$id], $dataTypeDefinitions[$id]);
         } else {
             $this->dataTypeDefinitions[$id] = $dataTypeDefinitions[$id];
         }
     }
 }
 /**
  * @see SnakFormatter::format
  *
  * Formats the given Snak as an wikitext link to an authoritative resource.
  * The URL of that link is determined using a SnakUrlExpander.
  * If the snak could not be expanded into a URL, the identifier is returned as simple text.
  *
  * @param Snak $snak
  *
  * @throws ParameterTypeException if $snak is not a PropertyValueSnak, or if $snak->getDataValue()
  * does not return a StringValue.
  * @return string Wikitext
  */
 public function formatSnak(Snak $snak)
 {
     Assert::parameterType('Wikibase\\DataModel\\Snak\\PropertyValueSnak', $snak, '$snak');
     /** @var PropertyValueSnak $snak */
     $id = $snak->getDataValue()->getValue();
     $url = $this->urlExpander->expandUrl($snak);
     if ($url === null) {
         return wfEscapeWikiText($id);
     } else {
         return '[' . $this->escapeWikitextInUrl($url) . ' ' . wfEscapeWikiText($id) . ']';
     }
 }
Пример #15
0
 /**
  * Constructs a TitleValue.
  *
  * @note TitleValue expects a valid DB key; typically, a TitleValue is constructed either
  * from a database entry, or by a TitleParser. We could apply "some" normalization here,
  * such as substituting spaces by underscores, but that would encourage the use of
  * un-normalized text when constructing TitleValues. For constructing a TitleValue from
  * user input or external sources, use a TitleParser.
  *
  * @param int $namespace The namespace ID. This is not validated.
  * @param string $dbkey The page title in valid DBkey form. No normalization is applied.
  * @param string $fragment The fragment title. Use '' to represent the whole page.
  *   No validation or normalization is applied.
  *
  * @throws InvalidArgumentException
  */
 public function __construct($namespace, $dbkey, $fragment = '')
 {
     Assert::parameterType('integer', $namespace, '$namespace');
     Assert::parameterType('string', $dbkey, '$dbkey');
     Assert::parameterType('string', $fragment, '$fragment');
     // Sanity check, no full validation or normalization applied here!
     Assert::parameter(!preg_match('/^_|[ \\r\\n\\t]|_$/', $dbkey), '$dbkey', 'invalid DB key');
     Assert::parameter($dbkey !== '', '$dbkey', 'should not be empty');
     $this->namespace = $namespace;
     $this->dbkey = $dbkey;
     $this->fragment = $fragment;
 }
 /**
  * @see SnakUrlExpander::expandUrl
  *
  * @param PropertyValueSnak $snak
  *
  * @return string|null A URL or URI derived from the Snak, or null if no such URL
  *         could be determined.
  */
 public function expandUrl(PropertyValueSnak $snak)
 {
     $propertyId = $snak->getPropertyId();
     $value = $snak->getDataValue();
     Assert::parameterType('DataValues\\StringValue', $value, '$snak->getDataValue()');
     $pattern = $this->infoProvider->getPropertyInfo($propertyId);
     if ($pattern === null) {
         return null;
     }
     $id = urlencode($value->getValue());
     $url = str_replace('$1', $id, $pattern);
     return $url;
 }
 /**
  * @param string $dataTypeId
  *
  * @throws OutOfBoundsException
  * @return ValueValidator[]
  */
 public function getValidators($dataTypeId)
 {
     if (!isset($this->validatorBuilders[$dataTypeId])) {
         // NOTE: fail hard, to avoid bypassing validators if the data type is mistyped or some such.
         throw new OutOfBoundsException('No validators known for data type ' . $dataTypeId);
     }
     $validators = call_user_func($this->validatorBuilders[$dataTypeId]);
     Assert::postcondition(is_array($validators), "Factory function for {$dataTypeId} did not return an array of ValueValidator objects.");
     foreach ($validators as $v) {
         Assert::postcondition($v instanceof ValueValidator, "Factory function for {$dataTypeId} did not return an array of ValueValidator objects.");
     }
     return $validators;
 }
 /**
  * @see SnakFormatter::format
  *
  * Formats the given Snak's value as a HTML link.
  * The URL of that link is determined using a SnakUrlExpander.
  * If the snak could not be expanded into a URL, the identifier is returned as simple text.
  *
  * @param Snak $snak
  *
  * @throws ParameterTypeException if $snak is not a PropertyValueSnak, or if $snak->getDataValue()
  * does not return a StringValue.
  * @return string HTML
  */
 public function formatSnak(Snak $snak)
 {
     Assert::parameterType('Wikibase\\DataModel\\Snak\\PropertyValueSnak', $snak, '$snak');
     /** @var PropertyValueSnak $snak */
     $id = $snak->getDataValue()->getValue();
     $url = $this->urlExpander->expandUrl($snak);
     $attr = array('class' => 'wb-external-id');
     if ($url === null) {
         return Html::element('span', $attr, $id);
     } else {
         $attr['href'] = $url;
         return Html::element('a', $attr, $id);
     }
 }
 /**
  * @param Title $title
  * @param array $params
  */
 public function __construct(Title $title, array $params)
 {
     parent::__construct('wikibase-addUsagesForPage', $title, $params);
     Assert::parameter(isset($params['pageId']) && is_int($params['pageId']) && $params['pageId'] > 0, '$params["pageId"]', 'must be a positive integer');
     Assert::parameter(isset($params['usages']) && is_array($params['usages']) && !empty($params['usages']), '$params["usages"]', 'must be a non-empty array');
     Assert::parameter(isset($params['touched']) && is_string($params['touched']) && $params['touched'] !== '', '$params["touched"]', 'must be a timestamp string');
     Assert::parameterElementType('array', $params['usages'], '$params["usages"]');
     $this->pageId = $params['pageId'];
     $this->usages = $params['usages'];
     $this->touched = $params['touched'];
     $wikibaseClient = WikibaseClient::getDefaultInstance();
     $usageUpdater = $wikibaseClient->getStore()->getUsageUpdater();
     $idParser = $wikibaseClient->getEntityIdParser();
     $this->overrideServices($usageUpdater, $idParser);
 }
Пример #20
0
 /**
  * Re-uses existing Cache objects from $other. Cache objects are only re-used if the
  * registered factory function for both is the same. Cache config is not copied,
  * and only instances of caches defined on this instance with the same config
  * are copied.
  *
  * @see SalvageableService::salvage()
  *
  * @param SalvageableService $other The object to salvage state from. $other must have the
  * exact same type as $this.
  */
 public function salvage(SalvageableService $other)
 {
     Assert::parameterType(self::class, $other, '$other');
     /** @var ConfigFactory $other */
     foreach ($other->factoryFunctions as $name => $otherFunc) {
         if (!isset($this->factoryFunctions[$name])) {
             continue;
         }
         // if the callback function is the same, salvage the Cache object
         // XXX: Closures are never equal!
         if (isset($other->configs[$name]) && $this->factoryFunctions[$name] == $otherFunc) {
             $this->configs[$name] = $other->configs[$name];
             unset($other->configs[$name]);
         }
     }
     // disable $other
     $other->factoryFunctions = [];
     $other->configs = [];
 }
Пример #21
0
 /**
  * Get a statistically unique 128-bit unsigned integer ID string.
  * The bits of the UID are prefixed with the time (down to the millisecond).
  *
  * These IDs are suitable as globally unique IDs, without any enforced uniqueness.
  * New rows almost always have higher UIDs, which makes B-TREE updates on INSERT fast.
  * They can also be stored as "DECIMAL(39) UNSIGNED" or BINARY(16) in MySQL.
  *
  * UID generation is serialized on each server (as the node ID is for the whole machine).
  *
  * @param int $base Specifies a base other than 10
  * @return string Number
  * @throws MWException
  */
 public static function newTimestampedUID128($base = 10)
 {
     Assert::parameterType('integer', $base, '$base');
     Assert::parameter($base <= 36, '$base', 'must be <= 36');
     Assert::parameter($base >= 2, '$base', 'must be >= 2');
     $gen = self::singleton();
     $time = $gen->getTimestampAndDelay('lockFile128', 16384, 1048576);
     return wfBaseConvert($gen->getTimestampedID128($time), 2, $base);
 }
Пример #22
0
 public function testPostcondition_fail()
 {
     $this->setExpectedException('Wikimedia\\Assert\\PostconditionException');
     Assert::postcondition(false, 'test');
 }
 /**
  * @param EntityChangeFactory $changeFactory
  * @param ChangeTransmitter[] $changeTransmitters
  */
 public function __construct(EntityChangeFactory $changeFactory, array $changeTransmitters)
 {
     Assert::parameterElementType('Wikibase\\Repo\\Notifications\\ChangeTransmitter', $changeTransmitters, '$changeTransmitters');
     $this->changeFactory = $changeFactory;
     $this->changeTransmitters = $changeTransmitters;
 }
Пример #24
0
 /**
  * Get a statistically unique 128-bit unsigned integer ID string.
  * The bits of the UID are prefixed with the time (down to the millisecond).
  *
  * These IDs are suitable as globally unique IDs, without any enforced uniqueness.
  * New rows almost always have higher UIDs, which makes B-TREE updates on INSERT fast.
  * They can also be stored as "DECIMAL(39) UNSIGNED" or BINARY(16) in MySQL.
  *
  * UID generation is serialized on each server (as the node ID is for the whole machine).
  *
  * @param int $base Specifies a base other than 10
  * @return string Number
  * @throws RuntimeException
  */
 public static function newTimestampedUID128($base = 10)
 {
     Assert::parameterType('integer', $base, '$base');
     Assert::parameter($base <= 36, '$base', 'must be <= 36');
     Assert::parameter($base >= 2, '$base', 'must be >= 2');
     $gen = self::singleton();
     $info = $gen->getTimeAndDelay('lockFile128', 16384, 1048576, 1048576);
     $info['offsetCounter'] = $info['offsetCounter'] % 1048576;
     return Wikimedia\base_convert($gen->getTimestampedID128($info), 2, $base);
 }
 /**
  * @param IContextSource $context
  * @param string $specialPageName
  *
  * @return ChangesListSpecialPageHooksHandler
  */
 private static function newFromGlobalState(IContextSource $context, $specialPageName)
 {
     Assert::parameterType('string', $specialPageName, '$specialPageName');
     $settings = WikibaseClient::getDefaultInstance()->getSettings();
     return new self($context->getRequest(), $context->getUser(), LBFactory::singleton()->getMainLB(), $specialPageName, $settings->getSetting('showExternalRecentChanges'));
 }
 /**
  * @param callable[] $factoryCallbacks Factory callback functions as returned by
  *        DataTypeDefinitions::getRdfBuilderFactoryCallbacks(). Callbacks will be invoked
  *        with the signature ($mode, RdfVocabulary, EntityMentionListener) and must
  *        return a ValueSnakRdfBuilder (or null).
  */
 public function __construct(array $factoryCallbacks)
 {
     Assert::parameterElementType('callable', $factoryCallbacks, '$factoryCallbacks');
     $this->factoryCallbacks = $factoryCallbacks;
 }
Пример #27
0
 public function merge(MergeableUpdate $update)
 {
     /** @var CdnCacheUpdate $update */
     Assert::parameterType(__CLASS__, $update, '$update');
     $this->urls = array_merge($this->urls, $update->urls);
 }
Пример #28
0
 /**
  * Resize the maximum number of cache entries, removing older entries as needed
  *
  * @param int $maxKeys
  * @return void
  * @throws UnexpectedValueException
  */
 public function resize($maxKeys)
 {
     Assert::parameterType('integer', $maxKeys, '$maxKeys');
     Assert::parameter($maxKeys > 0, '$maxKeys', 'must be above zero');
     $this->maxCacheKeys = $maxKeys;
     while (count($this->cache) > $this->maxCacheKeys) {
         reset($this->cache);
         $evictKey = key($this->cache);
         unset($this->cache[$evictKey]);
         unset($this->cacheTimes[$evictKey]);
     }
 }
Пример #29
0
 /**
  * @param int $maxKeys Maximum number of entries allowed (min 1).
  * @throws Exception When $maxCacheKeys is not an int or not above zero.
  */
 public function __construct($maxKeys)
 {
     Assert::parameterType('integer', $maxKeys, '$maxKeys');
     Assert::parameter($maxKeys > 0, '$maxKeys', 'must be above zero');
     $this->maxCacheKeys = $maxKeys;
 }
 /**
  * @param PropertyInfoStore $infoStore
  * @param string $propertyInfoKey Name of the desired field in the PropertyInfo array.
  *        Use one of the PropertyInfoStore::KEY_XXX constants.
  */
 public function __construct(PropertyInfoStore $infoStore, $propertyInfoKey)
 {
     Assert::parameterType('string', $propertyInfoKey, '$propertyInfoKey');
     $this->infoStore = $infoStore;
     $this->propertyInfoKey = $propertyInfoKey;
 }