Witam,
korzystając z frameworka Kohana brakowało mi możliwości stosowania komponentów (często wykorzystywałem je przy pracy z Symfony). W związku z tym jakiś czas temu napisałem sobie rozszerzenie, które (moim zdaniem) nieźle spełnia funkcję komponentów w Kohana.

application/helpers/symfony.php

[PHP] pobierz, plaintext 
<?php
/**
 * Helper zawierający metody rodem z Symfony ;)
 * 
 * @package helpers
 */
class symfony {
    /**
     * Renderuje wskazany komponent.
     *
     * @param string $name Nazwa komponentu.
     * @param string $action Wywoływana akcja.
     * @param array $params Tablica przekazywanych parametrów.
     */
    public static function include_component($name, $action, array $params = array()) {
        $class = ucfirst($name).Component::CLASS_SUFFIX;
    
        require_once(APPPATH.Component::COMPONENTS_DIRECTORY.'/'.$name.'.php');
        
        $obj = new $class($name, $action, $params);
        $obj->$action();
        echo $obj->render();
    }
}
?>
[PHP] pobierz, plaintext 

application/libraries/Component.php

[PHP] pobierz, plaintext 
<?php
/**
 * Klasa definiująca komponent.
 * 
 * Komponent to "podwidok" posiadający własną logikę.
 *
 * @package libraries
 */
class Component {
    /**
     * Nazwa komponentu.
     *
     * @var string
     */
    private $name;
    
    /**
     * Wywoływana akcja.
     *
     * @var string
     */
    private $action;
    
    /**
     * Zbiór parametrów przekazywanych do komponentu.
     *
     * @var array
     */
    private $params;
    
    /**
     * Obiekt widoku danego komponentu.
     *
     * @var View
     */
    protected $view;
    
    /**
     * Tworzy nowy obiekt komponentu.
     *
     * @param string $name Nazwa komponentu.
     * @param string $action Wywoływana akcja.
     * @param array $params Tablica przekazywanych parametrów.
     */
    public function __construct($name, $action, array $params = array()) {
        $this->name = $name;
        $this->action = $action;
        $this->params = $params;
        
        $this->view = new View($name.'/'.$action.self::VIEWS_SUFFIX);
    }
    
    /**
     * Pobiera wartość parametru przekazanego do komponentu.
     * 
     * W przypadku gdy wartość nie zostanie odnaleziona zwraca wartość domyślną ($default).
     *
     * @param string $param Nazwa parametru.
     * @param mixed $default Wartość domyślna.
     * @return mixed
     */
    protected function getParam($param, $default = null) {
        return isset($this->params[$param]) ? $this->params[$param] : $default;
    }
    
    /**
     * Renderuje oraz zwraca szablon komponentu.
     *
     * @return string Szablon komponentu.
     */
    public function render() {
        return $this->view->render();
    }
    
    /**
     * Nazwa podkatalogu w katalogu application, w którym zlokalizowane będą klasy komponentów.
     */
    const COMPONENTS_DIRECTORY = 'components';
    
    /**
     * Suffix dołączany do nazwy komponentu w celu utworzenia nazwy klasy.
     * 
     * Nazwa klasy komponentu składa się z jego nazwy rozpoczynającej się od wielkiej litery
     * oraz od poniższego suffixu [nazwa_komponentu][SUFFIX], np.
     * class Category_Component {}
     */
    const CLASS_SUFFIX = '_Component';
    
    /**
     * Suffix dla pliku widoku komponentu.
     *
     * Widoki należy umieszczać w folderze application/views jako [nazwa_komponentu]/[akcja][SUFFIX],
     * np. application/category/menu_component.php
     */
    const VIEWS_SUFFIX = '_component';
}
?>
[PHP] pobierz, plaintext 

Aby dodać komponent do widoku (w moim przypadku jest to application/views/template.php) należy:
application/components/user.php

