Provided by: libjifty-perl_1.10518+dfsg-3ubuntu1_all 
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:
• Zugangskontrolle und Sicherheit
• Erweiterung von Datenmodellen
• Umfangreiche Beschreibung des Dispatchers
• Einbindung einer Applikation in einen Live Server
• Web Services im Detail
• Continuations (Fortsetzungen) und deren Einsatz
• Anpassungen der Darstellung (Benutzerdefinierte Wrapper und CSS)