module Data.NestedText.Util where

import qualified Control.Monad.Trans.Free as F
import Data.Functor (($>))
import qualified Data.Set as S
import qualified Data.Text as T
import Lens.Micro.Platform
import qualified Pipes as P
import qualified Pipes.Prelude as P
import qualified Pipes.Text as PT
import System.IO (Newline(..), nativeNewline)

specialCharsList :: S.Set Char
specialCharsList :: Set Char
specialCharsList = [Char] -> Set Char
forall a. Eq a => [a] -> Set a
S.fromAscList [Char]
",[]{}"
specialCharsDict :: S.Set Char
specialCharsDict :: Set Char
specialCharsDict = [Char] -> Set Char
forall a. Eq a => [a] -> Set a
S.fromAscList [Char]
",:[]{}"

isTabOrSpace :: Char -> Bool
isTabOrSpace :: Char -> Bool
isTabOrSpace Char
c = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
' ' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\t'

osNewline :: T.Text
osNewline :: Text
osNewline = case Newline
nativeNewline of
  Newline
LF -> [Char] -> Text
T.pack [Char]
"\n"
  Newline
CRLF -> [Char] -> Text
T.pack [Char]
"\r\n"

splitLines :: Monad m => P.Producer T.Text m r -> F.FreeT (P.Producer T.Text m) m r
splitLines :: forall (m :: * -> *) r.
Monad m =>
Producer Text m r -> FreeT (Producer Text m) m r
splitLines Producer Text m r
p0 = m (FreeF (Producer Text m) r (FreeT (Producer Text m) m r))
-> FreeT (Producer Text m) m r
forall (f :: * -> *) (m :: * -> *) a.
m (FreeF f a (FreeT f m a)) -> FreeT f m a
F.FreeT (m (FreeF (Producer Text m) r (FreeT (Producer Text m) m r))
 -> FreeT (Producer Text m) m r)