[PHP] pobierz, plaintext 
<?php
class User_Component extends Component {
    public function test() {
        // przypisanie aktualnego czasu do widoku
        $this->view->set('time', time());
        
        // utworzenie modelu użytkownika
        $mdlUser = new User_Model();
        // pobranie danych z bazy na podstawie przekazanego parametru
        $user = $mdlUser->get($this->getParam('userId'));
        // przypisanie pobranych danych do widoku
        $this->view->set('user', $user);
    }
}
?>
[PHP] pobierz, plaintext 

application/views/user/test_component.php

[PHP] pobierz, plaintext 
<p>Oto przykładowy komponent.</p>
<p>Czas: <?= $time ?>.</p>
<p>User: <?= $user['username'] ?></p>
[PHP] pobierz, plaintext 

application/views/template.php

[PHP] pobierz, plaintext 
<?php symfony::include_component('user', 'test', array('userId' => 1)) ?>
[PHP] pobierz, plaintext 

Bardziej życiowy przykład zastosowania: wyświetlanie panelu użytkownika. Jeżeli użytkownik nie jest zalogowany to wyświetlany jest formularz logowania, natomiast jeśli jest już zalogowany to wyświetlane jest info powitalne i link do wylogowania.

application/components/user.php

[PHP] pobierz, plaintext 
<?php
class User_Component extends Component {    
    public function panel() {
        $session = Session::instance();
        
        $isUserAuthenticated = $session->isUserAuthenticated();
        $this->view->set('isUserAuthenticated', $isUserAuthenticated);
        
        if ($isUserAuthenticated === true) {
            $this->view->set('username', $session->getUserData('username'));
            $this->view->set('isActive', $session->getUserData('is_active'));
        }
    }
}
?>
[PHP] pobierz, plaintext 

application/views/user/panel_component.php

[PHP] pobierz, plaintext 
<?php if ($isUserAuthenticated === true): ?>
<p>Witaj <strong><?= html::anchor('user/profile', $username) ?></strong>! <?= html::anchor('authentication/logout', 'Wyloguj &raquo;') ?></p>
    <?php if ($isActive == 'f'): ?>
    <p><strong>Konto nieaktywowane!</strong></p>
    <?php endif; ?>
<?php else: ?>
<?= form::open('authentication/login') ?>
    <fieldset>    
        <ul>
            <li>
                <label for="header_authentication_username">Nazwa użytkownika:</label>
                <?= form::input('authentication[username]', '', 'id="header_authentication_username"') ?>
            </li>
            <li>
                <label for="header_authentication_password">Hasło dostępu:</label>
                <?= form::password('authentication[password]', '', 'id="header_authentication_password"') ?>
            </li>
            <li>
                <input type="submit" value="Zaloguj" />
            </li>
        </ul>
    </fieldset>
<?= form::close() ?>
<?php endif; ?>
[PHP] pobierz, plaintext 

Wczytanie komponentu w application/views/template.php:

[PHP] pobierz, plaintext 
<?php symfony::include_component('user', 'panel') ?>
[PHP] pobierz, plaintext 

Prosiłbym o opinie oraz ewentualne uwagi czy sugestie.

pion

Mógłbyś ogólnie przybliżyć, w czym mają pomagać i generalnie do czego mają służyć te komponenty? Wyświetlanie formularza lub informacji można spokojnie zrealizować we frameworku bez użycia żadnych komponentów. Nie korzystałem dotychczas z Symfony, dlatego nie jestem w tym zorientowany i chciałbym się dowiedzieć, dlaczego uważasz takie rozwiązanie za dobre.

Bo wczytyjesz modul gdzie i kiedy chcesz a on reszte robi za ciebie

Jest tak, jak pisze ~marcio:


