cabal-gild 1.4.0.1 → 1.5.0.0

raw patch · 19 files changed

+228/−52 lines, 19 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• cabal-gild.cabal +3/−1
• source/library/CabalGild/Unstable/Action/AttachComments.hs +1/−1
• source/library/CabalGild/Unstable/Action/EvaluatePragmas.hs +9/−11
• source/library/CabalGild/Unstable/Action/FormatFields.hs +6/−0
• source/library/CabalGild/Unstable/Class/MonadWalk.hs +6/−1
• source/library/CabalGild/Unstable/Exception/DuplicateOption.hs +22/−0
• source/library/CabalGild/Unstable/Exception/SpecifiedOutputWithCheckMode.hs +8/−1
• source/library/CabalGild/Unstable/Exception/SpecifiedStdinWithFileInput.hs +8/−1
• source/library/CabalGild/Unstable/Extra/CharParsing.hs +2/−0
• source/library/CabalGild/Unstable/Extra/FilePath.hs +9/−0
• source/library/CabalGild/Unstable/Type/Condition.hs +8/−0
• source/library/CabalGild/Unstable/Type/Context.hs +8/−7
• source/library/CabalGild/Unstable/Type/DiscoverTarget.hs +7/−2
• source/library/CabalGild/Unstable/Type/Flag.hs +49/−6
• source/library/CabalGild/Unstable/Type/Mixin.hs +5/−0
• source/library/CabalGild/Unstable/Type/Optional.hs +8/−9
• source/library/CabalGild/Unstable/Type/Variable.hs +11/−0
• source/library/CabalGild/Unstable/Type/VersionRange.hs +5/−0
• source/test-suite/Main.hs +53/−12

@@ -11,7 +11,7 @@ maintainer: Taylor Fausak name: cabal-gild synopsis: Formats package descriptions.-version: 1.4.0.1+version: 1.5.0.0  source-repository head   type: git@@ -82,6 +82,7 @@     CabalGild.Unstable.Class.MonadWalk     CabalGild.Unstable.Class.MonadWrite     CabalGild.Unstable.Exception.CheckFailure+    CabalGild.Unstable.Exception.DuplicateOption     CabalGild.Unstable.Exception.InvalidLeniency     CabalGild.Unstable.Exception.InvalidMode     CabalGild.Unstable.Exception.InvalidOption@@ -95,6 +96,7 @@     CabalGild.Unstable.Extra.Either     CabalGild.Unstable.Extra.Field     CabalGild.Unstable.Extra.FieldLine+    CabalGild.Unstable.Extra.FilePath     CabalGild.Unstable.Extra.List     CabalGild.Unstable.Extra.ModuleName     CabalGild.Unstable.Extra.Name

@@ -55,7 +55,7 @@  -- | Attaches comments to a section argument. Note that section arguments -- cannot actually have comments attached. That's because section arguments--- must be on -- the same line as the section name, so all comments will end up+-- must be on the same line as the section name, so all comments will end up -- attached to the name. sectionArg ::   (Ord p) =>

