/**
* {@inheritdoc}
* @throws Exception\InvalidArgumentException
*/
public function setTarget($target)
{
if (!$target instanceof ModelInterface) {
throw new Exception\InvalidArgumentException(sprintf('"%s" works only with ModelInterface targets', __CLASS__));
}
return parent::setTarget($target);
}
public function setTarget($target)
{
if ($target instanceof FormInterface || $target instanceof Container) {
$this->setForm($target);
}
return parent::setTarget($target);
}
public function setTarget($test)
{
if (!$test instanceof TestInterface) {
$what = is_object($test) ? 'object of class ' . get_class($test) : gettype($test);
throw new InvalidArgumentException('Cannot use ' . $what . ' as a target for the test');
}
return parent::setTarget($test);
}
/**
* Create Annotation
*
* @param array $annotationData
* @return false|\stdClass
*/
public function createAnnotation(array $annotationData)
{
$event = new Event();
$event->setName(self::EVENT_CREATE_ANNOTATION);
$event->setTarget($this);
$event->setParams(array('class' => $annotationData[0], 'content' => $annotationData[1], 'raw' => $annotationData[2]));
$results = $this->getEventManager()->trigger($event, function ($r) {
return is_object($r);
});
$annotation = $results->last();
return is_object($annotation) ? $annotation : false;
}
/**
* Triggers the specified event on the defined context and return a concateneted string with the results
* @param string $eventName
* @param mixed $target
* @param array $argv
* @return string
*/
public function triggerEvent($eventName, $target, $argv)
{
//init the event with the target, params and name
$event = new Event();
$event->setTarget($target);
$event->setParams($argv);
$event->setName($eventName);
$content = "";
//trigger the event listeners
$responses = $this->events()->trigger($eventName, $event);
//merge all results and return the response
foreach ($responses as $response) {
$content .= $response;
}
return $content;
}
/**
* Triggers the specified event on the defined context and return a concateneted string with the results
*
* @param string $eventName
* @param mixed $target
* @param array $argv
* @return string
*/
public function __invoke($eventName, $target, $argv)
{
$alias = 'zfc-twig';
if (strpos($eventName, ':') !== false) {
$aux = explode(':', $eventName);
$alias = $aux[0];
$eventName = $aux[1];
}
//init the event with the target, params and name
$event = new Event();
$event->setTarget($target);
$event->setParams($argv);
$event->setName($eventName);
$content = "";
//trigger the event listeners
$responses = $this->events($alias)->trigger($eventName, $event);
//merge all results and return the response
foreach ($responses as $response) {
$content .= $response;
}
return $content;
}
public function testTriggerCanTakeAnOptionalCallbackArgumentToEmulateTriggerUntil()
{
$this->events->attach(__FUNCTION__, function ($e) {
return $e;
});
// Four scenarios:
// First: normal signature:
$responses = $this->events->trigger(__FUNCTION__, $this, array(), function ($r) {
return $r instanceof EventInterface;
});
$this->assertTrue($responses->stopped());
// Second: Event as $argv parameter:
$event = new Event();
$responses = $this->events->trigger(__FUNCTION__, $this, $event, function ($r) {
return $r instanceof EventInterface;
});
$this->assertTrue($responses->stopped());
// Third: Event as $target parameter:
$event = new Event();
$event->setTarget($this);
$responses = $this->events->trigger(__FUNCTION__, $event, function ($r) {
return $r instanceof EventInterface;
});
$this->assertTrue($responses->stopped());
// Fourth: Event as $event parameter:
$event = new Event();
$event->setTarget($this);
$event->setName(__FUNCTION__);
$responses = $this->events->trigger($event, function ($r) {
return $r instanceof EventInterface;
});
$this->assertTrue($responses->stopped());
}
/**
* Is this session valid?
*
* Notifies the Validator Chain until either all validators have returned
* true or one has failed.
*
* @return bool
*/
public function isValid()
{
$validator = $this->getValidatorChain();
$event = new Event();
$event->setName('session.validate');
$event->setTarget($this);
$event->setParams($this);
$falseResult = function ($test) {
return false === $test;
};
$responses = $validator->triggerEventUntil($falseResult, $event);
if ($responses->stopped()) {
// If execution was halted, validation failed
return false;
}
// Otherwise, we're good to go
return true;
}
public function testOnBootstrap()
{
$applicationEventManager = new EventManager();
$application = $this->getMock(ApplicationInterface::class);
$application->expects($this->any())->method('getEventManager')->will($this->returnValue($applicationEventManager));
$event = new Event();
$event->setTarget($application);
$module = new Module();
$module->onBootstrap($event);
$this->assertListenerAtPriority([$module, 'onDispatch'], -9999999, MvcEvent::EVENT_DISPATCH, $applicationEventManager);
$this->assertListenerAtPriority([$module, 'onDispatch'], -9999999, MvcEvent::EVENT_DISPATCH_ERROR, $applicationEventManager);
}
/**
* Determine if an element is marked to exclude from the definitions
*
* @param AnnotationCollection $annotations
* @return true|false
*/
protected function checkForExclude($annotations)
{
$event = new Event();
$event->setName(__FUNCTION__);
$event->setTarget($this);
$event->setParams(['annotations' => $annotations]);
$results = $this->getEventManager()->triggerEventUntil(function ($r) {
return true === $r;
}, $event);
return (bool) $results->last();
}
public function testOnBootstrap()
{
$applicationEventManager = new EventManager();
$application = $this->getMock('Zend\\Mvc\\ApplicationInterface');
$application->expects($this->any())->method('getEventManager')->will($this->returnValue($applicationEventManager));
$event = new Event();
$event->setTarget($application);
$module = new Module();
$module->onBootstrap($event);
$dispatchListeners = $applicationEventManager->getListeners(MvcEvent::EVENT_DISPATCH);
foreach ($dispatchListeners as $listener) {
$metaData = $listener->getMetadata();
$callback = $listener->getCallback();
$this->assertEquals('onDispatch', $callback[1]);
$this->assertEquals(-9999999, $metaData['priority']);
$this->assertTrue($callback[0] instanceof Module);
}
$dispatchListeners = $applicationEventManager->getListeners(MvcEvent::EVENT_DISPATCH_ERROR);
foreach ($dispatchListeners as $listener) {
$metaData = $listener->getMetadata();
$callback = $listener->getCallback();
$this->assertEquals('onDispatch', $callback[1]);
$this->assertEquals(-9999999, $metaData['priority']);
$this->assertTrue($callback[0] instanceof Module);
}
}
/**
* Parse a single page into a navigation configuration
*
* @param Page $page
* @return array
* @throws Exception\RuntimeException
*/
public function parsePage(PageInterface $page)
{
$meta = $page->getMetaData();
$navPage = Page::factory(array('type' => 'mvc', 'route' => (string) $page->getId(), 'label' => $meta->getNavigationTitle(), 'visible' => $page->isVisible()));
$event = new Event();
$event->setName(__FUNCTION__ . '.' . $page->getModule());
$event->setTarget($this);
$event->setParams(array('page' => $page, 'navigation' => $navPage));
$this->events->trigger($event);
return $navPage;
}
