Happstack: část druhá

Jádrem programů napsaných v Haskellu jsou typy. Ani Happstack není výjimkou. Jak jsme si ukázali minule, funkce simpleHTTP, pomocí které se dá jednoduše v prohlížeči vypsat text, jako jeden ze dvou parametrů požaduje parametr typu ServerPartT IO a (zkráceně ServerPart a), což jsme si označili jako aplikační kód. Typ IO značí, že se jedná o vstupně-výstupní akci a typ ServerPartT představuje součást webového serveru. Tento pojem v sobě zahrnuje HTTP požadavky (typ Request) a odpovědi (typ Response). Použití jedné nebo více součástí dává dohromady celý Happstack server, což je vlastně obyčejná serverová aplikace.

Pod tímto, na první pohled neintuitivním, konceptem si lze představit aplikaci v Happstacku jako jednu komplexní funkci, která na základě požadavku a dalších případných okolnostech vrátí odpověď. Hlavní součást HTTP požadavku je URL, jenž je v Happstacku vyhodnocováno pomocí monadických funkcí.

URL monády

Typický případ použití funkcí pro zpracování URL v Happstacku je jejich zapsání do seznamu a jejich následné sloučení pomocí funkce msum. Jestliže jste nikdy o této funkci neslyšeli, nalézá se v modulu Control.Monad a funguje podobně jako standardní seznamová funkce concat, jenom pracuje s monádami. Výsledkem její aplikace bude funkce, která postupně prochází jednotlivé položky seznamu. V případě, že některá položka seznamu bude vyhovovat HTTP požadavku, zpracuje se a procházení skončí; v opačném případě se bude pokračovat v procházení seznamu dále, dokud některá položka nebude vyhovovat. Pokud se žádná vyhovující položka v seznamu nenalezne, zobrazí se výchozí stránka s chybou 404 (nenalezeno). Dobrým nápadem je si vždy na posledním místě seznamu definovat vlastní chybovou stránku, jenž nahradí výchozí.

Základní funkce pro zpracování URL jsou nullDir a dir. První uspěje, pokud je zadaná adresa prázdná (jedná se tedy o kořenový adresář), druhá, pokud zadaná část adresy odpovídá řetězci. Jejich použití je bohužel trochu nekonzistentní, jak ukazuje příklad:

module Main where

import Control.Monad
import Happstack.Server

main :: IO ()
main = simpleHTTP nullConf handleURL

handleURL :: ServerPart Response
handleURL = msum [ do nullDir; ok $ toResponse "Výchozí stránka"
                 , dir "prvni" . ok $ toResponse "První stránka"
                 , dir "druhy" . ok $ toResponse "Druhá stránka"
                 , dir "treti" $ msum [ do nullDir; ok $ toResponse "Třetí stránka"
                                      , dir "ctvrty" . ok $ toResponse "Čtvrtá stránka"
                                      ]
                 , notFound $ toResponse "Chyba 404"
                 ]

Námi definovaná funkce handleURL vrací typ Response, tedy HTTP odpověď, proto je na všechny řetězce volána funkce toResponse, která je převede na odpovídající typ. Funkce ok je speciálním případem funkce return, ale chová se úplně stejně — naše odpovědí obalí typovým konstruktorem IO. Jak můžeme vidět u parametru treti, součásti URL lze zanořovat. V našem případě se tak v prohlížeči po zadání adresy http://localhost:8000/treti/ vypíše text „Třetí stránka“ a po zadání adresy http://localhost:8000/treti/ctvrty/ text „Čtvrtá stránka“. Poslední řádek definuje pomocí funkce notFound chybovou stránku.

Funkce dir zpracovává adresy bez ohledu na to, zda-li končí lomítkem nebo ne. Doporučuji toto chování změnit na přesměrování na verzi s lomítkem, aby byla každá adresa stránky unikátní. Provedeme to zapsáním následujících řádek do souboru .htaccess:

RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^([a-z0-9\/\_-]+[^/])$ $1/ [R=301,NC]

Funkce dir zachytí pouze statické části adresy stránek. Pro zpracování dynamických částí slouží funkce path. Ta jako parametr očekává funkci zpracovávající řetězec nebo číslo a vracející odpověď. Typu této funkce určuje, co se bude v adrese očekávat. Následující kód vypíše číslo zadané v URL:

handleURL :: ServerPart Response
handleURL = msum [ do nullDir; ok $ toResponse "Výchozí stránka"
                 , path pathNumber
                 , notFound $ toResponse "Chyba 404"
                 ]

pathNumber :: Int -> ServerPart Response
pathNumber n = ok . toResponse $ "Číslo v URL: " ++ show n

Po navštívení kupříkladu adresy http://localhost:8000/42/ se vypíše odpověď „Číslo v URL: 42“. Funkce pro zpracování URL můžeme mezi sebou libovolně kombinovat, jenom si vždy musíme dávat pozor, abychom vraceli hodnotu správného typu.

Kromě části URL můžeme určovat i jiné parametry dotazu. Kupříkladu funkce methodOnly určuje, kterou HTTP metodu od dotazu očekáváme. Protože se taktéž jedná o monadickou funkci, kombinuje se pomocí operátoru >>:

handleURL :: ServerPart Response
handleURL = msum [ do methodOnly GET >> nullDir; ok $ toResponse "Výchozí stránka"
                 , methodOnly GET >> path pathNumber
                 , notFound $ toResponse "Chyba 404"
                 ]

