public void EmptyPathnameThrows() { Assert.Throws <ArgumentNullException>(() => CmObjectFlatteningService.FlattenOwnerlessObject( "", new SortedDictionary <string, XElement>(), new XElement("junk"))); }
public void NullSortedDataCacheThrows() { using (var tempFile = new TempFile()) { var tempPath = tempFile.Path; Assert.Throws <ArgumentNullException>(() => CmObjectFlatteningService.FlattenOwnerlessObject( tempPath, null, new XElement("junk"))); } }
public void NullXelementThrows() { using (var tempFile = new TempFile()) { var tempPath = tempFile.Path; Assert.Throws <ArgumentNullException>(() => CmObjectFlatteningService.FlattenOwnerlessObject( tempPath, new SortedDictionary <string, XElement>(), null)); } }
public void EmptyGuidStringThrows() { using (var tempFile = new TempFile()) { var tempPath = tempFile.Path; Assert.Throws <ArgumentException>(() => CmObjectFlatteningService.FlattenOwnedObject( tempPath, new SortedDictionary <string, XElement>(), new XElement("junk"), string.Empty, new SortedDictionary <string, XElement>())); } }
/************************ Basic operations above here. ****************/ internal static void RestoreElement( string pathname, SortedDictionary <string, XElement> sortedData, XElement owningElement, string owningPropertyName, XElement ownedElement) { CmObjectFlatteningService.FlattenOwnedObject( pathname, sortedData, ownedElement, owningElement.Attribute(SharedConstants.GuidStr).Value, owningElement, owningPropertyName); // Restore 'ownerguid' to ownedElement. }
public void ReversalIndexOwnerRestored() { using (var tempFile = new TempFile()) { var sortedData = new SortedDictionary <string, XElement>(); CmObjectFlatteningService.FlattenOwnedObject( tempFile.Path, sortedData, _reversalIndexElement, ReversalOwnerGuid, new SortedDictionary <string, XElement>()); Assert.IsTrue(_reversalIndexElement.Attribute(SharedConstants.OwnerGuid).Value == ReversalOwnerGuid); } }
public void AllElementsFlattened() { using (var tempFile = new TempFile()) { var sortedData = new SortedDictionary <string, XElement>(); CmObjectFlatteningService.FlattenOwnerlessObject( tempFile.Path, sortedData, _reversalIndexElement); Assert.AreEqual(7, sortedData.Count()); Assert.AreEqual(1, sortedData.Values.Count(rt => rt.Attribute(SharedConstants.Class).Value == "ReversalIndex")); Assert.AreEqual(3, sortedData.Values.Count(rt => rt.Attribute(SharedConstants.Class).Value == "ReversalIndexEntry")); Assert.AreEqual(1, sortedData.Values.Count(rt => rt.Attribute(SharedConstants.Class).Value == SharedConstants.CmPossibilityList)); Assert.AreEqual(2, sortedData.Values.Count(rt => rt.Attribute(SharedConstants.Class).Value == "PartOfSpeech")); } }
public void ElementRenamed() { using (var tempFile = new TempFile()) { var tempPath = tempFile.Path; var sortedData = new SortedDictionary <string, XElement>(); CmObjectFlatteningService.FlattenOwnerlessObject( tempPath, sortedData, _reversalIndexElement); Assert.IsTrue(_reversalIndexElement.Name.LocalName == SharedConstants.RtTag); var classAttr = _reversalIndexElement.Attribute(SharedConstants.Class); Assert.IsNotNull(classAttr); Assert.AreEqual("ReversalIndex", classAttr.Value); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string scriptureBaseDir) { var stylesDir = scriptureBaseDir; // Just use main folder. // Path.Combine(baseDirectory, SharedConstants.Styles); if (!Directory.Exists(stylesDir)) { return; } var stylePathname = Path.Combine(scriptureBaseDir, StyleFilename); if (!File.Exists(stylePathname)) { return; } var doc = XDocument.Load(stylePathname); // StStyle instances are owned by Scripture in its Styles coll prop. var scrElement = highLevelData[SharedConstants.Scripture]; var scrOwningGuid = scrElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); var sortedStyles = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); foreach (var styleElement in doc.Root.Elements("StStyle")) { CmObjectFlatteningService.FlattenOwnedObject( stylePathname, sortedData, styleElement, scrOwningGuid, sortedStyles); // Restore 'ownerguid' to styleElement. } // Restore scrElement Styles property in sorted order. if (sortedStyles.Count == 0) { return; } var stylesOwningProp = scrElement.Element(SharedConstants.Styles) ?? CmObjectFlatteningService.AddNewPropertyElement(scrElement, SharedConstants.Styles); foreach (var sortedStyle in sortedStyles.Values) { stylesOwningProp.Add(sortedStyle); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string scriptureBaseDir) { if (!Directory.Exists(scriptureBaseDir)) { return; } var pathname = Path.Combine(scriptureBaseDir, SharedConstants.ImportSettingsFilename); if (!File.Exists(pathname)) { return; } // Owned by Scripture in ArchivedDrafts coll prop. var scrElement = highLevelData[SharedConstants.Scripture]; var scrOwningGuid = scrElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); var sortedImportSettings = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); var doc = XDocument.Load(pathname); foreach (var importSettingsElement in doc.Root.Elements("ScrImportSet")) { CmObjectFlatteningService.FlattenOwnedObject( pathname, sortedData, importSettingsElement, scrOwningGuid, sortedImportSettings); // Restore 'ownerguid' to importSettingsElement. } // Restore scrElement ImportSettings property in sorted order. if (sortedImportSettings.Count == 0) { return; } var importSettingsOwningProp = scrElement.Element(SharedConstants.ImportSettings) ?? CmObjectFlatteningService.AddNewPropertyElement(scrElement, SharedConstants.ImportSettings); foreach (var sortedimportSettings in sortedImportSettings.Values) { importSettingsOwningProp.Add(sortedimportSettings); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string linguisticsBaseDir) { // There is only one file here: Path.Combine(inventoryDir, SharedConstants.WordformInventoryFilename) var inventoryDir = Path.Combine(linguisticsBaseDir, SharedConstants.WordformInventoryRootFolder); if (!Directory.Exists(inventoryDir)) { return; } var inventoryPathnames = new List <string>(Directory.GetFiles(inventoryDir, string.Format("{0}_??.{1}", SharedConstants.WordformInventory, SharedConstants.Inventory), SearchOption.TopDirectoryOnly)); inventoryPathnames.Sort(StringComparer.InvariantCultureIgnoreCase); // the doc root will be "Inventory" (SharedConstants.WordformInventoryRootFolder). // This will store the PunctuationForm instances (unowned) in the header, and each PunctuationForm will be a child of header. // Each WfiWordform (unowned) will then be a child of root. foreach (var inventoryPathname in inventoryPathnames) { var doc = XDocument.Load(inventoryPathname); var unownedElements = new List <XElement>(); var optionalHeaderElement = doc.Root.Element(SharedConstants.Header); if (optionalHeaderElement != null) { unownedElements.AddRange(doc.Root.Element(SharedConstants.Header).Elements()); } var wordformElements = doc.Root.Elements("WfiWordform").ToList(); if (wordformElements.Any()) { unownedElements.AddRange(wordformElements); } // Query skips the dummy WfiWordform, if it is present. foreach (var unownedElement in unownedElements .Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid)) { CmObjectFlatteningService.FlattenOwnerlessObject( inventoryPathname, sortedData, unownedElement); } } }
public void RefColElementsRestoredToObjsurElements() { using (var tempFile = new TempFile()) { var sortedData = new SortedDictionary <string, XElement>(); var possibilityElement = new XElement("CmPossibility", new XAttribute(SharedConstants.GuidStr, "c1ed6dc8-e382-11de-8a39-0800200c9a66"), new XElement("Restrictions", new XElement(SharedConstants.Refcol, BaseDomainServices.CreateAttributes("0039739a-7fcf-4838-8b75-566b8815a29f", "r"), new XElement(SharedConstants.Refcol, BaseDomainServices.CreateAttributes("00b560a2-9af0-4185-bbeb-c0eb3c5e3769", "r"))))); CmObjectFlatteningService.FlattenOwnerlessObject( tempFile.Path, sortedData, possibilityElement); var restored = sortedData["c1ed6dc8-e382-11de-8a39-0800200c9a66"]; Assert.IsTrue(restored.ToString().Contains(SharedConstants.Objsur)); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string scriptureBaseDir) { if (!Directory.Exists(scriptureBaseDir)) { return; // Nothing to do. } var langProjElement = highLevelData[SharedConstants.LangProject]; var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); var sortedLists = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); foreach (var listPathname in Directory.GetFiles(scriptureBaseDir, "*.list", SearchOption.TopDirectoryOnly)) { if (listPathname.EndsWith(SharedConstants.NoteCategoriesListFilename)) { continue; // Wrong list. } var listDoc = XDocument.Load(listPathname); var listElement = listDoc.Element("CheckList").Element(SharedConstants.CmPossibilityList); CmObjectFlatteningService.FlattenOwnedObject( listPathname, sortedData, listElement, langProjGuid, sortedLists); // Restore 'ownerguid' to list. } if (sortedLists.Count == 0) { return; } // Restore LangProj CheckLists property in sorted order. var checkListsProp = langProjElement.Element(CheckLists) ?? CmObjectFlatteningService.AddNewPropertyElement(langProjElement, CheckLists); foreach (var sortedList in sortedLists.Values) { checkListsProp.Add(sortedList); } }
public void ObjSurElementsRestored() { using (var tempFile = new TempFile()) { var sortedData = new SortedDictionary <string, XElement>(); CmObjectFlatteningService.FlattenOwnerlessObject( tempFile.Path, sortedData, _reversalIndexElement); var revIdx = sortedData.Values.First(rt => rt.Attribute(SharedConstants.Class).Value == "ReversalIndex"); var owningProp = revIdx.Element("Entries"); CheckOwningProperty(owningProp, 2); owningProp = sortedData.Values.First(rt => rt.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() == "0039739a-7fcf-4838-8b75-566b8815a29f".ToLowerInvariant()).Element("Subentries"); CheckOwningProperty(owningProp, 1); owningProp = revIdx.Element("PartsOfSpeech"); CheckOwningProperty(owningProp, 1); var posList = sortedData.Values.First(rt => rt.Attribute(SharedConstants.Class).Value == SharedConstants.CmPossibilityList); owningProp = posList.Element("Possibilities"); CheckOwningProperty(owningProp, 2); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string generalBaseDir) { var userDefinedDir = Path.Combine(generalBaseDir, "UserDefinedLists"); if (!Directory.Exists(userDefinedDir)) { return; } foreach (var userDefinedListPathname in Directory.GetFiles(userDefinedDir, "*." + SharedConstants.List, SearchOption.TopDirectoryOnly)) { // These are un-owned lists. var userDefinedListDoc = XDocument.Load(userDefinedListPathname); CmObjectFlatteningService.FlattenOwnerlessObject(userDefinedListPathname, sortedData, userDefinedListDoc.Root.Element(SharedConstants.CmPossibilityList)); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string scriptureBaseDir) { if (!Directory.Exists(scriptureBaseDir)) { return; // Nothing to do. } var pathname = Path.Combine(scriptureBaseDir, SharedConstants.ScriptureReferenceSystemFilename); if (!File.Exists(pathname)) { return; // Nobody home. } var doc = XDocument.Load(pathname); CmObjectFlatteningService.FlattenOwnerlessObject( pathname, sortedData, doc.Element(SharedConstants.ScriptureReferenceSystem).Element("ScrRefSystem")); }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string scriptureBaseDir) { if (!Directory.Exists(scriptureBaseDir)) { return; } // Owned by Scripture in ArchivedDrafts coll prop. var scrElement = highLevelData[SharedConstants.Scripture]; var scrOwningGuid = scrElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); var sortedDrafts = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); foreach (var draftPathname in Directory.GetFiles(scriptureBaseDir, "*." + SharedConstants.ArchivedDraft, SearchOption.TopDirectoryOnly)) { var doc = XDocument.Load(draftPathname); var draftElement = doc.Root.Element(SharedConstants.ScrDraft); CmObjectFlatteningService.FlattenOwnedObject(draftPathname, sortedData, draftElement, scrOwningGuid, sortedDrafts); // Restore 'ownerguid' to draftElement. } // Restore scrElement ArchivedDrafts property in sorted order. if (sortedDrafts.Count == 0) { return; } var draftsOwningProp = scrElement.Element(SharedConstants.ArchivedDrafts) ?? CmObjectFlatteningService.AddNewPropertyElement(scrElement, SharedConstants.ArchivedDrafts); foreach (var sortedDraft in sortedDrafts.Values) { draftsOwningProp.Add(sortedDraft); } }
internal static SortedDictionary <string, XElement> PutHumptyTogetherAgain(IProgress progress, bool writeVerbose, string pathRoot) { var retval = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); var sortedData = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); var highLevelData = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); // NB: Don't even think of changing the order these methods are called in. GeneralDomainServices.FlattenDomain(progress, writeVerbose, highLevelData, sortedData, pathRoot); CmObjectFlatteningService.CombineData(retval, sortedData); ScriptureDomainServices.FlattenDomain(progress, writeVerbose, highLevelData, sortedData, pathRoot); CmObjectFlatteningService.CombineData(retval, sortedData); AnthropologyDomainServices.FlattenDomain(progress, writeVerbose, highLevelData, sortedData, pathRoot); CmObjectFlatteningService.CombineData(retval, sortedData); LinguisticsDomainServices.FlattenDomain(progress, writeVerbose, highLevelData, sortedData, pathRoot); CmObjectFlatteningService.CombineData(retval, sortedData); foreach (var highLevelElement in highLevelData.Values) { retval[highLevelElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant()] = highLevelElement; } return(retval); }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string linguisticsBaseDir) { var lexiconDir = Path.Combine(linguisticsBaseDir, SharedConstants.Lexicon); if (!Directory.Exists(lexiconDir)) { return; } var langProjElement = highLevelData[SharedConstants.LangProject]; var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); var lexDbPathnames = new List <string>(Directory.GetFiles(lexiconDir, string.Format("{0}_??.{1}", SharedConstants.Lexicon, SharedConstants.Lexdb), SearchOption.TopDirectoryOnly)); lexDbPathnames.Sort(StringComparer.InvariantCultureIgnoreCase); foreach (var lexDbPathname in lexDbPathnames) { var lexDbDoc = XDocument.Load(lexDbPathname); var rootLexDbDoc = lexDbDoc.Root; var headerLexDbDoc = rootLexDbDoc.Element(SharedConstants.Header); if (headerLexDbDoc != null) { var lexDb = headerLexDbDoc.Element(SharedConstants.LexDb); highLevelData[SharedConstants.LexDb] = lexDb; // Let MorphAndSyn access it to put "MorphTypes" back into lexDb. foreach (var listPathname in Directory.GetFiles(lexiconDir, "*.list", SearchOption.TopDirectoryOnly)) { var listDoc = XDocument.Load(listPathname); var listElement = listDoc.Root.Element(SharedConstants.CmPossibilityList); var listFilenameSansExtension = Path.GetFileNameWithoutExtension(listPathname); switch (listFilenameSansExtension) { default: // In LexDB. Just add the list to the owning prop, and let it get flattened, normally. lexDb.Element(listFilenameSansExtension).Add(listElement); break; case "SemanticDomainList": case "AffixCategories": // Flatten the LP list by itself, and add an appropriate surrogate. CmObjectFlatteningService.FlattenOwnedObject( listPathname, sortedData, listElement, langProjGuid, langProjElement, listFilenameSansExtension); // Restore 'ownerguid' to list. break; } } // Flatten lexDb. CmObjectFlatteningService.FlattenOwnedObject( lexDbPathname, sortedData, lexDb, langProjGuid, langProjElement, SharedConstants.LexDb); // Restore 'ownerguid' to LexDb. } // Flatten all entries in root of lexDbDoc. (EXCEPT if it has a guid of Guid.Empty, in which case, just ignore it, and it will go away.) foreach (var entryElement in rootLexDbDoc.Elements(SharedConstants.LexEntry) .Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid)) { CmObjectFlatteningService.FlattenOwnerlessObject( lexDbPathname, sortedData, entryElement); } } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string anthropologyBaseDir) { var langProjElement = highLevelData[SharedConstants.LangProject]; var currentPathname = Path.Combine(anthropologyBaseDir, SharedConstants.DataNotebookFilename); var doc = XDocument.Load(currentPathname); var root = doc.Root; var dnMainElement = root.Element(SharedConstants.Header).Element("RnResearchNbk"); // Add the record elements (except the possible dummy one) into dnMainElement. var sortedRecords = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); foreach (var recordElement in root.Elements("RnGenericRec") .Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid)) { // Add it to Records property of dnMainElement, BUT in sorted order, below, and then flatten dnMainElement. sortedRecords.Add(recordElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), recordElement); } if (sortedRecords.Count > 0) { var recordsElementOwningProp = dnMainElement.Element("Records") ?? CmObjectFlatteningService.AddNewPropertyElement(dnMainElement, "Records"); foreach (var sortedChartElement in sortedRecords.Values) { recordsElementOwningProp.Add(sortedChartElement); } } // Put the RecTypes list back into place in dnMainElement, before dnMainElement is restored. // But only as an <objsur> element. var recTypesPathname = Path.Combine(anthropologyBaseDir, "RecTypes." + SharedConstants.List); if (File.Exists(recTypesPathname)) { var listDoc = XDocument.Load(recTypesPathname); BaseDomainServices.RestoreElement(recTypesPathname, sortedData, dnMainElement, "RecTypes", listDoc.Root.Element(SharedConstants.CmPossibilityList)); } BaseDomainServices.RestoreElement(currentPathname, sortedData, langProjElement, "ResearchNotebook", dnMainElement); // Put the lists back where they belong in LangProj. foreach (var listPathname in Directory.GetFiles(anthropologyBaseDir, "*." + SharedConstants.List)) { var listDoc = XDocument.Load(listPathname); var listRoot = listDoc.Root; var listRootName = listRoot.Name.LocalName; if (listRootName == "RecTypes") { continue; } BaseDomainServices.RestoreElement(listPathname, sortedData, langProjElement, listRootName, listRoot.Element(SharedConstants.CmPossibilityList)); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string linguisticsBaseDir) { var morphAndSynDir = Path.Combine(linguisticsBaseDir, SharedConstants.MorphologyAndSyntax); if (!Directory.Exists(morphAndSynDir)) { return; } var langProjElement = highLevelData[SharedConstants.LangProject]; var lexDb = highLevelData[SharedConstants.LexDb]; var currentPathname = Path.Combine(morphAndSynDir, SharedConstants.MorphTypesListFilename); if (lexDb != null && File.Exists(currentPathname)) { // Restore MorphTypes list to LexDb. var morphTypesDoc = XDocument.Load(currentPathname); BaseDomainServices.RestoreElement( currentPathname, sortedData, lexDb, SharedConstants.MorphTypes, morphTypesDoc.Root.Element(SharedConstants.CmPossibilityList)); // Owned elment. } var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); currentPathname = Path.Combine(morphAndSynDir, SharedConstants.MorphAndSynFeaturesFilename); if (File.Exists(currentPathname)) { var mAndSFeatSysDoc = XDocument.Load(currentPathname); BaseDomainServices.RestoreElement( currentPathname, sortedData, langProjElement, "MsFeatureSystem", mAndSFeatSysDoc.Root.Element("FsFeatureSystem")); // Owned elment. } currentPathname = Path.Combine(morphAndSynDir, SharedConstants.PartsOfSpeechFilename); if (File.Exists(currentPathname)) { var posDoc = XDocument.Load(currentPathname); BaseDomainServices.RestoreElement( currentPathname, sortedData, langProjElement, SharedConstants.PartsOfSpeech, posDoc.Root.Element(SharedConstants.CmPossibilityList)); // Owned elment. } currentPathname = Path.Combine(morphAndSynDir, SharedConstants.AnalyzingAgentsFilename); // Put Agents back into LP. var sortedAgents = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); var agentDoc = XDocument.Load(currentPathname); foreach (var agentElement in agentDoc.Root.Elements()) { CmObjectFlatteningService.FlattenOwnedObject( currentPathname, sortedData, agentElement, langProjGuid, sortedAgents); // Restore 'ownerguid' to agent. } // Restore LP AnalyzingAgents property in sorted order. if (sortedAgents.Count > 0) { var langProjOwningProp = langProjElement.Element(SharedConstants.AnalyzingAgents); foreach (var sortedTextObjSurElement in sortedAgents.Values) { langProjOwningProp.Add(sortedTextObjSurElement); } } currentPathname = Path.Combine(morphAndSynDir, SharedConstants.MorphAndSynDataFilename); if (File.Exists(currentPathname)) { var mAndSDataDoc = XDocument.Load(currentPathname); var morphDataElement = mAndSDataDoc.Root.Element("MoMorphData"); BaseDomainServices.RestoreElement( currentPathname, sortedData, langProjElement, "MorphologicalData", morphDataElement); currentPathname = Path.Combine(morphAndSynDir, "ProdRestrict." + SharedConstants.List); if (File.Exists(currentPathname)) { var prodRestrictDoc = XDocument.Load(currentPathname); var prodRestrictListElement = prodRestrictDoc.Root.Element(SharedConstants.CmPossibilityList); BaseDomainServices.RestoreElement( currentPathname, sortedData, morphDataElement, "ProdRestrict", prodRestrictListElement); } } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string scriptureBaseDir) { if (!Directory.Exists(scriptureBaseDir)) { return; } // scriptureBaseDir is root/Scripture. var pathname = Path.Combine(scriptureBaseDir, SharedConstants.ScriptureTransFilename); if (!File.Exists(pathname)) { return; // Nobody home. } var doc = XDocument.Load(pathname); var scrElement = doc.Element(SharedConstants.TranslatedScripture).Elements().First(); // Put the NoteCategories list back in the right place. pathname = Path.Combine(scriptureBaseDir, SharedConstants.NoteCategoriesListFilename); if (File.Exists(pathname)) { doc = XDocument.Load(pathname); BaseDomainServices.RestoreElement(pathname, sortedData, scrElement, SharedConstants.NoteCategories, doc.Root.Element(SharedConstants.CmPossibilityList)); } // Owned by LangProj in TranslatedScripture prop. var langProjElement = highLevelData[SharedConstants.LangProject]; CmObjectFlatteningService.FlattenOwnedObject( pathname, sortedData, scrElement, langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), langProjElement, SharedConstants.TranslatedScripture); // Restore 'ownerguid' to scrElement. // Put the <objsur> elements back into BookAnnotations and ScriptureBooks property elements. // There will always be 66 ScrBookAnnotations instances and they need go in canonical book order. // There may (or may not) be ScrBook instances, but they all go in canonical book order in ScriptureBooks, if present. var booksDir = Path.Combine(scriptureBaseDir, SharedConstants.Books); var sortedFiles = new SortedList <int, string>(66); foreach (var pathnameForAnn in Directory.GetFiles(booksDir, "*." + SharedConstants.bookannotations)) { sortedFiles.Add(Int32.Parse(Path.GetFileNameWithoutExtension(pathnameForAnn)), pathnameForAnn); } var scrElementGuid = scrElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); var scriptureBooksProperty = scrElement.Element(SharedConstants.ScriptureBooks); foreach (var sortedPathnameKvp in sortedFiles) { var sortedDoc = XDocument.Load(sortedPathnameKvp.Value); var element = sortedDoc.Root.Element(SharedConstants.ScrBookAnnotations); CmObjectFlatteningService.FlattenOwnedObject( sortedPathnameKvp.Value, sortedData, element, scrElementGuid, scrElement, SharedConstants.BookAnnotations); // Restore 'ownerguid' to annotation. // Deal with optional ScrBook var bookPathname = sortedPathnameKvp.Value.Replace(SharedConstants.bookannotations, SharedConstants.book); if (!File.Exists(bookPathname)) { continue; } if (scriptureBooksProperty == null) { scriptureBooksProperty = new XElement(SharedConstants.ScriptureBooks); scrElement.Add(scriptureBooksProperty); // Make sure new property is sorted in correct place. DataSortingService.SortMainRtElement(scrElement); } // Add book <objsur> element to scrElement's ScriptureBooks element. sortedDoc = XDocument.Load(bookPathname); element = sortedDoc.Root.Element(SharedConstants.ScrBook); CmObjectFlatteningService.FlattenOwnedObject( bookPathname, sortedData, element, scrElementGuid, scrElement, SharedConstants.ScriptureBooks); // Restore 'ownerguid' to book. } highLevelData.Add(scrElement.Attribute(SharedConstants.Class).Value, scrElement); }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string linguisticsBaseDir) { var reversalDir = Path.Combine(linguisticsBaseDir, ReversalRootFolder); if (!Directory.Exists(reversalDir)) { return; } var lexDb = highLevelData[SharedConstants.LexDb]; var sortedRevs = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); var unlovedFolders = new HashSet <string>(); foreach (var revIndexDirectoryName in Directory.GetDirectories(reversalDir)) { var dirInfo = new DirectoryInfo(revIndexDirectoryName); var ws = dirInfo.Name; var reversalPathname = Path.Combine(revIndexDirectoryName, ws + "." + SharedConstants.Reversal); if (!File.Exists(reversalPathname)) { // If a reversal is deleted but there were ChorusNotes associated with it the directory might be // here without any reversal files inside it. unlovedFolders.Add(revIndexDirectoryName); continue; } var reversalDoc = XDocument.Load(reversalPathname); // Put entries back into index's Entries element. var root = reversalDoc.Element("Reversal"); var header = root.Element(SharedConstants.Header); var revIdxElement = header.Element("ReversalIndex"); // Restore POS list, if it exists. var catPathname = Path.Combine(revIndexDirectoryName, ws + "-" + SharedConstants.PartsOfSpeechFilename); if (File.Exists(catPathname)) { var catListDoc = XDocument.Load(catPathname); BaseDomainServices.RestoreElement( catPathname, sortedData, revIdxElement, SharedConstants.PartsOfSpeech, catListDoc.Root.Element(SharedConstants.CmPossibilityList)); // Owned elment. } // Put all records back in ReversalIndex, before sort and restore. // EXCEPT, if there is only one of them and it is guid.Empty, then skip it var sortedRecords = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); foreach (var recordElement in root.Elements("ReversalIndexEntry") .Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid)) { // Add it to Records property of revIdxElement, BUT in sorted order, below, and then flatten dnMainElement. sortedRecords.Add(recordElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), recordElement); } if (sortedRecords.Count > 0) { var recordsElementOwningProp = revIdxElement.Element("Entries") ?? CmObjectFlatteningService.AddNewPropertyElement(revIdxElement, "Entries"); foreach (var sortedChartElement in sortedRecords.Values) { recordsElementOwningProp.Add(sortedChartElement); } } CmObjectFlatteningService.FlattenOwnedObject(reversalPathname, sortedData, revIdxElement, lexDb.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), sortedRevs); // Restore 'ownerguid' to indices. } foreach (var unlovedFolder in unlovedFolders) { Directory.Delete(unlovedFolder, true); } // Restore lexDb ReversalIndexes property in sorted order. if (sortedRevs.Count == 0) { return; } var reversalsOwningProp = lexDb.Element("ReversalIndexes") ?? CmObjectFlatteningService.AddNewPropertyElement(lexDb, "ReversalIndexes"); foreach (var sortedRev in sortedRevs.Values) { reversalsOwningProp.Add(sortedRev); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string linguisticsBaseDir) { var discourseDir = Path.Combine(linguisticsBaseDir, SharedConstants.DiscourseRootFolder); if (!Directory.Exists(discourseDir)) { return; } var chartPathname = Path.Combine(discourseDir, SharedConstants.DiscourseChartFilename); if (!File.Exists(chartPathname)) { return; } // The charts need to be sorted in guid order, before being added back into the owning prop element. var doc = XDocument.Load(chartPathname); var root = doc.Root; var discourseElement = root.Element(SharedConstants.Header).Element("DsDiscourseData"); // Add lists back into discourseElement. foreach (var listPathname in Directory.GetFiles(discourseDir, "*." + SharedConstants.List)) { var listDoc = XDocument.Load(listPathname); var listFilename = Path.GetFileName(listPathname); var listElement = listDoc.Root.Element(SharedConstants.CmPossibilityList); switch (listFilename) { case SharedConstants.ChartMarkersFilename: discourseElement.Element(SharedConstants.ChartMarkers).Add(listElement); break; case SharedConstants.ConstChartTemplFilename: discourseElement.Element(SharedConstants.ConstChartTempl).Add(listElement); break; } } // Add the chart elements (except the possible dummy one) into discourseElement. var sortedCharts = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); foreach (var chartElement in root.Elements(SharedConstants.DsChart) .Where(element => element.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant() != SharedConstants.EmptyGuid)) { // No. Add it to discourseElement, BUT in sorted order, below, and then flatten discourseElement. // Restore the right main element name from the class attribute. var classAttr = chartElement.Attribute(SharedConstants.Class); chartElement.Name = classAttr.Value; classAttr.Remove(); sortedCharts.Add(chartElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(), chartElement); } if (sortedCharts.Count > 0) { var discourseElementOwningProp = discourseElement.Element("Charts") ?? CmObjectFlatteningService.AddNewPropertyElement(discourseElement, "Charts"); foreach (var sortedChartElement in sortedCharts.Values) { discourseElementOwningProp.Add(sortedChartElement); } } var langProjElement = highLevelData[SharedConstants.LangProject]; BaseDomainServices.RestoreElement( chartPathname, sortedData, langProjElement, "DiscourseData", discourseElement); }
public void EnsureDuplicateGuidsAreChangedAndChorusNotesFileContainsConflictReport() { const string nestedReversal = @"<ReversalIndex guid='fe832a87-4846-4895-9c7e-98c5da0c84ba'> <Entries> <ReversalIndexEntry guid='0039739a-7fcf-4838-8b75-566b8815a29f'> <Subentries> <ReversalIndexEntry guid='14a6b4bc-1bb3-4c67-b70c-5a195e411e27' > <Subentries> <ReversalIndexEntry guid='c1ed6dc9-e382-11de-8a39-0800200c9a66' /> </Subentries> </ReversalIndexEntry> <ReversalIndexEntry guid='14a6b4bc-1bb3-4c67-b70c-5a195e411e27' > <Subentries> <ReversalIndexEntry guid='c1ed6dc9-e382-11de-8a39-0800200c9a66' /> </Subentries> </ReversalIndexEntry> </Subentries> </ReversalIndexEntry> </Entries> </ReversalIndex>"; using (var tempFile = new TempFile()) { var notesPathname = tempFile.Path + ".ChorusNotes"; try { var reversalIndexElement = XElement.Parse(nestedReversal); var sortedDict = new SortedDictionary <string, XElement>(); Assert.IsFalse(File.Exists(notesPathname)); CmObjectFlatteningService.FlattenOwnerlessObject( tempFile.Path, sortedDict, reversalIndexElement); Assert.IsTrue(File.Exists(notesPathname)); var doc = XDocument.Load(notesPathname); var annotation = doc.Root.Element("annotation"); string refLeadIn = "silfw://localhost/link?app=flex&database=current&server=&tool=default&guid="; var refAttr = annotation.Attribute("ref").Value; string refTrail = "&tag=&label=ReversalIndexEntry"; Assert.That(refAttr.Substring(0, refLeadIn.Length), Is.EqualTo(refLeadIn)); Assert.That(refAttr.Substring(refAttr.Length - refTrail.Length, refTrail.Length), Is.EqualTo(refTrail)); var guidNewRie = refAttr.Substring(refLeadIn.Length, refAttr.Length - refLeadIn.Length - refTrail.Length); Assert.DoesNotThrow(() => new Guid(guidNewRie), "guid in ref link should parse as a guid"); var msgElement = annotation.Element("message"); Assert.IsTrue(msgElement.LastNode.ToString().Contains("Chorus.merge.xml.generic.IncompatibleMoveConflict")); Assert.That(msgElement.LastNode, Is.InstanceOf <XCData>()); var doc2 = XDocument.Parse(((XCData)msgElement.LastNode).Value); var conflictElement = doc2.Root; Assert.That(conflictElement.Attribute("contextPath").Value, Is.EqualTo(refAttr)); Assert.AreEqual("FLExBridge", msgElement.Attribute("author").Value); var html = conflictElement.Attribute("htmlDetails").Value; Assert.That(html, Is.StringContaining(guidNewRie), "The HTML should contain a link to the changed-guid object"); Assert.That(html, Is.StringContaining("14a6b4bc-1bb3-4c67-b70c-5a195e411e27"), "The HTML should contain a link to conflicting object"); // Make sure the duplicate guids were changed in both levels. var ries = from rie in sortedDict.Values where rie.Attribute(SharedConstants.Class).Value == "ReversalIndexEntry" select rie; Assert.AreEqual(5, ries.Count()); // The guids had to be changed, for there to be five of them. Assert.IsTrue(sortedDict.ContainsKey("0039739a-7fcf-4838-8b75-566b8815a29f")); Assert.IsTrue(sortedDict.ContainsKey("14a6b4bc-1bb3-4c67-b70c-5a195e411e27")); Assert.IsTrue(sortedDict.ContainsKey("c1ed6dc9-e382-11de-8a39-0800200c9a66")); Assert.IsTrue(sortedDict.ContainsKey(guidNewRie)); var parent = sortedDict["0039739a-7fcf-4838-8b75-566b8815a29f"]; var modSurrogate = parent.Element("Subentries").Elements("objsur").Last(); Assert.That(modSurrogate.Attribute("guid").Value, Is.EqualTo(guidNewRie), "the objsur for the item with the new ID should match"); } finally { File.Delete(notesPathname); } } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string generalBaseDir) { var langProjPathname = Path.Combine(generalBaseDir, SharedConstants.LanguageProjectFilename); var langProjDoc = XDocument.Load(langProjPathname); var langProjElement = langProjDoc.Root.Element(SharedConstants.LangProject); // Add LP to highLevelData. highLevelData.Add(SharedConstants.LangProject, langProjElement); // Flatten it. CmObjectFlatteningService.FlattenOwnerlessObject( langProjPathname, sortedData, langProjElement); // Add stuff LP owns that is here, then flatten it. // LP AnnotationDefs (OA-CmPossibilityList). var currentPathname = Path.Combine(generalBaseDir, SharedConstants.AnnotationDefsListFilename); if (File.Exists(currentPathname)) { // Flatten it here to get the right pathname into the method. BaseDomainServices.RestoreElement( currentPathname, sortedData, langProjElement, SharedConstants.AnnotationDefs, XDocument.Load(currentPathname).Root.Element(SharedConstants.CmPossibilityList)); } // LP Styles (OC-StStyle) var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); var sortedElements = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExStylesFilename); XDocument doc; if (File.Exists(currentPathname)) { doc = XDocument.Load(currentPathname); foreach (var styleElement in doc.Root.Elements(SharedConstants.StStyle)) { // Put style back into LP's Styles element. CmObjectFlatteningService.FlattenOwnedObject( currentPathname, sortedData, styleElement, langProjGuid, sortedElements); // Restore 'ownerguid' to style. } // Restore LP Styles property in sorted order. var langProjOwningProp = langProjElement.Element(SharedConstants.Styles); foreach (var sortedTextObjSurElement in sortedElements.Values) { langProjOwningProp.Add(sortedTextObjSurElement); } } // LP Filters (OC-CmFilter) currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExFiltersFilename); if (File.Exists(currentPathname)) { sortedElements = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); doc = XDocument.Load(currentPathname); foreach (var filterElement in doc.Root.Elements("CmFilter")) { // Put CmFilter back into LP's Filters element. CmObjectFlatteningService.FlattenOwnedObject( currentPathname, sortedData, filterElement, langProjGuid, sortedElements); // Restore 'ownerguid' to style. } // Restore LP Filters property in sorted order. var langProjOwningProp = langProjElement.Element(SharedConstants.Filters); foreach (var sortedTextObjSurElement in sortedElements.Values) { langProjOwningProp.Add(sortedTextObjSurElement); } } // LP Annotations (OC-CmAnnotation). [Odd elements like in Discourse.] currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExAnnotationsFilename); if (File.Exists(currentPathname)) { sortedElements = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); doc = XDocument.Load(currentPathname); foreach (var annotationElement in doc.Root.Elements(SharedConstants.CmAnnotation)) { // Put CmAnnotation back into LP's Annotations element. var classAttr = annotationElement.Attribute(SharedConstants.Class); annotationElement.Name = classAttr.Value; classAttr.Remove(); CmObjectFlatteningService.FlattenOwnedObject( currentPathname, sortedData, annotationElement, langProjGuid, sortedElements); // Restore 'ownerguid' to style. } // Restore LP Annotations property in sorted order. var owningProp = langProjElement.Element(SharedConstants.Annotations); foreach (var sortedTextObjSurElement in sortedElements.Values) { owningProp.Add(sortedTextObjSurElement); } } // No VirtualOrdering instances are owned. if (MetadataCache.MdCache.ModelVersion > MetadataCache.StartingModelVersion) { currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExVirtualOrderingFilename); doc = XDocument.Load(currentPathname); foreach (var orderingElement in doc.Root.Elements(SharedConstants.VirtualOrdering)) { CmObjectFlatteningService.FlattenOwnerlessObject( currentPathname, sortedData, orderingElement); } } // Some CmPicture instances may not be owned. currentPathname = Path.Combine(generalBaseDir, SharedConstants.FLExUnownedPicturesFilename); doc = XDocument.Load(currentPathname); foreach (var pictureElement in doc.Root.Elements(SharedConstants.CmPicture)) { CmObjectFlatteningService.FlattenOwnerlessObject( currentPathname, sortedData, pictureElement); } }
internal static void FlattenContext( SortedDictionary <string, XElement> highLevelData, SortedDictionary <string, XElement> sortedData, string linguisticsBaseDir) { var textCorpusBaseDir = Path.Combine(linguisticsBaseDir, SharedConstants.TextCorpus); if (!Directory.Exists(textCorpusBaseDir)) { return; } var langProjElement = highLevelData[SharedConstants.LangProject]; var langProjGuid = langProjElement.Attribute(SharedConstants.GuidStr).Value.ToLowerInvariant(); // Put the Genre list back in the right place. var pathname = Path.Combine(textCorpusBaseDir, SharedConstants.GenreListFilename); var doc = XDocument.Load(pathname); BaseDomainServices.RestoreElement(pathname, sortedData, langProjElement, SharedConstants.GenreList, doc.Root.Element(SharedConstants.CmPossibilityList)); // Put the markup tags list back in the right place. pathname = Path.Combine(textCorpusBaseDir, SharedConstants.TextMarkupTagsListFilename); doc = XDocument.Load(pathname); BaseDomainServices.RestoreElement(pathname, sortedData, langProjElement, SharedConstants.TextMarkupTags, doc.Root.Element(SharedConstants.CmPossibilityList)); // Put the translation tags list back in the right place. pathname = Path.Combine(textCorpusBaseDir, SharedConstants.TranslationTagsListFilename); doc = XDocument.Load(pathname); BaseDomainServices.RestoreElement(pathname, sortedData, langProjElement, SharedConstants.TranslationTags, doc.Root.Element(SharedConstants.CmPossibilityList)); if (MetadataCache.MdCache.ModelVersion < 7000059) { // Backwards compatible code. // Put Texts back into LP. var sortedTexts = new SortedDictionary <string, XElement>(StringComparer.OrdinalIgnoreCase); foreach (var textPathname in Directory.GetFiles(textCorpusBaseDir, "*." + SharedConstants.TextInCorpus, SearchOption.TopDirectoryOnly)) { var textDoc = XDocument.Load(textPathname); // Put texts back into index's Entries element. var root = textDoc.Root; var textElement = root.Elements().First(); CmObjectFlatteningService.FlattenOwnedObject( textPathname, sortedData, textElement, langProjGuid, sortedTexts); // Restore 'ownerguid' to text. } // Restore LP Texts property in sorted order. if (sortedTexts.Count == 0) { return; } var langProjOwningProp = langProjElement.Element("Texts"); foreach (var sortedTextObjSurElement in sortedTexts.Values) { langProjOwningProp.Add(sortedTextObjSurElement); } } else { // Put Texts (all unowned now) all in 'sortedData'. foreach (var textPathname in Directory.GetFiles(textCorpusBaseDir, "*." + SharedConstants.TextInCorpus, SearchOption.TopDirectoryOnly)) { var textDoc = XDocument.Load(textPathname); var root = textDoc.Root; var textElement = root.Elements().First(); CmObjectFlatteningService.FlattenOwnerlessObject( textPathname, sortedData, textElement); } } }