    module Distribution.Pretty
      ( Pretty (..)
      , prettyShow
      , defaultStyle
      , flatStyle

        -- * Utilities
      , showFilePath
      , showToken
      , showTokenStr
      , showFreeText
      , showFreeTextV3

        -- * Deprecated
      , Separator
      ) where

    import Distribution.CabalSpecVersion
    import Distribution.Compat.Prelude
    import Prelude ()

    import qualified Text.PrettyPrint as PP

    class Pretty a where
      pretty :: a -> PP.Doc

      prettyVersioned :: CabalSpecVersion -> a -> PP.Doc
      prettyVersioned CabalSpecVersion
    _ = a -> Doc
    forall a. Pretty a => a -> Doc
    pretty

    -- | @since 3.4.0.0
    instance Pretty PP.Doc where
      pretty :: Doc -> Doc
    pretty = Doc -> Doc
    forall a. a -> a
    id

    instance Pretty Bool where
      pretty :: Bool -> Doc
    pretty = String -> Doc
    PP.text (String -> Doc) -> (Bool -> String) -> Bool -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Bool -> String
    forall a. Show a => a -> String
    show

    instance Pretty Int where
      pretty :: Int -> Doc
    pretty = String -> Doc
    PP.text (String -> Doc) -> (Int -> String) -> Int -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Int -> String
    forall a. Show a => a -> String
    show

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

    prettyShow :: Pretty a => a -> String
    prettyShow :: forall a. Pretty a => a -> String
    prettyShow = Style -> Doc -> String
    PP.renderStyle Style
    defaultStyle (Doc -> String) -> (a -> Doc) -> a -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Doc
    forall a. Pretty a => a -> Doc
    pretty

    -- | The default rendering style used in Cabal for console
    -- output. It has a fixed page width and adds line breaks
    -- automatically.
    defaultStyle :: PP.Style
    defaultStyle :: Style
    defaultStyle =
      PP.Style
        { mode :: Mode
    PP.mode = Mode
    PP.PageMode
        , lineLength :: Int
    PP.lineLength = Int
    79
        , ribbonsPerLine :: Float
    PP.ribbonsPerLine = Float
    1.0
        }

    -- | A style for rendering all on one line.
    flatStyle :: PP.Style
    flatStyle :: Style
    flatStyle =
      PP.Style
        { mode :: Mode
    PP.mode = Mode
    PP.LeftMode
        , lineLength :: Int
    PP.lineLength = String -> Int
    forall {a}. String -> a
    err String
    "lineLength"
        , ribbonsPerLine :: Float
    PP.ribbonsPerLine = String -> Float
    forall {a}. String -> a
    err String
    "ribbonsPerLine"
        }
      where
        err :: String -> a
    err String
    x =
          String -> a
    forall a. HasCallStack => String -> a
    error
            ( String
    "flatStyle: tried to access "
                String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    x
                String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    " in LeftMode. "
                String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "This should never happen and indicates a bug in Cabal."
            )

    -------------------------------------------------------------------------------
    -- Utilities
    -------------------------------------------------------------------------------

    -- TODO: remove when ReadP parser is gone.
    type Separator = [PP.Doc] -> PP.Doc

    showFilePath :: FilePath -> PP.Doc
    showFilePath :: String -> Doc
    showFilePath = String -> Doc
    showToken

    showToken :: String -> PP.Doc
    showToken :: String -> Doc
    showToken = String -> Doc
    PP.text (String -> Doc) -> (String -> String) -> String -> Doc
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> String
    showTokenStr

    showTokenStr :: String -> String
    showTokenStr :: String -> String
    showTokenStr String
    str
      -- if token looks like a comment (starts with --), print it in quotes
      | String
    "--" String -> String -> Bool
    forall a. Eq a => [a] -> [a] -> Bool
    `isPrefixOf` String
    str = String -> String
    forall a. Show a => a -> String
    show String
    str
      -- also if token ends with a colon (e.g. executable name), print it in quotes
      | String
    ":" String -> String -> Bool
    forall a. Eq a => [a] -> [a] -> Bool
    `isSuffixOf` String
    str = String -> String
    forall a. Show a => a -> String
    show String
    str
      | Bool -> Bool
    not ((Char -> Bool) -> String -> Bool
    forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
    any Char -> Bool
    dodgy String
    str) Bool -> Bool -> Bool
    && Bool -> Bool
    not (String -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null String
    str) = String
    str
      | Bool
    otherwise = String -> String
    forall a. Show a => a -> String
    show String
    str
      where
        dodgy :: Char -> Bool
    dodgy Char
    c = Char -> Bool
    isSpace Char
    c Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    ','

    -- | Pretty-print free-format text, ensuring that it is vertically aligned,
    -- and with blank lines replaced by dots for correct re-parsing.
    showFreeText :: String -> PP.Doc
    showFreeText :: String -> Doc
    showFreeText String
    "" = Doc
    forall a. Monoid a => a
    mempty
    showFreeText String
    s = [Doc] -> Doc
    PP.vcat [String -> Doc
    PP.text (if String -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null String
    l then String
    "." else String
    l) | String
    l <- String -> [String]
    lines_ String
    s]

    -- | Pretty-print free-format text.
    -- Since @cabal-version: 3.0@ we don't replace blank lines with dots.
    --
    -- @since 3.0.0.0
    showFreeTextV3 :: String -> PP.Doc
    showFreeTextV3 :: String -> Doc
    showFreeTextV3 String
    "" = Doc
    forall a. Monoid a => a
    mempty
    showFreeTextV3 String
    s = [Doc] -> Doc
    PP.vcat [String -> Doc
    PP.text String
    l | String
    l <- String -> [String]
    lines_ String
    s]

    -- | 'lines_' breaks a string up into a list of strings at newline
    -- characters.  The resulting strings do not contain newlines.
    lines_ :: String -> [String]
    lines_ :: String -> [String]
    lines_ [] = [String
    ""]
    lines_ String
    s =
      let (String
    l, String
    s') = (Char -> Bool) -> String -> (String, String)
    forall a. (a -> Bool) -> [a] -> ([a], [a])
    break (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\n') String
    s
       in String
    l String -> [String] -> [String]
    forall a. a -> [a] -> [a]
    : case String
    s' of
            [] -> []
            (Char
    _ : String
    s'') -> String -> [String]
    lines_ String
    s''