Hello community,
here is the log from the commit of package ghc-case-insensitive for
openSUSE:Factory checked in at 2014-11-26 20:54:36
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-case-insensitive (Old)
and /work/SRC/openSUSE:Factory/.ghc-case-insensitive.new (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-case-insensitive"
Changes:
--------
---
/work/SRC/openSUSE:Factory/ghc-case-insensitive/ghc-case-insensitive.changes
2014-08-25 11:05:50.000000000 +0200
+++
/work/SRC/openSUSE:Factory/.ghc-case-insensitive.new/ghc-case-insensitive.changes
2014-11-26 20:54:40.000000000 +0100
@@ -1,0 +2,12 @@
+Tue Sep 9 20:24:56 UTC 2014 - [email protected]
+
+- update to 1.1.0.3
+* no changelog
+* for Haskell Platform 2014.2.0.0
+
+-------------------------------------------------------------------
+Tue Sep 2 08:52:04 UTC 2014 - [email protected]
+
+- regenerate spec file
+
+-------------------------------------------------------------------
Old:
----
case-insensitive-1.0.0.1.tar.gz
New:
----
case-insensitive-1.1.0.3.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ ghc-case-insensitive.spec ++++++
--- /var/tmp/diff_new_pack.Kyj76m/_old 2014-11-26 20:54:41.000000000 +0100
+++ /var/tmp/diff_new_pack.Kyj76m/_new 2014-11-26 20:54:41.000000000 +0100
@@ -1,8 +1,7 @@
#
# spec file for package ghc-case-insensitive
#
-
-# Copyright (c) 2012 Peter Trommler <[email protected]>
+# Copyright (c) 2014 SUSE LINUX Products GmbH, Nuernberg, Germany.
#
# All modifications and additions to the file contributed by third parties
# remain the property of their copyright owners, unless otherwise agreed
@@ -16,55 +15,55 @@
# Please submit bugfixes or comments via http://bugs.opensuse.org/
#
-%global pkg_name case-insensitive
-
-%global common_summary Haskell case insensitive string comparison library
-%global common_description The Haskell module Data.CaseInsensitive provides
the CI type constructor which can be parameterised by a string-like type like:
String, ByteString, Text, etc. Comparisons of values of the resulting type will
be insensitive to cases.
+%global pkg_name case-insensitive
Name: ghc-case-insensitive
-Version: 1.0.0.1
+Version: 1.1.0.3
Release: 0
-Summary: %{common_summary}
-
-Group: System/Libraries
+Summary: Case insensitive string comparison
License: BSD-3-Clause
-# BEGIN cabal2spec
-URL: http://hackage.haskell.org/package/%{pkg_name}
+Group: System/Libraries
+
+Url: http://hackage.haskell.org/package/%{pkg_name}
Source0:
http://hackage.haskell.org/packages/archive/%{pkg_name}/%{version}/%{pkg_name}-%{version}.tar.gz
+BuildRoot: %{_tmppath}/%{name}-%{version}-build
+
BuildRequires: ghc-Cabal-devel
BuildRequires: ghc-rpm-macros
-# END cabal2spec
+# Begin cabal-rpm deps:
BuildRequires: ghc-bytestring-devel
BuildRequires: ghc-deepseq-devel
BuildRequires: ghc-hashable-devel
-Buildrequires: ghc-text-devel
-
-BuildRoot: %{_tmppath}/%{name}-%{version}-build
+BuildRequires: ghc-text-devel
+# End cabal-rpm deps
%description
-%{common_description}
+The module @Data.CaseInsensitive@ provides the 'CI' type constructor which can
+be parameterised by a string-like type like: 'String', 'ByteString', 'Text',
+etc.. Comparisons of values of the resulting type will be insensitive to cases.
+
%package devel
Summary: Haskell %{pkg_name} library development files
-Group: Development/Languages/Other
-Requires: ghc-compiler
-Requires(post): ghc-compiler
-Requires(postun): ghc-compiler
+Group: Development/Libraries/Other
+Provides: %{name}-static = %{version}-%{release}
+Requires: ghc-compiler = %{ghc_version}
+Requires(post): ghc-compiler = %{ghc_version}
+Requires(postun): ghc-compiler = %{ghc_version}
Requires: %{name} = %{version}-%{release}
%description devel
-%{common_description}
-This package contains the development files.
+This package provides the Haskell %{pkg_name} library development
+files.
+
%prep
%setup -q -n %{pkg_name}-%{version}
-
%build
%ghc_lib_build
-
%install
%ghc_lib_install
@@ -80,5 +79,6 @@
%files devel -f %{name}-devel.files
%defattr(-,root,root,-)
+%doc README.markdown
%changelog
++++++ case-insensitive-1.0.0.1.tar.gz -> case-insensitive-1.1.0.3.tar.gz ++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/case-insensitive-1.0.0.1/Data/CaseInsensitive/Internal.hs
new/case-insensitive-1.1.0.3/Data/CaseInsensitive/Internal.hs
--- old/case-insensitive-1.0.0.1/Data/CaseInsensitive/Internal.hs
1970-01-01 01:00:00.000000000 +0100
+++ new/case-insensitive-1.1.0.3/Data/CaseInsensitive/Internal.hs
2014-01-14 00:28:43.000000000 +0100
@@ -0,0 +1,188 @@
+{-# LANGUAGE CPP, NoImplicitPrelude, DeriveDataTypeable #-}
+
+#if __GLASGOW_HASKELL__ >= 702
+{-# LANGUAGE Unsafe #-}
+#endif
+
+-----------------------------------------------------------------------------
+-- |
+-- Module : Data.CaseInsensitive.Internal
+-- Copyright : (c) 2011-2013 Bas van Dijk
+-- License : BSD-style (see the file LICENSE)
+-- Maintainer : Bas van Dijk <[email protected]>
+--
+-- Internal module which exports the 'CI' type, constructor,
+-- associated instances and the 'FoldCase' class and instances.
+--
+-----------------------------------------------------------------------------
+
+module Data.CaseInsensitive.Internal ( CI
+ , mk
+ , unsafeMk
+ , original
+ , foldedCase
+ , map
+ , FoldCase(foldCase)
+ ) where
+
+--------------------------------------------------------------------------------
+-- Imports
+--------------------------------------------------------------------------------
+
+-- from base:
+import Data.Bool ( (||) )
+import Data.Char ( Char, toLower )
+import Data.Eq ( Eq, (==) )
+import Data.Function ( on )
+import Data.Monoid ( Monoid, mempty, mappend )
+import Data.Ord ( Ord, compare )
+import Data.String ( IsString, fromString )
+import Data.Typeable ( Typeable )
+import Data.Word ( Word8 )
+import Prelude ( String, (.), fmap, (&&), (+), (<=), (>=), otherwise )
+import Text.Read ( Read, readPrec )
+import Text.Show ( Show, showsPrec )
+
+import qualified Data.List as L ( map )
+
+#if __GLASGOW_HASKELL__ < 700
+import Control.Monad ( (>>) )
+import Prelude ( fromInteger )
+#endif
+
+-- from bytestring:
+import qualified Data.ByteString as B ( ByteString, map )
+import qualified Data.ByteString.Lazy as BL ( ByteString, map )
+
+-- from text:
+import qualified Data.Text as T ( Text, toCaseFold )
+import qualified Data.Text.Lazy as TL ( Text, toCaseFold, pack, unpack )
+
+-- from deepseq:
+import Control.DeepSeq ( NFData, rnf, deepseq )
+
+-- from hashable:
+import Data.Hashable ( Hashable, hashWithSalt )
+
+
+--------------------------------------------------------------------------------
+-- Case Insensitive Strings
+--------------------------------------------------------------------------------
+
+{-| A @CI s@ provides /C/ase /I/nsensitive comparison for the string-like type
+@s@ (for example: 'String', 'T.Text', 'B.ByteString', etc.).
+
+Note that @CI s@ has an instance for 'IsString' which together with the
+@OverloadedStrings@ language extension allows you to write case insensitive
+string literals as in:
+
+@
+\> (\"Content-Type\" :: 'CI' 'T.Text') == (\"CONTENT-TYPE\" :: 'CI' 'T.Text')
+True
+@
+
+-}
+data CI s = CI { original :: !s -- ^ Retrieve the original string-like value.
+ , foldedCase :: !s -- ^ Retrieve the case folded string-like
value.
+ -- (Also see 'foldCase').
+ }
+ deriving Typeable
+
+-- | Make the given string-like value case insensitive.
+mk :: FoldCase s => s -> CI s
+mk s = CI s (foldCase s)
+
+-- | Constructs a 'CI' from an already case folded string-like
+-- value. The given string is used both as the 'original' as well as
+-- the 'foldedCase'.
+--
+-- This function is unsafe since the compiler can't guarantee that the
+-- provided string is case folded.
+unsafeMk :: FoldCase s => s -> CI s
+unsafeMk s = CI s s
+
+-- | Transform the original string-like value but keep it case insensitive.
+map :: FoldCase s2 => (s1 -> s2) -> (CI s1 -> CI s2)
+map f = mk . f . original
+
+instance (IsString s, FoldCase s) => IsString (CI s) where
+ fromString = mk . fromString
+
+instance Monoid s => Monoid (CI s) where
+ mempty = CI mempty mempty
+ CI o1 l1 `mappend` CI o2 l2 = CI (o1 `mappend` o2) (l1 `mappend` l2)
+
+instance Eq s => Eq (CI s) where
+ (==) = (==) `on` foldedCase
+
+instance Ord s => Ord (CI s) where
+ compare = compare `on` foldedCase
+
+instance (Read s, FoldCase s) => Read (CI s) where
+ readPrec = fmap mk readPrec
+
+instance Show s => Show (CI s) where
+ showsPrec prec = showsPrec prec . original
+
+instance Hashable s => Hashable (CI s) where
+ hashWithSalt salt = hashWithSalt salt . foldedCase
+
+instance NFData s => NFData (CI s) where
+ rnf (CI o f) = o `deepseq` f `deepseq` ()
+
+--------------------------------------------------------------------------------
+-- Folding (lowering) cases
+--------------------------------------------------------------------------------
+
+-- | Class of string-like types that support folding cases.
+--
+-- /Note/: In some languages, case conversion is a locale- and
context-dependent
+-- operation. The @foldCase@ method is /not/ intended to be locale sensitive.
+-- Programs that require locale sensitivity should use appropriate versions of
+-- the case mapping functions from the @text-icu@ package:
+-- <http://hackage.haskell.org/package/text-icu>
+class FoldCase s where
+ foldCase :: s -> s
+
+ foldCaseList :: [s] -> [s]
+ foldCaseList = L.map foldCase
+
+instance FoldCase a => FoldCase [a] where
+ foldCase = foldCaseList
+
+-- | Note that @foldCase@ on @'B.ByteString's@ is only guaranteed to be
correct for ISO-8859-1 encoded strings!
+instance FoldCase B.ByteString where foldCase = B.map toLower8
+
+-- | Note that @foldCase@ on @'BL.ByteString's@ is only guaranteed to be
correct for ISO-8859-1 encoded strings!
+instance FoldCase BL.ByteString where foldCase = BL.map toLower8
+
+instance FoldCase Char where
+ foldCase = toLower
+ foldCaseList = TL.unpack . TL.toCaseFold . TL.pack
+
+instance FoldCase T.Text where foldCase = T.toCaseFold
+instance FoldCase TL.Text where foldCase = TL.toCaseFold
+instance FoldCase (CI s) where foldCase (CI _ l) = CI l l
+
+toLower8 :: Word8 -> Word8
+toLower8 w
+ | 65 <= w && w <= 90 ||
+ 192 <= w && w <= 214 ||
+ 216 <= w && w <= 222 = w + 32
+ | otherwise = w
+
+--------------------------------------------------------------------------------
+-- Rewrite RULES
+--------------------------------------------------------------------------------
+
+{-# RULES "mk/ByteString" forall (bs :: B.ByteString). mk bs = CI bs
(foldCaseBS bs) #-}
+
+foldCaseBS :: B.ByteString -> B.ByteString
+foldCaseBS bs = B.map toLower8' bs
+ where
+ toLower8' :: Word8 -> Word8
+ toLower8' w
+ | 65 <= w && w <= 90 ||
+ 192 <= w && w <= 214 ||
+ 216 <= w && w <= 222 = w + 32
+ | otherwise = w
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/case-insensitive-1.0.0.1/Data/CaseInsensitive/Unsafe.hs
new/case-insensitive-1.1.0.3/Data/CaseInsensitive/Unsafe.hs
--- old/case-insensitive-1.0.0.1/Data/CaseInsensitive/Unsafe.hs 1970-01-01
01:00:00.000000000 +0100
+++ new/case-insensitive-1.1.0.3/Data/CaseInsensitive/Unsafe.hs 2014-01-14
00:28:43.000000000 +0100
@@ -0,0 +1,19 @@
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
+
+#if __GLASGOW_HASKELL__ >= 702
+{-# LANGUAGE Unsafe #-}
+#endif
+
+-----------------------------------------------------------------------------
+-- |
+-- Module : Data.CaseInsensitive.Unsafe
+-- Copyright : (c) 2011-2013 Bas van Dijk
+-- License : BSD-style (see the file LICENSE)
+-- Maintainer : Bas van Dijk <[email protected]>
+--
+-- Provides an unsafe way to create a case insensitive string-like value.
+--
+-----------------------------------------------------------------------------
+
+module Data.CaseInsensitive.Unsafe ( unsafeMk ) where
+import Data.CaseInsensitive.Internal ( unsafeMk )
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/case-insensitive-1.0.0.1/Data/CaseInsensitive.hs
new/case-insensitive-1.1.0.3/Data/CaseInsensitive.hs
--- old/case-insensitive-1.0.0.1/Data/CaseInsensitive.hs 2013-03-29
08:34:43.000000000 +0100
+++ new/case-insensitive-1.1.0.3/Data/CaseInsensitive.hs 2014-01-14
00:28:43.000000000 +0100
@@ -1,4 +1,4 @@
-{-# LANGUAGE CPP, NoImplicitPrelude, DeriveDataTypeable #-}
+{-# LANGUAGE CPP, NoImplicitPrelude #-}
#if __GLASGOW_HASKELL__ >= 702
{-# LANGUAGE Trustworthy #-}
@@ -30,157 +30,4 @@
, map
, FoldCase(foldCase)
) where
-
---------------------------------------------------------------------------------
--- Imports
---------------------------------------------------------------------------------
-
--- from base:
-import Data.Bool ( (||) )
-import Data.Char ( Char, toLower )
-import Data.Eq ( Eq, (==) )
-import Data.Function ( on )
-import Data.Monoid ( Monoid, mempty, mappend )
-import Data.Ord ( Ord, compare )
-import Data.String ( IsString, fromString )
-import Data.Typeable ( Typeable )
-import Data.Word ( Word8 )
-import Prelude ( String, (.), fmap, (&&), (+), (<=), (>=), otherwise )
-import Text.Read ( Read, readPrec )
-import Text.Show ( Show, showsPrec )
-
-import qualified Data.List as L ( map )
-
-#if __GLASGOW_HASKELL__ < 700
-import Control.Monad ( (>>) )
-import Prelude ( fromInteger )
-#endif
-
--- from bytestring:
-import qualified Data.ByteString as B ( ByteString, map )
-import qualified Data.ByteString.Lazy as BL ( ByteString, map )
-
--- from text:
-import qualified Data.Text as T ( Text, toCaseFold )
-import qualified Data.Text.Lazy as TL ( Text, toCaseFold, pack, unpack )
-
--- from deepseq:
-import Control.DeepSeq ( NFData, rnf, deepseq )
-
--- from hashable:
-import Data.Hashable ( Hashable, hashWithSalt )
-
---------------------------------------------------------------------------------
--- Case Insensitive Strings
---------------------------------------------------------------------------------
-
-{-| A @CI s@ provides /C/ase /I/nsensitive comparison for the string-like type
-@s@ (for example: 'String', 'T.Text', 'B.ByteString', etc.).
-
-Note that @CI s@ has an instance for 'IsString' which together with the
-@OverloadedStrings@ language extension allows you to write case insensitive
-string literals as in:
-
-@
-\> (\"Content-Type\" :: 'CI' 'T.Text') == (\"CONTENT-TYPE\" :: 'CI' 'T.Text')
-True
-@
-
--}
-data CI s = CI { original :: !s -- ^ Retrieve the original string-like value.
- , foldedCase :: !s -- ^ Retrieve the case folded string-like
value.
- -- (Also see 'foldCase').
- }
- deriving Typeable
-
--- | Make the given string-like value case insensitive.
-mk :: FoldCase s => s -> CI s
-mk s = CI s (foldCase s)
-
--- | Transform the original string-like value but keep it case insensitive.
-map :: FoldCase s2 => (s1 -> s2) -> (CI s1 -> CI s2)
-map f = mk . f . original
-
-instance (IsString s, FoldCase s) => IsString (CI s) where
- fromString = mk . fromString
-
-instance Monoid s => Monoid (CI s) where
- mempty = CI mempty mempty
- CI o1 l1 `mappend` CI o2 l2 = CI (o1 `mappend` o2) (l1 `mappend` l2)
-
-instance Eq s => Eq (CI s) where
- (==) = (==) `on` foldedCase
-
-instance Ord s => Ord (CI s) where
- compare = compare `on` foldedCase
-
-instance (Read s, FoldCase s) => Read (CI s) where
- readPrec = fmap mk readPrec
-
-instance Show s => Show (CI s) where
- showsPrec prec = showsPrec prec . original
-
-instance Hashable s => Hashable (CI s) where
- hashWithSalt salt = hashWithSalt salt . foldedCase
-
-instance NFData s => NFData (CI s) where
- rnf (CI o f) = o `deepseq` f `deepseq` ()
-
---------------------------------------------------------------------------------
--- Folding (lowering) cases
---------------------------------------------------------------------------------
-
--- | Class of string-like types that support folding cases.
---
--- /Note/: In some languages, case conversion is a locale- and
context-dependent
--- operation. The @foldCase@ method is /not/ intended to be locale sensitive.
--- Programs that require locale sensitivity should use appropriate versions of
--- the case mapping functions from the @text-icu@ package:
--- <http://hackage.haskell.org/package/text-icu>
-class FoldCase s where
- foldCase :: s -> s
-
- foldCaseList :: [s] -> [s]
- foldCaseList = L.map foldCase
-
-instance FoldCase a => FoldCase [a] where
- foldCase = foldCaseList
-
--- | Note that @foldCase@ on @'B.ByteString's@ is only guaranteed to be
correct for ISO-8859-1 encoded strings!
-instance FoldCase B.ByteString where foldCase = B.map toLower8
-
--- | Note that @foldCase@ on @'BL.ByteString's@ is only guaranteed to be
correct for ISO-8859-1 encoded strings!
-instance FoldCase BL.ByteString where foldCase = BL.map toLower8
-
-instance FoldCase Char where
- foldCase = toLower
- foldCaseList = TL.unpack . TL.toCaseFold . TL.pack
-
-instance FoldCase T.Text where foldCase = T.toCaseFold
-instance FoldCase TL.Text where foldCase = TL.toCaseFold
-instance FoldCase (CI s) where foldCase (CI _ l) = CI l l
-
-toLower8 :: Word8 -> Word8
-toLower8 w
- | 65 <= w && w <= 90 ||
- 192 <= w && w <= 214 ||
- 216 <= w && w <= 222 = w + 32
- | otherwise = w
-
---------------------------------------------------------------------------------
--- Rewrite RULES
---------------------------------------------------------------------------------
-
-{-# RULES
- "mk/ByteString" forall (bs :: B.ByteString). mk bs = CI bs (foldCaseBS bs)
- #-}
-
-foldCaseBS :: B.ByteString -> B.ByteString
-foldCaseBS bs = B.map toLower8' bs
- where
- toLower8' :: Word8 -> Word8
- toLower8' w
- | 65 <= w && w <= 90 ||
- 192 <= w && w <= 214 ||
- 216 <= w && w <= 222 = w + 32
- | otherwise = w
+import Data.CaseInsensitive.Internal
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/case-insensitive-1.0.0.1/case-insensitive.cabal
new/case-insensitive-1.1.0.3/case-insensitive.cabal
--- old/case-insensitive-1.0.0.1/case-insensitive.cabal 2013-03-29
08:34:43.000000000 +0100
+++ new/case-insensitive-1.1.0.3/case-insensitive.cabal 2014-01-14
00:28:43.000000000 +0100
@@ -1,5 +1,5 @@
name: case-insensitive
-version: 1.0.0.1
+version: 1.1.0.3
cabal-version: >=1.8
build-type: Simple
license: BSD3
@@ -27,10 +27,11 @@
ghc-options: -Wall
build-depends: base >= 3 && < 4.8
, bytestring >= 0.9 && < 0.11
- , text >= 0.3 && < 0.12
+ , text >= 0.3 && < 1.2
, deepseq >= 1.1 && < 1.4
, hashable >= 1.0 && < 1.3
- exposed-modules: Data.CaseInsensitive
+ exposed-modules: Data.CaseInsensitive, Data.CaseInsensitive.Unsafe
+ other-modules: Data.CaseInsensitive.Internal
test-suite test-case-insensitive
type: exitcode-stdio-1.0
@@ -40,7 +41,7 @@
build-depends: case-insensitive
, base >= 3 && < 4.8
, bytestring >= 0.9 && < 0.11
- , text >= 0.3 && < 0.12
+ , text >= 0.3 && < 1.2
, HUnit >= 1.2.2 && < 1.3
, test-framework >= 0.2.4 && < 0.9
, test-framework-hunit >= 0.2.4 && < 0.4
@@ -57,5 +58,5 @@
build-depends: case-insensitive
, base >= 3 && < 4.8
, bytestring >= 0.9 && < 0.11
- , criterion >= 0.6.1 && < 0.7
+ , criterion >= 0.6.1 && < 0.9
, deepseq >= 1.1 && < 1.4
--
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
