blaze-builder-conduit 0.2.0.1 → 0.3.0

raw patch · 3 files changed

+25/−28 lines, 3 filesdep ~conduitPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: conduit

API changes (from Hackage documentation)

Files

• Data/Conduit/Blaze.hs +15/−16
• blaze-builder-conduit.cabal +2/−2
• test/main.hs +8/−10

@@ -41,9 +41,8 @@   , builderToByteStringWithFlush     ) where -import Data.Conduit hiding (SinkResult (Done))-import Control.Monad.Trans.Resource-import Control.Monad.Trans.Class+import Data.Conduit hiding (Sink (Done))+import Control.Monad (liftM)  import qualified Data.ByteString                   as S @@ -53,14 +52,14 @@  -- | Incrementally execute builders and pass on the filled chunks as -- bytestrings.-builderToByteString :: ResourceUnsafeIO m => Conduit Builder m S.ByteString+builderToByteString :: MonadUnsafeIO m => Conduit Builder m S.ByteString builderToByteString =   builderToByteStringWith (allNewBuffersStrategy defaultBufferSize)  -- | -- -- Since 0.0.2-builderToByteStringFlush :: ResourceUnsafeIO m => Conduit (Flush Builder) m (Flush S.ByteString)+builderToByteStringFlush :: MonadUnsafeIO m => Conduit (Flush Builder) m (Flush S.ByteString) builderToByteStringFlush =   builderToByteStringWithFlush (allNewBuffersStrategy defaultBufferSize) @@ -71,7 +70,7 @@ -- WARNING: This conduit yields bytestrings that are NOT -- referentially transparent. Their content will be overwritten as soon -- as control is returned from the inner sink!-unsafeBuilderToByteString :: ResourceUnsafeIO m+unsafeBuilderToByteString :: MonadUnsafeIO m                           => IO Buffer  -- action yielding the inital buffer.                           -> Conduit Builder m S.ByteString unsafeBuilderToByteString = builderToByteStringWith . reuseBufferStrategy@@ -81,7 +80,7 @@ -- filled chunks as bytestrings to an inner sink. -- -- INV: All bytestrings passed to the inner sink are non-empty.-builderToByteStringWith :: ResourceUnsafeIO m+builderToByteStringWith :: MonadUnsafeIO m                         => BufferAllocStrategy                         -> Conduit Builder m S.ByteString builderToByteStringWith (ioBuf0, nextBuf) = conduitState@@ -89,7 +88,7 @@     (push nextBuf)     close   where-    close ioBuf = lift $ unsafeFromIO $ do+    close ioBuf = unsafeLiftIO $ do         buf <- ioBuf         return $ maybe [] return $ unsafeFreezeNonEmptyBuffer buf @@ -97,7 +96,7 @@ -- -- Since 0.0.2 builderToByteStringWithFlush-    :: ResourceUnsafeIO m+    :: MonadUnsafeIO m     => BufferAllocStrategy     -> Conduit (Flush Builder) m (Flush S.ByteString) builderToByteStringWithFlush (ioBuf0, nextBuf) = conduitState@@ -105,14 +104,14 @@     push'     close   where-    close ioBuf = lift $ unsafeFromIO $ do+    close ioBuf = unsafeLiftIO $ do         buf <- ioBuf         return $ maybe [] (return . Chunk) $ unsafeFreezeNonEmptyBuffer buf -    push' :: ResourceUnsafeIO m+    push' :: MonadUnsafeIO m           => IO Buffer           -> Flush Builder-          -> ResourceT m (ConduitStateResult (IO Buffer) input (Flush S.ByteString))+          -> m (ConduitStateResult (IO Buffer) input (Flush S.ByteString))     push' ioBuf Flush = do         StateProducing ioBuf' chunks <- push nextBuf ioBuf flush         let myFold bs rest@@ -120,14 +119,14 @@                 | otherwise = Chunk bs : rest             chunks' = foldr myFold [Flush] chunks         return $ StateProducing ioBuf' chunks'-    push' ioBuf (Chunk builder) = (fmap . fmap) Chunk (push nextBuf ioBuf builder)+    push' ioBuf (Chunk builder) = (liftM . fmap) Chunk (push nextBuf ioBuf builder) -push :: ResourceUnsafeIO m+push :: MonadUnsafeIO m      => (Int -> Buffer -> IO (IO Buffer))      -> IO Buffer      -> Builder-     -> ResourceT m (ConduitStateResult (IO Buffer) input S.ByteString)-push nextBuf ioBuf0 x = lift $ unsafeFromIO $ do+     -> m (ConduitStateResult (IO Buffer) input S.ByteString)+push nextBuf ioBuf0 x = unsafeLiftIO $ do     (ioBuf', front) <- go (unBuilder x (buildStep finalStep)) ioBuf0 id     return $ StateProducing ioBuf' $ front []   where

@@ -1,5 +1,5 @@ Name:                blaze-builder-conduit-Version:             0.2.0.1+Version:             0.3.0 Synopsis:            Convert streams of builders to streams of bytestrings. Description:         Convert streams of builders to streams of bytestrings. License:             BSD3@@ -20,7 +20,7 @@                      , bytestring               >= 0.9                      , text                     >= 0.11                      , blaze-builder            >= 0.2.1.4      && < 0.4-                     , conduit                  >= 0.2          && < 0.3+                     , conduit                  >= 0.3          && < 0.4   ghc-options:     -Wall  test-suite test

@@ -9,19 +9,17 @@ import qualified Data.Conduit.List as CL import Data.ByteString.Char8 () import Data.Conduit.Blaze (builderToByteString, builderToByteStringFlush)-import Data.Conduit (runResourceT) import Control.Monad.ST (runST) import Data.Monoid import qualified Data.ByteString as S import Blaze.ByteString.Builder (fromByteString, toLazyByteString, insertLazyByteString) import qualified Data.ByteString.Lazy as L import Data.ByteString.Lazy.Char8 ()-import Control.Monad.IO.Class (liftIO)  main :: IO () main = hspecX $ do     describe "blaze" $ do-        prop "idempotent to toLazyByteString" $ \bss' -> runST $ runResourceT $ do+        prop "idempotent to toLazyByteString" $ \bss' -> runST $ do             let bss = map S.pack bss'             let builders = map fromByteString bss             let lbs = toLazyByteString $ mconcat builders@@ -29,21 +27,21 @@             outBss <- src C.$= builderToByteString C.$$ CL.consume             return $ lbs == L.fromChunks outBss -        it "works for large input" $ runResourceT $ do+        it "works for large input" $ do             let builders = replicate 10000 (fromByteString "hello world!")             let lbs = toLazyByteString $ mconcat builders             let src = mconcat $ map (CL.sourceList . return) builders-            outBss <- src C.$= builderToByteString C.$$ CL.consume :: C.ResourceT IO [S.ByteString]-            liftIO $ lbs @=? L.fromChunks outBss+            outBss <- src C.$= builderToByteString C.$$ CL.consume+            lbs @=? L.fromChunks outBss -        it "works for lazy bytestring insertion" $ runResourceT $ do+        it "works for lazy bytestring insertion" $ do             let builders = replicate 10000 (insertLazyByteString "hello world!")             let lbs = toLazyByteString $ mconcat builders             let src = mconcat $ map (CL.sourceList . return) builders-            outBss <- src C.$= builderToByteString C.$$ CL.consume :: C.ResourceT IO [S.ByteString]-            liftIO $ lbs @=? L.fromChunks outBss+            outBss <- src C.$= builderToByteString C.$$ CL.consume+            lbs @=? L.fromChunks outBss -        prop "flushing" $ \bss' -> runST $ runResourceT $ do+        prop "flushing" $ \bss' -> runST $ do             let bss = concatMap (\bs -> [C.Chunk $ S.pack bs, C.Flush]) $ filter (not . null) bss'             let src = CL.sourceList $ map (fmap fromByteString) bss             outBss <- src C.$= builderToByteStringFlush C.$$ CL.consume