{-# LANGUAGE OverloadedStrings #-}

module Distribution.Cab.GenPaths (genPaths) where

import Control.Exception
import Control.Monad
import Data.List (isSuffixOf)
import Distribution.Cab.Utils (readGenericPackageDescription, unPackageName)
import Distribution.Package (pkgName, pkgVersion)
import Distribution.PackageDescription (package, 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