Change fromChunk signature for Windows

This is to avoid inadvertant errors e.g. in readRaw we were reading it
as a Word8 array on Windows even though we should be reading it as
Word16.

Author: harendra-kumar

core/src/Streamly/Internal/FileSystem/Path/Common.hs

@@ -1185,15 +1185,16 @@ isValidPath' os path =
         Just _ -> True
 
 {-# INLINE unsafeFromChunk #-}
-unsafeFromChunk :: Array Word8 -> Array a
-unsafeFromChunk = Array.unsafeCast
+unsafeFromChunk :: Array a -> Array a
+unsafeFromChunk = id
 
 {-# INLINE fromChunk #-}
 fromChunk :: forall m a. (MonadThrow m, Unbox a, Integral a) =>
-    OS -> Array Word8 -> m (Array a)
-fromChunk Posix arr =
+    OS -> Array a -> m (Array a)
+fromChunk os arr = validatePath os arr >> pure arr
+{-
     let arr1 = Array.unsafeCast arr :: Array a
-     in validatePath Posix arr1 >> pure arr1
+     in validatePath os arr1 >> pure arr1
 fromChunk Windows arr =
     case Array.cast arr of
         Nothing ->
@@ -1202,6 +1203,7 @@ fromChunk Windows arr =
                 $ "Encoded path length " ++ show (Array.byteLength arr)
                     ++ " is not a multiple of 16-bit."
         Just x -> validatePath Windows x >> pure x
+-}
 
 -- | Convert 'Path' to an array of bytes.
 {-# INLINE toChunk #-}

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

@@ -276,11 +276,15 @@ isValidPath a = Common.isValidPath Common.OS_NAME a
 -- been using it consistently in streamly. We use "bytes" for a stream of
 -- bytes.
 
--- | /Unsafe/: The user is responsible to make sure that the failure cases
--- mentioned in 'fromChunk' cannot occur.
+-- | /Unsafe/: The user is responsible to make sure that the path is valid as
+-- per 'isValidPath'.
 --
 {-# INLINE unsafeFromChunk #-}
+#ifndef IS_WINDOWS
 unsafeFromChunk :: IsPath OS_PATH a => Array Word8 -> a
+#else
+unsafeFromChunk :: IsPath OS_PATH a => Array Word16 -> a
+#endif
 unsafeFromChunk =
 #ifndef DEBUG
     unsafeFromPath . OS_PATH . Common.unsafeFromChunk
@@ -290,13 +294,14 @@ unsafeFromChunk =
 
 -- XXX mkPath?
 
--- | Convert a byte array into a Path:
---
--- * Throws 'InvalidPath' if 'isValidPath' fails on the path.
--- * On Windows, throws 'InvalidPath' if the array length is not aligned on two
--- byte boundary.
+-- | Convert a byte array into a Path.
+-- Throws 'InvalidPath' if 'isValidPath' fails on the path.
 --
+#ifndef IS_WINDOWS
 fromChunk :: (MonadThrow m, IsPath OS_PATH a) => Array Word8 -> m a
+#else
+fromChunk :: (MonadThrow m, IsPath OS_PATH a) => Array Word16 -> m a
+#endif
 fromChunk arr = Common.fromChunk Common.OS_NAME arr >>= fromPath . OS_PATH
 
 -- XXX Should be a Fold instead?
@@ -423,27 +428,18 @@ showRaw p =
             toPath p in show arr
 
 #ifndef IS_WINDOWS
--- | Read a raw array as a path type.
+-- | Parse a raw array of bytes as a path type.
 --
 -- >>> readRaw = fromJust . Path.fromChunk . read
 --
--- >>> arr <- Stream.fold Array.create $ Unicode.encodeUtf8 $ Stream.fromList "hello"
+-- >>> arr = rawFromString "hello"
 -- >>> Path.showRaw $ (Path.readRaw $ show arr :: Path.PosixPath)
 -- "fromList [104,101,108,108,111]"
 --
 -- See also: 'showRaw'.
-#else
--- | Read a raw array as a path type.
---
--- >> readRaw = fromJust . Path.fromChunk . read
---
--- >> arr <- Stream.fold Array.create $ Unicode.encodeUtf16LE $ Stream.fromList "hello"
--- >> Path.showRaw $ (Path.readRaw $ show arr :: Path.WindowsPath)
---
--- See also: 'showRaw'.
-#endif
 readRaw :: IsPath OS_PATH a => [Char] -> a
 readRaw = fromJust . fromChunk . read
+#endif
 
 -- We cannot show decoded path in the Show instance as it may not always
 -- succeed and it depends on the encoding which we may not even know. The

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

@@ -5,19 +5,21 @@
 >>> :m
 >>> :set -XQuasiQuotes
 >>> import Data.Maybe (fromJust)
+>>> import Data.Word (Word16)
 >>> import qualified Streamly.Data.Stream as Stream
 
 For APIs that have not been released yet.
 
 >>> import Streamly.Internal.FileSystem.WindowsPath (WindowsPath, path)
+>>> import Streamly.Internal.Data.Array (Array)
 >>> import qualified Streamly.Internal.Data.Array as Array
 >>> import qualified Streamly.Internal.FileSystem.WindowsPath as Path
 >>> import qualified Streamly.Internal.Unicode.Stream as Unicode
 
 >>> import Data.Either (Either, isLeft)
 >>> import Control.Exception (SomeException, evaluate, try)
 
->>> rawFromString = Array.fromPureStream . Unicode.encodeUtf8' . Stream.fromList
+>>> rawFromString = Array.fromPureStream . Unicode.encodeUtf16le' . Stream.fromList
 >>> pack = fromJust . Path.fromString
 >>> fails action = (try (evaluate action) :: IO (Either SomeException String)) >>= return . isLeft
 -}
@@ -34,7 +36,6 @@ For APIs that have not been released yet.
 -- | Check if the filepath is valid i.e. does the operating system or the file
 -- system allow such a path in listing or creating files?
 --
--- >>> rawFromString = Array.fromPureStream . Unicode.encodeUtf16le' . Stream.fromList
 -- >>> isValid = Path.isValidPath . rawFromString
 --
 -- >>> isValid ""
@@ -158,6 +159,18 @@ validatePath' a = Common.validatePath' Common.Windows a
 isValidPath' :: Array Word16 -> Bool
 isValidPath' a = Common.isValidPath' Common.Windows a
 
+-- | Read a raw array of Word16 as a path type.
+--
+-- >>> readRaw = fromJust . Path.fromChunk . read
+--
+-- >>> arr :: Array Word16 = rawFromString "hello"
+-- >>> Path.showRaw $ (Path.readRaw $ show arr :: Path.WindowsPath)
+-- "fromList [104,101,108,108,111]"
+--
+-- See also: 'showRaw'.
+readRaw :: IsPath OS_PATH a => [Char] -> a
+readRaw = fromJust . fromChunk . read
+
 -- | A path that is attached to a root. "C:\\" is considered an absolute root
 -- and "." as a dynamic root. ".." is not considered a root, "..\/x" or "x\/y"
 -- are not rooted paths.