Installation

Wie man Contao 4 installiert

Composer

Aktuell kann Contao 4 nur über Composer installiert werden.

Manuell

git clone -b develop https://github.com/contao/standard-edition.git
cd standard-edition
curl -sS https://getcomposer.org/installer | php
php composer.phar install

Mit create-project

curl -sS https://getcomposer.org/installer | php
php composer.phar create-project contao/standard-edition contao4 4.0.0

Übersetzungen

Übersetzungen lassen sich mit Hilfe des Transifex-Clients installieren.

Deutsch

for i in $(ls -d vendor/contao/*-bundle); do \
  cd $i; \
  tx pull -l de; \
  cd -; \
done;

Webserver

Damit Symfony im Browser aufgerufen werden kann, muss der Webserver entsprechend angepasst werden.

Voraussetzungen

  • Setzen des Document-Roots auf den Ordner /web
  • Mappen aller Requests auf die Datei app.php

Der Ordner /web enthält bereits eine .htaccess-Datei mit den Standard-Einstellungen*. Weitere Informationen für alle gängigen Webserver gibt es auf symfony.com.

* Erst nach dem Release der RC hinzugekommen.

Entry-Points

In Contao 3 gibt es für jede Route einen Entry-Point, also eine PHP-Datei wie z.B. contao/main.php. In Symfony gibt es jedoch nur einen Entry-Point (web/app.php) und die Routen müssen konfiguriert werden.

Auswirkung

  • Eigene Entry-Points (z.B. in Isotope) funktionieren in Contao 4
  • Die Verwendung eigener Entry-Points ist jedoch veraltet und wird in Contao 5.0 nicht mehr unterstützt

Informationen zum Symfony-Routing gibt es auf symfony.com.

app_dev.php

Die Datei web/app_dev.php ist ein zweiter Entry-Point, der automatisch den Debug-Mode aktiviert.

Einschränkungen

  • Standardmäßig nur auf localhost nutzbar
  • Für die Nutzung auf dem Live-Server muss ein Benutzername und ein Passwort vergeben werden (siehe Quellcode).

Im Debug-Mode lädt Symfony den Web-Profiler, der detaillierte Informationen über die Applikation liefert.

dump()

Die Funktion dump() wird in Contao 4 auf das Debug-Bundle gemappt und integriert ihre Ausgabe direkt in den Web-Profiler.

Vorteile

  • Kein Debug-Markup irgendwo auf der Seite
  • Verschachtelte Informationen können ein- und ausgeklappt werden

Die Funktion ist nur vorhanden, wenn sich der Kernel im Debug-Modus befindet (standardmäßig beim Aufruf der Applikation über app_dev.php).

Bundles

In Symfony ist alles ein Bundle

Bundles

Bundles sind First-Class-Objekte in Symfony, die den benötigten Glue-Code enthalten, um Ressourcen in die Applikation zu integrieren.

Bundles können

  • Controller bereitstellen
  • Commands bereitstellen
  • Entities/Documents bereitstellen
  • Services bereitstellen
  • Assets bereitstellen (Bilder, Stylesheets, Skripte)

Bundles

Auch Contao 4 besteht jetzt aus Symfony-Bundles, die im Ordner /vendor/contao liegen.

Contao-Bundles

  • Hauptbundle ist contao/core-bundle
  • Zur Standard-Distribution gehören außerdem calendar-bundle, comments-bundle, faq-bundle, listing-bundle, news-bundle und newsletter-bundle

Weitere Informationen: Bundles erstellen und Bundles Best-Practice

Extensions werden Bundles

Ordnerstruktur

Wir empfehlen euch folgende Ordnerstruktur:

src/
  .../                 <-- neue PHP-Klassen nach PSR-4
  Resources/
      config/
      contao/          <-- der bisherige Contao-Code
      public/          <-- öffentliche Ressourcen
  DemoBundle.php
tests/
  .../                 <-- die Unit-Tests für die neuen Klassen
  bootstrap.php
CHANGELOG.md
composer.json
phpunit.xml.dist
README.md

Calendar-Bundle

      <-- Transifex-Konfiguration


      <-- Bisherige Contao-Dateien
      <-- Öffentliche Ressourcen

      <-- Bundle-Klasse

Bundle-Klasse

namespace Contao\CalendarBundle;

use Symfony\Component\HttpKernel\Bundle\Bundle;

/**
 * Configures the Contao calendar bundle.
 *
 * @author Leo Feyer <https://github.com/leofeyer>
 */
class ContaoCalendarBundle extends Bundle
{
}

Bundle-Aktivierung

Bundles müssen im App-Kernel registriert werden:

// app/AppKernel.php
public function registerBundles()
{
    // Reihenfolge beachten, falls Ressourcen überschrieben werden sollen
    $bundles = [
        new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
        new Contao\CoreBundle\ContaoCoreBundle(),
        new Contao\CalendarBundle\ContaoCalendarBundle(),
    ];

    // ...

    return $bundles;
}

Extensions installieren

Installation

Alte Erweiterungen, die noch keine Bundles sind und noch in /system/modules liegen, können ebenfalls installiert werden.

Schritte

  • Dateien nach /system/modules kopieren*
  • Symlinks anlegen**: app/console contao:symlinks
  • Registrierung im App-Kernel

* Die Installation mittels Composer ist in Arbeit.
** Nur notwendig, wenn die Erweiterung einen öffentlichen Unterordner beinhaltet.

Registrierung

Um alte Erweiterungen im App-Kernel zu registrieren, steht die Klasse ContaoModuleBundle zur Verfügung:

// app/AppKernel.php
use Contao\CoreBundle\HttpKernel\Bundle\ContaoModuleBundle;

public function registerBundles()
{
    $bundles = [
        new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
        new Contao\CoreBundle\ContaoCoreBundle(),
        new ContaoModuleBundle('repository', $this->getRootDir()),
    ];

    // ...

    return $bundles;
}

Refactoring

Ziel

Der bisherige Contao-Code sollte nach und nach refactored werden, bis der Ordner src/Resources/contao irgendwann leer ist.

Allerdings

  • Es handelt sich hierbei um ein langfristiges Ziel
  • Der Core muss erstmal selbst refactored werden, damit er die bisherigen Ressourcen nicht mehr benötigt
  • Refactoring ist aktuell also erstmal nur für PHP-Klassen möglich

Best-Practices

Fabien Potencier, der Erschaffer von Symfony, hat die Symfony Best-Practices für das Arbeiten mit dem Framework veröffentlicht.

Contao-Bundles

  • Wir folgen in Contao den Empfehlungen
  • Lediglich die Test-Klassen liegen in /tests anstatt in /src/Tests

Die Best-Practices gelten für die Entwicklung einer App mit Symfony. Die Entwicklung eines Vendor-Bundles weicht an manchen Stellen ab (z.B. liegen die Bundle-Ressourcen in /vendor/**/src/Resources anstatt in /app/Resources).

Controller

Wir empfehlen den "fat models, thin controllers"-Ansatz.

Bedeutung

  • Der Controller wird so klein wie möglich gehalten
    • Möglichst keine Business-Logik
    • Führt Model und View zusammen und gibt die Response zurück
  • Das Model manipuliert und persistiert die Daten
  • Die Business-Logik wird in separaten, wiederverwendbaren Klassen gekapselt, die über den Dependency-Injection-Container als Services angefordert werden können

Qualitätskontrolle

Die gute Nachricht

Es gibt Webservices, die diese Tools bereitstellen und euren Code automatisch prüfen (kontinuierliche Integration). Die meisten sind kostenlos für Open-Source-Projekte.

Wir nutzen

  • Travis CI (führt die Unit-Tests nach jedem Commit aus)
  • Scrutinizer (analysiert die Code-Qualität und Test-Coverage)

Verschiedenes

Was Entwickler sonst noch über Contao 4 wissen sollten

Template::output()

Das Symfony Request-Respone-Konzept sieht es vor, dass jeder Controller entweder ein Response-Objekt zurückgibt oder eine Exception wirft.

In Contao wurde die Antwort an den Client jedoch bisher durch die Methode Template::output() erzeugt, welche in Contao 4 nun veraltet ist und in einer zukünftigen Version entfernt wird.

Alternativen

  • Template::getResponse()
  • throw new ResponseException(new Response($str))
  • /contao/core-bundle/src/Exception/*.php

Informationen

Das Contao Core-Bundle enthält mehrere Markdown-Dateien mit Informationen für Entwickler:

Dateien

  • UPGRADE.md: nicht rückwärtskompatible Änderungen
  • DEPRECATED.md: veraltete Ressourcen, die demnächst entfernt werden
  • Die Verwendung veralteter Ressourcen ist im Web-Profiler ersichtlich

Dokumentation

Semantische Versionierung

Beginnend mit Contao 4 verwenden wir semantische Versionierung.

Regeln

  • Bugfix-Releases dürfen nur rückwärtskompatible Fixes enthalten
  • Minor-Releases können rückwärtskompatible neue Features enthalten
  • Jede inkompatible API-Änderung muss als neue Major-Version veröffentlicht werden

API-Änderungen

Nicht jeder rückwärtsinkompatible Änderung ist auch eine API-Änderung!

API

  • Als "public" oder "protected" deklarierte Methoden in PHP-Klassen
  • Ausgenommen Methoden, die als @internal gekennzeichnet sind

Templates sind explizit nicht Teil der API und können sich daher auch in Minor- oder Bugfix-Versionen ändern, selbst wenn dadurch Stylesheet-Anpassungen notwendig werden.

Noch Fragen?

Vielen Dank für die Aufmerksamkeit