module CabalGild.Unstable.Type.Mixin where

import qualified Data.List as List
import qualified Data.Ord as Ord
import qualified Distribution.Parsec as Parsec
import qualified Distribution.Pretty as Pretty
import qualified Distribution.Types.IncludeRenaming as IncludeRenaming
import qualified Distribution.Types.Mixin as Mixin
import qualified Distribution.Types.ModuleRenaming as ModuleRenaming

-- | This is a wrapper around 'Mixin.Mixin' that sorts the nested module names
-- when parsing.
newtype Mixin = Mixin
  { Mixin -> Mixin
unwrap :: Mixin.Mixin
  }
  deriving (Mixin -> Mixin -> Bool
(Mixin -> Mixin -> Bool) -> (Mixin -> Mixin -> Bool) -> Eq Mixin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mixin -> Mixin -> Bool
== :: Mixin -> Mixin -> Bool
$c/= :: Mixin -> Mixin -> Bool
/= :: Mixin -> Mixin -> Bool
Eq, Int -> Mixin -> ShowS
[Mixin] -> ShowS
Mixin -> String
(Int -> Mixin -> ShowS)
-> (Mixin -> String) -> ([Mixin] -> ShowS) -> Show Mixin
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Mixin -> ShowS
showsPrec :: Int -> Mixin -> ShowS
$cshow :: Mixin -> String
show :: Mixin -> String
$cshowList :: [Mixin] -> ShowS
showList :: [Mixin] -> ShowS
Show)

instance Ord Mixin where
  compare :: Mixin -> Mixin -> Ordering
compare = (Mixin -> Mixin) -> Mixin -> Mixin -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
Ord.comparing Mixin -> Mixin
unwrap

instance Parsec.Parsec Mixin where
  parsec :: forall (m :: * -> *). CabalParsing m => m Mixin
parsec = Mixin -> Mixin
Mixin (Mixin -> Mixin) -> (Mixin -> Mixin) -> Mixin -> Mixin
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Mixin -> Mixin
sortMixin (Mixin -> Mixin) -> m Mixin -> m Mixin
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Mixin
forall a (m :: * -> *). (Parsec a, CabalParsing m) => m a
forall (m :: * -> *). CabalParsing m => m Mixin
Parsec.parsec

instance Pretty.Pretty Mixin where
  pretty :: Mixin -> Doc
pretty = Mixin -> Doc
forall a. Pretty a => a -> Doc
Pretty.pretty (Mixin -> Doc) -> (Mixin -> Mixin) -> Mixin -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Mixin -> Mixin
unwrap

sortMixin :: Mixin.Mixin -> Mixin.Mixin
sortMixin :: Mixin -> Mixin
sortMixin Mixin
x =
  Mixin.Mixin
    { mixinPackageName :: PackageName
Mixin.mixinPackageName = Mixin -> PackageName
Mixin.mixinPackageName Mixin
x,
      mixinLibraryName :: LibraryName
Mixin.mixinLibraryName = Mixin -> LibraryName
Mixin.mixinLibraryName Mixin
x,
      mixinIncludeRenaming :: IncludeRenaming
Mixin.mixinIncludeRenaming = IncludeRenaming -> IncludeRenaming
sortIncludeRenaming (IncludeRenaming -> IncludeRenaming)
-> IncludeRenaming -> IncludeRenaming
forall a b. (a -> b) -> a -> b
$ Mixin -> IncludeRenaming
Mixin.mixinIncludeRenaming Mixin
x
    }

sortIncludeRenaming :: IncludeRenaming.IncludeRenaming -> IncludeRenaming.IncludeRenaming
sortIncludeRenaming :: IncludeRenaming -> IncludeRenaming
sortIncludeRenaming IncludeRenaming
x =
  IncludeRenaming.IncludeRenaming
    { includeProvidesRn :: ModuleRenaming
IncludeRenaming.includeProvidesRn = ModuleRenaming -> ModuleRenaming
sortModuleRenaming (ModuleRenaming -> ModuleRenaming)
-> ModuleRenaming -> ModuleRenaming
forall a b. (a -> b) -> a -> b
$ IncludeRenaming -> ModuleRenaming
IncludeRenaming.includeProvidesRn IncludeRenaming
x,
      includeRequiresRn :: ModuleRenaming
IncludeRenaming.includeRequiresRn = ModuleRenaming -> ModuleRenaming
sortModuleRenaming (ModuleRenaming -> ModuleRenaming)
-> ModuleRenaming -> ModuleRenaming
forall a b. (a -> b) -> a -> b
$ IncludeRenaming -> ModuleRenaming
IncludeRenaming.includeRequiresRn IncludeRenaming
x
    }

sortModuleRenaming :: ModuleRenaming.ModuleRenaming -> ModuleRenaming.ModuleRenaming
sortModuleRenaming :: ModuleRenaming -> ModuleRenaming
sortModuleRenaming ModuleRenaming
x = case ModuleRenaming
x of
  ModuleRenaming
ModuleRenaming.DefaultRenaming -> ModuleRenaming
ModuleRenaming.DefaultRenaming
  ModuleRenaming.HidingRenaming [ModuleName]
ys -> [ModuleName] -> ModuleRenaming
ModuleRenaming.HidingRenaming ([ModuleName] -> ModuleRenaming) -> [ModuleName] -> ModuleRenaming
forall a b. (a -> b) -> a -> b
$ [ModuleName] -> [ModuleName]
forall a. Ord a => [a] -> [a]
List.sort [ModuleName]
ys
  ModuleRenaming.ModuleRenaming [(ModuleName, ModuleName)]
ys -> [(ModuleName, ModuleName)] -> ModuleRenaming
ModuleRenaming.ModuleRenaming ([(ModuleName, ModuleName)] -> ModuleRenaming)
-> [(ModuleName, ModuleName)] -> ModuleRenaming
forall a b. (a -> b) -> a -> b
$ [(ModuleName, ModuleName)] -> [(ModuleName, ModuleName)]
forall a. Ord a => [a] -> [a]
List.sort [(ModuleName, ModuleName)]
ys