Conjugate: use dynamic conjugation and declension

Author: catreedle

Keyboards/DataContracts/de_declensions.json

@@ -0,0 +1,59 @@
+{
+  "declensions": {
+    "1": {
+      "title": "Винительные местоимения",
+      "forms": {
+        "я": "меня",
+        "ты": "тебя",
+        "он/она/оно": "его/её/его",
+        "мы": "нас",
+        "вы": "вас",
+        "они": "их"
+      }
+    },
+    "2": {
+      "title": "Дательные местоимения",
+      "forms": {
+        "я": "мне",
+        "ты": "тебе",
+        "он/она/оно": "ему/ей/ему",
+        "мы": "нам",
+        "вы": "вам",
+        "они": "им"
+      }
+    },
+    "3": {
+      "title": "Родительные местоимения",
+      "forms": {
+        "я": "меня",
+        "ты": "тебя",
+        "он/она/оно": "его/её/его",
+        "мы": "нас",
+        "вы": "вас",
+        "они": "их"
+      }
+    },
+    "4": {
+      "title": "Творительные местоимения",
+      "forms": {
+        "я": "мной",
+        "ты": "тобой",
+        "он/она/оно": "им/ей/им",
+        "мы": "нами",
+        "вы": "вами",
+        "они": "ими"
+      }
+    },
+    "5": {
+      "title": "Предложные местоимения",
+      "forms": {
+        "я": "мне",
+        "ты": "тебе",
+        "он/она/оно": "нём/ней/нём",
+        "мы": "нас",
+        "вы": "вас",
+        "они": "них"
+      }
+    }
+  }
+}

Keyboards/DataContracts/ru_declensions.json

@@ -0,0 +1,125 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+import Foundation
+
+/// Manages retrieval of verb conjugations for different languages.
+
+class ConjugationManager {
+  static let shared = ConjugationManager()
+
+  private init() {}
+
+  /// Returns nested structure: [TenseTitle: [TypeTitle: [(pronoun, conjugatedForm)]]]
+  func getConjugations(
+    verb: String,
+    language: String
+  ) -> [(String, [(String, [(String, String)])])]? {
+
+    let contract = ContractManager.shared.loadContract(language: language)
+
+    guard let conjugations = contract.conjugations else {
+      return nil
+    }
+
+    var result: [(String, [(String, [(String, String)])])] = []
+
+    for (_, tenseGroup) in conjugations.sorted(by: {
+      Int($0.key) ?? 0 < Int($1.key) ?? 0
+    }) {
+      var conjugationTypes: [(String, [(String, String)])] = []
+
+      for (_, conjugationType) in tenseGroup.conjugationTypes.sorted(by: {
+        Int($0.key) ?? 0 < Int($1.key) ?? 0
+      }) {
+        var forms: [(String, String)] = []
+
+        for (pronoun, columnName) in conjugationType.conjugationForms {
+          let conjugatedForm = queryConjugatedForm(
+            verb: verb,
+            columnName: columnName,
+            language: language
+          )
+          forms.append((pronoun, conjugatedForm))
+        }
+
+        conjugationTypes.append((conjugationType.title, forms))
+      }
+
+      result.append((tenseGroup.title, conjugationTypes))
+    }
+
+    return result.isEmpty ? nil : result
+  }
+
+  private func queryConjugatedForm(
+    verb: String,
+    columnName: String,
+    language: String
+  ) -> String {
+    if columnName.contains("[") {
+      return parseComplexForm(verb: verb, columnName: columnName, language: language)
+    } else {
+      // Simple column query
+      let results = LanguageDBManager.shared.queryVerb(of: verb, with: [columnName])
+      let result = results.first ?? ""
+
+      return result
+    }
+  }
+
+  private func parseComplexForm(
+    verb: String,
+    columnName: String,
+    language: String
+  ) -> String {
+    // Extract "[auxiliaryPart]" and "mainColumn"
+    let pattern = "\\[(.*?)\\]"
+    guard let regex = try? NSRegularExpression(pattern: pattern),
+          let match = regex.firstMatch(in: columnName, range: NSRange(columnName.startIndex..., in: columnName)) else {
+      return ""
+    }
+
+    let auxiliaryPart = (columnName as NSString).substring(with: match.range(at: 1))
+    let mainColumn = columnName.replacingOccurrences(of: pattern, with: "", options: .regularExpression)
+      .trimmingCharacters(in: .whitespaces)
+
+    // Get the main verb form (e.g., "gegangen")
+    guard let mainForm = LanguageDBManager.shared.queryVerb(of: verb, with: [mainColumn]).first,
+          !mainForm.isEmpty else {
+      return ""
+    }
+
+    // Check if it's dynamic lookup (German style: "indicativePresentFirstPersonSingular auxiliaryVerb")
+    let auxWords = auxiliaryPart.split(separator: " ")
+    if auxWords.count > 1 {
+      let targetForm = String(auxWords.first!)  // e.g., "indicativePresentFirstPersonSingular"
+      let auxColumn = String(auxWords.last!)    // e.g., "auxiliaryVerb"
+
+      // Get the auxiliary verb identifier
+      if let auxVerbId = LanguageDBManager.shared.queryVerb(of: verb, with: [auxColumn]).first,
+         !auxVerbId.isEmpty {
+
+        // Try querying by wdLexemeId first
+        var auxConjugated = LanguageDBManager.shared.queryVerb(
+          of: auxVerbId,
+          identifierColumn: "wdLexemeId",
+          with: [targetForm]
+        ).first
+
+        // Fallback: try by infinitive
+        if auxConjugated?.isEmpty ?? true {
+          auxConjugated = LanguageDBManager.shared.queryVerb(
+            of: auxVerbId,
+            with: [targetForm]
+          ).first
+        }
+
+        if let auxConjugated = auxConjugated, !auxConjugated.isEmpty {
+          return "\(auxConjugated) \(mainForm)"
+        }
+      }
+    }
+
+    // Fallback: use auxiliary as-is
+    return "\(auxiliaryPart) \(mainForm)"
+  }
+}

