Provided by: libjifty-perl_1.10518+dfsg-1ubuntu2_all bug

NAME

       Jifty::Manual::Tutorial_de - Einfuehrung in Jifty

BESCHREIBUNG

       Dieses Tutorial sollte Ihnen alles Wichtige mit auf den Weg geben, um
       erfolgreich eine erste Applikation mit Jifty zu bauen.

WIE?

   Anforderungen
       Hier steht, was Sie installiert haben sollten -- wenigstens wenn wir es
       schreiben.

   Jifty installieren
       Nicht wirklich eine grosse Sache. Wir glauben stark an das DRY (Don't
       Repeat Yourself -- Keine Wiederholungen) Prinzip. Das ist einer der
       grossen Gruende, warum wir Perl und das CPAN lieben. Jifty benutzt viel
       Code aus dem CPAN. Bei der letzten Zaehlung waren es wenigstens 60
       Pakete. Die meisten Module sind auf vielen Plattformen einsetzbare nur
       in Perl geschriebene Module und sollten ohne Probleme funktionieren.

       Wir haben einige Anstrengungen unternommen, damit Sie nicht Ihre Zeit
       damit verbringen muessen, Abhaengigkeiten aufzuloesen, nur um Jifty zu
       installieren. Das Jifty Installationsprogramm stellt fest, welche
       Module Ihr System benoetigt und laedt bei Bedarf die erforderlichen
       Module nach. Also machen Sie sich keine Sorgen, Sie werden immer
       gefragt, bevor Aenderungen vorgenommen werden.

       Auf den meisten Systemen wird Perl mit dem CPAN Modul ausgeliefert,
       womit die Jifty Installation einfach wird:

         # perl -MCPAN -e'install Jifty'       # auf Unix-aehnlichen Systemen
         # perl -MCPAN -e"install Jifty"       # auf Win32 Systemen

       Falls Sie lieber eine ".tar.gz" Datei von Jifty herunterladen wollen,
       koennen Sie diese wie folgt installieren:

         # tar xzvf jifty-<version>.tgz
         # cd jifty-<version>
         # perl Makefile.PL
         # make
         # make test
         # make install

       Falls die Tests nicht erfolgreich verlaufen, waere eine Rueckmeldung an
       uns interessannt. Bitte melden Sie sich bei der Liste
       "jifty-devel@lists.jifty.org" und melden den Fehler. (Oder sehen Sie
       nach unter "HILFE" weiter unten wo beschrieben ist, wie Sie sich uns
       anschliessen koennen.)

   Erstellung eines Rumpfes
       Wenn Sie Jifty erfolgreich installiert haben, koennen Sie Ihre erste
       Applikation erstellen.

       Jifty ist geplantermassen Minimalistisch. Wenn Sie eine Applikation
       erstellen moechten, kopieren Sie einfach das jifty
       Kommandozeilenprogramm in das bin/ Unterverzeichnis in Ihr
       Applikations-Verzeichnis.

       OK, es ist natuerlich hilfreich, ein wenig strukturierter vorzugehen.
       Jifty wird mit Werkzeugen geliefert, die Ihnen helfen, die notwendigen
       Strukturen anzulegen.

       Wechseln Sie in ein sicheres Verzeichnis, in dem Sie Ihre Applikation
       anlegen moechten (Jifty erstellt das notwendige Unterverzeichnis fuer
       Sie).

         # jifty app --name MyWeblog
         Can't guess application root from current path (/tmp) or bin path (/usr/bin)
         Creating new application MyWeblog
         Creating directory lib
         Creating directory lib/MyWeblog
         Creating directory bin
         Creating directory etc
         Creating directory doc
         Creating directory log
         Creating directory var
         Creating directory var/mason
         Creating directory share
         Creating directory share/po
         Creating directory share/web
         Creating directory share/web/templates
         Creating directory share/web/static
         Creating directory lib/MyWeblog/Model
         Creating directory lib/MyWeblog/Action
         Creating directory t
         Creating configuration file MyWeblog/etc/config.yml

       Sehen wir uns die einzelnen Verzeichnisse genauer an.

       bin Innerhalb des bin/ Verzeichnisses liegt jifty, die Jifty
           Kommandozentrale. Einige der wichtigsten Befehle sind "schema",
           welches ein Datenbank-Schema erstellt oder erneuert und "server",
           womit ein funktionsfaehiger Webserver gestartet wird. Um die von
           jifty verstandenen Kommandos herauszufinden, tippen Sie:

               jifty help

       etc Konfigurationsdateien leben in etc/ und Jifty wird vernuenftige
           Standardwerte verwenden, sollte keine Konfigurationsdatei vorhanden
           sein oder benoetigte Eintraege fehlen.

       doc Leider erstellt Jifty keine magische Dokumentation, aber wenn Sie
           dokumentieren, dann bitte in das Verzeichnis doc/.

       log Jifty setzt Log::Log4perl ein, um mitzuprotokollieren.
           Voreingestellt ist das Erstellen der Logs server.log und error.log
           in das log/ Verzeichnis.

       share/web/templates
           Jifty nutzt HTML::Mason als sein primaeres Template System. Legen
           Sie die Templates Ihrer Appkikation in share/web/templates/. Von
           Haus aus wird Jifty mit einer vordefinierten Applikation geliefert,
           die im Verzeichnis share/web/templates/ installiert wird. Diese
           vordefinierte Applikation ist ein bequemer Weg um eine einfache
           eigene Applikation schnell zum Laufen zu bringen, jedoch sind
           sicher Anpassungen notwendig, wenn Ihre Applikation komplexer wird.

           Sie koennen schnell herausfinden, wo Jifty seine vordefinierten
           Templates ablegt:

             perl -MJifty::Util -e 'print Jifty::Util->share_root'

       share/web/static
           Einige einfache Dinge, die zu Ihrer Applikation gehoeren, brauchen
           nicht (oder sollten nicht) durch das Template-System laufen.

           Stecken Sie solche Dateien einfach in das share/web/static/
           Verzeichnis und Jifty wird diese verwenden, wenn es nicht
           gleichzeitig ein Template mit identischen Namen gibt.

           Von Hause aus wird Jifty mit einigen CSS Stilen, JavaScript
           Bibliotheken und einem Pony geliefert. Sehen Sie einfach im
           Verzeichnis share/web/static der Jifty Distribution nach oder dort
           wo Jifty seine Standard-Templates ablegt.

       lib/MyWeblog
           Eine naehere Beschreibung des Objekt Modells und der
           Verzeichnishierarchie finden Sie unter Jifty::Manual::ObjectModel

           Zum Bau einer funktionsfaehigen einfachen Applikation brauchen Sie
           sich nur Gedanken ueber zwei Arten von Klassen, Models und Actions
           zu machen.

       lib/MyWeblog/Model
           Die wirkliche Basis Ihrer Applikation lebt in "lib/AppName/Model".
           Alle Klassen hier definieren die Daten(bank)strukturen Ihrer
           Applikation und wie diese miteinander verbunden sind. Jifty benutzt
           diese Model-Klassen zum Erstellen oder Aktualisieren des Datenbank-
           Schemas, wenn dies notwendig sein sollte.

       lib/MyWeblog/Action
           Als wir gesagt haben, dass Sie sich nur ueber Models und Actions
           den Kopf zerbrechen muessen, haben wir nicht die ganze Wahrheit
           gesagt. Jifty kuemmert sich um grundlegende Datenbank Interaktionen
           ("CREATE (Anlegen), READ (Lesen), UPDATE (Aktualisieren), DELETE
           (Loeschen)"). Entsprechend benoetigte Actions werden fuer die
           jeweiligen Models automatisch erzeugt und koennen jederzeit
           veraendert werden, sollte dies notwendig werden.

       t   Jifty legt bereits Test-Routinen fuer Ihre Applikation an, kann
           allerdings nicht die Tests fuer Sie schreiben. (Es erstellt jedoch
           einfache Tests fuer die Model-Klassen, die Sie anlegen.)

       var Jifty speichert Cache-Dateien hier, waehrend der Server laeuft.
           Normalerweise werden Sie hier nichts tun muessen.

   Erstellung eines Datenmodells
       Wie Sie sich aus der Tatsache, dass diese Tutorial-Applikation MyWeblog
       heisst, vorstellen koennen, ist das hier vorgestellte Beispiel ein
       einfaches Weblog. Kuenftige Tutorials werden Authentifizierung,
       Kommentare sowie RSS und Atom Feeds beschreiben.

       Posts

       Weblogs konzentrieren sich rund um Posts, daher ist es keine
       Ueberraschung, dass unser erstes Model, das wir erzeugen werden, ein
       "Post" ist.

         # cd MyWeblog
         # jifty model --name Post
         Writing file /tmp/MyWeblog/t/00-model-Post.t
         Writing file /tmp/MyWeblog/lib/MyWeblog/Model/Post.pm

       Grossartig! Nun haben Sie ein Post Model (Nur, dass es im Augenblick
       noch nichts modelliert).

       Oeffnen Sie lib/MyWeblog/Model/Post.pm in Ihrem Lieblings-Editor.

       Sie sollten etwas sehen wie:

         use strict;
         use warnings;

         package MyWeblog::Model::Post;
         use Jifty::DBI::Schema;

         use MyWeblog::Record schema {

         };

         # Your model-specific methods go here.

         1;

       Nun ist es an der Zeit, der Model Klasse etwas ueber Posts zu
       erzaehlen. Fangen wir damit an, einem Post einen "body" (Rumpf) und
       einen "title" (Titel) zu geben. (In einem kommenden Tutorial wird die
       Applikation voll "Folksonomy"-tauglich werden, was wir durch Anfuegen
       einer "category" (Kategorie) und Erweitern der "category" zu einer
       "tags" (Indexierung, Etikett) Tabelle erreichen koennten.)

       Editieren Sie unter dieser Zeile:

         use MyWeblog::Record schema {

       Fuegen Sie diese Zeilen an:

         column title =>
               type is 'text',
               label is 'Title',
               default is 'Ohne Titel';

         column body =>
               type is 'text',
               label is 'Content',
               render_as 'Textarea';

       Abspeichern bitte nicht vergessen.

   Erstellung der Datenbank
       Gut. Nun ist es an der Zeit, die Datenbank zu erstellen.
       Standardgemaess benutzt Jifty eine SQLite Datenbank. Wenn Sie lieber
       PostgreSQL oder MySQL verwenden moechten, dann koennen Sie Anpassungen
       an etc/jifty.yml vornehmen. (Sehen Sie dazu in "Jifty::Config" nach, um
       mehr darueber zu erfahren.)

         # jifty schema --setup
         INFO - Generating SQL for application MyWeblog...
         INFO - Using MyWeblog::Model::Post
         INFO - Using Jifty::Model::Session
         INFO - Using Jifty::Model::Metadata
         INFO - Using Jifty::Model::Schema
         INFO - Set up version v0.0.1, jifty version 0.607280

   Start des Jifty Application Server
       OK. Nun haben Sie eine lauffaehige, aber noch einfache Applikation.
       Starten Sie den Webserver und schauen Sie sich um. Werfen Sie einen
       Blick auf die AJAX gesteuerte Administrations-Umgebung, die Online
       Dokumentation und das Pony.

         # ./bin/jifty server
         INFO - You can connect to your server at http://localhost:8888/

       Starten Sie diese Kommandofolge immer im Hauptverzeichnis Ihrer Jifty
       Applikation, andernfalls werden etliche Fehlermeldungen die Folge sein.

       Auf den meisten Plattformen wird ein einfaches "jifty server" Kommando
       ebenfalls funktionieren. :)

   Erstellung der Benutzeroberflaeche
       Die Administrations-Umgebung gibt Ihnen zwar alles, was Sie brauchen,
       um mit den Daten der Applikation zu arbeiten, ist aber noch lange kein
       Weblog.

       Erstellung von Posts

       Erstellen Sie eine Seite zum Posten eines neuen Weblog Eintrages:

         # cd share/web/templates/

       Erstellen Sie eine neue Datei namens post in Ihrem Editor. Stellen Sie
       sicher, dass diese so aussieht:

         <%init>
         my $action = Jifty->web->new_action(class => 'CreatePost');
         </%init>

         <&| /_elements/wrapper, title => "Post Eintrag Erstellen" &>
         <% Jifty->web->form->start() %>
         <% Jifty->web->form->next_page( url => '/') %>
         <% $action->form_field('title') %>
         <% $action->form_field('body') %>
         <% Jifty->web->form->submit( label => 'Post' ) %>
         <% Jifty->web->form->end() %>
         </&>

       Ja, dies ist eine Template Datei in HTML::Mason Syntax. Wenn Sie noch
       nicht genug ueber Mason wissen, empfehlen wir dessen Online
       Dokumentation fuer mehr Details. Mason Templates sollten jeweils in der
       ersten Spalte der Datei beginnen. Besonders wichtig sind die "<%init>"
       und "</%init>" Bloecke, die unbedingt lingsbuendig geschrieben werden
       muessen.

       Anzeige

       Es ist relativ einfach, eine einfache Auflistung von Eintraegen zu
       erhalten und ein wenig aufwaendiger, eine AJAX gesteuerte seitenweise
       Darstellung zu bekommen. Hier beschreiben wir, wie man beides macht;
       Sie koennen entscheiden, welches Ihnen besser gefaellt.

       (Falls Sie per Kopieren und Einfuegen den Beispiel-Code von unten
       uebertragen, stellen Sie sicher, dass er in einer Spalte erscheint,
       ansonsten wird es nicht funktionieren.)

       Der schnelle Weg

       Erstellen Sie eine neue Datei index.html im share/web/templates
       Verzeichnis in Ihrem Editor. (Der Webserver wird die URL "/index.html"
       als die Standard Seite fuer Ihre Applikation annehmen.) Befuellen Sie
       die Datei wie folgt:

         <%init>
         my $posts = MyWeblog::Model::PostCollection->new();
         $posts->unlimit();
         </%init>

         <&| /_elements/wrapper, title => Jifty->config->framework('ApplicationName') &>
         <dl>
         % while (my $post = $posts->next) {
          <dt><% $post->title %></dt>
          <dd><% $post->body %></dd>
         % }
         </dl>
         </&>

       (Entfernen Sie die Leerzeichen am Zeilenanfang!)

       Die aufwaendige Art, mit der Sie viele coole Dinge bekommen

       Die aufwaendige Art benutzt eines von Jifty's fortgeschrittenen
       Eigenschaften: PageRegions (Seitenbereiche). Diese Bereiche erlauben
       Ihrer Applikation einzelne Bestandteile einer Seite unabhaengig
       voneinander neu zu laden. Das funktioniert sowohl unter Benutzung von
       AJAX auf modernen Browsern, als auch mit GET Requests auf nicht
       JavaScript faehigen Browsern wie "lynx", "w3m" oder dem Browser Ihres
       Handys.

       Der Nachteil dieser Methode ist, dass jeder Seiten-Bereich in einer
       eigenen Fragment Datei vorliegen muss.

       Die aufwaendige Art beginnt zunaechst genauso wie der schnelle Weg.
       Erstellen Sie eine neue Datei mit dem Namen
       share/web/templates/index.html in Ihrem Editor. Befuellen Sie die Datei
       mit:

         <&| /_elements/wrapper, title => Jifty->config->framework('ApplicationName') &>

         <% Jifty->web->region(name => "myweblog-posts",
                               path => "/fragments/page_of_posts") %>
         </&>

       Wenn Sie mitgedacht haben, dann haben Sie bestimmt schon erraten, dass
       Sie als naechstes eine Datei
       share/web/templates/fragments/page_of_posts mit dem nachfolgenden
       Inhalt anlegen duerfen:

         <%args>
         $page => 1
         </%args>
         <%init>
         my $posts = MyWeblog::Model::PostCollection->new();
         $posts->unlimit();
         $posts->set_page_info( current_page => $page,
                                per_page     => 15
                              );
         $m->out("Keine Eintraege.") if ($posts->pager->total_entries == 0);

         </%init>
         % if ($posts->pager->last_page > 1) {
            Seite <% $page %> von <% $posts->pager->last_page %>
         % }
         <dl class="list">
         % while (my $post = $posts->next) {
          <dt><% $post->title %></dt>
          <dd><% $post->body %></dd>
         % }
         </dl>

         % if ($posts->pager->previous_page) {
           <% Jifty->web->link( label => "vorherige Seite", onclick => { args => { page => $posts->pager->previous_page } } ) %>
         % }
         % if ($posts->pager->next_page) {
           <% Jifty->web->link( label => "naechste Seite", onclick => { args => { page => $posts->pager->next_page } } ) %>
         % }

       Nun starten Sie den Jifty Webserver erneut. Erstellen Sie einen Post
       indem Sie die URL "/post" auf Ihrem Webserver anfahren. Erstellen Sie
       wenigstens 15 Eintraege und beobachten Sie dabei, wie Jifty Ihnen die
       AJAX Knoepfe "vorherige Seite" und "naechste Seite" erstellt. Schalten
       Sie JavaScript aus oder verwenden Sie lynx und beobachten Sie wie AJAX
       automatisch zurueckfaellt zum vollstaendigen Laden der jeweils neuen
       Seite. Alles umsonst. Danke, Jifty!

       Hey, woher kam diese Klasse?

       Wenn Sie genau aufgepasst haben, dann haben Sie sich sicher gefragt,
       woher die "MyWeblog::Model::PostCollection" Klasse kam. Es gibt keine
       Datei mit dem Namen PostCollection.pm. Jifty setzt "Jifty::ClassLoader"
       ein, um einige Klassen fuer Sie zu erstellen. Selbstverstaendlich
       koennten Sie das ebenfalls tun. Lesen Sie unter Jifty::ClassLoader mehr
       darueber.

   Navigation
       Natuerlich ist es unschoen, sich die URL der Post Seite merken zu
       muessen. Um einen Post Eintrag im Menue zu bekommen, muessen Sie die
       Standard Menues ueberschreiben.

       Jifty's Standard Menues werden durch _elements/nav in den Standard
       Applikations Templates (die mit dem Pony) erzeugt. Im Augenblick bleibt
       Ihnen nichts anderes uebrig, als _elements/nav zu ueberschreiben. (Wir
       arbeiten an Methoden, dies besser zu gestalten.)

       Legen Sie innerhalb des Verzeichnisses share/web/templates Ihrer
       Applikation ein Verzeichnis _elements an.

         mkdir share/web/templates/_elements

       Sie moechten bestimmt mit den normalen Jifty Templates arbeiten, also
       muessen wir nur den "$top->child( Post... )" Teil anfuegen.

         cat $(perl -MJifty::Util -e 'print Jifty::Util->share_root' \
           )/web/templates/_elements/nav > share/web/templates/_elements/nav

       Ansonsten koennen Sie innerhalb _elements auch gerne eine neue Datei
       namens "nav" anlegen, die so aussehen koennte:

         <%init>
         my $top = Jifty->web->navigation;
         $top->child( Home => url => "/");
         $top->child( Post => url => "/post",
                              label => "Neuen Eintrag");
         </%init>

       Mehr Information ueber das Menue System koennen Sie der Dokumentation
       unter Jifty::Web::Menu entnehmen.

   Das war's
       Das war alles, das Sie benoetigen, um anzufangen, Jifty Applikationen
       zu erstellen. Wir arbeiten hart daran, Jifty noch einfacher einsetzbar
       zu machen und die dicken Brocken dieses Tutorials so bald als moeglich
       zu vereinfachen.

       Bitte nehmen Sie auf der "jifty-devel" Mailing Liste Kontakt mit uns
       auf, wenn Sie Fragen haben, wie man Jifty benutzt oder was Sie
       schwierig zu benutzen finden. Dies ist eine Mailing Liste in englischer
       Sprache.

HILFE

   Online Hilfe
       Das "jifty" Kommandozeilen Programm besitzt eine eingebaute Hilfe
       Funktion.

         jifty help

         jifty help <kommando>

       Wenn Ihr Server mit eingeschaltetem Administrations-Modus arbeitet (die
       Konfigurations-Einstellung "AdminMode" fehlt oder sie ist ungleich
       Null), dann koennen Sie den "Online Docs" Link in Ihrem Browser
       benutzen, um eine ausfuehrliche modulweise Dokumentation zu Jifty zu
       erhalten.

   Beitreten der Mailing Liste
       "jifty-devel@lists.jifty.org" ist der Ort, an dem wir besprechen, wie
       wir Jifty erstellen, was es an Problemen oder Vorschlaegen gibt und so
       weiter.

       Um der Liste beizutreten, senden Sie eine Mail an
       "jifty-devel-subscribe@lists.jifty.org". Bitte beachten Sie, dass die
       Kommunikation in dieser Liste in englischer Sprache gefuehrt wird.

   Unser Wiki
       Wir haben ein Wiki! (Tatsaechlich ist das Wiki die hauptsaechliche
       Website von Jifty).

       Besuchen Sie uns unter <http://jifty.org/>, lesen Sie und tragen Sie
       etwas bei!

       Das Wiki wird von Wifty betrieben, einem Wiki das auf Jifty basiert.
       Sein Code ist frei verfuegbar in unserem Subversion Repository.

FEHLER MELDEN

       In dieser fruehen Phase von Jifty melden Sie bitte alle Fehler, die
       Ihnen auffallen, an "jifty-devel@lists.jifty.org".

KUeNFTIGE TUTORIALS

       Kuenftige Tutorials werden enthalten:

       o   Zugangskontrolle und Sicherheit

       o   Erweiterung von Datenmodellen

       o   Umfangreiche Beschreibung des Dispatchers

       o   Einbindung einer Applikation in einen Live Server

       o   Web Services im Detail

       o   Continuations (Fortsetzungen) und deren Einsatz

       o   Anpassungen der Darstellung (Benutzerdefinierte Wrapper und CSS)