More renaming

Author: hasufell

Generate.hs

@@ -48,12 +48,12 @@ main = do
         ,"import qualified System.OsPath.Windows as AFP_W"
         ,"import qualified System.OsPath.Posix as AFP_P"
 #endif
-        ,"instance IsString WindowsString where fromString = WS . either (error . show) id . encodeWith (mkUTF16le TransliterateCodingFailure)"
-        ,"instance IsString PosixString where fromString = PS . either (error . show) id . encodeWith (mkUTF8 TransliterateCodingFailure)"
+        ,"instance IsString WindowsString where fromString = WS . either (error . show) id . encodeWithTE (mkUTF16le TransliterateCodingFailure)"
+        ,"instance IsString PosixString where fromString = PS . either (error . show) id . encodeWithTE (mkUTF8 TransliterateCodingFailure)"
         ,"#if defined(mingw32_HOST_OS) || defined(__MINGW32__)"
-        ,"instance IsString OsString where fromString = OsString . WS . either (error . show) id . encodeWith (mkUTF16le TransliterateCodingFailure)"
+        ,"instance IsString OsString where fromString = OsString . WS . either (error . show) id . encodeWithTE (mkUTF16le TransliterateCodingFailure)"
         ,"#else"
-        ,"instance IsString OsString where fromString = OsString . PS . either (error . show) id . encodeWith (mkUTF8 TransliterateCodingFailure)"
+        ,"instance IsString OsString where fromString = OsString . PS . either (error . show) id . encodeWithTE (mkUTF8 TransliterateCodingFailure)"
         ,"#endif"
         ,"tests :: [(String, Property)]"
         ,"tests ="] ++

System/FilePath/Internal.hs

@@ -127,7 +127,7 @@ import Data.List(stripPrefix, isSuffixOf, uncons)
 #define FILEPATH FilePath
 #else
 import Prelude (fromIntegral)
-import System.OsPath.Encoding ( encodeWith )
+import System.OsPath.Encoding ( encodeWithTE )
 import GHC.IO.Encoding.Failure ( CodingFailureMode(..) )
 import qualified Data.Char as C
 #ifdef WINDOWS
@@ -1180,10 +1180,10 @@ snoc str = \c -> str <> [c]
 #else
 #ifdef WINDOWS
 fromString :: P.String -> STRING
-fromString = P.either (P.error . P.show) P.id . encodeWith (mkUTF16le ErrorOnCodingFailure)
+fromString = P.either (P.error . P.show) P.id . encodeWithTE (mkUTF16le ErrorOnCodingFailure)
 #else
 fromString :: P.String -> STRING
-fromString = P.either (P.error . P.show) P.id . encodeWith (mkUTF8 ErrorOnCodingFailure)
+fromString = P.either (P.error . P.show) P.id . encodeWithTE (mkUTF8 ErrorOnCodingFailure)
 #endif
 
 _a, _z, _A, _Z, _period, _quotedbl, _backslash, _slash, _question, _U, _N, _C, _colon, _semicolon, _US, _less, _greater, _bar, _asterisk, _nul, _space, _underscore :: CHAR

System/OsPath/Common.hs

@@ -40,32 +40,21 @@ module System.OsPath
   , OsChar
 #endif
   -- * Filepath construction
+  , PS.encodeUtf
+  , PS.encodeWith
+  , PS.encodeFS
 #if defined(WINDOWS) || defined(POSIX)
-  , toPlatformStringUtf
-  , toPlatformStringEnc
-  , toPlatformStringFS
   , pstr
-  , packPlatformString
 #else
-  , toOsPathUtf
-  , toOsPathEnc
-  , toOsPathFS
   , osp
-  , packOsPath
 #endif
+  , PS.pack
 
   -- * Filepath deconstruction
-#if defined(WINDOWS) || defined(POSIX)
-  , fromPlatformStringUtf
-  , fromPlatformStringEnc
-  , fromPlatformStringFS
-  , unpackPlatformString
-#else
-  , fromOsPathUtf
-  , fromOsPathEnc
-  , fromOsPathFS
-  , unpackOsPath
-#endif
+  , PS.decodeUtf
+  , PS.decodeWith
+  , PS.decodeFS
+  , PS.unpack
 
   -- * Word construction
   , unsafeFromChar
@@ -119,53 +108,53 @@ where
 
 #ifdef WINDOWS
 import System.OsPath.Types
-import System.OsString.Windows
+import System.OsString.Windows as PS
     ( unsafeFromChar
     , toChar
-    , fromPlatformStringUtf
-    , fromPlatformStringEnc
-    , fromPlatformStringFS
-    , packPlatformString
+    , decodeUtf
+    , decodeWith
+    , decodeFS
+    , pack
     , pstr
-    , toPlatformStringUtf
-    , toPlatformStringEnc
-    , toPlatformStringFS
-    , unpackPlatformString
+    , encodeUtf
+    , encodeWith
+    , encodeFS
+    , unpack
     )
 import Data.Bifunctor ( bimap )
 import qualified System.OsPath.Windows.Internal as C
 
 #elif defined(POSIX)
 
 import System.OsPath.Types
