chore: use pre-commit-gleam for gleam hooks

Author: jtdowney

.pre-commit-config.yaml

@@ -12,17 +12,8 @@ repos:
         exclude: ^birdie_snapshots/.*\.accepted$
       - id: trailing-whitespace
         exclude: ^birdie_snapshots/.*\.accepted$
-  - repo: local
+  - repo: https://github.com/jtdowney/pre-commit-gleam
+    rev: v1.0.0
     hooks:
-      - id: gleam-check
-        name: gleam check
-        entry: gleam check
-        language: system
-        files: ^src/.*\.gleam$
-        pass_filenames: false
-      - id: gleam-format
-        name: gleam format --check
-        entry: gleam format --check src test
-        language: system
-        files: ^src/.*\.gleam$
-        pass_filenames: false
+      - id: format
+      - id: check

dev/cose/encrypt_examples.gleam

@@ -41,8 +41,7 @@ fn direct_encryption() {
 
   // Decrypt
   let assert Ok(parsed) = encrypt.parse(data)
-  let assert Ok(dec) =
-    encrypt.decryptor(gose.Direct, content_alg, keys: [k])
+  let assert Ok(dec) = encrypt.decryptor(gose.Direct, content_alg, keys: [k])
   let assert Ok(pt) = encrypt.decrypt(dec, parsed)
   let assert Ok(text) = bit_array.to_string(pt)
   io.println("Decrypted: " <> text)
@@ -116,8 +115,7 @@ fn multi_recipient() {
 
   // Encrypt
   let assert Ok(message) = encrypt.new(content_alg)
-  let assert Ok(aes_r) =
-    encrypt.new_aes_kw_recipient(gose.Aes128, key: aes_key)
+  let assert Ok(aes_r) = encrypt.new_aes_kw_recipient(gose.Aes128, key: aes_key)
   let assert Ok(ec_r) =
     encrypt.new_ecdh_es_aes_kw_recipient(gose.Aes128, key: ec_key)
   let message =

dev/jose/jwe_examples.gleam

@@ -221,13 +221,9 @@ fn ecdh_es_direct() {
   // Decrypt
   let assert Ok(parsed) = jwe.parse_compact(token)
   let assert Ok(decryptor) =
-    jwe.key_decryptor(
-      gose.EcdhEs(gose.EcdhEsDirect),
-      gose.AesGcm(gose.Aes256),
-      [
-        key,
-      ],
-    )
+    jwe.key_decryptor(gose.EcdhEs(gose.EcdhEsDirect), gose.AesGcm(gose.Aes256), [
+      key,
+    ])
   let assert Ok(decrypted) = jwe.decrypt(decryptor, parsed)
   let assert Ok(message) = bit_array.to_string(decrypted)
   io.println("Decrypted: " <> message)
@@ -242,10 +238,7 @@ fn ecdh_es_with_key_wrap() {
 
   // Encrypt
   let assert Ok(token) =
-    jwe.new_ecdh_es(
-      gose.EcdhEsAesKw(gose.Aes256),
-      gose.AesGcm(gose.Aes256),
-    )
+    jwe.new_ecdh_es(gose.EcdhEsAesKw(gose.Aes256), gose.AesGcm(gose.Aes256))
     |> jwe.with_apu(<<"Alice":utf8>>)
     |> jwe.with_apv(<<"Bob":utf8>>)
     |> jwe.encrypt(key, plaintext)
@@ -276,10 +269,7 @@ fn password_based_encryption() {
 
   // Encrypt
   let assert Ok(token) =
-    jwe.new_pbes2(
-      gose.Pbes2Sha256Aes128Kw,
-      gose.AesGcm(gose.Aes128),
-    )
+    jwe.new_pbes2(gose.Pbes2Sha256Aes128Kw, gose.AesGcm(gose.Aes128))
     |> jwe.with_p2c(1000)
     |> result.try(jwe.encrypt_with_password(_, password, plaintext))
     |> result.try(jwe.serialize_compact)

dev/jose/jwe_multi_examples.gleam

@@ -53,21 +53,17 @@ fn two_aes_kw_recipients() {
   let assert Ok(parsed) = jwe_multi.parse_json(json_str)
 
   let assert Ok(dec) =
-    jwe_multi.decryptor(
-      gose.AesKeyWrap(gose.AesKw, gose.Aes256),
-      enc,
-      keys: [k1],
-    )
+    jwe_multi.decryptor(gose.AesKeyWrap(gose.AesKw, gose.Aes256), enc, keys: [
+      k1,
+    ])
   let assert Ok(pt) = jwe_multi.decrypt(dec, parsed)
   let assert Ok(text) = bit_array.to_string(pt)
   io.println("Recipient 1 decrypted: " <> text)
 
   let assert Ok(dec) =
-    jwe_multi.decryptor(
-      gose.AesKeyWrap(gose.AesKw, gose.Aes128),
-      enc,
-      keys: [k2],
-    )
+    jwe_multi.decryptor(gose.AesKeyWrap(gose.AesKw, gose.Aes128), enc, keys: [
+      k2,
+    ])
   let assert Ok(pt) = jwe_multi.decrypt(dec, parsed)
   let assert Ok(text) = bit_array.to_string(pt)
   io.println("Recipient 2 decrypted: " <> text)
@@ -129,11 +125,9 @@ fn mixed_recipients() {
   let assert Ok(parsed) = jwe_multi.parse_json(json_str)
 
   let assert Ok(dec) =
-    jwe_multi.decryptor(
-      gose.AesKeyWrap(gose.AesKw, gose.Aes256),
-      enc,
-      keys: [aes_key],
-    )
+    jwe_multi.decryptor(gose.AesKeyWrap(gose.AesKw, gose.Aes256), enc, keys: [
+      aes_key,
+    ])
   let assert Ok(pt) = jwe_multi.decrypt(dec, parsed)
   let assert Ok(text) = bit_array.to_string(pt)
   io.println("AES-KW recipient decrypted: " <> text)

dev/jose/jwk_examples.gleam

@@ -346,10 +346,7 @@ fn encrypted_jwk_export() {
   let plaintext = bit_array.from_string(json.to_string(key_json))
 
   let assert Ok(encrypted) =
-    jwe.new_pbes2(
-      gose.Pbes2Sha256Aes128Kw,
-      gose.AesGcm(gose.Aes256),
-    )
+    jwe.new_pbes2(gose.Pbes2Sha256Aes128Kw, gose.AesGcm(gose.Aes256))
     |> jwe.with_cty("jwk+json")
     |> jwe.with_p2c(1000)
     |> result.try(jwe.encrypt_with_password(_, "my-secure-password", plaintext))

dev/jose/jws_examples.gleam

@@ -58,9 +58,7 @@ fn rsa_signing() {
 
   // Sign
   let assert Ok(token) =
-    jws.new(
-      gose.DigitalSignature(gose.RsaPkcs1(gose.RsaPkcs1Sha256)),
-    )
+    jws.new(gose.DigitalSignature(gose.RsaPkcs1(gose.RsaPkcs1Sha256)))
     |> jws.with_kid("rsa-key-001")
     |> jws.sign(key, payload)
     |> result.try(jws.serialize_compact)
@@ -72,10 +70,9 @@ fn rsa_signing() {
   let assert Ok(pub_key) = gose.public_key(key)
   let assert Ok(parsed) = jws.parse_compact(token)
   let assert Ok(verifier) =
-    jws.verifier(
-      gose.DigitalSignature(gose.RsaPkcs1(gose.RsaPkcs1Sha256)),
-      [pub_key],
-    )
+    jws.verifier(gose.DigitalSignature(gose.RsaPkcs1(gose.RsaPkcs1Sha256)), [
+      pub_key,
+    ])
   let assert Ok(Nil) = jws.verify(verifier, parsed)
   io.println("Verified with public key")
   io.println("")
@@ -99,12 +96,9 @@ fn ecdsa_signing() {
   // Verify
   let assert Ok(parsed) = jws.parse_compact(token)
   let assert Ok(verifier) =
-    jws.verifier(
-      gose.DigitalSignature(gose.Ecdsa(gose.EcdsaP256)),
-      [
-        key,
-      ],
-    )
+    jws.verifier(gose.DigitalSignature(gose.Ecdsa(gose.EcdsaP256)), [
+      key,
+    ])
   let assert Ok(Nil) = jws.verify(verifier, parsed)
   io.println("Signature verified")
   io.println("")

dev/jose/jws_multi_examples.gleam

@@ -50,10 +50,9 @@ fn two_signers() {
   let assert Ok(parsed) = jws_multi.parse_json(json_str)
 
   let assert Ok(ec_verifier) =
-    jws_multi.verifier(
-      gose.DigitalSignature(gose.Ecdsa(gose.EcdsaP256)),
-      keys: [ec_key],
-    )
+    jws_multi.verifier(gose.DigitalSignature(gose.Ecdsa(gose.EcdsaP256)), keys: [
+      ec_key,
+    ])
   let assert Ok(Nil) = jws_multi.verify(ec_verifier, parsed)
   io.println("ES256 signature verified")
 
@@ -78,21 +77,15 @@ fn single_signer_json() {
 
   let assert Ok(body) =
     jws_multi.new(payload:)
-    |> jws_multi.sign(
-      gose.Mac(gose.Hmac(gose.HmacSha256)),
-      key: hmac_key,
-    )
+    |> jws_multi.sign(gose.Mac(gose.Hmac(gose.HmacSha256)), key: hmac_key)
   let message = jws_multi.assemble(body)
 
   let json_str = jws_multi.serialize_json(message) |> json.to_string
   io.println("JWS JSON: " <> json_str)
 
   let assert Ok(parsed) = jws_multi.parse_json(json_str)
   let assert Ok(verifier) =
-    jws_multi.verifier(
-      gose.Mac(gose.Hmac(gose.HmacSha256)),
-      keys: [hmac_key],
-    )
+    jws_multi.verifier(gose.Mac(gose.Hmac(gose.HmacSha256)), keys: [hmac_key])
   let assert Ok(Nil) = jws_multi.verify(verifier, parsed)
   io.println("HMAC signature verified")
   io.println("")

dev/jose/jwt_examples.gleam

@@ -189,11 +189,7 @@ fn key_rotation() {
 
   // Sign
   let assert Ok(signed) =
-    jwt.sign(
-      gose.Mac(gose.Hmac(gose.HmacSha256)),
-      claims,
-      old_key,
-    )
+    jwt.sign(gose.Mac(gose.Hmac(gose.HmacSha256)), claims, old_key)
 
   let token = jwt.serialize(signed)
 
@@ -242,11 +238,7 @@ fn validation_options() {
     )
 
   let assert Ok(verifier) =
-    jwt.verifier(
-      gose.Mac(gose.Hmac(gose.HmacSha256)),
-      [key],
-      options,
-    )
+    jwt.verifier(gose.Mac(gose.Hmac(gose.HmacSha256)), [key], options)
   let assert Ok(verified) = jwt.verify_and_validate(verifier, token, now)
 
   let decoder = {
@@ -554,11 +546,7 @@ fn dangerous_escape_hatches() {
     |> jwt.with_subject("user-42")
     |> jwt.with_expiration(past)
   let assert Ok(signed) =
-    jwt.sign(
-      gose.Mac(gose.Hmac(gose.HmacSha256)),
-      claims:,
-      key: k,
-    )
+    jwt.sign(gose.Mac(gose.Hmac(gose.HmacSha256)), claims:, key: k)
   let token = jwt.serialize(signed)
 
   // Inspect claims BEFORE any verification happens. Never trust these values

dev/jose/nested_jwt_examples.gleam

@@ -58,11 +58,7 @@ fn nested_jwt_symmetric() {
     |> jwt.with_expiration(exp)
 
   let assert Ok(signed_jwt) =
-    jwt.sign(
-      gose.Mac(gose.Hmac(gose.HmacSha256)),
-      claims,
-      signing_key,
-    )
+    jwt.sign(gose.Mac(gose.Hmac(gose.HmacSha256)), claims, signing_key)
   let inner_token = jwt.serialize(signed_jwt)
   io.println("Inner signed JWT created")
 
@@ -161,13 +157,9 @@ fn nested_jwt_asymmetric() {
   // Recipient: decrypt with private key
   let assert Ok(parsed_jwe) = jwe.parse_compact(nested_token)
   let assert Ok(decryptor) =
-    jwe.key_decryptor(
-      gose.EcdhEs(gose.EcdhEsDirect),
-      gose.AesGcm(gose.Aes256),
-      [
-        recipient_encryption_key,
-      ],
-    )
+    jwe.key_decryptor(gose.EcdhEs(gose.EcdhEsDirect), gose.AesGcm(gose.Aes256), [
+      recipient_encryption_key,
+    ])
   let assert Ok(inner_bits) = jwe.decrypt(decryptor, parsed_jwe)
   let assert Ok(decrypted_inner_token) = bit_array.to_string(inner_bits)