/**
* Lecture de données depuis le cache
*
* @param string $pId Identifiant de l'élément à récupérer
* @param string $pType Type de cache ou récupérer les données
* @param array $pExtra Paramètres supplémentaires
* @return string
* @throws CopixCacheException
*/
public function read($pId, $pType, $pExtra)
{
if ($return = CopixFile::read($this->_makeFileName($pId, $pType, $pExtra))) {
return unserialize($return);
}
throw new CopixCacheException($pId . '-' . $pType);
}
/**
* Set the data mode
* @param string $dataset_name
* @param strong $mode "static" or "db"
*/
public function setDataMode($mode = "static", $dataset = null, $connectionName = null)
{
if (empty($dataset) && $mode == "db") {
throw new Exception("No dataset given for CopixBayesian datas used with database");
}
$this->dataset = "bayesiantable_" . $dataset;
$this->mode = $mode == "db" ? "db" : "static";
//get tables
if ($this->mode == "db") {
$this->connectionName = $connectionName;
$ct = CopixDB::getConnection($connectionName);
if (!in_array($this->dataset, $ct->getTableList())) {
if ($ct instanceof CopixDBConnectionMySQL || $ct instanceof CopixDBConnectionPDO_MySQL) {
$sql = CopixFile::read(dirname(__FILE__) . "/../install/template_scripts/install.pdo_mysql.sql");
} elseif ($ct instanceof CopixDBConnectionPDO_SQLite) {
$sql = CopixFile::read(dirname(__FILE__) . "/../install/template_scripts/install.pdo_sqlite.sql");
} elseif ($ct instanceof CopixDBConnectionPDO_PgSQL) {
$sql = CopixFile::read(dirname(__FILE__) . "/../install/template_scripts/install.pdo_pgsql.sql");
} else {
//throw new CopixException("Data type: ".get_class($ct)." not currently supported");
}
$sql = str_replace('%TABLENAME%', $this->dataset, $sql);
_doQuery($sql, array(), $connectionName);
}
}
}
/**
* Ecriture du fichier de configuration
* @param array $pData le tableau des handlers à créer
* @return boolean si le fichier à été crée convenablement
*/
public function write($pData)
{
$generator = new CopixPHPGenerator();
$str = $generator->getPHPTags($generator->getVariableDeclaration('$_' . $this->_handlerType . '_handlers', $pData));
$file = new CopixFile();
if (($oldContent = $file->read($this->getPath())) !== false) {
$file->write($this->getPath(true), $oldContent);
}
return $file->write($this->getPath(), $str);
}
/**
* Traite un fichier de module.
*
* Si le type MIME du fichier est l'un de ceux pour lesquels on procède à la résolution
* de {copixresource}, on vérifie si une version cachée existe.
*
* @param string $pFilePath Chemin complet du ficher.
* @param string $pMIMEType Type MIME du fichier.
* @return string Chemin complet du fichier à envoyer.
*/
private function _processModuleFile($pFilePath, $pMIMEType)
{
// Seuls certains types MIME sont traités
if (!in_array($pMIMEType, self::$_processedMimeTypes)) {
return $pFilePath;
}
// Récupère la config
$config = $this->_getCopixConfig();
// Calcule le chemin du fichier en cache
$cacheKey = array(COPIX_TEMP_PATH . 'resources/');
$cacheKey[] = $this->_module;
$cacheKey[] = $this->_theme;
if ($config->i18n_path_enabled) {
$cacheKey[] = $this->_country;
$cacheKey[] = $this->_lang;
}
$cacheKey[] = preg_replace('@[/\\x5c]@', '_', $this->_path);
$cacheFile = join('_', $cacheKey);
// Vérifie le fichier caché
if ($config->force_compile || !file_exists($cacheFile) || ($config->compile_check || filemtime($pFilePath) > filemtime($cacheFile))) {
// Génère le fichier de cache en remplaçant tous les tags
CopixFile::write($cacheFile, preg_replace_callback('@\\{\\s*copixresource\\s+path=(["\'])(((\\w+)?\\|)?/?(.+))\\1\\s*}@i', array($this, '_replaceCopixresource'), CopixFile::read($pFilePath)));
}
// On envoie le fichier caché
return $cacheFile;
}
/**
* Test de cration d'un fichier, d'criture puis de lecture
* @param string $pFileName le nom du fichier tester
*/
public function _testFile($pFileName)
{
$this->assertFalse(file_exists($pFileName));
$this->assertTrue(CopixFile::write($pFileName, 'abcdef'));
$this->assertTrue(file_exists($pFileName));
$this->assertTrue(CopixFIle::read($pFileName) === 'abcdef');
$this->assertTrue(CopixFile::write($pFileName, $this->_bigData));
$this->assertTrue(CopixFile::read($pFileName) === $this->_bigData);
$this->assertTrue(CopixFile::delete($pFileName));
$this->assertFalse(file_exists($pFileName));
}
/**
* Extrait des informations de l'ensemble des fichiers module.xml des modules installés.
*
* @param string $pCacheKey Clef pour la mise en cache.
* @param string $pXPath Expression XPath de sélection des
* @param callback $pParserCallback
* @return mixed La valeur retournée par $pParserCallback.
*/
public static function getParsedModuleInformation($pCacheKey, $pXPath, $pParserCallback)
{
if (!is_callable($pParserCallback)) {
$final = '';
if (is_array($pParserCallback)) {
foreach ($pParserCallback as $name) {
$final .= $name;
}
}
throw new Exception("getParsedModuleInformation: {$final} should be callable");
}
$config = CopixConfig::instance();
$force_compile = $config->force_compile;
$compile_check = $config->compile_check;
//var_dump($force_compile, $compile_check);
if (!isset(self::$_registryCache[$pCacheKey])) {
$cacheFile = self::_getRegistryCacheFile($pCacheKey);
$must_compile = !file_exists($cacheFile) || $force_compile;
if (!$must_compile && $compile_check) {
// Test les fichiers si compile_check est vrai
_log("Vérification du cache pour {$pCacheKey} ({$cacheFile})", "registry", CopixLog::NOTICE);
$cacheDate = filemtime($cacheFile);
foreach (self::getList(true) as $moduleName) {
$descriptorPath = self::getPath($moduleName) . 'module.xml';
if (filemtime($descriptorPath) > $cacheDate) {
_log("{$descriptorPath} est plus récent que {$cacheFile}", "registry", CopixLog::NOTICE);
$must_compile = true;
break;
}
}
}
if ($must_compile) {
_log("Génération du cache pour {$pCacheKey} ({$cacheFile})", "registry", CopixLog::NOTICE);
// Liste les modules
$nodes = array();
foreach (self::getList(true) as $moduleName) {
$xml = simplexml_load_file(self::getPath($moduleName) . 'module.xml');
// Extrait les infos
$moduleNodes = $xml->xpath($pXPath);
// N'ajoute dans la liste que si on trouve quelque chose
if (is_array($moduleNodes) && count($moduleNodes) > 0) {
$nodes[$moduleName] = $xml->xpath($pXPath);
}
}
// Compile le tout
self::$_registryCache[$pCacheKey] = call_user_func($pParserCallback, $nodes);
// Ecrit le cache
CopixFile::write($cacheFile, serialize(self::$_registryCache[$pCacheKey]));
} else {
_log("Chargement du cache pour {$pCacheKey} ({$cacheFile})", "registry", CopixLog::NOTICE);
self::$_registryCache[$pCacheKey] = unserialize(CopixFile::read($cacheFile));
}
}
return self::$_registryCache[$pCacheKey];
}
/**
* Recherche de templates dans un module et d'extension donnée.
*
* Cette fonction va rechercher les templates dans le répertoire module template par défaut
* et également dans le répertoire de surcharge dans le thème default
* (project/modules/module_name/templates/* & project/themes/default/module_name/*)
*
* <code>
* $arTemplates = CopixTpl::find ('module_name', '.dyn.tpl');
* //recherche de plusieurs types de templates
* $arTemplates = CopixTpl::find ('module_name', array ('.dyn.tpl', '.dyn.ptpl'));
* //recherche avec masques
* $arTemplates = CopixTpl::find ('module_name', '.dyn.*');
* </code>
*
* @param string $pModuleName le nom du module dans lequel on va chercher le template
* @param mixed $pExtension l'extension que l'on recherche (ou un tableau d'extensions)
*
* @return array Retourne un tableau contenant en clé 'modules|fichier_trouvé' et en valeur le nom dans (tpl){*@name NOM} (ptpl)/*@name NOM si aucun nom n'est trouvé, on mets la clé
*/
public static function find($pModuleName, $pExtension)
{
if (!is_array($pExtension)) {
$pExtension = array($pExtension);
}
$files = array();
foreach ($pExtension as $extension) {
$files = array_merge($files, CopixFile::search('*' . $extension, COPIX_PROJECT_PATH . 'themes/default/' . $pModuleName . '/', false));
$files = array_merge($files, CopixFile::search('*' . $extension, CopixModule::getPath($pModuleName) . 'templates/', false));
}
$arFiles = array();
/*TODO Ajouter la gestion des ptpl*/
foreach ($files as $key => $file) {
$name = $pModuleName . '|' . basename($file);
$tpl = CopixFile::read($file);
if (substr($file, strlen($file) - 4) == 'ptpl') {
$nom = ereg_replace('.*\\/*@name ([^\\*]+[^/]+)\\*/.*', '\\1', $tpl);
} else {
$nom = ereg_replace('.*{*@name ([^\\*]+[^}]+)\\*\\}.*', '\\1', $tpl);
}
if (strlen($nom) == strlen($tpl)) {
$nom = $name;
}
$arFiles[$name] = $nom;
}
return $arFiles;
}
/**
* Lit le contenu des fichiers PHP sans les compiler, à la recherche de déclarations de classes et d'interfaces.
*
* L'objectif est de remplir le tableau $this->potentialClassPaths sans pour autant compiler le PHP.
* Il est possible que l'on trouve des déclarations en commentaires, c'est pour cela que l'on parle de chemin "potentiel".
*
* @param array $pFiles Liste des fichiers à analyser.
*
* @see $this->potentialClassPaths
*/
public function preParse($pFiles)
{
foreach ($pFiles as $file) {
if (preg_match_all('/\\s*(?:interface|class)\\s+(I?Copix\\w+)\\s+.*\\{/', CopixFile::read($file), $matches, PREG_PATTERN_ORDER)) {
foreach ($matches[1] as $className) {
$this->_addPotentialClassPath($className, $file);
}
}
}
}
