admin/Spanish
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add per-form English translations to verb conjugation table

Browse Source 
New EnglishConjugator in SharedModels constructs English translations
by combining the verb's infinitive with person pronouns and tense
auxiliaries (e.g., abatir conditional yo → "I would knock down").
Covers all 20 tense IDs, handles 60+ irregular English verbs,
multi-word verbs, 3rd person rules, gerund and participle formation.

VerbDetailView shows the English below each conjugated form, plus a
legend explaining red = irregular conjugation. 42 tests.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Trey t
2026-04-11 23:44:17 -05:00
parent c58313496e
commit a1dc17bf00
4 changed files with 544 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Conjuga/Conjuga.xcodeproj/project.pbxproj
View File

@@ -211,6 +211,7 @@
7E6AF62A3A949630E067DC22 /* Info.plist */,
353C5DE41FD410FA82E3AED7 /* Models */,
1994867BC8E985795A172854 /* Services */,
BFC1AEBE02CE22E6474FFEA6 /* Utilities */,
3C75490F53C34A37084FF478 /* ViewModels */,
A81CA75762B08D35D5B7A44D /* Views */,
);
@@ -399,6 +400,13 @@
path = Course;
sourceTree = "<group>";
};
BFC1AEBE02CE22E6474FFEA6 /* Utilities */ = {
isa = PBXGroup;
children = (
);
path = Utilities;
sourceTree = "<group>";
};
F605D24E5EA11065FD18AF7E /* Products */ = {
isa = PBXGroup;
children = (

29
Conjuga/Conjuga/Views/Verbs/VerbDetailView.swift
View File

@@ -38,15 +38,30 @@ struct VerbDetailView: View {
ContentUnavailableView("No forms loaded", systemImage: "exclamationmark.triangle")
} else {
ForEach(formsForTense, id: \.personIndex) { form in
HStack {
Text(TenseInfo.persons[form.personIndex])
.foregroundStyle(.secondary)
.frame(minWidth: 100, alignment: .leading)
Text(form.form)
.fontWeight(form.regularity != "ordinary" ? .semibold : .regular)
.foregroundStyle(form.regularity != "ordinary" ? .red : .primary)
VStack(alignment: .leading, spacing: 2) {
HStack {
Text(TenseInfo.persons[form.personIndex])
.foregroundStyle(.secondary)
.frame(minWidth: 100, alignment: .leading)
Text(form.form)
.fontWeight(form.regularity != "ordinary" ? .semibold : .regular)
.foregroundStyle(form.regularity != "ordinary" ? .red : .primary)
}
Text(EnglishConjugator.translate(
english: verb.english,
tenseId: selectedTense.id,
personIndex: form.personIndex
))
.font(.caption)
.foregroundStyle(.secondary)
}
}
if formsForTense.contains(where: { $0.regularity != "ordinary" }) {
Label("Red indicates an irregular conjugation", systemImage: "info.circle")
.font(.caption)
.foregroundStyle(.secondary)
}
}
} header: {
Text("Conjugation")

246
Conjuga/SharedModels/Sources/SharedModels/EnglishConjugator.swift Normal file
View File

@@ -0,0 +1,246 @@
import Foundation
/// Constructs approximate English translations for Spanish conjugation forms
/// by combining the verb's English infinitive with person pronouns and tense auxiliaries.
///
/// Not perfect for irregular English verbs (go→went, be→was) but covers the
/// common patterns well enough for a learning context.
public enum EnglishConjugator {
public static func translate(english: String, tenseId: String, personIndex: Int) -> String {
let base = english.hasPrefix("to ") ? String(english.dropFirst(3)).trimmingCharacters(in: .whitespaces) : english
guard !base.isEmpty else { return "" }
let pronoun = pronoun(for: personIndex)
switch tenseId {
// Indicative
case "ind_presente":
return "\(pronoun) \(presentForm(base, personIndex: personIndex))"
case "ind_preterito":
return "\(pronoun) \(pastForm(base))"
case "ind_imperfecto":
return "\(pronoun) used to \(base)"
case "ind_futuro":
return "\(pronoun) will \(base)"
case "ind_perfecto":
return "\(pronoun) \(haveForm(personIndex)) \(pastParticiple(base))"
case "ind_pluscuamperfecto":
return "\(pronoun) had \(pastParticiple(base))"
case "ind_futuro_perfecto":
return "\(pronoun) will have \(pastParticiple(base))"
case "ind_preterito_anterior":
return "\(pronoun) had \(pastParticiple(base))"
// Conditional
case "cond_presente":
return "\(pronoun) would \(base)"
case "cond_perfecto":
return "\(pronoun) would have \(pastParticiple(base))"
// Subjunctive
case "subj_presente":
return "that \(pronoun) \(base)"
case "subj_imperfecto_1", "subj_imperfecto_2":
return "that \(pronoun) would \(base)"
case "subj_perfecto":
return "that \(pronoun) \(haveForm(personIndex)) \(pastParticiple(base))"
case "subj_pluscuamperfecto_1", "subj_pluscuamperfecto_2":
return "that \(pronoun) had \(pastParticiple(base))"
case "subj_futuro":
return "that \(pronoun) will \(base)"
case "subj_futuro_perfecto":
return "that \(pronoun) will have \(pastParticiple(base))"
// Imperative
case "imp_afirmativo":
return imperativeAffirmative(base, personIndex: personIndex)
case "imp_negativo":
return "don't \(base)"
default:
return "\(pronoun) \(base)"
}
}
// MARK: - Pronouns
private static func pronoun(for personIndex: Int) -> String {
switch personIndex {
case 0: "I"
case 1: "you"
case 2: "he/she"
case 3: "we"
case 4: "you all"
case 5: "they"
default: ""
}
}
// MARK: - Present tense
private static func presentForm(_ base: String, personIndex: Int) -> String {
// 3rd person singular adds -s/-es
guard personIndex == 2 else { return base }
let words = base.split(separator: " ")
guard let first = words.first else { return base }
let verb = String(first)
let rest = words.dropFirst().joined(separator: " ")
let conjugated = addThirdPersonS(verb)
return rest.isEmpty ? conjugated : "\(conjugated) \(rest)"
}
private static func addThirdPersonS(_ verb: String) -> String {
if verb == "have" { return "has" }
if verb == "be" { return "is" }
if verb == "do" { return "does" }
if verb == "go" { return "goes" }
if verb.hasSuffix("sh") || verb.hasSuffix("ch") || verb.hasSuffix("x") ||
verb.hasSuffix("s") || verb.hasSuffix("z") || verb.hasSuffix("o") {
return verb + "es"
}
if verb.hasSuffix("y") && verb.count > 1 {
let yIndex = verb.index(before: verb.endIndex)
let beforeY = verb[verb.index(before: yIndex)]
if !"aeiou".contains(beforeY) {
return String(verb.dropLast()) + "ies"
}
}
return verb + "s"
}
// MARK: - Past tense
private static func pastForm(_ base: String) -> String {
// Check common irregulars first
let words = base.split(separator: " ")
guard let first = words.first else { return base }
let verb = String(first).lowercased()
let rest = words.dropFirst().joined(separator: " ")
let irregular: String? = commonIrregularPast[verb]
let past = irregular ?? addEd(String(first))
return rest.isEmpty ? past : "\(past) \(rest)"
}
private static func addEd(_ verb: String) -> String {
if verb.hasSuffix("e") { return verb + "d" }
if verb.hasSuffix("y") && verb.count > 1 {
let beforeY = verb[verb.index(before: verb.endIndex)]
if !"aeiou".contains(beforeY) {
return String(verb.dropLast()) + "ied"
}
}
return verb + "ed"
}
// MARK: - Past participle
private static func pastParticiple(_ base: String) -> String {
let words = base.split(separator: " ")
guard let first = words.first else { return base }
let verb = String(first).lowercased()
let rest = words.dropFirst().joined(separator: " ")
let irregular: String? = commonIrregularParticiple[verb]
let participle = irregular ?? addEd(String(first))
return rest.isEmpty ? participle : "\(participle) \(rest)"
}
// MARK: - Gerund
private static func gerund(_ base: String) -> String {
let words = base.split(separator: " ")
guard let first = words.first else { return base }
let verb = String(first)
let rest = words.dropFirst().joined(separator: " ")
let ing: String
if verb.hasSuffix("ie") {
ing = String(verb.dropLast(2)) + "ying"
} else if verb.hasSuffix("e") && !verb.hasSuffix("ee") {
ing = String(verb.dropLast()) + "ing"
} else {
ing = verb + "ing"
}
return rest.isEmpty ? ing : "\(ing) \(rest)"
}
// MARK: - Auxiliaries
private static func haveForm(_ personIndex: Int) -> String {
personIndex == 2 ? "has" : "have"
}
private static func beForm(_ personIndex: Int) -> String {
switch personIndex {
case 0: "am"
case 2: "is"
default: "are"
}
}
// MARK: - Imperative
private static func imperativeAffirmative(_ base: String, personIndex: Int) -> String {
switch personIndex {
case 1, 4: "\(base)!"
case 3: "let's \(base)!"
default: "\(base)!"
}
}
// MARK: - Irregular lookups (most common English irregulars)
private static let commonIrregularPast: [String: String] = [
"be": "was/were", "have": "had", "do": "did", "go": "went",
"say": "said", "get": "got", "make": "made", "know": "knew",
"think": "thought", "take": "took", "come": "came", "see": "saw",
"want": "wanted", "give": "gave", "tell": "told", "find": "found",
"put": "put", "leave": "left", "bring": "brought", "begin": "began",
"keep": "kept", "hold": "held", "write": "wrote", "stand": "stood",
"hear": "heard", "let": "let", "mean": "meant", "set": "set",
"meet": "met", "run": "ran", "pay": "paid", "sit": "sat",
"speak": "spoke", "read": "read", "grow": "grew", "lose": "lost",
"fall": "fell", "feel": "felt", "cut": "cut", "sell": "sold",
"drive": "drove", "buy": "bought", "wear": "wore", "choose": "chose",
"sleep": "slept", "eat": "ate", "drink": "drank", "swim": "swam",
"fly": "flew", "break": "broke", "sing": "sang", "catch": "caught",
"send": "sent", "build": "built", "spend": "spent", "win": "won",
"fight": "fought", "throw": "threw", "teach": "taught", "lead": "led",
"understand": "understood", "draw": "drew", "ride": "rode",
"rise": "rose", "shake": "shook", "forget": "forgot",
"shoot": "shot", "wake": "woke", "bite": "bit", "hide": "hid",
"lay": "laid", "lie": "lay", "strike": "struck", "hang": "hung",
"blow": "blew", "dig": "dug", "feed": "fed", "forgive": "forgave",
"freeze": "froze", "hurt": "hurt", "light": "lit", "shut": "shut",
"steal": "stole", "stick": "stuck", "sweep": "swept",
"swing": "swung", "tear": "tore",
]
private static let commonIrregularParticiple: [String: String] = [
"be": "been", "have": "had", "do": "done", "go": "gone",
"say": "said", "get": "gotten", "make": "made", "know": "known",
"think": "thought", "take": "taken", "come": "come", "see": "seen",
"give": "given", "tell": "told", "find": "found",
"put": "put", "leave": "left", "bring": "brought", "begin": "begun",
"keep": "kept", "hold": "held", "write": "written", "stand": "stood",
"hear": "heard", "let": "let", "mean": "meant", "set": "set",
"meet": "met", "run": "run", "pay": "paid", "sit": "sat",
"speak": "spoken", "read": "read", "grow": "grown", "lose": "lost",
"fall": "fallen", "feel": "felt", "cut": "cut", "sell": "sold",
"drive": "driven", "buy": "bought", "wear": "worn", "choose": "chosen",
"sleep": "slept", "eat": "eaten", "drink": "drunk", "swim": "swum",
"fly": "flown", "break": "broken", "sing": "sung", "catch": "caught",
"send": "sent", "build": "built", "spend": "spent", "win": "won",
"fight": "fought", "throw": "thrown", "teach": "taught", "lead": "led",
"understand": "understood", "draw": "drawn", "ride": "ridden",
"rise": "risen", "shake": "shaken", "forget": "forgotten",
"shoot": "shot", "wake": "woken", "bite": "bitten", "hide": "hidden",
"lay": "laid", "lie": "lain", "strike": "struck", "hang": "hung",
"blow": "blown", "dig": "dug", "feed": "fed", "forgive": "forgiven",
"freeze": "frozen", "hurt": "hurt", "light": "lit", "shut": "shut",
"steal": "stolen", "stick": "stuck", "sweep": "swept",
"swing": "swung", "tear": "torn",
]
}

268
Conjuga/SharedModels/Tests/SharedModelsTests/EnglishConjugatorTests.swift Normal file
View File

@@ -0,0 +1,268 @@
import Testing
@testable import SharedModels
@Suite("EnglishConjugator")
struct EnglishConjugatorTests {
// MARK: - haber (to have) — irregular English verb
@Test("haber present: I have / you have / he/she has")
func haberPresent() {
#expect(t("to have", "ind_presente", 0) == "I have")
#expect(t("to have", "ind_presente", 1) == "you have")
#expect(t("to have", "ind_presente", 2) == "he/she has")
#expect(t("to have", "ind_presente", 3) == "we have")
#expect(t("to have", "ind_presente", 5) == "they have")
}
@Test("haber preterite: I had")
func haberPreterite() {
#expect(t("to have", "ind_preterito", 0) == "I had")
#expect(t("to have", "ind_preterito", 2) == "he/she had")
}
@Test("haber future: I will have")
func haberFuture() {
#expect(t("to have", "ind_futuro", 0) == "I will have")
#expect(t("to have", "ind_futuro", 3) == "we will have")
}
@Test("haber conditional: I would have")
func haberConditional() {
#expect(t("to have", "cond_presente", 0) == "I would have")
}
@Test("haber present perfect: I have had / he/she has had")
func haberPresentPerfect() {
#expect(t("to have", "ind_perfecto", 0) == "I have had")
#expect(t("to have", "ind_perfecto", 2) == "he/she has had")
}
// MARK: - ir (to go) — irregular English verb
@Test("ir present: I go / he/she goes")
func irPresent() {
#expect(t("to go", "ind_presente", 0) == "I go")
#expect(t("to go", "ind_presente", 2) == "he/she goes")
#expect(t("to go", "ind_presente", 5) == "they go")
}
@Test("ir preterite: I went")
func irPreterite() {
#expect(t("to go", "ind_preterito", 0) == "I went")
#expect(t("to go", "ind_preterito", 2) == "he/she went")
}
@Test("ir imperfect: I used to go")
func irImperfect() {
#expect(t("to go", "ind_imperfecto", 0) == "I used to go")
}
@Test("ir present perfect: I have gone")
func irPresentPerfect() {
#expect(t("to go", "ind_perfecto", 0) == "I have gone")
#expect(t("to go", "ind_perfecto", 2) == "he/she has gone")
}
// MARK: - ser (to be) — most irregular English verb
@Test("ser present: he/she is")
func serPresent() {
#expect(t("to be", "ind_presente", 2) == "he/she is")
}
@Test("ser preterite: I was/were")
func serPreterite() {
#expect(t("to be", "ind_preterito", 0) == "I was/were")
}
@Test("ser present perfect: I have been")
func serPresentPerfect() {
#expect(t("to be", "ind_perfecto", 0) == "I have been")
}
// MARK: - hablar (to speak)
@Test("hablar present: I speak / he/she speaks")
func hablarPresent() {
#expect(t("to speak", "ind_presente", 0) == "I speak")
#expect(t("to speak", "ind_presente", 2) == "he/she speaks")
}
@Test("hablar preterite: I spoke")
func hablarPreterite() {
#expect(t("to speak", "ind_preterito", 0) == "I spoke")
}
@Test("hablar present perfect: I have spoken")
func hablarPresentPerfect() {
#expect(t("to speak", "ind_perfecto", 0) == "I have spoken")
}
// MARK: - comer (to eat)
@Test("comer preterite: I ate")
func comerPreterite() {
#expect(t("to eat", "ind_preterito", 0) == "I ate")
}
@Test("comer present perfect: I have eaten")
func comerPresentPerfect() {
#expect(t("to eat", "ind_perfecto", 0) == "I have eaten")
}
// MARK: - vivir (to live) — regular English verb
@Test("vivir present: I live / he/she lives")
func vivirPresent() {
#expect(t("to live", "ind_presente", 0) == "I live")
#expect(t("to live", "ind_presente", 2) == "he/she lives")
}
@Test("vivir preterite: I lived")
func vivirPreterite() {
#expect(t("to live", "ind_preterito", 0) == "I lived")
}
// MARK: - abatir (to knock down) — multi-word verb
@Test("abatir present: I knock down / he/she knocks down")
func abatirPresent() {
#expect(t("to knock down", "ind_presente", 0) == "I knock down")
#expect(t("to knock down", "ind_presente", 2) == "he/she knocks down")
}
@Test("abatir conditional: I would knock down")
func abatirConditional() {
#expect(t("to knock down", "cond_presente", 0) == "I would knock down")
#expect(t("to knock down", "cond_presente", 2) == "he/she would knock down")
}
@Test("abatir preterite: I knocked down")
func abatirPreterite() {
#expect(t("to knock down", "ind_preterito", 0) == "I knocked down")
}
// MARK: - Conditional
@Test("conditional: I would speak")
func conditional() {
#expect(t("to speak", "cond_presente", 0) == "I would speak")
#expect(t("to speak", "cond_presente", 2) == "he/she would speak")
}
@Test("conditional perfect: I would have gone")
func conditionalPerfect() {
#expect(t("to go", "cond_perfecto", 0) == "I would have gone")
}
// MARK: - Subjunctive
@Test("present subjunctive: that I speak")
func presentSubjunctive() {
#expect(t("to speak", "subj_presente", 0) == "that I speak")
#expect(t("to speak", "subj_presente", 2) == "that he/she speak")
}
@Test("imperfect subjunctive (ra): that I would speak")
func imperfectSubjunctive1() {
#expect(t("to speak", "subj_imperfecto_1", 0) == "that I would speak")
}
@Test("imperfect subjunctive (se): that I would speak")
func imperfectSubjunctive2() {
#expect(t("to speak", "subj_imperfecto_2", 0) == "that I would speak")
}
@Test("subjunctive perfect: that I have spoken")
func subjunctivePerfect() {
#expect(t("to speak", "subj_perfecto", 0) == "that I have spoken")
#expect(t("to speak", "subj_perfecto", 2) == "that he/she has spoken")
}
@Test("subjunctive pluperfect: that I had gone")
func subjunctivePluperfect() {
#expect(t("to go", "subj_pluscuamperfecto_1", 0) == "that I had gone")
#expect(t("to go", "subj_pluscuamperfecto_2", 0) == "that I had gone")
}
@Test("subjunctive future: that I will speak")
func subjunctiveFuture() {
#expect(t("to speak", "subj_futuro", 0) == "that I will speak")
}
@Test("subjunctive future perfect: that I will have spoken")
func subjunctiveFuturePerfect() {
#expect(t("to speak", "subj_futuro_perfecto", 0) == "that I will have spoken")
}
// MARK: - Imperative
@Test("imperative affirmative")
func imperativeAffirmative() {
#expect(t("to speak", "imp_afirmativo", 1) == "speak!")
#expect(t("to speak", "imp_afirmativo", 3) == "let's speak!")
}
@Test("imperative negative")
func imperativeNegative() {
#expect(t("to speak", "imp_negativo", 1) == "don't speak")
}
// MARK: - Compound indicative tenses
@Test("pluperfect: I had spoken")
func pluperfect() {
#expect(t("to speak", "ind_pluscuamperfecto", 0) == "I had spoken")
#expect(t("to go", "ind_pluscuamperfecto", 0) == "I had gone")
}
@Test("future perfect: I will have spoken")
func futurePerfect() {
#expect(t("to speak", "ind_futuro_perfecto", 0) == "I will have spoken")
}
@Test("preterite anterior: I had spoken (same as pluperfect in English)")
func preteriteAnterior() {
#expect(t("to speak", "ind_preterito_anterior", 0) == "I had spoken")
}
// MARK: - Edge cases
@Test("empty english returns empty string")
func emptyEnglish() {
#expect(t("", "ind_presente", 0) == "")
#expect(t("to ", "ind_presente", 0) == "")
}
@Test("unknown tense falls back to pronoun + base")
func unknownTense() {
#expect(t("to speak", "some_future_tense", 0) == "I speak")
}
@Test("3rd person present: study → studies")
func thirdPersonYRule() {
#expect(t("to study", "ind_presente", 2) == "he/she studies")
}
@Test("3rd person present: play → plays")
func thirdPersonVowelY() {
#expect(t("to play", "ind_presente", 2) == "he/she plays")
}
@Test("3rd person present: watch → watches")
func thirdPersonChRule() {
#expect(t("to watch", "ind_presente", 2) == "he/she watches")
}
@Test("past regular: carry → carried")
func pastYRule() {
#expect(t("to carry", "ind_preterito", 0) == "I carried")
}
// MARK: - Helper
private func t(_ english: String, _ tenseId: String, _ personIndex: Int) -> String {
EnglishConjugator.translate(english: english, tenseId: tenseId, personIndex: personIndex)
}
}