{-# LANGUAGE CPP #-}
-- |
-- Module: Staversion.Internal.Version
-- Description: Compatibility wrapper for Distribution.Version etc. from Cabal package
-- Maintainer: Toshio Ito <debug.ito@gmail.com>
--
-- __This is an internal module. End-users should not use it.__
module Staversion.Internal.Version
       ( -- * Re-exports
         V.Version,
         V.VersionRange,
         V.LowerBound(..),
         V.UpperBound(..),
         V.Bound(..),
         V.VersionInterval,
         V.thisVersion,
         V.unionVersionRanges,
         V.simplifyVersionRange,
         V.fromVersionIntervals,
         V.asVersionIntervals,
         -- * Compatibility
         mkVersion,
         mkVersionIntervals,
         versionNumbers,
         docVersionRange,
         -- * Util
         BaseVersion,
         showBaseVersion,
         parseVersionText
       ) where

import Data.Maybe (listToMaybe, fromJust)
import Data.Text (Text, unpack)

import qualified Distribution.Version as V
#if MIN_VERSION_Cabal(2,2,0)
import qualified Distribution.Pretty as DP
#else
import qualified Distribution.Text as DT
#endif

import Data.Version (parseVersion)
import qualified Data.Version as BaseV
import Text.ParserCombinators.ReadP (readP_to_S)
import Text.PrettyPrint (Doc)

-- | A Version type by "Data.Version".
type BaseVersion = BaseV.Version

showBaseVersion :: BaseVersion -> String
showBaseVersion :: BaseVersion -> String
showBaseVersion = BaseVersion -> String
BaseV.showVersion

baseVToV :: BaseV.Version -> V.Version
baseVToV :: BaseVersion -> Version
baseVToV = [Int] -> Version
mkVersion ([Int] -> Version)
-> (BaseVersion -> [Int]) -> BaseVersion -> Version
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BaseVersion -> [Int]
BaseV.versionBranch

-- | Parse a version text. There must not be any trailing characters
-- after a valid version text.
parseVersionText :: Text -> Maybe V.Version
parseVersionText :: Text -> Maybe Version
parseVersionText = [(BaseVersion, String)] -> Maybe Version
extractResult ([(BaseVersion, String)] -> Maybe Version)
-> (Text -> [(BaseVersion, String)]) -> Text -> Maybe Version
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ReadP BaseVersion -> ReadS BaseVersion
forall a. ReadP a -> ReadS a
readP_to_S ReadP BaseVersion
parseVersion) ReadS BaseVersion
-> (Text -> String) -> Text -> [(BaseVersion, String)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
unpack where
  extractResult :: [(BaseVersion, String)] -> Maybe Version
extractResult = (BaseVersion -> Version) -> Maybe BaseVersion -> Maybe Version
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BaseVersion -> Version
baseVToV (Maybe BaseVersion -> Maybe Version)
-> ([(BaseVersion, String)] -> Maybe BaseVersion)
-> [(BaseVersion, String)]
-> Maybe Version
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [BaseVersion] -> Maybe BaseVersion
forall a. [a] -> Maybe a
listToMaybe ([BaseVersion] -> Maybe BaseVersion)
-> ([(BaseVersion, String)] -> [BaseVersion])
-> [(BaseVersion, String)]
-> Maybe BaseVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((BaseVersion, String) -> BaseVersion)
-> [(BaseVersion, String)] -> [BaseVersion]
forall a b. (a -> b) -> [a] -> [b]
map (BaseVersion, String) -> BaseVersion
forall a b. (a, b) -> a
fst ([(BaseVersion, String)] -> [BaseVersion])
-> ([(BaseVersion, String)] -> [(BaseVersion, String)])
-> [(BaseVersion, String)]
-> [BaseVersion]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((BaseVersion, String) -> Bool)
-> [(BaseVersion, String)] -> [(BaseVersion, String)]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(BaseVersion, String)
pair -> (BaseVersion, String) -> String
forall a b. (a, b) -> b
snd (BaseVersion, String)
pair String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
"")

#if MIN_VERSION_Cabal(2,0,0)
mkVersion :: [Int] -> V.Version
mkVersion :: [Int] -> Version
mkVersion = [Int] -> Version
V.mkVersion

versionNumbers :: V.Version -> [Int]
versionNumbers :: Version -> [Int]
versionNumbers = Version -> [Int]
V.versionNumbers

#else

mkVersion :: [Int] -> V.Version
mkVersion vs = V.Version vs []

versionNumbers :: V.Version -> [Int]
versionNumbers = V.versionBranch

#endif


#if MIN_VERSION_Cabal(2,2,0)

mkVersionIntervals :: [V.VersionInterval] -> V.VersionIntervals
mkVersionIntervals :: [VersionInterval] -> VersionIntervals
mkVersionIntervals = [VersionInterval] -> VersionIntervals
V.mkVersionIntervals

#else

mkVersionIntervals :: [V.VersionInterval] -> V.VersionIntervals
mkVersionIntervals = fromJust . V.mkVersionIntervals

#endif


#if MIN_VERSION_Cabal(2,2,0)
docVersionRange :: V.VersionRange -> Doc
docVersionRange :: VersionRange -> Doc
docVersionRange = VersionRange -> Doc
forall a. Pretty a => a -> Doc
DP.pretty
#else
docVersionRange :: V.VersionRange -> Doc
docVersionRange = DT.disp
#endif