@@ -4,6 +4,7 @@ import qualified CabalGild.Unstable.Exception.InvalidOption as InvalidOption import qualified CabalGild.Unstable.Exception.UnknownOption as UnknownOption import qualified CabalGild.Unstable.Extra.FieldLine as FieldLine+import qualified CabalGild.Unstable.Extra.FilePath as FilePath import qualified CabalGild.Unstable.Extra.ModuleName as ModuleName import qualified CabalGild.Unstable.Extra.Name as Name import qualified CabalGild.Unstable.Extra.String as String@@ -26,7 +27,6 @@ import qualified Distribution.Utils.Generic as Utils import qualified System.Console.GetOpt as GetOpt import qualified System.FilePath as FilePath-import qualified System.FilePath.Windows as FilePath.Windows  -- | High level wrapper around 'field' that makes this action easier to compose -- with other actions.@@ -76,15 +76,15 @@   let (excs, incs) = Either.partitionEithers flgs   mapM_ (Exception.throwM . UnknownOption.fromString) opts   mapM_ (Exception.throwM . InvalidOption.fromString) errs-  let root = FilePath.dropTrailingPathSeparator . normalize $ FilePath.takeDirectory p+  let root = FilePath.dropTrailingPathSeparator . clean $ FilePath.takeDirectory p       directories =         List.nubOrd-          . fmap normalize+          . fmap clean           $ if null args then ["."] else args-      exclusions = List.nubOrd $ fmap normalize excs+      exclusions = List.nubOrd $ fmap clean excs       inclusions =         List.nubOrd-          . fmap normalize+          . fmap clean           $ if null incs then ["**"] else incs   files <- Trans.lift $ MonadWalk.walk root inclusions exclusions   let comments = concatMap (snd . FieldLine.annotation) fls@@ -95,7 +95,7 @@         DiscoverTarget.Modules ->           zipWith ModuleName.toFieldLine ((,) position <$> comments : repeat [])             . Maybe.mapMaybe (toModuleName directories)-            $ Maybe.mapMaybe (stripAnyExtension extensions . normalize) files+            $ Maybe.mapMaybe (stripAnyExtension extensions . clean) files         DiscoverTarget.Files ->           zipWith             (\a -> Fields.FieldLine a . String.toUtf8)@@ -108,11 +108,9 @@           else n   pure $ Fields.Field name fieldLines -normalize :: FilePath -> FilePath-normalize =-  FilePath.normalise-    . FilePath.joinPath-    . FilePath.Windows.splitDirectories+-- | Converts separators into POSIX format and then normalizes the result.+clean :: FilePath -> FilePath+clean = FilePath.normalise . FilePath.toPosixSeparators  -- | These are the names of the fields that can have this action applied to -- them.

@@ -77,6 +77,8 @@             else sas      in Fields.Section n newSas $ fmap (field csv) fs +-- | Returns 'True' if the field name is a conditional. @if@ is always one, and+-- @elif@ is one for Cabal versions 2.2 and later. isConditional :: CabalSpecVersion.CabalSpecVersion -> Fields.Name p -> Bool isConditional csv n =   Name.isIf n@@ -102,6 +104,8 @@         . PrettyPrint.renderStyle style         $ pretty csv r +-- | Collects comments from the given field lines (see 'collectComments') and+-- attaches them all to the first one. floatComments ::   p ->   [Fields.FieldLine (p, [c])] ->@@ -112,6 +116,8 @@     (True : repeat False)     fls +-- | Collects all comments from the given field lines. Their relative order+-- will be maintained. collectComments :: [Fields.FieldLine (p, [c])] -> [c] collectComments = concatMap (snd . FieldLine.annotation) 

@@ -3,9 +3,14 @@ import qualified System.FilePattern as FilePattern import qualified System.FilePattern.Directory as FilePattern --- | A wrapper around 'FilePattern.getDirectoryFilesIgnore'.+-- | A 'Monad' that can also "walk" a directory to discover files within it. class (Monad m) => MonadWalk m where+  -- | This has the same signature and semantics as+  -- 'FilePattern.getDirectoryFilesIgnore'. The first argument is the directory+  -- to walk. The second argument is a list of patterns to include. The third+  -- argument is a list of patterns to exclude.   walk :: FilePath -> [FilePattern.FilePattern] -> [FilePattern.FilePattern] -> m [FilePath] +-- | Uses 'FilePattern.getDirectoryFilesIgnore'. instance MonadWalk IO where   walk = FilePattern.getDirectoryFilesIgnore

@@ -0,0 +1,22 @@+module CabalGild.Unstable.Exception.DuplicateOption where++import qualified Control.Monad.Catch as Exception++-- | This exception is thrown when an option is specified more than once.+data DuplicateOption+  = DuplicateOption+  { option :: String,+    old :: String,+    new :: String+  }+  deriving (Eq, Show)++instance Exception.Exception DuplicateOption where+  displayException x =+    "overriding option --"+      <> option x+      <> " (before: "+      <> old x+      <> ", after: "+      <> new x+      <> ")"

