/** * Fills $this->files with all the .request files found in the regression * directory, recursively. */ public function __construct() { $siteaccess = strtolower(__CLASS__); if (ezcBaseFeatures::classExists('eZSiteAccessHelper', true)) { require_once 'siteaccesscreator.php'; // - ./siteaccess/site.ini.append.php.replace is copied over site.ini.append.php, // with certain values replaced dynamically (@ezc_siteaccess@ and // @ezc_webdav_database@) // - the extension ezsiteaccesshelper is called to create the siteaccess with // the same name as this class (in lowercase), and it will copy the site.ini.append.php // file to the ezp/siteaccess/@ezc_siteaccess@ folder // - the extension ezsiteaccesshelper is called to enable the created siteaccess // in ezp/siteaccess/override/site.ini.append.php $replace = array(); $replace['@ezc_siteaccess@'] = $siteaccess; $replace['@ezc_webdav_database@'] = ezpTestRunner::dsn()->database; $templateDir = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'siteaccess'; try { // replace @ezc_siteaccess@ and @ezc_webdav_database@ in site.ini.append.php // with respective values $contents = file_get_contents($templateDir . DIRECTORY_SEPARATOR . 'site.ini.append.php.replace'); if (count($replace) > 0) { foreach ($replace as $key => $replacement) { $contents = str_replace($key, $replacement, $contents); } } file_put_contents($templateDir . DIRECTORY_SEPARATOR . 'site.ini.append.php', $contents); ezpSiteAccessCreator::$docRoot = eZSys::rootDir() . DIRECTORY_SEPARATOR; ezpSiteAccessCreator::createSiteAccess($siteaccess, $templateDir); } catch (Exception $e) { // eZSiteAccessHelper::createSiteAccess throws an exception // if the siteaccess exists already // var_dump( $e->getMessage() ); } } else { die("The WebDAV test suite requires the extension eZSiteAccessHelper in order to create a siteaccess.\n"); } $basePath = dirname(__FILE__) . '/regression'; $this->readDirRecursively($basePath, $this->files, 'request'); parent::__construct(); }
/** * Parses a required type. * * @param mixed $type * @param ezcTemplateCursor $startCursor * @param bool $mergeElements * @return bool */ protected function parseRequiredType($type, ezcTemplateCursor $startCursor = null, $mergeElements = true) { if (is_string($type)) { $className = 'ezcTemplate' . $type . 'SourceToTstParser'; if (!ezcBaseFeatures::classExists($className)) { throw new ezcTemplateInternalException("Could instantiate sub-parser for type <{$type}>, the class <{$className}> does not exist"); } $this->subParser = new $className($this->parser, $this, $startCursor); } else { if (is_object($type) && $type instanceof ezcTemplateSourceToTstParser) { $this->subParser = $type; } else { throw new ezcTemplateInternalException("Cannot use <" . gettype($type) . "> as parser in ezcTemplateSourceToTstParser::parseRequiredType()"); } } $this->lastParser = $this->subParser; $this->subParser->parse(); if ($this->subParser->status == self::PARSE_SUCCESS) { $this->currentCursor->copy($this->subParser->endCursor); $this->lastCursor->copy($this->currentCursor); if ($mergeElements) { $this->mergeElements($this->subParser); } $this->subParser = null; return true; } elseif ($this->subParser->status === self::PARSE_PARTIAL_SUCCESS) { $this->status = $this->subParser->status; return false; } return false; }
public function testClassExistsNotFoundAutoload() { $this->assertEquals(false, ezcBaseFeatures::classExists('ezcBaseNonExistingClass')); }
/** * Creates a new cache in the manager. * This method is used to create a new cache inside the manager. * Each cache has a unique ID to access it during the application * runtime. Each location may only be used by 1 cache. * * The $storageClass parameter must be a subclass of * {@link ezcCacheStorage} and tells the manager which object * will be used for the cache. * * The $location parameter depends on the kind of {@link ezcCacheStorage} * used for the cache you create. Usually this is a directory on your * file system, but may also be e.g. a data source name, if you cache in * a database or similar. For memory-based storage ({@link ezcCacheStorageApcPlain} * or {@link ezcCacheStorageMemcachePlain}) it is null, but for * memory/file hybrid storage ({@link ezcCacheStorageFileApcArray}) it should * be an existing writeable path. * * The $options array consists of several standard attributes and can * additionally contain options defined by the {@link ezcCacheStorage} * class. Standard options are: * * <code> * array( * 'ttl' => 60*60*24, // Time-to-life, default: 1 day * ); * </code> * * @param string $id ID of the cache to create. * @param string $location Location to create the cache in. Null for * memory-based storage and an existing * writeable path for file or memory/file * storage. * @param string $storageClass Subclass of {@link ezcCacheStorage}. * @param array(string=>string) $options Options for the cache. * @return void * * @throws ezcBaseFileNotFoundException * If the given location does not exist or is not a * directory (thrown by sanity checks performed when storing the * configuration of a cache to ensure the latter calls to * {@link ezcCacheManager::getCache()} do not fail). * @throws ezcBaseFilePermissionException * If the given location is not read/writeable (thrown by sanity * checks performed when storing the configuration of a cache to * ensure the latter calls to {@link ezcCacheManager::getCache()} * do not fail). * @throws ezcCacheUsedLocationException * If the given location is already in use by another cache. * @throws ezcCacheInvalidStorageClassException * If the given storage class does not exist or is no subclass of * ezcCacheStorage. */ public static function createCache($id, $location = null, $storageClass, $options = array()) { // BC for missing location. The location should not be missing. if ($location !== null) { // Unifiy file system locations if (substr($location, 0, 1) === '/') { // If non-existent if (($realLocation = realpath($location)) === false) { throw new ezcBaseFileNotFoundException($location, 'cache location', 'Does not exist or is no directory.'); } $location = $realLocation; } // Sanity check double taken locations. foreach (self::$configurations as $confId => $config) { if ($config['location'] === $location) { throw new ezcCacheUsedLocationException($location, $confId); } } } // Sanity check storage class. if (!ezcBaseFeatures::classExists($storageClass) || !is_subclass_of($storageClass, 'ezcCacheStorage')) { throw new ezcCacheInvalidStorageClassException($storageClass); } self::$configurations[$id] = array('location' => $location, 'class' => $storageClass, 'options' => $options); }
/** * Initializes the manager. * * Initializes the manager with the values which will be used by the configuration * reader. It sets the default location and reader options and which reader to * use by specifying the class name. * * @throws ezcConfigurationInvalidReaderClassException if the $readerClass * does not exist or does not implement the ezcConfigurationReader * interface. * * @param string $readerClass The name of the class to use as a * configuration reader. This class must implement the * ezcConfigurationReader interface. * @param string $location The main placement for the configuration. It is * up to the specific reader to interpret this value. This * can for instance be used to determine the directory * location for an INI file. * @param array $options Options for the configuration reader, this is * passed on the reader specified in $readerClass when it is * created. Check the documentation for the specific reader * to see which options it supports. * @return void */ public function init($readerClass, $location, array $options = array()) { // Check if the passed classname actually exists if (!ezcBaseFeatures::classExists($readerClass, true)) { throw new ezcConfigurationInvalidReaderClassException($readerClass); } // Check if the passed classname actually implements the interface. if (!in_array('ezcConfigurationReader', class_parents($readerClass))) { throw new ezcConfigurationInvalidReaderClassException($readerClass); } $this->readerClass = $readerClass; $this->location = $location; $this->options = $options; }
/** * Check all known handlers for availability. * * This method checks all registered handler classes for if the they are * available (using {@link ezcImageAnalyzerHandler::isAvailable()}). * * @throws ezcImageAnalyzerInvalidHandlerException * If a registered handler class does not exist * or does not inherit from {@link ezcImageAnalyzerHandler}. */ protected function checkHandlers() { if (isset(ezcImageAnalyzer::$availableHandlers) && is_array(ezcImageAnalyzer::$availableHandlers)) { return; } ezcImageAnalyzer::$availableHandlers = array(); foreach (ezcImageAnalyzer::$knownHandlers as $handlerClass => $options) { if (!ezcBaseFeatures::classExists($handlerClass) || !is_subclass_of($handlerClass, 'ezcImageAnalyzerHandler')) { throw new ezcImageAnalyzerInvalidHandlerException($handlerClass); } $handler = new $handlerClass($options); if ($handler->isAvailable()) { ezcImageAnalyzer::$availableHandlers[] = clone $handler; } } }
/** * Initialize converter with settings object. * The ezcImageConverter can be directly instantiated, but it's * highly recommended to use a manual singleton implementation * to have just 1 instance of a ezcImageConverter per Request. * * ATTENTION: The ezcImageConverter does not support animated * GIFs. Animated GIFs will simply be ignored by all filters and * conversions. * * @param ezcImageConverterSettings $settings Settings for the converter. * * @throws ezcImageHandlerSettingsInvalidException * If handler settings are invalid. * @throws ezcImageMimeTypeUnsupportedException * If a given MIME type is not supported. */ public function __construct(ezcImageConverterSettings $settings) { // Initialize handlers foreach ($settings->handlers as $i => $handlerSettings) { if (!$handlerSettings instanceof ezcImageHandlerSettings) { throw new ezcImageHandlerSettingsInvalidException(); } $handlerClass = $handlerSettings->className; if (!ezcBaseFeatures::classExists($handlerClass)) { throw new ezcImageHandlerNotAvailableException($handlerClass); } $handler = new $handlerClass($handlerSettings); $this->handlers[$handlerSettings->referenceName] = $handler; } // Check implicit conversions foreach ($settings->conversions as $mimeIn => $mimeOut) { if (!$this->allowsInput($mimeIn)) { throw new ezcImageMimeTypeUnsupportedException($mimeIn, 'input'); } if (!$this->allowsOutput($mimeOut)) { throw new ezcImageMimeTypeUnsupportedException($mimeOut, 'output'); } } $this->settings = $settings; }
/** * Adds the difference write handler class $writerClass to the manager for $type * * @throws ezcDbSchemaInvalidWriterClassException if the $writerClass * doesn't exist or doesn't extend the abstract class * ezcDbSchemaDiffWriter. * @param string $type * @param string $writerClass */ public static function addDiffWriter($type, $writerClass) { // Check if the passed classname actually exists if (!ezcBaseFeatures::classExists($writerClass, true)) { throw new ezcDbSchemaInvalidDiffWriterClassException($writerClass); } // Check if the passed classname actually implements the interface. if (!in_array('ezcDbSchemaDiffWriter', class_implements($writerClass))) { throw new ezcDbSchemaInvalidDiffWriterClassException($writerClass); } self::$diffWriteHandlers[$type] = $writerClass; }
/** * Adds the classname $callbackClassname as callback for the identifier $identifier. * * @param string $identifier * @param string $callbackClassname */ public static function setCallback($identifier, $callbackClassname) { if (array_key_exists($identifier, self::$callbackMap)) { throw new ezcBaseInitCallbackConfiguredException($identifier, self::$callbackMap[$identifier]); } else { // Check if the passed classname actually exists if (!ezcBaseFeatures::classExists($callbackClassname, true)) { throw new ezcBaseInitInvalidCallbackClassException($callbackClassname); } // Check if the passed classname actually implements the interface. if (!in_array('ezcBaseConfigurationInitializer', class_implements($callbackClassname))) { throw new ezcBaseInitInvalidCallbackClassException($callbackClassname); } self::$callbackMap[$identifier] = $callbackClassname; } }
/** * Parses the statements, foreach, while, if, elseif, etc. * * @param ezcTemplateCursor $cursor * @return bool */ protected function parseCurrent(ezcTemplateCursor $cursor) { // Check if any control structure names are used. // Note: The code inside the (?:) brace ensures that the next character // is not an alphabetical character ie. a word boundary $matches = $cursor->pregMatchComplete("#^(tr|tr_context|foreach|while|if|elseif|else|switch|case|default|include|return|break|continue|skip|delimiter|increment|decrement|reset|charset|capture)(?:[^a-zA-Z0-9_])#"); if ($matches === false) { return false; } $name = $matches[1][0]; $cursor->advance(strlen($matches[1][0])); // control structure map $csMap = array(); $csMap['foreach'] = 'ForeachLoop'; $csMap['for'] = 'ForLoop'; $csMap['while'] = 'WhileLoop'; $csMap['if'] = 'IfCondition'; $csMap['elseif'] = 'IfCondition'; $csMap['else'] = 'IfCondition'; $csMap['switch'] = 'SwitchCondition'; $csMap['case'] = 'SwitchCondition'; $csMap['default'] = 'SwitchCondition'; $csMap['include'] = 'Include'; $csMap['return'] = 'Include'; $csMap['break'] = 'Loop'; $csMap['continue'] = 'Loop'; $csMap['skip'] = 'Delimiter'; $csMap['delimiter'] = 'Delimiter'; $csMap['increment'] = 'Cycle'; $csMap['decrement'] = 'Cycle'; $csMap['reset'] = 'Cycle'; $csMap['charset'] = 'Charset'; $csMap['capture'] = 'Capture'; $csMap['tr'] = 'Translation'; $csMap['tr_context'] = 'TranslationContext'; // tmp if (!isset($csMap[$name])) { return false; } $parser = 'ezcTemplate' . $csMap[$name] . 'SourceToTstParser'; // tmp if (!ezcBaseFeatures::classExists($parser)) { return false; } if (!ezcBaseFeatures::classExists($parser)) { throw new ezcTemplateInternalException("Requested parser class <{$parser}> does not exist"); } $controlStructureParser = new $parser($this->parser, $this, null); $this->block->name = $name; $controlStructureParser->block = $this->block; if (!$this->parseRequiredType($controlStructureParser)) { return false; } return true; }
public function testReader5() { if (!ezcBaseFeatures::classExists('SimpleXMLIterator')) { $this->markTestSkipped("This test is supposed to run only when the SimpleXML extension is available."); } $currentDir = dirname(__FILE__); $backend = new ezcTranslationTsBackend("{$currentDir}/files/translations"); $backend->setOptions(array('format' => '[LOCALE].xml')); $backend->initReader('nb-no'); $contexts = array(); foreach ($backend as $contextName => $context) { $contexts[] = $contextName; } $backend->deinitReader(); $expected = array('contentstructuremenu/show_content_structure', 'design/admin/class/classlist', 'design/admin/class/datatype/browse_objectrelationlist_placement'); self::assertEquals($expected, $contexts); }
/** * Adds custom tags or functions to the customBlock or customFunction * property and indirectly adds the custom extension to the template * language. * * The parameter $customBlockClass expects a class that implements either * the interface ezcTemplateCustomBlock, ezcTemplateCustomFunction, or both. * * New custom blocks are added to the * {@link ezcTemplateConfiguration::customBlocks $customBlocks} property while * custom functions are added to the * {@link ezcTemplateConfiguration::customFunctions $customFunctions} property. * * @param string $customClass * @throws ezcBaseValueException if the $customClass parameter is not a * string, or when the classname that it represents does not * implement either the ezcTemplateCustomBlock or * ezcTemplateCustomFunction interface. */ public function addExtension($customClass) { if (!is_string($customClass) || !ezcBaseFeatures::classExists($customClass, true)) { throw new ezcBaseValueException('customClass', $customClass, 'string with classname that implements the ezcTemplateCustomBlock or ezcTemplateCustomFunction interface', 'argument'); } $implements = class_implements($customClass); $added = false; if (in_array("ezcTemplateCustomBlock", $implements)) { $this->properties["customBlocks"][$customClass] = $customClass; $added = true; } if (in_array("ezcTemplateCustomFunction", $implements)) { $this->properties["customFunctions"][$customClass] = $customClass; $added = true; } if (!$added) { throw new ezcBaseValueException('customClass', $customClass, 'string with classname that implements the ezcTemplateCustomBlock or ezcTemplateCustomFunction interface', 'argument'); } }
/** * Adds the classname $callbackClassname as callback for the identifier $identifier. * * @param string $identifier * @param string $callbackClassname */ public static function setCallback($identifier, $callbackClassname) { if (array_key_exists($identifier, self::$callbackMap)) { throw new ezcBaseInitCallbackConfiguredException($identifier, self::$callbackMap[$identifier]); } else { // Check if the passed classname actually exists if (!ezcBaseFeatures::classExists($callbackClassname, true)) { throw new ezcBaseInitInvalidCallbackClassException($callbackClassname); } // Check if the passed classname actually implements the interface. We // have to do that with reflection here unfortunately $interfaceClass = new ReflectionClass('ezcBaseConfigurationInitializer'); $handlerClass = new ReflectionClass($callbackClassname); if (!$handlerClass->isSubclassOf($interfaceClass)) { throw new ezcBaseInitInvalidCallbackClassException($callbackClassname); } self::$callbackMap[$identifier] = $callbackClassname; } }
/** * Initializes the ezcExecution environment. * * With this method you initialize the ezcExecution environment. You need * to specify a class name $callBackClassName that will be used to call the * onError() method on in case of an error. The class name that you * pass should implement the ezcExecutionErrorHandler interface. This * method takes care of registering the uncaught exception and shutdown * handlers. * * @throws ezcExecutionInvalidCallbackException if an unknown callback * class was passed. * @throws ezcExecutionWrongClassException if an invalid callback class was * passed. * @throws ezcExecutionAlreadyInitializedException if the environment was * already initialized. * * @param string $callbackClassName * @return void */ public static function init($callbackClassName) { // Check if the passed classname actually exists if (!ezcBaseFeatures::classExists($callbackClassName, true)) { throw new ezcExecutionInvalidCallbackException($callbackClassName); } // Check if the passed classname actually implements the interface. We // have to do that with reflection here unfortunately since we only // have the classname and not an object. $interfaceClass = new ReflectionClass('ezcExecutionErrorHandler'); $handlerClass = new ReflectionClass($callbackClassName); if (!$handlerClass->isSubclassOf($interfaceClass)) { throw new ezcExecutionWrongClassException($callbackClassName); } // Check if it was already initialized once if (self::$isInitialized == true) { throw new ezcExecutionAlreadyInitializedException(); } // Install shutdown handler and exception handler set_exception_handler(array('ezcExecution', 'exceptionCallbackHandler')); if (!self::$shutdownHandlerRegistered) { register_shutdown_function(array('ezcExecution', 'shutdownCallbackHandler')); } self::$callbackClassName = $callbackClassName; self::$isInitialized = true; self::$cleanExit = false; self::$shutdownHandlerRegistered = true; }
/** * Initializes the ezcExecution environment. * * With this method you initialize the ezcExecution environment. You need * to specify a class name $callBackClassName that will be used to call the * onError() method on in case of an error. The class name that you * pass should implement the ezcExecutionErrorHandler interface. This * method takes care of registering the uncaught exception and shutdown * handlers. * * @throws ezcExecutionInvalidCallbackException if an unknown callback * class was passed. * @throws ezcExecutionWrongClassException if an invalid callback class was * passed. * @throws ezcExecutionAlreadyInitializedException if the environment was * already initialized. * * @param string $callbackClassName * @return void */ public static function init($callbackClassName) { // Check if the passed classname actually exists if (!ezcBaseFeatures::classExists($callbackClassName, true)) { throw new ezcExecutionInvalidCallbackException($callbackClassName); } // Check if the passed classname actually implements the interface. if (!in_array('ezcExecutionErrorHandler', class_implements($callbackClassName))) { throw new ezcExecutionWrongClassException($callbackClassName); } // Check if it was already initialized once if (self::$isInitialized == true) { throw new ezcExecutionAlreadyInitializedException(); } // Install shutdown handler and exception handler set_exception_handler(array('ezcExecution', 'exceptionCallbackHandler')); if (!self::$shutdownHandlerRegistered) { register_shutdown_function(array('ezcExecution', 'shutdownCallbackHandler')); } self::$callbackClassName = $callbackClassName; self::$isInitialized = true; self::$cleanExit = false; self::$shutdownHandlerRegistered = true; }