| <?php |
| /** |
| * File containing the ezcTemplateCompiledCode class |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| * @package Template |
| * @version //autogen// |
| * @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0 |
| * @access private |
| */ |
| /** |
| * Represents a compiled PHP file on the filesystem which can be generated or |
| * executed. |
| * |
| * If you want to know if a compiled file exists and can be used create a new |
| * instance of this and check the isValid() flag. |
| * |
| * If you are unsure where the compiled file resides you can use the static |
| * methods findCurrent() and findAll() to get those identifiers. |
| * |
| * @property-read string $identifier |
| * The unique identifier for the compiled file. |
| * @property-read string $path |
| * The complete (but relative) path to the compiled file. Will |
| * be set even if it does not exist. |
| * @property ezcTemplateOutputContext $context |
| * The context used for the currently compiled file. |
| * @property ezcTemplate $template |
| * The template which is used when executing the template code. |
| * |
| * @package Template |
| * @version //autogen// |
| * @access private |
| */ |
| class ezcTemplateCompiledCode |
| { |
| /** |
| * The unique number for the template engine, this will be increased each time |
| * the compiled code needs to be recompiled at the client. |
| */ |
| const ENGINE_ID = 1; |
| |
| /** |
| * An array containing the properties of this object. |
| * |
| * @var array(string=>mixed) |
| */ |
| private $properties = array(); |
| |
| /** |
| * @var ezcTemplateVariableCollection |
| */ |
| private $send; |
| |
| /** |
| * @var ezcTemplateVariableCollection |
| */ |
| private $receive; |
| |
| |
| /** |
| * Property get |
| * |
| * @param string $name |
| * @return mixed |
| */ |
| public function __get( $name ) |
| { |
| switch ( $name ) |
| { |
| case 'identifier': |
| case 'path': |
| case 'context': |
| case 'template': |
| return $this->properties[$name]; |
| default: |
| throw new ezcBasePropertyNotFoundException( $name ); |
| } |
| } |
| |
| /** |
| * Property set |
| * |
| * @param string $name |
| * @param mixed $value |
| * @return void |
| */ |
| public function __set( $name, $value ) |
| { |
| switch ( $name ) |
| { |
| case 'context': |
| if ( $value !== null and |
| !( $value instanceof ezcTemplateOutputContext ) ) |
| throw new ezcBaseValueException( $name, $value, 'ezcTemplateOutputContext' ); |
| $this->properties[$name] = $value; |
| break; |
| case 'template': |
| if ( $value !== null and |
| !( $value instanceof ezcTemplate ) ) |
| throw new ezcBaseValueException( $name, $value, 'ezcTemplate' ); |
| $this->properties[$name] = $value; |
| break; |
| case 'identifier': |
| case 'path': |
| throw new ezcBasePropertyPermissionException( $name, ezcBasePropertyPermissionException::READ ); |
| default: |
| throw new ezcBasePropertyNotFoundException( $name ); |
| } |
| } |
| |
| /** |
| * Property isset |
| * |
| * @param string $name |
| * @return bool |
| */ |
| public function __isset( $name ) |
| { |
| switch ( $name ) |
| { |
| case 'identifier': |
| case 'path': |
| case 'context': |
| case 'template': |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Initialises the object with the identifier and the full path to the PHP file. |
| * |
| * @param string $identifier |
| * @param string $path |
| * @param ezcTemplateOutputContext $context |
| * @param ezcTemplate $template |
| */ |
| public function __construct( $identifier, $path, |
| /*ezcTemplateOutputContext*/ $context = null, ezcTemplate $template = null ) |
| { |
| $this->properties['identifier'] = $identifier; |
| $this->properties['path'] = $path; |
| $this->context = $context; |
| $this->template = $template; |
| } |
| |
| /** |
| * Executes the current compiled file using the source object. |
| * |
| * The input template variables is taken from the template. |
| * |
| * @throws ezcTemplateNoManagerException if there is no template set. |
| * @throws ezcTemplateNoOutputContextException if there is no output context set. |
| * @throws ezcTemplateInvalidCompiledFileException if the compiled cannot be executed. |
| * |
| * @return string |
| */ |
| public function execute() |
| { |
| if ( $this->template === null ) |
| throw new ezcTemplateNoManagerException( __CLASS__, 'template' ); |
| if ( $this->context === null ) |
| throw new ezcTemplateNoOutputContextException( __CLASS__, 'context' ); |
| |
| if ( !$this->isValid() ) |
| throw new ezcTemplateInvalidCompiledFileException( $this->identifier, $this->path ); |
| |
| $this->send = clone $this->template->send; |
| $this->receive = $this->template->receive; |
| return include( $this->path ); |
| } |
| |
| |
| /** |
| * The compiled template calls this method to see if the current template should be recompiled. |
| * Usually its the first method called in the template. |
| * |
| * A template should be recompiled if either one of the following rules apply: |
| * - The template source is newer than the compiled template. |
| * - The ENGINE_ID in the template (and given as parameter) is different than the ezcTemplateCompiledCode::ENGINE_ID. |
| * |
| * @param int $engineID |
| * |
| * @throws ezcTemplateOutdatedCompilationException when the template should be recompiled. |
| * @return void |
| */ |
| protected function checkRequirements( $engineID, $compileFlags = array() ) |
| { |
| if ( $this->template->configuration->checkModifiedTemplates && |
| // Do not recompile when the modification times are the same. This messes up the caching tests. |
| file_exists( $this->template->stream ) && |
| filemtime( $this->template->stream ) > filemtime( $this->properties['path'] ) ) |
| { |
| throw new ezcTemplateOutdatedCompilationException( "The source template file '{$this->template->stream}' is newer than '{$this->path}', will recompile." ); |
| } |
| |
| // Check if caching is enabled |
| if ( isset( $compileFlags["disableCache"] ) ) |
| { |
| if ( $this->template->configuration->disableCache != $compileFlags["disableCache"] ) |
| { |
| throw new ezcTemplateOutdatedCompilationException( "The compileFlag 'disableCache' has been changed, will recompile." ); |
| } |
| } |
| |
| // Check if the engine ID differs |
| if ( $engineID !== self::ENGINE_ID ) |
| { |
| throw new ezcTemplateOutdatedCompilationException( "The compilation file '{$this->path}' is outdated, will recompile." ); |
| } |
| } |
| |
| /** |
| * Returns true if the compiled code exists and is valid for execution. |
| * |
| * @return bool |
| */ |
| public function isValid() |
| { |
| return file_exists( $this->path ) and is_readable( $this->path ); |
| } |
| |
| /** |
| * Returns true if the compiled code exists on the filesystem. |
| * |
| * @return bool |
| */ |
| public function isAvailable() |
| { |
| return file_exists( $this->path ); |
| } |
| |
| /** |
| * Finds the compiled file based on the stream path and template options. |
| * |
| * Returns the compiled code object which can be used for execution or queried for more info. |
| * |
| * @param string $location The stream path of the requested template file. |
| * @param ezcTemplateOutputContext $context The current output context handler. |
| * @param ezcTemplateManager $template The template which contains the current settings. |
| * @return ezcTemplateCompiledCode |
| */ |
| public static function findCompiled( $location, ezcTemplateOutputContext $context, ezcTemplate $template ) |
| { |
| $options = 'ezcTemplate::options(' . |
| false /*(bool)$template->outputDebugEnabled*/ . '-' . |
| false /*(bool)$template->compiledDebugEnabled*/ . ')'; |
| $identifier = md5( 'ezcTemplateCompiled(' . $location . ')' ); |
| $name = basename( $location, '.ezt' ); |
| |
| $path = $template->configuration->compilePath . DIRECTORY_SEPARATOR . $template->configuration->compiledTemplatesPath . DIRECTORY_SEPARATOR . |
| $context->identifier() . '-' . |
| $template->generateOptionHash() . '/' . |
| $name . '-' . $identifier . ".php"; |
| return new ezcTemplateCompiledCode( $identifier, $path, $context, $template ); |
| } |
| } |
| ?> |