/// ------------------------------------------------------------------------------------ /// <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> /// ------------------------------------------------------------------------------------ public ScrSfFileList(IScrImportSFFiles source, ScrMappingList mappingList, ImportDomain importDomain, bool scanInlineBackslashMarkers) : this(null) { var deleteList = new List <ICmFile>(); // Load the files into an in-memory list foreach (ICmFile file in source.FilesOC) { try { IScrImportFileInfo info = new ScrImportFileInfo(file, mappingList, importDomain, source.WritingSystem, source.NoteTypeRA, scanInlineBackslashMarkers); Add(info); } catch (ScriptureUtilsException e) { var userAction = source.Services.GetInstance <IFdoUI>(); userAction.DisplayMessage(MessageType.Error, string.Format(ScrFdoResources.kstidImportBadFile, e.Message), Strings.ksErrorCaption, e.HelpTopic); deleteList.Add(file); } } // delete all of the files that caused errors foreach (ICmFile deleteItem in deleteList) { source.FilesOC.Remove(deleteItem); } m_modified = false; }
/// ------------------------------------------------------------------------------------ /// <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="wsId">The ICU locale of the source to which this file belongs /// (null for Scripture source)</param> /// <param name="noteType">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> /// ------------------------------------------------------------------------------------ internal ScrImportFileInfo(ICmFile file, ScrMappingList mappingList, ImportDomain domain, string wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers) : this(file.AbsoluteInternalPath, mappingList, domain, wsId, noteType, 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(IScrImportSFFiles source, ScrMappingList mappingList, ImportDomain importDomain, bool scanInlineBackslashMarkers, string helpFile) : this(null) { List <ICmFile> deleteList = new List <ICmFile>(); // Load the files into an in-memory list foreach (ICmFile file in source.FilesOC) { try { IScrImportFileInfo info = new ScrImportFileInfo(file, mappingList, importDomain, source.WritingSystem, source.NoteTypeRA, scanInlineBackslashMarkers); Add(info); } catch (ScriptureUtilsException e) { MessageBoxUtils.Show(string.Format(ScrFdoResources.kstidImportBadFile, e.Message), "", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0, helpFile, HelpNavigator.Topic, e.HelpTopic); deleteList.Add(file); } } // delete all of the files that caused errors foreach (ICmFile deleteItem in deleteList) { source.FilesOC.Remove(deleteItem); } m_modified = false; }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates a <see cref="ScrImportFileInfo"/> based on a file. 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="wsId">The writing system identifier of the source to which this file /// belongs (null for Scripture source)</param> /// <param name="noteType">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 virtual IScrImportFileInfo Create(string fileName, ScrMappingList mappingList, ImportDomain domain, string wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers) { return(new ScrImportFileInfo(fileName, mappingList, domain, wsId, noteType, scanInlineBackslashMarkers)); }
private void DoCommonNonModelSetup() { m_scrMappingsList = new ScrMappingList(MappingSet.Main, m_stylesheet); m_notesMappingsList = new ScrMappingList(MappingSet.Notes, m_stylesheet); LoadInMemoryMappingLists(); LoadSources(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="wsId">The writing system identifier of the source to which this file /// belongs (null for Scripture source)</param> /// <param name="noteType">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 wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers) { m_fileName = fileName; m_mappingList = mappingList; m_domain = domain; m_wsId = wsId; m_noteType = noteType; 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.WsId); 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 AddDefaultMappingIfNeeded_btMappings() { IVwStylesheet stylesheet = MockRepository.GenerateStub<IVwStylesheet>(); stylesheet.Stub(x => x.GetContext(ScrStyleNames.NormalFootnoteParagraph)).Return((int)ContextValues.Note); stylesheet.Stub(x => x.GetContext(ScrStyleNames.NormalParagraph)).Return((int)ContextValues.Text); stylesheet.Stub(x => x.GetContext("Emphasis")).Return((int)ContextValues.General); stylesheet.Stub(x => x.GetContext(ScrStyleNames.Remark)).Return((int)ContextValues.Annotation); stylesheet.Stub(x => x.GetType(ScrStyleNames.NormalFootnoteParagraph)).Return((int)StyleType.kstParagraph); stylesheet.Stub(x => x.GetType(ScrStyleNames.NormalParagraph)).Return((int)StyleType.kstParagraph); stylesheet.Stub(x => x.GetType("Emphasis")).Return((int)StyleType.kstCharacter); stylesheet.Stub(x => x.GetType(ScrStyleNames.Remark)).Return((int)StyleType.kstParagraph); ScrMappingList list = new ScrMappingList(MappingSet.Main, stylesheet); 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); }
public bool LoadProjectMappings(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. ScrText scParatextText; try { // REVIEW (EberhardB): I'm not sure if ScrTextCollection.Get() returns a // reference to a ScrText or a new object (in which case we would have to // call Dispose() on it) scParatextText = ScrTextCollection.Get(project); } catch (Exception ex) { Logger.WriteError(ex); return(false); } mappingList.ResetInUseFlags(domain); try { foreach (ScrTag tag in scParatextText.DefaultStylesheet.Tags) { if (tag == null) { break; } string marker = @"\" + tag.Marker; string endMarker = string.Empty; if (!String.IsNullOrEmpty(tag.Endmarker)) { 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 == ScrStyleType.scEndStyle) { continue; } // Create a new mapping for this marker. mappingList.AddDefaultMappingIfNeeded(marker, endMarker, domain, false, false); } ScrParser parser = scParatextText.Parser(); foreach (int bookNum in scParatextText.BooksPresentSet.SelectedBookNumbers()) { foreach (UsfmToken token in parser.GetUsfmTokens(new VerseRef(bookNum, 0, 0), false, true)) { if (token.Marker == null) { continue; // Tokens alternate between text and marker types } ImportMappingInfo mapping = mappingList[@"\" + token.Marker]; 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.WriteError(ex); return(false); } return(true); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Save the in-memory mapping lists for the given mapping set /// </summary> /// <param name="mappingsOC">The owning collection of ScrMarkerMapping objects in the /// database</param> /// <param name="mappingInfoList">The in-memory list of ImportMappingInfo objects</param> /// ------------------------------------------------------------------------------------ private void SaveMappings(IFdoOwningCollection<IScrMarkerMapping> mappingsOC, ScrMappingList mappingInfoList) { UndoableUnitOfWorkHelper.DoUsingNewOrCurrentUOW("Save mappings", "Save mappings", m_cache.ServiceLocator.GetInstance<IActionHandler>(), () => { mappingsOC.Clear(); foreach (ImportMappingInfo info in mappingInfoList) { IScrMarkerMapping mapping = Services.GetInstance<IScrMarkerMappingFactory>().Create(); mappingsOC.Add(mapping); // The "Default Paragraph Characters" style is not a real style. So, we save it as // as separate target type. We want to set the style now for the in-memory info. if (info.StyleName == StyleUtils.DefaultParaCharsStyleName) info.MappingTarget = MappingTargetType.DefaultParaChars; else if (info.Style == null || info.Style.Name != info.StyleName) info.SetStyle(m_cache.LangProject.TranslatedScriptureOA.FindStyle(info.StyleName)); ((ScrMarkerMapping)mapping).InitFromImportMappingInfo(info); } }); }
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_btNotFromTeStyle() { IVwStylesheet stylesheet = MockRepository.GenerateStrictMock<IVwStylesheet>(); ScrMappingList list = new ScrMappingList(MappingSet.Main, stylesheet); 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); }
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); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates a <see cref="ScrImportFileInfo"/> based on a file. 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="wsId">The writing system identifier of the source to which this file /// belongs (null for Scripture source)</param> /// <param name="noteType">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 virtual IScrImportFileInfo Create(string fileName, ScrMappingList mappingList, ImportDomain domain, string wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers) { return new ScrImportFileInfo(fileName, mappingList, domain, wsId, noteType, scanInlineBackslashMarkers); }
/// ------------------------------------------------------------------------------------ /// <summary> /// Shuts down the FDO cache /// </summary> /// <remarks>This method is called after each test</remarks> /// ------------------------------------------------------------------------------------ public override void TestTearDown() { m_builder.Dispose(); m_builder = null; m_settings = null; m_mappingList = null; base.TestTearDown(); }
public override void FixtureSetup() { base.FixtureSetup(); IWritingSystem wsSpanish; Cache.ServiceLocator.WritingSystemManager.GetOrSet("es", out wsSpanish); IWritingSystem wsGerman; Cache.ServiceLocator.WritingSystemManager.GetOrSet("de", out wsGerman); NonUndoableUnitOfWorkHelper.Do(m_actionHandler, () => { Cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.Add(wsSpanish); Cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems.Add(wsSpanish); Cache.ServiceLocator.WritingSystems.AnalysisWritingSystems.Add(wsGerman); Cache.ServiceLocator.WritingSystems.CurrentAnalysisWritingSystems.Add(wsGerman); }); m_mappingList = new ScrMappingList(MappingSet.Main, null); }
/// ------------------------------------------------------------------------------------ /// <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="wsId">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> /// ------------------------------------------------------------------------------------ internal ScrImportFileInfo(ICmFile file, ScrMappingList mappingList, ImportDomain domain, string wsId, bool scanInlineBackslashMarkers) : this(file, mappingList, domain, wsId, null, scanInlineBackslashMarkers) { }
public void AddDefaultMappingIfNeeded_btMappingsWithNonDefaultMappings() { IVwStylesheet stylesheet = MockRepository.GenerateStub<IVwStylesheet>(); stylesheet.Stub(x => x.GetContext("Emphasis")).Return((int)ContextValues.General); stylesheet.Stub(x => x.GetType("Emphasis")).Return((int)StyleType.kstCharacter); ScrMappingList list = new ScrMappingList(MappingSet.Main, stylesheet); 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 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")); }
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 AddNullMappingInfo() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(null); }
/// ------------------------------------------------------------------------------------ /// <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="wsId">The writing system identifier of the source to which this file /// belongs (null for Scripture source)</param> /// <param name="noteType">The CmAnnotationDefn of the source to which /// this file belongs (only used for Note sources)</param> /// ------------------------------------------------------------------------------------ internal ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain, string wsId, ICmAnnotationDefn noteType) : this(fileName, mappingList, domain, wsId, noteType, false) { }
public void AddBlankMarker() { ScrMappingList list = new ScrMappingList(MappingSet.Main, null); list.Add(new ImportMappingInfo(string.Empty, string.Empty, string.Empty)); }
/// ------------------------------------------------------------------------------------ /// <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 Environment.NewLine</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, null, fParatext5) { }
/// ------------------------------------------------------------------------------------ /// <summary> /// Creates a mocked <see cref="IScrImportFileInfo"/>. 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="wsId">The writing system identifier of the source to which this file /// belongs (null for Scripture source)</param> /// <param name="noteType">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 override IScrImportFileInfo Create(string fileName, ScrMappingList mappingList, ImportDomain domain, string wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers) { IScrImportFileInfo info = MockRepository.GenerateStub<IScrImportFileInfo>(); m_mockedScrImportFinfos[fileName] = info; info.Stub(x => x.FileName).Return(fileName); info.Stub(x => x.WsId).Return(wsId); info.Stub(x => x.NoteType).Return(noteType); return info; }
/// ------------------------------------------------------------------------------------ /// <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> /// ------------------------------------------------------------------------------------ public ScrSfFileList(IScrImportSFFiles source, ScrMappingList mappingList, ImportDomain importDomain, bool scanInlineBackslashMarkers) : this(null) { var deleteList = new List<ICmFile>(); // Load the files into an in-memory list foreach (ICmFile file in source.FilesOC) { try { IScrImportFileInfo info = new ScrImportFileInfo(file, mappingList, importDomain, source.WritingSystem, source.NoteTypeRA, scanInlineBackslashMarkers); Add(info); } catch (ScriptureUtilsException e) { var userAction = source.Services.GetInstance<IFdoUI>(); userAction.DisplayMessage(MessageType.Error, string.Format(ScrFdoResources.kstidImportBadFile, e.Message), Strings.ksErrorCaption, e.HelpTopic); deleteList.Add(file); } } // delete all of the files that caused errors foreach (ICmFile deleteItem in deleteList) source.FilesOC.Remove(deleteItem); m_modified = false; }
public void Init() { m_mappingList = new ScrMappingList(MappingSet.Main, null); m_factory = new ScrImportFileInfoFactory(); m_fileOs = new MockFileOS(); FileUtils.Manager.SetFileAdapter(m_fileOs); }
public void AddDefaultMappingIfNeeded_FigureMarkers() { IVwStylesheet stylesheet = MockRepository.GenerateMock<IVwStylesheet>(); ScrMappingList list = new ScrMappingList(MappingSet.Main, stylesheet); 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); }
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"]); }
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); }
private bool LoadProjectMappings(string project, ScrMappingList mappingList, ImportDomain domain) { // If the new project ID is null, then do not load mappings. if (string.IsNullOrEmpty(project)) return false; // Load the tags from the paratext project and create mappings for them. ScrText scParatextText; try { // REVIEW (EberhardB): I'm not sure if ScrTextCollection.Get() returns a // reference to a ScrText or a new object (in which case we would have to // call Dispose() on it) scParatextText = ScrTextCollection.Get(project); } catch (Exception ex) { Logger.WriteError(ex); m_IsParatextInitialized = false; return false; } foreach (ImportMappingInfo mapping in mappingList) mapping.SetIsInUse(domain, false); try { foreach (ScrTag tag in scParatextText.DefaultStylesheet.Tags) { if (tag == null) break; string marker = @"\" + tag.Marker; string endMarker = string.Empty; if (!String.IsNullOrEmpty(tag.Endmarker)) 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 == ScrStyleType.scEndStyle) continue; // Create a new mapping for this marker. mappingList.AddDefaultMappingIfNeeded(marker, endMarker, domain, false, false); } ScrParser parser = scParatextText.Parser; foreach (int bookNum in scParatextText.BooksPresentSet.SelectedBookNumbers) { foreach (UsfmToken token in parser.GetUsfmTokens(new VerseRef(bookNum, 0, 0), false, true)) { if (token.Marker == null) continue; // Tokens alternate between text and marker types ImportMappingInfo mapping = mappingList[@"\" + token.Marker]; if (mapping != null) mapping.SetIsInUse(domain, true); } } } catch (Exception ex) { Logger.WriteError(ex); // A lot goes on in the try block, so this exception doesn't necessarily mean Paratext is inaccessible, // so don't mark Paratext as uninitialized return false; } return true; }