{-# LANGUAGE GeneralisedNewtypeDeriving #-}

-- | This module provides functionality for helping writing data values as CSV entries.
--
-- A couple of 'db-analyzer` analysis produce CSV files, which contain
-- the analysis' results. A way to populate these files is to write
-- the headers first, and then, line by line, write the rows that
-- contain the data. Each column in a row containing data must
-- correspond to a given header. To make it easier to maintain this
-- correspondence between headers and data, we usually specify a CSV
-- builder as:
--
-- > [(TextBuilder, a -> IO TextBuilder)]
--
-- where each first component of each tuple in the list represents a
-- header, and each second component determines how the value that
-- corresponds to that header is computed, given a certain value that
-- is needed to compute a row in the resulting CSV.
--
-- We use 'TextBuilder' to efficiently intercalate values with the CSV 'Separator'.
--
module Cardano.Tools.DBAnalyser.CSV (
    Separator (Separator, unSeparator)
  , computeAndWriteLine
  , computeAndWriteLinePure
  , computeColumns
  , computeColumnsPure
  , writeHeaderLine
  , writeLine
  ) where

import           Data.String (IsString)
import qualified Data.Text.IO as Text.IO
import qualified System.IO as IO
import qualified TextBuilder as TextBuilder
import           TextBuilder (TextBuilder)

newtype Separator = Separator { Separator -> TextBuilder
unSeparator :: TextBuilder }
  deriving (Int -> Separator -> ShowS
[Separator] -> ShowS
Separator -> String
(Int -> Separator -> ShowS)
-> (Separator -> String)
-> ([Separator] -> ShowS)
-> Show Separator
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Separator -> ShowS
showsPrec :: Int -> Separator -> ShowS
$cshow :: Separator -> String
show :: Separator -> String
$cshowList :: [Separator] -> ShowS
showList :: [Separator] -> ShowS
Show, String -> Separator
(String -> Separator) -> IsString Separator
forall a. (String -> a) -> IsString a
$cfromString :: String -> Separator
fromString :: String -> Separator
IsString, Semigroup Separator
Separator
Semigroup Separator =>
Separator
-> (Separator -> Separator -> Separator)
-> ([Separator] -> Separator)
-> Monoid Separator
[Separator] -> Separator
Separator -> Separator -> Separator
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: Separator
mempty :: Separator
$cmappend :: Separator -> Separator -> Separator
mappend :: Separator -> Separator -> Separator
$cmconcat :: [Separator] -> Separator
mconcat :: [Separator] -> Separator
Monoid, NonEmpty Separator -> Separator
Separator -> Separator -> Separator
(Separator -> Separator -> Separator)
-> (NonEmpty Separator -> Separator)
-> (forall b. Integral b => b -> Separator -> Separator)
-> Semigroup Separator
forall b. Integral b => b -> Separator -> Separator
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: Separator -> Separator -> Separator
<> :: Separator -> Separator -> Separator
$csconcat :: NonEmpty Separator -> Separator
sconcat :: NonEmpty Separator -> Separator
$cstimes :: forall b. Integral b => b -> Separator -> Separator
stimes :: forall b. Integral b => b -> Separator -> Separator
Semigroup)

writeHeaderLine :: IO.Handle -> Separator -> [(TextBuilder, a)] -> IO ()
writeHeaderLine :: forall a. Handle -> Separator -> [(TextBuilder, a)] -> IO ()
writeHeaderLine Handle
handle (Separator TextBuilder
separator) =
      Handle -> Text -> IO ()
Text.IO.hPutStrLn Handle
handle
    (Text -> IO ())
-> ([(TextBuilder, a)] -> Text) -> [(TextBuilder, a)] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBuilder -> Text
TextBuilder.toText
    (TextBuilder -> Text)
-> ([(TextBuilder, a)] -> TextBuilder)
-> [(TextBuilder, a)]
-> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBuilder -> [TextBuilder] -> TextBuilder
forall (f :: * -> *).
Foldable f =>
TextBuilder -> f TextBuilder -> TextBuilder
TextBuilder.intercalate TextBuilder
separator
    ([TextBuilder] -> TextBuilder)
-> ([(TextBuilder, a)] -> [TextBuilder])
-> [(TextBuilder, a)]
-> TextBuilder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((TextBuilder, a) -> TextBuilder)
-> [(TextBuilder, a)] -> [TextBuilder]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (TextBuilder, a) -> TextBuilder
forall a b. (a, b) -> a
fst

writeLine :: IO.Handle -> Separator -> [TextBuilder] -> IO ()
writeLine :: Handle -> Separator -> [TextBuilder] -> IO ()
writeLine Handle
handle (Separator TextBuilder
separator) =
      Handle -> Text -> IO ()
Text.IO.hPutStrLn Handle
handle
    (Text -> IO ())
-> ([TextBuilder] -> Text) -> [TextBuilder] -> IO ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBuilder -> Text
TextBuilder.toText
    (TextBuilder -> Text)
-> ([TextBuilder] -> TextBuilder) -> [TextBuilder] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextBuilder -> [TextBuilder] -> TextBuilder
forall (f :: * -> *).
Foldable f =>
TextBuilder -> f TextBuilder -> TextBuilder
TextBuilder.intercalate TextBuilder
separator

computeAndWriteLine :: IO.Handle -> Separator -> [(a, b -> IO TextBuilder)] -> b -> IO ()
computeAndWriteLine :: forall a b.
Handle -> Separator -> [(a, b -> IO TextBuilder)] -> b -> IO ()
computeAndWriteLine Handle
handle Separator
separator [(a, b -> IO TextBuilder)]
csvTextBuilder b
b = do
  [b -> IO TextBuilder] -> b -> IO [TextBuilder]
forall a. [a -> IO TextBuilder] -> a -> IO [TextBuilder]
computeColumns (((a, b -> IO TextBuilder) -> b -> IO TextBuilder)
-> [(a, b -> IO TextBuilder)] -> [b -> IO TextBuilder]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a, b -> IO TextBuilder) -> b -> IO TextBuilder
forall a b. (a, b) -> b
snd [(a, b -> IO TextBuilder)]
csvTextBuilder) b
b IO [TextBuilder] -> ([TextBuilder] -> IO ()) -> IO ()
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Handle -> Separator -> [TextBuilder] -> IO ()
writeLine Handle
handle Separator
separator

