.-.-.-.-.-

verifie_conformite.php000066600000014372152502550330011146 0ustar00<?php

/***************************************************************************\
 *  SPIP, Systeme de publication pour l'internet                           *
 *                                                                         *
 *  Copyright (c) 2001-2014                                                *
 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
 *                                                                         *
 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
\***************************************************************************/

if (!defined('_ECRIRE_INC_VERSION')) return;

include_spip('inc/xml');
include_spip('inc/plugin');

// http://doc.spip.org/@plugin_verifie_conformite
function plugins_verifie_conformite_dist($plug, &$arbre, $dir_plugins = _DIR_PLUGINS){
	static $etats = array('dev','experimental','test', 'stable');

$matches = array();
	$silence = false;
	$p = null;
	// chercher la declaration <plugin spip='...'> a prendre pour cette version de SPIP
	if ($n = spip_xml_match_nodes(",^plugin(\s|$),", $arbre, $matches)){
		// version de SPIP
		$vspip = $GLOBALS['spip_version_branche'];
		foreach($matches as $tag=>$sous){
			list($tagname,$atts) = spip_xml_decompose_tag($tag);
			if ($tagname=='plugin' AND is_array($sous)){
				// On rajoute la condition sur $n :
				// -- en effet si $n==1 on a pas plus a choisir la balise que l'on ait
				//    un attribut spip ou pas. Cela permet de traiter tous les cas mono-balise
				//    de la meme facon.
				if (!isset($atts['spip'])
					OR $n==1
					OR plugin_version_compatible($atts['spip'],$vspip,'spip')) {
					// on prend la derniere declaration avec ce nom
					$p = end($sous);
					$compat_spip = isset($atts['spip']) ? $atts['spip'] : '';
				}
			}
		}
	}
	if (is_null($p)){
		$arbre = array('erreur' => array(_T('erreur_plugin_tag_plugin_absent')." : $plug"));
		$silence = true;
	}
	else
		$arbre = $p;
	if (!is_array($arbre)) $arbre = array();
  // verification de la conformite du plugin avec quelques
  // precautions elementaires
	if (!isset($arbre['nom'])){
		if (!$silence)
			$arbre['erreur'][] = _T('erreur_plugin_nom_manquant');
		$arbre['nom'] = array("");
	}
	if (!isset($arbre['version'])){
	  	if (!$silence)
			$arbre['erreur'][] = _T('erreur_plugin_version_manquant');
		$arbre['version'] = array("");
	}
	if (!isset($arbre['prefix'])){
	  	if (!$silence)
			$arbre['erreur'][] = _T('erreur_plugin_prefix_manquant');
		$arbre['prefix'] = array("");
	} else{
		$prefix = trim(end($arbre['prefix']));
		if (strtoupper($prefix)=='SPIP' AND $plug!="./"){
			$arbre['erreur'][] = _T('erreur_plugin_prefix_interdit');
		}
		if (isset($arbre['etat'])){
			$etat = trim(end($arbre['etat']));
			if (!in_array($etat, $etats))
				$arbre['erreur'][] = _T('erreur_plugin_etat_inconnu')." : '$etat'";
		}
		if (isset($arbre['options'])){
			foreach($arbre['options'] as $optfile){
				$optfile = trim($optfile);
				if (!@is_readable($dir_plugins."$plug/$optfile"))
  				if (!$silence)
						$arbre['erreur'][] = _T('erreur_plugin_fichier_absent')." : $optfile";
			}
		}
		if (isset($arbre['fonctions'])){
			foreach($arbre['fonctions'] as $optfile){
				$optfile = trim($optfile);
				if (!@is_readable($dir_plugins."$plug/$optfile"))
  				if (!$silence)
						$arbre['erreur'][] = _T('erreur_plugin_fichier_absent')." : $optfile";
			}
		}
		$fonctions = array();
		if (isset($arbre['fonctions']))
			$fonctions = $arbre['fonctions'];
	  $liste_methodes_reservees = array('__construct','__destruct','plugin','install','uninstall',strtolower($prefix));

$extraire_pipelines = charger_fonction("extraire_pipelines","plugins");
	  $arbre['pipeline'] = $extraire_pipelines($arbre);
		foreach($arbre['pipeline'] as $pipe){
			if (!isset($pipe['nom']))
				if (!$silence)
					$arbre['erreur'][] = _T("erreur_plugin_nom_pipeline_non_defini");
			if (isset($pipe['action'])) $action = $pipe['action'];
			else $action = $pipe['nom'];
			// verif que la methode a un nom autorise
			if (in_array(strtolower($action),$liste_methodes_reservees)){
				if (!$silence)
					$arbre['erreur'][] = _T("erreur_plugin_nom_fonction_interdit")." : $action";
			}
			if (isset($pipe['inclure'])) {
				$inclure = $dir_plugins."$plug/".$pipe['inclure'];
				if (!@is_readable($inclure))
	  			if (!$silence)
						$arbre['erreur'][] = _T('erreur_plugin_fichier_absent')." : $inclure";
			}
		}
		$necessite = array();
		$spip_trouve = false;
		if (spip_xml_match_nodes(',^necessite,',$arbre,$needs)){
			foreach(array_keys($needs) as $tag){
				list($tag,$att) = spip_xml_decompose_tag($tag);
				$necessite[] = $att;
				if (strtolower($att['id']) == 'spip')
					$spip_trouve = true;
			}
		}
		if ($compat_spip AND !$spip_trouve)
				$necessite[] = array('id' => 'spip', 'version' => $compat_spip);
		$arbre['necessite'] = $necessite;
		$utilise = array();
		if (spip_xml_match_nodes(',^utilise,',$arbre,$uses)){
			foreach(array_keys($uses) as $tag){
				list($tag,$att) = spip_xml_decompose_tag($tag);
				$utilise[] = $att;
			}
		}
		$arbre['utilise'] = $utilise;
		$procure = array();
		if (spip_xml_match_nodes(',^procure,',$arbre,$uses)){
			foreach(array_keys($uses) as $tag){
				list($tag,$att) = spip_xml_decompose_tag($tag);
				$procure[] = $att;
			}
		}
		$arbre['procure'] = $procure;
		$path = array();
		if (spip_xml_match_nodes(',^chemin,',$arbre,$paths)){
			foreach(array_keys($paths) as $tag){
				list($tag,$att) = spip_xml_decompose_tag($tag);
				$att['path'] = $att['dir']; // ancienne syntaxe
				$path[] = $att;
			}
		}
		else
			$path = array(array('dir'=>'')); // initialiser par defaut
		$arbre['path'] = $path;
		// exposer les noisettes
		if (isset($arbre['noisette'])){
			foreach($arbre['noisette'] as $k=>$nut){
				$nut = preg_replace(',[.]html$,uims','',trim($nut));
				$arbre['noisette'][$k] = $nut;
				if (!@is_readable($dir_plugins."$plug/$nut.html"))
  				if (!$silence)
						$arbre['erreur'][] = _T('erreur_plugin_fichier_absent')." : $nut";
			}
		}
		$traduire = array();
		if (spip_xml_match_nodes(',^traduire,',$arbre,$trads)){
			foreach(array_keys($trads) as $tag){
				list($tag,$att) = spip_xml_decompose_tag($tag);
				$traduire[] = $att;
			}
		}
		$arbre['traduire'] = $traduire;
	}
}

?>
infos_plugin.php000066600000015227152502550330007764 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;

