Plural command: update query for plural command and add plural annotation

Author: catreedle

Keyboards/DataManager/LanguageDBManager.swift

@@ -97,16 +97,22 @@ class LanguageDBManager {
   ///   - query: the query to run against the language database.
   ///   - outputCols: the columns from which the values should come.
   ///   - args: arguments to pass to `query`.
-  private func queryDBRows(query: String, outputCols _: [String], args: StatementArguments) -> [String] {
+  private func queryDBRows(query: String, outputCols: [String], args: StatementArguments) -> [String] {
     var outputValues = [String]()
     do {
       guard let languageDB = database else { return [] }
       let rows = try languageDB.read { db in
         try Row.fetchAll(db, sql: query, arguments: args)
       }
       for r in rows {
-        outputValues.append(r["word"])
-      }
+        // Loop through all columns.
+        for col in outputCols {
+            if let value = r[col] as? String,
+                   !value.trimmingCharacters(in: .whitespaces).isEmpty {
+                    outputValues.append(value)
+                }
+            }
+        }
     } catch let error as DatabaseError {
       let errorMessage = error.message
       let errorSQL = error.sql
@@ -301,20 +307,47 @@ extension LanguageDBManager {
 
   /// Query the plural form of word in `nouns`.
   func queryNounPlural(of word: String) -> [String] {
-    let query = """
-    SELECT
-      *
+    let language = getControllerLanguageAbbr()
+    let contract = ContractManager.shared.loadContract(language: language)
 
-    FROM
-      nouns
+    let queryInfos = PluralManager.shared.buildPluralQuery(
+      word: word,
+      contract: contract
+    )
 
-    WHERE
-      noun = ?
-    """
-    let outputCols = ["plural"]
-    let args = [word]
+    // Try each query until we find a result.
+    for queryInfo in queryInfos {
+      let result = queryDBRow(
+        query: queryInfo.query,
+        outputCols: queryInfo.outputCols,
+        args: StatementArguments(queryInfo.args)
+      )
 
-    return queryDBRow(query: query, outputCols: outputCols, args: StatementArguments(args))
+      // If we found a result, return it.
+      if result.count >= 2 && !result[1].isEmpty {
+        return [result[1]]
+      }
+    }
+
+    return []
+  }
+
+  /// Query all plural forms for the current language.
+  func queryAllPluralForms() -> [String]? {
+    let language = getControllerLanguageAbbr()
+    let contract = ContractManager.shared.loadContract(language: language)
+
+    guard let queryInfo = PluralManager.shared.buildAllPluralsQuery(contract: contract) else {
+      return nil
+    }
+
+    let result = queryDBRows(
+      query: queryInfo.query,
+      outputCols: queryInfo.outputCols,
+      args: StatementArguments()
+    )
+
+    return result == [""] ? nil : result
   }
 
   /// Query preposition form of word in `prepositions`.

Keyboards/DataManager/PluralManager.swift

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+import Foundation
+
+/// Manages plural query logic based on data contracts
+class PluralManager {
+  static let shared = PluralManager()
+
+  private init() {}
+
+  struct PluralQueryInfo {
+    let query: String
+    let outputCols: [String]
+    let args: [String]
+  }
+
+  /**Builds a query to find the plural form of a word based on the contract structure
+   - Parameters:
+   - word: The singular word to find the plural for
+   - contract: The data contract defining the database structure
+   - Returns: Query info to execute, or nil if contract is invalid
+   */
+  func buildPluralQuery(word: String, contract: DataContract?) -> [PluralQueryInfo] {  // ← Return array!
+    guard let contract = contract,
+          let numbers = contract.numbers,
+          !numbers.isEmpty else {
+      NSLog("PluralManager: No valid plural columns in contract")
+      return []
+    }
+
+    var queries: [PluralQueryInfo] = []
+
+    // Build a query for EACH singular/plural pair
+    for (singularCol, pluralCol) in numbers {
+      let query = """
+            SELECT `\(singularCol)`, `\(pluralCol)`
+            FROM nouns
+            WHERE `\(singularCol)` = ? COLLATE NOCASE
+            """
+
+      queries.append(PluralQueryInfo(
+        query: query,
+        outputCols: [singularCol, pluralCol],
+        args: [word.lowercased()]
+      ))
+    }
+
+    return queries
+  }
+
+  /**Builds a query to get all plural forms for a language
+   - Parameter contract: The data contract defining plural columns
+   - Returns: Query info to execute, or nil if contract is invalid
+   */
+  func buildAllPluralsQuery(contract: DataContract?) -> PluralQueryInfo? {
+    guard let contract = contract,
+          let numbers = contract.numbers,
+          !numbers.isEmpty else {
+      NSLog("PluralManager: No valid plural columns in contract")
+      return nil
+    }
+
+    let pluralColumns = Array(numbers.values)
+    let columns = pluralColumns.map { "`\($0)`" }.joined(separator: ", ")
+    let query = "SELECT \(columns) FROM nouns"
+
+    return PluralQueryInfo(
+      query: query,
+      outputCols: pluralColumns,
+      args: []
+    )
+  }
+}

Keyboards/KeyboardsBase/InterfaceVariables.swift

@@ -118,6 +118,7 @@ var shiftButtonState: ShiftButtonState = .normal
 var commandState: CommandState = .idle
 var autoActionState: AutoActionState = .suggest
 var conjViewShiftButtonsState: ConjViewShiftButtonsState = .bothInactive
+var pluralWords: Set<String>?
 
 // Variables and functions to determine display parameters.
 enum DeviceType {

Keyboards/KeyboardsBase/KeyboardViewController.swift

@@ -2057,6 +2057,11 @@ class KeyboardViewController: UIInputViewController {
 
       // Drop non-unique values in case the lexicon has added words that were already present.
       LanguageDBManager.shared.deleteNonUniqueAutocompletions()
+
+      // Load plural words for the current language
+      if let allPlurals = LanguageDBManager.shared.queryAllPluralForms() {
+        pluralWords = Set(allPlurals.map { $0.lowercased() })
+      }
     }
 
     setKeyboard()

Keyboards/KeyboardsBase/ScribeFunctionality/Annotate.swift

@@ -52,7 +52,15 @@ func convertFullGenderToAbbr(_ genderFull: String) -> String {
 ///   - wordToAnnotate: the word that an annotation should be created for.
 ///   - KVC: the keyboard view controller.
 func wordAnnotation(wordToAnnotate: String, KVC: KeyboardViewController) {
-  let nounForm = LanguageDBManager.shared.queryNounForm(of: wordToAnnotate)[0]
+  var nounForm: String
+
+  // Check if word is plural first
+  if let pluralWords = pluralWords, pluralWords.contains(wordToAnnotate.lowercased()) {
+    nounForm = "PL"
+  } else {
+    nounForm = LanguageDBManager.shared.queryNounForm(of: wordToAnnotate)[0]
+  }
+
   prepAnnotationForm = LanguageDBManager.shared.queryPrepForm(of: wordToAnnotate.lowercased())[0]
 
   hasNounForm = !nounForm.isEmpty
@@ -254,7 +262,14 @@ func typedWordAnnotation(KVC: KeyboardViewController) {
 ///   - index: the auto action key index that the annotation should be set for.
 ///   - KVC: the keyboard view controller.
 func autoActionAnnotation(autoActionWord: String, index: Int, KVC: KeyboardViewController) {
-  let nounForm = LanguageDBManager.shared.queryNounForm(of: autoActionWord)[0]
+  var nounForm: String
+
+  // Check if word is plural first
+  if let pluralWords = pluralWords, pluralWords.contains(autoActionWord.lowercased()) {
+    nounForm = "PL"
+  } else {
+    nounForm = LanguageDBManager.shared.queryNounForm(of: autoActionWord)[0]
+  }
 
   hasNounForm = !nounForm.isEmpty
 

Keyboards/KeyboardsBase/ScribeFunctionality/Plural.swift

@@ -13,7 +13,7 @@ import UIKit
 func queryPlural(commandBar: UILabel) {
   // Cancel via a return press.
   if let commandBarText = commandBar.text,
-    commandBarText == pluralPromptAndCursor || commandBarText == pluralPromptAndCursor {
+    commandBarText == pluralPromptAndCursor {
     return
   }
 
@@ -37,25 +37,25 @@ func queryPluralNoun(queriedNoun: String) {
     noun = noun.lowercased()
   }
 
-  wordToReturn = LanguageDBManager.shared.queryNounPlural(of: noun)[0]
+  // Check if the word is already plural (always use lowercase for Set lookup).
+  let lowercaseNoun = noun.lowercased()
+  let isAlreadyPlural = pluralWords?.contains(lowercaseNoun) == true
 
-  guard !wordToReturn.isEmpty else {
-    commandState = .invalid
-    return
+  if isAlreadyPlural {
+    wordToReturn = noun  // Use original capitalization.
+    commandState = .alreadyPlural
+  } else {
+    let result = LanguageDBManager.shared.queryNounPlural(of: noun)
+    guard !result.isEmpty, !result[0].isEmpty else {
+      commandState = .invalid
+      return
+    }
+    wordToReturn = result[0]
   }
 
-  if wordToReturn != "isPlural" {
-    if inputWordIsCapitalized {
-      proxy.insertText(wordToReturn.capitalized + getOptionalSpace())
-    } else {
-      proxy.insertText(wordToReturn + getOptionalSpace())
-    }
+  if inputWordIsCapitalized {
+    proxy.insertText(wordToReturn.capitalized + getOptionalSpace())
   } else {
-    if inputWordIsCapitalized {
-      proxy.insertText(noun.capitalized + getOptionalSpace())
-    } else {
-      proxy.insertText(noun + getOptionalSpace())
-    }
-    commandState = .alreadyPlural
+    proxy.insertText(wordToReturn + getOptionalSpace())
   }
 }