private void UpdateLinkNode(IXmlNode node, VerseEntry verseEntry)
{
var hrefAttrName = "href"; // todo: а может быть такое, что в провайдере другой атрибут используется для ссылок?
var hrefAttrValue = this.verseLinkService.GetVerseLink(verseEntry.VersePointer);
node.SetAttributeValue(hrefAttrName, hrefAttrValue);
}
/// <summary>
/// Например, ":5"
/// </summary>
/// <param name="verseEntry"></param>
/// <param name="docParseContext"></param>
/// <returns></returns>
private static bool VerseRule(VerseEntry verseEntry, IDocumentParseContext docParseContext)
{
var latestVp = docParseContext.CurrentParagraph.LatestVerseEntry?.VersePointer;
if (latestVp == null)
{
var chapterEntry = docParseContext.CurrentParagraph.GetHierarchyChapterEntry()
?? docParseContext.CurrentHierarchy?.GetHierarchyChapterEntry();
if (chapterEntry?.Found == true)
{
latestVp = chapterEntry.ChapterPointer;
}
else if (docParseContext.TitleChapter?.Found == true)
{
latestVp = docParseContext.TitleChapter.ChapterPointer;
}
}
if (latestVp != null && latestVp.MultiVerseType <= MultiVerse.OneChapter)
{
verseEntry.VersePointer.Book = latestVp.Book;
verseEntry.VersePointer.ModuleShortName = latestVp.ModuleShortName;
var latestTopChapter = string.IsNullOrEmpty(latestVp.ModuleShortName) ? latestVp.MostTopChapter : latestVp.OriginalMostTopChapter;
verseEntry.VersePointer.SetChapter(latestTopChapter);
return(true);
}
return(false);
}
private VerseEntry TryGetVerseEntry(string text, int startIndex, int indexOfDigit, bool useCommaDelimiter)
{
var textFragmentInfo = GetTextFragmentInfo(text, startIndex, indexOfDigit, useCommaDelimiter);
CheckTextFragment(textFragmentInfo, text, useCommaDelimiter);
if (textFragmentInfo.IsEmpty)
{
return new VerseEntry()
{
EntryType = VerseEntryType.None
}
}
;
var result = new VerseEntry()
{
EntryType = textFragmentInfo.EntryType,
EntryOptions = textFragmentInfo.GetEntryOptions(),
StartIndex = textFragmentInfo.Boundaries.StartIndex,
EndIndex = textFragmentInfo.Boundaries.EndIndex,
VersePointer = new VersePointer(
textFragmentInfo.BibleBookInfo,
textFragmentInfo.ModuleName,
textFragmentInfo.GetVerseText(),
textFragmentInfo.VerseNumber,
textFragmentInfo.TopVerseNumber)
};
return(result);
}
/// <summary>
/// Например, "; 5"
/// </summary>
/// <param name="verseEntry"></param>
/// <param name="docParseContext"></param>
/// <returns></returns>
private static bool ChapterRule(VerseEntry verseEntry, IDocumentParseContext docParseContext)
{
if (docParseContext.CurrentParagraph.LatestVerseEntry != null)
{
var latestVp = docParseContext.CurrentParagraph.LatestVerseEntry.VersePointer;
verseEntry.VersePointer.Book = latestVp.Book;
verseEntry.VersePointer.ModuleShortName = latestVp.ModuleShortName;
return(true);
}
return(false);
}
private void AssertVerseEntry(
VerseEntry verseEntryInfo,
int startIndex,
int endIndex,
VerseEntryType verseEntryType,
VerseEntryOptions?verseEntryOptions = null)
{
Assert.AreEqual(startIndex, verseEntryInfo.StartIndex);
Assert.AreEqual(endIndex, verseEntryInfo.EndIndex);
Assert.AreEqual(verseEntryType, verseEntryInfo.EntryType);
if (verseEntryOptions.HasValue)
{
Assert.AreEqual(verseEntryOptions.Value, verseEntryInfo.EntryOptions);
}
}
public bool TryRecognizeVerse(VerseEntry verseEntry, IDocumentParseContext docParseContext)
{
if (!verseEntry.VersePointerFound)
{
return(false);
}
foreach (var func in _funcs[verseEntry.EntryType])
{
if (func(verseEntry, docParseContext))
{
return(_verseCorrectionService.CheckAndCorrectVerse(verseEntry.VersePointer));
}
}
return(false);
}
private void InsertVerseLink(VerseInNodeEntry verseInNodeEntry, VerseEntry verseEntry)
{
var verseLink = documentProvider.GetVersePointerLink(verseEntry.VersePointer);
var verseInNodeStartIndex = verseInNodeEntry.StartIndex + verseInNodeEntry.NodeEntry.Shift;
var verseInNodeEndIndex = verseInNodeEntry.EndIndex + verseInNodeEntry.NodeEntry.Shift + 1;
verseInNodeEntry.NodeEntry.Node.InnerXml = string.Concat(
verseInNodeEntry.NodeEntry.Node.InnerXml.Substring(0, verseInNodeStartIndex),
verseLink,
verseInNodeEndIndex < verseInNodeEntry.NodeEntry.Node.InnerXml.Length
? verseInNodeEntry.NodeEntry.Node.InnerXml.Substring(verseInNodeEndIndex)
: string.Empty);
var shift = verseLink.Length - verseEntry.VersePointer.OriginalVerseName.Length;
verseInNodeEntry.NodeEntry.Shift += shift;
}
public VerseEntry TryGetVerse(string text, int startIndex, int leftBoundary, bool useCommaDelimiter)
{
VerseEntry result = null;
var maxBookNameLength = _applicationManager.CurrentModuleInfo.MaxBookNameLength - 2;
var indexOfDigit = StringUtils.GetNextIndexOfDigit(text, startIndex);
while (indexOfDigit != -1)
{
if (EntryIsLikeVerse(text, indexOfDigit, useCommaDelimiter))
{
var actualStringStartIndex = indexOfDigit - maxBookNameLength;
if (actualStringStartIndex < leftBoundary)
{
actualStringStartIndex = leftBoundary;
}
result = TryGetVerseEntry(text, actualStringStartIndex, indexOfDigit, useCommaDelimiter);
}
if (result != null && result.VersePointerFound)
{
break;
}
else
{
indexOfDigit = StringUtils.GetNextIndexOfDigit(text, indexOfDigit + 1);
}
}
if (result == null)
{
result = new VerseEntry()
{
EntryType = VerseEntryType.None
}
}
;
return(result);
}
/// <summary>
/// Например, ",5-6"
/// </summary>
/// <param name="verseEntry"></param>
/// <param name="docParseContext"></param>
/// <returns></returns>
private static bool ChapterOrVerseRule(VerseEntry verseEntry, IDocumentParseContext docParseContext)
{
if (docParseContext.CurrentParagraph.LatestVerseEntry != null &&
StringUtils.CheckDivergence(docParseContext.CurrentParagraph.ParseResult.Text, docParseContext.CurrentParagraph.LatestVerseEntry.EndIndex, verseEntry.StartIndex, 2, ','))
{
var latestVp = docParseContext.CurrentParagraph.LatestVerseEntry.VersePointer;
verseEntry.VersePointer.Book = latestVp.Book;
verseEntry.VersePointer.ModuleShortName = latestVp.ModuleShortName;
verseEntry.EntryType = latestVp.VerseNumber.IsChapter
? VerseEntryType.Chapter
: VerseEntryType.Verse;
var latestTopChapter = string.IsNullOrEmpty(latestVp.ModuleShortName) ? latestVp.MostTopChapter : latestVp.OriginalMostTopChapter;
if (verseEntry.EntryType == VerseEntryType.Verse)
{
verseEntry.VersePointer.MoveChapterToVerse(latestTopChapter);
var latestTopVerse = string.IsNullOrEmpty(latestVp.ModuleShortName) ? latestVp.MostTopVerse : latestVp.OriginalMostTopVerse;
if (verseEntry.VersePointer.Verse <= latestTopVerse)
{
return(false);
}
}
else
{
if (verseEntry.VersePointer.Chapter <= latestTopChapter)
{
return(false);
}
}
return(true);
}
return(false);
}
public void SetLatestVerseEntry(VerseEntry verseEntry)
{
LatestVerseEntry = verseEntry;
ParseResult.VersesCount += verseEntry.VersePointer.SubVerses.VersesCount;
}
/// <summary>
///
/// </summary>
/// <param name="parseString"></param>
/// <param name="verseEntryInfo"></param>
/// <param name="skipNodes">Чтобы не проверять строку с начала</param>
/// <returns></returns>
private VerseInNodeEntry FindNodeAndMoveVerseTextInOneNodeIfNotReadonly(TextNodesString parseString, VerseEntry verseEntryInfo, ref int skipNodes)
{
var result = new VerseInNodeEntry();
if (parseString.NodesInfo.Count > 1)
{
foreach (var nodeEntry in parseString.NodesInfo.Skip(skipNodes))
{
if (result.NodeEntry == null)
{
if (nodeEntry.StartIndex <= verseEntryInfo.StartIndex && verseEntryInfo.StartIndex <= nodeEntry.EndIndex)
{
if (!nodeEntry.WasCleaned)
{
nodeEntry.Clean(); // то есть, если в этой ноде есть стих, тогда мы можем немного её почистить. Чтобы другие ноды не изменять.
}
result.NodeEntry = nodeEntry;
result.StartIndex = verseEntryInfo.StartIndex - nodeEntry.StartIndex;
result.EndIndex = (nodeEntry.EndIndex >= verseEntryInfo.EndIndex ? verseEntryInfo.EndIndex : nodeEntry.EndIndex) - nodeEntry.StartIndex;
if (this.docParseContext.DocumentId.IsReadonly || parseString.IsReadonly)
{
break;
}
if (nodeEntry.EndIndex >= verseEntryInfo.EndIndex)
{
break;
}
}
}
else
{
if (!nodeEntry.WasCleaned)
{
nodeEntry.Clean();
}
var moveCharsCount = (verseEntryInfo.EndIndex > nodeEntry.EndIndex ? nodeEntry.EndIndex : verseEntryInfo.EndIndex) - nodeEntry.StartIndex + 1;
var verseTextPart = nodeEntry.Node.InnerXml.Substring(0, moveCharsCount);
result.EndIndex += moveCharsCount;
nodeEntry.StartIndex += moveCharsCount; // здесь может быть ситуация, когда Startindex > EndIndex. Когда нода была из одного символа. Похоже, что это нормально. Так как мы больше нигде не используем эти ноды.
result.NodeEntry.Node.InnerXml += verseTextPart;
nodeEntry.Node.InnerXml = nodeEntry.Node.InnerXml.Remove(0, moveCharsCount);
if (verseEntryInfo.EndIndex <= nodeEntry.EndIndex)
{
break;
}
}
skipNodes++;
}
}
else
{
result.NodeEntry = parseString.NodesInfo.First();
result.StartIndex = verseEntryInfo.StartIndex;
result.EndIndex = verseEntryInfo.EndIndex;
if (!result.NodeEntry.WasCleaned)
{
result.NodeEntry.Clean();
}
}
return(result);
}
private static bool FullVerseRule(VerseEntry verseEntry, IDocumentParseContext docParseContext)
{
return(true);
}