// lecture d'un texte ecrit en pseudo-xml issu d'un fichier plugin.xml
// et conversion approximative en tableau PHP.
function plugins_infos_plugin($desc, $plug='', $dir_plugins=_DIR_PLUGINS) {
	include_spip('inc/xml');
	$arbre = spip_xml_parse($desc);

$verifie_conformite = charger_fonction('verifie_conformite','plugins');
	$verifie_conformite($plug, $arbre, $dir_plugins);

include_spip('inc/charsets');

// On renvoie la DTD utilisee
	$ret['dtd'] = "plugin";

if (isset($arbre['categorie']))
		$ret['categorie'] = trim(spip_xml_aplatit($arbre['categorie']));
	if (isset($arbre['nom']))
		$ret['nom'] = charset2unicode(spip_xml_aplatit($arbre['nom']));
	if (isset($arbre['icon']))
		$ret['logo'] = trim(spip_xml_aplatit($arbre['icon']));
	if (isset($arbre['auteur']))
		$ret['auteur'][] = trim(spip_xml_aplatit($arbre['auteur'])); // garder le 1er niveau en tableau mais traiter le multi possible
	if (isset($arbre['licence']))
		$ret['licence'][] = trim(spip_xml_aplatit($arbre['licence']));
	if (isset($arbre['version']))
		$ret['version'] = trim(spip_xml_aplatit($arbre['version']));
	if (isset($arbre['version_base']))
		$ret['schema'] = trim(spip_xml_aplatit($arbre['version_base']));
	if (isset($arbre['etat']))
		$ret['etat'] = trim(spip_xml_aplatit($arbre['etat']));

$ret['description'] = $ret['slogan'] = "";
	if (isset($arbre['slogan']))
		$ret['slogan'] = trim(spip_xml_aplatit($arbre['slogan']));
	if (isset($arbre['description'])){
		$ret['description'] = trim(spip_xml_aplatit($arbre['description']));
	}

if (isset($arbre['lien'])){
		$ret['documentation'] = trim(join(' ',$arbre['lien']));
		if ($ret['documentation']) {
			// le lien de doc doit etre une url et c'est tout
			if (!preg_match(',^https?://,iS', $ret['documentation']))
				$ret['documentation'] = "";
		}
	}

if (isset($arbre['options']))
		$ret['options'] = $arbre['options'];
	if (isset($arbre['fonctions']))
		$ret['fonctions'] = $arbre['fonctions'];
	if (isset($arbre['prefix'][0]))
		$ret['prefix'] = trim(array_pop($arbre['prefix']));
	if (isset($arbre['install']))
		$ret['install'] = $arbre['install'];
	if (isset($arbre['meta']))
		$ret['meta'] = trim(spip_xml_aplatit($arbre['meta']));

$necessite = info_plugin_normalise_necessite($arbre['necessite']);
	$ret['compatibilite'] = isset($necessite['compatible'])?$necessite['compatible']:'';
	$ret['necessite'] = $necessite['necessite'];
	$ret['lib'] = $necessite['lib'];
	$ret['utilise'] = info_plugin_normalise_utilise($arbre['utilise']);
	$ret['procure'] = info_plugin_normalise_procure($arbre['procure']);
	$ret['chemin']  = info_plugin_normalise_chemin($arbre['path']);

if (isset($arbre['pipeline']))
		$ret['pipeline'] = $arbre['pipeline'];

$extraire_boutons = charger_fonction('extraire_boutons','plugins');
	$les_boutons = $extraire_boutons($arbre);
	$ret['menu'] = $les_boutons['bouton'];
	$ret['onglet'] = $les_boutons['onglet'];

$ret['traduire'] = $arbre['traduire'];
		
	if (isset($arbre['config']))
		$ret['config'] = spip_xml_aplatit($arbre['config']);
	if (isset($arbre['noisette']))
		$ret['noisette'] = $arbre['noisette'];

if (isset($arbre['erreur'])) {
		$ret['erreur'] = $arbre['erreur'];
		if ($plug) spip_log("infos_plugin $plug " . @join(' ', $arbre['erreur']));
	}

return $ret;
}

// Un attribut de nom "id" a une signification particuliere en XML
// qui ne correspond pas a l'utilissation qu'en font les plugin.xml
// Pour eviter de complexifier la lecture de paquet.xml
// qui n'est pour rien dans cette bevue, on doublonne l'information
// sous les deux index "nom" et "id" dans l'arbre de syntaxe abstraite
// pour compatibilite, mais seul le premier est disponible quand on lit
// un paquet.xml, "id" devant etre considere comme obsolete

/**
 * Normaliser les description des necessite
 * 
 * Ajoute les clés
 * - 'nom' (= id)
 * - 'compatibilite' (= version)
 *
 * @param array $utilise
 * 		Liste des necessite trouvés pour le plugin
 * @return array
 * 		Liste des necessite modifiés.
 */
function info_plugin_normalise_necessite($necessite) {
	$res = array('necessite' => array(), 'lib' => array());

if (is_array($necessite)) {
		foreach($necessite as $need) {
			$id = $need['id'];
			$v = isset($need['version']) ? $need['version'] : '';
			
			// Necessite SPIP version x ?
			if (strtoupper($id)=='SPIP') {
				$res['compatible'] = $v;
			} else if (preg_match(',^lib:\s*([^\s]*),i', $id, $r)) {
				$res['lib'][] = array('nom' => $r[1], 'id' => $r[1], 'lien' => $need['src']);
			} else $res['necessite'][] = array('id' => $id, 'nom' => $id, 'version' => $v, 'compatibilite' => $v);
		}
	}
	
	return $res;
}

/**
 * Normaliser la description des utilise
 * 
 * Ajoute les clés
 * - 'nom' (= id)
 * - 'compatibilite' (= version)
 *
 * @param array $utilise
 * 		Liste des utilise trouvés pour le plugin
 * @return array
 * 		Liste des utilise modifiés.
 */
function info_plugin_normalise_utilise($utilise) {
	$res = array();

if (is_array($utilise)) {
		foreach($utilise as $need){
			$id = $need['id'];
			$v = isset($need['version']) ? $need['version'] : '' ;
			$res[]= array('nom' => $id, 'id' => $id, 'version' => $v, 'compatibilite' => $v);
		}
	}
	return $res;
}

/**
 * Normaliser la description des procurations
 * 
 * Ajoute la cle 'nom' (= id)
 *
 * @param array $procure
 * 		Liste des procure trouvés pour le plugin
 * @return array
 * 		Liste des procure modifiés.
 */
function info_plugin_normalise_procure($procure) {
	$res = array();

if (is_array($procure)) {
		foreach($procure as $need){
			$id = $need['id'];
			$v = $need['version'];
			$res[]= array('nom' => $id, 'id' => $id, 'version' => $v);
		}
	}
	return $res;
}

/**
 * Normaliser la description du chemin
 * 
 * Ajoute le clés 'path' (= dir)
 *
 * @param array $chemins
 * 		Liste des chemins trouvés pour le plugin
 * @return array
 * 		Liste des chemins modifiés.
 */
function info_plugin_normalise_chemin($chemins) {
	$res = array();

if (is_array($chemins)) {
		foreach ($chemins as $c) {
			$c['path'] = $c['dir'];
			$res[] = $c;
		}
	}
	return $res;
}
?>
afficher_plugin.php000066600000023576152502550330010423 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;
include_spip('inc/charsets');
include_spip('inc/texte');
include_spip('inc/plugin'); // pour plugin_est_installe

