{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ViewPatterns #-}

-- |
-- Module      :  Distribution.Simple.Setup.Copy
-- Copyright   :  Isaac Jones 2003-2004
--                Duncan Coutts 2007
-- License     :  BSD3
--
-- Maintainer  :  cabal-devel@haskell.org
-- Portability :  portable
--
-- Definition of the copy command-line options.
-- See: @Distribution.Simple.Setup@
module Distribution.Simple.Setup.Copy
  ( CopyFlags
      ( CopyCommonFlags
      , copyVerbosity
      , copyDistPref
      , copyCabalFilePath
      , copyWorkingDir
      , copyTargets
      , ..
      )
  , emptyCopyFlags
  , defaultCopyFlags
  , copyCommand
  ) where

import Distribution.Compat.Prelude hiding (get)
import Prelude ()

import Distribution.ReadE
import Distribution.Simple.Command hiding (boolOpt, boolOpt')
import Distribution.Simple.Flag
import Distribution.Simple.InstallDirs
import Distribution.Simple.Setup.Common
import Distribution.Simple.Utils
import Distribution.Utils.Path
import Distribution.Verbosity

-- ------------------------------------------------------------

-- * Copy flags

-- ------------------------------------------------------------

-- | Flags to @copy@: (destdir, copy-prefix (backwards compat), verbosity)
data CopyFlags = CopyFlags
  { CopyFlags -> CommonSetupFlags
copyCommonFlags :: !CommonSetupFlags
  , CopyFlags -> Last CopyDest
copyDest :: Flag CopyDest
  }
  deriving (Int -> CopyFlags -> ShowS
[CopyFlags] -> ShowS
CopyFlags -> [Char]
(Int -> CopyFlags -> ShowS)
-> (CopyFlags -> [Char])
-> ([CopyFlags] -> ShowS)
-> Show CopyFlags
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CopyFlags -> ShowS
showsPrec :: Int -> CopyFlags -> ShowS
$cshow :: CopyFlags -> [Char]
show :: CopyFlags -> [Char]
$cshowList :: [CopyFlags] -> ShowS
showList :: [CopyFlags] -> ShowS
Show, (forall x. CopyFlags -> Rep CopyFlags x)
-> (forall x. Rep CopyFlags x -> CopyFlags) -> Generic CopyFlags
forall x. Rep CopyFlags x -> CopyFlags
forall x. CopyFlags -> Rep CopyFlags x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CopyFlags -> Rep CopyFlags x
from :: forall x. CopyFlags -> Rep CopyFlags x
$cto :: forall x. Rep CopyFlags x -> CopyFlags
to :: forall x. Rep CopyFlags x -> CopyFlags
Generic)

pattern CopyCommonFlags
  :: Flag Verbosity
  -> Flag (SymbolicPath Pkg (Dir Dist))
  -> Flag (SymbolicPath CWD (Dir Pkg))
  -> Flag (SymbolicPath Pkg File)
  -> [String]
  -> CopyFlags
pattern $mCopyCommonFlags :: forall {r}.
CopyFlags
-> (Flag Verbosity
    -> Flag (SymbolicPath Pkg ('Dir Dist))
    -> Flag (SymbolicPath CWD ('Dir Pkg))
    -> Flag (SymbolicPath Pkg 'File)
    -> [[Char]]
    -> r)
-> ((# #) -> r)
-> r
CopyCommonFlags
  { CopyFlags -> Flag Verbosity
copyVerbosity
  , CopyFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
copyDistPref
  , CopyFlags -> Flag (SymbolicPath CWD ('Dir Pkg))
copyWorkingDir
  , CopyFlags -> Flag (SymbolicPath Pkg 'File)
copyCabalFilePath
  , CopyFlags -> [[Char]]
copyTargets
  } <-
  ( copyCommonFlags ->
      CommonSetupFlags
        { setupVerbosity = copyVerbosity
        , setupDistPref = copyDistPref
        , setupWorkingDir = copyWorkingDir
        , setupCabalFilePath = copyCabalFilePath
        , setupTargets = copyTargets
        }
    )

instance Binary CopyFlags
instance Structured CopyFlags

defaultCopyFlags :: CopyFlags
defaultCopyFlags :: CopyFlags
defaultCopyFlags =
  CopyFlags
    { copyCommonFlags :: CommonSetupFlags
copyCommonFlags = CommonSetupFlags
defaultCommonSetupFlags
    , copyDest :: Last CopyDest
copyDest = CopyDest -> Last CopyDest
forall a. a -> Last a
Flag CopyDest
NoCopyDest
    }

copyCommand :: CommandUI CopyFlags
copyCommand :: CommandUI CopyFlags
copyCommand =
  CommandUI
    { commandName :: [Char]
commandName = [Char]
"copy"
    , commandSynopsis :: [Char]
commandSynopsis = [Char]
"Copy the files of all/specific components to install locations."
    , commandDescription :: Maybe ShowS
commandDescription = ShowS -> Maybe ShowS
forall a. a -> Maybe a
Just (ShowS -> Maybe ShowS) -> ShowS -> Maybe ShowS
forall a b. (a -> b) -> a -> b
$ \[Char]
_ ->
        ShowS
wrapText ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
          [Char]
"Components encompass executables and libraries. "
            [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"Does not call register, and allows a prefix at install time. "
            [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"Without the --destdir flag, configure determines location.\n"
    , commandNotes :: Maybe ShowS
commandNotes = ShowS -> Maybe ShowS
forall a. a -> Maybe a
Just (ShowS -> Maybe ShowS) -> ShowS -> Maybe ShowS
forall a b. (a -> b) -> a -> b
$ \[Char]
pname ->
        [Char]
"Examples:\n"
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"  "
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
pname
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" copy           "
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"    All the components in the package\n"
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"  "
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
pname
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" copy foo       "
          [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"    A component (i.e. lib, exe, test suite)"
    , commandUsage :: ShowS
commandUsage =
        [Char] -> [[Char]] -> ShowS
usageAlternatives [Char]
"copy" ([[Char]] -> ShowS) -> [[Char]] -> ShowS
forall a b. (a -> b) -> a -> b
$
          [ [Char]
"[FLAGS]"
          , [Char]
"COMPONENTS [FLAGS]"
          ]
    , commandDefaultFlags :: CopyFlags
commandDefaultFlags = CopyFlags
defaultCopyFlags
    , commandOptions :: ShowOrParseArgs -> [OptionField CopyFlags]
commandOptions = \ShowOrParseArgs
showOrParseArgs -> case ShowOrParseArgs
showOrParseArgs of
        ShowOrParseArgs
ShowArgs ->
          (OptionField CopyFlags -> Bool)
-> [OptionField CopyFlags] -> [OptionField CopyFlags]
forall a. (a -> Bool) -> [a] -> [a]
filter
            ( ([Char] -> [[Char]] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [[Char]
"target-package-db"])
                ([Char] -> Bool)
-> (OptionField CopyFlags -> [Char])
-> OptionField CopyFlags
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OptionField CopyFlags -> [Char]
forall a. OptionField a -> [Char]
optionName
            )
            ([OptionField CopyFlags] -> [OptionField CopyFlags])
-> [OptionField CopyFlags] -> [OptionField CopyFlags]
forall a b. (a -> b) -> a -> b
$ ShowOrParseArgs -> [OptionField CopyFlags]
copyOptions ShowOrParseArgs
ShowArgs
        ShowOrParseArgs
ParseArgs -> ShowOrParseArgs -> [OptionField CopyFlags]
copyOptions ShowOrParseArgs
ParseArgs
    }

copyOptions :: ShowOrParseArgs -> [OptionField CopyFlags]
copyOptions :: ShowOrParseArgs -> [OptionField CopyFlags]
copyOptions ShowOrParseArgs
showOrParseArgs =
  (CopyFlags -> CommonSetupFlags)
-> (CommonSetupFlags -> CopyFlags -> CopyFlags)
-> ShowOrParseArgs
-> [OptionField CopyFlags]
-> [OptionField CopyFlags]
forall flags.
(flags -> CommonSetupFlags)
-> (CommonSetupFlags -> flags -> flags)
-> ShowOrParseArgs
-> [OptionField flags]
-> [OptionField flags]
withCommonSetupOptions
    CopyFlags -> CommonSetupFlags
copyCommonFlags
    (\CommonSetupFlags
c CopyFlags
f -> CopyFlags
f{copyCommonFlags = c})
    ShowOrParseArgs
showOrParseArgs
    [ [Char]
-> [[Char]]
-> [Char]
-> (CopyFlags -> Last CopyDest)
-> (Last CopyDest -> CopyFlags -> CopyFlags)
-> MkOptDescr
     (CopyFlags -> Last CopyDest)
     (Last CopyDest -> CopyFlags -> CopyFlags)
     CopyFlags
-> OptionField CopyFlags
forall get set a.
[Char]
-> [[Char]]
-> [Char]
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
        [Char]
""
        [[Char]
"destdir"]
        [Char]
"directory to copy files to, prepended to installation directories"
        CopyFlags -> Last CopyDest
copyDest
        ( \Last CopyDest
v CopyFlags
flags -> case CopyFlags -> Last CopyDest
copyDest CopyFlags
flags of
            Flag (CopyToDb [Char]
_) -> [Char] -> CopyFlags
forall a. HasCallStack => [Char] -> a
error [Char]
"Use either 'destdir' or 'target-package-db'."
            Last CopyDest
_ -> CopyFlags
flags{copyDest = v}
        )
        ( [Char]
-> ReadE (Last CopyDest)
-> (Last CopyDest -> [[Char]])
-> MkOptDescr
     (CopyFlags -> Last CopyDest)
     (Last CopyDest -> CopyFlags -> CopyFlags)
     CopyFlags
forall b a.
Monoid b =>
[Char]
-> ReadE b
-> (b -> [[Char]])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg
            [Char]
"DIR"
            (([Char] -> Last CopyDest) -> ReadE (Last CopyDest)
forall a. ([Char] -> a) -> ReadE a
succeedReadE (CopyDest -> Last CopyDest
forall a. a -> Last a
Flag (CopyDest -> Last CopyDest)
-> ([Char] -> CopyDest) -> [Char] -> Last CopyDest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> CopyDest
CopyTo))
            (\Last CopyDest
f -> case Last CopyDest
f of Flag (CopyTo [Char]
p) -> [[Char]
p]; Last CopyDest
_ -> [])
        )
    , [Char]
-> [[Char]]
-> [Char]
-> (CopyFlags -> Last CopyDest)
-> (Last CopyDest -> CopyFlags -> CopyFlags)
-> MkOptDescr
     (CopyFlags -> Last CopyDest)
     (Last CopyDest -> CopyFlags -> CopyFlags)
     CopyFlags
-> OptionField CopyFlags
forall get set a.
[Char]
-> [[Char]]
-> [Char]
-> get
-> set
-> MkOptDescr get set a
-> OptionField a
option
        [Char]
""
        [[Char]
"target-package-db"]
        [Char]
"package database to copy files into. Required when using ${pkgroot} prefix."
        CopyFlags -> Last CopyDest
copyDest
        ( \Last CopyDest
v CopyFlags
flags -> case CopyFlags -> Last CopyDest
copyDest CopyFlags
flags of
            Last CopyDest
NoFlag -> CopyFlags
flags{copyDest = v}
            Flag CopyDest
NoCopyDest -> CopyFlags
flags{copyDest = v}
            Last CopyDest
_ -> [Char] -> CopyFlags
forall a. HasCallStack => [Char] -> a
error [Char]
"Use either 'destdir' or 'target-package-db'."
        )
        ( [Char]
-> ReadE (Last CopyDest)
-> (Last CopyDest -> [[Char]])
-> MkOptDescr
     (CopyFlags -> Last CopyDest)
     (Last CopyDest -> CopyFlags -> CopyFlags)
     CopyFlags
forall b a.
Monoid b =>
[Char]
-> ReadE b
-> (b -> [[Char]])
-> MkOptDescr (a -> b) (b -> a -> a) a
reqArg
            [Char]
"DATABASE"
            (([Char] -> Last CopyDest) -> ReadE (Last CopyDest)
forall a. ([Char] -> a) -> ReadE a
succeedReadE (CopyDest -> Last CopyDest
forall a. a -> Last a
Flag (CopyDest -> Last CopyDest)
-> ([Char] -> CopyDest) -> [Char] -> Last CopyDest
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> CopyDest
CopyToDb))
            (\Last CopyDest
f -> case Last CopyDest
f of Flag (CopyToDb [Char]
p) -> [[Char]
p]; Last CopyDest
_ -> [])
        )
    ]

emptyCopyFlags :: CopyFlags
emptyCopyFlags :: CopyFlags
emptyCopyFlags = CopyFlags
forall a. Monoid a => a
mempty

instance Monoid CopyFlags where
  mempty :: CopyFlags
mempty = CopyFlags
forall a. (Generic a, GMonoid (Rep a)) => a
gmempty
  mappend :: CopyFlags -> CopyFlags -> CopyFlags
mappend = CopyFlags -> CopyFlags -> CopyFlags
forall a. Semigroup a => a -> a -> a
(<>)

instance Semigroup CopyFlags where
  <> :: CopyFlags -> CopyFlags -> CopyFlags
(<>) = CopyFlags -> CopyFlags -> CopyFlags
forall a. (Generic a, GSemigroup (Rep a)) => a -> a -> a
gmappend