V tomto kódu vracíme na všechny dotazy využívající jiné metody než GET (tedy např. POST) chybovou stránku 404.

Psaní HTML kódu

Happstack přináší tři různé způsoby zadávání HTML kódu aplikace: přímé zadávání do řetězců, generování pomocí kombinátorů a šablony. První způsob je nejjednodušší, ale není příliš vhodný pro netriviální aplikace, protože pak náš kód nebývá příliš přehledný a ani bezpečný. Kombinátorový generátor je údajně o něco rychlejší než šablonovací systém, ten ovšem nabízí větší kontrolu nad kódem a práce s ním je přirozenější.

HTML řetězce

Aby se odlišil obyčejný text od HTML, modul Text.Html zavádí nový datový typ HtmlString. Když funkci toResponse předáme obyčejný řetězec typu String, je automaticky escapován — některé speciální znaky jsou převedeny na HTML entity. Musíme tedy převést typ String na HtmlString:

module Main where

import Happstack.Server
import Happstack.Helpers
import Text.Html hiding (HtmlString)

main :: IO ()
main = simpleHTTP nullConf . ok $ toResponse ref

ref :: HtmlString
ref = HtmlString "<p><a href=\"http://zdrojak.cz/\">Zdroják</a></p>"

Konstruktor HtmlString převede řetězec na HTML řetězec, v prohlížeči se tedy zobrazí odkaz. Kdybychom chtěli k řetězci před jeho převodem na HTML řetězec přiřetězit nějaký vstup, je nutné použít funkci s relativně dlouhým názvem stringToHtmlString, jinak nedojde k jeho escapování a my bychom si v aplikaci vytvořili potenciální bezpečnostní díru:

ref :: HtmlString
ref = HtmlString $ "<p><a href=\"http://zdrojak.cz/\">" ++ stringToHtmlString "<Zdroják>" ++ "</a></p>"

Generování HTML značek

Po nahlédnutí do dokumentace modulu Text.Html uvidíme velké množství funkcí se stejným názvem jako jsou některé HTML značky. To jsou již zmiňované kombinátory. S jejich použitím a kombinací operátorů << (vložení dovnitř prvku), +++ (přiřetězení dalšího prvku) a ! (modifikace atributu) si HTML kód lehce vygenerujeme:

ref :: Html
ref = header << thetitle << "Titulek" +++ body << p << anchor ! [href "http://zdrojak.cz/"] << "<Zdroják>"

Řetězce se automaticky escapují, takže by nemělo dojít k vložení nějakého zákeřného kódu zvenku. Jak už název napovídá, kombinátory jsou funkce, jež lze lehce kombinovat a spojovat dohromady, takže při dobrém návrhu nebývá problém s opakováním kódu.

HTML šablony

Šablony mají tu výhodu, že je oddělen HTML kód od aplikačního. Lehce tak můžeme zadat vytvoření HTML kódu někomu úplně jinému a pouze mu poskytnout seznam proměnných, které v šablonách chceme použít. Haskell obsahuje několik šablonovacích systémů, my se podíváme na HStringTemplate (modul Text.StringTemplate). Tento systém je založen na knihovně Java StringTemplate.

Nejprve si založíme adresář templates a vytvoříme v něm hlavní šablonu body.st:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>$ title $</title>
</head>

<body>
$ ref() $
</body>

Tato šablona obsahuje proměnnou title a bude inkludovat šablonu ref.st, kterou umístíme taktéž do adresáře templates:

<a href="http://zdrojak.cz/">$ link $</a>

Proměnné se v šabloně vyznačují pomocí dvou dolarových symbolů, inkluze další šablony stejně, jenom se za identifikátor dopíšou závorky. Kdybychom chtěli do šablony přidat komentář, stačí ho napsat mezi dvojici znaků $! a !$. Zbývá už jen napsat nový kód aplikace:

module Main where

import Happstack.Server
import Happstack.Helpers
import Control.Monad.Trans
import Text.StringTemplate
import Text.StringTemplate.Helpers
import Text.Html hiding (HtmlString)

main :: IO ()
main = simpleHTTP nullConf ref

escapeKeys :: [(String, String)] -> [(String, String)]
escapeKeys = map (\(x, y) -> (x, stringToHtmlString y))

ref :: ServerPart Response
ref = liftIO $ do
    templates <- directoryGroup "templates"
    let keys = escapeKeys [("title", "Titulek"), ("link", "<Zdroják>")]
        body = renderTemplateGroup templates keys "body"
    return . toResponse $ HtmlString body

Tento kód je o trochu složitější. V první řadě je zde potřeba funkce liftIO z modulu Control.Monad.Trans, jež zařídí převod z monády IO na jinou. Ve funkci ref jsou totiž načítány šablony, proto se celá funkce snaží zabalit do monády IO. To je taktéž důvod, proč musíme použít obecnější funkci return namísto funkce ok. Dále se zde volá funkce directoryGroup sloužící k načtení adresáře s šablonami. Funkce renderTemplateGroup vygeneruje šablonu spolu s proměnnými v proměnné keys a zajistí i inkluzi. Protože šablonový systém automaticky neescapuje proměnné, bylo potřeba sem připsat vlastní funkci escapeKeys, která zajišťuje ošetření vstupu.

Související odkazy

• Oficiální web Haskellu
• Happstack Tutorial
• Dokumentace modulů Happstack.Server, Text.Html a Text.StringTemplate

V následujícím dílu si vyzkoušíme zpracovávání formulářů.