/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo from a CmFile. This is used when populating the /// file list from the database. /// </summary> /// <param name="file">The CmFile</param> /// <param name="mappingList">List of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which /// this file belongs (only used for Note sources)</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(ICmFile file, ScrMappingList mappingList, ImportDomain domain, string icuLocale, int noteTypeHvo, bool scanInlineBackslashMarkers) : this(file.AbsoluteInternalPath, mappingList, domain, icuLocale, noteTypeHvo, scanInlineBackslashMarkers) { m_file = file; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="ScrSfFileList"/> class based on an /// existing ScrImportSFFiles in the DB. /// </summary> /// <param name="source">A DB-based collection of Standard Format files</param> /// <param name="mappingList">The mapping list to which mappings will be added if any /// new ones are found when scanning the files</param> /// <param name="importDomain">Main (vernacular Scripture), BT or Annotations</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// <param name="helpFile">The path of the application help file.</param> /// ------------------------------------------------------------------------------------ public ScrSfFileList(ScrImportSFFiles source, ScrMappingList mappingList, ImportDomain importDomain, bool scanInlineBackslashMarkers, string helpFile) : this(null) { List <int> deleteList = new List <int>(); // Load the files into an in-memory list foreach (ICmFile file in source.FilesOC) { try { ScrImportFileInfo info = new ScrImportFileInfo(file, mappingList, importDomain, source.ICULocale, source.NoteTypeRAHvo, scanInlineBackslashMarkers); Add(info); } catch (ScriptureUtilsException e) { MessageBox.Show(string.Format(ScrFdoResources.kstidImportBadFile, e.Message), "", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0, helpFile, HelpNavigator.Topic, e.HelpTopic); deleteList.Add(file.Hvo); } } // delete all of the files that caused errors foreach (int deleteItem in deleteList) { source.Cache.DeleteObject(deleteItem); } m_modified = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo based on a filename. This is used to build an /// in-memory list of files. /// </summary> /// <param name="fileName">Name of the file whose info this represents</param> /// <param name="mappingList">Sorted list of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which /// this file belongs (only used for Note sources)</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain, string icuLocale, int noteTypeHvo, bool scanInlineBackslashMarkers) { m_fileName = fileName; m_mappingList = mappingList; m_domain = domain; m_icuLocale = icuLocale; m_noteTypeHvo = noteTypeHvo; m_doStrictFileChecking = false; ScanInlineBackslashMarkers = scanInlineBackslashMarkers; Initialize(); }
public void SetMappings_Main() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(new ImportMappingInfo(@"\a", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, ScrStyleNames.NormalParagraph, null)); list.Add(new ImportMappingInfo(@"\a", null, false, MappingTargetType.TEStyle, MarkerDomain.BackTrans, ScrStyleNames.NormalParagraph, "es")); list.Add(new ImportMappingInfo(@"\b", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, ScrStyleNames.NormalParagraph, null)); list.Add(new ImportMappingInfo(@"\c", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, "wrong style for chapter", null)); list.Add(new ImportMappingInfo(@"\v", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, "wrong style for verse", null)); list.Add(new ImportMappingInfo(@"\id", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, "id should be null", null)); list.Add(new ImportMappingInfo(@"\btp", null, false, MappingTargetType.TEStyle, MarkerDomain.BackTrans, ScrStyleNames.NormalParagraph, null)); Assert.AreEqual(6, list.Count); ImportMappingInfo mapping = list[0]; Assert.AreEqual(@"\a", mapping.BeginMarker); Assert.IsNull(mapping.EndMarker); Assert.AreEqual(ScrStyleNames.NormalParagraph, mapping.StyleName); Assert.AreEqual(MarkerDomain.Default, mapping.Domain); Assert.IsFalse(mapping.IsExcluded); Assert.IsFalse(mapping.IsInline); Assert.AreEqual(MappingTargetType.TEStyle, mapping.MappingTarget); Assert.AreEqual("es", mapping.IcuLocale); mapping = list[1]; Assert.AreEqual(@"\b", mapping.BeginMarker); Assert.AreEqual(MarkerDomain.Default, mapping.Domain); mapping = list[2]; Assert.AreEqual(@"\btp", mapping.BeginMarker); Assert.AreEqual(MarkerDomain.BackTrans, mapping.Domain); mapping = list[3]; Assert.AreEqual(@"\c", mapping.BeginMarker); Assert.AreEqual(ScrStyleNames.ChapterNumber, mapping.StyleName); Assert.AreEqual(MarkerDomain.Default, mapping.Domain); mapping = list[4]; Assert.AreEqual(@"\id", mapping.BeginMarker); Assert.IsNull(mapping.StyleName); Assert.AreEqual(MarkerDomain.Default, mapping.Domain); mapping = list[5]; Assert.AreEqual(@"\v", mapping.BeginMarker); Assert.AreEqual(ScrStyleNames.VerseNumber, mapping.StyleName); Assert.AreEqual(MarkerDomain.Default, mapping.Domain); }
public void Init() { m_mappingList = new ScrMappingList(MappingSet.Main, null); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Load the mappings for a paratext project into the specified list. /// </summary> /// <param name="project">Paratext project ID</param> /// <param name="mappingList">ScrMappingList to which new mappings will be added</param> /// <param name="domain">The import domain for which this project is the source</param> /// <returns><c>true</c> if the Paratext mappings were loaded successfully; <c>false</c> /// otherwise</returns> /// ------------------------------------------------------------------------------------ public static bool LoadParatextMappings(string project, ScrMappingList mappingList, ImportDomain domain) { // If the new project ID is null, then do not load mappings. if (project == null) { return(false); } // Load the tags from the paratext project and create mappings for them. SCRIPTUREOBJECTSLib.ISCScriptureText3 scParatextText = null; try { scParatextText = new SCRIPTUREOBJECTSLib.SCScriptureTextClass(); scParatextText.Load(project); } catch (Exception ex) { Logger.WriteEvent(string.Format( "Got {0} exception loading paratext mappings (ScrImportP6Project.LoadParatextMappings):\n{1}", ex.GetType(), ex.Message)); return(false); } // TE-5802 try { for (int i = 0; true; i++) { SCRIPTUREOBJECTSLib.ISCTag tag = scParatextText.NthTag(i); if (tag == null) { break; } string marker = @"\" + tag.Marker; string endMarker = string.Empty; if (tag.Endmarker != string.Empty && tag.Endmarker != null) { endMarker = @"\" + tag.Endmarker; } // When the nth marker has an end marker, the nth + 1 marker will be // that end marker. Therefore, we have to skip those "end style" markers. if (tag.StyleType == SCRIPTUREOBJECTSLib.SCStyleType.scEndStyle) { continue; } // Create a new mapping for this marker. mappingList.AddDefaultMappingIfNeeded(marker, endMarker, domain, false, false); } SCRIPTUREOBJECTSLib.SCReference startRefPT = new SCRIPTUREOBJECTSLib.SCReference(); SCRIPTUREOBJECTSLib.SCReference endRefPT = new SCRIPTUREOBJECTSLib.SCReference(); startRefPT.Parse("GEN 1:0"); endRefPT.Parse("REV 22:21"); SCRIPTUREOBJECTSLib.ISCTextEnum scParatextTextEnum = scParatextText.TextEnum( (SCRIPTUREOBJECTSLib.SCReference)startRefPT, (SCRIPTUREOBJECTSLib.SCReference)endRefPT, (SCRIPTUREOBJECTSLib.SCTextType) 0, //scTitle | scSection | scVerseText | scNoteText | scOther) (SCRIPTUREOBJECTSLib.SCTextProperties) 0); SCRIPTUREOBJECTSLib.SCTextSegment scParatextTextSegment = new SCRIPTUREOBJECTSLib.SCTextSegmentClass(); mappingList.ResetInUseFlags(domain); while (scParatextTextEnum.Next(scParatextTextSegment) != 0) { string sMarker = @"\" + scParatextTextSegment.Tag.Marker; ImportMappingInfo mapping = mappingList[sMarker]; if (mapping != null) { mapping.SetIsInUse(domain, true); } // ENHANCE (TE-4408): Consider Detecting markers that occur in the data but are missing // from the STY file. How can we write a test for this? //else if (ScrImportFileInfo.IsValidMarker(sMarker)) //{ // mappingList.AddDefaultMappingIfNeeded(sMarker,domain, false, true); //} //else //{ // throw new ScriptureUtilsException(SUE_ErrorCode.InvalidCharacterInMarker, null, 0, // sMarker + sText, new ScrReference(scParatextTextSegment.FirstReference.BBCCCVVV)); //} } } catch (Exception ex) { Logger.WriteEvent(string.Format( "Got {0} exception loading paratext mappings (ScrImportP6Project.LoadParatextMappings):\n{1}", ex.GetType(), ex.Message)); return(false); } return(true); }
public void SetMappings_Notes() { ScrMappingList list = new ScrMappingList(MappingSet.Notes, null); list.Add(new ImportMappingInfo(@"\a", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\b", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, ScrStyleNames.Remark, null)); try { list.Add(new ImportMappingInfo(@"\q", null, false, MappingTargetType.TEStyle, MarkerDomain.BackTrans, ScrStyleNames.NormalParagraph, null)); Assert.Fail("Illegal mapping (to BackTrans domain) was not caught"); } catch (ArgumentException) {} Assert.AreEqual(2, list.Count); ImportMappingInfo mapping = list[0]; Assert.AreEqual(@"\a", mapping.BeginMarker); Assert.AreEqual(MarkerDomain.Default, mapping.Domain); mapping = list[1]; Assert.AreEqual(@"\b", mapping.BeginMarker); Assert.AreEqual(MarkerDomain.Default, mapping.Domain); }
public void AddInfoWithNullMarker() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(new ImportMappingInfo(null, null, null)); }
public void AddDefaultMappingIfNeeded_btMappingsWithNonDefaultMappings() { DynamicMock mockStylesheet = new DynamicMock(typeof(IVwStylesheet)); mockStylesheet.SetupResultForParams("GetContext", (int)ContextValues.General, "Emphasis"); mockStylesheet.SetupResultForParams("GetType", (int)StyleType.kstCharacter, "Emphasis"); ScrMappingList list = new ScrMappingList(MappingSet.Main, (IVwStylesheet)mockStylesheet.MockInstance); list.Add(new ImportMappingInfo(@"\p", null, "Emphasis")); list.AddDefaultMappingIfNeeded(@"\btp", ImportDomain.Main, true); Assert.AreEqual(2, list.Count); // Test that \btp maps automatically to the corresponding vernacular style ("Emphasis") // but does not map into the Back-trans marker domain because Emphasis is a character style. ImportMappingInfo info = list[@"\btp"]; Assert.AreEqual(MarkerDomain.Default, info.Domain, @"\btp should not map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.AreEqual("Emphasis", info.StyleName); }
public void AddDefaultMappingIfNeeded_FigureMarkers() { DynamicMock mockStylesheet = new DynamicMock(typeof(IVwStylesheet)); ScrMappingList list = new ScrMappingList(MappingSet.Main, (IVwStylesheet)mockStylesheet.MockInstance); list.AddDefaultMappingIfNeeded(@"\cap", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\cat", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\gmb", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\gmbj", ImportDomain.Main, true); Assert.AreEqual(4, list.Count); ImportMappingInfo info = list[@"\cap"]; Assert.AreEqual(MarkerDomain.Default, info.Domain); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.FigureCaption, info.MappingTarget); Assert.IsNull(info.StyleName); info = list[@"\cat"]; Assert.AreEqual(MarkerDomain.Default, info.Domain); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.FigureFilename, info.MappingTarget); Assert.IsNull(info.StyleName); info = list[@"\gmb"]; Assert.AreEqual(MarkerDomain.Default, info.Domain); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.FigureFilename, info.MappingTarget); Assert.IsNull(info.StyleName); info = list[@"\gmbj"]; Assert.AreEqual(MarkerDomain.Default, info.Domain); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.FigureCaption, info.MappingTarget); Assert.IsNull(info.StyleName); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo based on a Toolbox (i.e., non-Paratext 5) filename. /// This is used only in tests. /// </summary> /// <param name="fileName">Name of the file whose info this represents</param> /// <param name="mappingList">Sorted list of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which /// this file belongs (only used for Note sources)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain, string icuLocale, int noteTypeHvo) : this(fileName, mappingList, domain, icuLocale, noteTypeHvo, false) { }
/// ------------------------------------------------------------------------------------ /// <summary> /// Load the mappings for a paratext project into the specified list. /// </summary> /// <param name="project">Paratext project ID</param> /// <param name="mappingList">ScrMappingList to which new mappings will be added</param> /// <param name="domain">The import domain for which this project is the source</param> /// <returns><c>true</c> if the Paratext mappings were loaded successfully; <c>false</c> /// otherwise</returns> /// ------------------------------------------------------------------------------------ public static bool LoadParatextMappings(string project, ScrMappingList mappingList, ImportDomain domain) { // If the new project ID is null, then do not load mappings. if (project == null) return false; // Load the tags from the paratext project and create mappings for them. SCRIPTUREOBJECTSLib.ISCScriptureText3 scParatextText = null; try { scParatextText = new SCRIPTUREOBJECTSLib.SCScriptureTextClass(); scParatextText.Load(project); } catch (Exception ex) { Logger.WriteEvent(string.Format( "Got {0} exception loading paratext mappings (ScrImportP6Project.LoadParatextMappings):\n{1}", ex.GetType(), ex.Message)); return false; } // TE-5802 try { for (int i = 0; true; i++) { SCRIPTUREOBJECTSLib.ISCTag tag = scParatextText.NthTag(i); if (tag == null) break; string marker = @"\" + tag.Marker; string endMarker = string.Empty; if (tag.Endmarker != string.Empty && tag.Endmarker != null) endMarker = @"\" + tag.Endmarker; // When the nth marker has an end marker, the nth + 1 marker will be // that end marker. Therefore, we have to skip those "end style" markers. if (tag.StyleType == SCRIPTUREOBJECTSLib.SCStyleType.scEndStyle) continue; // Create a new mapping for this marker. mappingList.AddDefaultMappingIfNeeded(marker, endMarker, domain, false, false); } SCRIPTUREOBJECTSLib.SCReference startRefPT = new SCRIPTUREOBJECTSLib.SCReference(); SCRIPTUREOBJECTSLib.SCReference endRefPT = new SCRIPTUREOBJECTSLib.SCReference(); startRefPT.Parse("GEN 1:0"); endRefPT.Parse("REV 22:21"); SCRIPTUREOBJECTSLib.ISCTextEnum scParatextTextEnum = scParatextText.TextEnum( (SCRIPTUREOBJECTSLib.SCReference)startRefPT, (SCRIPTUREOBJECTSLib.SCReference)endRefPT, (SCRIPTUREOBJECTSLib.SCTextType)0, //scTitle | scSection | scVerseText | scNoteText | scOther) (SCRIPTUREOBJECTSLib.SCTextProperties)0); SCRIPTUREOBJECTSLib.SCTextSegment scParatextTextSegment = new SCRIPTUREOBJECTSLib.SCTextSegmentClass(); mappingList.ResetInUseFlags(domain); while (scParatextTextEnum.Next(scParatextTextSegment) != 0) { string sMarker = @"\" + scParatextTextSegment.Tag.Marker; ImportMappingInfo mapping = mappingList[sMarker]; if (mapping != null) mapping.SetIsInUse(domain, true); // ENHANCE (TE-4408): Consider Detecting markers that occur in the data but are missing // from the STY file. How can we write a test for this? //else if (ScrImportFileInfo.IsValidMarker(sMarker)) //{ // mappingList.AddDefaultMappingIfNeeded(sMarker,domain, false, true); //} //else //{ // throw new ScriptureUtilsException(SUE_ErrorCode.InvalidCharacterInMarker, null, 0, // sMarker + sText, new ScrReference(scParatextTextSegment.FirstReference.BBCCCVVV)); //} } } catch (Exception ex) { Logger.WriteEvent(string.Format( "Got {0} exception loading paratext mappings (ScrImportP6Project.LoadParatextMappings):\n{1}", ex.GetType(), ex.Message)); return false; } return true; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo from a CmFile owned by a BT source. This is /// used when populating the file list from the database. /// </summary> /// <param name="file">The CmFile</param> /// <param name="mappingList">Sorted list of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(CmFile file, ScrMappingList mappingList, ImportDomain domain, string icuLocale, bool scanInlineBackslashMarkers) : this(file, mappingList, domain, icuLocale, 0, scanInlineBackslashMarkers) { }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo based on a Toolbox (i.e., non-Paratext 5) filename. /// This is used only in tests. /// </summary> /// <param name="fileName">Name of the file whose info this represents</param> /// <param name="mappingList">Sorted list of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which /// this file belongs (only used for Note sources)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain, string icuLocale, int noteTypeHvo) : this(fileName, mappingList, domain, icuLocale, noteTypeHvo, false) { }
public override void Exit() { CheckDisposed(); m_builder.Dispose(); m_builder = null; m_settings = null; m_mappingList = null; base.Exit(); }
/// <summary> /// Executes in two distinct scenarios. /// /// 1. If disposing is true, the method has been called directly /// or indirectly by a user's code via the Dispose method. /// Both managed and unmanaged resources can be disposed. /// /// 2. If disposing is false, the method has been called by the /// runtime from inside the finalizer and you should not reference (access) /// other managed objects, as they already have been garbage collected. /// Only unmanaged resources can be disposed. /// </summary> /// <param name="disposing"></param> /// <remarks> /// If any exceptions are thrown, that is fine. /// If the method is being done in a finalizer, it will be ignored. /// If it is thrown by client code calling Dispose, /// it needs to be handled by fixing the bug. /// /// If subclasses override this method, they should call the base implementation. /// </remarks> protected override void Dispose(bool disposing) { //Debug.WriteLineIf(!disposing, "****************** " + GetType().Name + " 'disposing' is false. ******************"); // Must not be run more than once. if (IsDisposed) return; if (disposing) { // Dispose managed resources here. } // Dispose unmanaged resources here, whether disposing is true or false. m_mappingList = null; base.Dispose(disposing); }
public void Enumerator() { ScrMappingList list = new ScrMappingList(MappingSet.Notes, null); list.Add(new ImportMappingInfo(@"\aa", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\bb", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\cc", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); int i = 0; foreach (ImportMappingInfo info in list) Assert.AreEqual(list[i++], info); Assert.AreEqual(3, i); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo based on a filename. This is used to build an /// in-memory list of files. /// </summary> /// <param name="fileName">Name of the file whose info this represents</param> /// <param name="mappingList">Sorted list of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which /// this file belongs (only used for Note sources)</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain, string icuLocale, int noteTypeHvo, bool scanInlineBackslashMarkers) { m_fileName = fileName; m_mappingList = mappingList; m_domain = domain; m_icuLocale = icuLocale; m_noteTypeHvo = noteTypeHvo; m_doStrictFileChecking = false; ScanInlineBackslashMarkers = scanInlineBackslashMarkers; Initialize(); }
public void AddDefaultMappingIfNeeded_btMappings() { DynamicMock mockStylesheet = new DynamicMock(typeof(IVwStylesheet)); mockStylesheet.SetupResultForParams("GetContext", (int)ContextValues.Note, ScrStyleNames.NormalFootnoteParagraph); mockStylesheet.SetupResultForParams("GetContext", (int)ContextValues.Text, ScrStyleNames.NormalParagraph); mockStylesheet.SetupResultForParams("GetContext", (int)ContextValues.General, "Emphasis"); mockStylesheet.SetupResultForParams("GetContext", (int)ContextValues.Annotation, ScrStyleNames.Remark); mockStylesheet.SetupResultForParams("GetType", (int)StyleType.kstParagraph, ScrStyleNames.NormalFootnoteParagraph); mockStylesheet.SetupResultForParams("GetType", (int)StyleType.kstParagraph, ScrStyleNames.NormalParagraph); mockStylesheet.SetupResultForParams("GetType", (int)StyleType.kstCharacter, "Emphasis"); mockStylesheet.SetupResultForParams("GetType", (int)StyleType.kstParagraph, ScrStyleNames.Remark); ScrMappingList list = new ScrMappingList(MappingSet.Main, (IVwStylesheet)mockStylesheet.MockInstance); list.AddDefaultMappingIfNeeded(@"\bt", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\btc", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\btf", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\btp", ImportDomain.Main, true); list.Add(new ImportMappingInfo(@"\emph", null, "Emphasis")); list.AddDefaultMappingIfNeeded(@"\btemph", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\btrem", ImportDomain.Main, true); list.AddDefaultMappingIfNeeded(@"\bty", ImportDomain.Main, true); Assert.AreEqual(8, list.Count); // Test that \bt does not map automatically as a Back-trans marker. ImportMappingInfo info = list[@"\bt"]; Assert.AreEqual(MarkerDomain.Default, info.Domain, @"\bt should not map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.IsNull(info.StyleName); // Test that \btc does not map automatically as a Back-trans marker (this is a special exception to the rul). info = list[@"\btc"]; Assert.AreEqual(MarkerDomain.Default, info.Domain, @"\btc should not map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.IsNull(info.StyleName); // Test that \btf maps automatically as a Back-trans marker. info = list[@"\btf"]; Assert.AreEqual(MarkerDomain.BackTrans | MarkerDomain.Footnote, info.Domain, @"\btf should map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.AreEqual(ScrStyleNames.NormalFootnoteParagraph, info.StyleName); // Test that \btp maps automatically as a Back-trans marker. info = list[@"\btp"]; Assert.AreEqual(MarkerDomain.BackTrans, info.Domain, @"\btp should map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.AreEqual(ScrStyleNames.NormalParagraph, info.StyleName); // Test that \btemph maps automatically to the corresponding vernacular style but does not map // into the Back-trans marker domain because \emph is a character style. info = list[@"\btemph"]; Assert.AreEqual(MarkerDomain.Default, info.Domain, @"\btemph should not map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.AreEqual("Emphasis", info.StyleName); // Test that \btrem does not map automatically as a Back-trans marker (because \rem is a Note style). info = list[@"\btrem"]; Assert.AreEqual(MarkerDomain.Default, info.Domain, @"\btrem should not map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.IsNull(info.StyleName); // Test that \bty does not map automatically as a Back-trans marker (because \y has no default mapping). info = list[@"\bty"]; Assert.AreEqual(MarkerDomain.Default, info.Domain, @"\bty should not map automatically as a Back-trans marker"); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TEStyle, info.MappingTarget); Assert.IsNull(info.StyleName); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo from a CmFile. This is used when populating the /// file list from the database. /// </summary> /// <param name="file">The CmFile</param> /// <param name="mappingList">List of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which /// this file belongs (only used for Note sources)</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(ICmFile file, ScrMappingList mappingList, ImportDomain domain, string icuLocale, int noteTypeHvo, bool scanInlineBackslashMarkers): this(file.AbsoluteInternalPath, mappingList, domain, icuLocale, noteTypeHvo, scanInlineBackslashMarkers) { m_file = file; }
public void AddDefaultMappingIfNeeded_btNotFromTeStyle() { DynamicMock mockStylesheet = new DynamicMock(typeof(IVwStylesheet)); mockStylesheet.Strict = true; ScrMappingList list = new ScrMappingList(MappingSet.Main, (IVwStylesheet)mockStylesheet.MockInstance); list.Add(new ImportMappingInfo(@"\h", null, false, MappingTargetType.TitleShort, MarkerDomain.Default, null, null)); list.AddDefaultMappingIfNeeded(@"\bth", ImportDomain.Main, true); list.Add(new ImportMappingInfo(@"\vt", null, false, MappingTargetType.DefaultParaChars, MarkerDomain.Default, null, null)); list.AddDefaultMappingIfNeeded(@"\btvt", ImportDomain.Main, true); Assert.AreEqual(4, list.Count); // Test that \bth maps automatically to the corresponding vernacular import property // in the Back-trans marker domain. ImportMappingInfo info = list[@"\bth"]; Assert.AreEqual(MarkerDomain.BackTrans, info.Domain); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.TitleShort, info.MappingTarget); // Test that \btvt maps automatically to Default Paragraph Characters // in the Back-trans marker domain. info = list[@"\btvt"]; Assert.AreEqual(MarkerDomain.BackTrans, info.Domain); Assert.IsFalse(info.IsExcluded); Assert.AreEqual(MappingTargetType.DefaultParaChars, info.MappingTarget); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo from a CmFile owned by a BT source. This is /// used when populating the file list from the database. /// </summary> /// <param name="file">The CmFile</param> /// <param name="mappingList">Sorted list of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="domain">The import domain to which this file belongs</param> /// <param name="icuLocale">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// ------------------------------------------------------------------------------------ public ScrImportFileInfo(CmFile file, ScrMappingList mappingList, ImportDomain domain, string icuLocale, bool scanInlineBackslashMarkers): this(file, mappingList, domain, icuLocale, 0, scanInlineBackslashMarkers) { }
public void AddNullMappingInfo() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(null); }
public void Delete() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(new ImportMappingInfo(@"\aa", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\bb", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\cc", null, false, MappingTargetType.TEStyle, MarkerDomain.BackTrans, ScrStyleNames.Remark, null)); Assert.AreEqual(3, list.Count); list.Delete(list[1]); Assert.AreEqual(2, list.Count); Assert.AreEqual(@"\aa", list[0].BeginMarker); Assert.AreEqual(@"\cc", list[1].BeginMarker); }
public void AddBlankMarker() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(new ImportMappingInfo(string.Empty, string.Empty, string.Empty)); }
public void HasChanged() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(new ImportMappingInfo(@"\aa", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\bb", null, false, MappingTargetType.TEStyle, MarkerDomain.Default, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\cc", null, false, MappingTargetType.TEStyle, MarkerDomain.BackTrans, ScrStyleNames.Remark, null)); Assert.IsTrue((bool)ReflectionHelper.GetProperty(list, "HasChanged")); Assert.AreEqual(3, list.Count); ReflectionHelper.SetProperty(list[0], "HasChanged", false); ReflectionHelper.SetProperty(list[1], "HasChanged", false); ReflectionHelper.SetProperty(list[2], "HasChanged", false); Assert.IsFalse((bool)ReflectionHelper.GetProperty(list, "HasChanged")); list.Delete(list[1]); Assert.AreEqual(2, list.Count); Assert.IsTrue((bool)ReflectionHelper.GetProperty(list, "HasChanged")); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Initializes a new instance of the <see cref="ScrSfFileList"/> class based on an /// existing ScrImportSFFiles in the DB. /// </summary> /// <param name="source">A DB-based collection of Standard Format files</param> /// <param name="mappingList">The mapping list to which mappings will be added if any /// new ones are found when scanning the files</param> /// <param name="importDomain">Main (vernacular Scripture), BT or Annotations</param> /// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// <param name="helpFile">The path of the application help file.</param> /// ------------------------------------------------------------------------------------ public ScrSfFileList(ScrImportSFFiles source, ScrMappingList mappingList, ImportDomain importDomain, bool scanInlineBackslashMarkers, string helpFile) : this(null) { List<int> deleteList = new List<int>(); // Load the files into an in-memory list foreach (ICmFile file in source.FilesOC) { try { ScrImportFileInfo info = new ScrImportFileInfo(file, mappingList, importDomain, source.ICULocale, source.NoteTypeRAHvo, scanInlineBackslashMarkers); Add(info); } catch (ScriptureUtilsException e) { MessageBox.Show(string.Format(ScrFdoResources.kstidImportBadFile, e.Message), "", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0, helpFile, HelpNavigator.Topic, e.HelpTopic); deleteList.Add(file.Hvo); } } // delete all of the files that caused errors foreach (int deleteItem in deleteList) source.Cache.DeleteObject(deleteItem); m_modified = false; }
public void Index_OutOfRange() { ScrMappingList list = new ScrMappingList(MappingSet.Notes, null); list.Add(new ImportMappingInfo(@"\a", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); // Access the second element which should throw an exception ImportMappingInfo info = list[1]; }
public void LookupByKey() { ScrMappingList list = new ScrMappingList(MappingSet.Notes, null); list.Add(new ImportMappingInfo(@"\aa", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\bb", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); list.Add(new ImportMappingInfo(@"\cc", null, false, MappingTargetType.TEStyle, MarkerDomain.Note, ScrStyleNames.Remark, null)); ImportMappingInfo info = list[@"\bb"]; Assert.AreEqual(@"\bb", info.BeginMarker); Assert.AreEqual(list[1], info); }
public void LookupByKey_NonExistent() { ScrMappingList list = new ScrMappingList(MappingSet.Notes, null); Assert.IsNull(list["moogy"]); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Construct a ScrImportFileInfo based on a filename. This is used to build an /// in-memory list of files. /// </summary> /// <param name="fileContents">String containing one or more "lines" of data, separated /// by \r\n</param> /// <param name="mappingList">Sorted list of mappings to which newly found mappings /// should (and will) be added</param> /// <param name="fParatext5"><c>true</c> to look for backslash markers /// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers /// must start on a new line, but Paratext considers all backslashes in the data to be /// SF markers.)</param> /// ------------------------------------------------------------------------------------ public DummyScrImportFileInfo(string fileContents, ScrMappingList mappingList, bool fParatext5) : base(fileContents, mappingList, ImportDomain.Main, null, 0, fParatext5) { }
public override void FixtureSetup() { CheckDisposed(); base.FixtureSetup(); m_mappingList = new ScrMappingList(MappingSet.Main, null); }