Commit `ac963099bc`

ac963099bc8d89a532fc833fbf2f5528cbc86b32

parent: fa307c5cb1

Verified · cmc

cmc <hello@cleberg.net> · 2026-10-14 07:44 UTC

Reply by mail on and off

Notifications gain Reply by mail where the instance reads replies, as
the account page shows it (reply_available, krz/gitbay#334); a server
that does not say offers it, and its refusal explains.

The account's switches go back when the server refuses a change rather
than showing what it refused: SettingToggle takes a write that says
whether it was accepted. Settings screens whose writes do not say keep
the reload's word, as before.

Closes #33

Layout: unified · split

gitbay/Account/AccountViewModel.swift +35 −5

     /// repositories it can write to (v1.19.0); nil until read, or on a
     /// server whose `show` has no `watch`.
     private(set) var watchOn: Bool?
+    /// Whether replying to notification mail comments (gitbay v1.39.0).
+    private(set) var replyOn: Bool?
+    private var replyAvailable: Bool?
     /// The account's addresses; nil until read, or on a server without
     /// `email list`.
     private(set) var emails: [EmailAddress]?
     nonisolated private struct NotificationSettings: Decodable, Sendable {
         let mail: Bool
         let watch: Bool?
+        let reply: Bool?
+        let replyAvailable: Bool?
+        enum CodingKeys: String, CodingKey {
+            case mail, watch, reply
+            case replyAvailable = "reply_available"
+        }
     }
     func loadNotificationPreferences() async {
             ["notifications", "settings", "show"], as: NotificationSettings.self)
         mailOn = settings?.mail
         watchOn = settings?.watch
+        replyOn = settings?.reply
+        replyAvailable = settings?.replyAvailable
+    }
+    /// The reply switch, offered where the instance reads replies to its
+    /// mail (krz/gitbay#334). A server that does not say is offered it,
+    /// and its refusal explains.
+    var offersReply: Bool { replyOn != nil && replyAvailable != false }
+    /// `notifications settings reply on|off`: issue and merge request mail
+    /// carries a Reply-To, and a reply is posted as a comment.
+    @discardableResult
+    func setReply(_ on: Bool) async -> Bool {
+        return await setPreference("reply", on)
     }
     /// `notifications settings mail on|off`, then read the value back.