// http://doc.spip.org/@ligne_plug
function plugins_afficher_plugin_dist($url_page, $plug_file, $checked, $actif, $expose=false, $class_li="item", $dir_plugins=_DIR_PLUGINS) {

static $id_input = 0;
	static $versions = array();

$force_reload = (_request('var_mode')=='recalcul');
	$get_infos = charger_fonction('get_infos','plugins');
	$info = $get_infos($plug_file, $force_reload, $dir_plugins);
	$prefix = $info['prefix'];
	$cfg = "";
	$checkable = ($dir_plugins!==_DIR_PLUGINS_DIST);
	$nom = plugin_nom($info,$dir_plugins,$plug_file);

if (!plugin_version_compatible($info['compatibilite'], $GLOBALS['spip_version_branche'],'spip')){
		$info['slogan'] = _T('plugin_info_non_compatible_spip');
		$erreur = http_img_pack("plugin-dis-32.png",_T('plugin_info_non_compatible_spip')," class='picto_err'",_T('plugin_info_non_compatible_spip'));
		$class_li .= " disabled";
		$checkable = false;
	}
	elseif (isset($info['erreur'])) {
		$class_li .= " error";
		$erreur = http_img_pack("plugin-err-32.png",_T('plugin_info_erreur_xml')," class='picto_err'",_T('plugin_info_erreur_xml'))
		  . "<div class='erreur'>" . join('<br >', $info['erreur']) . "</div>";
		$checkable = false;
	}
	elseif (isset($GLOBALS['erreurs_activation_raw'][$dir_plugins.$plug_file])){
		$class_li .= " error";
		$erreur = http_img_pack("plugin-err-32.png",_T('plugin_impossible_activer', array('plugin' => $nom))," class='picto_err'",_T('plugin_impossible_activer', array('plugin' => $nom)))
		  . "<div class='erreur'>" . implode("<br />",$GLOBALS['erreurs_activation_raw'][$dir_plugins.$plug_file]) . "</div>";
	}
	else
		$cfg = $actif ? plugin_bouton_config($plug_file,$info,$dir_plugins) : "";

// numerotons les occurrences d'un meme prefix
	$versions[$prefix] = $id = isset($versions[$prefix]) ? $versions[$prefix] + 1 : '';

$class_li .= ($actif?" actif":"") . ($expose?" on":"");
	return "<li id='$prefix$id' class='$class_li'>"
	. ((!$checkable AND !$checked)
	   ? '': plugin_checkbox(++$id_input, $dir_plugins.$plug_file, $checked))
	.  plugin_resume($info, $dir_plugins, $plug_file, $url_page)
	. $cfg
	. $erreur
	. (($dir_plugins!==_DIR_PLUGINS_DIST AND plugin_est_installe($plug_file))
	    ? plugin_desintalle($plug_file,$nom,$dir_plugins) : '')
	. "<div class='details'>" // pour l'ajax de exec/info_plugin
	. (!$expose ? '' : affiche_bloc_plugin($plug_file, $info, $dir_plugins))
	. "</div>"
	."</li>";
}

function plugin_bouton_config($nom, $infos, $dir)
{
	// la verification se base sur le filesystem
	// il faut donc n'utiliser que des minuscules, par convention
	$prefix = strtolower($infos['prefix']);
	// si plugin.xml fournit un squelette, le prendre
	if ($infos['config'])
		return recuperer_fond("$dir$nom/" . $infos['config'],
				array('script' => 'configurer_' . $prefix,
					'nom' => $nom));

// si le plugin CFG est la, l'essayer
	if  (defined('_DIR_PLUGIN_CFG')) {
		if (include_spip('inc/cfg')) // test CFG version >= 1.0.5
			if ($cfg = icone_lien_cfg("$dir$nom", "cfg"))
				return "<div class='cfg_link'>$cfg</div>";
	}

// sinon prendre le squelette std sur le nom std
	return recuperer_fond("prive/squelettes/inclure/cfg",
			array('script' => 'configurer_' . $prefix,
				'nom' => $nom));
}

// checkbox pour activer ou desactiver
// si ce n'est pas une extension

function plugin_checkbox($id_input, $file, $actif)
{
	$name = substr(md5($file),0,16);

return "<div class='check'>\n"
	. "<input type='checkbox' name='s$name' id='label_$id_input'"
	. ($actif?" checked='checked'":"")
	. " class='checkbox'  value='O' />"
	. "\n<label for='label_$id_input'>"._T('activer_plugin')."</label>"
	. "</div>";
}

function plugin_nom($info, $dir_plugins, $plug_file){
	$prefix = $info['prefix'];
	$dir = "$dir_plugins$plug_file";
	// Si dtd paquet, on traite le nom soit par son item de langue soit par sa valeur immediate a l'index "nom"
	if ($info['dtd'] == "paquet") {
		$nom = PtoBR(plugin_propre("{$prefix}_nom", "$dir/lang/paquet-$prefix"));
		if (!$nom)
			$nom = PtoBR(propre($info['nom']));
	}
	else
		$nom = typo(attribut_html($info['nom']));

return trim($nom);
}

// Cartouche Resume
function plugin_resume($info, $dir_plugins, $plug_file, $url_page){
	$prefix = $info['prefix'];
	$dir = "$dir_plugins$plug_file";
	$slogan = PtoBR(plugin_propre($info['slogan'], "$dir/lang/paquet-$prefix"));
	// une seule ligne dans le slogan : couper si besoin
	if (($p=strpos($slogan, "<br />"))!==FALSE)
		$slogan = substr($slogan, 0,$p);
	// couper par securite
	$slogan = couper($slogan, 80);

$nom = plugin_nom($info, $dir_plugins, $plug_file);

$url = parametre_url($url_page, "plugin", substr($dir,strlen(_DIR_RACINE)));

if (isset($info['logo']) and $i = trim($info['logo'])) {
		include_spip("inc/filtres_images_mini");
		$i = inserer_attribut(image_reduire("$dir/$i", 32),'alt','');
		$i = "<div class='icon'><a href='$url' rel='info'>$i</a></div>";
	} else $i = '';

return "<div class='resume'>"
	. "<h3><a href='$url' rel='info'>"
	. $nom
	. "</a></h3>"
	. " <span class='version'>".$info['version']."</span>"
	. " <span class='etat'> - "
	. plugin_etat_en_clair($info['etat'])
	. "</span>"
	. "<div class='short'>".$slogan."</div>"
	. $i
	. "</div>";
}

function plugin_desintalle($plug_file, $nom, $dir_plugins=null){
	if (!$dir_plugins)
		$dir_plugins = _DIR_PLUGINS;

$action = redirige_action_auteur('desinstaller_plugin',"$dir_plugins::$plug_file",'admin_plugin');
	$text = _T('bouton_desinstaller');
	$text2 = _T('info_desinstaller_plugin');
	$file = basename($plug_file);

return "<div class='actions'>[".
		"<a href='$action'
		onclick='return confirm(\"$text $nom ?\\n$text2\")'>"
		. $text
		. "</a>]</div>"	;
}

function plugin_etat_en_clair($etat){
	if (!in_array($etat,array('stable','test','experimental')))
		$etat = 'developpement';
	return _T('plugin_etat_'.$etat);
}

