-- | Hackish Haddock module.
module Lambdabot.Plugin.Haskell.Haddock (haddockPlugin) where

import Lambdabot.Plugin

import qualified Data.ByteString.Char8 as P
import Data.List
import qualified Data.Map as M

type HaddockState = M.Map P.ByteString [P.ByteString]
type Haddock = ModuleT HaddockState LB

haddockPlugin :: Module HaddockState
haddockPlugin :: Module HaddockState
haddockPlugin = forall st. Module st
newModule
    { moduleCmds :: ModuleT HaddockState LB [Command Haddock]
moduleCmds = forall (m :: * -> *) a. Monad m => a -> m a
return
        [ (String -> Command Identity
command String
"index")
            { help :: Cmd Haddock ()
help = forall (m :: * -> *). Monad m => String -> Cmd m ()
say String
"index <ident>. Returns the Haskell modules in which <ident> is defined"
            , process :: String -> Cmd Haddock ()
process = String -> Cmd Haddock ()
doHaddock
            }
        ]
        
    , moduleDefState :: LB HaddockState
moduleDefState  = forall (m :: * -> *) a. Monad m => a -> m a
return forall k a. Map k a
M.empty
    , moduleSerialize :: Maybe (Serial HaddockState)
moduleSerialize = forall a. a -> Maybe a
Just (forall b. (ByteString -> b) -> Serial b
readOnly forall t. Packable t => ByteString -> t
readPacked)
    }

doHaddock :: String -> Cmd Haddock ()
doHaddock :: String -> Cmd Haddock ()
doHaddock String
k = do
    HaddockState
m <- forall (m :: * -> *). MonadLBState m => m (LBState m)
readMS
    forall (m :: * -> *). Monad m => String -> Cmd m ()
say forall a b. (a -> b) -> a -> b
$ forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"bzzt"
        (forall a. [a] -> [[a]] -> [a]
intercalate (String
", ") forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map ByteString -> String
P.unpack)
        (forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup (ByteString -> ByteString
stripPs (String -> ByteString
P.pack String
k)) HaddockState
m)

-- make \@index ($) work.
stripPs :: P.ByteString -> P.ByteString
stripPs :: ByteString -> ByteString
stripPs = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> (ByteString, ByteString)
P.spanEnd (forall a. Eq a => a -> a -> Bool
==Char
')') forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool) -> ByteString -> (ByteString, ByteString)
P.span (forall a. Eq a => a -> a -> Bool
==Char
'(')