switch pathParser to Text.Lazy, add storePathToText, refactor imports a bit

Author: sorki

hnix-store-core/src/System/Nix/Internal/StorePath.hs

@@ -33,9 +33,10 @@ import Data.Hashable (Hashable(..))
 import Data.HashSet (HashSet)
 import Data.Proxy (Proxy(..))
 
-import Data.Attoparsec.ByteString.Char8 (Parser, (<?>))
-import qualified Data.Attoparsec.ByteString.Char8 as P
-import System.FilePath (splitFileName)
+import Data.Attoparsec.Text.Lazy (Parser, (<?>))
+
+import qualified Data.Attoparsec.Text.Lazy
+import qualified System.FilePath
 
 -- | A path in a Nix store.
 --
@@ -162,6 +163,12 @@ storePathToFilePath
   -> FilePath
 storePathToFilePath = BC.unpack . storePathToRawFilePath
 
+-- | Render a 'StorePath' as a 'Text'.
+storePathToText
+  :: StorePath
+  -> Text
+storePathToText = T.pack . BC.unpack . storePathToRawFilePath
+
 -- | Build `narinfo` suffix from `StorePath` which
 -- can be used to query binary caches.
 storePathToNarInfo
@@ -180,7 +187,7 @@ parsePath
   -> Either String StorePath
 parsePath expectedRoot x =
   let
-    (rootDir, fname) = splitFileName . BC.unpack $ x
+    (rootDir, fname) = System.FilePath.splitFileName . BC.unpack $ x
     (digestPart, namePart) = T.breakOn "-" $ T.pack fname
     digest = decodeBase32 digestPart
     name = makeStorePathName . T.drop 1 $ namePart
@@ -195,28 +202,26 @@ parsePath expectedRoot x =
 
 pathParser :: FilePath -> Parser StorePath
 pathParser expectedRoot = do
-  P.string (BC.pack expectedRoot)
+  Data.Attoparsec.Text.Lazy.string (T.pack expectedRoot)
     <?> "Store root mismatch" -- e.g. /nix/store
 
-  P.char '/'
+  Data.Attoparsec.Text.Lazy.char '/'
     <?> "Expecting path separator"
 
-  digest <- decodeBase32 . T.pack . BC.unpack
-    <$> P.takeWhile1 (\c -> c `elem` digits32)
+  digest <- decodeBase32
+    <$> Data.Attoparsec.Text.Lazy.takeWhile1 (\c -> c `elem` digits32)
     <?> "Invalid Base32 part"
 
-  P.char '-'
+  Data.Attoparsec.Text.Lazy.char '-'
     <?> "Expecting dash (path name separator)"
 
-  c0 <- P.satisfy (\c -> c /= '.' && validStorePathNameChar c)
+  c0 <- Data.Attoparsec.Text.Lazy.satisfy (\c -> c /= '.' && validStorePathNameChar c)
     <?> "Leading path name character is a dot or invalid character"
 
-  rest <- P.takeWhile validStorePathNameChar
+  rest <- Data.Attoparsec.Text.Lazy.takeWhile validStorePathNameChar
     <?> "Path name contains invalid character"
 
-  let name = makeStorePathName
-              $ T.pack . BC.unpack
-              $ BC.cons c0 rest
+  let name = makeStorePathName $ T.cons c0 rest
 
   either fail return
     $ StorePath <$> digest <*> name <*> pure expectedRoot

hnix-store-core/src/System/Nix/StorePath.hs

@@ -14,10 +14,12 @@ module System.Nix.StorePath
   , unStorePathName
   , validStorePathName
   , -- * Rendering out 'StorePath's
-    storePathToRawFilePath
-  , storePathToFilePath
+    storePathToFilePath
+  , storePathToRawFilePath
+  , storePathToText
   , storePathToNarInfo
-  , parsePath
+  , -- * Parsing 'StorePath's
+    parsePath
   , pathParser
   ) where
 

hnix-store-core/tests/StorePath.hs

@@ -5,12 +5,11 @@
 
 module StorePath where
 
-import qualified Data.ByteString.Char8            as BSC
-import qualified Data.Attoparsec.ByteString.Char8 as P
+import qualified Data.Attoparsec.Text.Lazy
 
 import           Test.Tasty.QuickCheck
 
