Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package ghc-string-conv for openSUSE:Factory checked in at 2022-08-01 21:28:56 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-string-conv (Old) and /work/SRC/openSUSE:Factory/.ghc-string-conv.new.1533 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Package is "ghc-string-conv" Mon Aug 1 21:28:56 2022 rev:3 rq:985826 version:0.2.0 Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-string-conv/ghc-string-conv.changes 2020-12-22 11:46:41.977874220 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-string-conv.new.1533/ghc-string-conv.changes 2022-08-01 21:29:04.749429281 +0200 @@ -1,0 +2,9 @@ +Fri Mar 4 00:48:53 UTC 2022 - Peter Simons <psimons@suse.com> + +- Update string-conv to version 0.2.0. + Upstream has edited the change log file since the last release in + a non-trivial way, i.e. they did more than just add a new entry + at the top. You can review the file at: + http://hackage.haskell.org/package/string-conv-0.2.0/src/changelog.md + +------------------------------------------------------------------- Old: ---- string-conv-0.1.2.tar.gz New: ---- string-conv-0.2.0.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-string-conv.spec ++++++ --- /var/tmp/diff_new_pack.NBQZNM/_old 2022-08-01 21:29:05.261430749 +0200 +++ /var/tmp/diff_new_pack.NBQZNM/_new 2022-08-01 21:29:05.269430772 +0200 @@ -1,7 +1,7 @@ # # spec file for package ghc-string-conv # -# Copyright (c) 2020 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 @@ -17,8 +17,9 @@ %global pkg_name string-conv +%bcond_with tests Name: ghc-%{pkg_name} -Version: 0.1.2 +Version: 0.2.0 Release: 0 Summary: Standardized conversion between string types License: BSD-3-Clause @@ -29,6 +30,11 @@ BuildRequires: ghc-rpm-macros BuildRequires: ghc-text-devel ExcludeArch: %{ix86} +%if %{with tests} +BuildRequires: ghc-quickcheck-instances-devel +BuildRequires: ghc-tasty-devel +BuildRequires: ghc-tasty-quickcheck-devel +%endif %description Avoids the need to remember many different functions for converting string @@ -54,6 +60,9 @@ %install %ghc_lib_install +%check +%cabal_test + %post devel %ghc_pkg_recache ++++++ string-conv-0.1.2.tar.gz -> string-conv-0.2.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/string-conv-0.1.2/Data/String/Conv.hs new/string-conv-0.2.0/Data/String/Conv.hs --- old/string-conv-0.1.2/Data/String/Conv.hs 2016-06-23 01:16:18.000000000 +0200 +++ new/string-conv-0.2.0/Data/String/Conv.hs 1970-01-01 01:00:00.000000000 +0100 @@ -1,118 +0,0 @@ -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE MultiParamTypeClasses #-} - -module Data.String.Conv - ( StringConv (..) - , toS - , toSL - , convS - , convSL - , Leniency (..) - ) where - ------------------------------------------------------------------------------- -import Data.ByteString.Char8 as B -import Data.ByteString.Lazy.Char8 as LB -import Data.Text as T -import Data.Text.Encoding as T -import Data.Text.Encoding.Error as T -import Data.Text.Lazy as LT -import Data.Text.Lazy.Encoding as LT ------------------------------------------------------------------------------- - - ------------------------------------------------------------------------------- --- | Data type representing the two leniency modes defining how decoding --- failure is handled. -data Leniency = Lenient | Strict - deriving (Eq,Show,Read,Ord,Enum,Bounded) - - ------------------------------------------------------------------------------- --- | A type class to standardize string conversions. With this type class you --- only need to remember one function for converting between any two string --- variants. This package includes support for String, ByteString, and Text --- as well as the Lazy and Strict variants where necessary. --- --- This type class lets you control how conversion should behave when failure --- is possible. Strict mode will cause an exception to be thrown when --- decoding fails. Lenient mode will attempt to recover, inserting a --- replacement character for invalid bytes. --- --- StringConv's `toS` function is most useful when you have a fully defined --- string conversion with a fixed (non-polymorphic) input and output type. Of --- course you can still use it when you don't have a fixed type. In that case --- you might need to specify a type class constraint such as @StringConv --- s String@. -class StringConv a b where - strConv :: Leniency -> a -> b - - ------------------------------------------------------------------------------- --- | Universal string conversion function for strict decoding. -toS :: StringConv a b => a -> b -toS = strConv Strict - - ------------------------------------------------------------------------------- --- | Universal string conversion function for lenient decoding. -toSL :: StringConv a b => a -> b -toSL = strConv Lenient - - -instance StringConv String String where strConv _ = id -instance StringConv String B.ByteString where strConv l = T.encodeUtf8 . strConv l -instance StringConv String LB.ByteString where strConv l = LT.encodeUtf8 . strConv l -instance StringConv String T.Text where strConv _ = T.pack -instance StringConv String LT.Text where strConv _ = LT.pack - -instance StringConv B.ByteString String where strConv l = T.unpack . strConv l -instance StringConv B.ByteString B.ByteString where strConv _ = id -instance StringConv B.ByteString LB.ByteString where strConv _ = LB.fromChunks . return -instance StringConv B.ByteString T.Text where strConv = decodeUtf8T -instance StringConv B.ByteString LT.Text where strConv l = strConv l . LB.fromChunks . return - -instance StringConv LB.ByteString String where strConv l = LT.unpack . strConv l -instance StringConv LB.ByteString B.ByteString where strConv _ = B.concat . LB.toChunks -instance StringConv LB.ByteString LB.ByteString where strConv _ = id -instance StringConv LB.ByteString T.Text where strConv l = decodeUtf8T l . strConv l -instance StringConv LB.ByteString LT.Text where strConv = decodeUtf8LT - -instance StringConv T.Text String where strConv _ = T.unpack -instance StringConv T.Text B.ByteString where strConv _ = T.encodeUtf8 -instance StringConv T.Text LB.ByteString where strConv l = strConv l . T.encodeUtf8 -instance StringConv T.Text LT.Text where strConv _ = LT.fromStrict -instance StringConv T.Text T.Text where strConv _ = id - -instance StringConv LT.Text String where strConv _ = LT.unpack -instance StringConv LT.Text T.Text where strConv _ = LT.toStrict -instance StringConv LT.Text LT.Text where strConv _ = id -instance StringConv LT.Text LB.ByteString where strConv _ = LT.encodeUtf8 -instance StringConv LT.Text B.ByteString where strConv l = strConv l . LT.encodeUtf8 - - ------------------------------------------------------------------------------- --- | Convenience helper for dispatching based on leniency. -decodeUtf8T :: Leniency -> B.ByteString -> T.Text -decodeUtf8T Lenient = T.decodeUtf8With T.lenientDecode -decodeUtf8T Strict = T.decodeUtf8With T.strictDecode - - ------------------------------------------------------------------------------- --- | Convenience helper for dispatching based on leniency. -decodeUtf8LT :: Leniency -> LB.ByteString -> LT.Text -decodeUtf8LT Lenient = LT.decodeUtf8With T.lenientDecode -decodeUtf8LT Strict = LT.decodeUtf8With T.strictDecode - - ------------------------------------------------------------------------------- --- | A lens for 'toS' to make it slightly more convenient in some scenarios. -convS :: (StringConv a b, StringConv b a, Functor f) => (b -> f b) -> a -> f a -convS f a = fmap toS (f (toS a)) - - ------------------------------------------------------------------------------- --- | A lens for 'toSL' to make it slightly more convenient in some scenarios. -convSL :: (StringConv a b, StringConv b a, Functor f) => (b -> f b) -> a -> f a -convSL f a = fmap toSL (f (toSL a)) - diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/string-conv-0.1.2/Setup.hs new/string-conv-0.2.0/Setup.hs --- old/string-conv-0.1.2/Setup.hs 2016-06-23 01:16:18.000000000 +0200 +++ new/string-conv-0.2.0/Setup.hs 2022-03-04 01:40:10.000000000 +0100 @@ -1,2 +1,3 @@ import Distribution.Simple + main = defaultMain diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/string-conv-0.1.2/changelog.md new/string-conv-0.2.0/changelog.md --- old/string-conv-0.1.2/changelog.md 2016-06-23 01:16:18.000000000 +0200 +++ new/string-conv-0.2.0/changelog.md 2022-03-04 01:37:41.000000000 +0100 @@ -1,6 +1,8 @@ -0.1.2 +0.2.0 ===== -* Fixed bug where String <-> ByteString conversion would trim characters to 8 bits. Now it goes through conversion to Text first. +* Don't set optimization flag for library +* Add property tests and fix to make String <-> ByteString conversion safer [PR 6](https://github.com/Soostone/string-conv/pull/6). +* Add lib-Werror flag for development 0.1.1 ===== diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/string-conv-0.1.2/src/Data/String/Conv.hs new/string-conv-0.2.0/src/Data/String/Conv.hs --- old/string-conv-0.1.2/src/Data/String/Conv.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/string-conv-0.2.0/src/Data/String/Conv.hs 2022-03-04 01:40:11.000000000 +0100 @@ -0,0 +1,138 @@ +{-# LANGUAGE FlexibleInstances #-} +{-# LANGUAGE MultiParamTypeClasses #-} + +module Data.String.Conv + ( StringConv (..), + toS, + toSL, + convS, + convSL, + Leniency (..), + ) +where + +------------------------------------------------------------------------------ +import Data.ByteString as B +import Data.ByteString.Lazy as LB +import Data.Text as T +import Data.Text.Encoding as T +import Data.Text.Encoding.Error as T +import Data.Text.Lazy as LT +import Data.Text.Lazy.Encoding as LT + +------------------------------------------------------------------------------ + +------------------------------------------------------------------------------ + +-- | Data type representing the two leniency modes defining how decoding +-- failure is handled. +data Leniency = Lenient | Strict + deriving (Eq, Show, Read, Ord, Enum, Bounded) + +------------------------------------------------------------------------------ + +-- | A type class to standardize string conversions. With this type class you +-- only need to remember one function for converting between any two string +-- variants. This package includes support for String, ByteString, and Text +-- as well as the Lazy and Strict variants where necessary. +-- +-- This type class lets you control how conversion should behave when failure +-- is possible. Strict mode will cause an exception to be thrown when +-- decoding fails. Lenient mode will attempt to recover, inserting a +-- replacement character for invalid bytes. +-- +-- StringConv's `toS` function is most useful when you have a fully defined +-- string conversion with a fixed (non-polymorphic) input and output type. Of +-- course you can still use it when you don't have a fixed type. In that case +-- you might need to specify a type class constraint such as @StringConv +-- s String@. +class StringConv a b where + strConv :: Leniency -> a -> b + +------------------------------------------------------------------------------ + +-- | Universal string conversion function for strict decoding. +toS :: StringConv a b => a -> b +toS = strConv Strict + +------------------------------------------------------------------------------ + +-- | Universal string conversion function for lenient decoding. +toSL :: StringConv a b => a -> b +toSL = strConv Lenient + +instance StringConv String String where strConv _ = id + +instance StringConv String B.ByteString where strConv _ = T.encodeUtf8 . T.pack + +instance StringConv String LB.ByteString where strConv _ = LT.encodeUtf8 . LT.pack + +instance StringConv String T.Text where strConv _ = T.pack + +instance StringConv String LT.Text where strConv _ = LT.pack + +instance StringConv B.ByteString String where strConv l = T.unpack . decodeUtf8T l + +instance StringConv B.ByteString B.ByteString where strConv _ = id + +instance StringConv B.ByteString LB.ByteString where strConv _ = LB.fromChunks . return + +instance StringConv B.ByteString T.Text where strConv = decodeUtf8T + +instance StringConv B.ByteString LT.Text where strConv l = strConv l . LB.fromChunks . return + +instance StringConv LB.ByteString String where strConv l = LT.unpack . decodeUtf8LT l + +instance StringConv LB.ByteString B.ByteString where strConv _ = B.concat . LB.toChunks + +instance StringConv LB.ByteString LB.ByteString where strConv _ = id + +instance StringConv LB.ByteString T.Text where strConv l = decodeUtf8T l . strConv l + +instance StringConv LB.ByteString LT.Text where strConv = decodeUtf8LT + +instance StringConv T.Text String where strConv _ = T.unpack + +instance StringConv T.Text B.ByteString where strConv _ = T.encodeUtf8 + +instance StringConv T.Text LB.ByteString where strConv l = strConv l . T.encodeUtf8 + +instance StringConv T.Text LT.Text where strConv _ = LT.fromStrict + +instance StringConv T.Text T.Text where strConv _ = id + +instance StringConv LT.Text String where strConv _ = LT.unpack + +instance StringConv LT.Text T.Text where strConv _ = LT.toStrict + +instance StringConv LT.Text LT.Text where strConv _ = id + +instance StringConv LT.Text LB.ByteString where strConv _ = LT.encodeUtf8 + +instance StringConv LT.Text B.ByteString where strConv l = strConv l . LT.encodeUtf8 + +------------------------------------------------------------------------------ + +-- | Convenience helper for dispatching based on leniency. +decodeUtf8T :: Leniency -> B.ByteString -> T.Text +decodeUtf8T Lenient = T.decodeUtf8With T.lenientDecode +decodeUtf8T Strict = T.decodeUtf8With T.strictDecode + +------------------------------------------------------------------------------ + +-- | Convenience helper for dispatching based on leniency. +decodeUtf8LT :: Leniency -> LB.ByteString -> LT.Text +decodeUtf8LT Lenient = LT.decodeUtf8With T.lenientDecode +decodeUtf8LT Strict = LT.decodeUtf8With T.strictDecode + +------------------------------------------------------------------------------ + +-- | A lens for 'toS' to make it slightly more convenient in some scenarios. +convS :: (StringConv a b, StringConv b a, Functor f) => (b -> f b) -> a -> f a +convS f a = fmap toS (f (toS a)) + +------------------------------------------------------------------------------ + +-- | A lens for 'toSL' to make it slightly more convenient in some scenarios. +convSL :: (StringConv a b, StringConv b a, Functor f) => (b -> f b) -> a -> f a +convSL f a = fmap toSL (f (toSL a)) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/string-conv-0.1.2/string-conv.cabal new/string-conv-0.2.0/string-conv.cabal --- old/string-conv-0.1.2/string-conv.cabal 2016-06-23 01:16:18.000000000 +0200 +++ new/string-conv-0.2.0/string-conv.cabal 2022-03-04 01:44:09.000000000 +0100 @@ -1,35 +1,71 @@ -name: string-conv -version: 0.1.2 -synopsis: Standardized conversion between string types -description: Avoids the need to remember many different functions - for converting string types. Just use one universal - function toS for all monomorphic string conversions. -license: BSD3 -license-file: LICENSE -author: Ozgun Ataman -maintainer: ozgun.ataman@soostone.com -copyright: Soostone Inc, 2012-2015 -category: Data, String, Text -homepage: https://github.com/Soostone/string-conv -bug-reports: https://github.com/Soostone/string-conv/issues -build-type: Simple -cabal-version: >=1.8 +cabal-version: 1.12 + +-- This file has been generated from package.yaml by hpack version 0.34.6. +-- +-- see: https://github.com/sol/hpack + +name: string-conv +version: 0.2.0 +synopsis: Standardized conversion between string types +description: Avoids the need to remember many different functions for converting string types. Just use one universal function toS for all monomorphic string conversions. +category: Data, String, Text +homepage: https://github.com/Soostone/string-conv +bug-reports: https://github.com/Soostone/string-conv/issues +author: Ozgun Ataman +maintainer: ozgun.ataman@soostone.com +copyright: Soostone Inc, 2012-2015 +license: BSD3 +license-file: LICENSE +build-type: Simple extra-source-files: - README.md - changelog.md + README.md + changelog.md + +source-repository head + type: git + location: https://github.com/Soostone/string-conv flag lib-Werror - default: False - manual: True + description: Turn on -Wall and -Werror. Should always be enabled in development. -source-repository head - type: git - location: https://github.com/Soostone/string-conv.git + manual: True + default: False library - exposed-modules: Data.String.Conv - build-depends: base >= 4.4 && < 5, bytestring, text + exposed-modules: + Data.String.Conv + other-modules: + Paths_string_conv + hs-source-dirs: + src + build-depends: + base >=4.4 && <5 + , bytestring + , text if flag(lib-Werror) - ghc-options: -Werror + ghc-options: -Wall -Werror -fwarn-redundant-constraints -Wincomplete-record-updates -Wincomplete-uni-patterns -Widentities + else + ghc-options: -Wall -fwarn-redundant-constraints -Wincomplete-record-updates -Widentities + default-language: Haskell2010 - ghc-options: -Wall +test-suite tests + type: exitcode-stdio-1.0 + main-is: Main.hs + other-modules: + Paths_string_conv + hs-source-dirs: + test + ghc-options: -threaded -rtsopts -with-rtsopts=-N + build-depends: + base >=4.4 && <5 + , bytestring + , quickcheck-instances >=0.3.17 + , string-conv + , tasty + , tasty-quickcheck + , text + if flag(lib-Werror) + ghc-options: -Wall -Werror -fwarn-redundant-constraints -Wincomplete-record-updates -Wincomplete-uni-patterns -Widentities + else + ghc-options: -Wall -fwarn-redundant-constraints -Wincomplete-record-updates -Widentities + default-language: Haskell2010 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/string-conv-0.1.2/test/Main.hs new/string-conv-0.2.0/test/Main.hs --- old/string-conv-0.1.2/test/Main.hs 1970-01-01 01:00:00.000000000 +0100 +++ new/string-conv-0.2.0/test/Main.hs 2022-03-04 01:40:11.000000000 +0100 @@ -0,0 +1,92 @@ +{-# LANGUAGE OverloadedStrings #-} + +import Data.ByteString as B +import Data.ByteString.Lazy as LB +import Data.String.Conv +import Data.Text as T +import Data.Text.Lazy as LT +import Test.QuickCheck.Instances.ByteString () +import Test.QuickCheck.Instances.Text () +import Test.Tasty +import Test.Tasty.QuickCheck + +main :: IO () +main = + defaultMain $ + testGroup + " tests" + [ strictDecoding, + lenientDecoding + ] + +strictDecoding :: TestTree +strictDecoding = + testGroup + "strict decoding (toS method)" + [ testProperty "converting String to String" $ do + \s -> s == (toS (toS (s :: String) :: String)), + testProperty "converting String to strict ByteString" $ do + \s -> s == (toS (toS (s :: String) :: B.ByteString)), + testProperty "converting String to lazy ByteString" $ do + \s -> s == (toS (toS (s :: String) :: LB.ByteString)), + testProperty "converting String to strict Text" $ do + \s -> s == (toS (toS (s :: String) :: T.Text)), + testProperty "converting String to lazy Text" $ do + \s -> s == (toS (toS (s :: String) :: LT.Text)), + testProperty "converting strict ByteString to strict ByteString" $ do + \s -> s == (toS (toS (s :: B.ByteString) :: B.ByteString)), + testProperty "converting strict ByteString to lazy ByteString" $ do + \s -> s == (toS (toS (s :: B.ByteString) :: LB.ByteString)), + testProperty "converting lazy ByteString to lazy ByteString" $ do + \s -> s == (toS (toS (s :: LB.ByteString) :: LB.ByteString)), + testProperty "converting strict Text to lazy ByteString" $ do + \s -> s == (toS (toS (s :: T.Text) :: LB.ByteString)), + testProperty "converting strict Text to strict ByteString" $ do + \s -> s == (toS (toS (s :: LB.ByteString) :: B.ByteString)), + testProperty "converting strict Text to strict Text" $ do + \s -> s == (toS (toS (s :: T.Text) :: T.Text)), + testProperty "converting strict Text to lazy Text" $ do + \s -> s == (toS (toS (s :: T.Text) :: LT.Text)), + testProperty "converting lazy Text to strict ByteString" $ do + \s -> s == (toS (toS (s :: LT.Text) :: B.ByteString)), + testProperty "converting lazy Text to lazy ByteString" $ do + \s -> s == (toS (toS (s :: LT.Text) :: LB.ByteString)), + testProperty "converting lazy Text to lazy Text" $ do + \s -> s == (toS (toS (s :: LT.Text) :: LT.Text)) + ] + +lenientDecoding :: TestTree +lenientDecoding = + testGroup + "lenient decoding (toSL method)" + [ testProperty "converting String to String" $ do + \s -> s == (toSL (toSL (s :: String) :: String)), + testProperty "converting String to strict ByteString" $ do + \s -> s == (toSL (toSL (s :: String) :: B.ByteString)), + testProperty "converting String to lazy ByteString" $ do + \s -> s == (toSL (toSL (s :: String) :: LB.ByteString)), + testProperty "converting String to strict Text" $ do + \s -> s == (toSL (toSL (s :: String) :: T.Text)), + testProperty "converting String to lazy Text" $ do + \s -> s == (toSL (toSL (s :: String) :: LT.Text)), + testProperty "converting strict ByteString to strict ByteString" $ do + \s -> s == (toSL (toSL (s :: B.ByteString) :: B.ByteString)), + testProperty "converting strict ByteString to lazy ByteString" $ do + \s -> s == (toSL (toSL (s :: B.ByteString) :: LB.ByteString)), + testProperty "converting lazy ByteString to lazy ByteString" $ do + \s -> s == (toSL (toSL (s :: LB.ByteString) :: LB.ByteString)), + testProperty "converting strict Text to lazy ByteString" $ do + \s -> s == (toSL (toSL (s :: T.Text) :: LB.ByteString)), + testProperty "converting strict Text to strict ByteString" $ do + \s -> s == (toSL (toSL (s :: LB.ByteString) :: B.ByteString)), + testProperty "converting strict Text to strict Text" $ do + \s -> s == (toSL (toSL (s :: T.Text) :: T.Text)), + testProperty "converting strict Text to lazy Text" $ do + \s -> s == (toSL (toSL (s :: T.Text) :: LT.Text)), + testProperty "converting lazy Text to strict ByteString" $ do + \s -> s == (toSL (toSL (s :: LT.Text) :: B.ByteString)), + testProperty "converting lazy Text to lazy ByteString" $ do + \s -> s == (toSL (toSL (s :: LT.Text) :: LB.ByteString)), + testProperty "converting lazy Text to lazy Text" $ do + \s -> s == (toSL (toSL (s :: LT.Text) :: LT.Text)) + ]