@@ -1,5 +1,6 @@ module CabalGild.Unstable.Exception.SpecifiedOutputWithCheckMode where +import qualified CabalGild.Unstable.Type.Flag as Flag import qualified Control.Monad.Catch as Exception  -- | This exception is thrown when the user specifies the output while using@@ -9,4 +10,10 @@   deriving (Eq, Show)  instance Exception.Exception SpecifiedOutputWithCheckMode where-  displayException = const "cannot use --output when --mode is check"+  displayException =+    const $+      "cannot use --"+        <> Flag.outputOption+        <> " when --"+        <> Flag.modeOption+        <> " is check"

@@ -1,5 +1,6 @@ module CabalGild.Unstable.Exception.SpecifiedStdinWithFileInput where +import qualified CabalGild.Unstable.Type.Flag as Flag import qualified Control.Monad.Catch as Exception  -- | This exception is thrown when the user specifies the STDIN name while@@ -10,4 +11,10 @@   deriving (Eq, Show)  instance Exception.Exception SpecifiedStdinWithFileInput where-  displayException = const "cannot use --stdin when --input is a file"+  displayException =+    const $+      "cannot use --"+        <> Flag.stdinOption+        <> " when --"+        <> Flag.inputOption+        <> " is a file"

@@ -3,8 +3,10 @@ import qualified Distribution.Compat.CharParsing as Parse import qualified Distribution.Parsec as Parsec +-- | Wraps the given parser in parentheses. parens :: (Parsec.CabalParsing m) => m a -> m a parens = Parse.between (token "(") (token ")") +-- | Parses the given string followed by any amount of blank space. token :: (Parsec.CabalParsing m) => String -> m () token s = Parse.string s *> Parse.spaces

@@ -0,0 +1,9 @@+module CabalGild.Unstable.Extra.FilePath where++import qualified System.FilePath.Posix as Posix+import qualified System.FilePath.Windows as Windows++-- | Converts a 'FilePath' with potential Windows-style separators in it to one+-- with only POSIX-style separators.+toPosixSeparators :: FilePath -> FilePath+toPosixSeparators = Posix.joinPath . Windows.splitDirectories

@@ -9,6 +9,8 @@ import qualified Text.Parsec.Expr as PE import qualified Text.PrettyPrint as PrettyPrint +-- | Similar to 'Distribution.Types.Condition.Condition', but retains+-- information about parentheses. data Condition a   = Par (Condition a)   | Not (Condition a)@@ -18,6 +20,9 @@   | Var a   deriving (Eq, Show) +-- | Similar to 'Distribution.Fields.ConfVar.parseConditionConfVar', but+-- parameterized on the variable parser. Also it's a normal parser rather than+-- a function on section arguments. parseCondition :: Parsec.ParsecParser a -> Parsec.ParsecParser (Condition a) parseCondition parseVariable = Parsec.PP $ \csv -> do   let operators :: (P.Stream s m Char) => PE.OperatorTable s u m (Condition b)@@ -38,6 +43,7 @@       )       csv +-- | Parses a literal 'Condition'. parseLit :: (Parsec.CabalParsing m) => m Bool parseLit =   Parse.choice@@ -47,6 +53,8 @@       False <$ Parse.token "false"     ] +-- | Pretty-prints a 'Condition' using the given pretty-printer for the+-- variables. prettyCondition :: (a -> PrettyPrint.Doc) -> Condition a -> PrettyPrint.Doc prettyCondition f x =   case x of

