/**
* Validate the provided value or list of values against the criterion.
*
* @since 0.4
*
* @param Parameter $parameter
* @param array $parameters
*
* @return CriterionValidationResult
*/
public function validate(Parameter $parameter, array $parameters)
{
$result = new CriterionValidationResult();
if (is_array($parameter->getValue())) {
foreach ($parameter->getValue() as $item) {
if (!$this->doValidation($item, $parameter, $parameters)) {
$result->addInvalidItem($item);
}
}
if ($result->hasInvalidItems()) {
$allInvalid = count($result->getInvalidItems()) == count($parameter->getValue());
// If the parameter is required and all items are invalid, it's fatal.
// Else it's high for required, and normal for non-required parameters.
if ($parameter->isRequired()) {
$severity = $allInvalid ? ValidationError::SEVERITY_FATAL : ValidationError::SEVERITY_HIGH;
} else {
$severity = $allInvalid ? ValidationError::SEVERITY_NORMAL : ValidationError::SEVERITY_LOW;
}
$result->addError(new ValidationError($this->getListErrorMessage($parameter, $result->getInvalidItems(), $allInvalid), $severity));
}
} else {
if (!$this->doValidation($parameter->getValue(), $parameter, $parameters)) {
$result->addError(new ValidationError($this->getItemErrorMessage($parameter), $parameter->isRequired() ? ValidationError::SEVERITY_FATAL : ValidationError::SEVERITY_NORMAL));
}
}
return $result;
}
/**
* Validate a parameter against the criterion.
*
* @param Parameter $parameter
* @param array $parameters
*
* @since 0.4
*/
public function manipulate(Parameter &$parameter, array &$parameters)
{
if (is_array($parameter->getValue())) {
$value =& $parameter->getValue();
foreach ($value as &$item) {
$this->doManipulation($item, $parameter, $parameters);
}
} else {
$this->doManipulation($parameter->getValue(), $parameter, $parameters);
}
}
/**
* @see ParameterManipulation::manipulate
*
* @since 1.0.1
*/
public function manipulate(Parameter &$parameter, array &$parameters)
{
if (!in_array($parameters['type']->getValue(), $parameter->getValue())) {
if ($parameters['type']->wasSetToDefault()) {
if (count($parameter->getValue()) > 0) {
$types = $parameter->getValue();
$parameters['type']->setValue($types[0]);
}
} else {
array_unshift($parameter->getValue(), $parameters['type']->getValue());
}
}
}
private function setParameter(Parameter $param)
{
$set_param_head = 'SET_PARAM ' . $param->getKey();
try {
if ($param->isRawValue()) {
$raw_value = self::BEGIN_RAW . "\n" . base64_encode($param->getValue()) . "\n" . self::END_RAW;
return $this->socket_client->request($set_param_head . ' ' . self::RAW_VALUE_ANNOUNCMENT . "\n" . $raw_value);
} else {
return $this->socket_client->request($set_param_head . ' ' . $param->getValue());
}
} catch (\Exception $e) {
throw $e;
}
}
function testSetup()
{
$param = new Parameter('name', 'value');
$this->assertEquals('NAME', $param->name);
$this->assertEquals('value', $param->value);
$this->assertEquals('value', $param->getValue());
}
function testSetupNameLess()
{
$card = new Component\VCard();
$param = new Parameter($card, null, 'URL');
$this->assertEquals('VALUE', $param->name);
$this->assertEquals('URL', $param->getValue());
$this->assertTrue($param->noName);
}
public function testIsImmutable()
{
$parameter = new Parameter('foo', [$std = new \stdClass()]);
// Mutate injected object
$std->foo = 'bar';
// Mutate retrieved object
$parameter->getValue()[0]->foo = 'baz';
$this->assertEquals(new Parameter('foo', [new \stdClass()]), $parameter);
}
/**
* @see ParameterManipulation::manipulate
*
* @since 0.7
*/
public function manipulate(Parameter &$parameter, array &$parameters)
{
global $egMapsOLLayerGroups, $egMapsOLAvailableLayers;
$layerDefs = array();
$layerNames = array();
foreach ($parameter->getValue() as $layerOrGroup) {
$lcLayerOrGroup = strtolower($layerOrGroup);
// Layer groups. Loop over all items and add them when not present yet.
if (array_key_exists($lcLayerOrGroup, $egMapsOLLayerGroups)) {
foreach ($egMapsOLLayerGroups[$lcLayerOrGroup] as $layerName) {
if (!in_array($layerName, $layerNames)) {
if (is_array($egMapsOLAvailableLayers[$layerName])) {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$layerName][0];
} else {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$layerName];
}
$layerNames[] = $layerName;
}
}
} elseif (array_key_exists($lcLayerOrGroup, $egMapsOLAvailableLayers)) {
if (!in_array($lcLayerOrGroup, $layerNames)) {
if (is_array($egMapsOLAvailableLayers[$lcLayerOrGroup])) {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$lcLayerOrGroup][0];
} else {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$lcLayerOrGroup];
}
$layerNames[] = $lcLayerOrGroup;
}
} else {
$title = Title::newFromText($layerOrGroup, Maps_NS_LAYER);
if ($title->getNamespace() == Maps_NS_LAYER && $title->exists()) {
$layerPage = new MapsLayerPage($title);
if ($layerPage->hasValidDefinition('openlayers')) {
$layer = $layerPage->getLayer();
if (!in_array($layerOrGroup, $layerNames)) {
$layerDefs[] = $layer->getJavaScriptDefinition();
$layerNames[] = $layerOrGroup;
}
} else {
wfWarn("Invalid layer ({$layerOrGroup}) encountered after validation.");
}
} else {
wfWarn("Invalid layer ({$layerOrGroup}) encountered after validation.");
}
}
}
$parameter->setValue($layerDefs);
MapsMappingServices::getServiceInstance('openlayers')->addLayerDependencies($this->getDependencies($layerNames));
}
public function testParameter()
{
$parameter = new Parameter('foo');
$this->assertSame('foo', $parameter->getValue());
$this->assertSame('foo', $parameter());
}
/**
* @see ParameterManipulation::manipulate
*
* @since 0.4
*/
public function manipulate(Parameter &$parameter, array &$parameters)
{
$parameter->setValue($this->wrapper . implode($this->wrapper . $this->delimiter . $this->wrapper, $parameter->getValue()) . $this->wrapper);
}
/**
* @see ParameterCriterion::validate
*/
public function validate(Parameter $parameter, array $parameters)
{
return count($parameter->getValue()) == count(array_unique($this->careAboutCapitalization ? $parameter->getValue() : array_map('strtolower', $parameter->getValue())));
}
/**
* @see ParameterManipulation::manipulate
*
* @since 0.7
*/
public function manipulate(Parameter &$parameter, array &$parameters)
{
global $egMapsOLLayerGroups, $egMapsOLAvailableLayers;
$layerDefs = array();
$usedLayers = array();
foreach ($parameter->getValue() as $layerOrGroup) {
$lcLayerOrGroup = strtolower($layerOrGroup);
// Layer groups. Loop over all items and add them if not present yet.
if (array_key_exists($lcLayerOrGroup, $egMapsOLLayerGroups)) {
foreach ($egMapsOLLayerGroups[$lcLayerOrGroup] as $layerName) {
if (!in_array($layerName, $usedLayers)) {
if (is_array($egMapsOLAvailableLayers[$layerName])) {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$layerName][0];
} else {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$layerName];
}
$usedLayers[] = $layerName;
}
}
} elseif (array_key_exists($lcLayerOrGroup, $egMapsOLAvailableLayers)) {
if (!in_array($lcLayerOrGroup, $usedLayers)) {
if (is_array($egMapsOLAvailableLayers[$lcLayerOrGroup])) {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$lcLayerOrGroup][0];
} else {
$layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$lcLayerOrGroup];
}
$usedLayers[] = $lcLayerOrGroup;
}
} else {
$layerParts = explode($this->groupNameSep, $layerOrGroup, 2);
$layerGroup = $layerParts[0];
$layerName = count($layerParts) > 1 ? $layerParts[1] : null;
$title = Title::newFromText($layerGroup, Maps_NS_LAYER);
if ($title !== null && $title->getNamespace() == Maps_NS_LAYER) {
/**
* TODO/FIXME: This shouldn't be here and using $wgParser, instead it should
* be somewhere around MapsBaseMap::renderMap. But since we do a lot more than
* 'parameter manipulation' in here, we already diminish the information needed
* for this which will never arrive there. Perhaps the whole
* MapsLayer::getJavaScriptDefinition() shouldn't be done here.
*/
global $wgParser;
// add dependency to the layer page so if the layer definition gets updated,
// the page where it is used will be updated as well:
$rev = Revision::newFromTitle($title);
$wgParser->getOutput()->addTemplate($title, $title->getArticleID(), $rev->getId());
// if the whole layer group is not yet loaded into the map and the group exists:
if (!in_array($layerGroup, $usedLayers) && $title->exists()) {
$layerPage = new MapsLayerPage($title);
if ($layerName !== null) {
// load specific layer with name:
$layer = MapsLayers::loadLayer($title, $layerName);
$layers = new MapsLayerGroup($layer);
$usedLayer = $layerOrGroup;
} else {
// load all layers from group:
$layers = MapsLayers::loadLayerGroup($title);
$usedLayer = $layerGroup;
}
foreach ($layers->getLayers() as $layer) {
if (($layer->getName() === null || !in_array($layerGroup . $this->groupNameSep . $layer->getName(), $usedLayers)) && $layer->isOk()) {
$layerDefs[] = $layer->getJavaScriptDefinition();
}
}
$usedLayers[] = $usedLayer;
// have to add this after loop of course!
}
} else {
wfWarn("Invalid layer ({$layerOrGroup}) encountered after validation.");
}
}
}
$parameter->setValue($layerDefs);
MapsMappingServices::getServiceInstance('openlayers')->addLayerDependencies($this->getDependencies($usedLayers));
}
/**
* @see ParameterCriterion::validate
*/
public function validate(Parameter $parameter, array $parameters)
{
$count = count($parameter->getValue());
return ($this->upperBound === false || $count <= $this->upperBound) && ($this->lowerBound === false || $count >= $this->lowerBound);
}
/**
* @covers phpDocumentor\Transformer\Template\Parameter::getValue
* @covers phpDocumentor\Transformer\Template\Parameter::setValue
*/
public function testSetAndGetValue()
{
$this->assertSame(null, $this->fixture->getValue());
$this->fixture->setValue('value');
$this->assertSame('value', $this->fixture->getValue());
}
/**
* @see ItemParameterCriterion::getFullListErrorMessage
*/
protected function getFullListErrorMessage( Parameter $parameter ) {
global $wgLang;
$originalCount = count( $this->allowedValues );
if ( $originalCount > 15 ) {
$allowedValues = array_slice( $this->allowedValues, 0, 13 );
$omitCount = $originalCount - count( $allowedValues );
return wfMsgExt(
'validator-list-error-accepts-only-omitted',
'parsemag',
$parameter->getOriginalName(),
$wgLang->listToText( $allowedValues ),
count( $allowedValues ),
$wgLang->formatNum( $omitCount )
);
}
else {
return wfMsgExt(
'validator-list-error-accepts-only',
'parsemag',
$parameter->getOriginalName(),
$wgLang->listToText( $this->allowedValues ),
count( $this->allowedValues ),
$parameter->getValue()
);
}
}
/**
* Configures wrapped formatter class with any attributes on this element.
*/
public function prepare()
{
if (!$this->formatter) {
throw new BuildException("No formatter specified (use type or classname attribute)", $this->getLocation());
}
$out = $this->getOutputWriter();
print "Setting output writer to: " . get_class($out) . "\n";
$this->formatter->setOutput($out);
if ($this->formatter instanceof PlainPDOResultFormatter) {
// set any options that apply to the plain formatter
$this->formatter->setShowheaders($this->showheaders);
$this->formatter->setRowdelim($this->rowdelimiter);
$this->formatter->setColdelim($this->coldelimiter);
} elseif ($this->formatter instanceof XMLPDOResultFormatter) {
// set any options that apply to the xml formatter
$this->formatter->setEncoding($this->encoding);
$this->formatter->setFormatOutput($this->formatoutput);
}
foreach ($this->formatterParams as $param) {
$param = new Parameter();
$method = 'set' . $param->getName();
if (!method_exists($this->formatter, $param->getName())) {
throw new BuildException("Formatter " . get_class($this->formatter) . " does not have a {$method} method.", $this->getLocation());
}
call_user_func(array($this->formatter, $method), $param->getValue());
}
}
/**
* @see ParameterCriterion::validate
*/
public function validate(Parameter $parameter, array $parameters)
{
$count = count($parameter->getValue());
return $count <= $this->upperBound && $count >= $this->lowerBound;
}
