Parse_TextBase.hs

module Test.Parse_TextBase(parse_TextBase) where

import Test.General
import Hoogle.TextBase.All
import Hoogle.TypeSig.All


typ x = case parseTypeSig x of
            Left err -> error $ "parse_TextBase, failed to parse type signature: " ++ show x
            Right y -> y

parse_TextBase = do
    let (===) a b = parseTest parseTextBaseString a (map (flip (,) "") b)

    "" === []
    "-- foo" === []

    "module Foo.Bar.String" === [ItemModule ["Foo","Bar","String"]]
    "module Test" === [ItemModule ["Test"]]

    "class Foo a" === [ItemClass $ typ "Foo a"]
    "class Foo a b" === [ItemClass $ typ "Foo a b"]

    "foo :: Bool" === [ItemFunc "foo" $ typ "Bool"]
    "(++) :: Int" === [ItemFunc "++" $ typ "Int"]
    "++ :: Int" === [ItemFunc "++" $ typ "Int"]
    "@@ :: Int" === [ItemFunc "@@" $ typ "Int"]

    "type Bar a = Foo [a]" === [ItemAlias (typ "Bar a") (typ "Foo [a]")]

    "data [] a" === [ItemData DataKeyword $ typ "[a]"]
    "[] :: [] a" === [ItemFunc "[]" $ typ "[a]"]
    ": :: a -> [a] -> [] a" === [ItemFunc ":" $ typ "a -> [a] -> [a]"]
    "(:) :: a -> [a] -> [] a" === [ItemFunc ":" $ typ "a -> [a] -> [a]"]
    "() :: ()" === [ItemFunc "()" $ typ "()"]
    "data (:+:) a b" === [ItemData DataKeyword $ typ "(:+:) a b"]

    "data Foo a" === [ItemData DataKeyword $ typ "Foo a"]
    "newtype Foo a" === [ItemData NewTypeKeyword $ typ "Foo a"]

    "instance Eq a => Eq [a]" === [ItemInstance $ typ "Eq a => Eq [a]"]

    "@keyword ~" === [ItemAttribute "keyword" "~"]
    "@keyword ->" === [ItemAttribute "keyword" "->"]
    "@keyword module" === [ItemAttribute "keyword" "module"]

    "@package neil" === [ItemAttribute "package" "neil"]
    "@foo bar" === [ItemAttribute "foo" "bar"]
    "@debug" === [ItemAttribute "debug" ""]