# Użycie konwencjonalnej modularnej struktury katalogów

## Wprowadzenie

Konwencjonalna modularna struktura katalogów pozwala ci na oddzielenie różnych aplikacji MVC w osobne jednostki i użycie ich z różnymi kontrolerami frontowymi. Przykładem może być taka struktura katalogów:

    docroot/
        index.php
    application/
        default/
            controllers/
                IndexController.php
                FooController.php
                models/
                views/
                    scripts/
                        index/
                        foo/
                    helpers/
                    filters/
        blog/
            controllers/
                IndexController.php
            models/
            views/
                scripts/
                    index/
                helpers/
                filters/
        news/
            controllers/
                IndexController.php
                ListController.php
            models/
            views/
                scripts/
                    index/
                    list/
                helpers/
                filters/

W tym modelu, nazwa modułu uwidacznia się jako przedrostek nazw kontrolerów, ktore zawiera moduł. Powyższy przykład zawiera trzy kontrolery modułów, 'Blog_IndexController', 'News_IndexController', oraz 'News_ListController'. Dwa globalne kontrolery, 'IndexController' oraz 'FooController' są także zdefiniowane; żaden z nich nie posiada własnej przestrzeni nazw. Ta struktura katalogów będzie używana w przykładach w tym rozdziale.

### Brak przestrzeni nazw w domyślnym module

Zauważ, że w domyślnym module nazwa kontrolera nie ma przedrostka defniującego przestrzeń nazw. Dlatego w powyższym przykładzie kontrolery w domyślnym module nie potrzebują przedrostka 'Default_' -- są one po prostu uruchamiane jako 'IndexController' oraz 'FooController'. Przedrostek definiujący przestrzeń nazw jest jednak używany we wszystkich innych modułach.

Więc jak implementujesz taką strukturę katalogów używając komponentów MVC Zend Framework?

## Określanie ścieżek kontrolera modułów

Pierwszym krokiem użycia modułów jest zmodyfikowanie sposobu określania listy ścieżek do kontrolerów w kontrolerze frontowym. W podstawowej wersji MVC, przekazujesz tablicę lub łańcuch znaków do metody `setControllerDirectory()`, lub ścieżkę do metody `addControllerDirectory()`. Gdy używasz modułów, musisz także odpowiednio zmienić wywołania tych metod.

W metodzie `setControllerDirectory()`, musisz przekazać tablicę asocjacyjną i określić pary klucz/wartość w postaci moduł/ścieżka. Specjalny klucz `default` będzie użyty dla globalnych kontrolerów (tych, które nie potrzebują przestrzeni nazw). Wszystkie wpisy powinny zawierać łańcuch znaków wskazujący na pojedynczą ścieżkę, a klucz `default` musi istnieć. Na przykład:

    $front->setControllerDirectory(array(
          'default' => '/path/to/application/controllers',
          'blog'    => '/path/to/application/blog/controllers'
    ));

Metoda `addControllerDirectory()` przyjmuje opcjonalny drugi argument. Gdy używasz modułów, przekaż nazwę modułu jak drugi argument; jeśli nie określisz drugiego argumentu, ścieżka zostanie dodana dla domyślnej przestrzeni nazw. Na przykład:

    $front->addControllerDirectory('/path/to/application/news/controllers', 'news');

Zostawiając najlepsze na koniec, najprostszym sposobem określenia katalogu modułów jest określenie ich wszystkich na raz, gdy wszystkie moduły znajdują się w jednym katalogu i posiadają taką samą strukturę. Można to zrobić za pomocą metody `addModuleDirectory()`:

    /**
     * Zakładając, że tak wygląda struktura katalogów:
     * application/
     *     modules/
     *         default/
     *             controllers/
     *         foo/
     *             controllers/
     *         bar/
     *             controllers/
     */
    $front->addModuleDirectory('/path/to/application/modules');

Powyższy przykład definiuje moduły `default`, `foo`, oraz `bar`, każdy wskazujący na podkatalog `controllers` danego modułu.

Możesz określić nazwę podkatalogu kontrolerów używaną w modułach za pomocą metody `setModuleControllerDirectoryName()`:

    /**
     * Zmieniamy nazwę podkatalogu kontrolerów na 'con'
     * application/
     *     modules/
     *         default/
     *             con/
     *         foo/
     *             con/
     *         bar/
     *             con/
     */
    $front->setModuleControllerDirectoryName('con');
    $front->addModuleDirectory('/path/to/application/modules');

Możesz określić aby podkatalog kontrolerów nie był używany w modułach, przekazując pustą wartość do metody `setModuleControllerDirectoryName()`.

## Dopasowanie tras do modułów

Domyślna trasa w `Zend_Controller_Router_Rewrite` jest obiektem typu `Zend_Controller_Router_Route_Module`. Ta trasa obsługuje takie schematy routingu:

- `:module/:controller/:action/*`

- `:controller/:action/*`

Innymi słowy, dopasuje ona tylko kontroler oraz akcję, lub wraz z poprzedzającym je modułem. Zasady dopasowania określają, że moduł będzie dopasowany tylko wtedy, gdy klucz o takiej samej nazwie istnieje w tablicy ze ścieżkami kontrolerów przekazanej do kontrolera frontowego i obiektu uruchamiającego.

## Moduł lub globalny domyślny kontroler

W domyślnym routerze jeśli w URL nie został określony kontroler, użyty zostanie domyślny kontroler (`IndexController`, jeśli nie określono inaczej). Gdy używamy kontrolerów modularnych, jeśli moduł został określony, ale kontroler nie, obiekt uruchamiający wpierw będzie szukał domyślnego kontrolera w ścieżce modułu, a w drugiej kolejności będzie szukał w ścieżce dla domyślnej globalnej przestrzeni nazw 'default'.

Jeśli chcesz zawsze używać domyślnej przestrzeni nazw, ustaw parametr `useDefaultControllerAlways` w kontrolerze frontowym:

    $front->setParam('useDefaultControllerAlways', true);