cake-0.0.1: Cake/Rules.hs

module Cake.Rules where

import Cake.Core
import qualified Parsek
import System.Directory
import System.FilePath
import Control.Applicative
import Control.Monad (when)
import Control.Monad.RWS
import qualified Parsek
import Parsek (completeResults, parse, Parser)
import qualified Data.Map as M
import Data.Binary hiding (put,get)
import Text.Groom
import qualified System.Process as P
import System.Exit
import Data.List


-- Helpers
quote :: String -> String
quote = show

-- Patterns
extension :: String -> Pattern
extension s = Parsek.many Parsek.anyChar <* Parsek.string s

-- Actions
copy :: FilePath -> FilePath -> Act()
copy from to = promise to $ needing [from] $ do
  mkdir $ takeDirectory to
  liftIO $ copyFile from to

system' :: [String] -> Act ExitCode
system' xs = do 
  debug $ "Running: " ++ (intercalate " " xs)
  liftIO $ P.system (intercalate " " $ map quote xs)

succeed :: Act ExitCode -> Act ()
succeed act = do
  code <- act
  when (code /= ExitSuccess) $ fail "Command returned non-zero exitcode."

mkdir :: FilePath -> Act ()    
mkdir d = liftIO $ createDirectoryIfMissing True d
    
system xs = succeed $ system' xs

touch :: FilePath -> Act ()
touch x = do
  system ["touch",x]
  
readFile :: FilePath -> Act String
readFile x = do
  need x
  liftIO $ Prelude.readFile x
  

{-
mpostDeriv = extension "-delayed.mp" ==> \s -> do
  let input = s ++ ".mp"
  need input
  rm (s ++ "-delayed.mp")
  mpost input
  mpost input
   -}

needing :: [FilePath] -> Act () -> Act ()
needing xs act = do
  mapM_ need xs
  cut act
          
-- Rules

simple outExt inExt f = extension outExt ==> \s -> do
  let input = s ++ inExt
      output = s ++ outExt
  needing [input]  $ f output input
  

tex_markdown_standalone = simple ".tex" ".markdown" $ \o i -> 
  system ["pandoc","--tab-stop=2","--standalone","-f","markdown","-t","latex", 
          "-o", o, i]
  
pdf_tex = simple ".pdf" ".tex" $ \o i -> 
  system ["latexmk","-pdf",i]

{-
pdf_tex2 = extension ".pdf" $ \c -> do
  let input = extension ".tex"
  ls <- filter ("\\bibliography" `isPrefixOf`) lines <$> readFile input
  cut $ do
    case ls of
       [] -> return ()
       (l:_) -> do let l' = reverse . dropWhile (== '}') . dropWhile . reverse . dropWhile (== '{') $ l
                       bibs = spli
-}
allRules = tex_markdown_standalone <|> pdf_tex