Maj du code de l'exporter + du builder + gestion des dependences (reste à gérer les versions non compatibles) + gestion du reste

exporter/Builder.php

@@ -0,0 +1,64 @@
+<?php if( !defined('__ROOT__') ) define('__ROOT__', dirname(dirname(__FILE__)) );
+
+
+	class Builder{
+
+
+		private static function src(){	return __ROOT__.'/src'; }
+		private $modules = null;
+		private $root    = null;
+
+
+
+		/* BUILDS A BUILDER WITH SPECIFIC LOCATION AND CONFIG
+		*
+		* @pRoot<String> 										Path to project root
+		* @pModules<Array> 										Modules to load
+		*
+		*/
+		public function __construct($pRoot, $pModules){
+			/* [1] Stores the path
+			=========================================================*/
+			$this->root = $pRoot;
+
+			/* [2] Stores the modules
+			=========================================================*/
+			$this->modules = $pModules;
+		}
+
+
+
+		public function build(){
+
+			/* [1] Builds project's base file structure
+			=========================================================*/
+			/* (1) Copy from src/files */
+			shell_exec("cp -r ".__ROOT__."/src/files/* ".$this->root);
+
+
+
+			/* [2] Browse each module to load
+			=========================================================*/
+			foreach($this->modules as $module=>$version){
+				$path = "/$module/$version";
+
+				/* (1) Copy module folder if it exists */
+				if(	file_exists(__ROOT__."/src/modules$path/") && is_dir(__ROOT__."/src/modules$path/") && count(scandir(__ROOT__."/src/modules$path/")) > 2 )
+					shell_exec("cp -r ".__ROOT__."/src/modules$path ".$this->root."/build/$module");
+
+				/* (2) Copy module config if it exists */
+				if(	file_exists(__ROOT__."/src/config$path/") && is_dir(__ROOT__."/src/config$path/") && count(scandir(__ROOT__."/src/config$path/")) > 2 )
+					shell_exec("cp -r ".__ROOT__."/src/config$path/* ".$this->root."/config/");
+
+			}
+
+		}
+
+
+
+
+
+
+
+
+	}

exporter/Exporter.php

@@ -1,5 +1,7 @@
 <?php if( !defined('__ROOT__') ) define('__ROOT__', dirname(dirname(__FILE__)) );
 
+	require_once 'Builder.php';
+
 
 	class Exporter{
 
@@ -7,6 +9,9 @@
 
 		public static function config_path(){ return __ROOT__.'/exporter/modules.json'; }
 
+
+
+
 		/* CONSTRUCTOR -> LOADS CONFIG
 		*
 		*/
@@ -17,6 +22,9 @@
 		}
 
 
+
+
+
 		/* RETURNS AVAILABLE MODULE LIST
 		*
 		* @return modules<Array> 							Set containing modules and their versions
@@ -29,7 +37,11 @@
 				$modules[$module] = [];
 
 				foreach($versions as $version=>$dependencies)
-					$modules[$module][] = $version;
+					// if version of module enabled
+					if( isset($this->modules['enabled'][$module]) && is_array($this->modules['enabled'][$module]) && in_array($version, $this->modules['enabled'][$module]) )
+						$modules[$module][] = [ 'version' => $version, 'enabled' => true ];
+					else
+						$modules[$module][] = [ 'version' => $version, 'enabled' => false ];
 			}
 
 			return $modules;
@@ -70,7 +82,7 @@
 
 			/* (2) If wrong version given, set to default */
 			if( is_null($pVersion) || !isset($module[$pVersion]) )
-				echo "chosing latest $vname version.\n";
+				echo "chosing latest version:\n-----------------------\n   [x] $mname:$vname (can throw errors)\n\n";
 
 			/* (2) Else, we get given @version */
 			else
@@ -84,14 +96,52 @@
 			if( !isset($this->modules['enabled'][$mname]) )
 				$this->modules['enabled'][$mname] = '0';
 
-			/* (2) If not dependency or version lower -> Set version */
+			/* (3) Checks cross version dependency -> trying to enable lower-than-required version of a module*/
+			$crossDep = false;
+
+			// For each available module
+			foreach($this->modules['enabled'] as $xModule=>$xVersion){
+
+				// Loads each module's dependencies
+				if(	!isset($this->modules['available'][$xModule][$xVersion]) )
+					continue;
+
+				$xDependencies = $this->modules['available'][$xModule][$xVersion];
+
+				// if module needs a higher version of current module
+				if(	isset($xDependencies[$mname]) && $this->lower($this->modules['available'][$mname], $vname, $xDependencies[$mname]) ){
+					$crossDep = true;
+					break;
+				}
+
+			}
+
+
+			/* (4) If trying to load lower than required version -> error */
+			if(	$crossDep ){
+
+				// Update module's version
+				if(	$this->lower($this->modules['available'][$mname], $this->modules['enabled'][$mname], $xDependencies[$mname]) )
+					$this->modules['enabled'][$mname] = $xDependencies[$mname];
+
+				$this->store();
+
+				return "module `$xModule:$xVersion` needs `$mname:".$xDependencies[$mname]."`\n\naborted.\n";
+			}
+
+
+			/* (5) If not a dependency or higher version -> set/update version */
 			if( !$pDep || $this->lower($module, $this->modules['enabled'][$mname], $vname) ){
 
-				if( $pDep ) echo "- $mname-$vname   ($vname+ required)\n";
+				// if a dependency, set new params
+				if( $pDep )
+					echo "   [x] $mname:$vname   (version $vname+ required)\n";
 
+				// else, store new module
 				$this->modules['enabled'][$mname] = $vname;
 
-			} else if( $pDep ) echo "- $mname-".$this->modules['enabled'][$mname]."   ($vname+ required)\n";
+			}else if( $pDep )
+				echo "   [x] $mname:".$this->modules['enabled'][$mname]."   (version $vname+ required)\n";
 
 
 			/* [4] Loading dependencies
@@ -181,6 +231,27 @@
 		}
 
 
+
+
+
+
+		/* BUILDS A PROJECT
+		*
+		* @pPath<String> 										Path to project root
+		*
+		*/
+		public function build($pPath){
+			$builder = new Builder($pPath, $this->modules['enabled']);
+
+			$builder->build();
+		}
+
+
+
+
+
+
+
 		/* CHECKS IF @pFirst IS LOWER THAN @pSecond VERSION
 		*
 		* @pModule<Array> 										Module's content
@@ -202,6 +273,9 @@
 			/* (2) Get @pSecond index */
 			$ps_index = array_search($pSecond, $keys);
 
+			if(	$pf_index === false )
+				return true;
+
 			return $pf_index < $ps_index;
 		}
 

exporter/main.php

@@ -32,7 +32,11 @@
 			foreach($modules as $module=>$versions){
 
 				foreach($versions as $version)
-					echo " - $module-$version\n";
+					// if enabled
+					if(	$version['enabled'] )
+						echo " [x] $module (version ".$version['version'].")\n";
+					else
+						echo " [ ] $module (version ".$version['version'].")\n";
 
 				echo "\n";
 			}
@@ -43,15 +47,15 @@
 		---------------------------------------------------------*/
 		case 'enable': {
 
-			if( $arglen < 2 || !preg_match("/^(.+)-([0-9\.]+)$/i", $arguments[1], $matches) ){
-				echo "You must specify @module-@version.\n";
+			if( $arglen < 2 || !preg_match("/^(.+):([0-9\.-]+)$/i", $arguments[1], $matches) ){
+				echo "You must specify @module:@version.\n";
 				return;
 			}
 
 			$err = $exporter->enable($matches[1], $matches[2]);
 
 			/* (1) Managing state */
-			if( $err === true ) echo "success.\n";
+			if( $err === true ) echo "\n\n** success **\n";
 			else                echo $err;
 
 		} break;
@@ -68,7 +72,27 @@
 			$err = $exporter->disable($arguments[1]);
 
 			/* (1) Managing state */
-			if( $err === true ) echo "success.\n";
+			if( $err === true ) echo "\n\n** success **\n";
+			else                echo $err;
+
+		} break;
+
+		/* (3) Builds a project
+		---------------------------------------------------------*/
+		case 'build': {
+
+			if( $arglen < 2 || !is_dir($arguments[1]) ){
+				echo "You must specify your project root's @path.\n";
+				return;
+			}
+
+			// Removes the optional final '/'
+			$arguments[1] = preg_replace('/^(.+)\/$/', '$1', $arguments[1]);
+
+			$err = $exporter->build($arguments[1]);
+
+			/* (1) Managing state */
+			if( $err === true ) echo "\n\n** success **\n";
 			else                echo $err;
 
 		} break;

exporter/modules.json