// http://doc.spip.org/@plugin_propre
function plugin_propre($texte, $module='') {
	// retirer le retour a la racine du module, car le find_in_path se fait depuis la racine
	if (_DIR_RACINE AND strncmp($module,_DIR_RACINE,strlen(_DIR_RACINE))==0)
		$module = substr($module,strlen(_DIR_RACINE));
	if (preg_match("|^\w+_[\w_]+$|", $texte)) {
		$texte = _T(($module ? "$module:" : '') . $texte, array(), array('force' => false));
	}
	return propre($texte);
}

// http://doc.spip.org/@affiche_bloc_plugin
function affiche_bloc_plugin($plug_file, $info, $dir_plugins=null) {
	if (!$dir_plugins)
		$dir_plugins = _DIR_PLUGINS;

$prefix = $info['prefix'];
	$dir = "$dir_plugins$plug_file/lang/paquet-$prefix";

$s = "";
	// TODO: le traiter_multi ici n'est pas beau
	// cf. description du plugin/_stable_/ortho/plugin.xml
	$description = "";
	if (isset($info['description']))
		$description = plugin_propre($info['description'], $dir);

if (isset($info['documentation'])
	  AND $lien = $info['documentation']){
		$description .= "<p><em class='site'><a href='$lien' class='spip_out'>" . _T('en_savoir_plus') .'</a></em></p>';
	}
	$s .= "<dd class='desc'>".$description."</dd>\n";

if (isset($info['auteur'])){
		if (is_array($info['auteur']))
			$a = formater_credits($info['auteur'], ', ');
		// pour compat mais ne doit plus arriver
		else
			$a = trim($info['auteur']);
		if ($a)
			$s .= "<dt class='auteurs'>" . _T('public:par_auteur') ."</dt><dd class='auteurs'>". PtoBR(propre($a, $dir)) . "</dd>\n";
	}

if (isset($info['credit'])){
		if ($a = formater_credits($info['credit'], ', '))
			$s .= "<dt class='credits'>" . _T('plugin_info_credit') ."</dt><dd class='credits'>". PtoBR(propre($a, $dir)) . "</dd>\n";
	}

if (isset($info['licence'])) {
		if (is_array($info['licence']))
			$a = formater_credits($info['licence'], ', ');
		// pour compat mais ne doit plus arriver
		else
			$a = trim($info['licence']);
	if ($a)
		$s .= "<dt class='licence'>" . _T('intitule_licence') ."</dt><dd class='licence'>". PtoBR(propre($a, $dir)) . "</dd>\n";
	}

$s = "<dl class='description'>$s</dl>";

//
	// Ajouter les infos techniques
	//
	$infotech = array();

$version = "<dt>"._T('version')."</dt><dd>".$info['version'];
	// Version SVN
	if ($svn_revision = version_svn_courante($dir_plugins.$plug_file))
		$version .= ($svn_revision<0 ? ' SVN':'').' ['.abs($svn_revision).']';
	$version .="</dd>";
	$infotech[] = $version;
	$infotech[] = "<dt>"._T('repertoire_plugins')."</dt><dd>".joli_repertoire("$dir_plugins$plug_file")."</dd>";
	// source zip le cas echeant
	$infotech[] = (lire_fichier($dir_plugins.$plug_file.'/install.log', $log)
	AND preg_match(',^source:(.*)$,m', $log, $r))
		? '<dt>'._T('plugin_source').'</dt><dd>'.trim($r[1])."</dd>"
		:'';

$infotech[] = !$info['necessite'] ? '' :
	  ('<dt>' .  _T('plugin_info_necessite') . '</dt><dd>' . join(' ', array_map('array_shift', $info['necessite'])) . '</dd>');

$s .= "<dl class='tech'>"
		. join('', $infotech)
		."</dl>";

return $s;
}

function formater_credits($infos, $sep=', ') {
	$texte = '';

foreach ($infos as $_credit) {
		if ($texte)
			$texte .= $sep;
		// Si le credit en cours n'est pas un array c'est donc un copyright
		$texte .=
			(!is_array($_credit))
			? PtoBR(propre($_credit))
			: ($_credit['url'] ? '<a href="' . $_credit['url'] . '">' : '') .
			  $_credit['nom'] .
			  ($_credit['url'] ? '</a>' : '');
	}

return $texte;
}

?>
get_infos.php000066600000006151152502550330007241 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;

/**
 * lecture du fichier de configuration d'un plugin
 *
 * @staticvar string $filecache
 * @staticvar array $cache
 * @param string|array|bool $plug
 * @param bool $reload
 * @param string $dir
 * @return array
 */
function plugins_get_infos_dist($plug=false, $reload=false, $dir = _DIR_PLUGINS, $clean_old=false){
	static $cache='';
	static $filecache = '';

if ($cache===''){
		$filecache = _DIR_TMP."plugin_xml_cache.gz";
		if (is_file($filecache)){
			lire_fichier($filecache, $contenu);
			$cache = unserialize($contenu);
		}
		if (!is_array($cache)) $cache = array();
	}

if (defined('_VAR_MODE') AND _VAR_MODE=='recalcul')
		$reload = true;

if ($plug===false) {
		ecrire_fichier($filecache, serialize($cache));
		return $cache;
	}
	elseif (is_string($plug)) {
		$res = plugins_get_infos_un($plug, $reload, $dir, $cache);
	}
	elseif (is_array($plug)) {
		$res = false;
		if (!$reload) $reload = -1;
		foreach($plug as $nom)
		  $res |= plugins_get_infos_un($nom, $reload, $dir, $cache);
		// Nettoyer le cache des vieux plugins qui ne sont plus la
		if ($clean_old and count($cache[$dir])) {
			foreach (array_keys($cache[$dir]) as $p) {
				if (!in_array($p,$plug)) {
					unset($cache[$dir][$p]);
				}
			}
		}
	}
	if ($res) {
		ecrire_fichier($filecache, serialize($cache));
	}
	if (!isset($cache[$dir])) {
		return array();
	}
	return is_string($plug) ? $cache[$dir][$plug] : $cache[$dir];
}

function plugins_get_infos_un($plug, $reload, $dir, &$cache)
{
	if (!is_readable($file = "$dir$plug/" . ($desc = "paquet") . ".xml")) {
	  if (!is_readable($file = "$dir$plug/" . ($desc = "plugin") . ".xml"))
	    return false;
	}

if (($time = intval(@filemtime($file))) < 0) return false;
	$md5 = md5_file($file);

$pcache = isset($cache[$dir][$plug]) 
	  ? $cache[$dir][$plug] : array('filemtime' => 0, 'md5_file' => '');

// si le cache est valide
	if ((intval($reload) <= 0)
		AND ($time > 0)
		AND ($time <= $pcache['filemtime'])
	  AND $md5==$pcache['md5_file'])
		return false;

// si on arrive pas a lire le fichier, se contenter du cache
	if (!($texte = spip_file_get_contents($file))) {
		return false;
	}

$f = charger_fonction('infos_' . $desc, 'plugins');
	$ret = $f($texte, $plug, $dir);
	$ret['filemtime'] = $time;
	$ret['md5_file'] = $md5;
	$diff = ($ret != $pcache);

if ($diff) {
		$cache[$dir][$plug] = $ret;
#		echo count($cache[$dir]), $dir,$plug, " $reloadc<br>"; 
	}
	return $diff;
}
?>
afficher_repertoires.php000066600000007242152502550330011460 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;

