Hello community, here is the log from the commit of package ghc-retry for openSUSE:Factory checked in at 2019-10-18 14:34:53 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-retry (Old) and /work/SRC/openSUSE:Factory/.ghc-retry.new.2352 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-retry" Fri Oct 18 14:34:53 2019 rev:17 rq:737216 version:0.8.0.2 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-retry/ghc-retry.changes 2019-05-12 11:36:21.978391165 +0200 +++ /work/SRC/openSUSE:Factory/.ghc-retry.new.2352/ghc-retry.changes 2019-10-18 14:34:55.424006520 +0200 @@ -1,0 +2,7 @@ +Sat Sep 28 02:01:09 UTC 2019 - [email protected] + +- Update retry to version 0.8.0.2. + 0.8.0.2 + * Update docs for default retry policy. [PR 64](https://github.com/Soostone/retry/pull/64) + +------------------------------------------------------------------- Old: ---- retry-0.8.0.1.tar.gz New: ---- retry-0.8.0.2.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-retry.spec ++++++ --- /var/tmp/diff_new_pack.pOvCFD/_old 2019-10-18 14:34:56.196004509 +0200 +++ /var/tmp/diff_new_pack.pOvCFD/_new 2019-10-18 14:34:56.204004488 +0200 @@ -19,7 +19,7 @@ %global pkg_name retry %bcond_with tests Name: ghc-%{pkg_name} -Version: 0.8.0.1 +Version: 0.8.0.2 Release: 0 Summary: Retry combinators for monadic actions that may fail License: BSD-3-Clause ++++++ retry-0.8.0.1.tar.gz -> retry-0.8.0.2.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/retry-0.8.0.1/changelog.md new/retry-0.8.0.2/changelog.md --- old/retry-0.8.0.1/changelog.md 2019-05-01 19:37:33.000000000 +0200 +++ new/retry-0.8.0.2/changelog.md 2019-09-27 22:24:28.000000000 +0200 @@ -1,3 +1,6 @@ +0.8.0.2 +* Update docs for default retry policy. [PR 64](https://github.com/Soostone/retry/pull/64) + 0.8.0.1 * Loosen upper bounds diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/retry-0.8.0.1/retry.cabal new/retry-0.8.0.2/retry.cabal --- old/retry-0.8.0.1/retry.cabal 2019-05-01 19:37:42.000000000 +0200 +++ new/retry-0.8.0.2/retry.cabal 2019-09-27 22:23:31.000000000 +0200 @@ -14,7 +14,7 @@ case we should hang back for a bit and retry the query instead of simply raising an exception. -version: 0.8.0.1 +version: 0.8.0.2 synopsis: Retry combinators for monadic actions that may fail license: BSD3 license-file: LICENSE diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/retry-0.8.0.1/src/Control/Retry.hs new/retry-0.8.0.2/src/Control/Retry.hs --- old/retry-0.8.0.1/src/Control/Retry.hs 2019-01-08 22:41:56.000000000 +0100 +++ new/retry-0.8.0.2/src/Control/Retry.hs 2019-09-27 17:56:03.000000000 +0200 @@ -131,9 +131,9 @@ -- Naturally, 'mempty' will retry immediately (delay 0) for an -- unlimited number of retries, forming the identity for the 'Monoid'. -- --- The default under 'def' implements a constant 50ms delay, up to 5 times: +-- The default retry policy 'retryPolicyDefault' implements a constant 50ms delay, up to 5 times: -- --- >> def = constantDelay 50000 <> limitRetries 5 +-- >> retryPolicyDefault = constantDelay 50000 <> limitRetries 5 -- -- For anything more complex, just define your own 'RetryPolicyM': -- @@ -403,7 +403,7 @@ -- -- >>> import Data.Maybe -- >>> let f _ = putStrLn "Running action" >> return Nothing --- >>> retrying def (const $ return . isNothing) f +-- >>> retrying retryPolicyDefault (const $ return . isNothing) f -- Running action -- Running action -- Running action @@ -450,7 +450,7 @@ -- before finally failing for good: -- -- >>> let f _ = putStrLn "Running action" >> error "this is an error" --- >>> recoverAll def f +-- >>> recoverAll retryPolicyDefault f -- Running action -- Running action -- Running action @@ -509,7 +509,7 @@ :: (MonadIO m, MonadCatch m) #endif => RetryPolicyM m - -- ^ Just use 'def' for default settings + -- ^ Just use 'retryPolicyDefault' for default settings -> [(RetryStatus -> Handler m Bool)] -- ^ Should a given exception be retried? Action will be -- retried if this returns True *and* the policy allows it. @@ -555,7 +555,7 @@ :: (MonadIO m, MonadCatch m) #endif => RetryPolicyM m - -- ^ Just use 'def' for default settings + -- ^ Just use 'retryPolicyDefault' for default settings -> [(RetryStatus -> Handler m Bool)] -- ^ Should a given exception be retried? Action will be -- retried if this returns True *and* the policy allows it. @@ -725,7 +725,7 @@ -- instance Exception AnotherException --- test = retrying def [h1,h2] f +-- test = retrying retryPolicyDefault [h1,h2] f -- where -- f = putStrLn "Running action" >> throwM AnotherException -- h1 = Handler $ \ (e :: TestException) -> return False diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/retry-0.8.0.1/test/Tests/Control/Retry.hs new/retry-0.8.0.2/test/Tests/Control/Retry.hs --- old/retry-0.8.0.1/test/Tests/Control/Retry.hs 2019-01-08 22:41:56.000000000 +0100 +++ new/retry-0.8.0.2/test/Tests/Control/Retry.hs 2019-09-27 21:47:34.000000000 +0200 @@ -8,9 +8,7 @@ import Control.Applicative import Control.Concurrent import Control.Concurrent.STM as STM -import Control.Exception (AsyncException (..), IOException, - MaskingState (..), - getMaskingState, throwTo) +import qualified Control.Exception as EX import Control.Monad.Catch import Control.Monad.Identity import Control.Monad.IO.Class @@ -72,7 +70,7 @@ recoverAll (limitRetries 2) (const work) `finally` putMVar done () atomically (STM.check . (== 1) =<< readTVar counter) - throwTo tid UserInterrupt + EX.throwTo tid EX.UserInterrupt takeMVar done @@ -225,26 +223,26 @@ maskingStateTests :: TestTree maskingStateTests = testGroup "masking state" [ testCase "shouldn't change masking state in a recovered action" $ do - maskingState <- getMaskingState + maskingState <- EX.getMaskingState final <- try $ recovering retryPolicyDefault testHandlers $ const $ do - maskingState' <- getMaskingState + maskingState' <- EX.getMaskingState maskingState' @?= maskingState fail "Retrying..." assertBool - ("Expected IOException but didn't get one") - (isLeft (final :: Either IOException ())) + ("Expected EX.IOException but didn't get one") + (isLeft (final :: Either EX.IOException ())) , testCase "should mask asynchronous exceptions in exception handlers" $ do let checkMaskingStateHandlers = [ const $ Handler $ \(_ :: SomeException) -> do - maskingState <- getMaskingState - maskingState @?= MaskedInterruptible + maskingState <- EX.getMaskingState + maskingState @?= EX.MaskedInterruptible return shouldRetry ] final <- try $ recovering retryPolicyDefault checkMaskingStateHandlers $ const $ fail "Retrying..." assertBool - ("Expected IOException but didn't get one") - (isLeft (final :: Either IOException ())) + ("Expected EX.IOException but didn't get one") + (isLeft (final :: Either EX.IOException ())) ]
