public override IWordAligner Load(SpanFactory<ShapeNode> spanFactory, SegmentPool segmentPool, CogProject project, XElement elem)
{
var settings = new AlineSettings();
LoadSettings(project.Segmenter, project.FeatureSystem, elem, settings);
XElement relevantFeaturesElem = elem.Element(ConfigManager.Cog + "RelevantFeatures");
Debug.Assert(relevantFeaturesElem != null);
var relevantVowelFeatures = new List<SymbolicFeature>();
var relevantConsFeatures = new List<SymbolicFeature>();
var featureWeights = new Dictionary<SymbolicFeature, int>();
var valueMetrics = new Dictionary<FeatureSymbol, int>();
foreach (XElement featureElem in relevantFeaturesElem.Elements(ConfigManager.Cog + "RelevantFeature"))
{
var feature = project.FeatureSystem.GetFeature<SymbolicFeature>((string) featureElem.Attribute("ref"));
if ((bool?) featureElem.Attribute("vowel") ?? false)
relevantVowelFeatures.Add(feature);
if ((bool?) featureElem.Attribute("consonant") ?? false)
relevantConsFeatures.Add(feature);
featureWeights[feature] = (int) featureElem.Attribute("weight");
foreach (XElement valueElem in featureElem.Elements(ConfigManager.Cog + "RelevantValue"))
{
FeatureSymbol symbol = feature.PossibleSymbols[(string) valueElem.Attribute("ref")];
valueMetrics[symbol] = (int) valueElem.Attribute("metric");
}
}
settings.SoundChangeScoringEnabled = (bool?) elem.Element(ConfigManager.Cog + "SoundChangeScoringEnabled") ?? true;
settings.SyllablePositionCostEnabled = (bool?) elem.Element(ConfigManager.Cog + "SyllablePositionCostEnabled") ?? true;
return new Aline(segmentPool, relevantVowelFeatures, relevantConsFeatures, featureWeights, valueMetrics, settings);
}
private IEnumerable <IProcessor <Variety> > GetSegmentProcessors()
{
CogProject project = _projectService.Project;
return(new[]
{
new VarietySegmenter(project.Segmenter),
project.VarietyProcessors[ComponentIdentifiers.Syllabifier],
new SegmentFrequencyDistributionCalculator(_segmentPool)
});
}
public void Import(object importSettingsViewModel, Stream stream, CogProject project)
{
var reader = new CsvReader(new StreamReader(stream), ',');
if (!SkipRows(reader, 5))
{
project.Meanings.Clear();
project.Varieties.Clear();
return;
}
var varieties = new List <Variety>();
var meanings = new Dictionary <string, Meaning>();
IList <string> varietyRow;
while (reader.ReadRow(out varietyRow))
{
if (string.IsNullOrEmpty(varietyRow[0]))
{
break;
}
var variety = new Variety(varietyRow[0].Trim());
if (!SkipRows(reader, 2))
{
throw new ImportException("Metadata for a variety is incomplete.");
}
Meaning curMeaning = null;
IList <string> glossRow;
while (reader.ReadRow(out glossRow) && glossRow.Any(s => !string.IsNullOrEmpty(s)))
{
if (!string.IsNullOrEmpty(glossRow[0]))
{
string gloss = glossRow[0].Trim();
curMeaning = meanings.GetOrCreate(gloss, () => new Meaning(gloss, null));
}
if (curMeaning == null)
{
throw new ImportException("A gloss is missing.");
}
string wordStr = glossRow[1].Trim();
if (!string.IsNullOrEmpty(wordStr))
{
variety.Words.Add(new Word(wordStr, curMeaning));
}
}
varieties.Add(variety);
}
project.Meanings.ReplaceAll(meanings.Values);
project.Varieties.ReplaceAll(varieties);
}
public void Export_PhoneticSimilarity()
{
CogProject project = CreateProject();
var exporter = new NexusSimilarityMatrixExporter();
using (var stream = new MemoryStream())
{
exporter.Export(stream, project, SimilarityMetric.Phonetic);
Assert.That(Encoding.UTF8.GetString(stream.ToArray()), Is.EqualTo(string.Format(NexusFileTemplate, 0.05, 0.15, 0.25)));
}
}
private void CloseProject()
{
if (_projectFileStream != null)
{
_projectFileStream.Close();
_projectFileStream = null;
}
_project = null;
_projectName = null;
_isChanged = false;
}
private CogProject CreateProject()
{
var project = new CogProject();
var variety1 = new Variety("variety1");
project.Varieties.Add(variety1);
var variety2 = new Variety("variety2");
project.Varieties.Add(variety2);
var variety3 = new Variety("variety3");
project.Varieties.Add(variety3);
var meaning1 = new Meaning("meaning1", null);
project.Meanings.Add(meaning1);
var meaning2 = new Meaning("meaning2", null);
project.Meanings.Add(meaning2);
var meaning3 = new Meaning("meaning3", null);
project.Meanings.Add(meaning3);
variety1.Words.Add(new Word("word1", meaning1));
variety1.Words.Add(new Word("word2", meaning2));
variety1.Words.Add(new Word("word3", meaning3));
variety2.Words.Add(new Word("word4", meaning1));
variety2.Words.Add(new Word("word5", meaning2));
variety2.Words.Add(new Word("word6", meaning3));
variety3.Words.Add(new Word("word7", meaning1));
variety3.Words.Add(new Word("word8", meaning2));
variety3.Words.Add(new Word("word9", meaning3));
var vpGenerator = new VarietyPairGenerator();
vpGenerator.Process(project);
double score = 1.0;
foreach (VarietyPair vp in project.VarietyPairs)
{
foreach (Meaning meaning in project.Meanings)
{
Word w1 = vp.Variety1.Words[meaning].First();
Word w2 = vp.Variety2.Words[meaning].First();
WordPair wp = vp.WordPairs.Add(w1, w2);
wp.PredictedCognacyScore = score;
wp.PredictedCognacy = true;
score -= 0.1;
}
}
return(project);
}
public void Export()
{
CogProject project = CreateProject();
var exporter = new NexusCognateSetsExporter();
using (var stream = new MemoryStream())
{
exporter.Export(stream, project);
Assert.That(Encoding.UTF8.GetString(stream.ToArray()), Is.EqualTo(string.Format(NexusFileTemplate, "112", "112", "111")));
}
}
public void Varieties_Remove_VarietyRemoved()
{
using (var env = new WordListsViewModelTestEnvironment())
{
CogProject project = SetupProjectWithThreeVarieties(env);
project.Varieties.RemoveAt(0);
Assert.That(env.WordListsViewModel.Varieties.Select(v => v.Name), Is.EqualTo(new[] { "variety2", "variety3" }));
Assert.That(env.WordListsViewModel.IsEmpty, Is.False);
}
}
public void Varieties_Clear_AllVarietiesRemoved()
{
using (var env = new WordListsViewModelTestEnvironment())
{
CogProject project = SetupProjectWithThreeVarieties(env);
project.Varieties.Clear();
Assert.That(env.WordListsViewModel.Varieties.Count, Is.EqualTo(0));
Assert.That(env.WordListsViewModel.IsEmpty, Is.True);
}
}
public void Meanings_Remove_MeaningRemoved()
{
using (var env = new WordListsViewModelTestEnvironment())
{
CogProject project = SetupProjectWithThreeMeanings(env);
project.Meanings.RemoveAt(0);
Assert.That(env.WordListsViewModel.Meanings.Select(s => s.Gloss), Is.EqualTo(new[] { "gloss2", "gloss3" }));
Assert.That(env.WordListsViewModel.IsEmpty, Is.False);
}
}
private CogProject SetupProject(WordListsViewModelTestEnvironment env)
{
var project = new CogProject()
{
Meanings = { new Meaning("gloss1", "cat1") },
Varieties = { new Variety("variety1") }
};
env.OpenProject(project);
return(project);
}
public void OpenProject(CogProject project)
{
_projectService.Project.Returns(project);
_projectService.ProjectOpened += Raise.Event();
VarietiesViewModel.VarietiesView = new ListCollectionView(VarietiesViewModel.Varieties);
if (VarietiesViewModel.SelectedVariety != null)
{
WordsViewModel wordsViewModel = VarietiesViewModel.SelectedVariety.Words;
wordsViewModel.WordsView = new ListCollectionView(wordsViewModel.Words);
}
}
private IEnumerable <IProcessor <VarietyPair> > GetCompareProcessors()
{
CogProject project = _projectService.Project;
var processors = new List <IProcessor <VarietyPair> >
{
project.VarietyPairProcessors[ComponentIdentifiers.WordPairGenerator],
new EMSoundChangeInducer(_segmentPool, project, ComponentIdentifiers.PrimaryWordAligner, ComponentIdentifiers.PrimaryCognateIdentifier),
new SoundCorrespondenceIdentifier(_segmentPool, project, ComponentIdentifiers.PrimaryWordAligner)
};
return(processors);
}
public override void Setup()
{
CogProject project = _projectService.Project;
IEnumerable <SonorityClass> sonorityScale;
var syllabifier = (SimpleSyllabifier)project.VarietyProcessors[ComponentIdentifiers.Syllabifier];
var sspSyllabifier = syllabifier as SspSyllabifier;
bool automaticSyllabificationEnabled;
bool vowelsSameSonorityTautosyllabic;
if (sspSyllabifier != null)
{
vowelsSameSonorityTautosyllabic = sspSyllabifier.VowelsSameSonorityTautosyllabic;
sonorityScale = sspSyllabifier.SonorityScale;
automaticSyllabificationEnabled = true;
}
else
{
vowelsSameSonorityTautosyllabic = false;
sonorityScale = new[]
{
new SonorityClass(1, new UnnaturalClass("Prenasal", new[] { "ᵐ", "ⁿ", "ᵑ" }, false, project.Segmenter)),
new SonorityClass(2, new NaturalClass("Stop", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.ConsonantType).Symbol("stop").Symbol("nasal-").Value)),
new SonorityClass(3, new NaturalClass("Affricate", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.ConsonantType).Symbol("affricate").Value)),
new SonorityClass(4, new NaturalClass("Fricative", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.ConsonantType).Symbol("fricative").Symbol("lateral-").Value)),
new SonorityClass(5, new NaturalClass("Nasal", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.ConsonantType).Symbol("nasal+").Value)),
new SonorityClass(6, new NaturalClass("Trill", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.ConsonantType).Symbol("trill").Value)),
new SonorityClass(7, new NaturalClass("Lateral", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.ConsonantType).Symbol("lateral+").Value)),
new SonorityClass(8, new NaturalClass("Flap", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.ConsonantType).Symbol("flap").Value)),
new SonorityClass(9, new UnnaturalClass("Glide", new[] { "j", "ɥ", "ɰ", "w" }, true, project.Segmenter)),
new SonorityClass(9, new NaturalClass("Non-syllabic vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic-").Value)),
new SonorityClass(10, new NaturalClass("Close vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic+").Symbol("close").Value)),
new SonorityClass(11, new NaturalClass("Near-close vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic+").Symbol("near-close").Value)),
new SonorityClass(12, new NaturalClass("Close-mid vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic+").Symbol("close-mid").Value)),
new SonorityClass(13, new NaturalClass("Mid vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic+").Symbol("mid").Value)),
new SonorityClass(14, new NaturalClass("Open-mid vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic+").Symbol("open-mid").Value)),
new SonorityClass(15, new NaturalClass("Near-open vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic+").Symbol("near-open").Value)),
new SonorityClass(16, new NaturalClass("Open vowel", FeatureStruct.New(project.FeatureSystem).Symbol(CogFeatureSystem.VowelType).Symbol("syllabic+").Symbol("open").Value))
};
automaticSyllabificationEnabled = false;
}
Set(() => CombineVowels, ref _combineVowels, syllabifier.CombineVowels);
Set(() => CombineConsonants, ref _combineConsonants, syllabifier.CombineConsonants);
Set(() => VowelsSameSonorityTautosyllabic, ref _vowelsSameSonorityTautosyllabic, vowelsSameSonorityTautosyllabic);
Set(() => AutomaticSyllabificationEnabled, ref _automaticSyllabificationEnabled, automaticSyllabificationEnabled);
_sonorityClasses.SelectedSoundClass = null;
_sonorityClasses.SoundClasses.Clear();
foreach (SonorityClass sonorityClass in sonorityScale)
{
_sonorityClasses.SoundClasses.Add(new SoundClassViewModel(sonorityClass.SoundClass, sonorityClass.Sonority));
}
}
public void StrRep()
{
DispatcherHelper.Initialize();
var busyService = Substitute.For <IBusyService>();
var projectService = Substitute.For <IProjectService>();
var analysisService = Substitute.For <IAnalysisService>();
var project = new CogProject(_spanFactory);
project.Meanings.Add(new Meaning("gloss1", "cat1"));
project.Varieties.Add(new Variety("variety1"));
WordViewModel.Factory wordFactory = word => new WordViewModel(busyService, analysisService, word);
WordListsVarietyMeaningViewModel.Factory varietyMeaningFactory = (v, meaning) => new WordListsVarietyMeaningViewModel(busyService, analysisService, wordFactory, v, meaning);
projectService.Project.Returns(project);
var variety = new WordListsVarietyViewModel(projectService, varietyMeaningFactory, project.Varieties[0]);
WordListsVarietyMeaningViewModel varietyMeaning = variety.Meanings[0];
Assert.That(varietyMeaning.Words, Is.Empty);
Assert.That(varietyMeaning.StrRep, Is.Empty);
project.Varieties[0].Words.Add(new Word("hɛ.loʊ", project.Meanings[0]));
Assert.That(varietyMeaning.StrRep, Is.EqualTo("hɛ.loʊ"));
Assert.That(varietyMeaning.Words.Select(w => w.StrRep), Is.EqualTo(new[] { "hɛ.loʊ" }));
project.Varieties[0].Words.Add(new Word("gu.gəl", project.Meanings[0]));
Assert.That(varietyMeaning.StrRep, Is.EqualTo("hɛ.loʊ,gu.gəl"));
Assert.That(varietyMeaning.Words.Select(w => w.StrRep), Is.EqualTo(new[] { "hɛ.loʊ", "gu.gəl" }));
varietyMeaning.StrRep = "hɛ.lp,gu.gəl";
Assert.That(varietyMeaning.Words.Select(w => w.StrRep), Is.EqualTo(new[] { "hɛ.lp", "gu.gəl" }));
varietyMeaning.StrRep = "hɛ.lp";
Assert.That(varietyMeaning.Words.Select(w => w.StrRep), Is.EqualTo(new[] { "hɛ.lp" }));
varietyMeaning.StrRep = "";
Assert.That(varietyMeaning.Words, Is.Empty);
varietyMeaning.StrRep = null;
Assert.That(varietyMeaning.Words, Is.Empty);
varietyMeaning.StrRep = " hɛ.lp,gu.gəl ,gu.fi ";
Assert.That(varietyMeaning.Words.Select(w => w.StrRep), Is.EqualTo(new[] { "hɛ.lp", "gu.gəl", "gu.fi" }));
Assert.That(varietyMeaning.StrRep, Is.EqualTo("hɛ.lp,gu.gəl,gu.fi"));
varietyMeaning.StrRep = "hɛ.lp,gu.gəl,gu";
Assert.That(varietyMeaning.Words.Select(w => w.StrRep), Is.EqualTo(new[] { "hɛ.lp", "gu.gəl", "gu" }));
}
public ICognateIdentifier Load(SegmentPool segmentPool, CogProject project, XElement elem)
{
var ignoreRegularInsertionDeletion = (bool?)elem.Element(ConfigManager.Cog + "IgnoreRegularInsertionDeletion") ?? false;
var regularConsEqual = (bool?)elem.Element(ConfigManager.Cog + "RegularConsonantsAreEqual") ?? false;
var automaticRegularCorrespondenceThreshold = (bool?)elem.Element(ConfigManager.Cog + "AutomaticRegularCorrespondenceThreshold") ?? false;
var defaultRegularCorrespondenceThreshold = (int?)elem.Element(ConfigManager.Cog + "DefaultRegularCorrespondenceThreshold") ?? 3;
var ignoredMappings = ConfigManager.LoadComponent <ISegmentMappings>(segmentPool, project, elem.Element(ConfigManager.Cog + "IgnoredCorrespondences"));
var similarSegments = ConfigManager.LoadComponent <ISegmentMappings>(segmentPool, project, elem.Element(ConfigManager.Cog + "SimilarSegments"));
return(new BlairCognateIdentifier(segmentPool, ignoreRegularInsertionDeletion, regularConsEqual, automaticRegularCorrespondenceThreshold,
defaultRegularCorrespondenceThreshold, ignoredMappings, similarSegments));
}
public void StrRep_SetStrRepNull_WordsEmpty()
{
using (var env = new WordListsViewModelTestEnvironment())
{
CogProject project = SetupProject(env);
WordListsVarietyMeaningViewModel varietyMeaning = env.WordListsViewModel.Varieties[0].Meanings[0];
project.Varieties[0].Words.Add(new Word("hɛ.loʊ", project.Meanings[0]));
varietyMeaning.StrRep = null;
Assert.That(varietyMeaning.Words, Is.Empty);
}
}
// We may not ever use this function; if so, we can delete it later.
public void CheckIsDefaultProject(CogProject project)
{
Assert.That(project, Is.Not.Null);
Assert.That(project.Varieties, Is.Empty);
Assert.That(project.FeatureSystem, Is.Not.Empty);
Assert.That(project.FeatureSystem.Count, Is.EqualTo(17));
Assert.That(project.FeatureSystem.Select(feat => feat.ToString()).Take(5),
Is.EquivalentTo(new[] { "Place", "Manner", "Syllabic", "Voice", "Nasal" }));
IEnumerable <string> consonantSample = project.Segmenter.Consonants.Select(symbol => symbol.StrRep).Skip(20).Take(20);
string joinedSample = string.Join("", consonantSample);
Assert.That(joinedSample, Is.EqualTo("zçðħŋᵑɓɕɖɗɟɠɡɢɣɥɦɧɫɬ"));
}
private void SetupProjectWithWords(WordListsViewModelTestEnvironment env)
{
var project = new CogProject(env.SpanFactory)
{
Meanings = { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") },
Varieties = { new Variety("variety1"), new Variety("variety2") }
};
project.Varieties[0].Words.AddRange(new[] { new Word("hello", project.Meanings[0]), new Word("good", project.Meanings[1]), new Word("bad", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("help", project.Meanings[0]), new Word("google", project.Meanings[1]), new Word("batter", project.Meanings[2]) });
env.OpenProject(project);
}
public IProcessor <VarietyPair> Load(SegmentPool segmentPool, CogProject project, XElement elem)
{
XElement alignerElem = elem.Element(ConfigManager.Cog + "ApplicableWordAligner");
Debug.Assert(alignerElem != null);
var alignerID = (string)alignerElem.Attribute("ref");
XElement cognateIdentifierElem = elem.Element(ConfigManager.Cog + "ApplicableCognateIdentifier");
Debug.Assert(cognateIdentifierElem != null);
var cognateIdentifierID = (string)cognateIdentifierElem.Attribute("ref");
return(new EMSoundChangeInducer(segmentPool, project, alignerID, cognateIdentifierID));
}
public void UpdateCognicity_RegularCorrespondences()
{
var segmentPool = new SegmentPool();
CogProject project = TestHelpers.GetTestProject(_spanFactory, segmentPool);
project.Meanings.AddRange(new[] { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") });
project.Varieties.AddRange(new[] { new Variety("variety1"), new Variety("variety2") });
project.Varieties[0].Words.AddRange(new[] { new Word("hɛ.lo", project.Meanings[0]), new Word("gʊd", project.Meanings[1]), new Word("bæ", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("hɛ.ɬa", project.Meanings[0]), new Word("gud", project.Meanings[1]), new Word("pæ", project.Meanings[2]) });
var varSegementer = new VarietySegmenter(project.Segmenter);
foreach (Variety variety in project.Varieties)
{
varSegementer.Process(variety);
}
var vp = new VarietyPair(project.Varieties[0], project.Varieties[1]);
project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(segmentPool, project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("l"))].Increment(segmentPool.GetExisting("ɬ"), 3);
vp.SoundChangeFrequencyDistribution[new SoundContext(segmentPool.GetExisting("b"))].Increment(segmentPool.GetExisting("p"), 3);
var aligner = new TestWordAligner(segmentPool);
var ignoredMappings = Substitute.For <ISegmentMappings>();
ignoredMappings.IsMapped(Arg.Any <ShapeNode>(), Arg.Any <Ngram <Segment> >(), Arg.Any <ShapeNode>(), Arg.Any <ShapeNode>(), Arg.Any <Ngram <Segment> >(), Arg.Any <ShapeNode>()).Returns(false);
var similarSegmentsMappings = Substitute.For <ISegmentMappings>();
similarSegmentsMappings.IsMapped(Arg.Any <ShapeNode>(), segmentPool.GetExisting("b"), Arg.Any <ShapeNode>(), Arg.Any <ShapeNode>(), segmentPool.GetExisting("p"), Arg.Any <ShapeNode>()).Returns(true);
var cognateIdentifier = new BlairCognateIdentifier(segmentPool, false, false, ignoredMappings, similarSegmentsMappings);
var wp = vp.WordPairs[0];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[1];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
wp = vp.WordPairs[2];
cognateIdentifier.UpdateCognicity(wp, aligner.Compute(wp));
Assert.That(wp.AreCognatePredicted, Is.True);
}
private CogProject SetupProjectWithWords(TestEnvironment env)
{
var project = new CogProject()
{
Meanings = { new Meaning("gloss1", "cat1"), new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") },
Varieties = { new Variety("variety1"), new Variety("variety2") }
};
project.Varieties[0].Words.AddRange(new[] { new Word("hello", project.Meanings[0]), new Word("good", project.Meanings[1]), new Word("bad", project.Meanings[2]) });
project.Varieties[1].Words.AddRange(new[] { new Word("help", project.Meanings[0]), new Word("google", project.Meanings[1]), new Word("goofy", project.Meanings[2]) });
env.OpenProject(project);
return(project);
}
public void Varieties()
{
DispatcherHelper.Initialize();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var analysisService = Substitute.For <IAnalysisService>();
WordsViewModel.Factory wordsFactory = words => new WordsViewModel(busyService, words);
WordViewModel.Factory wordFactory = word => new WordViewModel(busyService, analysisService, word);
VarietiesVarietyViewModel.Factory varietyFactory = variety => new VarietiesVarietyViewModel(projectService, dialogService, wordsFactory, wordFactory, variety);
var varieties = new VarietiesViewModel(projectService, dialogService, analysisService, varietyFactory);
var project = new CogProject(_spanFactory);
projectService.Project.Returns(project);
projectService.ProjectOpened += Raise.Event();
varieties.VarietiesView = new ListCollectionView(varieties.Varieties);
Assert.That(varieties.Varieties, Is.Empty);
Assert.That(varieties.IsVarietySelected, Is.False);
Assert.That(varieties.SelectedVariety, Is.Null);
project.Varieties.Add(new Variety("variety1"));
Assert.That(varieties.Varieties.Count, Is.EqualTo(1));
Assert.That(varieties.Varieties[0].Name, Is.EqualTo("variety1"));
Assert.That(varieties.IsVarietySelected, Is.True);
Assert.That(varieties.SelectedVariety, Is.EqualTo(varieties.VarietiesView.Cast <VarietiesVarietyViewModel>().First()));
project = new CogProject(_spanFactory)
{
Varieties = { new Variety("French"), new Variety("English"), new Variety("Spanish") }
};
projectService.Project.Returns(project);
projectService.ProjectOpened += Raise.Event();
Assert.That(varieties.Varieties.Select(v => v.Name), Is.EqualTo(new[] { "French", "English", "Spanish" }));
Assert.That(varieties.IsVarietySelected, Is.False);
Assert.That(varieties.SelectedVariety, Is.Null);
varieties.VarietiesView = new ListCollectionView(varieties.Varieties);
VarietiesVarietyViewModel[] varietiesViewArray = varieties.VarietiesView.Cast <VarietiesVarietyViewModel>().ToArray();
Assert.That(varieties.IsVarietySelected, Is.True);
Assert.That(varieties.SelectedVariety, Is.EqualTo(varietiesViewArray[0]));
// should be sorted
Assert.That(varietiesViewArray.Select(v => v.Name), Is.EqualTo(new[] { "English", "French", "Spanish" }));
}
public IProcessor <VarietyPair> Load(SegmentPool segmentPool, CogProject project, XElement elem)
{
var initialAlignmentThreshold = (double)elem.Element(ConfigManager.Cog + "InitialAlignmentThreshold");
XElement alignerElem = elem.Element(ConfigManager.Cog + "ApplicableWordAligner");
Debug.Assert(alignerElem != null);
var alignerID = (string)alignerElem.Attribute("ref");
XElement cognateIdentifierElem = elem.Element(ConfigManager.Cog + "ApplicableCognateIdentifier");
Debug.Assert(cognateIdentifierElem != null);
var cognateIdentifierID = (string)cognateIdentifierElem.Attribute("ref");
return(new CognacyWordPairGenerator(segmentPool, project, initialAlignmentThreshold, alignerID, cognateIdentifierID));
}
public void Varieties()
{
DispatcherHelper.Initialize();
var projectService = Substitute.For <IProjectService>();
var dialogService = Substitute.For <IDialogService>();
var busyService = Substitute.For <IBusyService>();
var analysisService = Substitute.For <IAnalysisService>();
var importService = Substitute.For <IImportService>();
var exportService = Substitute.For <IExportService>();
WordViewModel.Factory wordFactory = word => new WordViewModel(busyService, analysisService, word);
WordListsVarietyMeaningViewModel.Factory varietyMeaningFactory = (variety, meaning) => new WordListsVarietyMeaningViewModel(busyService, analysisService, wordFactory, variety, meaning);
WordListsVarietyViewModel.Factory varietyFactory = variety => new WordListsVarietyViewModel(projectService, varietyMeaningFactory, variety);
var wordLists = new WordListsViewModel(projectService, dialogService, importService, exportService, analysisService, varietyFactory);
var project = new CogProject(_spanFactory)
{
Varieties = { new Variety("variety1"), new Variety("variety2"), new Variety("variety3") }
};
projectService.Project.Returns(project);
projectService.ProjectOpened += Raise.Event();
Assert.That(wordLists.Varieties.Select(v => v.Name), Is.EqualTo(new[] { "variety1", "variety2", "variety3" }));
Assert.That(wordLists.IsEmpty, Is.False);
project.Varieties.RemoveAt(0);
Assert.That(wordLists.Varieties.Select(v => v.Name), Is.EqualTo(new[] { "variety2", "variety3" }));
Assert.That(wordLists.IsEmpty, Is.False);
project.Varieties.Add(new Variety("variety1"));
Assert.That(wordLists.Varieties.Select(v => v.Name), Is.EqualTo(new[] { "variety2", "variety3", "variety1" }));
Assert.That(wordLists.IsEmpty, Is.False);
project.Varieties.Clear();
Assert.That(wordLists.Varieties.Count, Is.EqualTo(0));
Assert.That(wordLists.IsEmpty, Is.True);
project = new CogProject(_spanFactory)
{
Varieties = { new Variety("variety1") }
};
projectService.Project.Returns(project);
projectService.ProjectOpened += Raise.Event();
Assert.That(wordLists.Varieties.Select(v => v.Name), Is.EqualTo(new[] { "variety1" }));
Assert.That(wordLists.IsEmpty, Is.False);
}
public static bool Load(SegmentPool segmentPool, string configFilePath, out CogProject project)
{
XDocument doc;
try
{
doc = XDocument.Load(configFilePath);
}
catch (XmlException xe)
{
throw new ConfigException("The specified file is not a valid Cog config file", xe);
}
return(LoadProject(segmentPool, doc, out project));
}
public void Varieties_Add_VarietyAdded()
{
using (var env = new WordListsViewModelTestEnvironment())
{
CogProject project = new CogProject(env.SpanFactory)
{
Varieties = { new Variety("variety2"), new Variety("variety3") }
};
env.OpenProject(project);
project.Varieties.Add(new Variety("variety1"));
Assert.That(env.WordListsViewModel.Varieties.Select(v => v.Name), Is.EqualTo(new[] { "variety2", "variety3", "variety1" }));
Assert.That(env.WordListsViewModel.IsEmpty, Is.False);
}
}
public void Meanings_Add_MeaningAdded()
{
using (var env = new WordListsViewModelTestEnvironment())
{
CogProject project = new CogProject(env.SpanFactory)
{
Meanings = { new Meaning("gloss2", "cat2"), new Meaning("gloss3", "cat3") }
};
env.OpenProject(project);
project.Meanings.Add(new Meaning("gloss1", "cat1"));
Assert.That(env.WordListsViewModel.Meanings.Select(s => s.Gloss), Is.EqualTo(new[] { "gloss2", "gloss3", "gloss1" }));
Assert.That(env.WordListsViewModel.IsEmpty, Is.False);
}
}
public void Import(object importSettingsViewModel, Stream stream, CogProject project)
{
var vm = (ImportTextWordListsViewModel)importSettingsViewModel;
switch (vm.Format)
{
case TextWordListsFormat.VarietyRows:
ImportVarietyRows(stream, project, vm.CategoriesIncluded);
break;
case TextWordListsFormat.GlossRows:
ImportGlossRows(stream, project, vm.CategoriesIncluded);
break;
}
}
public WordPair ToWordPair(CogProject project, VarietyPair vp)
{
Meaning meaning = project.Meanings[Meaning];
Word word1 = vp.Variety1.Words[meaning].First(w => w.StrRep == Word1);
Word word2 = vp.Variety2.Words[meaning].First(w => w.StrRep == Word2);
var wp = new WordPair(word1, word2)
{
AreCognatePredicted = AreCognatePredicted,
PhoneticSimilarityScore = PhoneticSimilarityScore,
CognicityScore = CognicityScore
};
wp.AlignmentNotes.AddRange(_alignmentNotes);
return(wp);
}
public void Migrate(SegmentPool segmentPool, CogProject project)
{
Symbol symbol;
if (project.Segmenter.Consonants.TryGet("ħ", out symbol))
{
FeatureStruct fs = symbol.FeatureStruct.Clone();
fs.PriorityUnion(FeatureStruct.New(project.FeatureSystem)
.Symbol("pharyngeal")
.Symbol("fricative").Value);
fs.Freeze();
project.Segmenter.Consonants.Remove(symbol.StrRep);
project.Segmenter.Consonants.Add(symbol.StrRep, fs, symbol.Overwrite);
}
}
public TestEnvironment(string word1, string word2, bool ignoreRegularInsertionDeletion = false, bool regularConsEqual = false, bool automaticRegularCorrThreshold = false)
{
_segmentPool = new SegmentPool();
_project = TestHelpers.GetTestProject(_spanFactory, _segmentPool);
_project.Meanings.Add(new Meaning("gloss1", "cat1"));
_project.Varieties.AddRange(new[] {new Variety("variety1"), new Variety("variety2")});
_project.Varieties[0].Words.Add(new Word(word1, _project.Meanings[0]));
_project.Varieties[1].Words.Add(new Word(word2, _project.Meanings[0]));
var varSegementer = new VarietySegmenter(_project.Segmenter);
foreach (Variety variety in _project.Varieties)
varSegementer.Process(variety);
var vp = new VarietyPair(_project.Varieties[0], _project.Varieties[1]);
_project.VarietyPairs.Add(vp);
var wordPairGenerator = new SimpleWordPairGenerator(_segmentPool, _project, 0.3, "primary");
wordPairGenerator.Process(vp);
vp.CognateSoundCorrespondenceFrequencyDistribution = new ConditionalFrequencyDistribution<SoundContext, Ngram<Segment>>();
var ignoredMappings = Substitute.For<ISegmentMappings>();
var similarSegmentsMappings = Substitute.For<ISegmentMappings>();
_cognateIdentifier = new BlairCognateIdentifier(_segmentPool, ignoreRegularInsertionDeletion, regularConsEqual, automaticRegularCorrThreshold,
3, ignoredMappings, similarSegmentsMappings);
_aligner = new TestWordAligner(_segmentPool);
}
public ThresholdSegmentMappings(CogProject project, int threshold, string alignerID)
{
_project = project;
_threshold = threshold;
_alignerID = alignerID;
}
