public void MatchSingleString_Ask2()
{
var result = new Pronoun("pronouns: ask", s);
Assert.AreEqual(result.value, PronounFlags.ASK);
Assert.AreEqual("ask", result.ToString());
}
public void MatchSingleString_Any2()
{
var result = new Pronoun("pronouns: any", s);
Assert.AreEqual(result.value, PronounFlags.ALL);
Assert.AreEqual("any/all", result.ToString());
}
public void PronounsInsideTextShouldBeParsed_Reverse()
{
var result = new Pronoun("This is a player description with some pronouns they/she with an fc 0123-4567-8912", s);
Assert.AreEqual(result.value, PronounFlags.SHE | PronounFlags.THEY | PronounFlags.ORDER_RTL);
Assert.AreEqual("they/she", result.ToString());
}
public void MatchSingleString_It()
{
var result = new Pronoun("it", s);
Assert.AreEqual(result.value, PronounFlags.IT);
Assert.AreEqual("it/it", result.ToString());
}
public void NoMatchEmptyString()
{
var result = new Pronoun("", s);
Assert.AreEqual(result.value, PronounFlags.NONE);
Assert.AreEqual("none", result.ToString());
}
public void PronounsInsideTextShouldBeParsed()
{
var result = new Pronoun("This is a player description with some pronouns he/she/they with an fc 0123-4567-8912", s);
Assert.AreEqual(result.value, PronounFlags.HE | PronounFlags.SHE | PronounFlags.THEY);
Assert.AreEqual("he/she/they", result.ToString());
}
public void MatchSingleString_He()
{
var result = new Pronoun("he", s);
Assert.AreEqual(result.value, PronounFlags.HE);
Assert.AreEqual("he/him", result.ToString());
}
public void PronounsFromProfile_2()
{
var result = new Pronoun("he/him or they/them pronouns please", s);
Assert.AreEqual(result.value, PronounFlags.HE | PronounFlags.THEY);
Assert.AreEqual("he/they", result.ToString());
}
public void PronounsFromProfile_6()
{
var result = new Pronoun("I like Splatoon `he/him/ne`.", s);
Assert.AreEqual(result.value, PronounFlags.HE | PronounFlags.NEO);
Assert.AreEqual("he/" + Pronoun.NEO_PLACEHOLDER, result.ToString());
}
public void NoMatchJunkDigitsString()
{
var result = new Pronoun("1111", s);
Assert.AreEqual(result.value, PronounFlags.NONE);
Assert.AreEqual("none", result.ToString());
}
public void PronounsFromProfile_4()
{
var result = new Pronoun("Name/Nick - they/she", s);
Assert.AreEqual(result.value, PronounFlags.SHE | PronounFlags.THEY | PronounFlags.ORDER_RTL);
Assert.AreEqual("they/she", result.ToString());
}
public void PronounsFromProfile_5()
{
var result = new Pronoun("I'm a streamer, 99 years old, ⛳. She/Her. I enjoy Splatoon.", s);
Assert.AreEqual(result.value, PronounFlags.SHE);
Assert.AreEqual("she/her", result.ToString());
}
public void MatchSingleString_She2()
{
var result = new Pronoun("She/her", s);
Assert.AreEqual(result.value, PronounFlags.SHE);
Assert.AreEqual("she/her", result.ToString());
}
public void PronounsFromProfile_3()
{
var result = new Pronoun("They/Them - 99 - UTC", s);
Assert.AreEqual(result.value, PronounFlags.THEY);
Assert.AreEqual("they/them", result.ToString());
}
public void PronounsFromProfile_1()
{
var result = new Pronoun("**she/they** • chaotic kazoo bard •", s);
Assert.AreEqual(result.value, PronounFlags.SHE | PronounFlags.THEY);
Assert.AreEqual("she/they", result.ToString());
}
public void MatchSingleString_They()
{
var result = new Pronoun("they", s);
Assert.AreEqual(result.value, PronounFlags.THEY);
Assert.AreEqual("they/them", result.ToString());
}
public void MatchMultipleString_SheThey_Reverse()
{
const string test = "they/she";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.SHE | PronounFlags.THEY | PronounFlags.ORDER_RTL);
Assert.AreEqual(test, result.ToString());
}
public void MatchSingleString_It2()
{
const string test = "it/it";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.IT);
Assert.AreEqual(test, result.ToString());
}
public void MatchSingleString_He2()
{
const string test = "he/him";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.HE);
Assert.AreEqual(test, result.ToString());
}
public void MatchMultipleString_SheNeo_Reverse()
{
const string test = "ve/she";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.SHE | PronounFlags.NEO | PronounFlags.ORDER_RTL);
Assert.AreEqual(Pronoun.NEO_PLACEHOLDER + "/she", result.ToString());
}
public void MatchMultipleString_SheNeo()
{
const string test = "she/ve";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.SHE | PronounFlags.NEO);
Assert.AreEqual("she/" + Pronoun.NEO_PLACEHOLDER, result.ToString());
}
public void MatchMultipleString_HeIt_Reverse()
{
const string test = "it/he";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.HE | PronounFlags.IT | PronounFlags.ORDER_RTL);
Assert.AreEqual(test, result.ToString());
}
public void MatchMultipleString_HeIt()
{
const string test = "he/it";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.HE | PronounFlags.IT);
Assert.AreEqual(test, result.ToString());
}
public void MatchMultipleString_SheThey()
{
const string test = "she/they";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.SHE | PronounFlags.THEY);
Assert.AreEqual(test, result.ToString());
}
public void MatchSingleString_They2()
{
const string test = "they/them";
var result = new Pronoun(test, s);
Assert.AreEqual(result.value, PronounFlags.THEY);
Assert.AreEqual(test, result.ToString());
}
public void MatchNeoBranches()
{
foreach (var test in new string[] { "ce", "cer", "eir", "eirself", "em", "emself", "ey", "ne", "sie", "ve", "ver", "vis", "xe", "xem", "xemself", "xyr", "ze", "zie", "zirs" })
{
var result = new Pronoun(test, s);
Assert.AreEqual(PronounFlags.NEO, result.value, $"Expected Neo parse for pronoun {test}");
Assert.AreEqual(Pronoun.NEO_PLACEHOLDER, result.ToString(), $"Expected Neo parse for pronoun {test}");
}
}
public void NoMatchNeoBranches()
{
foreach (var test in new string[] { "care", "air", "airs", "cat", "dog", "them", "themself", "ye", "yes", "sit", "vet", "visit", "ex", "zero" })
{
var result = new Pronoun(test, s);
Assert.AreNotEqual(result.value, PronounFlags.NEO, $"Unexpected Neo parse for pronoun {test}");
Assert.AreNotEqual(Pronoun.NEO_PLACEHOLDER, result.ToString(), $"Unexpected Neo parse for pronoun {test}");
}
}
// Lie les noms et les compléments du nom et place le résultat dans phraseFonction.
private static void LierNomsComplNom(List <Word> phrase, List <Word[]> phraseFonction)
{
for (ushort indiceMotCourant = 0; indiceMotCourant < phrase.Count; indiceMotCourant++)
{
Word mot = phrase[indiceMotCourant];
bool quiSujet = true;
// Si on tombe sur un nom ou nom propre...
if ((mot.Nature == "nom" || mot.Nature == "nom propre") && indiceMotCourant < phrase.Count - 1)
{
VariableWord nomComplete = (VariableWord)mot;
ushort indiceMotTeste = (ushort)(indiceMotCourant + 1);
// On cherche un éventuel complément du nom, qui se situe toujours après le nom.
// Le complément du nom est la plupart du temps précédé d'une préposition.
// Ainsi, pour savoir si le nom possède un complément du nom, on regarde si une
// préposition se trouve après lui.
if (phrase[indiceMotTeste].Nature == "préposition")
{
Word laPreposition = phrase[indiceMotTeste];
if (indiceMotTeste < phrase.Count - 1)
{
indiceMotTeste++;
// Si le mot suivant la préposition est et nom, un nom propre, un pronom, un verbe infinitif, ou un adverbe,
// la préposition se rattache à ce mot suivant.
if (new string[] { "nom", "nom propre", "pronom", "verbe infinitif", "adverbe" }.Contains(phrase[indiceMotTeste].Nature))
{
phraseFonction.Add(new Word[] { laPreposition, new LinkBetweenWord("PREP"), phrase[indiceMotTeste] });
}
// On supprime la préposition de la phrase et vu que cela décale les mots vers la gauche, on fait indiceMotTeste-=2
// pour retomber sur le nom complément.
phrase.RemoveAt(indiceMotTeste - 1);
indiceMotTeste--;
if (phrase[indiceMotTeste].ToString() == "qui")
{
indiceMotTeste--;
quiSujet = false;
}
// On traite le cas où le nom complément peut être suivi d'un pronom relatif (qui que quoi dont où -quel)
// qui se rattache au nom complément (et non pas au nom complété). La seule façon de savoir si le pronom
// relatif "QUI" (sujet) se rattache au nom complément ou au nom complété est de regarder les accords avec
// le verbe dans la suite de la phrase, pour voir à quel nom entre le nom complément et le nom complété
// conjugue le verbe. Si les deux noms sont du même genre/nombre... on ne peut devenir que grâce au sens de la phrase !
// Pour les autres pronoms relatifs (que COD, quoi, dont (= de qui) COI, auquel (= de qui) COI, où CCL),
// ils se rattachent la plupart du temps au nom qui se trouve juste avant (donc le nom complément) s'il
// n'y a pas de virgule pour les séparer.
// Le pronom relatif ne peut se rattacher qu'à un nom, on vérifie donc que le mot soit un nom.
// On vérifie également qu'on ne se situe pas au dernier mot, et donc qu'il y a encore des mots après...
// Enfin, on regarde si le mot suivant est un pronom.
if ((phrase[indiceMotTeste].Nature == "nom" || phrase[indiceMotTeste].Nature == "nom propre") &&
indiceMotTeste < phrase.Count - 1 && phrase[indiceMotTeste + 1].Nature == "pronom")
{
Name nomComplement = (Name)phrase[indiceMotTeste];
Pronoun pronom = (Pronoun)phrase[indiceMotTeste + 1];
// On vérifie que le pronom soit de type relatif.
if (pronom.Type.Contains("relatif"))
{
// Si le pronom relatif est "qui"...
#region Cas où le pronom relatif est "qui"
if (pronom.ToString() == "qui")
{
// Tant qu'il y a encore un encore un mot après...
for (ushort i = (ushort)(indiceMotTeste + 2); i < phrase.Count; i++)
{
// Si on a trouvé un verbe conjugué...
if (phrase[i].Nature == "verbe conjugué")
{
ConjugatedVerb verbeConjugue = (ConjugatedVerb)phrase[i];
// Si le verbe est conjugué à un temps composé (et donc qu'il possède un participe passé accordable)...
#region Cas où le verbe est à un temps composé
if (verbeConjugue.IsTempsCompose())
{
// On récupère l'auxiliaire.
Verb auxConjugue = new ConjugatedVerb(verbeConjugue.GetAuxiliaireConjugue(), verbeConjugue.Person);
// On le passe à l'infinitif.
Verb.ToInfinitive(ref auxConjugue);
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complément.
if (quiSujet && auxConjugue.ToString() == "être" && SontAccordes(nomComplement, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complété.
else if (quiSujet && auxConjugue.ToString() == "être" && SontAccordes(nomComplete, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
}
#endregion
// Sinon, si le verbe n'est pas à un temps composé, on regarde s'il s'agit du verbe être et
// on cherche s'il est suivi d'un adjectif, accordable...
#region Cas où le verbe n'est pas à un temps composé, on cherche un adjectif à la suite.
else if (verbeConjugue.Action == "être" && i < phrase.Count - 1)
{
// On ne cherche l'adjectif que 4 positions plus loin dans la phrase.
for (int j = i + 1; j < i + 5; j++)
{
// Si on trouve un adjectif...
if (phrase[j].Nature == "adjectif")
{
// Si cet adjectif est accordé avec le nom complément...
if (SontAccordes(nomComplement, (VariableWord)phrase[j]))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Sinon, si cet adjectif est accordé avec le nom complété...
else if (SontAccordes(nomComplete, (VariableWord)phrase[j]))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// On sort du for après le premier adjectif trouvé.
break;
}
}
}
#endregion
break;
}
}
}
#endregion
// Sinon, si le pronom relatif est "que"...
#region Cas où le pronom relatif est "que"
else if (pronom.ToString() == "que")
{
// Tant qu'il y a encore un encore un mot après...
for (ushort i = (ushort)(indiceMotTeste + 2); i < phrase.Count; i++)
{
// Si on a trouvé un verbe conjugué...
if (phrase[i].Nature == "verbe conjugué")
{
ConjugatedVerb verbeConjugue = (ConjugatedVerb)phrase[i];
// Si le verbe est conjugué à un temps composé (et donc qu'il possède un participe passé accordable)...
#region Cas où le verbe est à un temps composé
if (verbeConjugue.IsTempsCompose())
{
// On récupère l'auxiliaire.
Verb auxConjugue = new ConjugatedVerb(verbeConjugue.GetAuxiliaireConjugue(), verbeConjugue.Person);
// On le passe à l'infinitif.
Verb.ToInfinitive(ref auxConjugue);
// Si le verbe utilise l'auxiliaire avoir, et que le nom complément est accordé avec le participe passé,
// le pronom relatif remplace le nom complément (car avec avoir, le participe passé s'accorde avec le COD
// si ce dernier se situe avant le verbe).
if (auxConjugue.ToString() == "avoir" && SontAccordes(nomComplement, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
// Si le verbe utilise l'auxiliaire être, et que le nom complément est accordé avec le verbe,
// le pronom relatif remplace le nom complété.
else if (auxConjugue.ToString() == "avoir" && SontAccordes(nomComplete, verbeConjugue))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplete });
}
// Autrement, le cas par défaut est que le pronom relatif remplace le nom précédent, donc nom complément.
else
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
}
#endregion
break;
}
}
}
#endregion
// Sinon, si le pronom relatif est "dont", "auquel", "où"...
#region Cas où le pronom relatif est "dont", "auquel", "où"
else if (new string[] { "dont", "auquel", "où" }.Contains(pronom.ToString()))
{
phraseFonction.Add(new Word[] { pronom, new LinkBetweenWord("REMPLACE"), nomComplement });
}
#endregion
}
}
}
}
// TODO: Traiter les rares cas où le complément du nom n'est pas séparé du nom par une préposition.
}
}
}
/// <exception cref="InvalidEnumArgumentException">Thrown if a valid Pronoun is passed in without being supported</exception>
public static string GetTerm(this GenderedTermType t, Pronoun pronoun)
{
GenderedTermTypeAttr attr = GetAttr(t);
switch (pronoun)
{
case Pronoun.HE: return(attr.HeTerm);
case Pronoun.SHE: return(attr.SheTerm);
case Pronoun.THEY: return(attr.TheyTerm);
default: throw new InvalidEnumArgumentException("Unsupported pronoun: \"" + pronoun.ToString() + "\"");
}
}