private function setParamProcessor($paramProcessor)
{
if ($paramProcessor === null) {
$paramProcessor = Processor::newDefault();
}
$this->paramProcessor = $paramProcessor;
}
/**
* Takes an array of unprocessed parameters,
* and sets them on a new Validator object,
* which is returned and ready to process the parameters.
*
* @since 1.8
*
* @param array $params
* @param array $printRequests
* @param boolean $unknownInvalid
*
* @return Processor
*/
public static function getValidatorForParams(array $params, array $printRequests = array(), $unknownInvalid = true)
{
$paramDefinitions = self::getParameters();
$paramDefinitions['format']->setPrintRequests($printRequests);
$processorOptions = new Options();
$processorOptions->setUnknownInvalid($unknownInvalid);
$validator = Processor::newFromOptions($processorOptions);
$validator->setParameters($params, $paramDefinitions, false);
return $validator;
}
private function getProcessedParams(HookDefinition $definition, array $rawParams)
{
$processor = Processor::newDefault();
$processor->setParameters($rawParams, $definition->getParameters());
$params = array();
foreach ($processor->processParameters()->getParameters() as $param) {
$params[$param->getName()] = $param->getValue();
}
return $params;
}
/**
* Returns the ProcessingError objects for the errors and warnings that should be displayed.
*
* @since 0.4
*
* @return array of array of ProcessingError
*/
protected function getErrorsToDisplay()
{
$errors = array();
$warnings = array();
foreach ($this->validator->getErrors() as $error) {
// Check if the severity of the error is high enough to display it.
if ($error->shouldShow()) {
$errors[] = $error;
} elseif ($error->shouldWarn()) {
$warnings[] = $error;
}
}
return array('errors' => $errors, 'warnings' => $warnings);
}
/**
* @dataProvider processingProvider
* @since 3.0
*/
public function testParamProcessing(array $parameters, array $expectedValues)
{
$definitions = $this->getInstance()->getParamDefinitions();
$processor = Processor::newDefault();
$processor->setParameters($parameters, $definitions);
$result = $processor->processParameters();
if ($result->hasFatal()) {
$this->fail('Fatal error occurred during the param processing: ' . $processor->hasFatalError()->getMessage());
}
$actual = $result->getParameters();
$expectedValues = array_merge($this->getDefaultValues(), $expectedValues);
foreach ($expectedValues as $name => $expected) {
$this->assertArrayHasKey($name, $actual);
$this->assertEquals($expected, $actual[$name]->getValue(), 'Expected ' . var_export($expected, true) . ' should match actual ' . var_export($actual[$name]->getValue(), true));
}
}
/**
* @since 1.0
*
* @param string $coordinates
* @param string $inputName
* @param boolean $isMandatory
* @param boolean $isDisabled
* @param array $params
*
* @return string
*/
public function getInputOutput($coordinates, $inputName, $isMandatory, $isDisabled, array $params)
{
$parameters = array();
foreach ($params as $key => $value) {
if (!is_array($value) && !is_object($value) && !is_null($value)) {
$parameters[$key] = $value;
}
}
if (!is_null($coordinates)) {
$parameters['locations'] = $coordinates;
}
$validator = Processor::newDefault();
$validator->setParameters($parameters, $this->getParameterInfo());
$processingResult = $validator->processParameters();
if ($processingResult->hasFatal()) {
return $this->getFatalOutput($validator->getErrors());
} else {
return $this->getMapOutput($validator->getParameterValues(), $inputName);
}
}
/**
* @dataProvider parameterProvider
*/
public function testValidateParameters(array $params, array $definitions, Options $options, array $expected = array())
{
$validator = Processor::newFromOptions($options);
$validator->setParameters($params, $definitions);
$processingResult = $validator->processParameters();
$actualValues = array();
foreach ($processingResult->getParameters() as $param) {
$actualValues[$param->getName()] = $param->getValue();
}
$this->assertEquals($expected, $actualValues);
}
/**
* Validates the layer.
*
* @since 0.7.1
*/
protected function validate()
{
if ($this->hasValidated) {
return;
}
$this->hasValidated = true;
$validator = Processor::newDefault();
$validator->setParameters($this->properties, $this->getParameterDefinitions());
$validator->validateParameters();
if ($validator->hasErrors() !== false) {
$this->errors = $validator->getErrors();
}
$params = $validator->getParameterValues();
$this->properties = $params;
}