@@ -14,6 +14,7 @@ import qualified Control.Monad.Catch as Exception import qualified Data.Char as Char import qualified Data.List as List+import qualified Data.Maybe as Maybe import qualified Data.Version as Version import qualified Paths_cabal_gild as This import qualified System.Console.GetOpt as GetOpt@@ -40,7 +41,7 @@ fromConfig config = do   let version = Version.showVersion This.version -  Monad.when (Optional.withDefault False $ Config.help config) $ do+  Monad.when (Maybe.fromMaybe False . Optional.toMaybe $ Config.help config) $ do     let header =           unlines             [ "cabal-gild version " <> version,@@ -52,7 +53,7 @@       $ GetOpt.usageInfo header Flag.options     Exception.throwM Exit.ExitSuccess -  Monad.when (Optional.withDefault False $ Config.version config) $ do+  Monad.when (Maybe.fromMaybe False . Optional.toMaybe $ Config.version config) $ do     MonadLog.logLn version     Exception.throwM Exit.ExitSuccess @@ -66,15 +67,15 @@       Exception.throwM SpecifiedOutputWithCheckMode.SpecifiedOutputWithCheckMode     _ -> pure () -  let theInput = Optional.withDefault Input.Stdin $ Config.input config+  let theInput = Maybe.fromMaybe Input.Stdin . Optional.toMaybe $ Config.input config       filePath = case theInput of         Input.Stdin -> "."         Input.File f -> f   pure     Context-      { crlf = Optional.withDefault Leniency.Lenient $ Config.crlf config,+      { crlf = Maybe.fromMaybe Leniency.Lenient . Optional.toMaybe $ Config.crlf config,         input = theInput,-        mode = Optional.withDefault Mode.Format $ Config.mode config,-        output = Optional.withDefault Output.Stdout $ Config.output config,-        stdin = Optional.withDefault filePath $ Config.stdin config+        mode = Maybe.fromMaybe Mode.Format . Optional.toMaybe $ Config.mode config,+        output = Maybe.fromMaybe Output.Stdout . Optional.toMaybe $ Config.output config,+        stdin = Maybe.fromMaybe filePath . Optional.toMaybe $ Config.stdin config       }

@@ -1,6 +1,11 @@ module CabalGild.Unstable.Type.DiscoverTarget where +-- | This type determines the type of thing to search for when using the+-- @discover@ pragma. data DiscoverTarget-  = Files-  | Modules+  = -- | Discovers any file at all.+    Files+  | -- | Discovers only Haskell modules, which also includes signatures and+    -- various pre-processors.+    Modules   deriving (Eq, Show)

@@ -1,10 +1,13 @@ module CabalGild.Unstable.Type.Flag where +import qualified CabalGild.Unstable.Exception.DuplicateOption as DuplicateOption import qualified CabalGild.Unstable.Exception.InvalidOption as InvalidOption import qualified CabalGild.Unstable.Exception.UnexpectedArgument as UnexpectedArgument import qualified CabalGild.Unstable.Exception.UnknownOption as UnknownOption import qualified Control.Monad.Catch as Exception import qualified Data.Foldable as Foldable+import qualified Data.Map as Map+import qualified Data.Maybe as Maybe import qualified System.Console.GetOpt as GetOpt  -- | A flag, which represents a command line option. The values associated with@@ -46,36 +49,54 @@       "",     GetOpt.Option       []-      ["crlf"]+      [crlfOption]       (GetOpt.ReqArg CRLF "LENIENCY")       "Sets the CRLF handling mode. Must be either 'lenient' or 'strict'.\nDefault: 'lenient'",     GetOpt.Option       ['i']-      ["input"]+      [inputOption]       (GetOpt.ReqArg Input "FILE")       "Sets the input file. Use '-' for standard input (STDIN).\nDefault: '-'",     GetOpt.Option       []-      ["io"]+      [ioOption]       (GetOpt.ReqArg IO "FILE")       "Shortcut for setting both the input and output files.",     GetOpt.Option       ['m']-      ["mode"]+      [modeOption]       (GetOpt.ReqArg Mode "MODE")       "Sets the mode. Must be either 'check' or 'format'.\nDefault: 'format'",     GetOpt.Option       ['o']-      ["output"]+      [outputOption]       (GetOpt.ReqArg Output "FILE")       "Sets the output file. Use '-' for standard output (STDOUT).\nDefault: '-'",     GetOpt.Option       ['s']-      ["stdin"]+      [stdinOption]       (GetOpt.ReqArg Stdin "FILE")       "Sets the path to the input file when using STDIN.\nDefault: '.'"   ] +crlfOption :: String+crlfOption = "crlf"++inputOption :: String+inputOption = "input"++ioOption :: String+ioOption = "io"++modeOption :: String+modeOption = "mode"++outputOption :: String+outputOption = "output"++stdinOption :: String+stdinOption = "stdin"+ -- | Converts a list of command line arguments into a list of flags. If there -- are any unexpected arguments, invalid options, or unknown options, an -- exception will be thrown.@@ -85,4 +106,26 @@   Foldable.traverse_ (Exception.throwM . UnexpectedArgument.fromString) args   Foldable.traverse_ (Exception.throwM . InvalidOption.fromString) errs   Foldable.traverse_ (Exception.throwM . UnknownOption.fromString) opts+  detectDuplicateOptions flgs   pure flgs++detectDuplicateOptions :: (Exception.MonadThrow m) => [Flag] -> m ()+detectDuplicateOptions =+  let toWarnings o l =+        fmap (uncurry . flip $ DuplicateOption.DuplicateOption o)+          . reverse+          . filter (uncurry (/=))+          $ zip l (drop 1 l)+      fromFlag f = case f of+        CRLF s -> Just (crlfOption, [s])+        Input s -> Just (inputOption, [s])+        IO s -> Just (ioOption, [s])+        Mode s -> Just (modeOption, [s])+        Output s -> Just (outputOption, [s])+        Stdin s -> Just (stdinOption, [s])+        _ -> Nothing+   in Foldable.traverse_ Exception.throwM+        . concatMap (uncurry toWarnings)+        . Map.toAscList+        . Map.fromListWith (<>)+        . Maybe.mapMaybe fromFlag

@@ -24,6 +24,7 @@ instance Pretty.Pretty Mixin where   pretty = Pretty.pretty . unwrap +-- | Sorts the 'Mixin.mixinIncludeRenaming' field using 'sortIncludeRenaming'. sortMixin :: Mixin.Mixin -> Mixin.Mixin sortMixin x =   Mixin.Mixin@@ -32,6 +33,8 @@       Mixin.mixinIncludeRenaming = sortIncludeRenaming $ Mixin.mixinIncludeRenaming x     } +-- | Sorts both 'IncludeRenaming.includeProvidesRn' and+-- 'IncludeRenaming.includeRequiresRn' fields using 'sortModuleRenaming'. sortIncludeRenaming :: IncludeRenaming.IncludeRenaming -> IncludeRenaming.IncludeRenaming sortIncludeRenaming x =   IncludeRenaming.IncludeRenaming@@ -39,6 +42,8 @@       IncludeRenaming.includeRequiresRn = sortModuleRenaming $ IncludeRenaming.includeRequiresRn x     } +-- | Sorts both 'ModuleRenaming.HidingRenaming' and+-- 'ModuleRenaming.ModuleRenaming' variants. sortModuleRenaming :: ModuleRenaming.ModuleRenaming -> ModuleRenaming.ModuleRenaming sortModuleRenaming x = case x of   ModuleRenaming.DefaultRenaming -> ModuleRenaming.DefaultRenaming