-import System.OsString.Posix
+import System.OsString.Posix as PS
     ( unsafeFromChar
     , toChar
-    , fromPlatformStringUtf
-    , fromPlatformStringEnc
-    , fromPlatformStringFS
-    , packPlatformString
+    , decodeUtf
+    , decodeWith
+    , decodeFS
+    , pack
     , pstr
-    , toPlatformStringUtf
-    , toPlatformStringEnc
-    , toPlatformStringFS
-    , unpackPlatformString
+    , encodeUtf
+    , encodeWith
+    , encodeFS
+    , unpack
     )
 import Data.Bifunctor ( bimap )
 import qualified System.OsPath.Posix.Internal as C
 
 #else
 
-import System.OsPath.Internal
+import System.OsPath.Internal as PS
     ( osp
-    , fromOsPathUtf
-    , fromOsPathEnc
-    , fromOsPathFS
-    , packOsPath
-    , toOsPathUtf
-    , toOsPathEnc
-    , toOsPathFS
-    , unpackOsPath
+    , decodeUtf
+    , decodeWith
+    , decodeFS
+    , pack
+    , encodeUtf
+    , encodeWith
+    , encodeFS
+    , unpack
     )
 import System.OsPath.Types
     ( OsPath )

System/OsPath/Encoding.hs

@@ -13,8 +13,8 @@ module System.OsPath.Encoding
   , ucs2le_encode
 
   -- * base encoding
-  , encodeWith
-  , decodeWith
+  , encodeWithTE
+  , decodeWithTE
   , encodeWithBasePosix
   , decodeWithBasePosix
   , encodeWithBaseWindows

System/OsPath/Encoding/Internal.hs

@@ -187,14 +187,14 @@ peekFilePathLenPosix fp = getFileSystemEncoding >>= \enc -> GHC.peekCStringLen e
 --
 
 -- | Decode with the given 'TextEncoding'.
-decodeWith :: TextEncoding -> BS8.ShortByteString -> Either EncodingException String
-decodeWith enc ba = unsafePerformIO $ do
+decodeWithTE :: TextEncoding -> BS8.ShortByteString -> Either EncodingException String
+decodeWithTE enc ba = unsafePerformIO $ do
   r <- try @SomeException $ BS8.useAsCStringLen ba $ \fp -> GHC.peekCStringLen enc fp
   evaluate $ force $ first (flip EncodingError Nothing . displayException) r
 
 -- | Encode with the given 'TextEncoding'.
-encodeWith :: TextEncoding -> String -> Either EncodingException BS8.ShortByteString
-encodeWith enc str = unsafePerformIO $ do
+encodeWithTE :: TextEncoding -> String -> Either EncodingException BS8.ShortByteString
+encodeWithTE enc str = unsafePerformIO $ do
   r <- try @SomeException $ GHC.withCStringLen enc str $ \cstr -> BS8.packCStringLen cstr
   evaluate $ force $ first (flip EncodingError Nothing . displayException) r
 

System/OsPath/Internal.hs

