[PHP] Standaard global waarde probleem

[Scyth]

Ik ben, zoals velen, begonnen aan een eigen Content Management System.

Nu zit ik echter met het probleem van locaties van eventuele includes.

Er zijn verschillende 'plug ins' die functionaliteit aan het geheel verlenen.
Een daarvan is bijvoorbeeld de php waarin de login routines zitten, en een skinning class.
Beide zijn at will weg te laten, maar dan boet je dus in op functionaliteit.

De te laden plugins wil ik eigenlijk kunnen bepalen in een standaard include aan het begin van elke php die uiteindelijk content gaat renderen. Logisch in dit geval.

Twee vraagjes nu:
1. Hoe kan ik de functionaliteit van verschillende plugins (dus functions in classes) via een andere class laten verlopen?
Ik heb gezocht op de PHP online documentation, en eigenlijk staat alleen bij PHP4 netjes de 'extend' optie van classes uitgelegd. Volg ik die stappen daarentegen:
- Ik zet in de plugins 'extends config' achter de classdef
- Ik include de plugins in de config
... krijg ik een foutmelding dat hij niet kan includen omdat hij niet een class kan instantieren of iets dergelijks. Iemand een iedee wat ik fout doe?
2. Hoe kan ik van de énige include bovenaan een dynamische include maken?
Bovenaan elke php die output levert, staat de 'include_once($path.'config.php');' regel. $path echter, staat in de config file. Is er een mogelijkheid dat ik deze config kan voorzien van een dynamisch pad? (zodat als ik de CMS op een andere host pleur, dat ik niet 30+ php's aan hoef te passen omdat mijn path niet meer klopt) Of moet ik in dit geval met relative paths gaan werken (waardoor je vast zit aan een directory structuur).

De eerste vraag van mij zal vast een n00b vraag zijn, en ik kijk vast over iets heen, de tweede echter, lijkt mij iets moeilijker.

Ik hoop dat jullie mij van antwoorden kunnen voorzien!

[Verwijderd]

Vraag1:

Een array met plugin objecten, die array is dan aan attribuut van de klasse waar je die plugins gebruikt.

Vraag2:

Met $_SERVER, realpath() of dirname(__FILE__)...

Je kunt het beste constanten maken met absolute paden.

dus:

PHP:

define('PATH_ROOT', dirname(__FILE__) . DIRECTORY_SEPARATOR);

[ Voor 68% gewijzigd door Verwijderd op 07-09-2005 23:18 ]

[Scyth]

code:

require_once ($_SERVER['DOCUMENT_ROOT'].'/includes/config.php');

werkt opzich goed genoeg, daar de CMS van mij geen rekening hoeft te houden met een ontbrekende includes directory. Of is er een mogelijkheid dat $_SERVER['DOCUMENT_ROOT'] een foutieve root geeft?

En ik begrijp je antwoord op vraag 1 nog niet helemaal, maar een array van plugins staat me wel aan. Ga me er in verdiepen!

[Verwijderd]

Ok, (erg) simpel voorbeeldje.

PHP:

# Array om aan te geven welke plugins je wil gebruiken
$aPlugins = array('plugin1', 'plugin2', 'plugin3');

# Klasse maken
include 'class.blaat.php';

$oBlaat = new blaat;

# Array met plugin objecten maken
foreach( $aPlugins as $sPlugin_naam )
{
 include './class.' . $sPlugin_naam . '.php';
  
 $oBlaat->aPlugin_object[$sPlugin_naam] = new $sPlugin_naam;
}

Pas op, dit script kan veiliger

[Scyth]

Dis is dus in principe hetzelfde als nieuwe plugin objecten aanmaken in de main class die je in elke php include. Met het verschil dan, dat je bij deze versie kan selecteren welke plugins je wil laden. Nice. Tho, ik snap niet hoe ik een plugin kan benaderen in een class waarin een plugin verwerkt is.

PHP:

$oBlaat->connect->query('SELECT .... blaat')

werkt toch niet? Daar komt bij dat ik eigenlijk niet de hele $oBlaat main class voor ieder gebruik van een plugin wil hebben.

Misschien wil ik wel te veel

[ Voor 23% gewijzigd door Scyth op 08-09-2005 00:06 ]

[Michali]

Het is de bedoeling bij plugins dat ze in princiepe geheel op zich zelf staan. Als andere delen echt afhankelijk van een plugin zijn, dan zou ik er geen plugin van maken, maar hem gewoon altijd beschikbaar maken.

[Scyth]

Michali schreef op donderdag 08 september 2005 @ 08:00:
Het is de bedoeling bij plugins dat ze in princiepe geheel op zich zelf staan. Als andere delen echt afhankelijk van een plugin zijn, dan zou ik er geen plugin van maken, maar hem gewoon altijd beschikbaar maken.

Precies. Alleen hoe maak ik netjes een array oid van zeg maar de 'standaard plugins', zodat ik niet pér php een lijst van 8 regels code heb, voor alleen de includes en de def's ervan? SandStormer's idee is trouwens geweldig, alleen ik vat de aansturing ervan nog niet.

extend werkt dus niet, omdat slechts de functionaliteit van 1 class overgenomen kan worden hiermee, en ik heb geen flauw idee hoe ik dit moet doen:

redelijk psuedo:

PHP:

class common {
  require_once(oPlugIn1.php);
  require_once(oPlugIn2.php);
  require_once(oPlugIn3.php);
  require_once(oPlugIn4.php);
  oPlugIn1 = new oPlugIn1;
  oPlugIn2 = new oPlugIn2;
  oPlugIn3 = new oPlugIn3;
  oPlugIn4 = new oPlugIn4;
}

class main {
  require_once (common.php);
  $oArray = new common()
  $oArray->$oPlugIn1->*functie of variabele*  // DIT WERKT DUS NIET
}

[ Voor 6% gewijzigd door Scyth op 08-09-2005 14:02 ]

[Jerry]

Het werkt toch gewoon zo:

PHP:

$oCMS = new common();
$oArray = $oCMS->getPlugins();
$oPlugin1 = $oArray[0];
$oPlugin1->*functie of variable*

Er moet alleen een nieuwe functie in common zitten die de plugins ophaalt.
Overigens kan ik niet ontdekken of je dit in php4 of php5 doet, maar dit werkt met php5.

Bron: http://nl3.php.net/zend-engine-2.php - Eerste voorbeeld

[ Voor 21% gewijzigd door Jerry op 08-09-2005 16:13 ]

[Michali]

Waarom zou je er plugins van maken? Het is toch beter om ze direct beschikbaar te maken lijkt me? Anders zou je ook met een PluginMananger kunnen werken oid. Je zou dan met een config file kunnen aangeven welke plugins er beschikbaar zijn, en waar ze te includen zijn. Bij het voor het eerst opvragen van zo'n plugin zou je hem dan kunnen includen en instantieren. Je krijgt dan iets als dit:

PHP:

// dit staat in een config file
$plugins = array(
  'plugin1' => 'plugins/plugin1.php',
  'plugin2' => 'plugins/plugin2.php'
);

// en dit is dan een class die er gebruik van maakt
class PluginMananger
{
  var $plugins = array();
  
  function hasPlugin($name) { return isset($GLOBALS['plugins'][$name]); }

  function getPlugin($name)
  {
    if ( !$this->hasPlugin($name) ) die("Error: Plugin '" . $name . "' is niet gedefinieerd!");
    if ( !isset($this->plugins[$name]) )
    {
      require_once($GLOBALS['plugins'][$name]);
      $this->plugins[$name] = new $name;
    }
    return $this->plugins[$name];
  }

  function getAllDefinedPlugins()
  {
    return array_keys($GLOBALS['plugins']);
  }
}

Even snel, kijk maar wat je er mee doet.

[ Voor 26% gewijzigd door Michali op 08-09-2005 17:09 ]

[Oid]

[rml][ PHP] Modulaire Opzet[/rml]