Provide multiple files to various CLI subcommands

dhall-openapi/openapi-to-dhall/Main.hs

@@ -75,10 +75,9 @@ writeDhall path expr = do
 
   let outputMode = Dhall.Util.Write
 
-  let input =
-        Dhall.Util.PossiblyTransitiveInputFile
-            path
-            Dhall.Util.NonTransitive
+  let inputs = pure (Dhall.Util.InputFile path)
+
+  let transitivity = Dhall.Util.NonTransitive
 
   let formatOptions = Dhall.Format.Format{..}
 

dhall/src/Dhall/Format.hs

@@ -11,19 +11,24 @@ module Dhall.Format
     , format
     ) where
 
-import Data.Foldable (for_)
-import Data.Maybe    (fromMaybe)
-import Dhall.Pretty  (CharacterSet, annToAnsiStyle, detectCharacterSet)
+import Data.Foldable      (for_)
+import Data.List.NonEmpty (NonEmpty)
+import Data.Maybe         (fromMaybe)
+import Dhall.Pretty
+    ( CharacterSet
+    , annToAnsiStyle
+    , detectCharacterSet
+    )
 import Dhall.Util
     ( Censor
     , CheckFailed (..)
     , Header (..)
+    , Input (..)
     , OutputMode (..)
-    , PossiblyTransitiveInput (..)
     , Transitivity (..)
+    , handleMultipleChecksFailed
     )
 
-import qualified Control.Exception
 import qualified Data.Text.IO
 import qualified Data.Text.Prettyprint.Doc                 as Pretty
 import qualified Data.Text.Prettyprint.Doc.Render.Terminal as Pretty.Terminal
@@ -40,19 +45,21 @@ import qualified System.IO
 data Format = Format
     { chosenCharacterSet :: Maybe CharacterSet
     , censor             :: Censor
-    , input              :: PossiblyTransitiveInput
+    , transitivity       :: Transitivity
+    , inputs             :: NonEmpty Input
     , outputMode         :: OutputMode
     }
 
 -- | Implementation of the @dhall format@ subcommand
 format :: Format -> IO ()
-format (Format { input = input0, ..}) = go input0
+format (Format { inputs = inputs0, transitivity = transitivity0, ..}) =
+    handleMultipleChecksFailed "format" "formatted" go inputs0
   where
     go input = do
         let directory = case input of
-                NonTransitiveStandardInput ->
+                StandardInput ->
                     "."
-                PossiblyTransitiveInputFile file _ ->
+                InputFile file ->
                     System.FilePath.takeDirectory file
 
         let status = Dhall.Import.emptyStatus directory
@@ -66,16 +73,16 @@ format (Format { input = input0, ..}) = go input0
                     <>  "\n")
 
         (originalText, transitivity) <- case input of
-            PossiblyTransitiveInputFile file transitivity -> do
+            InputFile file -> do
                 text <- Data.Text.IO.readFile file
 
-                return (text, transitivity)
-
-            NonTransitiveStandardInput -> do
+                return (text, transitivity0)
+            StandardInput -> do
                 text <- Data.Text.IO.getContents
 
                 return (text, NonTransitive)
 
+
         headerAndExpr@(_, parsedExpression) <- Dhall.Util.getExpressionAndHeaderFromStdinText censor originalText
 
         case transitivity of
@@ -84,7 +91,7 @@ format (Format { input = input0, ..}) = go input0
                     maybeFilepath <- Dhall.Import.dependencyToFile status import_
 
                     for_ maybeFilepath $ \filepath ->
-                        go (PossiblyTransitiveInputFile filepath Transitive)
+                        go (InputFile filepath)
 
             NonTransitive ->
                 return ()
@@ -94,16 +101,16 @@ format (Format { input = input0, ..}) = go input0
         let formattedText = Pretty.Text.renderStrict docStream
 
         case outputMode of
-            Write ->
+            Write -> do
                 case input of
-                    PossiblyTransitiveInputFile file _ ->
+                    InputFile file ->
                         if originalText == formattedText
                             then return ()
                             else AtomicWrite.LazyText.atomicWriteFile
                                     file
                                     (Pretty.Text.renderLazy docStream)
 
-                    NonTransitiveStandardInput -> do
+                    StandardInput -> do
                         supportsANSI <- System.Console.ANSI.hSupportsANSI System.IO.stdout
 
                         Pretty.Terminal.renderIO
@@ -112,12 +119,10 @@ format (Format { input = input0, ..}) = go input0
                                 then (fmap annToAnsiStyle docStream)
                                 else (Pretty.unAnnotateS docStream))
 