-import           System.Nix.Internal.StorePath
+import           System.Nix.StorePath
 import           Arbitrary
 
 -- | Test that Nix(OS) like paths roundtrip
@@ -22,9 +21,9 @@ prop_storePathRoundtrip' x =
   (parsePath (storePathRoot x) $ storePathToRawFilePath x) === Right x
 
 prop_storePathRoundtripParser (_ :: NixLike) = \(NixLike x) ->
-  (P.parseOnly (pathParser (storePathRoot x))
-    $ storePathToRawFilePath x) === Right x
+  (Data.Attoparsec.Text.Lazy.parseOnly (pathParser (storePathRoot x))
+    $ storePathToText x) === Right x
 
 prop_storePathRoundtripParser' x =
-  (P.parseOnly (pathParser (storePathRoot x))
-    $ storePathToRawFilePath x) === Right x
+  (Data.Attoparsec.Text.Lazy.parseOnly (pathParser (storePathRoot x))
+    $ storePathToText x) === Right x

hnix-store-remote/src/System/Nix/Store/Remote.hs

@@ -47,8 +47,8 @@ import qualified Data.Set
 import           Data.Proxy                (Proxy)
 import           Data.Text                 (Text)
 
-import qualified System.Nix.Build          as Build
 
+import           System.Nix.Build          (BuildMode, BuildResult)
 import           System.Nix.Hash           (Digest, ValidAlgo)
 import           System.Nix.StorePath
 import           System.Nix.Hash
@@ -60,7 +60,7 @@ import           System.Nix.Store.Remote.Types
 import           System.Nix.Store.Remote.Protocol
 import           System.Nix.Store.Remote.Util
 
-import qualified Data.Text.Encoding -- (encodeUtf8)
+import qualified Data.Text.Encoding
 
 type RepairFlag = Bool
 type CheckFlag = Bool
@@ -150,7 +150,7 @@ addTempRoot :: StorePath -> MonadStore ()
 addTempRoot pn = do
   void $ simpleOpArgs AddTempRoot $ putPath pn
 
-buildPaths :: StorePathSet -> Build.BuildMode -> MonadStore ()
+buildPaths :: StorePathSet -> BuildMode -> MonadStore ()
 buildPaths ps bm = do
   void $ simpleOpArgs BuildPaths $ do
     putPaths ps

hnix-store-remote/src/System/Nix/Store/Remote/Util.hs

@@ -16,7 +16,6 @@ import           Data.Time.Clock.POSIX
 import           Data.ByteString           (ByteString)
 import qualified Data.ByteString.Char8     as BSC
 import qualified Data.ByteString.Lazy      as BSL
-import qualified Data.HashSet              as HashSet
 
 import           Network.Socket.ByteString (recv, sendAll)
 
@@ -25,6 +24,8 @@ import           System.Nix.StorePath
 import           System.Nix.Store.Remote.Binary
 import           System.Nix.Store.Remote.Types
 
+import qualified Data.HashSet
+import qualified Data.Map
 
 genericIncremental :: (MonadIO m) => m (Maybe ByteString) -> Get a -> m a
 genericIncremental getsome parser = go decoder
@@ -105,13 +106,13 @@ getPath :: FilePath -> Get (Either String StorePath)
 getPath sd = parsePath sd <$> getByteStringLen
 
 getPaths :: FilePath -> Get StorePathSet
-getPaths sd = HashSet.fromList . rights . map (parsePath sd) <$> getByteStrings
+getPaths sd = Data.HashSet.fromList . rights . map (parsePath sd) <$> getByteStrings
 
 putPath :: StorePath -> Put
 putPath  = putByteStringLen . BSL.fromStrict . storePathToRawFilePath
 
 putPaths :: StorePathSet -> Put
-putPaths = putByteStrings . HashSet.toList .  HashSet.map (BSL.fromStrict . storePathToRawFilePath)
+putPaths = putByteStrings . Data.HashSet.toList . Data.HashSet.map (BSL.fromStrict . storePathToRawFilePath)
 
 putBool :: Bool -> Put
 putBool True  = putInt (1 :: Int)