private function shouldSkip($object, Exclusion $exclusion = null, SerializationContext $context)
{
if (null !== $exclusion && null !== $exclusion->getExcludeIf() && $this->expressionEvaluator->evaluate($exclusion->getExcludeIf(), $object)) {
return true;
}
if (!$context->getExclusionStrategy()) {
return false;
}
$propertyMetadata = new RelationPropertyMetadata($exclusion);
return $context->getExclusionStrategy()->shouldSkipProperty($propertyMetadata, $context);
}
public function testCompile()
{
$object = new \StdClass();
$linkHelperMock = $this->mockHelper('/foo', $object, 'self', false);
$expressionLanguage = new ExpressionLanguage();
$expressionEvaluator = new ExpressionEvaluator($expressionLanguage);
$expressionEvaluator->registerFunction(new LinkExpressionFunction($linkHelperMock));
$compiledExpression = $expressionLanguage->compile('link(object, "self", false)', array('object', 'link_helper'));
// setup variables for expression eval
$object = $object;
$link_helper = $linkHelperMock;
$this->assertEquals('/foo', eval(sprintf('return %s;', $compiledExpression)));
}
/**
* @param object $object
* @param SerializationContext $context
* @return Embed[]
*/
public function create($object, SerializationContext $context)
{
$embeds = array();
foreach ($this->relationsRepository->getRelations($object) as $relation) {
if ($this->exclusionManager->shouldSkipEmbed($object, $relation, $context)) {
continue;
}
$rel = $this->expressionEvaluator->evaluate($relation->getName(), $object);
$data = $this->expressionEvaluator->evaluate($relation->getEmbed()->getContent(), $object);
$xmlElementName = $this->expressionEvaluator->evaluate($relation->getEmbed()->getXmlElementName(), $object);
$embeds[] = new Embed($rel, $data, $xmlElementName);
}
return $embeds;
}
public function evaluateArray(array $array, $data)
{
if (!empty($this->functionsIds)) {
$this->registerFunctions();
}
return parent::evaluateArray($array, $data);
}
/**
* @param object $object
* @param Relation $relation
*
* @return Link
*/
public function createLink($object, Relation $relation)
{
$rel = $this->expressionEvaluator->evaluate($relation->getName(), $object);
$href = $relation->getHref();
if ($href instanceof Route) {
if (!$this->urlGeneratorRegistry->hasGenerators()) {
throw new \RuntimeException('You cannot use a route without an url generator.');
}
$name = $this->expressionEvaluator->evaluate($href->getName(), $object);
$parameters = is_array($href->getParameters()) ? $this->expressionEvaluator->evaluateArray($href->getParameters(), $object) : $this->expressionEvaluator->evaluate($href->getParameters(), $object);
$isAbsolute = $this->expressionEvaluator->evaluate($href->isAbsolute(), $object);
if (!is_array($parameters)) {
throw new \RuntimeException(sprintf('The route parameters should be an array, %s given. Maybe you forgot to wrap the expression in expr(...).', gettype($parameters)));
}
$href = $this->urlGeneratorRegistry->get($href->getGenerator())->generate($name, $parameters, $isAbsolute);
} else {
$href = $this->expressionEvaluator->evaluate($href, $object);
}
$attributes = $this->expressionEvaluator->evaluateArray($relation->getAttributes(), $object);
return new Link($rel, $href, $attributes);
}
public function testRegisterFunction()
{
$expressionEvaluator = new ExpressionEvaluator(new ExpressionLanguage());
$expressionEvaluator->registerFunction(new HelloExpressionFunction());
$this->string($expressionEvaluator->evaluate('expr(hello("toto"))', null))->isEqualTo('Hello, toto!');
}
/**
* Build a configured Hateoas instance.
*
* @return Hateoas
*/
public function build()
{
$metadataFactory = $this->buildMetadataFactory();
$relationProvider = new RelationProvider($metadataFactory, $this->chainResolver);
$relationsRepository = new RelationsRepository($metadataFactory, $relationProvider);
$expressionEvaluator = new ExpressionEvaluator($this->getExpressionLanguage(), $this->contextVariables);
$linkFactory = new LinkFactory($expressionEvaluator, $this->urlGeneratorRegistry);
$exclusionManager = new ExclusionManager($expressionEvaluator);
$linksFactory = new LinksFactory($relationsRepository, $linkFactory, $exclusionManager);
$embeddedsFactory = new EmbeddedsFactory($relationsRepository, $expressionEvaluator, $exclusionManager);
$linkHelper = new LinkHelper($linkFactory, $relationsRepository);
// Register Hateoas core functions
$expressionEvaluator->registerFunction(new LinkExpressionFunction($linkHelper));
// Register user functions
foreach ($this->expressionFunctions as $expressionFunction) {
$expressionEvaluator->registerFunction($expressionFunction);
}
if (null === $this->xmlSerializer) {
$this->setDefaultXmlSerializer();
}
if (null === $this->jsonSerializer) {
$this->setDefaultJsonSerializer();
}
$inlineDeferrers = array();
$eventSubscribers = array(new XmlEventSubscriber($this->xmlSerializer, $linksFactory, $embeddedsFactory), new JsonEventSubscriber($this->jsonSerializer, $linksFactory, $embeddedsFactory, $inlineDeferrers[] = new InlineDeferrer(), $inlineDeferrers[] = new InlineDeferrer()));
$this->serializerBuilder->addDefaultListeners()->configureListeners(function (EventDispatcherInterface $dispatcher) use($eventSubscribers) {
foreach ($eventSubscribers as $eventSubscriber) {
$dispatcher->addSubscriber($eventSubscriber);
}
});
$jmsSerializer = $this->serializerBuilder->build();
foreach (array_merge($inlineDeferrers, array($this->jsonSerializer, $this->xmlSerializer)) as $serializer) {
if ($serializer instanceof JMSSerializerMetadataAwareInterface) {
$serializer->setMetadataFactory($jmsSerializer->getMetadataFactory());
}
}
return new Hateoas($jmsSerializer, $linkHelper);
}
/**
* @dataProvider getTestEvaluateNonStringData
*/
public function testEvaluateNonString($value)
{
$expressionEvaluator = new ExpressionEvaluator(new ExpressionLanguage());
$this->variable($expressionEvaluator->evaluate($value, array()))->isIdenticalTo($value);
}
/**
* @dataProvider getTestEvaluateNonStringData
*/
public function testEvaluateNonString($value)
{
$expressionEvaluator = new ExpressionEvaluator(new ExpressionLanguage());
$this->assertSame($value, $expressionEvaluator->evaluate($value, array()));
}
public function evaluateArray(array $array, $data)
{
$this->registerFunctions();
return parent::evaluateArray($array, $data);
}