-> m (FreeF (Producer Text m) r (FreeT (Producer Text m) m r))
-> FreeT (Producer Text m) m r
forall a b. (a -> b) -> a -> b
$ Producer Text m r
-> m (FreeF (Producer Text m) r (FreeT (Producer Text m) m r))
forall {m :: * -> *} {r}.
Monad m =>
Producer Text m r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
go1 Producer Text m r
p0
 where
  go0 :: a -> m (FreeF (Proxy x' x () Text m) a (FreeT f m a))
go0 a
r = FreeF (Proxy x' x () Text m) a (FreeT f m a)
-> m (FreeF (Proxy x' x () Text m) a (FreeT f m a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FreeF (Proxy x' x () Text m) a (FreeT f m a)
 -> m (FreeF (Proxy x' x () Text m) a (FreeT f m a)))
-> FreeF (Proxy x' x () Text m) a (FreeT f m a)
-> m (FreeF (Proxy x' x () Text m) a (FreeT f m a))
forall a b. (a -> b) -> a -> b
$ Proxy x' x () Text m (FreeT f m a)
-> FreeF (Proxy x' x () Text m) a (FreeT f m a)
forall (f :: * -> *) a b. f b -> FreeF f a b
F.Free (Proxy x' x () Text m (FreeT f m a)
 -> FreeF (Proxy x' x () Text m) a (FreeT f m a))
-> Proxy x' x () Text m (FreeT f m a)
-> FreeF (Proxy x' x () Text m) a (FreeT f m a)
forall a b. (a -> b) -> a -> b
$ Text -> Proxy x' x () Text m ()
forall (m :: * -> *) a x' x. Functor m => a -> Proxy x' x () a m ()
P.yield Text
T.empty Proxy x' x () Text m ()
-> FreeT f m a -> Proxy x' x () Text m (FreeT f m a)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> m (FreeF f a (FreeT f m a)) -> FreeT f m a
forall (f :: * -> *) (m :: * -> *) a.
m (FreeF f a (FreeT f m a)) -> FreeT f m a
F.FreeT (FreeF f a (FreeT f m a) -> m (FreeF f a (FreeT f m a))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FreeF f a (FreeT f m a) -> m (FreeF f a (FreeT f m a)))
-> FreeF f a (FreeT f m a) -> m (FreeF f a (FreeT f m a))
forall a b. (a -> b) -> a -> b
$ a -> FreeF f a (FreeT f m a)
forall (f :: * -> *) a b. a -> FreeF f a b
F.Pure a
r)
  go1 :: Producer Text m r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
go1 Producer Text m r
p1 = do
    Either r (Text, Producer Text m r)
ec <- Producer Text m r -> m (Either r (Text, Producer Text m r))
forall (m :: * -> *) a r.
Monad m =>
Producer a m r -> m (Either r (a, Producer a m r))
P.next Producer Text m r
p1
    case Either r (Text, Producer Text m r)
ec of
      Left r
r -> r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall {m :: * -> *} {m :: * -> *} {m :: * -> *} {a} {x'} {x} {a}
       {f :: * -> *}.
(Monad m, Monad m, Functor m) =>
a -> m (FreeF (Proxy x' x () Text m) a (FreeT f m a))
go0 r
r
      Right (Text
txt, Producer Text m r
p2) -> if Text -> Bool
T.null Text
txt
        then Producer Text m r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
go1 Producer Text m r
p2
        else FreeF (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FreeF (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
 -> m (FreeF
         (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)))
-> FreeF
     (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall a b. (a -> b) -> a -> b
$ Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
-> FreeF
     (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
forall (f :: * -> *) a b. f b -> FreeF f a b
F.Free (Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
 -> FreeF
      (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
-> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
-> FreeF
     (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
forall a b. (a -> b) -> a -> b
$ Producer Text m r
-> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
go2 (Producer Text m r
 -> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r))
-> Producer Text m r
-> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
forall a b. (a -> b) -> a -> b
$ Text -> Proxy X () () Text m ()
forall (m :: * -> *) a x' x. Functor m => a -> Proxy x' x () a m ()
P.yield Text
txt Proxy X () () Text m () -> Producer Text m r -> Producer Text m r
forall a b.
Proxy X () () Text m a
-> Proxy X () () Text m b -> Proxy X () () Text m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Producer Text m r
p2
  go2 :: Producer Text m r
-> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
go2 Producer Text m r
p1 = do
    Producer Text m r
p2 <- Producer Text m r
p1 Producer Text m r
-> Getting
     (Proxy X () () Text m (Producer Text m r))
     (Producer Text m r)
     (Proxy X () () Text m (Producer Text m r))
-> Proxy X () () Text m (Producer Text m r)
forall s a. s -> Getting a s a -> a
^. (Char -> Bool)
-> Lens'
     (Producer Text m r) (Proxy X () () Text m (Producer Text m r))
forall (m :: * -> *) r.
Monad m =>
(Char -> Bool)
-> Lens' (Producer Text m r) (Producer Text m (Producer Text m r))
PT.break (\Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\n' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\r')
    FreeT (Proxy X () () Text m) m r
-> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
forall a. a -> Proxy X () () Text m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FreeT (Proxy X () () Text m) m r
 -> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r))
-> FreeT (Proxy X () () Text m) m r
-> Proxy X () () Text m (FreeT (Proxy X () () Text m) m r)
forall a b. (a -> b) -> a -> b
$ m (FreeF
     (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
-> FreeT (Proxy X () () Text m) m r
forall (f :: * -> *) (m :: * -> *) a.
m (FreeF f a (FreeT f m a)) -> FreeT f m a
F.FreeT (m (FreeF
      (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
 -> FreeT (Proxy X () () Text m) m r)
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
-> FreeT (Proxy X () () Text m) m r
forall a b. (a -> b) -> a -> b
$ do
      Either r (Char, Producer Text m r)
ec1 <- Producer Text m r -> m (Either r (Char, Producer Text m r))
forall (m :: * -> *) r.
Monad m =>
Producer Text m r -> m (Either r (Char, Producer Text m r))
PT.nextChar Producer Text m r
p2
      case Either r (Char, Producer Text m r)
ec1 of
        Left r
r -> FreeF (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FreeF (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
 -> m (FreeF
         (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)))
-> FreeF
     (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall a b. (a -> b) -> a -> b
$ r
-> FreeF
     (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)
forall (f :: * -> *) a b. a -> FreeF f a b
F.Pure r
r
        Right (Char
'\n', Producer Text m r
p3) -> Producer Text m r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
go1 Producer Text m r
p3
        Right (Char
'\r', Producer Text m r
p3) -> do
          Either r (Char, Producer Text m r)
ec2 <- Producer Text m r -> m (Either r (Char, Producer Text m r))
forall (m :: * -> *) r.
Monad m =>
Producer Text m r -> m (Either r (Char, Producer Text m r))
PT.nextChar Producer Text m r
p3
          case Either r (Char, Producer Text m r)
ec2 of
            Left r
r -> r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall {m :: * -> *} {m :: * -> *} {m :: * -> *} {a} {x'} {x} {a}
       {f :: * -> *}.
(Monad m, Monad m, Functor m) =>
a -> m (FreeF (Proxy x' x () Text m) a (FreeT f m a))
go0 r
r
            Right (Char
'\n', Producer Text m r
p4) -> Producer Text m r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
go1 Producer Text m r
p4
            Right (Char
c, Producer Text m r
p4) -> Producer Text m r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
go1 (Producer Text m r
 -> m (FreeF
         (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r)))
-> Producer Text m r
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall a b. (a -> b) -> a -> b
$ Text -> Proxy X () () Text m ()
forall (m :: * -> *) a x' x. Functor m => a -> Proxy x' x () a m ()
P.yield (Char -> Text
T.singleton Char
c) Proxy X () () Text m () -> Producer Text m r -> Producer Text m r
forall a b.
Proxy X () () Text m a
-> Proxy X () () Text m b -> Proxy X () () Text m b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Producer Text m r
p4
        Right (Char, Producer Text m r)
_ -> [Char]
-> m (FreeF
        (Proxy X () () Text m) r (FreeT (Proxy X () () Text m) m r))
forall a. HasCallStack => [Char] -> a
error [Char]
"splitLines: unreachable"

freeTToLines :: Monad m => F.FreeT (P.Producer T.Text m) m r -> m [T.Text]
freeTToLines :: forall (m :: * -> *) r.
Monad m =>
FreeT (Producer Text m) m r -> m [Text]
freeTToLines FreeT (Producer Text m) m r
free = FreeT (Producer Text m) m r -> m [Text]
forall (m :: * -> *) r.
Monad m =>
FreeT (Producer Text m) m r -> m [Text]
go FreeT (Producer Text m) m r
free
  where
    go :: FreeT (Proxy X () () Text m) m a -> m [Text]
go FreeT (Proxy X () () Text m) m a
ft = do
      FreeF (Proxy X () () Text m) a (FreeT (Proxy X () () Text m) m a)
step <- FreeT (Proxy X () () Text m) m a
-> m (FreeF
        (Proxy X () () Text m) a (FreeT (Proxy X () () Text m) m a))
forall (f :: * -> *) (m :: * -> *) a.
FreeT f m a -> m (FreeF f a (FreeT f m a))
F.runFreeT FreeT (Proxy X () () Text m) m a
ft
      case FreeF (Proxy X () () Text m) a (FreeT (Proxy X () () Text m) m a)
step of
        F.Pure a
_ -> [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return []
        F.Free Proxy X () () Text m (FreeT (Proxy X () () Text m) m a)
p0 -> do
          (Text
line, FreeT (Proxy X () () Text m) m a
p1) <- (Text -> Text -> Text)
-> Text
-> (Text -> Text)
-> Proxy X () () Text m (FreeT (Proxy X () () Text m) m a)
-> m (Text, FreeT (Proxy X () () Text m) m a)
forall (m :: * -> *) x a b r.
Monad m =>
(x -> a -> x) -> x -> (x -> b) -> Producer a m r -> m (b, r)
P.fold' Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
(<>) Text
T.empty Text -> Text
forall a. a -> a
id Proxy X () () Text m (FreeT (Proxy X () () Text m) m a)
p0
          [Text]
rest <- FreeT (Proxy X () () Text m) m a -> m [Text]
go FreeT (Proxy X () () Text m) m a
p1
          [Text] -> m [Text]
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text] -> m [Text]) -> [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ Text
line Text -> [Text] -> [Text]
forall a. a -> [a] -> [a]
: [Text]
rest