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)