Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package ghc-conduit for openSUSE:Factory checked in at 2022-10-13 15:44:06 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-conduit (Old) and /work/SRC/openSUSE:Factory/.ghc-conduit.new.2275 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-conduit" Thu Oct 13 15:44:06 2022 rev:33 rq:1009705 version:1.3.4.3 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-conduit/ghc-conduit.changes 2021-10-12 21:50:21.371957860 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-conduit.new.2275/ghc-conduit.changes 2022-10-13 15:44:38.055029463 +0200 @@ -1,0 +2,8 @@ +Thu Oct 6 07:03:22 UTC 2022 - Peter Simons <[email protected]> + +- Update conduit to version 1.3.4.3. + ## 1.3.4.3 + + * Fix space leak in `*>` [#496](https://github.com/snoyberg/conduit/issues/496) [#497](https://github.com/snoyberg/conduit/pull/497) + +------------------------------------------------------------------- Old: ---- conduit-1.3.4.2.tar.gz New: ---- conduit-1.3.4.3.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-conduit.spec ++++++ --- /var/tmp/diff_new_pack.1bSQQO/_old 2022-10-13 15:44:38.699030719 +0200 +++ /var/tmp/diff_new_pack.1bSQQO/_new 2022-10-13 15:44:38.703030726 +0200 @@ -1,7 +1,7 @@ # # spec file for package ghc-conduit # -# Copyright (c) 2021 SUSE LLC +# Copyright (c) 2022 SUSE LLC # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -19,7 +19,7 @@ %global pkg_name conduit %bcond_with tests Name: ghc-%{pkg_name} -Version: 1.3.4.2 +Version: 1.3.4.3 Release: 0 Summary: Streaming data processing library License: MIT ++++++ conduit-1.3.4.2.tar.gz -> conduit-1.3.4.3.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/conduit-1.3.4.2/ChangeLog.md new/conduit-1.3.4.3/ChangeLog.md --- old/conduit-1.3.4.2/ChangeLog.md 2021-09-26 06:27:07.000000000 +0200 +++ new/conduit-1.3.4.3/ChangeLog.md 2022-10-06 09:02:00.000000000 +0200 @@ -1,5 +1,9 @@ # ChangeLog for conduit +## 1.3.4.3 + +* Fix space leak in `*>` [#496](https://github.com/snoyberg/conduit/issues/496) [#497](https://github.com/snoyberg/conduit/pull/497) + ## 1.3.4.2 * Fix GHC 9.2 build [#473](https://github.com/snoyberg/conduit/pull/473) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/conduit-1.3.4.2/conduit.cabal new/conduit-1.3.4.3/conduit.cabal --- old/conduit-1.3.4.2/conduit.cabal 2021-09-26 06:27:07.000000000 +0200 +++ new/conduit-1.3.4.3/conduit.cabal 2022-10-06 09:02:00.000000000 +0200 @@ -1,5 +1,5 @@ Name: conduit -Version: 1.3.4.2 +Version: 1.3.4.3 Synopsis: Streaming data processing library. description: `conduit` is a solution to the streaming data problem, allowing for production, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/conduit-1.3.4.2/src/Data/Conduit/Combinators.hs new/conduit-1.3.4.3/src/Data/Conduit/Combinators.hs --- old/conduit-1.3.4.2/src/Data/Conduit/Combinators.hs 2021-08-05 04:20:47.000000000 +0200 +++ new/conduit-1.3.4.3/src/Data/Conduit/Combinators.hs 2022-10-02 06:29:48.000000000 +0200 @@ -2431,7 +2431,7 @@ -- Under the surface, this function uses a number of tricks to get high -- performance. For more information on both usage and implementation, -- please see: --- <https://www.fpcomplete.com/user/snoyberg/library-documentation/vectorbuilder> +-- <https://www.schoolofhaskell.com/user/snoyberg/library-documentation/vectorbuilder> -- -- @since 1.3.0 vectorBuilder :: (PrimMonad m, PrimMonad n, V.Vector v e, PrimState m ~ PrimState n) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/conduit-1.3.4.2/src/Data/Conduit/Internal/Conduit.hs new/conduit-1.3.4.3/src/Data/Conduit/Internal/Conduit.hs --- old/conduit-1.3.4.2/src/Data/Conduit/Internal/Conduit.hs 2021-09-26 06:27:01.000000000 +0200 +++ new/conduit-1.3.4.3/src/Data/Conduit/Internal/Conduit.hs 2022-10-06 09:02:00.000000000 +0200 @@ -148,6 +148,8 @@ {-# INLINE pure #-} (<*>) = ap {-# INLINE (<*>) #-} + (*>) = (>>) + {-# INLINE (*>) #-} instance Monad (ConduitT i o m) where return = pure @@ -327,7 +329,7 @@ where recurse = goLeft rp rc -sourceToPipe :: Monad m => Source m o -> Pipe l i o u m () +sourceToPipe :: Monad m => ConduitT () o m () -> Pipe l i o u m () sourceToPipe (ConduitT k) = go $ k Done where @@ -337,7 +339,7 @@ go (PipeM mp) = PipeM (liftM go mp) go (Leftover p ()) = go p -sinkToPipe :: Monad m => Sink i m r -> Pipe l i o u m r +sinkToPipe :: Monad m => ConduitT i Void m r -> Pipe l i o u m r sinkToPipe (ConduitT k) = go $ injectLeftovers $ k Done where @@ -347,7 +349,7 @@ go (PipeM mp) = PipeM (liftM go mp) go (Leftover _ l) = absurd l -conduitToPipe :: Monad m => Conduit i m o -> Pipe l i o u m () +conduitToPipe :: Monad m => ConduitT i o m () -> Pipe l i o u m () conduitToPipe (ConduitT k) = go $ injectLeftovers $ k Done where @@ -360,7 +362,7 @@ -- | Generalize a 'Source' to a 'Producer'. -- -- Since 1.0.0 -toProducer :: Monad m => Source m a -> ConduitT i a m () +toProducer :: Monad m => ConduitT () a m () -> ConduitT i a m () toProducer (ConduitT c0) = ConduitT $ \rest -> let go (HaveOutput p o) = HaveOutput (go p) o go (NeedInput _ c) = go (c ()) @@ -372,7 +374,7 @@ -- | Generalize a 'Sink' to a 'Consumer'. -- -- Since 1.0.0 -toConsumer :: Monad m => Sink a m b -> Consumer a m b +toConsumer :: Monad m => ConduitT a Void m b -> ConduitT a o m b toConsumer (ConduitT c0) = ConduitT $ \rest -> let go (HaveOutput _ o) = absurd o go (NeedInput p c) = NeedInput (go . p) (go . c) @@ -436,7 +438,7 @@ -- Any leftovers are discarded. -- -- Since 0.4.1 -zipSinks :: Monad m => Sink i m r -> Sink i m r' -> Sink i m (r, r') +zipSinks :: Monad m => ConduitT i Void m r -> ConduitT i Void m r' -> ConduitT i Void m (r, r') zipSinks (ConduitT x0) (ConduitT y0) = ConduitT $ \rest -> let Leftover _ i >< _ = absurd i _ >< Leftover _ i = absurd i @@ -455,7 +457,7 @@ -- source has been exhausted. -- -- Since 1.0.13 -zipSources :: Monad m => Source m a -> Source m b -> Source m (a, b) +zipSources :: Monad m => ConduitT () a m () -> ConduitT () b m () -> ConduitT () (a, b) m () zipSources (ConduitT left0) (ConduitT right0) = ConduitT $ \rest -> let go (Leftover left ()) right = go left right go left (Leftover right ()) = go left right @@ -476,7 +478,7 @@ -- source has been exhausted. -- -- Since 1.0.13 -zipSourcesApp :: Monad m => Source m (a -> b) -> Source m a -> Source m b +zipSourcesApp :: Monad m => ConduitT () (a -> b) m () -> ConduitT () a m () -> ConduitT () b m () zipSourcesApp (ConduitT left0) (ConduitT right0) = ConduitT $ \rest -> let go (Leftover left ()) right = go left right go left (Leftover right ()) = go left right @@ -601,11 +603,11 @@ -- The new conduit will stop processing once either source or upstream have been exhausted. mergeSource :: Monad m - => Source m i - -> Conduit a m (i, a) + => ConduitT () i m () + -> ConduitT a (i, a) m () mergeSource = loop . sealConduitT where - loop :: Monad m => SealedConduitT () i m () -> Conduit a m (i, a) + loop :: Monad m => SealedConduitT () i m () -> ConduitT a (i, a) m () loop src0 = await >>= maybe (return ()) go where go a = do @@ -629,9 +631,9 @@ -- -- Since 1.1.0 passthroughSink :: Monad m - => Sink i m r + => ConduitT i Void m r -> (r -> m ()) -- ^ finalizer - -> Conduit i m i + -> ConduitT i i m () passthroughSink (ConduitT sink0) final = ConduitT $ \rest -> let -- A bit of explanation is in order, this function is -- non-obvious. The purpose of go is to keep track of the sink @@ -689,11 +691,11 @@ -- However, @sourceToList@ is able to produce its results lazily, which cannot -- be done when running a conduit pipeline in general. Unlike the -- @Data.Conduit.Lazy@ module (in conduit-extra), this function performs no --- unsafe I\/O operations, and therefore can only be as lazily as the +-- unsafe I\/O operations, and therefore can only be as lazy as the -- underlying monad. -- -- Since 1.2.6 -sourceToList :: Monad m => Source m a -> m [a] +sourceToList :: Monad m => ConduitT () a m () -> m [a] sourceToList (ConduitT k) = go $ k Done where @@ -763,7 +765,7 @@ -- deprecated and will be removed in a future version. -- -- Since 1.2.3 -fuse :: Monad m => Conduit a m b -> ConduitM b c m r -> ConduitM a c m r +fuse :: Monad m => ConduitT a b m () -> ConduitT b c m r -> ConduitT a c m r fuse = (=$=) -- | Combine two @Conduit@s together into a new @Conduit@ (aka 'fuse'). @@ -794,9 +796,9 @@ -- -- @since 1.2.8 (.|) :: Monad m - => ConduitM a b m () -- ^ upstream - -> ConduitM b c m r -- ^ downstream - -> ConduitM a c m r + => ConduitT a b m () -- ^ upstream + -> ConduitT b c m r -- ^ downstream + -> ConduitT a c m r (.|) = fuse {-# INLINE (.|) #-} @@ -864,7 +866,7 @@ -- also return @Nothing@. -- -- Since 0.5.0 -await :: Monad m => Consumer i m (Maybe i) +await :: Monad m => ConduitT i o m (Maybe i) await = ConduitT $ \f -> NeedInput (f . Just) (const $ f Nothing) {-# INLINE [0] await #-} @@ -1051,14 +1053,14 @@ -- Mnemonic: connect + do more. -- -- Since 0.5.0 -($$+) :: Monad m => Source m a -> Sink a m b -> m (SealedConduitT () a m (), b) +($$+) :: Monad m => ConduitT () a m () -> ConduitT a Void m b -> m (SealedConduitT () a m (), b) src $$+ sink = connectResume (sealConduitT src) sink {-# INLINE ($$+) #-} -- | Continue processing after usage of @$$+@. -- -- Since 0.5.0 -($$++) :: Monad m => SealedConduitT () a m () -> Sink a m b -> m (SealedConduitT () a m (), b) +($$++) :: Monad m => SealedConduitT () a m () -> ConduitT a Void m b -> m (SealedConduitT () a m (), b) ($$++) = connectResume {-# INLINE ($$++) #-} @@ -1069,7 +1071,7 @@ -- run. Since version 1.3.0, there are no finalizers in conduit. -- -- Since 0.5.0 -($$+-) :: Monad m => SealedConduitT () a m () -> Sink a m b -> m b +($$+-) :: Monad m => SealedConduitT () a m () -> ConduitT a Void m b -> m b rsrc $$+- sink = do (_, res) <- connectResume rsrc sink return res @@ -1078,7 +1080,7 @@ -- | Left fusion for a sealed source. -- -- Since 1.0.16 -($=+) :: Monad m => SealedConduitT () a m () -> Conduit a m b -> SealedConduitT () b m () +($=+) :: Monad m => SealedConduitT () a m () -> ConduitT a b m () -> SealedConduitT () b m () SealedConduitT src $=+ ConduitT sink = SealedConduitT (src `pipeL` sink Done) -- | Provide for a stream of data that can be flushed. @@ -1100,7 +1102,7 @@ -- producing output. -- -- Since 1.0.13 -newtype ZipSource m o = ZipSource { getZipSource :: Source m o } +newtype ZipSource m o = ZipSource { getZipSource :: ConduitT () o m () } instance Monad m => Functor (ZipSource m) where fmap f = ZipSource . mapOutput f . getZipSource @@ -1116,7 +1118,7 @@ -- multiple sources, use `sequence_`. -- -- Since 1.0.13 -sequenceSources :: (Traversable f, Monad m) => f (Source m o) -> Source m (f o) +sequenceSources :: (Traversable f, Monad m) => f (ConduitT () o m ()) -> ConduitT () (f o) m () sequenceSources = getZipSource . sequenceA . fmap ZipSource -- | A wrapper for defining an 'Applicative' instance for 'Sink's which allows @@ -1126,7 +1128,7 @@ -- -- @ -- sequenceSinks :: (Monad m) --- => [Sink i m r] -> Sink i m [r] +-- => [ConduitT i Void m r] -> ConduitT i Void m [r] -- sequenceSinks = getZipSink . sequenceA . fmap ZipSink -- @ -- @@ -1141,7 +1143,7 @@ -- understood). -- -- Since 1.0.13 -newtype ZipSink i m r = ZipSink { getZipSink :: Sink i m r } +newtype ZipSink i m r = ZipSink { getZipSink :: ConduitT i Void m r } instance Monad m => Functor (ZipSink i m) where fmap f (ZipSink x) = ZipSink (liftM f x) @@ -1156,7 +1158,7 @@ -- Implemented on top of @ZipSink@, see that data type for more details. -- -- Since 1.0.13 -sequenceSinks :: (Traversable f, Monad m) => f (Sink i m r) -> Sink i m (f r) +sequenceSinks :: (Traversable f, Monad m) => f (ConduitT i Void m r) -> ConduitT i Void m (f r) sequenceSinks = getZipSink . sequenceA . fmap ZipSink -- | The connect-and-resume operator. This does not close the @Conduit@, but @@ -1282,7 +1284,7 @@ -- @Conduit@. Same caveats of forced consumption apply. -- -- Since 1.1.5 -fuseUpstream :: Monad m => ConduitT a b m r -> Conduit b m c -> ConduitT a c m r +fuseUpstream :: Monad m => ConduitT a b m r -> ConduitT b c m () -> ConduitT a c m r fuseUpstream up down = fmap fst (fuseBoth up down) {-# INLINE fuseUpstream #-} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/conduit-1.3.4.2/src/Data/Conduit/List.hs new/conduit-1.3.4.3/src/Data/Conduit/List.hs --- old/conduit-1.3.4.2/src/Data/Conduit/List.hs 2021-08-05 04:20:47.000000000 +0200 +++ new/conduit-1.3.4.3/src/Data/Conduit/List.hs 2022-10-02 06:29:48.000000000 +0200 @@ -8,9 +8,6 @@ -- Higher-level functions to interact with the elements of a stream. Most of -- these are based on list functions. -- --- For many purposes, it's recommended to use the conduit-combinators library, --- which provides a more complete set of functions. --- -- Note that these functions all deal with individual elements of a stream as a -- sort of \"black box\", where there is no introspection of the contained -- elements. Values such as @ByteString@ and @Text@ will likely need to be @@ -466,7 +463,7 @@ {- {-# RULES "conduit: source/map fusion .|" forall f src. src .| map f = mapFuseRight src f #-} -mapFuseRight :: Monad m => Source m a -> (a -> b) -> Source m b +mapFuseRight :: Monad m => ConduitT () a m () -> (a -> b) -> ConduitT () b m () mapFuseRight src f = CIC.mapOutput f src {-# INLINE mapFuseRight #-} -} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/conduit-1.3.4.2/test/Spec.hs new/conduit-1.3.4.3/test/Spec.hs --- old/conduit-1.3.4.2/test/Spec.hs 2021-08-05 04:20:47.000000000 +0200 +++ new/conduit-1.3.4.3/test/Spec.hs 2022-10-02 06:29:48.000000000 +0200 @@ -36,7 +36,6 @@ import Data.Textual.Encoding #endif import qualified Data.NonNull as NN -import System.IO.Silently (hCapture) import GHC.IO.Handle (hDuplicateTo) import qualified Data.ByteString as S import Data.ByteString.Builder (byteString, toLazyByteString) @@ -342,20 +341,6 @@ runConduitRes $ yield contents .| sinkIOHandle open res <- S.readFile fp res `shouldBe` contents - prop "print" $ \vals -> do - let expected = Prelude.unlines $ map showInt vals - (actual, ()) <- hCapture [IO.stdout] $ runConduit $ yieldMany vals .| printC - actual `shouldBe` expected -#ifndef WINDOWS - prop "stdout" $ \ (vals :: [String]) -> do - let expected = concat vals - (actual, ()) <- hCapture [IO.stdout] $ runConduit $ yieldMany (map T.pack vals) .| encodeUtf8C .| stdoutC - actual `shouldBe` expected - prop "stderr" $ \ (vals :: [String]) -> do - let expected = concat vals - (actual, ()) <- hCapture [IO.stderr] $ runConduit $ yieldMany (map T.pack vals) .| encodeUtf8C .| stderrC - actual `shouldBe` expected -#endif prop "map" $ \input -> runConduitPure (yieldMany input .| mapC succChar .| sinkList) `shouldBe` map succChar input diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/conduit-1.3.4.2/test/main.hs new/conduit-1.3.4.3/test/main.hs --- old/conduit-1.3.4.2/test/main.hs 2021-08-05 04:20:47.000000000 +0200 +++ new/conduit-1.3.4.3/test/main.hs 2022-10-02 06:29:48.000000000 +0200 @@ -264,7 +264,7 @@ x <- runConduitRes $ CI.ConduitT ((CI.unConduitT (CL.sourceList [1..10]) CI.Done - CI.>+> CI.injectLeftovers ((`CI.unConduitT` CI.Done) $ CL.map (* 2))) >>=) + CI.>+> CI.injectLeftovers ((\c -> c `CI.unConduitT` CI.Done) $ CL.map (* 2))) >>=) .| CL.fold (+) 0 x `shouldBe` 2 * sum [1..10 :: Int] @@ -580,8 +580,8 @@ y <- runConduit $ CL.sourceList [1..10 :: Int] .| CL.fold (+) 0 x `shouldBe` y it' "right identity" $ do - x <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (`CI.unConduitT` CI.Done) $ CL.fold (+) 0) CI.>+> CI.idP - y <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (`CI.unConduitT` CI.Done) $ CL.fold (+) 0) + x <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (\c -> c `CI.unConduitT` CI.Done) $ CL.fold (+) 0) CI.>+> CI.idP + y <- CI.runPipe $ mapM_ CI.yield [1..10 :: Int] CI.>+> (CI.injectLeftovers $ (\c -> c `CI.unConduitT` CI.Done) $ CL.fold (+) 0) x `shouldBe` y describe "generalizing" $ do @@ -630,7 +630,7 @@ describe "injectLeftovers" $ do it "works" $ do let src = mapM_ CI.yield [1..10 :: Int] - conduit = CI.injectLeftovers $ (`CI.unConduitT` CI.Done) $ C.awaitForever $ \i -> do + conduit = CI.injectLeftovers $ (\c -> c `CI.unConduitT` CI.Done) $ C.awaitForever $ \i -> do js <- CL.take 2 mapM_ C.leftover $ reverse js C.yield i