computeAndWriteLinePure :: IO.Handle -> Separator -> [(a, b -> TextBuilder)] -> b -> IO ()
computeAndWriteLinePure :: forall a b.
Handle -> Separator -> [(a, b -> TextBuilder)] -> b -> IO ()
computeAndWriteLinePure Handle
handle Separator
separator [(a, b -> TextBuilder)]
csvTextBuilder b
b =
    Handle -> Separator -> [TextBuilder] -> IO ()
writeLine Handle
handle Separator
separator ([TextBuilder] -> IO ()) -> [TextBuilder] -> IO ()
forall a b. (a -> b) -> a -> b
$ [b -> TextBuilder] -> b -> [TextBuilder]
forall a. [a -> TextBuilder] -> a -> [TextBuilder]
computeColumnsPure (((a, b -> TextBuilder) -> b -> TextBuilder)
-> [(a, b -> TextBuilder)] -> [b -> TextBuilder]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a, b -> TextBuilder) -> b -> TextBuilder
forall a b. (a, b) -> b
snd [(a, b -> TextBuilder)]
csvTextBuilder) b
b

computeColumns :: [a -> IO TextBuilder] -> a -> IO [TextBuilder]
computeColumns :: forall a. [a -> IO TextBuilder] -> a -> IO [TextBuilder]
computeColumns [a -> IO TextBuilder]
fTextBuilders a
a =
  [IO TextBuilder] -> IO [TextBuilder]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ([IO TextBuilder] -> IO [TextBuilder])
-> [IO TextBuilder] -> IO [TextBuilder]
forall a b. (a -> b) -> a -> b
$ ((a -> IO TextBuilder) -> IO TextBuilder)
-> [a -> IO TextBuilder] -> [IO TextBuilder]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> IO TextBuilder) -> a -> IO TextBuilder
forall a b. (a -> b) -> a -> b
$ a
a) [a -> IO TextBuilder]
fTextBuilders

computeColumnsPure :: [a -> TextBuilder] -> a -> [TextBuilder]
computeColumnsPure :: forall a. [a -> TextBuilder] -> a -> [TextBuilder]
computeColumnsPure [a -> TextBuilder]
fTextBuilders a
a =
  ((a -> TextBuilder) -> TextBuilder)
-> [a -> TextBuilder] -> [TextBuilder]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> TextBuilder) -> a -> TextBuilder
forall a b. (a -> b) -> a -> b
$ a
a) [a -> TextBuilder]
fTextBuilders