Prepare 0.1.1.1 release

Reformatted.
Added workflows.
Updated package metadata.

Author: brianjosephmckeon

.github/CODEOWNERS

@@ -0,0 +1 @@
+@byteverse/l3c

.github/workflows/build.yaml

@@ -0,0 +1,12 @@
+name: build
+on:
+  pull_request:
+    branches:
+      - "*"
+
+jobs:
+  call-workflow:
+    uses: byteverse/.github/.github/workflows/build.yaml@main
+    secrets: inherit
+    with:
+      release: false

.github/workflows/release.yaml

@@ -0,0 +1,12 @@
+name: release
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  call-workflow:
+    uses: byteverse/.github/.github/workflows/build.yaml@main
+    secrets: inherit
+    with:
+      release: true

.gitignore

@@ -1,3 +1,4 @@
+.vscode/
 dist
 dist-*
 cabal-dev

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Revision history for base64-bytes
 
+## 0.1.1.1 -- 2024-02-01
+
+* Update package metadata.
+
 ## 0.1.1.0 -- 2022-12-07
 
 * Support GHC 9.2

Main.hs

@@ -1,62 +1,71 @@
-cabal-version: 2.2
-name: base64-bytes
-version: 0.1.1.0
-synopsis: Base64 encoding of byte sequences
-homepage: https://github.com/andrewthad/base64-bytes
-bug-reports: https://github.com/andrewthad/base64-bytes/issues
-license: BSD-3-Clause
-license-file: LICENSE
-author: Andrew Martin
-maintainer: [email protected]
-copyright: 2019 Andrew Martin
-category: Data
-build-type: Simple
-extra-source-files: CHANGELOG.md
+cabal-version:   2.2
+name:            base64-bytes
+version:         0.1.1.1
+synopsis:        Base64 encoding of byte sequences
+description:     Base64 encoding of byte sequences.
+homepage:        https://github.com/byteverse/base64-bytes
+bug-reports:     https://github.com/byteverse/base64-bytes/issues
+license:         BSD-3-Clause
+license-file:    LICENSE
+author:          Andrew Martin
+maintainer:      [email protected]
+copyright:       2019 Andrew Martin
+category:        Data
+build-type:      Simple
+extra-doc-files: CHANGELOG.md
 
 library
   exposed-modules:
     Data.Bytes.Base64
     Data.Bytes.Base64.Url
+
   build-depends:
-    , base >=4.12 && <5
-    , primitive >=0.7 && <0.10
-    , byte-order >=0.1.1 && <0.2
-    , byteslice >=0.1.4 && <0.3
-    , run-st >=0.1 && <0.2
-    , bytebuild >=0.3.4 && <0.4
-    , natural-arithmetic >=0.1.1 && <0.2
-    , word-compat >=0.0.4
-  hs-source-dirs: src
+    , base                >=4.12  && <5
+    , byte-order          >=0.1.1 && <0.2
+    , bytebuild           >=0.3.4 && <0.4
+    , byteslice           >=0.1.4 && <0.3
+    , natural-arithmetic  >=0.1.1 && <0.2
+    , primitive           >=0.7   && <0.10
+    , run-st              >=0.1   && <0.2
+    , word-compat         >=0.0.4 && <0.1
+
+  hs-source-dirs:   src
   default-language: Haskell2010
-  ghc-options: -Wall -O2
+  ghc-options:      -Wall -O2
 
 test-suite test
-  Default-Language: Haskell2010
-  hs-source-dirs: test
-  main-is: Main.hs
-  type: exitcode-stdio-1.0
+  default-language: Haskell2010
+  hs-source-dirs:   test
+  main-is:          Main.hs
+  type:             exitcode-stdio-1.0
   build-depends:
     , base
     , base64-bytes
-    , natural-arithmetic >=0.1.1
     , bytebuild
+    , byteslice           >=0.1.4.0
+    , natural-arithmetic  >=0.1.1
     , primitive
-    , byteslice >=0.1.4.0
-  ghc-options: -O2 -Wall
+
+  ghc-options:      -O2 -Wall
 
 benchmark bench
-  type: exitcode-stdio-1.0
+  type:             exitcode-stdio-1.0
   build-depends:
     , base
+    , base64             >=0.3
     , base64-bytes
+    , base64-bytestring
     , byteslice
     , bytestring
     , gauge
     , primitive
-    , base64-bytestring
-    , base64 >=0.3
-    , random >=1.1
-  ghc-options: -Wall -O2
+    , random             >=1.1
+
+  ghc-options:      -Wall -O2
   default-language: Haskell2010
-  hs-source-dirs: bench
-  main-is: Main.hs
+  hs-source-dirs:   bench
+  main-is:          Main.hs
+
+source-repository head
+  type:     git
+  location: git://github.com/byteverse/base64-bytes.git

Setup.hs

