ci: add lint check

.github/workflows/lint.yml

@@ -0,0 +1,26 @@
+name: Lint
+
+on:
+  pull_request:
+  merge_group:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  nph:
+    name: NPH
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 2  # In PR, has extra merge commit: ^1 = PR, ^2 = base
+
+      - name: Check `nph` formatting
+        uses: arnetheduck/nph-action@v1
+        with:
+          version: 0.6.1
+          fail: true
+          suggest: true

quic.nimble

@@ -11,4 +11,4 @@ requires "nimcrypto >= 0.6.0 & < 0.7.0"
 requires "ngtcp2 >= 0.36.1"
 requires "unittest2"
 requires "chronicles >= 0.10.2"
-requires "bearssl >= 0.2.5"
+requires "bearssl >= 0.2.5"

quic/transport/framesorter.nim

@@ -2,12 +2,12 @@ import ../errors
 import std/[strformat, tables]
 import chronos
 
-type
-  FrameSorter* = object
-    buffer: Table[uint64, byte] # sparse byte storage
-    readPos: uint64 # where to emit data from
-    incoming: AsyncQueue[seq[byte]]
-    lastPos: Opt[uint64] # contains the index for the last position for a stream once a FIN is received
+type FrameSorter* = object
+  buffer: Table[uint64, byte] # sparse byte storage
+  readPos: uint64 # where to emit data from
+  incoming: AsyncQueue[seq[byte]]
+  lastPos: Opt[uint64]
+    # contains the index for the last position for a stream once a FIN is received
 
 proc initFrameSorter*(incoming: AsyncQueue[seq[byte]]): FrameSorter =
   result.incoming = incoming
@@ -49,4 +49,4 @@ proc isComplete*(fs: FrameSorter): bool =
   if fs.lastPos.isNone:
     return false
 
-  return  fs.readPos > fs.lastPos.get()
+  return fs.readPos > fs.lastPos.get()

quic/transport/ngtcp2/native.nim

@@ -23,4 +23,4 @@ export PicoTLSConnection
 export init
 export destroy
 export newConnection
-export certificateverifier
+export certificateverifier

quic/transport/ngtcp2/native/path.nim

@@ -25,6 +25,6 @@ proc newPath*(local, remote: TransportAddress): Path =
       addr_field: cast[ptr ngtcp2_sockaddr](p.remoteAddress.addr),
       addr_len: p.remoteAddrLen,
     ),
-    user_data: nil
+    user_data: nil,
   )
   p

quic/transport/version.nim

@@ -1,4 +1,5 @@
 #from pkg/ngtcp2 import NGTCP2_PROTO_VER_V2
 
 # V1
-const CurrentQuicVersion* =  cast[uint32](0x00000001u) # TODO: figure out how to export NGTCP2_PROTO_VER_V1 with futhark
+const CurrentQuicVersion* = cast[uint32](0x00000001u)
+  # TODO: figure out how to export NGTCP2_PROTO_VER_V1 with futhark

tests/helpers/simulation.nim

@@ -38,7 +38,8 @@ proc simulateLossyNetwork*(a, b: QuicConnection) {.async.} =
 
 proc setupConnection*(): Future[tuple[client, server: QuicConnection]] {.async.} =
   let rng = newRng()
-  let clientTLSBackend = newClientTLSBackend(@[], @[],toHashSet(@["test"]), Opt.none(CertificateVerifier))
+  let clientTLSBackend =
+    newClientTLSBackend(@[], @[], toHashSet(@["test"]), Opt.none(CertificateVerifier))
   let client = newQuicClientConnection(clientTLSBackend, zeroAddress, zeroAddress, rng)
 
   client.send() # Start Handshake

tests/quic/testExample.nim

@@ -10,21 +10,27 @@ import random
 suite "examples from Readme":
   test "outgoing and incoming connections":
     var message = newSeq[byte](50 * 1024) # 50kib
-    for i in 0..<message.len:
-      message[i] = rand(0'u8..255'u8)
+    for i in 0 ..< message.len:
+      message[i] = rand(0'u8 .. 255'u8)
 
     let alpn = @["test"]
     proc outgoing() {.async.} =
