{-# OPTIONS -Wno-redundant-constraints #-}

-- | `Stratosphere.Check` exports functions to catch errors
-- that would be too expensive or unwieldy to encode in types.
--
-- Stability: Experimental

module Stratosphere.Check (duplicateProperties) where

import Stratosphere.Prelude
import Stratosphere.Resource
import Stratosphere.Template

import qualified Data.Map.Strict as Map

newtype DuplicateProperty = DuplicateProperty Text
  deriving (Int -> DuplicateProperty -> ShowS
[DuplicateProperty] -> ShowS
DuplicateProperty -> String
(Int -> DuplicateProperty -> ShowS)
-> (DuplicateProperty -> String)
-> ([DuplicateProperty] -> ShowS)
-> Show DuplicateProperty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DuplicateProperty -> ShowS
showsPrec :: Int -> DuplicateProperty -> ShowS
$cshow :: DuplicateProperty -> String
show :: DuplicateProperty -> String
$cshowList :: [DuplicateProperty] -> ShowS
showList :: [DuplicateProperty] -> ShowS
Show, DuplicateProperty -> DuplicateProperty -> Bool
(DuplicateProperty -> DuplicateProperty -> Bool)
-> (DuplicateProperty -> DuplicateProperty -> Bool)
-> Eq DuplicateProperty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DuplicateProperty -> DuplicateProperty -> Bool
== :: DuplicateProperty -> DuplicateProperty -> Bool
$c/= :: DuplicateProperty -> DuplicateProperty -> Bool
/= :: DuplicateProperty -> DuplicateProperty -> Bool
Eq)

duplicateProperties :: Template -> [DuplicateProperty]
duplicateProperties :: Template -> [DuplicateProperty]
duplicateProperties =
    (Text -> DuplicateProperty) -> [Text] -> [DuplicateProperty]
forall a b. (a -> b) -> [a] -> [b]
map Text -> DuplicateProperty
DuplicateProperty
  ([Text] -> [DuplicateProperty])
-> (Template -> [Text]) -> Template -> [DuplicateProperty]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Text] -> [Text]
forall (f :: * -> *) a. (Foldable f, Eq a, Ord a) => f a -> [a]
duplicates
  ([Text] -> [Text]) -> (Template -> [Text]) -> Template -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Resource -> Text) -> [Resource] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (.logicalName)
  ([Resource] -> [Text])
-> (Template -> [Resource]) -> Template -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (.resourceList)
  (Resources -> [Resource])
-> (Template -> Resources) -> Template -> [Resource]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\Template{Maybe Object
Maybe Text
Maybe (Map Text Mapping)
Maybe Parameters
Maybe Outputs
Resources
conditions :: Maybe Object
description :: Maybe Text
formatVersion :: Maybe Text
mappings :: Maybe (Map Text Mapping)
metadata :: Maybe Object
outputs :: Maybe Outputs
parameters :: Maybe Parameters
resources :: Resources
resources :: Template -> Resources
parameters :: Template -> Maybe Parameters
outputs :: Template -> Maybe Outputs
metadata :: Template -> Maybe Object
mappings :: Template -> Maybe (Map Text Mapping)
formatVersion :: Template -> Maybe Text
description :: Template -> Maybe Text
conditions :: Template -> Maybe Object
..} -> Resources
resources)

duplicates :: (Foldable f, Eq a, Ord a) => f a -> [a]
duplicates :: forall (f :: * -> *) a. (Foldable f, Eq a, Ord a) => f a -> [a]
duplicates =
  Map a Int -> [a]
forall k a. Map k a -> [k]
Map.keys (Map a Int -> [a]) -> (f a -> Map a Int) -> f a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Bool) -> Map a Int -> Map a Int
forall a k. (a -> Bool) -> Map k a -> Map k a
Map.filter (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
one) (Map a Int -> Map a Int) -> (f a -> Map a Int) -> f a -> Map a Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> Map a Int -> Map a Int) -> Map a Int -> f a -> Map a Int
forall a b. (a -> b -> b) -> b -> f a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Int -> a -> Map a Int -> Map a Int
forall k v. (Eq k, Ord k, Num v) => v -> k -> Map k v -> Map k v
insertByAdding Int
one) []
  where one :: Int
        one :: Int
one = Int
1

insertByAdding :: (Eq k, Ord k, Num v) => v -> k -> Map k v -> Map k v
insertByAdding :: forall k v. (Eq k, Ord k, Num v) => v -> k -> Map k v -> Map k v
insertByAdding = (k -> v -> Map k v -> Map k v) -> v -> k -> Map k v -> Map k v
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((k -> v -> Map k v -> Map k v) -> v -> k -> Map k v -> Map k v)
-> (k -> v -> Map k v -> Map k v) -> v -> k -> Map k v -> Map k v
forall a b. (a -> b) -> a -> b
$ (v -> v -> v) -> k -> v -> Map k v -> Map k v
forall k a. Ord k => (a -> a -> a) -> k -> a -> Map k a -> Map k a
Map.insertWith v -> v -> v
forall a. Num a => a -> a -> a
(+)