-    func setMail(_ on: Bool) async {
+    @discardableResult
-        await setPreference("mail", on)
+    func setMail(_ on: Bool) async -> Bool {
+        return await setPreference("mail", on)
     }
     /// `notifications settings watch on|off`, then read the value back.
-    func setWatch(_ on: Bool) async {
+    @discardableResult
-        await setPreference("watch", on)
+    func setWatch(_ on: Bool) async -> Bool {
+        return await setPreference("watch", on)
     }
-    private func setPreference(_ name: String, _ on: Bool) async {
+    /// Whether the server took the change, so the switch can go back when
+    /// it did not.
+    private func setPreference(_ name: String, _ on: Bool) async -> Bool {
         working = true
         actionError = nil
         defer { working = false }
         do {
             try await client.run(["notifications", "settings", name, on ? "on" : "off"])
             await loadNotificationPreferences()
+            return true
         } catch let error as GitbayError {
             actionError = error.userFacingMessage
         } catch {
             actionError = GitbayError.transport(error).userFacingMessage
         }
+        return false
     }
     // MARK: - SSH keys

gitbay/Views/Account/AccountView.swift +12 −5

     private var notificationsSection: some View {
         if let mailOn = model.mailOn {
             Section {
-                SettingToggle(title: "Activity by mail", serverValue: mailOn) {
+                SettingToggle(title: "Activity by mail", serverValue: mailOn, accepted: {
                     await model.setMail($0)
-                }
+                })
                 .disabled(model.working)
                 if let watchOn = model.watchOn {
-                    SettingToggle(title: "Watch writable repositories", serverValue: watchOn) {
+                    SettingToggle(title: "Watch writable repositories", serverValue: watchOn, accepted: {
                         await model.setWatch($0)
-                    }
+                    })
+                    .disabled(model.working)
+                }
+                if model.offersReply, let replyOn = model.replyOn {
+                    SettingToggle(title: "Reply by mail", serverValue: replyOn, accepted: {
+                        await model.setReply($0)
+                    })
                     .disabled(model.working)
                 }
             } header: {
                 Text("Notifications")
             } footer: {
-                Text("Mail off keeps the inbox and stops the mail; login links are not activity and still arrive. Watching makes you a recipient of every issue and merge request on repositories you can write to.")
+                Text("Mail off keeps the inbox and stops the mail; login links are not activity and still arrive. Watching makes you a recipient of every issue and merge request on repositories you can write to."
+                     + (model.offersReply ? " With reply by mail, answering issue and merge request mail from a verified address posts your reply as a comment." : ""))
             }
         }
     }

gitbay/Views/Repos/RepoSettingsView.swift +20 −2

 /// A Toggle backed by real local state that mirrors the server value.
 /// A computed Binding whose setter spawns a Task proved unreliable under
 /// synthesized taps; a plain @State toggle is not.
+///
+/// A write that says whether the server took it lets the switch go back
+/// when it did not, rather than showing what was refused. A write that
+/// says nothing is taken as accepted, and the reload decides.
 struct SettingToggle: View {
     let title: String
     let serverValue: Bool
-    let write: (Bool) async -> Void
+    let write: (Bool) async -> Bool
     @State private var isOn = false
     @State private var seeded = false
+    init(title: String, serverValue: Bool, write: @escaping (Bool) async -> Void) {
+        self.title = title
+        self.serverValue = serverValue
+        self.write = { await write($0); return true }
+    }
+    init(title: String, serverValue: Bool, accepted write: @escaping (Bool) async -> Bool) {
+        self.title = title
+        self.serverValue = serverValue
+        self.write = write
+    }
     var body: some View {
         Toggle(title, isOn: $isOn)
             .onAppear {
             }
             .onChange(of: isOn) { _, newValue in
                 guard newValue != serverValue else { return }
-                Task { await write(newValue) }
+                Task {
+                    if !(await write(newValue)) { isOn = !newValue }
+                }
             }
     }
 }

gitbayTests/ReplyByMailTests.swift added +68

@@ -0,0 +1,68 @@
	1	import Foundation
	2	import Testing
	3	@testable import gitbay
	4
	5	private func makeClient() throws -> (GitbayClient, StubProtocol.Box) {
	6	let box = StubProtocol.box()
	7	let client = GitbayClient(
	8	instance: try GitbayInstance(url: "https://gitbay.org"),
	9	token: "test-token",
	10	session: box.session()
	11	)
	12	return (client, box)
	13	}
	14
	15	private func show(_ fields: String) -> String {
	16	#"{"protocol_version":1,"data":{"mail":true,"watch":false,"# + fields + #"},"exit_code":0}"#
	17	}
	18
	19	@MainActor
	20	struct ReplyByMailTests {
	21
	22	@Test func theSwitchShowsWhereTheInstanceReadsReplies() async throws {
	23	let (client, stub) = try makeClient()
	24	stub.enqueue(.init(status: 200, json: show(#""reply":false,"reply_available":true"#), match: "argv=show"))
	25	let model = AccountViewModel(client: client)
	26
	27	await model.loadNotificationPreferences()
	28
	29	#expect(model.replyOn == false)
	30	#expect(model.offersReply)
	31	}
	32
	33	@Test func noSwitchWhereTheInstanceDoesNot() async throws {
	34	let (client, stub) = try makeClient()
	35	stub.enqueue(.init(status: 200, json: show(#""reply":false,"reply_available":false"#), match: "argv=show"))
	36	let model = AccountViewModel(client: client)
	37
	38	await model.loadNotificationPreferences()
	39
	40	#expect(!model.offersReply)
	41	}
	42
	43	/// A server without reply_available says nothing either way: the
	44	/// switch shows, and the refusal explains if it cannot be turned on.
	45	@Test func anOlderServerShowsTheSwitch() async throws {
	46	let (client, stub) = try makeClient()
	47	stub.enqueue(.init(status: 200, json: show(#""reply":false"#), match: "argv=show"))
	48	let model = AccountViewModel(client: client)
	49
	50	await model.loadNotificationPreferences()
	51
	52	#expect(model.offersReply)
	53	}
	54
	55	@Test func turningItOnSendsReplyOn() async throws {
	56	let (client, stub) = try makeClient()
	57	stub.enqueue(.init(status: 200, json: #"{"protocol_version":1,"data":{},"exit_code":0}"#, match: "cmd"))
	58	stub.enqueue(.init(status: 200, json: show(#""reply":true,"reply_available":true"#), match: "argv=show"))
	59	let model = AccountViewModel(client: client)
	60
	61	await model.setReply(true)
	62
	63	let write = try #require(stub.seen.first { $0.method == "POST" })
	64	let body = try #require(try JSONSerialization.jsonObject(with: write.body) as? [String: Any])
	65	#expect(body["argv"] as? [String] == ["notifications", "settings", "reply", "on"])
	66	#expect(model.replyOn == true)
	67	}
	68	}

Commit ac963099bc

Commit `ac963099bc`