-            Check ->
-                if originalText == formattedText
-                    then return ()
-                    else do
-                        let command = "format"
-
-                        let modified = "formatted"
+                return (Right ())
 
-                        Control.Exception.throwIO CheckFailed{..}
+            Check ->
+                return $
+                    if originalText == formattedText
+                        then Right ()
+                        else Left CheckFailed{..}

dhall/src/Dhall/Freeze.hs

@@ -22,6 +22,7 @@ module Dhall.Freeze
     ) where
 
 import Data.Foldable       (for_)
+import Data.List.NonEmpty  (NonEmpty)
 import Data.Maybe          (fromMaybe)
 import Dhall.Pretty        (CharacterSet, detectCharacterSet)
 import Dhall.Syntax
@@ -34,9 +35,10 @@ import Dhall.Util
     ( Censor
     , CheckFailed (..)
     , Header (..)
+    , Input (..)
     , OutputMode (..)
-    , PossiblyTransitiveInput (..)
     , Transitivity (..)
+    , handleMultipleChecksFailed
     )
 import System.Console.ANSI (hSupportsANSI)
 
@@ -140,7 +142,8 @@ data Intent
 -- | Implementation of the @dhall freeze@ subcommand
 freeze
     :: OutputMode
-    -> PossiblyTransitiveInput
+    -> Transitivity
+    -> NonEmpty Input
     -> Scope
     -> Intent
     -> Maybe CharacterSet
@@ -152,30 +155,32 @@ freeze = freezeWithManager Dhall.Import.defaultNewManager
 freezeWithManager
     :: IO Dhall.Import.Manager
     -> OutputMode
-    -> PossiblyTransitiveInput
+    -> Transitivity
+    -> NonEmpty Input
     -> Scope
     -> Intent
     -> Maybe CharacterSet
     -> Censor
     -> IO ()
-freezeWithManager newManager outputMode input0 scope intent chosenCharacterSet censor = go input0
+freezeWithManager newManager outputMode transitivity0 inputs scope intent chosenCharacterSet censor =
+    handleMultipleChecksFailed "freeze" "frozen" go inputs
   where
     go input = do
         let directory = case input of
-                NonTransitiveStandardInput ->
+                StandardInput ->
                     "."
-                PossiblyTransitiveInputFile file _ ->
+                InputFile file ->
                     System.FilePath.takeDirectory file
 
         let status = Dhall.Import.emptyStatusWithManager newManager directory
 
         (originalText, transitivity) <- case input of
-            PossiblyTransitiveInputFile file transitivity -> do
+            InputFile file -> do
                 text <- Text.IO.readFile file
 
-                return (text, transitivity)
+                return (text, transitivity0)
 
-            NonTransitiveStandardInput -> do
+            StandardInput -> do
                 text <- Text.IO.getContents
 
                 return (text, NonTransitive)
@@ -190,7 +195,7 @@ freezeWithManager newManager outputMode input0 scope intent chosenCharacterSet c
                     maybeFilepath <- Dhall.Import.dependencyToFile status import_
 
                     for_ maybeFilepath $ \filepath ->
-                        go (PossiblyTransitiveInputFile filepath Transitive)
+                        go (InputFile filepath)
 
             NonTransitive ->
                 return ()
@@ -210,31 +215,29 @@ freezeWithManager newManager outputMode input0 scope intent chosenCharacterSet c
                 let unAnnotated = Pretty.unAnnotateS stream
 
                 case input of
-                    PossiblyTransitiveInputFile file _ ->
+                    InputFile file ->
                         if originalText == modifiedText
                             then return ()
                             else
                                 AtomicWrite.LazyText.atomicWriteFile
                                     file
                                     (Pretty.Text.renderLazy unAnnotated)
 
-                    NonTransitiveStandardInput -> do
+                    StandardInput -> do
                         supportsANSI <- System.Console.ANSI.hSupportsANSI System.IO.stdout
                         if supportsANSI
                            then
                              Pretty.renderIO System.IO.stdout (Dhall.Pretty.annToAnsiStyle <$> stream)
                            else
                              Pretty.renderIO System.IO.stdout unAnnotated
 
-            Check ->
-                if originalText == modifiedText
-                    then return ()
-                    else do
-                        let command = "freeze"
-
-                        let modified = "frozen"
+                return (Right ())
 
-                        Exception.throwIO CheckFailed{..}
+            Check ->
+                return $
+                    if originalText == modifiedText
+                        then Right ()
+                        else Left CheckFailed{..}
 
 {-| Slightly more pure version of the `freeze` function