Hello community,

here is the log from the commit of package ghc-async-dejafu for 
openSUSE:Factory checked in at 2017-04-20 20:55:39
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-async-dejafu (Old)
 and      /work/SRC/openSUSE:Factory/.ghc-async-dejafu.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Package is "ghc-async-dejafu"

Thu Apr 20 20:55:39 2017 rev:2 rq:487957 version:0.1.3.0

Changes:
--------
--- /work/SRC/openSUSE:Factory/ghc-async-dejafu/ghc-async-dejafu.changes        
2017-04-07 13:53:09.316761688 +0200
+++ /work/SRC/openSUSE:Factory/.ghc-async-dejafu.new/ghc-async-dejafu.changes   
2017-04-20 20:55:39.975949620 +0200
@@ -1,0 +2,5 @@
+Thu Sep 15 07:01:42 UTC 2016 - psim...@suse.com
+
+- Update to version 0.1.3.0 revision 0 with cabal2obs.
+
+-------------------------------------------------------------------

Old:
----
  async-dejafu-0.1.2.2.tar.gz

New:
----
  async-dejafu-0.1.3.0.tar.gz

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

Other differences:
------------------
++++++ ghc-async-dejafu.spec ++++++
--- /var/tmp/diff_new_pack.SLbJVH/_old  2017-04-20 20:55:40.807831980 +0200
+++ /var/tmp/diff_new_pack.SLbJVH/_new  2017-04-20 20:55:40.807831980 +0200
@@ -1,7 +1,7 @@
 #
 # spec file for package ghc-async-dejafu
 #
-# Copyright (c) 2016 SUSE LINUX GmbH, Nuernberg, Germany.
+# Copyright (c) 2017 SUSE LINUX GmbH, Nuernberg, Germany.
 #
 # All modifications and additions to the file contributed by third parties
 # remain the property of their copyright owners, unless otherwise agreed
@@ -19,32 +19,34 @@
 %global pkg_name async-dejafu
 %bcond_with tests
 Name:           ghc-%{pkg_name}
-Version:        0.1.2.2
+Version:        0.1.3.0
 Release:        0
 Summary:        Run MonadConc operations asynchronously and wait for their 
results
 License:        BSD-3-Clause
-Group:          System/Libraries
+Group:          Development/Languages/Other
 Url:            https://hackage.haskell.org/package/%{pkg_name}
 Source0:        
https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz
 BuildRequires:  ghc-Cabal-devel
-# Begin cabal-rpm deps:
-BuildRequires:  ghc-dejafu-devel
+BuildRequires:  ghc-concurrency-devel
 BuildRequires:  ghc-exceptions-devel
 BuildRequires:  ghc-rpm-macros
 BuildRoot:      %{_tmppath}/%{name}-%{version}-build
 %if %{with tests}
 BuildRequires:  ghc-HUnit-devel
+BuildRequires:  ghc-dejafu-devel
 BuildRequires:  ghc-hunit-dejafu-devel
 %endif
-# End cabal-rpm deps
 
 %description
 The <https://hackage.haskell.org/package/async async> library provides a
 higher-level interface over threads, allowing users to conveniently run IO
 operations asynchronously and wait for their results. This package is a
 reimplementation of async using the 'MonadConc' abstraction from
-<https://hackage.haskell.org/package/dejafu dejafu>, providing easy-to-use
-asynchronous operaitons within an easily-testable framework.
+<https://hackage.haskell.org/package/concurrency concurrency>, providing
+easy-to-use asynchronous operaitons within an easily-testable framework.
+
+This library itself is tested with <https://hackage.haskell.org/package/dejafu
+dejafu>.
 
 When these functions are used in an IO context, the behaviour should appear
 identical to the original async package.
@@ -63,20 +65,14 @@
 %prep
 %setup -q -n %{pkg_name}-%{version}
 
-
 %build
 %ghc_lib_build
 
-
 %install
 %ghc_lib_install
 
-
 %check
-%if %{with tests}
-%{cabal} test
-%endif
-
+%cabal_test
 
 %post devel
 %ghc_pkg_recache

++++++ async-dejafu-0.1.2.2.tar.gz -> async-dejafu-0.1.3.0.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/async-dejafu-0.1.2.2/Control/Concurrent/Async.hs 
new/async-dejafu-0.1.3.0/Control/Concurrent/Async.hs
--- old/async-dejafu-0.1.2.2/Control/Concurrent/Async.hs        2016-05-03 
00:25:35.000000000 +0200
+++ new/async-dejafu-0.1.3.0/Control/Concurrent/Async.hs        2016-08-28 
15:57:25.000000000 +0200
@@ -78,47 +78,17 @@
   ) where
 
 import Control.Applicative
+import Control.Concurrent.Classy.STM.TMVar (newEmptyTMVar, putTMVar, readTMVar)
 import Control.Exception (AsyncException(ThreadKilled), 
BlockedIndefinitelyOnSTM(..), Exception, SomeException)
 import Control.Monad
 import Control.Monad.Catch (finally, try, onException)
 import Control.Monad.Conc.Class
 import Control.Monad.STM.Class
 
