コード例 #1
0
 /**
  * Invoke the ViewHelper described by the ViewHelperNode, the properties
  * of which will already have been filled by the ViewHelperResolver.
  *
  * @param string|ViewHelperInterface $viewHelperClassName
  * @param array $arguments
  * @param RenderingContextInterface $renderingContext
  * @param \Closure $renderChildrenClosure
  * @return mixed
  */
 public function invoke($viewHelperClassNameOrInstance, array $arguments, RenderingContextInterface $renderingContext, \Closure $renderChildrenClosure = NULL)
 {
     if ($viewHelperClassNameOrInstance instanceof ViewHelperInterface) {
         $viewHelper = $viewHelperClassNameOrInstance;
     } else {
         $viewHelper = $this->viewHelperResolver->createViewHelperInstanceFromClassName($viewHelperClassNameOrInstance);
     }
     $expectedViewHelperArguments = $renderingContext->getViewHelperResolver()->getArgumentDefinitionsForViewHelper($viewHelper);
     // Rendering process
     $evaluatedArguments = array();
     foreach ($expectedViewHelperArguments as $argumentName => $argumentDefinition) {
         if (isset($arguments[$argumentName])) {
             /** @var NodeInterface|mixed $argumentValue */
             $argumentValue = $arguments[$argumentName];
             $evaluatedArguments[$argumentName] = $argumentValue instanceof NodeInterface ? $argumentValue->evaluate($renderingContext) : $argumentValue;
         } else {
             $evaluatedArguments[$argumentName] = $argumentDefinition->getDefaultValue();
         }
     }
     $this->abortIfUnregisteredArgumentsExist($expectedViewHelperArguments, $evaluatedArguments);
     $this->abortIfRequiredArgumentsAreMissing($expectedViewHelperArguments, $evaluatedArguments);
     $viewHelper->setArguments($evaluatedArguments);
     $viewHelper->setRenderingContext($renderingContext);
     if ($renderChildrenClosure) {
         $viewHelper->setRenderChildrenClosure($renderChildrenClosure);
     }
     return $viewHelper->initializeArgumentsAndRender();
 }
コード例 #2
0
 /**
  * @param mixed $candidate
  * @param RenderingContextInterface $renderingContext
  * @return mixed
  */
 protected static function getTemplateVariableOrValueItself($candidate, RenderingContextInterface $renderingContext)
 {
     $variables = $renderingContext->getVariableProvider()->getAll();
     $extractor = new VariableExtractor();
     $suspect = $extractor->getByPath($variables, $candidate);
     if (NULL === $suspect) {
         return $candidate;
     }
     return $suspect;
 }
コード例 #3
0
 /**
  * Loads the template source and render the template.
  * If "layoutName" is set in a PostParseFacet callback, it will render the file with the given layout.
  *
  * @param string $actionName If set, this action's template will be rendered instead of the one defined in the context.
  * @return string Rendered Template
  * @api
  */
 public function render($actionName = NULL)
 {
     $this->templateParser->setConfiguration($this->buildParserConfiguration());
     $this->templateParser->setVariableProvider($this->baseRenderingContext->getVariableProvider());
     $this->templateParser->setViewHelperResolver($this->viewHelperResolver);
     $this->baseRenderingContext->setViewHelperResolver($this->viewHelperResolver);
     $controllerName = $this->baseRenderingContext->getControllerName();
     if (!$actionName) {
         $actionName = $this->baseRenderingContext->getControllerAction();
     }
     $actionName = ucfirst($actionName);
     if (empty($templateIdentifier)) {
         $templateIdentifier = $this->templatePaths->getTemplateIdentifier($controllerName, $actionName);
     }
     $parsedTemplate = $this->getOrParseAndStoreTemplate($templateIdentifier, function ($parent, TemplatePaths $paths) use($controllerName, $actionName) {
         return $paths->getTemplateSource($controllerName, $actionName);
     });
     $parsedTemplate->addCompiledNamespaces($this->baseRenderingContext);
     if (!$parsedTemplate->hasLayout()) {
         $this->startRendering(self::RENDERING_TEMPLATE, $parsedTemplate, $this->baseRenderingContext);
         $output = $parsedTemplate->render($this->baseRenderingContext);
         $this->stopRendering();
     } else {
         $layoutName = $parsedTemplate->getLayoutName($this->baseRenderingContext);
         $layoutIdentifier = $this->templatePaths->getLayoutIdentifier($layoutName);
         $parsedLayout = $this->getOrParseAndStoreTemplate($layoutIdentifier, function ($parent, TemplatePaths $paths) use($layoutName) {
             return $paths->getLayoutSource($layoutName);
         });
         $this->startRendering(self::RENDERING_LAYOUT, $parsedTemplate, $this->baseRenderingContext);
         $output = $parsedLayout->render($this->baseRenderingContext);
         $this->stopRendering();
     }
     return $output;
 }
コード例 #4
0
 /**
  * Evaluate this node and return the correct object.
  *
  * Handles each part (denoted by .) in $this->objectPath in the following order:
  * - call appropriate getter
  * - call public property, if exists
  * - fail
  *
  * The first part of the object path has to be a variable in the
  * VariableProvider.
  *
  * @param RenderingContextInterface $renderingContext
  * @return object The evaluated object, can be any object type.
  */
 public function evaluate(RenderingContextInterface $renderingContext)
 {
     $variableProvider = $renderingContext->getVariableProvider();
     switch (strtolower($this->objectPath)) {
         case '_all':
             return $variableProvider->getAll();
         case 'true':
         case 'on':
         case 'yes':
             return TRUE;
         case 'false':
         case 'off':
         case 'no':
             return FALSE;
         default:
             return VariableExtractor::extract($variableProvider, $this->objectPath, $this->accessors);
     }
 }
