Use ReadOptions and options config in all the Posix APIs

Author: adithyaov

core/src/Streamly/Internal/FileSystem/Dir.hs

@@ -123,14 +123,20 @@ pMapUnfoldE = fmap ePathMap . Unfold.lmapM Path.fromString
 -- Functions
 --------------------------------------------------------------------------------
 
+#if defined(mingw32_HOST_OS) || defined(__MINGW32__)
+#define CONF_AP(x) x
+#else
+#define CONF_AP(x) (x (DirIO.followSymlinks True))
+#endif
+
 --  | Read a directory emitting a stream with names of the children. Filter out
 --  "." and ".." entries.
 --
 --  /Internal/
 --
 {-# INLINE reader #-}
 reader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
-reader = fmap Path.toString $ Unfold.lmapM Path.fromString DirIO.reader
+reader = fmap Path.toString $ Unfold.lmapM Path.fromString CONF_AP(DirIO.reader)
 
 -- | Read directories as Left and files as Right. Filter out "." and ".."
 -- entries.
@@ -139,12 +145,12 @@ reader = fmap Path.toString $ Unfold.lmapM Path.fromString DirIO.reader
 --
 {-# INLINE eitherReader #-}
 eitherReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath)
-eitherReader = pMapUnfoldE DirIO.eitherReader
+eitherReader = pMapUnfoldE CONF_AP(DirIO.eitherReader)
 
 
 {-# INLINE eitherReaderPaths #-}
 eitherReaderPaths ::(MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath)
-eitherReaderPaths = pMapUnfoldE DirIO.eitherReaderPaths
+eitherReaderPaths = pMapUnfoldE CONF_AP(DirIO.eitherReaderPaths)
 
 --
 -- | Read files only.
@@ -153,15 +159,15 @@ eitherReaderPaths = pMapUnfoldE DirIO.eitherReaderPaths
 --
 {-# INLINE fileReader #-}
 fileReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
-fileReader = pMapUnfold DirIO.fileReader
+fileReader = pMapUnfold CONF_AP(DirIO.fileReader)
 
 -- | Read directories only. Filter out "." and ".." entries.
 --
 --  /Internal/
 --
 {-# INLINE dirReader #-}
 dirReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath
-dirReader = pMapUnfold DirIO.dirReader
+dirReader = pMapUnfold CONF_AP(DirIO.dirReader)
 
 -- | Raw read of a directory.
 --

core/src/Streamly/Internal/FileSystem/DirIO.hs

@@ -80,8 +80,14 @@ module Streamly.Internal.FileSystem.DirIO
     -- * Metadata
     -- getMetadata GetMetadata (followSymlinks, noAutoMount - see fstatat)
 
+    -- * Configuration
+      ReadOptions
+    , followSymlinks
+    , ignoreNonExisting
+    , defaultReadOptions
+
     -- * Streams
-      read
+    , read
 
     -- Is there a benefit in providing a low level recursive read or
     -- concatIterate is good enough? Could be more efficient for non-concurrent
@@ -149,7 +155,9 @@ import qualified Streamly.Internal.Data.Fold as Fold
 import Streamly.Internal.FileSystem.Windows.ReadDir (eitherReader, reader)
 #else
 import Streamly.Internal.FileSystem.Posix.ReadDir
-    (readEitherChunks, eitherReader, reader)
+    ( readEitherChunks, eitherReader, reader, ReadOptions, defaultReadOptions
+    ,  ignoreNonExisting, followSymlinks
+    )
 #endif
 import qualified Streamly.Internal.Data.Stream as S
 import qualified Streamly.Data.Unfold as UF
@@ -252,6 +260,20 @@ toChunks = toChunksWithBufferOf defaultChunkSize
 readChunks :: MonadIO m => Unfold m Handle (Array Word8)
 readChunks = UF.first readChunksWithBufferOf defaultChunkSize
 
+-------------------------------------------------------------------------------
+-- Macros for Windows and Posix
+-------------------------------------------------------------------------------
+
+#if defined(mingw32_HOST_OS) || defined(__MINGW32__)
+#define CONF_TYP
+#define CONF_ARG
+#define CONF_AP(x) x
+#else
+#define CONF_TYP (ReadOptions -> ReadOptions) ->
+#define CONF_ARG confMod
+#define CONF_AP(x) (x CONF_ARG)
+#endif
+
 -------------------------------------------------------------------------------
 -- Read a Directory to Stream
 -------------------------------------------------------------------------------
@@ -298,52 +320,56 @@ toStreamWithBufferOf chunkSize h = AS.concat $ toChunksWithBufferOf chunkSize h
 -- created.
 
 {-# INLINE eitherReaderPaths #-}
-eitherReaderPaths ::(MonadIO m, MonadCatch m) =>
+eitherReaderPaths ::(MonadIO m, MonadCatch m) => CONF_TYP
     Unfold m Path (Either Path Path)
-eitherReaderPaths =
+eitherReaderPaths CONF_ARG =
     let (</>) = Path.append
-     in UF.mapM2 (\dir -> return . bimap (dir </>) (dir </>)) eitherReader
+     in UF.mapM2 (\dir -> return . bimap (dir </>) (dir </>)) CONF_AP(eitherReader)
 
 --
 -- | Read files only.
 --
 --  /Internal/
 --
 {-# INLINE fileReader #-}
-fileReader :: (MonadIO m, MonadCatch m) => Unfold m Path Path
-fileReader = fmap (fromRight undefined) $ UF.filter isRight eitherReader
+fileReader :: (MonadIO m, MonadCatch m) => CONF_TYP
+    Unfold m Path Path
+fileReader CONF_ARG = fmap (fromRight undefined) $ UF.filter isRight CONF_AP(eitherReader)
 
 -- | Read directories only. Filter out "." and ".." entries.
 --
 --  /Internal/
 --
 {-# INLINE dirReader #-}
-dirReader :: (MonadIO m, MonadCatch m) => Unfold m Path Path
-dirReader = fmap (fromLeft undefined) $ UF.filter isLeft eitherReader
+dirReader :: (MonadIO m, MonadCatch m) => CONF_TYP
+    Unfold m Path Path
+dirReader CONF_ARG = fmap (fromLeft undefined) $ UF.filter isLeft CONF_AP(eitherReader)
 
 -- | Raw read of a directory.
 --
 -- /Pre-release/
 {-# INLINE read #-}
-read :: (MonadIO m, MonadCatch m) => Path -> Stream m Path
-read = S.unfold reader
+read :: (MonadIO m, MonadCatch m) => CONF_TYP
+    Path -> Stream m Path
+read CONF_ARG = S.unfold CONF_AP(reader)
 
 -- | Read directories as Left and files as Right. Filter out "." and ".."
 -- entries. The output contains the names of the directories and files.
 --
 -- /Pre-release/
 {-# INLINE readEither #-}
-readEither :: (MonadIO m, MonadCatch m) => Path -> Stream m (Either Path Path)
-readEither = S.unfold eitherReader
+readEither :: (MonadIO m, MonadCatch m) => CONF_TYP
+    Path -> Stream m (Either Path Path)
+readEither CONF_ARG = S.unfold CONF_AP(eitherReader)
 
 -- | Like 'readEither' but prefix the names of the files and directories with
 -- the supplied directory path.
 {-# INLINE readEitherPaths #-}
-readEitherPaths :: (MonadIO m, MonadCatch m) =>
+readEitherPaths :: (MonadIO m, MonadCatch m) => CONF_TYP
     Path -> Stream m (Either Path Path)
-readEitherPaths dir =
+readEitherPaths f dir =
     let (</>) = Path.append
-     in fmap (bimap (dir </>) (dir </>)) $ readEither dir
+     in fmap (bimap (dir </>) (dir </>)) $ readEither f dir
 
 #if defined(mingw32_HOST_OS) || defined(__MINGW32__)
 -- XXX Implement a custom version of readEitherChunks (like for Posix) for
@@ -356,13 +382,13 @@ readEitherPaths dir =
 -- This is a generic (but slower?) version of readEitherChunks using
 -- eitherReaderPaths.
 {-# INLINE readEitherChunks #-}
-readEitherChunks :: (MonadIO m, MonadCatch m) =>
+readEitherChunks :: (MonadIO m, MonadCatch m) => CONF_TYP
     [Path] -> Stream m (Either [Path] [Path])
-readEitherChunks dirs =
+readEitherChunks f dirs =
     -- XXX Need to use a take to limit the group size. There will be separate
     -- limits for dir and files groups.
      S.groupsWhile grouper collector
-        $ S.unfoldEach eitherReaderPaths
+        $ S.unfoldEach (eitherReaderPaths f)
         $ S.fromList dirs
 
     where
@@ -390,16 +416,18 @@ readEitherChunks dirs =
 --  /Internal/
 --
 {-# INLINE readFiles #-}
-readFiles :: (MonadIO m, MonadCatch m) => Path -> Stream m Path
-readFiles = S.unfold fileReader
+readFiles :: (MonadIO m, MonadCatch m) => CONF_TYP
+    Path -> Stream m Path
+readFiles CONF_ARG = S.unfold CONF_AP(fileReader)
 
 -- | Read directories only.
 --
 --  /Internal/
 --
 {-# INLINE readDirs #-}
-readDirs :: (MonadIO m, MonadCatch m) => Path -> Stream m Path
-readDirs = S.unfold dirReader
+readDirs :: (MonadIO m, MonadCatch m) => CONF_TYP
+    Path -> Stream m Path
+readDirs CONF_ARG = S.unfold CONF_AP(dirReader)
 
 {-
 -------------------------------------------------------------------------------