module Hoogle(
TagStr(..), showTagText, showTagANSI, showTagHTML, showTagHTMLWith,
H.ParseError(..),
URL,
Language(..),
Database, loadDatabase, saveDatabase, createDatabase, showDatabase,
Query(..), H.Scope(..), parseQuery, H.renderQuery, H.isBlankQuery,
queryDatabases, querySuggestions, queryCompletions,
Score, H.scoring,
Result(..), search
) where
import Data.Binary.Defer.Index
import Data.Data
import General.Base
import General.System
import Hoogle.Type.TagStr
import qualified Hoogle.DataBase.All as H
import qualified Hoogle.Query.All as H
import qualified Hoogle.Score.All as H
import qualified Hoogle.Search.All as H
import qualified Hoogle.Type.All as H
import qualified Hoogle.Language.Haskell as H
import Hoogle.Query.All(Query)
import Hoogle.Score.All(Score)
data Language = Haskell
deriving (Enum,Read,Show,Eq,Ord,Bounded,Data,Typeable)
newtype Database = Database [H.DataBase]
toDataBase (Database x) = H.combineDataBase x
fromDataBase x = Database [x]
instance Monoid Database where
mempty = Database []
mappend (Database xs) (Database ys) = Database $ xs ++ ys
instance Show Database where
show = show . toDataBase
saveDatabase :: FilePath -> Database -> IO ()
saveDatabase file x = do
performGC
H.saveDataBase file $ toDataBase x
loadDatabase :: FilePath -> IO Database
loadDatabase = fmap fromDataBase . H.loadDataBase
createDatabase
:: Language
-> [Database]
-> String
-> ([H.ParseError], Database)
createDatabase _ dbs src = (err, fromDataBase $ H.createDataBase xs res)
where
(err,res) = H.parseInputHaskell src
xs = concat [x | Database x <- dbs]
showDatabase :: Database -> Maybe [String] -> String
showDatabase x sects = concatMap (`H.showDataBase` toDataBase x) $ fromMaybe [""] sects
parseQuery :: Language -> String -> Either H.ParseError Query
parseQuery _ = H.parseQuery
queryDatabases :: Query -> [String]
queryDatabases x = if null ps then ["default"] else ps
where ps = [p | H.PlusPackage p <- H.scope x]
querySuggestions :: Database -> Query -> Maybe TagStr
querySuggestions (Database dbs) q = H.suggestQuery dbs q
queryCompletions :: Database -> String -> [String]
queryCompletions x = H.completions (toDataBase x)
data Result = Result
{locations :: [(URL, [(URL, String)])]
,self :: TagStr
,docs :: TagStr
}
toResult :: H.Result -> (Score,Result)
toResult r@(H.Result entry view score) = (score, Result parents self docs)
where
ent = fromLink entry
self = H.renderResult r
parents = map (second $ map f) $ H.entryLocations ent
f = (H.entryURL &&& H.entryName) . fromLink
docs = H.renderDocumentation $ H.entryDocs ent
search :: Database -> Query -> [(Score,Result)]
search (Database xs) q = map toResult $ H.search xs q