Hello community,
here is the log from the commit of package ghc-base16-bytestring for
openSUSE:Factory checked in at 2020-07-09 13:19:00
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Comparing /work/SRC/openSUSE:Factory/ghc-base16-bytestring (Old)
and /work/SRC/openSUSE:Factory/.ghc-base16-bytestring.new.3060 (New)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-base16-bytestring"
Thu Jul 9 13:19:00 2020 rev:9 rq:819569 version:0.1.1.7
Changes:
--------
---
/work/SRC/openSUSE:Factory/ghc-base16-bytestring/ghc-base16-bytestring.changes
2020-06-19 17:08:44.433312376 +0200
+++
/work/SRC/openSUSE:Factory/.ghc-base16-bytestring.new.3060/ghc-base16-bytestring.changes
2020-07-09 13:19:29.601293463 +0200
@@ -1,0 +2,8 @@
+Sun Jun 21 02:00:47 UTC 2020 - [email protected]
+
+- Update base16-bytestring to version 0.1.1.7.
+ Upstream added a new change log file in this release. With no
+ previous version to compare against, the automatic updater cannot
+ reliable determine the relevante entries for this release.
+
+-------------------------------------------------------------------
Old:
----
base16-bytestring-0.1.1.6.tar.gz
New:
----
base16-bytestring-0.1.1.7.tar.gz
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ ghc-base16-bytestring.spec ++++++
--- /var/tmp/diff_new_pack.mjG5Ox/_old 2020-07-09 13:19:30.213295398 +0200
+++ /var/tmp/diff_new_pack.mjG5Ox/_new 2020-07-09 13:19:30.217295410 +0200
@@ -1,7 +1,7 @@
#
# spec file for package ghc-base16-bytestring
#
-# Copyright (c) 2019 SUSE LLC
+# Copyright (c) 2020 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 base16-bytestring
+%bcond_with tests
Name: ghc-%{pkg_name}
-Version: 0.1.1.6
+Version: 0.1.1.7
Release: 0
Summary: Fast base16 (hex) encoding and decoding for ByteStrings
License: BSD-3-Clause
@@ -29,7 +30,14 @@
BuildRequires: ghc-rpm-macros
%description
-Fast base16 (hex) encoding and decoding for ByteStrings.
+This package provides support for encoding and decoding binary data according
+to 'base16' (see also <https://tools.ietf.org/html/rfc4648 RFC 4648>) for
+strict (see "Data.ByteString.Base16") and lazy 'ByteString's (see
+"Data.ByteString.Base16.Lazy").
+
+See also the <https://hackage.haskell.org/package/base-encoding base-encoding>
+package which provides an uniform API providing conversion paths between more
+binary and textual types.
%package devel
Summary: Haskell %{pkg_name} library development files
@@ -51,6 +59,9 @@
%install
%ghc_lib_install
+%check
+%cabal_test
+
%post devel
%ghc_pkg_recache
@@ -61,6 +72,6 @@
%license LICENSE
%files devel -f %{name}-devel.files
-%doc README.markdown
+%doc CHANGELOG.md README.md
%changelog
++++++ base16-bytestring-0.1.1.6.tar.gz -> base16-bytestring-0.1.1.7.tar.gz
++++++
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/base16-bytestring-0.1.1.6/CHANGELOG.md
new/base16-bytestring-0.1.1.7/CHANGELOG.md
--- old/base16-bytestring-0.1.1.6/CHANGELOG.md 1970-01-01 01:00:00.000000000
+0100
+++ new/base16-bytestring-0.1.1.7/CHANGELOG.md 2001-09-09 03:46:40.000000000
+0200
@@ -0,0 +1,8 @@
+# 0.1.1.7
+
+* Fix some bugs in lazy decoding
+ ([#8](https://github.com/haskell/base16-bytestring/pull/8)).
+
+# 0.1.1.6
+
+* Changelog not recorded up to this version.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore'
old/base16-bytestring-0.1.1.6/Data/ByteString/Base16/Lazy.hs
new/base16-bytestring-0.1.1.7/Data/ByteString/Base16/Lazy.hs
--- old/base16-bytestring-0.1.1.6/Data/ByteString/Base16/Lazy.hs
2014-01-18 00:09:12.000000000 +0100
+++ new/base16-bytestring-0.1.1.7/Data/ByteString/Base16/Lazy.hs
2001-09-09 03:46:40.000000000 +0200
@@ -21,6 +21,7 @@
import qualified Data.ByteString.Base16 as B16
import qualified Data.ByteString as B
import qualified Data.ByteString.Unsafe as B
+import qualified Data.ByteString.Lazy as BL
import Data.ByteString.Lazy.Internal
-- | Encode a string into base16 form. The result will always be a
@@ -38,8 +39,6 @@
-- at the first invalid base16 sequence in the original string.
--
-- This function operates as lazily as possible over the input chunks.
--- The only instance in which it is non-lazy is if an odd-length chunk
--- ends with a byte that is valid base16.
--
-- Examples:
--
@@ -47,16 +46,21 @@
-- > decode "66quux" == ("f", "quux")
-- > decode "666quux" == ("f", "6quux")
decode :: ByteString -> (ByteString, ByteString)
-decode = foldrChunks go (Empty, Empty)
- where go c ~(y,z)
- | len == 0 = (chunk h y, z)
+decode = go Nothing
+ where
+ go :: Maybe Word8 -> ByteString -> (ByteString, ByteString)
+ go Nothing Empty = (Empty, Empty)
+ go (Just w) Empty = (Empty, BL.singleton w)
+ go (Just w) (Chunk c z) =
+ go Nothing (chunk (B.pack [w, B.unsafeHead c]) (chunk (B.unsafeTail
c) z))
+ go Nothing (Chunk c z)
+ | len == 0 =
+ let ~(res,tail') = go Nothing z
+ in (chunk h res, tail')
| len == 1 && isHex (B.unsafeHead t) =
- case z of
- Chunk a as | isHex (B.unsafeHead a)
- -> let (q,_) = B16.decode (t `B.snoc` B.unsafeHead a)
- in (chunk h (chunk q y), chunk (B.unsafeTail a) as)
- _ -> (chunk h y, chunk t z)
- | otherwise = (chunk h y, chunk t z)
+ let ~(res,tail') = go (Just (B.unsafeHead t)) z
+ in (chunk h res, tail')
+ | otherwise = (chunk h Empty, chunk t z)
where (h,t) = B16.decode c
len = B.length t
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/base16-bytestring-0.1.1.6/README.markdown
new/base16-bytestring-0.1.1.7/README.markdown
--- old/base16-bytestring-0.1.1.6/README.markdown 2014-01-18
00:09:12.000000000 +0100
+++ new/base16-bytestring-0.1.1.7/README.markdown 1970-01-01
01:00:00.000000000 +0100
@@ -1,37 +0,0 @@
-# Fast base16 support
-
-This package provides a Haskell library for working with base16-encoded
-data quickly and efficiently, using the ByteString type.
-
-
-# Performance
-
-This library is written in pure Haskell, and it's fast:
-
-* 250 MB/sec encoding
-
-* 200 MB/sec strict decoding (per RFC 4648)
-
-* 100 MB/sec lenient decoding
-
-
-# Get involved!
-
-Please report bugs via the
-[github issue tracker](http://github.com/bos/base16-bytestring).
-
-Master [github repository](http://github.com/bos/base16-bytestring):
-
-* `git clone git://github.com/bos/base16-bytestring.git`
-
-There's also a [Mercurial mirror](http://bitbucket.org/bos/base16-bytestring):
-
-* `hg clone http://bitbucket.org/bos/base16-bytestring`
-
-(You can create and contribute changes using either git or Mercurial.)
-
-
-# Authors
-
-This library is written and maintained by Bryan O'Sullivan,
-<[email protected]>.
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/base16-bytestring-0.1.1.6/README.md
new/base16-bytestring-0.1.1.7/README.md
--- old/base16-bytestring-0.1.1.6/README.md 1970-01-01 01:00:00.000000000
+0100
+++ new/base16-bytestring-0.1.1.7/README.md 2001-09-09 03:46:40.000000000
+0200
@@ -0,0 +1,34 @@
+# Fast base16 support [](https://hackage.haskell.org/package/base16-bytestring)
[](https://www.stackage.org/package/base16-bytestring)
[](http://travis-ci.org/haskell/base16-bytestring)
+
+**Please refer to the [package description on
Hackage](https://hackage.haskell.org/package/base16-bytestring#description) for
more information.**
+
+This package provides a Haskell library for working with base16-encoded
+data quickly and efficiently, using the `ByteString` type.
+
+
+# Performance
+
+This library is written in pure Haskell, and it's fast:
+
+* 250 MB/sec encoding
+
+* 200 MB/sec strict decoding (per RFC 4648)
+
+* 100 MB/sec lenient decoding
+
+
+# Get involved!
+
+Please report bugs via the
+[GitHub issue tracker](http://github.com/haskell/base16-bytestring).
+
+Master [Git repository](http://github.com/haskell/base16-bytestring):
+
+* `git clone git://github.com/haskell/base16-bytestring.git`
+
+
+# Authors
+
+This library is written by [Bryan O'Sullivan](mailto:[email protected]). It
+is maintained by [Emily Pillmore](mailto:[email protected]), [Herbert
Valerio Riedel](mailto:[email protected]) and [Mikhail
+Glushenkov](mailto:[email protected]).
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/base16-bytestring-0.1.1.6/base16-bytestring.cabal
new/base16-bytestring-0.1.1.7/base16-bytestring.cabal
--- old/base16-bytestring-0.1.1.6/base16-bytestring.cabal 2014-01-18
00:09:12.000000000 +0100
+++ new/base16-bytestring-0.1.1.7/base16-bytestring.cabal 2001-09-09
03:46:40.000000000 +0200
@@ -1,38 +1,53 @@
+cabal-version: 1.12
name: base16-bytestring
-version: 0.1.1.6
+version: 0.1.1.7
synopsis: Fast base16 (hex) encoding and decoding for ByteStrings
-description: Fast base16 (hex) encoding and decoding for ByteStrings
-homepage: http://github.com/bos/base16-bytestring
-bug-reports: http://github.com/bos/base16-bytestring/issues
+description: This package provides support for encoding and decoding
binary data according
+ to @base16@ (see also
<https://tools.ietf.org/html/rfc4648 RFC 4648>) for
+ strict (see "Data.ByteString.Base16") and lazy
@ByteString@s (see "Data.ByteString.Base16.Lazy").
+ .
+ See also the
<https://hackage.haskell.org/package/base-encoding base-encoding> package which
+ provides an uniform API providing conversion paths
between more binary and textual types.
+homepage: http://github.com/haskell/base16-bytestring
+bug-reports: http://github.com/haskell/base16-bytestring/issues
license: BSD3
license-file: LICENSE
-copyright: Copyright 2011 MailRank, Inc.
+copyright: Copyright 2011 MailRank, Inc.;
+ Copyright 2010-2020 Bryan O'Sullivan et al.
author: Bryan O'Sullivan <[email protected]>
-maintainer: Bryan O'Sullivan <[email protected]>
-copyright: 2010 Bryan O'Sullivan
+maintainer: Herbert Valerio Riedel <[email protected]>,
+ Mikhail Glushenkov <[email protected]>,
+ Emily Pillmore <[email protected]>
category: Data
build-type: Simple
-extra-source-files: README.markdown
-
-Cabal-version: >=1.6
+extra-source-files: README.md CHANGELOG.md
+tested-with: GHC==8.10.1, GHC==8.8.3, GHC==8.6.5,
+ GHC==8.4.4, GHC==8.2.2, GHC==8.0.2,
+ GHC==7.10.3, GHC==7.8.4, GHC==7.6.3,
+ GHC==7.4.2, GHC==7.2.2, GHC==7.0.4
library
exposed-modules:
Data.ByteString.Base16
Data.ByteString.Base16.Lazy
-
+
build-depends:
base == 4.*,
bytestring >= 0.9,
ghc-prim
ghc-options: -Wall -funbox-strict-fields
- ghc-prof-options: -auto-all
+ default-language: Haskell2010
source-repository head
type: git
- location: http://github.com/bos/base16-bytestring
+ location: http://github.com/haskell/base16-bytestring
-source-repository head
- type: mercurial
- location: http://bitbucket.org/bos/base16-bytestring
+test-suite test
+ type: exitcode-stdio-1.0
+ hs-source-dirs: tests
+ main-is: Tests.hs
+ default-language: Haskell2010
+ build-depends: base
+ , base16-bytestring
+ , bytestring
diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn'
'--exclude=.svnignore' old/base16-bytestring-0.1.1.6/tests/Tests.hs
new/base16-bytestring-0.1.1.7/tests/Tests.hs
--- old/base16-bytestring-0.1.1.6/tests/Tests.hs 1970-01-01
01:00:00.000000000 +0100
+++ new/base16-bytestring-0.1.1.7/tests/Tests.hs 2001-09-09
03:46:40.000000000 +0200
@@ -0,0 +1,68 @@
+import Data.Char (ord)
+import Data.Word (Word8)
+import qualified Data.ByteString as B
+import qualified Data.ByteString.Lazy as BL
+import qualified Data.ByteString.Base16 as Base16
+import qualified Data.ByteString.Base16.Lazy as Base16L
+
+-- Three-line "test framework" for Haskell. Crude, but at least it tells you
+-- the line number of the failure without you having to specify it.
+shouldBe :: (Eq a, Show a) => a -> a -> IO Bool
+shouldBe a b = return (a == b)
+infix 0 `shouldBe`
+
+c2w :: Char -> Word8
+c2w = fromIntegral . ord
+
+main :: IO ()
+main = do
+ let hexL = map c2w "0123456789abcdef"
+ hexU = map c2w "0123456789ABCDEF"
+ hexUL = map c2w "0123456789ABCDEFabcdef"
+ notHex = [c | c <- [0..255], c `notElem` hexUL]
+ hexL2 = do a <- hexL; b <- hexL; [a,b]
+ hexU2 = do a <- hexU; b <- hexU; [a,b]
+ bytes = B.pack [0..255]
+
+ -- Encode every byte
+ True <- Base16.encode bytes `shouldBe` B.pack hexL2
+
+ -- Decode every valid hex pair
+ True <- Base16.decode (B.pack hexL2) `shouldBe` (bytes, B.empty)
+ True <- Base16.decode (B.pack hexU2) `shouldBe` (bytes, B.empty)
+
+ -- Decode every invalid byte paired with a correct byte
+ let bads1 = [B.pack [a,b] | a <- notHex, b <- hexUL]
+ let bads2 = [B.pack [a,b] | a <- hexUL, b <- notHex]
+ True <- map Base16.decode bads1 `shouldBe` map (\s -> (B.empty, s)) bads1
+ True <- map Base16.decode bads2 `shouldBe` map (\s -> (B.empty, s)) bads2
+
+ -- Like above, but start with a correct byte
+ let correctHex = B.pack [97,98]
+ correctBytes = B.pack [171]
+ True <- map (Base16.decode . (correctHex `B.append`)) bads1
+ `shouldBe` map (\s -> (correctBytes, s)) bads1
+ True <- map (Base16.decode . (correctHex `B.append`)) bads2
+ `shouldBe` map (\s -> (correctBytes, s)) bads2
+
+ -- Like above, but end with a correct byte
+ True <- map (Base16.decode . (`B.append` correctHex)) bads1
+ `shouldBe` map (\s -> (B.empty, s `B.append` correctHex)) bads1
+ True <- map (Base16.decode . (`B.append` correctHex)) bads2
+ `shouldBe` map (\s -> (B.empty, s `B.append` correctHex)) bads2
+
+ -- Lazy decoding also works with odd length chunks
+ let encodedLazy = BL.fromChunks $ map (B.pack . map c2w)
["614","239","6","142","39"]
+ True <- Base16L.decode encodedLazy `shouldBe` (BL.pack . map c2w $
"aB9aB9",BL.empty)
+
+ -- Lazy decoding is lazy on success
+ let encodedLazy = BL.iterate id 48
+ True <- (BL.unpack . BL.take 8 . fst . Base16L.decode $ encodedLazy)
+ `shouldBe` [0,0,0,0,0,0,0,0]
+
+ -- Lazy decoding is lazy on failure
+ let encodedLazy = BL.iterate id 47
+ True <- (BL.unpack . BL.take 8 . fst . Base16L.decode $ encodedLazy)
+ `shouldBe` []
+
+ return ()