// http://doc.spip.org/@affiche_arbre_plugins
function plugins_afficher_repertoires_dist($url_page, $liste_plugins, $liste_plugins_actifs){
	$ligne_plug = charger_fonction('afficher_plugin','plugins');
	$racine = basename(_DIR_PLUGINS);
	$init_dir = $current_dir = "";
	// liste des repertoires deplies : construit en remontant l'arbo de chaque plugin actif
	// des qu'un path est deja note deplie on s'arrete
	$deplie = array($racine=>true);
	$fast_liste_plugins_actifs=array();
	foreach($liste_plugins_actifs as $key=>$plug){
		$chemin_plug = chemin_plug($racine, $plug);
		$fast_liste_plugins_actifs[$chemin_plug]=true;
		$dir = dirname($chemin_plug);$maxiter=100;
		while(strlen($dir) && !isset($deplie[$dir]) && $dir!=$racine && $maxiter-->0){
			$deplie[$dir] = true;
			$dir = dirname($dir);
		}
	}

// index repertoires --> plugin
	$dir_index=array();
	foreach($liste_plugins as $key=>$plug){
		$liste_plugins[$key] = chemin_plug($racine, $plug);
		$dir_index[dirname($liste_plugins[$key])][] = $key;
	}

$visible = @isset($deplie[$current_dir]);
	$maxiter=1000;

$res = '';
	while (count($liste_plugins) && $maxiter--){
		// le rep suivant
		$dir = dirname(reset($liste_plugins));
		if ($dir != $current_dir)
			$res .= tree_open_close_dir($current_dir,$dir,$deplie);

// d'abord tous les plugins du rep courant
		if (isset($dir_index[$current_dir]))
			foreach($dir_index[$current_dir] as $key){
				$plug = $liste_plugins[$key];
				$actif = @isset($fast_liste_plugins_actifs[$plug]);
				$id = substr(md5($plug),0,16);
				$res .= $ligne_plug($url_page, str_replace(_DIR_PLUGINS, '', _DIR_RACINE.$plug), $actif, 'menu-entree') . "\n";
				unset($liste_plugins[$key]);
			}
	}
	$res .= tree_open_close_dir($current_dir,$init_dir, true);

return "<ul class='menu-liste plugins'>"
	. $res
	. "</ul>";
}

// vraiment n'importe quoi la gestion des chemins des plugins
// une fonction pour aider...
// http://doc.spip.org/@chemin_plug
function chemin_plug($racine, $plug) {
	return preg_replace(',[^/]+/\.\./,', '', "$racine/$plug");
}

// http://doc.spip.org/@tree_open_close_dir
function tree_open_close_dir(&$current,$target,$deplie=array()){
	if ($current == $target) return "";
	$tcur = explode("/",$current);
	$ttarg = explode("/",$target);
	$tcom = array();
	$output = "";
	// la partie commune
	while (reset($tcur)==reset($ttarg)){
		$tcom[] = array_shift($tcur);
		array_shift($ttarg);
	}
	// fermer les repertoires courant jusqu'au point de fork
	while($close = array_pop($tcur)){
		$output .= "</ul>\n";
		$output .= fin_block();
		$output .= "</li>\n";
	}
	$chemin = "";
	if (count($tcom))
		$chemin .= implode("/",$tcom)."/";
	// ouvrir les repertoires jusqu'a la cible
	while($open = array_shift($ttarg)){
		$visible = @isset($deplie[$chemin.$open]);
		$chemin .= $open . "/";
		$output .= "<li>";
		$output .= bouton_block_depliable($chemin,$visible);
		$output .= debut_block_depliable($visible);

$output .= "<ul>\n";
	}
	$current = $target;
	return $output;
}

?>
extraire_pipelines.php000066600000002435152502550330011160 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;

/**
 * Extraire les infos de pipeline
 *
 * @param array $arbre
 */
function plugins_extraire_pipelines_dist(&$arbre){
	$pipeline = array();
	if (spip_xml_match_nodes(',^pipeline,',$arbre,$pipes)){
		foreach($pipes as $tag=>$p){
			if (!is_array($p[0])){
				list($tag,$att) = spip_xml_decompose_tag($tag);
				$pipeline[] = $att;
			}
			else foreach($p as $pipe){
				$att = array();
				if (is_array($pipe))
					foreach($pipe as $k=>$t)
						$att[$k] = trim(end($t));
				$pipeline[] = $att;
			}
		}
		unset($arbre[$tag]);
	}

return $pipeline;
}

?>
afficher_nom_plugin.php000066600000004251152502550330011261 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;
include_spip('inc/charsets');
include_spip('inc/texte');
include_spip('plugins/afficher_plugin');

// http://doc.spip.org/@ligne_plug
function plugins_afficher_nom_plugin_dist($url_page, $plug_file, $checked, $actif, $expose=false, $class_li="item", $dir_plugins=_DIR_PLUGINS){
	static $id_input=0;
	static $versions = array();

$erreur = false;
	$s = "";

$get_infos = charger_fonction('get_infos','plugins');
	$info = $get_infos($plug_file, false, $dir_plugins);

// numerotons les occurences d'un meme prefix
	$versions[$info['prefix']] = isset($versions[$info['prefix']]) ? $versions[$info['prefix']] + 1 : '';
	$id = $info['prefix'] . $versions[$info['prefix']];
	
	$class = $class_li;
	$class .= $actif?" actif":"";
	$class .= $expose?" on":"";
	$erreur = isset($info['erreur']);
	if ($erreur)
		$class .= " error";
	$s .= "<li id='$id' class='$class'>";

// Cartouche Resume
	$s .= "<div class='resume'>";

$prefix = $info['prefix'];
	$dir = "$dir_plugins$plug_file/lang/$prefix";
	$desc = plugin_propre($info['description'], $dir);
	$url_stat = parametre_url($url_page, "plugin",$dir_plugins.$plug_file);

$s .= "<strong class='nom'>".typo($info['nom'])."</strong>";
	$s .= " <span class='version'>".$info['version']."</span>";
	$s .= " <span class='etat'> - ".plugin_etat_en_clair($info['etat'])."</span>";
	$s .= "</div>";

if ($erreur){
		$s .= "<div class='erreur'>" . join('<br >', $info['erreur']) . "</div>";
	}

$s .= "</li>";
	return $s;
}

?>
extraire_boutons.php000066600000003733152502550330010663 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;

/**
 * Analyser un arbre xml et extraire les infos concernant les boutons et onglets
 *
 * @param <type> $arbre
 * @return <type> 
 */
function plugins_extraire_boutons_dist($arbre){
	$ret = array('bouton'=>array(),'onglet'=>array());
	// recuperer les boutons et onglets si necessaire
	spip_xml_match_nodes(",^(bouton|onglet)\s,",$arbre,$les_boutons);
	if (is_array($les_boutons) && count($les_boutons)){
		$ret['bouton'] = array();
		$ret['onglet'] = array();
		foreach($les_boutons as $bouton => $val) {
			$bouton = spip_xml_decompose_tag($bouton);
			$type = reset($bouton);
			$bouton = end($bouton);
			if (isset($bouton['id'])){
				$id = $bouton['id'];
				$val = reset($val);
				if(is_array($val)){
					$ret[$type][$id]['parent'] = isset($bouton['parent'])?$bouton['parent']:'';
					$ret[$type][$id]['position'] = isset($bouton['position'])?$bouton['position']:'';
					$ret[$type][$id]['titre'] = isset($val['titre'])?trim(spip_xml_aplatit($val['titre'])):'';
					$ret[$type][$id]['icone'] = isset($val['icone'])?trim(end($val['icone'])):'';
					$ret[$type][$id]['action'] = isset($val['url'])?trim(end($val['url'])):'';
					$ret[$type][$id]['parametres'] = isset($val['args'])?trim(end($val['args'])):'';
				}
			}
		}
	}
	return $ret;
}