@@ -8,13 +8,12 @@   | Specific a   deriving (Eq, Show) --- | Uses the provided default value if the optional is 'Default', otherwise--- gets the value out of the 'Specific'. Similar to 'Data.Maybe.fromMaybe'.-withDefault :: a -> Optional a -> a-withDefault = flip optional id+-- | Converts a 'Maybe' value into an 'Optional' one.+fromMaybe :: Maybe a -> Optional a+fromMaybe = maybe Default Specific --- | Basic destructor, similar to 'maybe'.-optional :: b -> (a -> b) -> Optional a -> b-optional b f o = case o of-  Default -> b-  Specific s -> f s+-- | Converts an 'Optional' value into a 'Maybe' one.+toMaybe :: Optional a -> Maybe a+toMaybe o = case o of+  Default -> Nothing+  Specific s -> Just s

@@ -11,6 +11,8 @@ import qualified Distribution.Types.VersionRange as VersionRange import qualified Text.PrettyPrint as PrettyPrint +-- | Similar to 'Distribution.Types.ConfVar.ConfVar', but with different+-- parsing and pretty-printing behavior. data Variable   = Arch System.Arch   | Flag Flag.FlagName@@ -18,6 +20,7 @@   | Os System.OS   deriving (Eq, Show) +-- | Parses a 'Variable'. This is generally as permissive as possible. parseVariable :: (Parsec.CabalParsing m) => m Variable parseVariable =   Parse.choice@@ -27,14 +30,17 @@       Os <$> parseOs     ] +-- | Parses an 'Arch'. parseArch :: (Parsec.CabalParsing m) => m System.Arch parseArch =   fmap (System.classifyArch System.Permissive) $     Parse.token "arch" *> Parse.parens parseIdent +-- | Parses a 'Flag'. parseFlag :: (Parsec.CabalParsing m) => m Flag.FlagName parseFlag = Parse.token "flag" *> Parse.parens (Parsec.parsec <* Parse.spaces) +-- | Parses an 'Impl'. parseImpl :: (Parsec.CabalParsing m) => m (Compiler.CompilerFlavor, VersionRange.VersionRange) parseImpl = do   Parse.token "impl"@@ -45,16 +51,21 @@       <*> Parse.option VersionRange.anyVersion Parsec.parsec       <* Parse.spaces +-- | Parses an 'Os'. parseOs :: (Parsec.CabalParsing m) => m System.OS parseOs =   fmap (System.classifyOS System.Permissive) $     Parse.token "os" *> Parse.parens parseIdent +-- | Parses an identifier. This is more permissive than anything provided by+-- Cabal. Any run of alphanumeric characters, underscores, or hyphens is+-- considered an identifier. parseIdent :: (Parsec.CabalParsing m) => m String parseIdent =   let isIdent c = Char.isAlphaNum c || c == '_' || c == '-'    in Parse.munch1 isIdent <* Parse.spaces +-- | Pretty-prints a 'Variable'. prettyVariable :: Variable -> PrettyPrint.Doc prettyVariable x =   case x of