Keyboards/DataManager/ConjugationManager.swift

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import Foundation
+
+/// Manages loading and parsing of declension contracts
+class DeclensionManager {
+  static let shared = DeclensionManager()
+
+  private init() {}
+
+  /// Loads declension cases for a language
+  func loadDeclensions(language: String) -> [NavigationLevel]? {
+    let languageCode = language.lowercased()
+
+    // Load declensions JSON file (e.g., "de_declensions.json")
+    guard let jsonResourcePath = Bundle.main.path(
+      forResource: "\(languageCode)_declensions",
+      ofType: "json"
+    ) else {
+      NSLog("Declensions not found: \(languageCode)_declensions.json")
+      return nil
+    }
+
+    do {
+      let data = try Data(contentsOf: URL(fileURLWithPath: jsonResourcePath))
+      guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+            let declensionsDict = json["declensions"] as? [String: [String: Any]] else {
+        return nil
+      }
+
+      // Sort by numeric keys
+      let sortedKeys = declensionsDict.keys.sorted { Int($0) ?? 0 < Int($1) ?? 0 }
+
+      var cases: [NavigationLevel] = []
+
+      for key in sortedKeys {
+        guard let declension = declensionsDict[key],
+              let title = declension["title"] as? String,
+              let forms = declension["forms"] as? [String: Any] else {
+          continue
+        }
+
+        let options = parseForms(forms, parentTitle: title)
+        cases.append(NavigationLevel(title: title, options: options))
+      }
+
+      return cases
+    } catch {
+      NSLog("Error loading declensions \(languageCode)/declensions.json: \(error)")
+      return nil
+    }
+  }
+
+  /// Recursively parses forms with optional displayValue
+  private func parseForms(
+    _ forms: [String: Any],
+    parentTitle: String
+  ) -> [(label: String, node: NavigationNode)] {
+    var options: [(label: String, node: NavigationNode)] = []
+
+    // Sort keys to maintain consistent order
+    let sortedKeys = forms.keys.sorted()
+
+    for key in sortedKeys {
+      guard let value = forms[key] else { continue }
+
+      if let stringValue = value as? String {
+        // Final value
+        options.append((label: key, node: .finalValue(stringValue)))
+
+      } else if let nestedDict = value as? [String: Any],
+                let title = nestedDict["title"] as? String,
+                let nestedForms = nestedDict["forms"] as? [String: Any] {
+        // Has nested forms - need to navigate deeper
+
+        // Check for explicit displayValue, otherwise auto-generate
+        let displayValue: String
+        if let explicit = nestedDict["displayValue"] as? String {
+          displayValue = explicit
+        } else {
+          displayValue = autoGenerateDisplayValue(from: nestedForms)
+        }
+
+        let suboptions = parseForms(nestedForms, parentTitle: title)
+        let nextLevel = NavigationLevel(title: title, options: suboptions)
+
+        options.append((label: key, node: .nextLevel(nextLevel, displayValue: displayValue)))
+      }
+    }
+
+    return options
+  }
+
+  /// Auto-generates display value by joining direct child values
+  private func autoGenerateDisplayValue(from forms: [String: Any]) -> String {
+    var values: [String] = []
+
+    // Sort keys to maintain consistent order
+    let sortedKeys = forms.keys.sorted()
+
+    for key in sortedKeys {
+      guard let value = forms[key] else { continue }
+
+      if let stringValue = value as? String {
+        // Direct string value - use it
+        values.append(stringValue)
+      }
+    }
+
+    return values.joined(separator: "/")
+  }
+}

Keyboards/DataManager/DeclensionManager.swift

@@ -420,6 +420,7 @@ extension LanguageDBManager {
 
   /// Query the verb form of word in `verbs`.
   func queryVerb(of word: String) -> [String] {
+    let columnName = (controllerLanguage == "Swedish") ? "verb" : "infinitive"
     let query = """
     SELECT
       *
@@ -428,9 +429,9 @@ extension LanguageDBManager {
       verbs
 
     WHERE
-      verb = ?
+      \(columnName) = ?
     """
-    let outputCols = ["verb"]
+    let outputCols = [columnName]
     let args = [word]
 
     return queryDBRow(query: query, outputCols: outputCols, args: StatementArguments(args))
@@ -439,8 +440,11 @@ extension LanguageDBManager {
   /// Query specific form of word in `verbs`.
   ///
   /// - Parameters:
+  ///   - word: The value to search for
+  ///   - identifierColumn: The column to search in (default: "infinitive" or "verb" for Swedish)
   ///   - outputCols: Specific form want to output
-  func queryVerb(of word: String, with outputCols: [String]) -> [String] {
+  func queryVerb(of word: String, identifierColumn: String? = nil, with outputCols: [String]) -> [String] {
+    let columnName = identifierColumn ?? ((controllerLanguage == "Swedish") ? "verb" : "infinitive")
     let query = """
     SELECT
       *
@@ -449,7 +453,7 @@ extension LanguageDBManager {
       verbs
 
     WHERE
-      verb = ?
+      \(columnName) = ?
     """
     let args = [word]