?>
infos_paquet.php000066600000024423152502550330007763 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;

/**
 * lecture d'un texte conforme a la DTD paquet.dtd
 * et conversion en tableau PHP identique a celui fourni par plugin.xml
 * manque la description
 *
 * @param $desc
 * @param string $plug
 * @param string $dir_plugins
 * @return array
 */
function plugins_infos_paquet($desc, $plug = '', $dir_plugins = _DIR_PLUGINS) {
	static $process = array( // tableau constant
		'debut' => 'paquet_debutElement',
		'fin' => 'paquet_finElement',
		'text' => 'paquet_textElement'
	);

$valider_xml = charger_fonction('valider', 'xml');
	$vxml = $valider_xml($desc, false, $process, 'paquet.dtd', "utf-8");
	if (!$vxml->err){
		// On veut toutes les variantes selon la version de SPIP
		if (!$plug)
			return $vxml->versions;

// compatibilite avec l'existant:
		$tree = $vxml->versions['0'];

// l'arbre renvoie parfois un tag vide... etrange. Pas la peine de garder ca.
		if (isset($tree['']) and !strlen($tree['']))
			unset($tree['']);

$tree['slogan'] = $tree['prefix']."_slogan";
		$tree['description'] = $tree['prefix']."_description";
		paquet_readable_files($tree, "$dir_plugins$plug/");
		if (!$tree['chemin'])
			$tree['chemin'] = array(array('path' => '')); // initialiser par defaut

// On verifie qu'il existe des balises spip qu'il faudrait rajouter dans
		// la structure d'infos du paquet en fonction de la version spip courante
		if (count($vxml->versions) > 1) {
			$vspip = $GLOBALS['spip_version_branche'];
			foreach ($vxml->versions as $_compatibilite => $_version) {
				if (($_version['balise'] == 'spip')
				AND (plugin_version_compatible($_compatibilite, $vspip,'spip'))) {
					// on merge les sous-balises de la balise spip compatible avec celles de la
					// balise paquet
					foreach ($_version as $_index => $_balise) {
						if ($_index AND $_index != 'balise')
							$tree[$_index] =array_merge($tree[$_index], $_balise);
					}
				}
			}
		}

return $tree;
	}
	// Prendre les messages d'erreur sans les numeros de lignes
	$msg = array_map('array_shift', $vxml->err);
	// Construire le lien renvoyant sur l'application du validateur XML 
	$h = $GLOBALS['meta']['adresse_site'].'/'
	     .substr("$dir_plugins$plug/", strlen(_DIR_RACINE)).'paquet.xml';

$h = generer_url_ecrire('valider_xml', "var_url=$h");
	$t = _T('plugins_erreur', array('plugins' => $plug));
	array_unshift($msg, "<a href='$h'>$t</a>");
	return array('erreur' => $msg);
}

/**
 * Verifier le presence des fichiers remarquables
 * options/actions/administrations et peupler la description du plugin en consequence
 *
 * @param array $tree
 * @param string $dir
 * @return void
 */
function paquet_readable_files(&$tree, $dir){
	$prefix = strtolower($tree['prefix']);

$tree['options'] = (is_readable($dir.$f = ($prefix.'_options.php'))) ? array($f) : array();
	$tree['fonctions'] = (is_readable($dir.$f = ($prefix.'_fonctions.php'))) ? array($f) : array();
	$tree['install'] = (is_readable($dir.$f = ($prefix.'_administrations.php'))) ? array($f) : array();
}

/**
 * Appeler le validateur, qui memorise le texte dans le tableau "versions"
 * On  memorise en plus dans les index de numero de version de SPIP
 * les attributs de la balise rencontree
 * qu'on complete par des entrees nommees par les sous-balises de "paquet",
 * et initialisees par un tableau vide, rempli a leur rencontre.
 * La sous-balise "spip", qui ne peut apparaitre qu'apres les autres,
 * reprend les valeurs recuperees precedement (valeurs par defaut)
 *
 * @param object $phraseur
 * @param string $name
 * @param array $attrs
 */
function paquet_debutElement($phraseur, $name, $attrs) {
	xml_debutElement($phraseur, $name, $attrs);
	if ($phraseur->err) return;
	if (($name=='paquet') OR ($name=='spip')){
		if ($name=='spip'){
			$n = $attrs['compatibilite'];
			$attrs = array();
		}
		else {
			$n = '0';
			$phraseur->contenu['paquet'] = $attrs;
			$attrs['menu'] = array();
			$attrs['chemin'] = array();
			$attrs['necessite'] = array();
			$attrs['lib'] = array();
			$attrs['onglet'] = array();
			$attrs['procure'] = array();
			$attrs['pipeline'] = array();
			$attrs['utilise'] = array();
		}
		$phraseur->contenu['compatible'] = $n;
		$phraseur->versions[$phraseur->contenu['compatible']] = $attrs;
	}
	else
		$phraseur->versions[$phraseur->contenu['compatible']][$name][0] = $attrs;
	$phraseur->versions[$phraseur->contenu['compatible']][''] = '';
}

/**
 * Appeler l'indenteur pour sa gestion de la profondeur,
 * et memoriser les attributs dans le tableau avec l'oppose de la profondeur
 * comme index, avec '' comme sous-index (les autres sont les attributs)
 *
 * @param pbject $phraseur
 * @param string $data
 */
function paquet_textElement($phraseur, $data) {
	xml_textElement($phraseur, $data);
	if ($phraseur->err OR !(trim($data))) return;
	$phraseur->versions[$phraseur->contenu['compatible']][''] .= $data;
}

/**
 * Si on sait deja que le texte n'est pas valide on ne fait rien.
 * Pour une balise sans attribut, le traitement est forcement toujours le meme.
 * Pour une balise sans texte, idem mais parce que la DTD est bien fichue
 *
 * @param object $phraseur
 * @param string $name
 */
function paquet_finElement($phraseur, $name) {
	if ($phraseur->err) return;
	$n = $phraseur->contenu['compatible'];

if (isset($phraseur->versions[$n][$name][0]) AND is_array($phraseur->versions[$n][$name][0])){
		$attrs = $phraseur->versions[$n][$name][0];
		unset($phraseur->versions[$n][$name][0]);
	} else {
		$attrs = array();
	}

$texte = trim($phraseur->versions[$n]['']);
	$phraseur->versions[$n][''] = '';

$f = 'info_paquet_'.$name;
	if (function_exists($f))
		$f($phraseur, $attrs, $texte);
	elseif (!$attrs)
		$phraseur->versions[$n][$name] = $texte;
	else {
		// Traitement generique. Si $attrs['nom'] n'existe pas, ce n'est pas normal ici
		$phraseur->versions[$n][$name][$attrs['nom']] = $attrs;
		#	  echo("<br>pour $name $n " . $attrs['nom']); var_dump($phraseur->versions[$n]);
	}
	xml_finElement($phraseur, $name, $attrs);
}

/**
 * Cas particulier de la balise licence :
 * transformer en lien sur url fournie dans l'attribut lien
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
 */