-#if MIN_VERSION_dejafu(0,3,0)
-import Control.Concurrent.Classy.STM.TMVar (newEmptyTMVar, putTMVar, readTMVar)
-#else
-import Control.Concurrent.STM.CTMVar (CTMVar, newEmptyCTMVar, putCTMVar, 
readCTMVar)
-#endif
-
 #if !MIN_VERSION_base(4,8,0)
 import Data.Traversable
 #endif
 
-#if !MIN_VERSION_dejafu(0,3,0)
-type MVar m = CVar m
-
-newEmptyMVar :: MonadConc m => m (MVar m a)
-newEmptyMVar = newEmptyCVar
-
-putMVar :: MonadConc m => MVar m a -> a -> m ()
-putMVar = putCVar
-
-takeMVar :: MonadConc m => MVar m a -> m a
-takeMVar = takeCVar
-
-type STM   m = STMLike m
-type TMVar m = CTMVar  m
-
-newEmptyTMVar :: MonadSTM stm => stm (TMVar stm a)
-newEmptyTMVar = newEmptyCTMVar
-
-putTMVar :: MonadSTM stm => TMVar stm a -> a -> stm ()
-putTMVar = putCTMVar
-
-readTMVar :: MonadSTM stm => TMVar stm a -> stm a
-readTMVar = readCTMVar
-#endif
-
 
-----------------------------------------------------------------------------------------
 -- Asynchronous and Concurrent Actions
 
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/async-dejafu-0.1.2.2/async-dejafu.cabal 
new/async-dejafu-0.1.3.0/async-dejafu.cabal
--- old/async-dejafu-0.1.2.2/async-dejafu.cabal 2016-05-26 13:31:13.000000000 
+0200
+++ new/async-dejafu-0.1.3.0/async-dejafu.cabal 2016-08-28 15:57:25.000000000 
+0200
@@ -2,7 +2,7 @@
 -- documentation, see http://haskell.org/cabal/users-guide/
 
 name:                async-dejafu
-version:             0.1.2.2
+version:             0.1.3.0
 synopsis:            Run MonadConc operations asynchronously and wait for 
their results.
 
 description:
@@ -11,10 +11,13 @@
   conveniently run IO operations asynchronously and wait for their
   results. This package is a reimplementation of async using the
   @MonadConc@ abstraction from
-  <https://hackage.haskell.org/package/dejafu dejafu>, providing
+  <https://hackage.haskell.org/package/concurrency concurrency>, providing
   easy-to-use asynchronous operaitons within an easily-testable
   framework.
   .
+  This library itself is tested with
+  <https://hackage.haskell.org/package/dejafu dejafu>.
+  .
   When these functions are used in an IO context, the behaviour should
   appear identical to the original async package.
 
@@ -37,15 +40,15 @@
 source-repository this
   type:     git
   location: https://github.com/barrucadu/dejafu.git
-  tag:      async-dejafu-0.1.2.2
+  tag:      async-dejafu-0.1.3.0
 
 library
   exposed-modules:     Control.Concurrent.Async
   -- other-modules:       
   -- other-extensions:    
-  build-depends:       base       >=4.8 && <5
-                     , dejafu     >=0.2 && <0.4
-                     , exceptions >=0.7 && <0.9
+  build-depends:       base        >=4.8 && <5
+                     , concurrency >=1   && <2
+                     , exceptions  >=0.7 && <0.9
   -- hs-source-dirs:      
   default-language:    Haskell2010
   ghc-options: -Wall
@@ -54,5 +57,5 @@
   hs-source-dirs:      tests
   type:                exitcode-stdio-1.0
   main-is:             Main.hs
-  build-depends:       base, async-dejafu, dejafu, HUnit, hunit-dejafu
+  build-depends:       base, async-dejafu, concurrency, dejafu>=0.4, HUnit, 
hunit-dejafu
   default-language:    Haskell2010
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' 
'--exclude=.svnignore' old/async-dejafu-0.1.2.2/tests/Main.hs 
new/async-dejafu-0.1.3.0/tests/Main.hs
--- old/async-dejafu-0.1.2.2/tests/Main.hs      2016-05-21 01:01:15.000000000 
+0200
+++ new/async-dejafu-0.1.3.0/tests/Main.hs      2016-08-28 15:57:25.000000000 
+0200
@@ -1,4 +1,3 @@
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE LambdaCase         #-}
 
@@ -15,16 +14,6 @@
 import Test.HUnit (Test(..), runTestTT, test)
 import Test.HUnit.DejaFu
 
-#if !MIN_VERSION_dejafu(0,3,0)
-type MVar m = CVar m
-
-newEmptyMVar :: MonadConc m => m (MVar m a)
-newEmptyMVar = newEmptyCVar
-
-takeMVar :: MonadConc m => MVar m a -> m a
-takeMVar = takeCVar
-#endif
-
 main :: IO ()
 main = void . runTestTT $ TestList
   [ TestLabel "async" $ test
@@ -111,8 +100,7 @@
 
 withasync_waitCatch_blocked :: MonadConc m => m (Maybe 
BlockedIndefinitelyOnMVar)
 withasync_waitCatch_blocked = do
-  _concAllKnown
-  r <- withAsync (_concAllKnown >> newEmptyMVar >>= takeMVar) waitCatch
+  r <- withAsync (newEmptyMVar >>= takeMVar) waitCatch
   return $ case r of
     Left e -> fromException e
     _      -> Nothing


Reply via email to