@@ -7,7 +7,7 @@ module System.OsPath.Internal where
 import {-# SOURCE #-} System.OsPath
     ( isValid )
 import System.OsPath.Types
-import System.OsString.Internal
+import System.OsString.Internal hiding ( fromBytes )
 import qualified System.OsString.Internal as OS
 
 import Control.Monad.Catch
@@ -31,17 +31,17 @@ import System.OsPath.Encoding ( EncodingException(..) )
 -- On unix this encodes as UTF8 (strictly), which is a good guess.
 --
 -- Throws a 'EncodingException' if encoding fails.
-toOsPathUtf :: MonadThrow m => String -> m OsPath
-toOsPathUtf = toOsStringUtf
+encodeUtf :: MonadThrow m => FilePath -> m OsPath
+encodeUtf = OS.encodeUtf
 
--- | Like 'toOsPathUtf', except allows to provide encodings.
-toOsPathEnc :: TextEncoding  -- ^ unix text encoding
-            -> TextEncoding  -- ^ windows text encoding
-            -> String
-            -> Either EncodingException OsPath
-toOsPathEnc = toOsStringEnc
+-- | Encode a 'FilePath' with the specified encoding.
+encodeWith :: TextEncoding  -- ^ unix text encoding
+           -> TextEncoding  -- ^ windows text encoding
+           -> FilePath
+           -> Either EncodingException OsPath
+encodeWith = OS.encodeWith
 
--- | Like 'toOsPathUtf', except this mimics the behavior of the base library when doing filesystem
+-- | Like 'encodeUtf', except this mimics the behavior of the base library when doing filesystem
 -- operations, which is:
 --
 -- 1. on unix, uses shady PEP 383 style encoding (based on the current locale,
@@ -52,8 +52,8 @@ toOsPathEnc = toOsStringEnc
 -- Looking up the locale requires IO. If you're not worried about calls
 -- to 'setFileSystemEncoding', then 'unsafePerformIO' may be feasible (make sure
 -- to deeply evaluate the result to catch exceptions).
-toOsPathFS :: String -> IO OsPath
-toOsPathFS = toOsStringFS
+encodeFS :: FilePath -> IO OsPath
+encodeFS = OS.encodeFS
 
 
 -- | Partial unicode friendly decoding.
@@ -62,17 +62,17 @@ toOsPathFS = toOsStringFS
 -- On unix this decodes as UTF8 (strictly), which is a good guess.
 --
 -- Throws a 'EncodingException' if decoding fails.
-fromOsPathUtf :: MonadThrow m => OsPath -> m String
-fromOsPathUtf = fromOsStringUtf
+decodeUtf :: MonadThrow m => OsPath -> m FilePath
+decodeUtf = OS.decodeUtf
 
--- | Like 'fromOsPathUtf', except allows to provide encodings.
-fromOsPathEnc :: TextEncoding  -- ^ unix text encoding
-              -> TextEncoding  -- ^ windows text encoding
-              -> OsPath
-              -> Either EncodingException String
-fromOsPathEnc = fromOsStringEnc
+-- | Decode an 'OsPath' with the specified encoding.
+decodeWith :: TextEncoding  -- ^ unix text encoding
+           -> TextEncoding  -- ^ windows text encoding
+           -> OsPath
+           -> Either EncodingException FilePath
+decodeWith = OS.decodeWith
 
--- | Like 'fromOsPathUtf', except this mimics the behavior of the base library when doing filesystem
+-- | Like 'decodeUtf', except this mimics the behavior of the base library when doing filesystem
 -- operations, which is:
 --
 -- 1. on unix, uses shady PEP 383 style encoding (based on the current locale,
@@ -83,24 +83,24 @@ fromOsPathEnc = fromOsStringEnc
 -- Looking up the locale requires IO. If you're not worried about calls
 -- to 'setFileSystemEncoding', then 'unsafePerformIO' may be feasible (make sure
 -- to deeply evaluate the result to catch exceptions).
-fromOsPathFS :: OsPath -> IO String
-fromOsPathFS = fromOsStringFS
+decodeFS :: OsPath -> IO FilePath
+decodeFS = OS.decodeFS
 
 
 -- | Constructs an @OsPath@ from a ByteString.
 --
 -- On windows, this ensures valid UCS-2LE, on unix it is passed unchanged/unchecked.
 --
 -- Throws 'EncodingException' on invalid UCS-2LE on windows (although unlikely).
-bytesToOsPath :: MonadThrow m
-              => ByteString
-              -> m OsPath
-bytesToOsPath = OS.bytesToOsString
+fromBytes :: MonadThrow m
+          => ByteString
+          -> m OsPath
+fromBytes = OS.fromBytes
 
 
 mkOsPath :: ByteString -> Q Exp
 mkOsPath bs =
-  case bytesToOsPath bs of
+  case fromBytes bs of
     Just afp' ->
       if isValid afp'
       then lift afp'
@@ -115,15 +115,15 @@ osp = qq mkOsPath
 
 
 -- | Unpack an 'OsPath' to a list of 'OsChar'.
-unpackOsPath :: OsPath -> [OsChar]
-unpackOsPath = unpackOsString
+unpack :: OsPath -> [OsChar]
+unpack = OS.unpack
 
 
 -- | Pack a list of 'OsChar' to an 'OsPath'.
 --
 -- Note that using this in conjunction with 'unsafeFromChar' to
 -- convert from @[Char]@ to 'OsPath' is probably not what
 -- you want, because it will truncate unicode code points.
-packOsPath :: [OsChar] -> OsPath
-packOsPath = packOsString
+pack :: [OsChar] -> OsPath
+pack = OS.pack
 

System/OsString.hs

@@ -19,18 +19,18 @@ module System.OsString
   -- * String types
     OsString
 
-  -- * String construction
-  , toOsStringUtf
-  , toOsStringEnc
-  , toOsStringFS
+  -- * OsString construction
+  , encodeUtf
+  , encodeWith
+  , encodeFS
   , osstr
-  , packOsString
+  , pack
 
-  -- * String deconstruction
-  , fromOsStringUtf
-  , fromOsStringEnc
-  , fromOsStringFS
-  , unpackOsString
+  -- * OsString deconstruction
+  , decodeUtf
+  , decodeWith
+  , decodeFS
+  , unpack
 
   -- * Word types
   , OsChar
@@ -46,15 +46,15 @@ where
 import System.OsString.Internal
     ( unsafeFromChar
     , toChar
-    , fromOsStringUtf
-    , fromOsStringEnc
-    , fromOsStringFS
+    , encodeUtf
+    , encodeWith
+    , encodeFS
     , osstr
-    , packOsString
-    , toOsStringUtf
-    , toOsStringEnc
-    , toOsStringFS
-    , unpackOsString
+    , pack
+    , decodeUtf
+    , decodeWith
+    , decodeFS
+    , unpack
     )
 import System.OsString.Internal.Types
     ( OsString, OsChar )