Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

executable file 104 lines (85 sloc) 3.508 kB
{-# LANGUAGE CPP #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveDataTypeable #-}
module Main where
import Control.Applicative
import Control.Concurrent.ParallelIO.Local
import Control.Exception
import Control.Monad hiding (sequence)
import Data.Foldable
import qualified Data.List as L
import Data.List.Split
#if MIN_VERSION_shelly(1, 0, 0)
import Data.Text as T hiding (filter, map, chunksOf)
#else
import Data.Text.Lazy as T hiding (filter, map, chunksOf)
#endif
import Filesystem.Path
import GHC.Conc
import Prelude hiding (FilePath, sequence, catch)
import Shelly
import System.Console.CmdArgs
import System.Environment (getArgs, withArgs)
import System.IO hiding (FilePath)
default (Text)
version :: String
version = "0.3.1"
copyright :: String
copyright = "2012-2014"
reHooSummary :: String
reHooSummary = "rehoo v" ++ version ++ ", (C) John Wiegley " ++ copyright
data Rehoo = Rehoo { chunks :: Int
, jobs :: Int
, outfile :: String
, dir :: String }
deriving (Data, Typeable, Show, Eq)
reHoo :: Rehoo
reHoo = Rehoo
{ chunks = def &= typ "INT"
&= help "Process INT .hoo's at a time (def: 16)"
, jobs = def &= name "j" &= typ "INT"
&= help "Run INT hoogle combine's (def: # of capabilities)"
, outfile = def &= typFile
&= help "Output file (defaults to default.hoo)"
, dir = def &= args &= typDir } &=
summary reHooSummary &=
program "rehoo" &=
help "Rebuild default.hoo from many .hoo files in the given directory"
main :: IO ()
main = do
mainArgs <- getArgs
opts <- withArgs (if L.null mainArgs then ["--help"] else mainArgs)
(cmdArgs reHoo)
caps <- GHC.Conc.getNumCapabilities
let jobs' = case jobs opts of 0 -> caps; x -> x
chunks' = case chunks opts of 0 -> 16; x -> x
outputPath = fromText $ case outfile opts of
"" -> "default.hoo"
x -> T.pack x
putStrLn $ "Running with " ++ show jobs'++ " workers and "
++ show chunks' ++ " sized chunks per worker"
shelly $ verbosely $ rm_f outputPath
_ <- GHC.Conc.setNumCapabilities jobs'
hoos <- shelly $ filter <$> pure (`hasExtension` "hoo")
<*> (ls . fromText . T.pack . dir $ opts)
tempPath <- withPool jobs' $ \pool -> processHoos pool chunks' hoos
shelly $ verbosely $ mv tempPath outputPath
processHoos :: Pool -> Int -> [FilePath] -> IO FilePath
processHoos pool size hoos
| L.length hoos > size =
-- Split the list into 'size' sized chunks and fork off a thread to
-- recursively process each chunk
let f = processHoos pool size in
bracket (parallel pool $ map f $ chunksOf size hoos)
(shelly . verbosely . traverse_ rm) f
| otherwise = do
-- Now that we have a list of files < size elements long, and are in our
-- own thread, we can start the process of running hoogle combine with
-- output going to a temp file
(tempPath, hndl) <- openTempFile "." "rehoo.hoo"
hClose hndl
let file = T.pack tempPath
shelly $ verbosely $
run_ "hoogle" ("combine": "--outfile":file :map toTextIgnore hoos)
return $ fromText file
-- Main.hs (rehoo) ends here
Jump to Line
Something went wrong with that request. Please try again.