X-Git-Url: http://git.cielonegro.org/gitweb.cgi?a=blobdiff_plain;f=Rakka%2FWiki%2FInterpreter%2FBase.hs;h=2363b9b5da362bdee29c2433f8ff9b3b21a9361e;hb=0b97160b4d55eca16f3c56b47a908997fc458284;hp=e03b669fd083ac568fdd0cfccb1237937cbb094b;hpb=f832f12703d807f5fc3350dc71d8624ffc5b97a5;p=Rakka.git

diff --git a/Rakka/Wiki/Interpreter/Base.hs b/Rakka/Wiki/Interpreter/Base.hs
index e03b669..2363b9b 100644
--- a/Rakka/Wiki/Interpreter/Base.hs
+++ b/Rakka/Wiki/Interpreter/Base.hs
@@ -1,32 +1,176 @@
 module Rakka.Wiki.Interpreter.Base
-    ( baseInterpreters
+    ( interpreters
     )
     where
 
-import           Rakka.Wiki.Interpreter
+import           Data.Map (Map)
+import qualified Data.Map as M
+import           Data.Maybe
+import           Rakka.Page
+import           Rakka.SystemConfig
 import           Rakka.Wiki
+import           Rakka.Wiki.Interpreter
+import           Text.XML.HXT.Arrow
 
 
-baseInterpreters :: [Interpreter]
-baseInterpreters = [ lineBreakInterp
-                   , spanInterp
-                   , divInterp
-                   ]
+interpreters :: [Interpreter]
+interpreters = [ lineBreakInterp
+               , spanInterp
+               , divInterp
+               , pageNameInterp
+               , otherLangsInterp
+               , newPageInterp
+               , editPageInterp
+               , loginInterp
+               , searchFieldInterp
+               ]
 
 
 lineBreakInterp :: Interpreter
-lineBreakInterp = pureInlineInterp "br" interpret
-    where
-      interpret (InlineCommand _ attrs _) _ = LineBreak attrs
+lineBreakInterp = InlineCommandInterpreter {
+                    iciName = "br"
+                  , iciInterpret
+                      = \ _ (InlineCommand _ attrs _) -> return $ LineBreak attrs
+                  }
 
 
 spanInterp :: Interpreter
-spanInterp = pureInlineInterp "span" interpret
-    where
-      interpret (InlineCommand _ attrs contents) _ = Span attrs contents
+spanInterp = InlineCommandInterpreter {
+               iciName = "span"
+             , iciInterpret
+                 = \ _ (InlineCommand _ attrs contents) -> return $ Span attrs contents
+             }
 
 
 divInterp :: Interpreter
-divInterp = pureBlockInterp "div" interpret
+divInterp = BlockCommandInterpreter {
+              bciName = "div"
+            , bciInterpret
+                = \ _ (BlockCommand _ attrs contents)
+                -> return $ Div attrs (map Block contents)
+            }
+
+
+pageNameInterp :: Interpreter
+pageNameInterp = InlineCommandInterpreter {
+                   iciName = "pageName"
+                 , iciInterpret
+                     = \ ctx _ -> return $ Text (fromMaybe "" $ ctxPageName ctx)
+                 }
+
+
+otherLangsInterp :: Interpreter
+otherLangsInterp
+    = BlockCommandInterpreter {
+        bciName = "inOtherLanguages"
+      , bciInterpret
+          = \ ctx _ ->
+            let linkTable = case ctxMainPage ctx of
+                              Just page -> runLA ( getXPathTreesInDoc "/page/otherLang/link"
+                                                   >>>
+                                                   ( getAttrValue0 "lang"
+                                                     &&&
+                                                     getAttrValue0 "page"
+                                                   )
+                                                 ) page
+                              Nothing   -> []
+            in
+              case linkTable of
+                [] -> return EmptyBlock
+                _  -> do Languages langTable <- getSysConf (ctxSysConf ctx)
+                         let merged = mergeTables langTable linkTable
+                         return $ mkLangList merged
+      }
     where
-      interpret (BlockCommand _ attrs contents) _ = Div attrs contents
\ No newline at end of file
+      mergeTables :: Map LanguageTag LanguageName
+                  -> [(LanguageTag, PageName)]
+                  -> [(LanguageName, PageName)]
+      mergeTables _ []     = []
+      mergeTables m (x:xs) = let (langTag, name) = x
+                                 langName        = fromMaybe langTag (M.lookup langTag m)
+                             in
+                               (langName, name) : mergeTables m xs
+
+      mkLangList :: [(LanguageName, PageName)] -> BlockElement
+      mkLangList xs = List Bullet (map mkLangLink xs)
+
+      mkLangLink :: (LanguageName, PageName) -> ListItem
+      mkLangLink (langName, name)
+          = [Inline (PageLink (Just name) Nothing (Just langName))]
+
+
+-- <input type="button"
+--        value="Create new page"
+--        onclick="Rakka.newPage()"
+--        class="newButton" />
+newPageInterp :: Interpreter
+newPageInterp 
+    = InlineCommandInterpreter {
+        iciName = "newPage"
+      , iciInterpret
+          = \ _ (InlineCommand _ args _) ->
+            let label = fromMaybe "Create new page" (lookup "label" args)
+                attrs = [ ("type"   , "button")
+                        , ("value"  , label)
+                        , ("onclick", "Rakka.newPage()")
+                        , ("class"  , "newButton")
+                        ]
+            in
+              return (Input attrs)
+      }
+
+
+-- <input type="button"
+--        value="Edit"
+--        onclick="Rakka.editPage(\"Foo\")"
+--        class="editButton" />
+editPageInterp :: Interpreter
+editPageInterp 
+    = InlineCommandInterpreter {
+        iciName = "editPage"
+      , iciInterpret
+          = \ ctx (InlineCommand _ args _) ->
+            let name  = fromMaybe (fromMaybe "" $ ctxPageName ctx) (lookup "page" args)
+                label = fromMaybe "Edit this page" (lookup "label" args)
+                attrs = [ ("type"   , "button")
+                        , ("value"  , label)
+                        , ("onclick", "Rakka.editPage(\"" ++ name ++ "\")")
+                        , ("class"  , "editButton")
+                        ]
+            in
+              return (Input attrs)
+      }
+
+
+-- <input type="button"
+--        value="Login"
+--        class="loginButton" />
+loginInterp :: Interpreter
+loginInterp 
+    = InlineCommandInterpreter {
+        iciName = "login"
+      , iciInterpret
+          = \ _ _ ->
+            let attrs = [ ("type" , "button")
+                        , ("value", "Login")
+                        , ("class", "loginButton")
+                        ]
+            in
+              return (Input attrs)
+      }
+
+
+-- <input type="text"
+--        class="searchField" />
+searchFieldInterp :: Interpreter
+searchFieldInterp 
+    = InlineCommandInterpreter {
+        iciName = "searchField"
+      , iciInterpret
+          = \ _ _ ->
+            let attrs = [ ("type" , "text")
+                        , ("class", "searchField")
+                        ]
+            in
+              return (Input attrs)
+      }