@@ -1,35 +1,43 @@
 {
 	"available": {
 		"error": {
-            "1": [],
-            "1.2": [],
-            "1.5": []
+			"1.0": [],
+			"2.0": []
 		},
 		"api": {
-            "0.8": [],
-            "1": {
-                "error": "1.2"
+			"1.0": {
+				"error": "1.0"
+			},
+			"2.0": {
+				"error": "2.0"
 			}
 		},
 		"orm": {
-            "0.8": {
-                "database": "1"
+			"0.8-1": {
+				"database": "1.0"
+			},
+			"0.8-2": {
+				"database": "2.0"
 			}
 		},
 		"database": {
-            "1": {
-                "error": "1"
+			"1.0": {
+				"error": "1.0"
+			},
+			"2.0": {
+				"error": "2.0"
 			}
 		},
 		"lightdb": {
-            "1": []
+			"1.0": []
 		},
 		"router": {
-            "1": []
+			"1.0": []
 		}
 	},
 	"enabled": {
-        "api": "1",
-        "error": "1.2"
+		"orm": "0.8",
+		"database": "1.0",
+		"error": "1.0"
 	}
 }

src/config/api/2.0/modules.json

@@ -0,0 +1,60 @@
+{
+
+	"RESTexample": {
+		"POST::article": {
+			"description": "Posts a new article",
+			"permissions": ["journalist"],
+			"parameters": {
+				"title":   { "description": "Article's title",   "type": "varchar(5,100)" },
+				"content": { "description": "Article's content", "type": "text" }
+			},
+			"output": {
+				"created_id": { "description": "Id of the created article", "type": "id" }
+			}
+		},
+
+		"GET::article": {
+			"description": "Gets all or a specific article",
+			"permissions": ["viewer", "journalist"],
+			"parameters": {
+				"URL_0":   { "description": "Article id",   "type": "id", "optional": true }
+			},
+			"output": {
+				"articles": { "description": "List of selected articles", "type": "array<mixed>" }
+			}
+		},
+
+		"VIEW::article": {
+			"description": "Gets a specific article into a json file (download)",
+			"permissions": ["viewer", "journalist"],
+			"options": { "download": true },
+			"parameters": {
+				"URL_0":   { "description": "Article id",   "type": "id" }
+			},
+			"output": {
+				"article": { "description": "Selected article as JSON file", "type": "text" }
+			}
+		},
+
+		"PUT::article": {
+			"description": "Updates a specific article",
+			"permissions": ["journalist"],
+			"parameters": {
+				"URL_0":   { "description": "Article id",   "type": "id" },
+				"content": { "description": "Article's content", "type": "text" }
+			},
+			"output": {
+				"article": { "description": "Returns updated article", "type": "array<mixed>" }
+			}
+		},
+
+		"DELETE::article": {
+			"description": "Deletes a specific article",
+			"permissions": ["journalist"],
+			"parameters": {
+				"URL_0":   { "description": "Article id",   "type": "id" }
+			},
+			"output": {}
+		}
+	}
+}

src/config/database/2.0/database-driver.json

@@ -0,0 +1,16 @@
+{
+	"default": {
+		"local": {
+			"host"     : "db_local_host",
+			"dbname"   : "db_local_name",
+			"user"     : "db_local_user",
+			"password" : "db_local_password"
+		},
+		"remote": {
+			"host"     : "db_remote_host",
+			"dbname"   : "db_remote_name",
+			"user"     : "db_remote_user",
+			"password" : "db_remote_password"
+		}
+	}
+}

src/modules/api/2.0/core/Authentification.php

@@ -0,0 +1,60 @@
+<?php
+
+	namespace api\core;
+
+	use \database\core\Repo;
+	use \error\core\Error;
+	use \error\core\Err;
+
+	class Authentification
+	{
+
+		private static $instance;
+
+		private $userType;
+		private $userId;
+
+		public function __construct()
+		{
+			$token = !empty($_SERVER['PHP_AUTH_DIGEST']) ? $_SERVER['PHP_AUTH_DIGEST'] : false;
+
+			$user = new Repo("AuthentificationRepo/identifyUserByToken", [$token]);
+			$user = $user->answer();
+
+			if( $user != false ){
+				$this->userType = $user["Type"];
+				$this->userId   = $user["Id"];
+			}
+
+			new Repo("AuthentificationRepo/updateToken",[$token]);
+
+			new Repo("AuthentificationRepo/purgeOldTokens",[]);
+
+			self::$instance = $this;
+		}
+
+		public function getUserType(){
+			return $this->userType;
+		}
+
+		public function getUserId(){
+			return $this->userId;
+		}
+
+		public static function permission(array $perm){
+			if(in_array(self::$instance->userType,$perm)){
+				return new Error(Err::Success);
+			}
+
+			return new Error(Err::TokenError);
+		}
+
+		/**
+		 * @return Authentification
+		 */
+		public static function getInstance(){
+			return self::$instance;
+		}
+
+
+	}

src/modules/api/2.0/core/Checker.php

@@ -0,0 +1,150 @@
+<?php
+
+	namespace api\core;
+
+
+	class Checker{
+
+
+		/* VERIFICATIONS DES TYPES UTILES GENERIQUES
+		*
+		* @type<String>		 									Type que l'on veut verifier
+		* @value<mixed*> 										Valeur a verifier
+		*
+		* @return match<Boolean> 								Retourne si oui ou non la valeur @value est du bon type @type
+		*
+		*/
+		public static function run($type, $value){
+			$checker = true;
+
+			/* [0] On verifie que $value n'est pas nul
+			=========================================================*/
+			if( is_null($value) ) return false;
+
+
+
+			/* [1] Si de type VARCHAR(min, max, flags)
+			=========================================================*/
+			if( preg_match('/^varchar\((\d+), ?(\d+)((?:, ?\w+)+)?\)$/', $type, $match) ){
+				// On recupere la taille min
+				$min = (int) $match[1];
+				// On recupere la taille max
+				$max = (int) $match[2];
+
+				// On recupere le sous-type si défini
+				$flags = isset($match[3]) ? explode(',', substr($match[3], 1)) : null;
+
+				// On effectue la verification de taille
+				$lenCheck = $checker && is_string($value) && strlen($value) <= $max && strlen($value) >= $min;
+
+				// On vérifie les FLAGS s'il est donné
+				if( is_array($flags) )
+					foreach( $flags as $flag )
+						$lenCheck = $lenCheck && self::run($flag, $value);
+
+				return $lenCheck;
+			}
+
+
+			/* [2] Si de type ARRAY(type_elements)
+			=========================================================*/
+			if( preg_match('/^array<(.+)>$/', $type, $match) ){
+
+				// Si c'est pas un tableau on retourne une erreur
+				if( !is_array($value) )
+					return false;
+
+
+				$elements_type = $match[1];
+
+				// On verifie le type pour chaque element
+				foreach($value as $element)
+					// Si erreur dans au moins 1 element, on retourne que c'est incorrect
+					if( !self::run($elements_type, trim($element) ) )
+						return false;
+
+				// Si aucune erreur, on retourne que tout est bon
+				return true;
+			}
+
+
+			/* [n] Sinon, tous les autres types definis
+			=========================================================*/
+			switch($type){
+				// Quoi que ce soit
+				case 'mixed':
+					return $checker && !is_null($value);
+					break;
+
+				// Entier positif (id dans BDD)
+				case 'id':
+					return $checker && is_numeric($value) && $value <= 2147483647 && $value >= 0;
+					break;
+
+				// Code RFID
+				case 'rfid':
+					return $checker && is_string($value) && preg_match('/^[\dA-F]{2}(\-[\dA-F]{2}){3,5}$/i', $value);
+					break;
+
+				// String quelconque (peut etre vide)
+				case 'text':
+					return $checker && is_string($value);
+
+				// Adresse mail (255 caracteres max)
+				case 'mail':
+					return $checker && is_string($value) && strlen($value) <= 50 && preg_match('/^[\w\.-]+@[\w\.-]+\.[a-z]{2,4}$/i', $value);
+					break;
+
+				// Hash sha1/md5
+				case 'hash':
+					return $checker && is_string($value) && preg_match('/^[\da-f]+$/i', $value) && (strlen($value) == 40 || strlen($value) == 64);
+					break;
+
+				case 'alphanumeric':
+					return $checker && is_string($value) && preg_match('/^[\w\.-]+$/ui', $value);
+					break;
+
+				case 'letters':
+					return $checker && is_string($value) && preg_match('/^[a-z -]+$/i', $value);
+					break;
+
+				case 'status':
+					return $checker && is_numeric($value) && floor($value) == $value && $value >= 0 && $value <= 100;
+					break;
+
+				// Tableau non vide
+				case 'array':
+					return $checker && is_array($value) && count($value) > 0;
+					break;
+
+				// Boolean
+				case 'boolean':
+					return $checker && is_bool($value);
+					break;
+
+				// Objet non vide
+				case 'object':
+					return $checker && is_object($value) && count((array) $value) > 0;
+					break;
+
+				// Chaine JSON (on vérifie via le parser)
+				case 'json':
+					return $checker && is_string($value) && json_decode($value, true) !== NULL;
+					break;
+
+				case 'numeric':
+					return $checker && (is_numeric($value) || $value == null || $value == 'null');
+					break;
+
+				default:
+					return false;
+					break;
+			}
+
+			return $checker;
+
+		}
+
+
+	}
+?>

src/modules/api/2.0/core/ModuleFactory.php

@@ -0,0 +1,31 @@
+<?php
+
+	namespace api\core;
+
+
+	class ModuleFactory{
+
+		/* INSTANCIE UN MODULE
+		*
+		* @module<String> 								Nom du module
+		* @arguments<Array>								[OPTIONNEL] Arguments à passer au constructeur
+		*
+		* @return instance<Module> 						Instance du module en question
+		*
+		*/
+		public static function getModule($module, $arguments=[]){
+			/* (1) On gère les arguments */
+			$arguments = is_array($arguments) ? $arguments : [];
+
+			/* (1) On vérifie que la classe existe */
+			if(	!file_exists(__BUILD__."/api/module/$module.php") )
+				return false;
+
+			/* (2) On récupère la classe */
+			$class_name = "\\api\\module\\$module";
+
+			/* (3) On retourne une instance */
+			return new $class_name($arguments);
+		}
+
+	}

src/modules/api/2.0/core/Request.php

@@ -0,0 +1,581 @@
+<?php
+
+	namespace api\core;
+	use \database\core\DatabaseDriver;
+	use \api\core\Authentification;
+	use \api\core\ModuleFactory;
+	use \error\core\Error;
+	use \error\core\Err;
+
+
+	class Request{
+
+		// Constantes
+		public static function config_path(){ return __ROOT__.'/config/modules.json'; }
+		public static $default_options = [
+			'download' => false
+		];
+
+		// Attributs prives utiles (initialisation)
+		private $path;
+		private $params;
+		private $modules;
+		private $options;
+
+		// Contiendra la reponse a la requete
+		public $answer;
+
+		// Contiendra l'etat de la requete
+		public $error;
+
+
+
+
+
+		/* CONSTRUCTEUR D'UNE REQUETE DE MODULE
+		*
+		* @path<String>				Chemin de delegation ("module/methode")
+		* @param<Array>				Tableau associatif contenant les parametres utiles au traitement
+		*
+		* @return status<Boolean>	Retourne si oui ou non tout s'est bien passe
+		*
+		*/
+		public function __construct($path=null, $params=null){
+			/* [0] Initialisation
+			=========================================================*/
+			/* (1) Erreur par défaut */
+			$this->error = new Error(Err::Success);
+
+			/* (2) Si pas parametre manquant, on quitte */
+			if( $path == null ){
+				$this->error->set(Err::MissingPath);
+				return false;
+			}
+
+
+			/* [1] On met a jour la configuration
+			=========================================================*/
+			/* (1) Section Title */
+			$this->modules = json_decode( file_get_contents(self::config_path()), true );
+
+			/* (2) Gestion de l'erreur de parsage */
+			if( $this->modules == null ){
+				$this->error->set(Err::ParsingFailed, 'json');
+				return false;
+			}
+
+
+
+			/* [2] Verification des types des parametres
+			=========================================================*/
+			/* (1) Section Title */
+			if( !is_string($path) ){ // Si le type est incorrect
+				$this->error->set(Err::WrongPathModule);
+				return false; // On retourne FALSE, si erreur
+			}
+
+			/* (2) Section Title */
+			$params = (is_array($params)) ? $params : [];
+
+			/* (3) On définit en constante la méthode HTTP */
+			define('__HTTP_METHOD__', strtoupper($_SERVER['REQUEST_METHOD']));
+
+
+			/* [3] Verification du chemin (existence module+methode)
+			=========================================================*/
+			if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
+				return false;
+
+
+			/* [4] Verification des droits
+			=========================================================*/
+			if( !$this->checkPermission() ) // Si on a pas les droits
+				return false;
+
+
+			/* [5] Verification des parametres (si @type est defini)
+			=========================================================*/
+			if( !$this->checkParams($params) ) // Verification de tous les types
+				return false;
+
+
+			/* [6] Récupèration des options
+			=========================================================*/
+			$this->buildOptions();
+
+
+			/* [7] Construction de l'objet
+			=========================================================*/
+			$this->params = $params;
+			$this->error->set(Err::Success);
+
+			return true; // On retourne que tout s'est bien passe
+
+		}
+
+
+
+		/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE
+		*
+		* @return answer<Response> 								Retourne une reponse de type <Response> si tout s'est bien passe
+		*
+		*/
+		public function dispatch(){
+			/* [0] Si c'est un download, on lance la methode `download()`
+			=========================================================*/
+			if( $this->options['download'] === true )
+				return $this->download();
+
+			/* [1] On verifie qu'aucune erreur n'a ete signalee
+			=========================================================*/
+			if( $this->error->get() !== Err::Success ) // si il y a une erreur
+				return new Response($this->error);  // on la passe a la reponse
+
+
+			/* [2] On essaie d'instancier le module
+			=========================================================*/
+			$instance = ModuleFactory::getModule($this->path['module']);
+
+			if(	$instance === false ){
+				$this->error->set(Err::UncallableModule, $this->path['module']);
+				return new Response($this->error);
+			}
+
+			/* [3] On verifie que la methode est amorcable
+			=========================================================*/
+			if( !is_callable([$instance, $this->getModuleMethod()]) ){
+				$this->error->set(Err::UncallableMethod, preg_replace('/\w+::/i', '', $this->path['method']) );
+				return new Response($this->error);
+			}
+
+
+			/* [4] On amorce la methode
+			=========================================================*/
+			/* (1) On lance la fonction */
+			$returned = call_user_func( [$instance, $this->getModuleMethod()], $this->params );
+
+			/* (2) On appelle le destructeur (si défini) */
+			$instance = null;
+
+
+			/* [5] Gestion de la reponse
+			=========================================================*/
+			/* (1) On construit la réponse avec l'erreur */
+			$response = new Response($this->error);
+
+			/* (2) On ajoute les données */
+			$response->appendAll($returned);
+
+			// On retourne la réponse
+			return $response;
+		}
+
+
+
+		/* EXECUTE LE TRAITEMENT ASSOCIE ET RENVOIE UN FICHIER AVEC LE HEADER ET LE BODY SPECIFIE
+		*
+		*/
+		public function download(){
+			/* [1] On verifie qu'aucune erreur n'a ete signalee
+			=========================================================*/
+			if( $this->error->get() !== Err::Success ) // si il y a une erreur
+				return new Response($this->error);  // on la passe a la reponse
+
+
+			/* [2] On essaie d'instancier le module
+			=========================================================*/
+			$instance = ModuleFactory::getModule($this->path['module']);
+
+			if(	$instance === false ){
+				$this->error->set(Err::UncallableModule);
+				return new Response($this->error);
+			}
+
+			/* [3] On verifie que la methode est amorcable
+			=========================================================*/
+			if( !is_callable([$instance, $this->getModuleMethod()]) ){
+				$this->error->set(Err::UncallableMethod);
+				return new Response($this->error);
+			}
+
+
+			/* [4] On amorce la methode
+			=========================================================*/
+			/* (1) On lance la fonction */
+			$returned = call_user_func( [$instance, $this->getModuleMethod()], $this->params );
+
+			/* (2) On appelle le destructeur (si défini) */
+			$instance = null;
+
+
+			/* [5] Vérification des erreurs et paramètres
+			=========================================================*/
+			/* (1) Vérification de l'erreur retournée, si pas Success, on retourne l'erreur */
+			if( isset($returned['error']) && $returned['error'] instanceof Error && $returned['error']->get() != Err::Success ){
+				$this->error = $returned['error'];
+				return new Response($this->error);
+			}
+
+			/* (2) Vérification du contenu, si pas défini */
+			if( !isset($returned['body']) ){
+				$this->error->set(Err::ParamError);
+				return new Response($this->error);
+			}
+
+			/* (3) Si @headers n'est pas défini on met par défaut */
+			if( !isset($returned['headers']) || !is_array($returned['headers']) )
+				$returned['headers'] = [];
+
+			$fromAjax = isset($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest';
+
+
+			/* [6.1] Si requête ajax on crée un fichier temporaire et on renvoie son URL
+			=========================================================*/
+			if( $fromAjax ){
+
+
+				$tmpfname = '/tmp/download_'.uniqid().'.php';
+				$bodyfname = __ROOT__.'/tmp/content_'.uniqid().'.php';
+
+				/* (1) On crée le fichier temporaire */
+				$tmpfnameroot = __ROOT__.$tmpfname;
+				$tmpfile = fopen($tmpfnameroot, 'w');
+
+				fwrite($tmpfile, '<?php'.PHP_EOL);
+
+				/* (2) Script qui écrira les headers */
+				foreach($returned['headers'] as $header=>$value)
+					fwrite($tmpfile, "header(\"$header: $value\");".PHP_EOL);
+
+				/* (3) Script qui écrira le contenu */
+				// 1) On écrit le contenu dans un fichier temporaire (et oui encore)
+				$bodyfile = fopen($bodyfname, 'w');
+				fwrite($bodyfile, $returned['body']);
+				fclose($bodyfile);
+				chmod($bodyfname, 0775);
+
+				fwrite($tmpfile, "readfile('$bodyfname');".PHP_EOL);
+
+				/* (4) Script qui supprimera les fichiers temporaires */
+				fwrite($tmpfile, "unlink('$bodyfname');".PHP_EOL);
+				fwrite($tmpfile, "unlink(__FILE__);".PHP_EOL);
+
+				fwrite($tmpfile, '?>'.PHP_EOL);
+
+				/* (5) On ferme le fichier */
+				fclose($tmpfile);
+				chmod($tmpfnameroot, 0775);
+
+				$response = new Response($this->error);
+				$response->append('link', $tmpfname);
+
+				return $response;
+
+			/* [6.2] Gestion du download direct si pas AJAX
+			=========================================================*/
+			}else{
+				/* (1) On définit les headers */
+				foreach($returned['headers'] as $header=>$value)
+					header($header.': '.$value);
+
+				/* (2) On affiche le contenu */
+				echo $returned['body'];
+
+				return true;
+			}
+		}
+
+
+		/* DESERIALISATION A PARTIR DE L'URL ET DES DONNEES POST (OPT)
+		*
+		* @url<String> 											Contenu de l'url après api/ (si existe)
+		* @post<Array> 											[opt] Tableau des donnes
+		*
+		* @return instance<Request> 							Retourne un objet de type <Request>
+		*
+		* @note
+		*	1. `path` peut être dans l'url : /method/module
+		*	   `path` peut être dans les données $_POST
+		*	2. les données peuvent être dans l'url : /module/method/data1/data2/...
+		*	   les données peuvent être dans les données $_POST
+		*
+		*/
+		public static function remote($url, $data=null){
+			is_null($data) && ($data = []);
+
+
+			/* [1] On verifie que le @path est renseigne
+			=========================================================*/
+			/* (1) Si le path est dans @url */
+			$pathInUrl = count($url) > 0 && is_string($url[0]) && strlen($url[0]) > 0 && preg_match('#^([\w_-]+/[\w_-]+)(?:/?|/((?:\w+/)*(?:\w+/?)))$#', $url[0], $urlMatches);
+
+			/* (2) On récupère le @path + les arguments dans l'URL  */
+			if( $pathInUrl ){
+				// {1} On ajoute le @path aux données //
+				$data['path'] = $urlMatches[1];
+
+				// {2} On ajoute les arguments d'URL aux données //
+				if( count($urlMatches) > 2 ){
+
+					$urlParams = explode('/', trim($urlMatches[2], '/'));
+					foreach($urlParams as $k=>$v)
+						$data["URL_$k"] = $v;
+
+				}
+
+			}
+
+
+			/* (2) On vérifie dans tous les cas si le path existe */
+			if( !isset($data['path']) )
+				return new Request();
+
+
+
+			/* [3] On met les paramètres en JSON
+			=========================================================*/
+			/* (1) On initialise les paramètres*/
+			$params = [];
+
+			/* (2) On met tous les paramètres en json (sauf @path) */
+			foreach($data as $name=>$value){
+				if( $name === 'path' )
+					continue;
+
+				// {1} On met en JSON //
+				$json = json_decode( $value, true );
+
+				// {2} Si ok -> on remplace //
+				if( !is_null($json) )
+					$params[$name] = $json;
+
+				// {3} Sinon, on laisse tel quel //
+				else
+					$params[$name] = $value;
+			}
+
+			/* [4] On retourne une instance de <Request>
+			=========================================================*/
+			return new Request($data['path'], $params);
+		}
+
+
+
+
+
+		/* VERIFICATION DU FORMAT ET DE LA COHERENCE DU CHEMIN SPECIFIE
+		*
+		* @path<String> 									String correspondant au chemin de delegation ("module/methode")
+		*
+		* @return validity<Boolean> 						Retourne si oui ou non l'objet est correct
+		*
+		*/
+		private function checkPath($path){
+			/* [1] Verification format general
+			=========================================================*/
+			if( !preg_match('#^([\w_-]+)/([\w_-]+)$#i', $path, $matches) ){ // Si mauvais format
+				$this->error->set(Err::WrongPathModule);
+				return false;
+			}
+
+			// On recupere les données de la regex
+			$module = $matches[1];
+			$method = __HTTP_METHOD__.'::'.$matches[2];
+
+
+			/* [2] Verification de l'existence du module (conf)
+			=========================================================*/
+			if( !array_key_exists($module, $this->modules) ){ // Si le module n'est pas specifie dans la conf
+				$this->error->set(Err::UnknownModule, $module);
+				return false; // On retourne FALSE, si erreur
+			}
+
+
+			/* [3] Verification de l'existence de la methode (conf)
+			=========================================================*/
+			if( array_key_exists($method, $this->modules[$module]) === false ){ // Si la methode n'est pas specifie dans la conf
+				$this->error->set(Err::UnknownMethod, preg_replace('/\w+::/i', '', $method) );
+				return false; // On retourne FALSE, si erreur
+			}
+
+
+
+			/* [4] Enregistrement du chemin et renvoi de SUCCESS
+			=========================================================*/
+			$this->path = [
+				'module' => $module,
+				'method' => $method
+			];
+
+			return true;
+		}
+
+
+
+
+
+
+		/* RETOURNE SI ON A LA PERMISSION D'EXECUTER CETTE METHODE
+		*
+		* @return permission<bool> 								Retourne si on a les droits ou pas pour executer cette methode
+		*
+		*/
+		private function checkPermission(){
+			/* [1] On recupere les informations utiles
+			=========================================================*/
+			// On recupere le nom de la methode
+			$method = $this->modules[$this->path['module']][$this->path['method']];
+
+			// Si aucune permission n'est definie
+			if( !isset($method['permissions']) ) return true;
+
+
+
+			/* [2] Vérification des permissions et de l'authentification
+			=========================================================*/
+			if(!empty($method['permissions'])){
+				$granted = Authentification::permission($method['permissions']);
+
+				/* (1) On retourne FAUX si aucun droit n'a ete trouve */
+				if( $granted->get() !== Err::Success ){
+					$this->error = $granted;
+					return false;
+				}
+			}
+
+
+
+			/* On retourne VRAI si la permission est ok */
+			return true;
+		}
+
+
+
+
+		/* VERIFICATION DU TYPE DES PARAMETRES ENVOYES
+		*
+		* @params<Array> 									Tableau associatif contenant les parametres
+		* @params peut se voir rajouter les paramètres optionnels s'ils ne sont pas renseignés (initialisés à NULL)
+		*
+		* @return correct<bool> 							Retourne si oui ou non les parametres ont le bon type
+		*
+		*/
+		private function checkParams(&$params){
+			/* [1] On verifie qu'il ne manque aucun parametre
+			=========================================================*/
+			// Si @params n'est pas un tableau
+			if( !is_array($params) ){
+				$this->error->set(Err::ConfigError);
+				return false;
+			}
+
+			$method = $this->modules[$this->path['module']][$this->path['method']];
+
+
+			/* [2] Si le type est defini, pour chaque param, on teste
+			=========================================================*/
+			foreach($method['parameters'] as $name=>$paramsdata){
+				/* (1) On récupère si le paramètre est optionnel ou pas */
+				$optional = isset($paramsdata['optional']) && $paramsdata['optional'] === true;
+
+				/* (2) Récupère si le paramètre est un fichier et définit comme de type 'FILE' */
+				$isFile = isset($paramsdata['type']) && $paramsdata['type'] == 'FILE' && isset($_FILES[$name]);
+
+				/* (3) Si le paramètre est obligatoire et qu'il n'est pas donné -> erreur */
+				if( !isset($params[$name]) && !$optional && !$isFile ){
+					$this->error->set(Err::MissingParam, $name);
+					return false;
+				}
+
+				/* (4) Si le type n'est pas defini, on a pas besoin de le vérifier */
+				if( !isset($paramsdata['type']) )
+					continue;
+
+				/* (5) Si le paramètre est optionnel et n'est pas donné */
+				if( $isFile || $optional && (!isset($params[$name]) || is_null($params[$name])) ){
+					// On le crée le param optionnel avec la valeur NULL
+					$params[$name] = null;
+
+					// On donne une référence vers le fichier, si c'en est un
+					if( $isFile )
+						$params[$name] = &$_FILES[$name];
+
+					continue; // On passe au paramètre suivant
+
+
+				/* (6) Si le paramètre est renseigné */
+				}else
+					// Si la verification est fausse, on retourne faux
+					if( !Checker::run($paramsdata['type'], $params[$name]) ){
+						$this->error->set(Err::WrongParam, $name, $paramsdata['type']);
+						return false;
+					}
+
+			}
+
+			/* [3] Gestion du retour, si tout s'est bien passe
+			=========================================================*/
+			return true;
+		}
+
+
+
+
+
+		/* AJOUT DES OPTIONS A PARTIR DE LA CONFIGURATION
+		*
+		*/
+		private function buildOptions(){
+			/* [0] On récupère les options de la méthode en cours
+			=========================================================*/
+			$method = $this->modules[$this->path['module']][$this->path['method']];
+
+			/* (1) Si 'option' n'est pas défini (ou incorrect), on met les valeurs par défaut */
+			if( !isset($method['options']) || !is_array($method['options']) )
+				return true;
+
+			/* (2) Par défaut on définit les options par défaut */
+			$this->options = self::$default_options;
+
+
+			/* (3) On récupère les options données */
+			$options = $method['options'];
+
+
+			/* [1] Gestion des différentes options
+			=========================================================*/
+			foreach($options as $option=>$value){
+				/* (1) On ne prend en compte l'option que si elle est dans les options par défaut */
+				if( !isset(self::$default_options[$option]) )
+					continue;
+
+				/* (2) Le type de la valeur doit être le même que celui de la valeur par défaut */
+				if( gettype($value) != gettype(self::$default_options[$option]) )
+					continue;
+
+				/* (3) Si tout est bon, on définit la valeur */
+				$this->options[$option] = $value;
+			}
+
+			return true;
+
+		}
+
+
+
+
+
+		/* RENVOI LE CHEMIN D'AMORCAGE DE LA METHODE
+		*
+		* @return method<String> 									Retourne le chemin d'amorcage de la method
+		*
+		*/
+		private function getModuleMethod(){
+			/* (1) On essaie de trouver le bon nom */
+			return preg_replace('/\w+::/i', '', $this->path['method']);
+		}
+
+
+	}
+
+?>

src/modules/api/2.0/core/Response.php

@@ -0,0 +1,122 @@
+<?php
+
+	namespace api\core;
+	use \error\core\Error;
+	use \error\core\Err;
+
+	class Response{
+
+		// Attributs prives utiles (initialisation)
+		private $data;
+		public $error;
+
+
+		/* CONSTRUCTEUR D'UNE REPONSE DE MODULE
+		*
+		* @error<ModuleError>					Erreur passee par la requete (si existe)
+		*
+		*/
+		public function __construct($error=null){
+			if(	!( $error instanceof Error ) )
+				$error = new Error(Err::Success);
+
+			$this->data = [];
+			$this->error = $error;
+		}
+				/* AJOUTE UNE DONNEE A LA REPONSE
+
+
+		*
+		* @key<String> 										Le nom de la valeur a ajouter
+		* @value<mixed*> 									La valeur a ajouter
+		*
+		*/
+		public function append($key, $value){
+			// Ajoute une entree pour la cle @key et de valeur @value
+			$this->data[$key] = $value;
+
+			return $this;
+		}
+
+
+		/* AJOUTE TOUTES LES DONNEES A LA REPONSE
+		*
+		* @dataset<Array> 									Le tableau associatif correspondant a la reponse
+		*
+		*/
+		public function appendAll($dataset){
+			// Si ce n'est pas un tableau, on ne fais rien
+			if( !is_array($dataset) )
+				return $this;
+
+			// Si une valeur contient une erreur
+			if( array_key_exists('error', $dataset) && $dataset['error'] instanceof Error){
+				// On definit cette erreur
+				$this->error = $dataset['error'];
+				// On enleve cette entree des donnees
+				unset($dataset['error']);
+			}
+
+			// Ajoute une entree pour la cle @key et de valeur @value
+			$this->data = $dataset;
+
+			return $this;
+		}
+				/* RECUPERE UNE DONNEE DE LA REPONSE
+
+
+		*
+		* @key<String> 										Le nom de la valeur a recuperer
+		*
+		* @return value<mixed*> 							La valeur a cette cle
+		* @return error<null> 								Retourne NULL si aucune valeur pour cette cle
+		*
+		*/
+		public function get($key){
+			// Si la valeur de cle @key n'existe pas, on retourne NULL
+			if( !isset($this->data[$key]) )
+				return null;
+
+			// Sinon, on retourne la valeur associee
+			return $this->data[$key];
+		}
+
+
+		/* RECUPERE TOUTES LES DONNEES DE LA REPONSE
+		*
+		* @return data<Array> 							Les donnees de la reponse
+		*
+		*/
+		public function getAll(){
+			// Sinon, on retourne la valeur associee
+			return $this->data;
+		}
+
+
+		/* SERIALISATION A PARTIR DES DONNEES
+		*
+		* @return json<String> 						Retourne les donnees serialisees
+		*
+		*/
+		public function serialize(){
+
+			// Code Http
+			$this->error->setHttpCode();
+
+			// Type de contenu
+			header('Content-Type: application/json; charset=utf-8');
+
+			// On rajoute l'erreur au message
+			$returnData = array_merge([
+					'error'            => $this->error->get(),
+					'ErrorDescription' => $this->error->explicit()
+				],
+				$this->data
+			);
+
+			return json_encode($returnData);
+
+		}
+		}
+
+?>

src/modules/api/2.0/module/RESTexample.php

@@ -0,0 +1,116 @@
+<?php
+
+namespace api\module;
+
+
+use error\core\Error;
+use error\core\Err;
+
+class RESTexample{
+
+	public function __construct(){
+		// Routine to execute before each call to RESTexample's method
+	}
+
+	public function __destruct(){
+		// Routine to execute after each call to RESTexample's method
+	}
+
+
+
+	public function article($argv){
+		extract($argv);
+
+		switch(__HTTP_METHOD__){
+			case 'POST':
+				// POST a new article with variables:
+				$title;   // new article's title
+				$content; // new article's content
+
+				// ...
+				// process to create article and get $output_created_id
+				// ...
+
+				if(	!$success )
+					return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
+
+				return ['created_id' => $output_created_id];
+				break;
+
+			case 'GET':
+				// GET all/an article with the variable:
+				$URL_0; // id of article ; if not given -> null
+
+				// ...
+				// process to get articles and get $output_get_articles
+				// ...
+
+				if(	!$success )
+					return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
+
+				return ['articles' => $output_get_articles];
+				break;
+
+			case 'VIEW':
+				// VIEW a specific article (download json file) with the variable:
+				$URL_0; // id of article ; if not given -> null
+
+				// ...
+				// process to get articles and get $output_get_articles
+				// ...
+
+				if(	!$success )
+					return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
+
+				// will download, but if AJAX will give a `link` to the file
+				return [
+					'headers' => [
+						'Content-Type' => 'application/json; charset=utf-8',
+						'Content-Disposition' => 'attachment; filename=export'.date('_d_m_Y', time()).'.json',
+						'Pragma'              => 'no-cache',
+						'Expires'             => '0'
+					],
+					'body' => json_encode($output_get_articles)
+				];
+				break;
+
+			case 'PUT':
+				// UPDATE an article with new content with variables:
+				$URL_0;   // id of article to update
+				$title;   // new article's title
+				$content; // new article's content
+
+				// ...
+				// process to get $output_updated_article
+				// ...
+
+				if(	!$success )
+					return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
+
+				return ['article' => $output_updated_article];
+				break;
+
+			case 'DELETE':
+				// DELETEs an article with the variable:
+				$URL_0; // id of the article to remove
+
+				// ...
+				// process to delete article
+				// ...
+
+				if(	!$success )
+					return ['error' => new Error(Err::ModuleError)]; // or other `Err` constant
+
+				return []; // returns success
+				break;
+
+			// if no match -> error
+			default:
+				return ['error' => new Error(Err::UnknownHttpMethod)];
+				break;
+		}
+
+	}
+
+
+}

src/modules/database/2.0/core/DatabaseDriver.php

@@ -0,0 +1,180 @@
+<?php
+
+	namespace database\core;
+	use \error\core\Error;
+	use \error\core\Err;
+
+
+	class DatabaseDriver{
+
+		/* STATIC ATTRIBUTES */
+		private static function conf(){
+			// YOUR CONFIGURATION BEHIND
+			$path = __CONFIG__.'/database-driver.json';
+
+			/* (1) Checks the file */
+			if( !is_file($path) )
+				return [];
+
+			/* (2) Checks json */
+			$parsed = json_decode( file_get_contents($path), true );
+
+			if( !is_array($parsed) )
+				return [];
+
+			/* (3) Returns configuration */
+			return $parsed;
+		}
+
+
+		private static $path;          // Databases configurations files
+		private static $config;        // PDO configurations
+		private static $instance = []; // Database driver instance list
+
+		public $error;
+
+		/* ATTRIBUTES */
+		private $host;
+		private $dbname;
+		private $username;
+		private $password;
+		private $pdo;
+
+
+
+		/* CONSTRUCTOR OF A DATABASE DRIVER
+		*
+		* @host<String> 										Database Server's host
+		* @dbname<String> 										Database name
+		* @username<String> 									Database username
+		* @password<String> 									Database password
+		*
+		*/
+		private function __construct($host, $dbname, $username, $password){
+			/* (2) Stores configuration */
+			$this->host     = $host;
+			$this->dbname   = $dbname;
+			$this->username = $username;
+			$this->password = $password;
+
+			try{
+
+				$this->pdo = new \PDO('mysql:host='.$this->host.';dbname='.$this->dbname, $this->username, $this->password);
+				$this->pdo->setAttribute(\PDO::ATTR_DEFAULT_FETCH_MODE, \PDO::FETCH_ASSOC);
+
+				// On signale que tout s'est bien passe
+				$this->error = new Error(Err::Success);
+
+			}catch(Exception $e){
+				// On signale qu'il y a une erreur
+				$this->error = new Error(Err::PDOConnection);
+			}
+		}
+
+
+
+		/************************************************
+		****       Multiton Management (static)      ****
+		************************************************/
+
+		/* ADDS A NEW CONNECTION
+		*
+		* @label<String> 										[optional] Database Label
+		*
+		* @return status<Boolean>								If added successfully
+		*
+		*/
+		private static function add($label=null){
+			$conf = self::conf();
+
+			/* [1] Default values
+			=========================================================*/
+			/* (1) If label isn't given */
+			is_null($label) && ($label = 'default');
+
+			/* (2) If label and no path */
+			if( $label !== 'default' && !isset($conf[$label]) )
+				return false;
+
+
+			/* [3] Instanciates the driver
+			=========================================================*/
+			try{
+
+				/* (1) If local -> instanciates with local configuration */
+				if( !checkdnsrr($_SERVER['SERVER_NAME'], 'NS') )
+					self::$instance[$label] = new DatabaseDriver($conf[$label]['local']['host'], $conf[$label]['local']['dbname'], $conf[$label]['local']['user'], $conf[$label]['local']['password']);
+				/* (2) If Remote -> instanciates with Remote configuration */
+				else
+					self::$instance[$label] = new DatabaseDriver($conf[$label]['remote']['host'], $conf[$label]['remote']['dbname'], $conf[$label]['remote']['user'], $conf[$label]['remote']['password']);
+
+				return true;
+
+			}catch(\Exception $e){
+
+				/* (3) If fails */
+				return false;
+
+			}
+
+		}
+
+
+		/* GET A DATABASE DRIVER INSTANCE
+		*
+		* @label<String> 										[optional] Driver's label
+		*
+		* @return driver<Database> 								Multiton
+		*
+		*/
+		public static function get($label=null){
+			$conf = self::conf();
+
+			/* [1] Checks arguments
+			=========================================================*/
+			/* (1) Label default value */
+			is_null($label) && ($label = 'default');
+
+			/* (2) If no label, or unknown label */
+			if( is_null($label) || !isset(self::$instance[$label]) ){
+
+				/* (2.1) Try to add the configuration if exists */
+				if( isset($conf[$label]) ){
+					self::add($label);
+					return self::get($label);
+				}
+
+
+				throw new \Exception('Database @label is incorrect.');
+			}
+
+
+			/* [2] Returns instance
+			=========================================================*/
+			return self::$instance[$label];
+		}
+
+
+		/** retourne la connection statique
+		 * @param null $label
+		 * @return \PDO
+		 */
+		public static function getPDO($label=null){
+			$instance = self::get($label);
+
+			return $instance->pdo;
+		}
+
+
+		public function getConfig(){
+			return [
+				'host' => $this->host,
+				'dbname' => $this->dbname,
+				'username' => $this->username
+			];
+		}
+
+
+
+	}
+?>

src/modules/database/2.0/core/Repo.php

@@ -0,0 +1,193 @@
+<?php
+
+	namespace database\core;
+
+	use \error\core\Error;
+	use \error\core\Err;
+	use \api\core\Authentification;
+
+
+	class Repo{
+
+		// Constantes
+		public static function config_path(){ return __ROOT__.'/config/repositories.json'; }
+
+
+		// Attributs prives utiles (initialisation)
+		private $path;
+		private $params; // Paramètres de la requête
+		private $repositories;
+
+		// Contiendra la reponse a la requete
+		private $answer;
+
+		// Contiendra l'etat de la requete
+		public  $error;
+
+
+
+
+
+		/* CONSTRUCTEUR D'UNE REQUETE DE MODULE
+		*
+		* @path<String>				Chemin de delegation ("repo/methode")
+		* @params<Array>			Tableau contenant les parametres utiles au traitement
+		*
+		* @return status<Boolean>	Retourne si oui ou non tout s'est bien passe
+		*
+		*/
+		public function __construct($path=null, $params=null){
+
+			// Si pas parametre manquant, on quitte
+			if( $path == null ){
+				$this->error = new Error(Err::MissingPath);
+				return false;
+			}
+
+			/* [0] On met a jour la configuration
+			=========================================================*/
+			// Modules specifies
+			$this->repositories = json_decode( file_get_contents(self::config_path()), true );
+
+			// Gestion de l'erreur de parsage
+			if( $this->repositories == null ){
+				$this->error = new Error(Err::ParsingFailed, 'json');
+				return false;
+			}
+
+
+
+			/* [1] Verification des types des parametres
+			=========================================================*/
+			// Type de @path
+			if( !is_string($path) ){ // Si le type est incorrect
+				$this->error = new Error(Err::WrongPathRepo);
+				return false; // On retourne FALSE, si erreur
+			}
+
+			// Type de @params (optionnel)
+			$params = (is_array($params)) ? $params : [];
+
+
+			/* [2] Verification du chemin (existence repo+methode)
+			=========================================================*/
+			if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
+				return false;
+				// Gestion d'erreur interne
+
+
+			/* [3] Construction de l'objet
+			=========================================================*/
+			$this->params = $params;
+			$this->error = new Error(Err::Success);
+
+			/* [4] Enregistrement de la reponse
+			=========================================================*/
+			$this->answer = $this->dispatch();
+
+
+			return true; // On retourne que tout s'est bien passe
+
+		}
+
+
+
+
+		public function answer(){
+			if( $this->error->get() !== Err::Success )
+				return false;
+
+			return $this->answer;
+		}
+
+
+
+		/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE
+		*
+		* @return answer<mixed*> 								Retourne une reponse, si tout s'est bien passe
+		*
+		*/
+		private function dispatch(){
+			/* [1] On verifie qu'aucune erreur n'a ete signalee
+			=========================================================*/
+			if( $this->error->get() !== Err::Success ) // si il y a une erreur
+				return false;  // on la passe a la reponse
+
+
+			/* [2] On verifie que la methode est amorcable
+			=========================================================*/
+			if( !is_callable($this->getFunctionCaller()) ){
+				$this->error = new Error(Err::UncallableMethod, $this->path['method']);
+				return false;
+			}
+
+
+			/* [3] On amorce la methode
+			=========================================================*/
+			return call_user_func_array( $this->getFunctionCaller(), $this->params );
+		}
+
+
+
+		/* VERIFICATION DU FORMAT ET DE LA COHERENCE DU CHEMIN SPECIFIE
+		*
+		* @path<String> 									String correspondant au chemin de delegation ("repo/methode")
+		*
+		* @return validity<Boolean> 						Retourne si oui ou non l'objet est correct
+		*
+		*/
+		private function checkPath($path){
+			/* [1] Verification format general
+			=========================================================*/
+			if( !preg_match('#^([\w_-]+)/([\w_-]+)$#i', $path, $matches) ){ // Si mauvais format
+				$this->error = new Error(Err::WrongPathRepo);
+				return false;
+			}
+
+			// On recupere les donnes de la regex
+			$repository = $matches[1];
+			$method     = $matches[2];
+
+			/* [2] Verification de l'existence du repo (conf)
+			=========================================================*/
+			if( !array_key_exists($repository, $this->repositories) ){ // Si le repo n'est pas specifie dans la conf
+				$this->error = new Error(Err::UnknownRepo, $repository);
+				return false; // On retourne FALSE, si erreur
+			}
+
+			/* [3] Verification de l'existence de la methode (conf)
+			=========================================================*/
+			if( array_search($method, $this->repositories[$repository]) === false ){ // Si la methode n'est pas specifie dans la conf
+				$this->error = new Error(Err::UnknownMethod, $method);
+				return false; // On retourne FALSE, si erreur
+			}
+
+
+
+			/* [4] Enregistrement du chemin et renvoi de SUCCESS
+			=========================================================*/
+			$this->path = [
+				'repo'   => $repository,
+				'method' => $method
+			];
+
+			return true;
+		}
+
+
+
+
+
+		/* RENVOI LE CHEMIN D'AMORCAGE DE LA METHODE
+		*
+		* @return path<Array> 									Retourne le chemin d'amorcage de la requete
+		*
+		*/
+		private function getFunctionCaller(){
+			return [ '\\database\\repo\\'.$this->path['repo'], $this->path['method'] ];
+		}
+
+
+	}
+
+?>

src/modules/error/2.0/Err.php

@@ -0,0 +1,109 @@
+<?php
+
+
+	namespace error\core;
+
+
+	class Err{
+		/* [1] Success
+		=========================================================*/
+			const Success             = 0;
+
+
+		/* [2] Fichiers / Ressources
+		=========================================================*/
+			/* (1) Parsage json/xml */
+			const ParsingFailed       = 1;
+			/* (2) Fichier inexistant */
+			const UnreachableResource = 2;
+			/* (3) Erreur d'upload */
+			const UploadError         = 3;
+			/* (4) Mauvais format de fichier */
+			const FormatError         = 4;
+
+
+		/* [3] Permissions
+		=========================================================*/
+			/* (1) Token inexistant ou incorrect */
+			const TokenError          = 5;
+			/* (2) Permission non autorisée */
+			const PermissionError     = 6;
+
+
+
+
+		/* [4] API
+		=========================================================*/
+			/* (1) Le module n'est pas activé */
+			const DisabledModule      = 7;
+
+			/* (2) Le @path n'est pas renseigne */
+			const MissingPath         = 8;
+			/* (3) Verification de la coherence du chemin (existe dans la conf) */
+			const WrongPathModule     = 9;
+
+			/* (4) Module non specifie dans la conf */
+			const UnknownModule       = 10;
+			/* (5) Methode non specifie pour ce Module dans la conf */
+			const UnknownMethod       = 11;
+
+			/* (6) Module non amorcable */
+			const UncallableModule    = 12;
+			/* (7) Methode non amorcable */
+			const UncallableMethod    = 13;
+
+			/* (8) Erreur méthode HTTP */
+			const UnknownHttpMethod   = 14;
+
+			/* (9) Erreur de configuration */
+			const ConfigError         = 15;
+			/* (10) Paramètre manquant */
+			const MissingParam        = 16;
+			/* (11) Paramètre incorrect */
+			const WrongParam          = 17;
+			/* (12) Erreur dans le traitement */
+			const ModuleError         = 18;
+
+
+		/* [5] Database
+		=========================================================*/
+		/* (1) Base de données
+		---------------------------------------------------------*/
+			/* (1) Erreur lors de la creation d'un objet PDO (connection) */
+			const PDOConnection       = 19;
+
+		/* (2) Repositories
+		---------------------------------------------------------*/
+			/* (1) Verification de la coherence du chemin (existe dans la conf) */
+			const WrongPathRepo       = 20;
+
+			/* (2) Module non specifie dans la conf */
+			const UnknownRepo         = 21;
+
+			/* (3) Erreur dans le traitement */
+			const RepoError           = 22;
+
+		/* (3) ORM
+		---------------------------------------------------------*/
+			/* (1) Table n'existe pas */
+			const UnknownTable        = 23;
+			/* (2) Pas permissions de lire le schéma */
+			const NotAllowedSchema    = 24;
+
+
+		/* [6] Erreurs diverses
+		=========================================================*/
+			/* (1) Aucune donnée trouvée */
+			const NoMatchFound        = 25;
+
+			/* (2) Mauvais chemin de template */
+			const UnknownTemplate     = 26;
+
+			/* (3) géolocalisation échouée */
+			const UnknownAddress      = 27;
+
+			/* (4) Erreur inconnue */
+			const UnknownError        = 28;
+	}
+
+?>

src/modules/error/2.0/Error.php

@@ -0,0 +1,191 @@
+<?php
+
+
+	namespace error\core;
+
+	use \error\core\Err;
+
+	class Error{
+
+		private $error     = null;
+		private $arguments = [];
+
+		/* ERROR CONSTRUCTOR
+		*
+		* @error<const> 										Const error
+		* @arg1<String>											[OPT] Argument 1
+		* @arg2<String>											[OPT] Argument 2
+		* @arg...<String>										[OPT] Argument ...
+		*
+		* @return instance<Error> 								Error instance
+		*
+		*/
+		public function __construct($const){
+			call_user_func_array([$this, 'set'], func_get_args());
+		}
+
+		/* ERROR GETTER
+		*
+		* @return Err<Err::Constant> 					Error
+		*
+		*/
+		public function get(){ return $this->error; }
+
+		/* ERROR SETTER
+		*
+		* @error<const> 										Const error
+		* @arg1<String>											[OPT] Argument 1
+		* @arg2<String>											[OPT] Argument 2
+		* @arg...<String>										[OPT] Argument ...
+		*
+		* @return instance<Error> 								Error instance
+		*
+		*/
+		public function set($const){
+			/* [1] On découpe les arguments
+			=========================================================*/
+			/* (1) On récupère l'erreur */
+			$this->error = !is_numeric($const) ? Err::UnknownError : $const;
+
+			/* (2) On récupère les arguments */
+			$this->arguments = array_slice(func_get_args(), 1);
+		}
+
+
+		/* EXPLICITE UN CODE D'ERREUR
+		*
+		* @return explicit<String> 							Description explicite du code d'erreur
+		*
+		*/
+		public function explicit(){
+			switch($this->error){
+				case Err::Success:             return $this->Success();             break;
+				case Err::ParsingFailed:       return $this->ParsingFailed();       break;
+				case Err::UnreachableResource: return $this->UnreachableResource(); break;
+				case Err::UploadError:         return $this->UploadError();         break;
+				case Err::FormatError:         return $this->FormatError();         break;
+				case Err::TokenError:          return $this->TokenError();          break;
+				case Err::PermissionError:     return $this->PermissionError();     break;
+				case Err::DisabledModule:      return $this->DisabledModule();      break;
+				case Err::MissingPath:         return $this->MissingPath();         break;
+				case Err::WrongPathModule:     return $this->WrongPathModule();     break;
+				case Err::UnknownModule:       return $this->UnknownModule();       break;
+				case Err::UnknownMethod:       return $this->UnknownMethod();       break;
+				case Err::UncallableModule:    return $this->UncallableModule();    break;
+				case Err::UncallableMethod:    return $this->UncallableMethod();    break;
+				case Err::UnknownHttpMethod:   return $this->UnknownHttpMethod();   break;
+				case Err::ConfigError:         return $this->ConfigError();        break;
+				case Err::MissingParam:        return $this->MissingParam();        break;
+				case Err::WrongParam:          return $this->WrongParam();          break;
+				case Err::ModuleError:         return $this->ModuleError();         break;
+				case Err::PDOConnection:       return $this->PDOConnection();       break;
+				case Err::WrongPathRepo:       return $this->WrongPathRepo();       break;
+				case Err::UnknownRepo:         return $this->UnknownRepo();         break;
+				case Err::RepoError:           return $this->RepoError();           break;
+				case Err::UnknownTable:        return $this->UnknownTable();        break;
+				case Err::NotAllowedSchema:    return $this->NotAllowedSchema();    break;
+				case Err::NoMatchFound:        return $this->NoMatchFound();        break;
+				case Err::UnknownTemplate:     return $this->UnknownTemplate();     break;
+				case Err::UnknownAddress:      return $this->UnknownAddress();      break;
+				case Err::UnknownError:        return $this->UnknownError();        break;
+
+				default:                       return $this->UnknownDebugError();   break;
+			}
+		}
+
+
+		private function Success(){
+			return 'all right';
+		}private function ParsingFailed(){
+			if(	count($this->arguments) > 0 )
+				return $this->arguments[0].' parsing failed';
+			else
+				return 'parsing failed';
+		}private function UnreachableResource(){
+			return 'unreachable resource';
+		}private function UploadError(){
+			return 'upload error';
+		}private function FormatError(){
+			return 'format error';
+		}private function TokenError(){
+			return 'bad or expired token';
+		}private function PermissionError(){
+			return 'permission error';
+		}private function DisabledModule(){
+			return 'disabled module';
+		}private function MissingPath(){
+			return 'missing path';
+		}private function WrongPathModule(){
+			return 'wrong module\'s path';
+		}private function UnknownModule(){
+			if(	count($this->arguments) > 0 )
+				return 'unknown module \''.$this->arguments[0].'\'';
+			else
+				return 'unknown module';
+		}private function UnknownMethod(){
+			if(	count($this->arguments) > 0 )
+				return 'unknown method \''.$this->arguments[0].'\'';
+			else
+				return 'unknown method';
+		}private function UncallableModule(){
+			if(	count($this->arguments) > 0 )
+				return 'uncallable module \''.$this->arguments[0].'\'';
+			else
+				return 'uncallable module';
+		}private function UncallableMethod(){
+			if(	count($this->arguments) > 0 )
+				return 'uncallable method \''.$this->arguments[0].'\'';
+			else
+				return 'uncallable method';
+		}private function UnknownHttpMethod(){
+			return 'unknown HTTP method';
+		}private function ConfigError(){
+			return 'configuration error';
+		}private function MissingParam(){
+			if(	count($this->arguments) > 0 )
+				return 'missing param \''.$this->arguments[0].'\'';
+			else
+				return 'missing param';
+		}private function WrongParam(){
+			if(	count($this->arguments) > 0 )
+				if(	count($this->arguments) > 1 )
+					return 'wrong param \''.$this->arguments[0].'\' expected to be of type \''.$this->arguments[1].'\'';
+				else
+					return 'wrong param \''.$this->arguments[0].'\'';
+			else
+				return 'wrong param';
+		}private function ModuleError(){
+			return 'module error';
+		}private function PDOConnection(){
+			return 'database error';
+		}private function WrongPathRepo(){
+			return 'wrong repository\'s path';
+		}private function UnknownRepo(){
+			return 'unknown repository';
+		}private function RepoError(){
+			return 'repository error';
+		}private function UnknownTable(){
+			return 'unknown table';
+		}private function NotAllowedSchema(){
+			return 'schema browsing not allowed';
+		}private function NoMatchFound(){
+			return 'no match found';
+		}private function UnknownTemplate(){
+			return 'unknown template';
+		}private function UnknownAddress(){
+			return 'unknown';
+		}private function UnknownError(){
+			return 'unknown error';
+		}private function UnknownDebugError(){
+			return 'unknown debug error';
+		}
+
+
+		public function setHttpCode(){
+			http_response_code( $this->error == Err::Success ? 200 : 417 );
+		}
+
+	}
+
+
+?>

src/modules/orm/0.8-2/core/SQLBuilder.php

@@ -0,0 +1,428 @@
+<?php
+
+	namespace orm\core;
+
+	use \database\core\DatabaseDriver;
+	use \orm\core\Rows;
+
+
+	class SQLBuilder{
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "SELECT" AVEC UNE LISTE DE CHAMPS
+		*
+		* @sqlFields<Array> 										Liste de champs : [table => field => [func, alias] ]
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function SELECT($sqlFields){
+			return $sqlFields;
+		}
+
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "ORDER BY" AVEC UNE LISTE DE CHAMPS
+		*
+		* @tables<Array> 											Liste de champs : [table => fields]
+		*
+		* @return sql<Array> 										Renvoie un tableau formatté
+		*
+		*/
+		public static function ORDERBY($tables){
+			return $tables;
+		}
+
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "GROUP BY" AVEC UNE LISTE DE CHAMPS
+		*
+		* @tables<Array> 											Liste de champs : [table => fields]
+		*
+		* @return sql<Array> 										Renvoie un tableau formatté
+		*
+		*/
+		public static function GROUPBY($tables){
+			return $tables;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "FROM" AVEC UNE LISTE DE TABLES
+		*
+		* @tables<Array> 										Liste de tables OU SQL PUR
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function FROM($tables){
+			return $tables;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "UPDATE" AVEC LA TABLE EN QUESTION
+		*
+		* @table<String> 										Table en question
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function UPDATE($table){
+			return $table;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "DELETE" AVEC LA TABLE EN QUESTION
+		*
+		* @table<String> 										Table en question
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function DELETE($table){
+			return $table;
+		}
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE TEXTUELLE "IN" AVEC UNE LISTE DE TABLES
+		*
+		* @field<Array> 										Tableau contenant [table, field]
+		* @array<Array>											Valeurs de la clause IN
+		* @offset<int>											Permet de rendre la condition unique (nommage des variables)
+		* @bound<Arary>										Tableau associatif contenant les variables "bindés" -> ajout des champs
+		*
+		* @return sql<String> 									Renvoie le textuel formatté
+		*
+		*/
+		public static function IN($field, $array, $offset=0, &$bound){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = '';
+
+			/* [1] On construit la requête
+			=========================================================*/
+			/* (1) Champ */
+			$sql .= $field[0].'.'.$field[1].' IN (';
+
+			/* (2) Valeurs */
+			$c = 0;
+			foreach($array as $i=>$value){
+				if( $c > 0 ) $sql .= ', ';
+
+				$sql .= ':'.$field[0].'_x_'.$field[1].'_'.$offset.'_'.$i;
+
+				$bound[':'.$field[0].'_x_'.$field[1].'_'.$offset.'_'.$i] = $value;
+
+				$c++;
+			}
+
+			return $sql.")";
+		}
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE TEXTUELLE "WHERE" AVEC UNE LISTE DE TABLES
+		*
+		* @field<Array> 										Tableau contenant [table, field]
+		* @valeur<Array>										Valeurs de la clause WHERE [valeur, opérateur]
+		* @offset<int>											Permet de rendre la condition unique (nommage des variables)
+		* @bound<Arary>										Tableau associatif contenant les variables "bindés" -> ajout des champs
+		*
+		* @return sql<String> 									Renvoie le textuel formatté
+		*
+		*/
+		public static function WHERE($field, $value, $offset=0, &$bound){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = '';
+
+
+			/* [1] On construit la requête
+			=========================================================*/
+			/* (1) Chamo */
+			$sql .= $field[0].'.'.$field[1].' ';
+
+			/* (2) Opérateur */
+			$sql .= substr($value[1], 2, -2).' ';
+
+			/* (3) Variable */
+			$sql .= ':'.$field[0].'_x_'.$field[1].'_'.$offset;
+
+			$bound[':'.$field[0].'_x_'.$field[1].'_'.$offset] = $value[0];
+
+
+			return $sql;
+		}
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "SET" AVEC UNE LISTE DE TABLES
+		*
+		* @values<Array> 										Tableau de la forme [ field=>value, field2=>value2 ]
+		* @bound<Arary>										Tableau associatif contenant les variables "bindés" -> ajout des champs
+		*
+		* @return sql<Array> 									Renvoie un tableau formatté
+		*
+		*/
+		public static function SET($values, &$bound){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = [];
+
+
+			/* [1] On construit la requête
+			=========================================================*/
+			$c = 0;
+			foreach($values as $field=>$value){
+				/* (1) Champ */
+				$sql[$c] = $field.' = ';
+
+				/* (2) Variable */
+				$sql[$c] .= ':update_'.$field;
+
+				$bound[':update_'.$field] = $value;
+
+				$c++;
+			}
+
+			return $sql;
+		}
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE FORMATTEE "LIMIT" AVEC UN NOMBRE D'ENTREES
+		*
+		* @count<int> 											Nombre limite
+		*
+		* @return sql<Array> 									Renvoie un sql formatté
+		*
+		*/
+		public static function LIMIT($count=null){
+			/* [0] Initialisation
+			=========================================================*/
+			$sql  = '';
+
+
+			/* [1] On construit la requête
+			=========================================================*/
+			if( intval($count) == $count )
+				$sql = intval($count);
+
+			return $sql;
+		}
+
+
+
+
+
+
+
+
+
+
+
+
+
+		/* CONSTRUIT LA REQUETE A PARTIR D'UNE REQUETTE FORMATTEE
+		*
+		* @request<Arary> 										Requête formattée
+		*
+		* @return sql<String> 									Requête formattée en SQL
+		*
+		*/
+		public static function BUILD($request){
+			/* [0] On initialise le retour
+			=========================================================*/
+			$sql = '';
+
+			/* [1] Gestion dans l'ordre
+			=========================================================*/
+			foreach($request as $clause=>$statements){
+
+				switch($clause){
+
+					/* (1) Clause SELECT
+					---------------------------------------------------------*/
+					case 'SELECT':
+						$sql .= "SELECT ";
+						$c = 0;
+						foreach($statements as $table=>$fields)
+							foreach($fields as $field=>$select){
+
+								/* (1) On construit le nom du champ */
+								$fieldStr = "$table.$field";
+
+								/* (2) On ajout le DISTINCT s'il y a lieu */
+								if( isset($select[1]) && $select[1] )
+									$fieldStr = "DISTINCT $fieldStr";
+
+								/* (3) On ajoute la fonction d'aggrégation s'il y a lieu */
+								if( isset($select[0]) && !is_null($select[0]) )
+									$fieldStr = substr($select[0], 2, -2)."($fieldStr)";
+
+
+								/* (4) On ajoute l'alias */
+								if( isset($select[0]) && !is_null($select[0]) )
+									$fieldStr = "$fieldStr as agg_$field";
+								else
+									$fieldStr = "$fieldStr";
+
+								$sql .= ($c==0) ? "$fieldStr" : ", $fieldStr";
+
+								$c++;
+							}
+
+							$sql .= "\n";
+						break;
+
+					/* (2) Clause FROM
+					---------------------------------------------------------*/
+					case 'FROM':
+							$sql .= 'FROM ';
+
+							$c = 0;
+							foreach($statements as $field){
+								$sql .= ($c==0) ? "$field" : ", $field";
+								$c++;
+							}
+
+							$sql .= "\n";
+						break;
+
+
+					/* (3) Clause WHERE
+					---------------------------------------------------------*/
+					case 'WHERE':
+							$c = 0;
+							foreach($statements as $field){
+								$sql .= ($c==0) ? "WHERE $field\n" : "AND   $field\n";
+								$c++;
+							}
+
+							$sql .= ($c==0) ? '' : "\n";
+						break;
+
+
+
+					/* (4) Clause LIMIT
+					---------------------------------------------------------*/
+					case 'LIMIT':
+							if( is_numeric($statements) )
+								$sql .= 'LIMIT '.intval($statements);
+						break;
+
+
+					/* (5) Clause DELETE
+					---------------------------------------------------------*/
+					case 'DELETE':
+							$sql .= "DELETE FROM $statements\n";
+						break;
+
+
+					/* (6) Clause UPDATE
+					---------------------------------------------------------*/
+					case 'UPDATE':
+							$sql .= "UPDATE $statements\n";
+						break;
+
+
+					/* (7) Clause SET
+					---------------------------------------------------------*/
+					case 'SET':
+							$c = 0;
+							foreach($statements as $field){
+								$sql .= ($c>0) ? "\n, $field" : "SET $field";
+								$c++;
+							}
+							$sql .= "\n";
+						break;
+
+					/* (8) Clause GROUP BY
+					---------------------------------------------------------*/
+					case 'GROUPBY':
+							$sql .= 'GROUP BY ';
+
+							$c = 0;
+							foreach($statements as $table=>$fields)
+								foreach($fields as $field){
+									$sql .= ($c==0) ? "$table.$field" : ", $table.$field";
+									$c++;
+								}
+
+							$sql .= "\n";
+						break;
+
+					/* (9) Clause ORDER BY
+					---------------------------------------------------------*/
+					case 'ORDERBY':
+
+							// si aucun ORDER BY, on quitte
+							if( count($statements) == 0 )
+								continue;
+
+							$sql .= 'ORDER BY ';
+
+							$c = 0;
+							foreach($statements as $table=>$fields)
+								foreach($fields as $field=>$order){
+
+									if( $c > 0 ) $sql .= ', ';
+
+									$sql .= "$table.$field ". substr($order, 2, -2);
+
+									$c++;
+								}
+
+							$sql .= "\n";
+						break;
+				}
+
+
+			}
+
+
+
+
+
+
+
+			/* [2] On retourne le résultat
+			=========================================================*/
+			return $sql;
+		}
+
+
+
+	}
+
+
+?>

src/modules/orm/0.8-2/core/Table.php

@@ -0,0 +1,194 @@
+<?php
+
+
+	namespace orm\core;
+
+	use \database\core\DatabaseDriver;
+	use \orm\core\Rows;
+
+
+	// CLASSE MAITRE
+	class Table{
+
+		private static $database = 'logauth';
+
+
+		/* RENVOIE LES DONNEES D'UNE TABLE
+		*
+		* @table<String> 										Nom de la table à selectionner
+		*
+		* @return this<ORM> 									Retourne une instance de l'ORM
+		*
+		*/
+		public static function get($table_name){
+			/* [0] Initialisation des attributs
+			=========================================================*/
+			$schema = [
+				'database' => self::$database,
+				'table'    => null,
+				'columns'  => null
+			];
+
+
+			/* [1] On vérifie que la table existe
+			=========================================================*/
+			/* (1) Requête */
+			$checkTable       = Database::getPDO()->query("SHOW tables FROM ".self::$database);
+			$checkTableResult = Database::delNumeric( $checkTable->fetchAll() );
+
+			/* (2) On met en forme les données */
+			$tables = [];
+			foreach($checkTableResult as $table)
+				$tables[] = $table['Tables_in_'.self::$database];
+
+			/* (3) Si n'existe pas, on renvoie une erreur */
+			if( !in_array($table_name, $tables) )
+				return null;
+
+			/* (4) On enregistre les données */
+			$schema['table'] = $table_name;
+
+
+
+			/* [2] Si la table existe, on récupère les colonnes
+			=========================================================*/
+			/* (1) On récupère les colonnes */
+			$getColumns    = Database::getPDO()->query("SHOW columns FROM ".self::$database.'.'.$table_name);
+			$columnsResult = Database::delNumeric( $getColumns->fetchAll() );
+
+			/* (2) On met en forme les données */
+			$columns = [];
+			foreach($columnsResult as $col){
+				// On formatte le type //
+				$type = $col['Type'];
+				if( preg_match('/^(int|float|varchar|text)/i', $type, $m) )
+					$type = strtolower($m[1]);
+
+				// On ajoute la colonne //
+				$columns[$col['Field']] = [
+					'type'    => $type,
+					'primary' => $col['Key'] == 'PRI'
+				];
+			}
+
+
+			/* (3) Si on trouve rien, on envoie une erreur */
+			if( !is_array($columns) || count($columns) == 0 )
+				return null;
+
+			/* (4) On enregistre les colonnes */
+			$schema['columns'] = $columns;
+
+
+
+			/* [3] On récupère les clés étrangères
+			=========================================================*/
+			/* (1) On récupère le texte du 'CREATE TABLE' */
+			$getCreateTable = Database::getPDO()->query("show create table ".$table_name);
+			$create_table = $getCreateTable->fetch()['Create Table'];
+
+			/* (2) On découpte en lignes */
+			$create_table_lines = explode("\n", $create_table);
+
+			/* (3) Pour chaque ligne, si c'est une contrainte, on l'enregistre dans la colonne associée */
+			foreach($create_table_lines as $i=>$line)
+				if( preg_match('/CONSTRAINT `.+` FOREIGN KEY \(`(.+)`\) REFERENCES `(.+)` \(`(.+)`\)+/i', $line, $m) )
+					$schema['columns'][$m[1]]['references'] = [$m[2], $m[3]];
+
+
+
+			/* [3] On renvoie une instance de 'Rows'
+			=========================================================*/
+			return new Rows($schema);
+
+		}
+
+
+
+	};
+
+
+
+	/*** USE CASE :: ACCESS TABLE `user` ***/
+	// ORM::Table('user');
+
+
+	/**** USE CASE :: WHERE ****/
+	// WHERE `username` = 'someUsername'
+	// ORM::Table('user')->whereUsername('someUsername');
+	//                    EQUIVALENT TO
+	// ORM::Table('user')->whereUsername('someUsername', Rows::COND_EQUAL);
+
+	// WHERE `id_user` < 100
+	// ORM::Table('user')->whereIdUser(100, Rows::COND_INF);
+
+	// WHERE `id_user` <= 100
+	// ORM::Table('user')->whereIdUser(100, Rows::COND_INFEQ);
+
+	// WHERE `id_user` > 10
+	// ORM::Table('user')->whereIdUser(10, Rows::COND_SUP);
+
+	// WHERE `id_user` >= 10
+	// ORM::Table('user')->whereIdUser(10, Rows::COND_SUPEQ);
+
+	// WHERE `id_user` in (1, 2, 3, 8)
+	// ORM::Table('user')->whereIdUser([1, 2, 3, 8], Rows::COND_IN);
+
+	// WHERE `id_user` LIKE 'John %'
+	// ORM::Table('user')->whereIdUser('John %', Rows::COND_LIKE);
+
+
+	/*** USE CASE :: ORDER BY ****/
+	// ORDER BY `a` ASC, `b` DESC
+	// Table::get('someTable')
+	//		->orderby('a', Rows::ORDER_ASC)
+	//		->orderby('b', Rows::ORDER_DESC);
+	//
+	// Note: `Rows::ORDER_ASC` is set by default if the given FLAG is invalid
+
+
+	/**** USE CASE :: SELECT ****/
+	// SELECT id_user, username
+	// Table::get('user')
+	//		->select('id_user')
+	//		->select('username');
+
+
+	/**** USE CASE :: AGGREGATION FUNCTIONS ****/
+	// SELECT COUNT(`count`)
+	// Table::get('user')->select('count', Rows::SEL_COUNT)
+
+	// SELECT SUM(distinct `count`)
+	// Table::get('user')->select('count', Rows::SEL_SUM, Rows::SEL_DISTINCT);
+
+	// SELECT AVG(`count`)
+	// Table::get('user')->select('count', Rows::SEL_AVG);
+
+	// SELECT MAX(`id_user`)
+	// Table::get('user')->select('id_user', Rows::SEL_MAX);
+
+	// SELECT MIN(`id_user`)
+	// Table::get('user')->select('id_user', Rows::SEL_MIN);
+
+	// SELECT GROUP_CONCAT(`count`)
+	// Table::get('user')->select('count', Rows::SEL_CONCAT);
+
+
+
+	/**** USE CASE :: FETCH ****/
+	// SELECT ... FROM ... WHERE ... ORDERBY ... LIMIT ...
+	// Table::get('user')
+	//		->select('id_user')
+	//		->fetch();
+
+	// SELECT UNIQUE ... FROM ... WHERE ... ORDERBY ... LIMIT ...
+	// Table::get('user')
+	//		->select('id_user')
+	//		->unique->fetch();
+
+
+	/**** USE CASE :: TABLE JOIN ****/
+	// WHERE `user`.`id_user` = `user_merge`.`id_user`
+	// Table::get('user_merge')->join(
+	//		Table::get('user')->whereIdUser(1, Rows::COND_SUP)
+	// );