function info_paquet_licence($phraseur, $attrs, $texte) {
	if (isset($attrs['lien']))
		$lien = $attrs['lien'];
	else
		$lien = '';
	$n = $phraseur->contenu['compatible'];
	$phraseur->versions[$n]['licence'][] = array('nom' => $texte, 'url' => $lien);
}

/**
 * Cas particulier de la balise chemin :
 * stocker un tableau
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
 */
function info_paquet_chemin($phraseur, $attrs, $texte) {
	$n = $phraseur->contenu['compatible'];
	if (isset($attrs['path'])){
		if (isset($attrs['type']))
			$phraseur->versions[$n]['chemin'][] = array('path' => $attrs['path'], 'type' => $attrs['type']);
		else
			$phraseur->versions[$n]['chemin'][] = array('path' => $attrs['path']);
	}
}

/**
 * Cas particulier de la balise auteur
 * peupler le mail si besoin (en le protegeant, mais est-ce bien la place pour cela ?)
 * et le lien vers le site de l'auteur si fournit
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
 */
function info_paquet_auteur($phraseur, $attrs, $texte) {
	#  echo 'auteur ', $texte;  var_dump($attrs);
	if (isset($attrs['mail'])){
		if (strpos($attrs['mail'], '@'))
			$attrs['mail'] = str_replace('@', ' AT ', $attrs['mail']);
		$mail = $attrs['mail'];
	}
	else
		$mail = '';

if (isset($attrs['lien']))
		$lien = $attrs['lien'];
	else
		$lien = '';

$n = $phraseur->contenu['compatible'];
	$phraseur->versions[$n]['auteur'][] = array('nom' => $texte, 'url' => $lien, 'mail' => $mail);
}

/**
 * Cas particulier de la balise credit
 * peupler le lien vers le site externe si necessaire
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
 */
function info_paquet_credit($phraseur, $attrs, $texte) {

if (isset($attrs['lien']))
		$lien = $attrs['lien'];
	else
		$lien = '';

$n = $phraseur->contenu['compatible'];
	$phraseur->versions[$n]['credit'][] = array('nom' => $texte, 'url' => $lien);
}

/**
 * Cas particulier de la balise copyright :
 * transformer en lien sur url fournie dans l'attribut lien
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
 */
function info_paquet_copyright($phraseur, $attrs, $texte) {
	$n = $phraseur->contenu['compatible'];
	$phraseur->versions[$n]['copyright'][] = $texte;
}

/**
 * Cas particulier de la balise paquet :
 * Remplacer cet index qui ne sert a rien par un index balise=paquet et ajouter la reference a la dtd
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
 */
function info_paquet_paquet($phraseur, $attrs, $texte) {
	$n = 0;
	$phraseur->versions[$n]['dtd'] = "paquet";
	$phraseur->versions[$n]['balise'] = "paquet";
}

/**
 * Cas particulier sur la balise traduire :
 * Elle n'a pas de 'nom' 
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
**/
function info_paquet_traduire($phraseur, $attrs, $texte) {
	$n = $phraseur->contenu['compatible'];
	$phraseur->versions[$n]['traduire'][] = $attrs;
}

/**
 * Cas particulier de la balise spip :
 * Remplacer cet index qui ne sert a rien par un index balise=spip et ajouter la reference a la dtd
 *
 * @param object $phraseur
 * @param array $attrs
 * @param string $texte
 */
function info_paquet_spip($phraseur, $attrs, $texte) {
	$n = $phraseur->contenu['compatible'];
	$phraseur->versions[$n]['balise'] = "spip";
}

/**
 * Pipelines : plusieurs declarations possibles pour un meme pipeline
 *
 * @param $phraseur
 * @param $attrs
 * @param $texte
 */
function info_paquet_pipeline($phraseur, $attrs, $texte) {
	$n = $phraseur->contenu['compatible'];
	$phraseur->versions[$n]['pipeline'][] = $attrs;
}

?>
afficher_liste.php000066600000007557152502550330010246 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;
include_spip('inc/charsets');

/**
 * Afficher une liste de plugins dans l'interface
 * http://doc.spip.org/@affiche_liste_plugins
 *
 * @param string $url_page
 * @param array $liste_plugins
 * @param array $liste_plugins_checked
 * @param array $liste_plugins_actifs
 * @param string $dir_plugins
 * @param string $afficher_un
 * @return string
 */
function plugins_afficher_liste_dist($url_page,$liste_plugins, $liste_plugins_checked, $liste_plugins_actifs, $dir_plugins=_DIR_PLUGINS,$afficher_un = 'afficher_plugin'){
	$get_infos = charger_fonction('get_infos','plugins');
	$ligne_plug = charger_fonction($afficher_un,'plugins');

$all_infos = $get_infos($liste_plugins, false, $dir_plugins);

$all_infos = pipeline('filtrer_liste_plugins',
	                     array(
											  'args'=>array(
		                      'liste_plugins'=>$liste_plugins,
		                      'liste_plugins_checked'=>$liste_plugins_checked,
		                      'liste_plugins_actifs'=>$liste_plugins_actifs,
		                      'dir_plugins'=>$dir_plugins),
												'data'=>$all_infos
	                     )
							);

$liste_plugins = array_flip($liste_plugins);
	foreach($liste_plugins as $chemin => $v) {
		// des plugins ont pu etre enleves de la liste par le pipeline. On en tient compte.
		if (isset($all_infos[$chemin])){
			$liste_plugins[$chemin] = strtoupper(trim(typo(translitteration(unicode2charset(html2unicode($all_infos[$chemin]['nom']))))));
		}
		else {
			unset($liste_plugins[$chemin]);
		}
	}
	asort($liste_plugins);
	$exposed = urldecode(_request('plugin'));

$block_par_lettre = false;//count($liste_plugins)>10;
	$fast_liste_plugins_actifs = array();
	$fast_liste_plugins_checked = array();
	if (is_array($liste_plugins_actifs))
		$fast_liste_plugins_actifs = array_flip($liste_plugins_actifs);
	if (is_array($liste_plugins_checked))
		$fast_liste_plugins_checked = array_flip($liste_plugins_checked);

$res = '';
	$block = '';
	$initiale = '';
	$block_actif = false;
	foreach($liste_plugins as $plug => $nom){
		if (($i=substr($nom,0,1))!==$initiale){
			$res .= $block_par_lettre ? affiche_block_initiale($initiale,$block,$block_actif): $block;
			$initiale = $i;
			$block = '';
			$block_actif = false;
		}
		// le rep suivant
		$actif = isset($fast_liste_plugins_actifs[$plug]);
		$checked = isset($fast_liste_plugins_checked[$plug]);
		$block_actif = $block_actif | $actif;
		$expose = ($exposed AND ($exposed==$plug OR $exposed==$dir_plugins . $plug OR $exposed==substr($dir_plugins,strlen(_DIR_RACINE)) . $plug));
		$block .= $ligne_plug($url_page, $plug, $checked, $actif, $expose, "item", $dir_plugins)."\n";
	}
	$res .= $block_par_lettre ? affiche_block_initiale($initiale,$block,$block_actif): $block;
	$class = basename($dir_plugins);
	return $res ? "<ul class='liste-items plugins $class'>$res</ul>" : "";
}

