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);
}
}
}