コード例 #5
0
 /**
  * @param RenderingContextInterface $renderingContext
  * @param string $expression
  * @param array $matches
  * @return integer|float
  */
 public static function evaluateExpression(RenderingContextInterface $renderingContext, $expression, array $matches)
 {
     // Split the expression on all recognized operators
     $matches = array();
     preg_match_all('/([+\\-*\\^\\/\\%]|[a-z0-9\\.]+)/s', $expression, $matches);
     $matches[0] = array_map('trim', $matches[0]);
     // Like the BooleanNode, we dumb down the processing logic to not apply
     // any special precedence on the priority of operators. We simply process
     // them in order.
     $variables = $renderingContext->getVariableProvider()->getAll();
     $result = array_shift($matches[0]);
     $result = parent::getTemplateVariableOrValueItself($result, $renderingContext);
     $operator = NULL;
     $operators = array('*', '^', '-', '+', '/', '%');
     foreach ($matches[0] as $part) {
         if (in_array($part, $operators)) {
             $operator = $part;
         } else {
             $part = parent::getTemplateVariableOrValueItself($part, $renderingContext);
             $result = self::evaluateOperation($result, $operator, $part);
         }
     }
     return $result;
 }
コード例 #6
0
 /**
  * @test
  */
 public function viewHelperVariableContainerCanBeReadCorrectly()
 {
     $viewHelperVariableContainer = $this->getMock('NamelessCoder\\Fluid\\Core\\ViewHelper\\ViewHelperVariableContainer');
     $this->renderingContext->injectViewHelperVariableContainer($viewHelperVariableContainer);
     $this->assertSame($viewHelperVariableContainer, $this->renderingContext->getViewHelperVariableContainer());
 }
コード例 #7
0
 /**
  * @param array $arguments
  * @param \Closure $renderChildrenClosure
  * @param RenderingContextInterface $renderingContext
  * @return string
  * @throws ViewHelper\Exception
  */
 public static function renderStatic(array $arguments, \Closure $renderChildrenClosure, RenderingContextInterface $renderingContext)
 {
     $templateVariableContainer = $renderingContext->getVariableProvider();
     if ($arguments['each'] === NULL) {
         return '';
     }
     if (is_object($arguments['each']) && !$arguments['each'] instanceof \Traversable) {
         throw new ViewHelper\Exception('ForViewHelper only supports arrays and objects implementing \\Traversable interface', 1248728393);
     }
     if ($arguments['reverse'] === TRUE) {
         // array_reverse only supports arrays
         if (is_object($arguments['each'])) {
             /** @var $each \Traversable */
             $each = $arguments['each'];
             $arguments['each'] = iterator_to_array($each);
         }
         $arguments['each'] = array_reverse($arguments['each']);
     }
     $iterationData = array('index' => 0, 'cycle' => 1, 'total' => count($arguments['each']));
     $output = '';
     foreach ($arguments['each'] as $keyValue => $singleElement) {
         $templateVariableContainer->add($arguments['as'], $singleElement);
         if ($arguments['key'] !== '') {
             $templateVariableContainer->add($arguments['key'], $keyValue);
         }
         if ($arguments['iteration'] !== NULL) {
             $iterationData['isFirst'] = $iterationData['cycle'] === 1;
             $iterationData['isLast'] = $iterationData['cycle'] === $iterationData['total'];
             $iterationData['isEven'] = $iterationData['cycle'] % 2 === 0;
             $iterationData['isOdd'] = !$iterationData['isEven'];
             $templateVariableContainer->add($arguments['iteration'], $iterationData);
             $iterationData['index']++;
             $iterationData['cycle']++;
         }
         $output .= $renderChildrenClosure();
         $templateVariableContainer->remove($arguments['as']);
         if ($arguments['key'] !== '') {
             $templateVariableContainer->remove($arguments['key']);
         }
         if ($arguments['iteration'] !== NULL) {
             $templateVariableContainer->remove($arguments['iteration']);
         }
     }
     return $output;
 }
コード例 #8
0
 /**
  * @param RenderingContextInterface $renderingContext
  * @return void
  */
 public function setRenderingContext(RenderingContextInterface $renderingContext)
 {
     $this->renderingContext = $renderingContext;
     $this->templateVariableContainer = $renderingContext->getVariableProvider();
     $this->viewHelperVariableContainer = $renderingContext->getViewHelperVariableContainer();
 }
コード例 #9
0
 /**
  * Public such that it is callable from within closures
  *
  * @param integer $uniqueCounter
  * @param RenderingContextInterface $renderingContext
  * @param string $viewHelperName
  * @return AbstractViewHelper
  */
 public function getViewHelper($uniqueCounter, RenderingContextInterface $renderingContext, $viewHelperName)
 {
     return $renderingContext->getViewHelperResolver()->createViewHelperInstanceFromClassName($viewHelperName);
 }
コード例 #10
0
 /**
  * Returns the name of the layout that is defined within the current template via <f:layout name="..." />
  * If no layout is defined, this returns NULL
  * This requires the current rendering context in order to be able to evaluate the layout name
  *
  * @param RenderingContextInterface $renderingContext
  * @return string
  * @throws View\Exception
  */
 public function getLayoutName(RenderingContextInterface $renderingContext)
 {
     return $renderingContext->getVariableProvider()->get('layoutName');
 }