-      let cb = proc(serverName: string, derCertificates: seq[seq[byte]]): bool {.gcsafe.} =
+      let cb = proc(
+          serverName: string, derCertificates: seq[seq[byte]]
+      ): bool {.gcsafe.} =
         # TODO: implement custom certificate validation
         return derCertificates.len > 0
 
       let customCertVerif: CertificateVerifier = CustomCertificateVerifier.init(cb)
-      let tlsConfig =
-        TLSConfig.init(testCertificate(), testPrivateKey(), alpn, certificateVerifier = Opt.some(customCertVerif))
+      let tlsConfig = TLSConfig.init(
+        testCertificate(),
+        testPrivateKey(),
+        alpn,
+        certificateVerifier = Opt.some(customCertVerif),
+      )
       let client = QuicClient.init(tlsConfig)
       let connection = await client.dial(initTAddress("127.0.0.1:12345"))
-      
+
       check connection.certificates().len == 1
 
       let stream = await connection.openStream()
@@ -33,10 +39,14 @@ suite "examples from Readme":
       await connection.close()
 
     proc incoming() {.async.} =
-      let cb = proc(serverName: string, derCertificates: seq[seq[byte]]): bool {.gcsafe.} =
+      let cb = proc(
+          serverName: string, derCertificates: seq[seq[byte]]
+      ): bool {.gcsafe.} =
         return derCertificates.len > 0
       let customCertVerif: CertificateVerifier = CustomCertificateVerifier.init(cb)
-      let tlsConfig = TLSConfig.init(testCertificate(), testPrivateKey(), alpn,  Opt.some(customCertVerif))
+      let tlsConfig = TLSConfig.init(
+        testCertificate(), testPrivateKey(), alpn, Opt.some(customCertVerif)
+      )
       let server = QuicServer.init(tlsConfig)
       let listener = server.listen(initTAddress("127.0.0.1:12345"))
 

tests/quic/testPacketReading.nim

@@ -4,7 +4,6 @@ import pkg/quic/transport/packets
 import pkg/quic/helpers/bits
 
 suite "packet reading":
-
   var datagram: seq[byte]
 
   setup:
@@ -34,7 +33,7 @@ suite "packet reading":
 
   test "reads version negotiation packet":
     let length = datagram.write(versionNegotiationPacket())
-    check readPacket(datagram[0..<length]).kind == packetVersionNegotiation
+    check readPacket(datagram[0 ..< length]).kind == packetVersionNegotiation
 
   test "reads version":
     const version = 0xAABBCCDD'u32
@@ -58,22 +57,22 @@ suite "packet reading":
   test "reads supported versions in version negotiation packet":
     const versions = @[0xAABBCCDD'u32, 0x11223344'u32]
     let length = datagram.write(versionNegotiationPacket(versions = versions))
-    let packet = readPacket(datagram[0..<length])
+    let packet = readPacket(datagram[0 ..< length])
     check packet.negotiation.supportedVersions == versions
 
   test "reads token from retry packet":
     const token = @[1'u8, 2'u8, 3'u8]
     var packet = retryPacket()
     packet.retry.token = token
     let length = datagram.write(packet)
-    check readPacket(datagram[0..<length]).retry.token == token
+    check readPacket(datagram[0 ..< length]).retry.token == token
 
   test "reads integrity tag from retry packet":
     const integrity = repeat(0xA'u8, 16)
     var packet = retryPacket()
-    packet.retry.integrity[0..<16] = integrity
+    packet.retry.integrity[0 ..< 16] = integrity
     let length = datagram.write(packet)
-    check readPacket(datagram[0..<length]).retry.integrity == integrity
+    check readPacket(datagram[0 ..< length]).retry.integrity == integrity
 
   test "reads packet number from handshake packet":
     const packetnumber = 0xABCD
@@ -163,4 +162,4 @@ suite "packet reading":
     packet.short.payload = payload
     packet.destination = ConnectionId(repeat(0'u8, DefaultConnectionIdLength))
     let length = datagram.write(packet)
-    check readPacket(datagram[0..<length]).short.payload == payload
+    check readPacket(datagram[0 ..< length]).short.payload == payload