@@ -16,6 +16,9 @@   | Intersect (VersionRange a) (VersionRange a)   deriving (Eq, Ord, Show) +-- | Converts a 'PkgconfigVersionRange.PkgconfigVersionRange' into a+-- 'VersionRange'. Note that the former is more expressive, so things like+-- 'PkgconfigVersionRange.PcOrLaterVersion' will be converted into a 'Union'. fromPkgconfigVersionRange ::   PkgconfigVersionRange.PkgconfigVersionRange ->   VersionRange PkgconfigVersion.PkgconfigVersion@@ -29,6 +32,8 @@   PkgconfigVersionRange.PcUnionVersionRanges v w -> Union (fromPkgconfigVersionRange v) (fromPkgconfigVersionRange w)   PkgconfigVersionRange.PcIntersectVersionRanges v w -> Intersect (fromPkgconfigVersionRange v) (fromPkgconfigVersionRange w) +-- | Converts a 'VersionRange.VersionRange' into a 'VersionRange'. These are+-- isomorphic, so no information is lost. fromVersionRange :: VersionRange.VersionRange -> VersionRange Version.Version fromVersionRange =   VersionRange.foldVersionRange

@@ -1,4 +1,3 @@-{- hlint ignore "Redundant bracket" -} {-# LANGUAGE GeneralizedNewtypeDeriving #-}  import qualified CabalGild.Unstable.Class.MonadLog as MonadLog@@ -6,6 +5,7 @@ import qualified CabalGild.Unstable.Class.MonadWalk as MonadWalk import qualified CabalGild.Unstable.Class.MonadWrite as MonadWrite import qualified CabalGild.Unstable.Exception.CheckFailure as CheckFailure+import qualified CabalGild.Unstable.Exception.DuplicateOption as DuplicateOption import qualified CabalGild.Unstable.Exception.InvalidOption as InvalidOption import qualified CabalGild.Unstable.Exception.SpecifiedOutputWithCheckMode as SpecifiedOutputWithCheckMode import qualified CabalGild.Unstable.Exception.SpecifiedStdinWithFileInput as SpecifiedStdinWithFileInput@@ -47,23 +47,55 @@     s `Hspec.shouldBe` Map.empty    Hspec.it "fails with an unknown option" $ do-    let (a, s, w) = runGild ["--unknown"] [] (".", [])-    a `shouldBeFailure` UnknownOption.UnknownOption "--unknown"-    w `Hspec.shouldBe` []-    s `Hspec.shouldBe` Map.empty+    expectException ["--unknown"] $+      UnknownOption.fromString "--unknown"    Hspec.it "fails with an invalid option" $ do-    let (a, s, w) = runGild ["--help=invalid"] [] (".", [])-    a `shouldBeFailure` InvalidOption.InvalidOption "option `--help' doesn't allow an argument"-    w `Hspec.shouldBe` []-    s `Hspec.shouldBe` Map.empty+    expectException ["--help=invalid"] $+      InvalidOption.fromString "option `--help' doesn't allow an argument"    Hspec.it "fails with an unexpected argument" $ do-    let (a, s, w) = runGild ["unexpected"] [] (".", [])-    a `shouldBeFailure` UnexpectedArgument.UnexpectedArgument "unexpected"+    expectException ["unexpected"] $+      UnexpectedArgument.fromString "unexpected"++  Hspec.it "fails when --crlf is given twice" $ do+    expectException ["--crlf=strict", "--crlf=lenient"] $+      DuplicateOption.DuplicateOption "crlf" "strict" "lenient"++  Hspec.it "does not fail when a flag is given twice with the same value" $ do+    let (a, s, w) =+          runGild+            ["--crlf=strict", "--crlf=strict"]+            [(Input.Stdin, String.toUtf8 "")]+            (".", [])+    a `Hspec.shouldSatisfy` Either.isRight     w `Hspec.shouldBe` []-    s `Hspec.shouldBe` Map.empty+    s `Hspec.shouldBe` Map.singleton Output.Stdout (String.toUtf8 "") +  Hspec.it "fails when a flag is repeatedly overriden" $ do+    expectException ["-ia", "-ib", "-i-"] $+      DuplicateOption.DuplicateOption "input" "a" "b"++  Hspec.it "fails when --input is given twice" $ do+    expectException+      ["--input=f", "--input=-"]+      $ DuplicateOption.DuplicateOption "input" "f" "-"++  Hspec.it "fails when --mode is given twice" $ do+    expectException+      ["--mode=check", "--mode=format"]+      $ DuplicateOption.DuplicateOption "mode" "check" "format"++  Hspec.it "fails when --output is given twice" $ do+    expectException+      ["--output=f", "--output=-"]+      $ DuplicateOption.DuplicateOption "output" "f" "-"++  Hspec.it "fails when --stdin is given twice" $ do+    expectException+      ["--stdin=f", "--stdin=g"]+      $ DuplicateOption.DuplicateOption "stdin" "f" "g"+   Hspec.it "reads from an input file" $ do     let (a, s, w) =           runGild@@ -1625,6 +1657,15 @@       fmap FilePath.joinPath <$> uncurry Map.singleton files     )     Map.empty++expectException ::+  (Stack.HasCallStack, Eq e, Exception.Exception e) =>+  [String] -> e -> Hspec.Expectation+expectException flags exception = do+  let (a, s, w) = runGild flags [] (".", [])+  a `shouldBeFailure` exception+  w `Hspec.shouldBe` []+  s `Hspec.shouldBe` Map.empty  type Test = TestT Identity.Identity