Przykład z panelem użytkownika może nie był najlepszy. Pomyśl sobie jednak, że masz np. sklep internetowy i na każdej podstronie chcesz wyświetlać menu kategorii (pobierane z bazy danych). Możesz oczywiście pisać odpowiednie metody do kontrolera nadrzędnego (i tak to jest realizowane w Kohana), które zrobią to za Ciebie. Jednak w momencie gdy takowych elementów będziesz miał więcej (np. box zawierający produkty w promocji, polecane czy też najchętniej kupowane) dodawanie nowych metod do kontrolera będzie upierdliwe. Poza tym: nie możesz takiego elementu wykorzystać w innym miejscu (np. pod listą produktów z danej kategorii). Skorzystanie z komponentu ogranicza się to wpisu symfony::include_component() w miejscu, w którym mają zostać wyświetlone dane.

Więcej informacji o komponentach znajdziesz tutaj:
http://www.symfony-project.org/book/1_2/07...ayer#Components

[PHP] pobierz, plaintext 
<?php
function add_modules($module) {
    
IF(file_exists('./system/modules/'.$module)) {    
    
    include('./system/modules/'.$module);
   }
return($zawartosc);
}
 
 
function draw_site($tpl = './theme/new/styl/normal/tpl1.tpl', $self) {
 
$layoutObiect = new layout($tpl);
 
$sql = mysql_query('select * from settings where dzial = "'.$self.'" limit 1');
$sql1 = mysql_query('select * from modules where module_dzial = "'.$self.'"');
 
$tab = mysql_fetch_assoc($sql);
 
foreach($tab as $key => $val) $layoutObiect -> addVar($key, $val);
 
while($re = mysql_fetch_assoc($sql1)) 
$layoutObiect -> addVar($re['module_place'], render_window($re['header'], add_modules($re['module_name'])));
 
$output .= $layoutObiect -> showCode();
 
return $output;
}
?>
[PHP] pobierz, plaintext 

Np u mnie tak wyglada ladowanie wszystkich modulow dla danej podstrony we wlasciwe miejsce oczywiscie mozna tez ladowac moduly gdy wystapi jakis $_GET za pomoca metody load_modules($module); ktora prawie niczym sie nie rozni od add_modules() oprocz tego ze zwraca zmienne z glownym kodem moduly.

Ogolnie moze i przyklad z modulem panela uzytkownika nie jest w pelni zrozumialy bo jak sam chcialem zrozumiec jak uzywac moduly kumpel tez mi zrobil taki przyklad i nic nie zrozumialem, jednak wedlug mnie ja moglbym to tak wytlumaczyc:

Zalozmy ze masz strone index.php(Strona glowna) ktora jest napisania za pomoca div'ow a do kazdego div'a mozesz zaladowac poszczegolny modul i wtedy na stronie kontrolujesz jakie maja byc moduly i gdzie one maja byc, oczywiscie dajac tez mozliwosc ladowania kilka modulow do tego samego div'a.

Ogolnie kod @phpion jest fajny tylko ze ja nie uzywam Kohana ani OOP dlatego tez napisalem wlasne metody

@marcio:
Za bardzo nie czaję w jakim celu wkleiłeś swój kod. Przyznam również, że nie do końca mogę się połapać o co Ci chodzi

Swoją drogą:
moduł != komponent

Ja na komponent mowie modul zreszta to chyba synonimy w pewnym sensie przynajmniej dla mnie w zyciu codziennym, a kod podalem zeby @Speedy mogl bardziej zrozumiec po co je uzywac

W takim razie nieco się rozmijamy z ideą komponentów. W Symfony (z którego zaczerpnąłem pomysł) jest to zupełnie coś innego niż to, co opisujesz. Komponent to nie moduł.

Koncepcja partiali jest chyba znana programistom Kohanej. Komponent to partial z wydzieloną logiką.

Dzięki za linki. Rzeczywiście, poczytałem i jest to fajna sprawa. Mogę sobie wykorzystać Twój kod w Kohanie?

Oczywiście, nie ma problemu.

Witam.
Nie jest to przypadkiem to samo/podobne podejście co hmvc in kohana tylko tam wykorzystuje się poprostu kontrolery?

kosmiczne pre-3.0 własnie opiera się na HMVC.