    {-|

    The @codes@ command lists the codes seen in transactions, in the order parsed.

    -}

    {-# LANGUAGE MultiWayIf #-}
    {-# LANGUAGE NamedFieldPuns #-}
    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TemplateHaskell #-}

    module Hledger.Cli.Commands.Codes (
      codesmode
     ,codes
    ) where

    import qualified Data.Text as T
    import qualified Data.Text.IO as T

    import Hledger
    import Hledger.Cli.CliOptions

    -- | Command line options for this command.
    codesmode :: Mode RawOpts
    codesmode = CommandDoc
    -> [Flag RawOpts]
    -> [(CommandDoc, [Flag RawOpts])]
    -> [Flag RawOpts]
    -> ([Arg RawOpts], Maybe (Arg RawOpts))
    -> Mode RawOpts
    hledgerCommandMode
      $(embedFileRelative "Hledger/Cli/Commands/Codes.txt")
      []
      [(CommandDoc, [Flag RawOpts])
    generalflagsgroup1]
      [Flag RawOpts]
    hiddenflags
      ([], Arg RawOpts -> Maybe (Arg RawOpts)
    forall a. a -> Maybe a
    Just (Arg RawOpts -> Maybe (Arg RawOpts))
    -> Arg RawOpts -> Maybe (Arg RawOpts)
    forall a b. (a -> b) -> a -> b
    $ CommandDoc -> Arg RawOpts
    argsFlag CommandDoc
    "[QUERY]")

    -- | The codes command.
    codes :: CliOpts -> Journal -> IO ()
    codes :: CliOpts -> Journal -> IO ()
    codes CliOpts{reportspec_ :: CliOpts -> ReportSpec
    reportspec_=ReportSpec
    rspec} Journal
    j = do
      let ts :: EntriesReport
    ts = ReportSpec -> Journal -> EntriesReport
    entriesReport ReportSpec
    rspec Journal
    j
          codes' :: [Text]
    codes' = (if ReportOpts -> Bool
    empty_ (ReportSpec -> ReportOpts
    _rsReportOpts ReportSpec
    rspec) then [Text] -> [Text]
    forall a. a -> a
    id else (Text -> Bool) -> [Text] -> [Text]
    forall a. (a -> Bool) -> [a] -> [a]
    filter (Bool -> Bool
    not (Bool -> Bool) -> (Text -> Bool) -> Text -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Bool
    T.null)) ([Text] -> [Text]) -> [Text] -> [Text]
    forall a b. (a -> b) -> a -> b
    $
                  (Transaction -> Text) -> EntriesReport -> [Text]
    forall a b. (a -> b) -> [a] -> [b]
    map Transaction -> Text
    tcode EntriesReport
    ts
      (Text -> IO ()) -> [Text] -> IO ()
    forall (t :: * -> *) (m :: * -> *) a b.
    (Foldable t, Monad m) =>
    (a -> m b) -> t a -> m ()
    mapM_ Text -> IO ()
    T.putStrLn [Text]
    codes'