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 - peter.trommler@ohm-hochschule.de + +- update to 1.1.0.3 +* no changelog +* for Haskell Platform 2014.2.0.0 + +------------------------------------------------------------------- +Tue Sep 2 08:52:04 UTC 2014 - peter.trommler@ohm-hochschule.de + +- 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 <peter.trommler@ohm-hochschule.de> +# 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 <v.dijk.bas@gmail.com> +-- +-- 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 <v.dijk.bas@gmail.com> +-- +-- 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: opensuse-commit+unsubscribe@opensuse.org For additional commands, e-mail: opensuse-commit+help@opensuse.org