Les conseils que je te donne: n'écris pas une ligne toi même sur Hoa, trouve un type qui le fera pour toi, et à qui tu expliquera l'aspect technique, mais qui n'aura aucun parti pris, tu auras une doc qui sera "lisible" et surtout sans "parti pris" je crois sincèrement que tu ne devrais jamais parler d'Hoa plubliquement si tu veux que ton framework rencontre un quelconque succès.
Mauvaise idée pour deux raisons : la première c'est qu'
HyWaN est un bon écrivant, la deuxième c'est qu'il est capable de vendre du sable à un chameau, même à moi il est arriver à foutre le doute (c'est pour ça que je lui parle plus, j'ai peur de finir dans une cave, le crâne razer à faire de la doc). Si non je soutiens
Nagol sur le fond.
Pour l'encodage :
firefox-5.0-r1, Gentoo Linux ~amd64
Pour revenir à la question : (ton site rame, il est coder en Hoa ou quoi ?!)
Ce qui me dérange dans l'aspect propagande ce que je reproche c'est cet aspect "c'est bien s'qu'on fait, faites nous confiance", il faudrait citer et faire des liens sur les principes, même si les gens ne les suivent pas au moins ça rassure.
Pour le code, je l'ai regardé pendant plus d'un heure (et oui, bizarrement à 4h du matin tout le monde dors).
Je me permet de copier ici
Library/Database/Database.php (je déplore l'abandon de subversion au passage) :
<?php
/**
* Hoa
*
*
* @license
*
* New BSD License
*
* Copyright © 2007-2011, Ivan Enderlin. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the Hoa nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS AND CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
namespace {
from('Hoa')
/**
* \Hoa\Database\Exception
*/
-> import('Database.Exception')
/**
* \Hoa\Database\Dal
*/
-> import('Database.Dal.~');
/**
* \Hoa\Database\Model\Table
*/
//-> import('Database.Model.Table')
/**
* \Hoa\Database\Model\Collection
*/
//-> import('Database.Model.Collection')
/**
* \Hoa\Database\Cache\Table
*/
//-> import('Database.Cache.Table');
}
namespace Hoa\Database {
/**
* Class \Hoa\Database.
*
* Main class of the \Hoa\Database package. Manage the autoload connection, all
* databases parameters, table and base cache etc.
*
* @author Ivan Enderlin <[email protected]>
* @copyright Copyright © 2007-2011 Ivan Enderlin.
* @license New BSD License
*/
class Database implements \Hoa\Core\Parameter\Parameterizable {
/**
* Singleton.
*
* @var \Hoa\Database object
*/
private static $_instance = null;
/**
* Collections of table caches.
*
* @var \Hoa\Database array
*/
protected $cache = array();
/**
* Parameters.
*
* @var \Hoa\Core\Parameter object
*/
protected $_parameters = null;
/**
* Singleton, and set parameters.
*
* @access private
* @param array $parameters Parameters.
* @return void
* @throw \Hoa\Database\Exception
*/
private function __construct ( Array $parameters = array() ) {
$this->_parameters = new \Hoa\Core\Parameter(
$this,
array(
'base' => null,
'table' => null,
'field' => null,
'schema' => null
),
array(
'base.class' => '(:base:U:)Base',
'base.file' => '_(:base:U:).php',
'base.directory' => 'hoa://Data/Etc/Database/Model/(:base:U:)/',
'table.class' => '(:table:U:)Table',
'table.file' => '(:table:U:).php',
'table.primaryKey' => 'Pk(:table:U:)',
'table.foreignKey' => 'Fk(:field:U:)',
'collection.class' => '(:table:U:)Collection',
'cache.enable' => true,
'cache.file.table' => '(:table:U:)Table.cache',
'cache.file.query' => '(:table:U:)Query.cache',
'cache.directory' => 'hoa://Data/Var/Private/Database/Cache/(:base:U:)/',
'constraint.method' => 'user(:field:U:)Constraint',
'schema.file' => '(:schema:U:).xml',
'schema.directory' => 'Data/Database/Schema/',
'connection.list.default.dal' => Dal::PDO,
'connection.list.default.dsn' => 'mysql:host=localhost;dbname=foobar',
'connection.list.default.username' => 'root',
'connection.list.default.password' => '',
'connection.list.default.options' => true,
'connection.autoload' => null // or connection ID, e.g. 'default'
)
);
$this->_parameters->setParameters($parameters);
return;
}
/**
* Singleton : get instance of \Hoa\Database.
*
* @access public
* @param array $parameters Parameters.
* @return void
*/
public static function getInstance ( Array $parameters = array() ) {
if(null === self::$_instance) {
self::$_instance = new self($parameters);
if(null === $autoload = self::$_instance->getParameter('connection.autoload'))
return self::$_instance;
Dal::getInstance($autoload);
}
return self::$_instance;
}
/**
* Get parameters.
*
* @access public
* @return \Hoa\Core\Parameter
*/
public function getParameters ( ) {
return $this->_parameters;
}
/**
* Get a base.
*
* @access public
* @param string $name The base name.
* @return \Hoa\Database\Model\Base
* @throw \Hoa\Database\Exception
*/
public function getBase ( $name ) {
/*
$oldBase = $this->getKeyword('base');
$this->setKeyword($name);
$directory = $this->getFormattedParameter('base.directory');
$file = $this->getFormattedParameter('base.file');
require_once $directory . $file;
$class = $this->getFormattedParameter('base.class');
if(!class_exists($class))
throw new \Hoa\Database\Exception(
'Cannot find the base class %s in %s.',
1, array($class, $directory . $file));
$this->setKeyword($oldBase);
return new $class();
*/
}
/**
* Get a table.
*
* @access public
* @param string $name The table name, must match with :
* base.table.
* @return \Hoa\Database\Model\Table
* @throw \Hoa\Database\Exception
*/
public function getTable ( $name ) {
/*
$cache = $this->getTableCache($name);
if(false !== $return = $cache->get(null))
return $return;
if(false === strpos($name, '.'))
throw new \Hoa\Database\Exception(
'The table name must match with <base>.<table>; given %s.',
2, $name);
list($base, $name) = explode('.', $name);
$oldBase = $this->getKeyword('base');
$oldTable = $this->getKeyword('table');
$this->setKeyword('base', $base);
$this->setKeyword('table', $table);
$directory = $this->getFormattedParameter('base.directory');
$file = $this->getFormattedParameter('table.file');
require_once $directory . $file;
$class = $this->getFormattedParameter('table.class');
if(!class_exists($class))
throw new \Hoa\Database\Exception(
'Cannot find the table class %s in %s.',
3, array($class, $directory . $file));
$instance = new $class();
$cache->set($name, $instance);
$this->setKeyword('base', $oldBase);
$this->setKeyword('table', $oldTable);
return $instance;
*/
}
/**
* Clean a specific cache.
*
* @access public
* @param string $name The table name, must match with :
* base.table.
* @return void
*/
public function cleanTableCache ( $name ) {
/*
$this->getTableCache($name)->clean(null);
*/
}
/**
* Get a table cache.
*
* @access protected
* @return \Hoa\Database\Cache\Table
*/
protected function getTableCache ( $name ) {
/*
$nameu = strtolower($name);
if(isset($this->cache[$nameu]))
return $this->cache[$nameu];
$this->cache[$nameu] = new \Hoa\Database\Cache\Table($name);
return $this->cache[$nameu];
*/
}
}
}
Je reproche deux choses majeure à ce code :
* La majorité ne sert à rien (mais passons on est dans les dépôts)
* Son héritage, qui est selon moi stupide
Je vais développer pour pas faire un agression dans le vent comme tu l'as fait (j'y reviendrais). Il aurait mieux valu faire une classe abstraite ayant plus de méthode et dont toutes les classes d'entrées de bibliothèques dérivent, implémenter une interface pour un méthode... Mais bon, c'est aussi discutable que Interface Abstract Concrete, par contre le fait d'avoir plus classes/interfaces dans le même fichier, ça améliore les perfs, mais c'est pas correcte méthodologiquement.
Concernant ton commentaire :
Déjà on est des utilisateurs potentiels, pas des concepteurs de framework, si non on s'y prendrais certainement autrement (comprendre différemment), notre rôle c'est de pointer du doigts les limites et de formuler des demandes, le tiens c'est de repousser les limites de ton framework et de créer les bibliothèques qu'on demande. Après certains vont contribuer à Hoa, que ce soit sous forme de code, de remonter de bug, de demandes, de participation sur les forums, de pubs... Chacun doit être en mesure de choisir son implication dans ton projet, tu n'as pas à forcer qui que ce soit "tout ou rien".
Concernant ta doc, je suis pas voyant, je lis pas dans les lignes du pieds, je juge avec ce que j'ai, c'est un peu comme si tu te présentait au BAC avec que du potentiel, on juge pas le potentiel, c'est impossible.
Dans ZF, mais corrigez moi, je rappel que j'ai commencé il y a moins de 15 jours, il y a deux choses majeure qui sont présentes et qui me manque dans Hoa :
* Quand je cré un projet ZF il me crée trois fichiers importants (je compte pas les dossiers même si tout est fichier) /public/index.php (qui se démène à tout initialiser et à lancer le bootstrap) /application/bootstrap.php et /application/configs/application.ini pour les configurations. ET C'EST TOUT, ZF étant un framework verbeux c'est le maximum qu'on peut attendre, dans Hoa, d'après ce que j'ai vu on a beaucoup plus de fichiers (notamment l'éclatement de Core et Library).
* Dans ZF lorsqu'on à une classe quelconque (prenons Zend_Db_Table_Row) on a en premier lieu Zend_Db_Table_Row_Interface qui décire les méthodes et leurs arguments, puis viens Zend_Db_Table_Row_Abstract qui implémente toute ou une partie de ces méthodes et enfin Zend_Db_Table_Row qui finie l'implémentation ou surcharge Zend_Db_Table_Row_Abstract (dans l'exemple il me semble qu'elle n'a plus rien à faire).
Voilà, tu es venu faire ta promo ici, il faut être ouvert au débat, encore une fois, les anciennes versions de la doc étaient biens, inspirent-en, ça ne peut te faire que du bien.
Maintenant je vais justifier les raisons pour lesquels je ne choisirais pas Hoa pour mes développements :
* Déjà je travail dans un univers où les outils que l'on utilisent sont TRÈS TRÈS TRÈS TRÈS contrôlés
* Hoa dispose d'un faible communauté et d'une faible visibilité
* Hoa n'est valable qu'à partir de PHP 5.3 et je bosse actuelle sur une 5.2.4
* La documentation est inachevée
* Je n'ai pas encore maitrisé ZF malgrès mes 10 heures par jour dessus
Voilà, ce que je voulais mettre en évidence c'est que même si je trouve ton travail prometteur (bien que, quoi que vous en disiez, le monde du travail et de la recherche sont relativement différents [je sais de quoi je parle]), ce sont des contraintes qui me dépassent. Cependant, si tu arrive à faire ton travail (dont accepter les critiques qu'on te formule), je serais ravis de suivre ton projet.
) mais juste une volonté d'être clair. Peut-être qu'on s'y prend mal. On va revoir ça avec la communauté.