// http://doc.spip.org/@affiche_block_initiale
function affiche_block_initiale($initiale,$block,$block_actif){
	if (strlen($block)){
		return "<li class='item'>"
		  . bouton_block_depliable($initiale,$block_actif?true:false)
		  . debut_block_depliable($block_actif)
		  . "<ul>$block</ul>"
		  . fin_block()
		  . "</li>";
	}
	return "";
}

?>
installer.php000066600000015014152502550330007257 0ustar00<?php

if (!defined('_ECRIRE_INC_VERSION')) return;

/**
 * Installe ou retire un plugin
 * 
 * Fonction surchargeable permettant d'installer ou retirer un plugin
 * en incluant les fichiers associes et en lancant les fonctions specifiques
 * 1. d'abord sur l'argument 'test',
 * 2. ensuite sur l'action demandee si le test repond False
 * 3. enfin sur l'argument 'test' a nouveau.
 * l'index install_test du tableau resultat est un tableau forme:
 *  - du resultat 3 
 *  - des Echo de l'etape 2
 *
 * @param string $plug, nom du plugin
 * @param string $action, nom de l'action (install|uninstall)
 * @param string $dir_type, repertoire du plugin
 * 
 * @return array|boolean True si deja installe, le tableau de get_infos sinon
 *
 */
function plugins_installer_dist($plug, $action, $dir_type='_DIR_PLUGINS')
{
	$get_infos = charger_fonction('get_infos','plugins');
	$infos = $get_infos($plug, false, constant($dir_type));
	if (!isset($infos['install']) OR !$infos['install']) return false;
	// passer en chemin absolu si possible, c'est plus efficace
	$dir = str_replace('_DIR_','_ROOT_',$dir_type);
	if (!defined($dir)) $dir = $dir_type;
	$dir = constant($dir);
	foreach($infos['install'] as $file) {
		$file = $dir . $plug . "/" . trim($file);
		if (file_exists($file)){
			include_once($file);
		}
	}
	$version = isset($infos['schema'])?$infos['schema']:'';
	$arg = $infos ;
	$f = $infos['prefix']."_install";
	if (!function_exists($f))
		$f = isset($infos['schema']) ? 'spip_plugin_install' : '';
	else
		$arg = $infos['prefix']; // stupide: info deja dans le nom

if (!$f) {
		// installation sans operation particuliere
		$infos['install_test'] = array(true, '');
		return $infos; 
	}
	$test = $f('test', $arg, $version);
	if ($action == 'uninstall') $test = !$test;
	// Si deja fait, on ne dit rien
	if ($test)  return true;
	// Si install et que l'on a la meta d'installation, c'est un upgrade
	if($action == 'install' && !is_null(lire_meta($infos['prefix'].'_base_version')))
		$infos['upgrade'] = true;

// executer l'installation ou l'inverse
	// et renvoyer la trace (mais il faudrait passer en AJAX plutot)
	ob_start(); 
	$f($action, $arg, $version);
	$aff = ob_get_contents(); 
	ob_end_clean();
	// vider le cache des descriptions de tables a chaque (de)installation
	$trouver_table = charger_fonction('trouver_table', 'base');
	$trouver_table('');
	$infos['install_test'] = array($f('test', $arg, $version), $aff);
	return $infos;
}

// Fonction par defaut pour install/desinstall

// http://doc.spip.org/@spip_plugin_install
function spip_plugin_install($action, $infos, $version_cible){
	$prefix = $infos['prefix'];
	if (isset($infos['meta']) AND (($table = $infos['meta']) !== 'meta'))
		$nom_meta = "base_version";
	else {  
		$nom_meta = $prefix."_base_version";
		$table = 'meta';
	}
	switch ($action){
		case 'test':
			return  (isset($GLOBALS[$table])
			AND isset($GLOBALS[$table][$nom_meta]) 
			AND spip_version_compare($GLOBALS[$table][$nom_meta],$version_cible,'>='));
			break;
		case 'install':
			if (function_exists($upgrade = $prefix."_upgrade"))
				$upgrade($nom_meta, $version_cible, $table);
			break;
		case 'uninstall':
		  if (function_exists($vider_tables = $prefix."_vider_tables"))
				$vider_tables($nom_meta, $table);
			break;
	}
}

/**
 * Compare 2 numeros de version entre elles.
 * 
 * Cette fonction est identique (arguments et retours) a la fonction PHP
 * version_compare() qu'elle appelle. Cependant, cette fonction reformate
 * les numeros de versions pour ameliorer certains usages dans SPIP ou bugs
 * dans PHP. On permet ainsi de comparer 3.0.4 à 3.0.* par exemple.
 * 
 * @param string $v1
 * 		Numero de version servant de base a la comparaison.
 * 		Ce numero ne peut pas comporter d'etoile.
 * @param string $v2
 * 		Numero de version a comparer.
 * 		Il peut posseder des etoiles tel que 3.0.*
 * @param string $op
 * 		Un operateur eventuel (<, >, <=, >=, =, == ...)
 * @return int|bool
 * 		Sans operateur : int. -1 pour inferieur, 0 pour egal, 1 pour superieur
 * 		Avec operateur : bool. 
**/
function spip_version_compare($v1,$v2,$op=null){
	$v1 = strtolower(preg_replace(',([0-9])[\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i','\\1.\\2',$v1));
	$v2 = strtolower(preg_replace(',([0-9])[\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i','\\1.\\2',$v2));
	$v1 = str_replace('rc','RC',$v1); // certaines versions de PHP ne comprennent RC qu'en majuscule
	$v2 = str_replace('rc','RC',$v2); // certaines versions de PHP ne comprennent RC qu'en majuscule

$v1 = explode('.',$v1);
	$v2 = explode('.',$v2);
	// $v1 est toujours une version, donc sans etoile
	while (count($v1)<count($v2))
		$v1[] = '0';

// $v2 peut etre une borne, donc accepte l'etoile
	$etoile = false;
	foreach ($v1 as $k => $v) {
		if (!isset($v2[$k]))
			$v2[] = ($etoile AND (is_numeric($v) OR $v=='pl' OR $v=='p')) ? $v : '0';
		else if ($v2[$k] == '*') {
			$etoile = true;
			$v2[$k] = $v;
		}
	}
	$v1 = implode('.',$v1);
	$v2 = implode('.',$v2);

return $op?version_compare($v1, $v2,$op):version_compare($v1, $v2);
}

// Cette fonction retourne la meta "plugin" deserialisee
// mais en fait une mise a jour qui aurait du intervenir au chgt de version
// http://doc.spip.org/@liste_plugin_actifs
function liste_plugin_actifs(){
	$liste = isset($GLOBALS['meta']['plugin'])?$GLOBALS['meta']['plugin']:'';
	if (!$liste) return array();
  	if (!is_array($liste=unserialize($liste))) {
		// compatibilite pre 1.9.2, mettre a jour la meta
		spip_log("MAJ meta plugin vieille version : $liste","plugin");
		$new = true;
		list(, $liste) = liste_plugin_valides(explode(",",$liste));
	} else {
		$new = false;
		// compat au moment d'une migration depuis version anterieure
		// si pas de dir_type, alors c'est _DIR_PLUGINS
		foreach ($liste as $prefix=>$infos) {
			if (!isset($infos['dir_type'])) {
				$liste[$prefix]['dir_type'] = "_DIR_PLUGINS";
				$new = true;
			}
		}
	}
	if ($new) ecrire_meta('plugin',serialize($liste));
	return $liste;
}

/home/etiennec/www/b9da6/../prive/../f1f54/./plugins.tar