{-# LANGUAGE OverloadedStrings #-}

module Distribution.Cab.GenPaths (genPaths) where

import Control.Exception
import Control.Monad
import Data.List (isSuffixOf)
import Distribution.Cab.Utils (readGenericPackageDescription)
import Distribution.Package (pkgName, pkgVersion)
import Distribution.PackageDescription
import Distribution.Verbosity (silent)
import Distribution.Version
import System.Directory

genPaths :: IO ()
genPaths :: IO ()
genPaths = do
    ([Char]
nm,Version
ver) <- IO [Char]
getCabalFile forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [Char] -> IO ([Char], Version)
getNameVersion
    let file :: [Char]
file = [Char]
"Paths_" forall a. [a] -> [a] -> [a]
++ [Char]
nm forall a. [a] -> [a] -> [a]
++ [Char]
".hs"
    [Char] -> IO ()
check [Char]
file forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> do
        [Char] -> IO ()
putStrLn forall a b. (a -> b) -> a -> b
$ [Char]
"Writing " forall a. [a] -> [a] -> [a]
++ [Char]
file forall a. [a] -> [a] -> [a]
++ [Char]
"..."
        [Char] -> [Char] -> IO ()
writeFile [Char]
file forall a b. (a -> b) -> a -> b
$ [Char]
"module Paths_" forall a. [a] -> [a] -> [a]
++ [Char]
nm forall a. [a] -> [a] -> [a]
++ [Char]
"  where\n"
                      forall a. [a] -> [a] -> [a]
++ [Char]
"import Data.Version\n"
                      forall a. [a] -> [a] -> [a]
++ [Char]
"\n"
                      forall a. [a] -> [a] -> [a]
++ [Char]
"version :: Version\n"
                      forall a. [a] -> [a] -> [a]
++ [Char]
"version = " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Version
ver forall a. [a] -> [a] -> [a]
++ [Char]
"\n"
  where
    check :: [Char] -> IO ()
check [Char]
file = do
        Bool
exist <- [Char] -> IO Bool
doesFileExist [Char]
file
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
exist forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e a. Exception e => e -> IO a
throwIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> IOError
userError forall a b. (a -> b) -> a -> b
$ [Char]
file forall a. [a] -> [a] -> [a]
++ [Char]
" already exists"

getNameVersion :: FilePath -> IO (String,Version)
getNameVersion :: [Char] -> IO ([Char], Version)
getNameVersion [Char]
file = do
    GenericPackageDescription
desc <- Verbosity -> [Char] -> IO GenericPackageDescription
readGenericPackageDescription Verbosity
silent [Char]
file
    let pkg :: PackageIdentifier
pkg = PackageDescription -> PackageIdentifier
package forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericPackageDescription -> PackageDescription
packageDescription forall a b. (a -> b) -> a -> b
$ GenericPackageDescription
desc
        nm :: [Char]
nm = PackageName -> [Char]
unPackageName forall a b. (a -> b) -> a -> b
$ PackageIdentifier -> PackageName
pkgName PackageIdentifier
pkg
        name :: [Char]
name = forall a b. (a -> b) -> [a] -> [b]
map (forall {p}. Eq p => p -> p -> p -> p
trans Char
'-' Char
'_') [Char]
nm
        version :: Version
version = PackageIdentifier -> Version
pkgVersion PackageIdentifier
pkg
    forall (m :: * -> *) a. Monad m => a -> m a
return ([Char]
name, Version
version)
  where
    trans :: p -> p -> p -> p
trans p
c1 p
c2 p
c
      | p
c forall a. Eq a => a -> a -> Bool
== p
c1   = p
c2
      | Bool
otherwise = p
c

getCabalFile :: IO FilePath
getCabalFile :: IO [Char]
getCabalFile = do
    [[Char]]
cnts <- (forall a. (a -> Bool) -> [a] -> [a]
filter [Char] -> Bool
isCabal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char] -> IO [[Char]]
getDirectoryContents [Char]
".")
            forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall (m :: * -> *) a.
Applicative m =>
(a -> m Bool) -> [a] -> m [a]
filterM [Char] -> IO Bool
doesFileExist
    case [[Char]]
cnts of
        []      -> forall e a. Exception e => e -> IO a
throwIO forall a b. (a -> b) -> a -> b
$ [Char] -> IOError
userError [Char]
"Cabal file does not exist"
        [Char]
cfile:[[Char]]
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return [Char]
cfile
  where
    isCabal :: String -> Bool
    isCabal :: [Char] -> Bool
isCabal [Char]
nm = [Char]
".cabal" forall a. Eq a => [a] -> [a] -> Bool
`isSuffixOf` [Char]
nm Bool -> Bool -> Bool
&& forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
nm forall a. Ord a => a -> a -> Bool
> Int
6