@@ -1,62 +1,67 @@
-{-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE BlockArguments #-}
 {-# LANGUAGE MagicHash #-}
-{-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE PackageImports #-}
 
 import Control.Monad.ST (runST)
-import System.Random (mkStdGen,randoms)
-import Data.Primitive (ByteArray(ByteArray),unsafeFreezeByteArray)
-import Data.Primitive (copyByteArray,newPinnedByteArray)
-import Gauge.Main (defaultMain,bgroup,bench,whnf)
-import Data.ByteString.Internal (ByteString(PS))
+import Data.ByteString.Internal (ByteString (PS))
+import Data.Primitive (ByteArray (ByteArray), copyByteArray, newPinnedByteArray, unsafeFreezeByteArray)
+import Gauge.Main (bench, bgroup, defaultMain, whnf)
+import System.Random (mkStdGen, randoms)
 
 import qualified Data.Bytes as Bytes
 import qualified Data.Bytes.Base64 as Base64
 import qualified Data.List as List
 import qualified GHC.Exts as Exts
 import qualified GHC.ForeignPtr as Exts
 
-import qualified "base64-bytestring" Data.ByteString.Base64 as BS
 import qualified "base64" Data.ByteString.Base64 as B64
+import qualified "base64-bytestring" Data.ByteString.Base64 as BS
 
 main :: IO ()
-main = defaultMain
-  [ bgroup "encode"
-    [ bgroup "base64-bytes"
-      [ bench "100" $
-          whnf (\x -> Base64.encode (Bytes.fromByteArray x)) str100
-      , bench "1000" $
-          whnf (\x -> Base64.encode (Bytes.fromByteArray x)) str1000
-      , bench "10000" $
-          whnf (\x -> Base64.encode (Bytes.fromByteArray x)) str10000
-      ]
-    , bgroup "base64-bytestring"
-      [ bench "100" $
-          whnf (\x -> BS.encode (byteArrayToByteString 100 x)) str100
-      , bench "1000" $
-          whnf (\x -> BS.encode (byteArrayToByteString 1000 x)) str1000
-      , bench "10000" $
-          whnf (\x -> BS.encode (byteArrayToByteString 10000 x)) str10000
-      ]
-    , bgroup "base64"
-      [ bench "100" $
-          whnf (\x -> B64.encodeBase64' (byteArrayToByteString 100 x)) str100
-      , bench "1000" $
-          whnf (\x -> B64.encodeBase64' (byteArrayToByteString 1000 x)) str1000
-      , bench "10000" $
-          whnf (\x -> B64.encodeBase64' (byteArrayToByteString 10000 x)) str10000
-      ]
+main =
+  defaultMain
+    [ bgroup
+        "encode"
+        [ bgroup
+            "base64-bytes"
+            [ bench "100" $
+                whnf (\x -> Base64.encode (Bytes.fromByteArray x)) str100
+            , bench "1000" $
+                whnf (\x -> Base64.encode (Bytes.fromByteArray x)) str1000
+            , bench "10000" $
+                whnf (\x -> Base64.encode (Bytes.fromByteArray x)) str10000
+            ]
+        , bgroup
+            "base64-bytestring"
+            [ bench "100" $
+                whnf (\x -> BS.encode (byteArrayToByteString 100 x)) str100
+            , bench "1000" $
+                whnf (\x -> BS.encode (byteArrayToByteString 1000 x)) str1000
+            , bench "10000" $
+                whnf (\x -> BS.encode (byteArrayToByteString 10000 x)) str10000
+            ]
+        , bgroup
+            "base64"
+            [ bench "100" $
+                whnf (\x -> B64.encodeBase64' (byteArrayToByteString 100 x)) str100
+            , bench "1000" $
+                whnf (\x -> B64.encodeBase64' (byteArrayToByteString 1000 x)) str1000
+            , bench "10000" $
+                whnf (\x -> B64.encodeBase64' (byteArrayToByteString 10000 x)) str10000
+            ]
+        ]
     ]
-  ]
 
 byteArrayToByteString :: Int -> ByteArray -> ByteString
-{-# inline byteArrayToByteString #-}
-byteArrayToByteString len (ByteArray x) = PS
-  ( Exts.ForeignPtr
-    (Exts.byteArrayContents# x)
-    (Exts.PlainPtr (Exts.unsafeCoerce# x))
-  ) 0 len
+{-# INLINE byteArrayToByteString #-}
+byteArrayToByteString len (ByteArray x) =
+  PS
+    ( Exts.ForeignPtr
+        (Exts.byteArrayContents# x)
+        (Exts.PlainPtr (Exts.unsafeCoerce# x))
+    )
+    0
+    len
 
 str100 :: ByteArray
 {-# NOINLINE str100 #-}

base64-bytes.cabal

@@ -0,0 +1,51 @@
+# Number of spaces per indentation step
+indentation: 2
+
+# Max line length for automatic line breaking
+column-limit: 200
+
+# Styling of arrows in type signatures (choices: trailing, leading, or leading-args)
+function-arrows: trailing
+
+# How to place commas in multi-line lists, records, etc. (choices: leading or trailing)
+comma-style: leading
+
+# Styling of import/export lists (choices: leading, trailing, or diff-friendly)
+import-export-style: leading
+
+# Whether to full-indent or half-indent 'where' bindings past the preceding body
+indent-wheres: false
+
+# Whether to leave a space before an opening record brace
+record-brace-space: true
+
+# Number of spaces between top-level declarations
+newlines-between-decls: 1
+
+# How to print Haddock comments (choices: single-line, multi-line, or multi-line-compact)
+haddock-style: multi-line
+
+# How to print module docstring
+haddock-style-module: null
+
+# Styling of let blocks (choices: auto, inline, newline, or mixed)
+let-style: auto
+
+# How to align the 'in' keyword with respect to the 'let' keyword (choices: left-align, right-align, or no-space)
+in-style: right-align
+
+# Whether to put parentheses around a single constraint (choices: auto, always, or never)
+single-constraint-parens: always
+
+# Output Unicode syntax (choices: detect, always, or never)
+unicode: never
+
+# Give the programmer more choice on where to insert blank lines
+respectful: true
+
+# Fixity information for operators
+fixities: []
+
+# Module reexports Fourmolu should know about
+reexports: []
+