/// <summary>
/// Creates an emphasized paragraph
/// </summary>
/// <param name="text">Content of the emphasized paragraph</param>
/// <param name="emphasisType">Type of the emphasis</param>
public MvcHtmlString EmphasizedParagraph(string text, EmphasisType emphasisType)
{
var p = new TagBuilderExt("p");
switch (emphasisType)
{
case EmphasisType.Muted:
p.AddCssClass("muted");
break;
case EmphasisType.Warning:
p.AddCssClass("text-warning");
break;
case EmphasisType.Error:
p.AddCssClass("text-error");
break;
case EmphasisType.Info:
p.AddCssClass("text-info");
break;
case EmphasisType.Success:
p.AddCssClass("text-success");
break;
default:
throw new ArgumentOutOfRangeException("emphasisType");
}
p.SetInnerText(text);
return(p.ToMvcHtmlString());
}
private IClassificationType GetClassificationForType(EmphasisType type)
{
switch (type)
{
case EmphasisType.Bold:
return(_registry.GetClassificationType(FormatDefinitions.Bold.Name));
case EmphasisType.Italic:
return(_registry.GetClassificationType(FormatDefinitions.Italic.Name));
case EmphasisType.Code:
return(_registry.GetClassificationType(FormatDefinitions.Code.Name));
case EmphasisType.Bold | EmphasisType.Italic:
return(_registry.GetClassificationType(FormatDefinitions.BoldItalic.Name));
case EmphasisType.Bold | EmphasisType.Code:
return(_registry.GetClassificationType(FormatDefinitions.BoldCode.Name));
case EmphasisType.Italic | EmphasisType.Code:
return(_registry.GetClassificationType(FormatDefinitions.ItalicCode.Name));
case EmphasisType.Bold | EmphasisType.Italic | EmphasisType.Code:
return(_registry.GetClassificationType(FormatDefinitions.BoldItalicCode.Name));
default:
return(null);
}
}
public void RemoveCharacters(EmphasisType emphasis)
{
int n = emphasis == EmphasisType.Bold ? 2 : 1;
Number -= n;
DelimiterOps.Transform(new Ops().Delete(n));
SetOpenerOrCloser();
}
/// <summary>Initializes a new instance of the <see cref="MarkdownEmphasis"/> class.</summary>
/// <param name="text">The emphasis text.</param>
/// <param name="emphasisType">Type of emphasis.</param>
public MarkdownEmphasis(string text, EmphasisType emphasisType) : this()
{
if (string.IsNullOrEmpty(text))
{
text = string.Empty;
}
MarkdownContentText = text;
Emphasis = emphasisType;
CreateEmphasis();
}
public void ReturnsSingleResultWhenMarkerIsAtEndOfText(string marker, EmphasisType type)
{
IEnumerable <EmphasisSpan> results;
results = Parse($"this is {marker}marked text{marker}");
Assert.Equal(
new[] { new EmphasisSpan {
StartOffset = 8, Length = 13, Type = type
} },
results
);
}
public void ReturnsCompletedSpansWhenThereAreIncompleteSpans(string marker, EmphasisType type)
{
IEnumerable <EmphasisSpan> results;
results = Parse($"this {marker}comment{marker} is {marker}incomplete");
Assert.Equal(
new[] { new EmphasisSpan {
StartOffset = 5, Length = 9, Type = type
} },
results
);
}
public void ReturnsSingleResultWhenMarkerCoversAllText(string marker, EmphasisType type)
{
IEnumerable <EmphasisSpan> results;
results = Parse($"{marker}all covered{marker}");
Assert.Equal(
new[] { new EmphasisSpan {
StartOffset = 0, Length = 13, Type = type
} },
results
);
}
public void DetectsEndMarkerBeforeBrackets(string marker, EmphasisType type, char bracket)
{
IEnumerable <EmphasisSpan> results;
results = Parse($"this is {marker}marked{marker}{bracket} with brackets");
Assert.Equal(
new[] { new EmphasisSpan {
StartOffset = 8, Length = 8, Type = type
} },
results
);
}
public void DetectsEndMarkerBeforePunctuation(string marker, EmphasisType type, char punctuation)
{
IEnumerable <EmphasisSpan> results;
results = Parse($"this is {marker}marked{marker}{punctuation} and has punctuation");
Assert.Equal(
new[] { new EmphasisSpan {
StartOffset = 8, Length = 8, Type = type
} },
results
);
}
private bool CanBeStartMarker(string text, int charIndex, EmphasisType markerType, EmphasisType spanType)
{
// Markers cannot start at the end of the text, so there must
// be a following character, and it cannot be whitespace.
if ((charIndex < (text.Length - 1)) && (!char.IsWhiteSpace(text[charIndex + 1])))
{
char previousChar;
// Markers can start at the start of the text.
if (charIndex == 0)
{
return(true);
}
previousChar = text[charIndex - 1];
// Markers can start after whitespace or an opening bracket.
if (char.IsWhiteSpace(text[charIndex - 1]) || OpeningBrackets.Contains(previousChar))
{
return(true);
}
// Or markers can start after another start marker.
if (Markers.TryGetValue(previousChar, out EmphasisType previousType))
{
// The previous character would be a start marker if
// it's a different type to this marker, and that
// previous marker type is in the current span type.
if (previousType != markerType)
{
if ((spanType & previousType) == previousType)
{
return(true);
}
}
}
}
return(false);
}
private void RemoveEmphasisFromLastSpans(EmphasisType type, int unclosedMarkerStartIndex, List <EmphasisSpan> spans)
{
for (int i = spans.Count - 1; i >= 0; i--)
{
EmphasisSpan temp;
// We can stop when we reach a span that ended before the unclosed
// marker started because it won't be affected by the unclosed marker.
if ((spans[i].StartOffset + spans[i].Length) < unclosedMarkerStartIndex)
{
break;
}
// This span included the unclosed marker, so
// we need to remove the type from this span.
temp = spans[i];
temp.Type &= (~type);
spans[i] = temp;
}
}
private bool CanBeEndMarker(string text, int charIndex, EmphasisType markerType, EmphasisType spanType)
{
// Markers can only end after a non-whitespace character.
if ((charIndex > 0) && (!char.IsWhiteSpace(text[charIndex - 1])))
{
char nextChar;
// Markers can end at the end of the text.
if (charIndex == (text.Length - 1))
{
return(true);
}
nextChar = text[charIndex + 1];
// Markers can end before whitespace, punctuation, or a closing bracket.
if (char.IsWhiteSpace(nextChar) || char.IsPunctuation(nextChar) || ClosingBrackets.Contains(nextChar))
{
return(true);
}
// Or a marker can end before another end marker.
if (Markers.TryGetValue(nextChar, out EmphasisType nextType))
{
// The next character will be an end marker if
// it's a different type to this marker, and that
// next marker type is in the current span type.
if (nextType != markerType)
{
if ((spanType & nextType) == nextType)
{
return(true);
}
}
}
}
return(false);
}
/// <summary>Creates the emphasis using the specified text.</summary>
/// <param name="text">The text.</param>
/// <param name="emphasis">The emphasis type to use.</param>
/// <returns>The <see cref="string"/>.</returns>
public static string CreateEmphasis(string text, EmphasisType emphasis)
{
if (string.IsNullOrEmpty(text))
{
text = string.Empty;
}
// Sets the emphasis.
string outputText;
switch (emphasis)
{
case EmphasisType.Bold:
{
outputText = Bold + text + Bold;
break;
}
case EmphasisType.Italic:
{
outputText = Italic + text + Italic;
break;
}
case EmphasisType.Strikethrough:
{
outputText = Strikethrough + text + Strikethrough;
break;
}
default:
{
throw new ArgumentOutOfRangeException(nameof(emphasis), emphasis, null);
}
}
return(outputText);
}
public void ReturnsMultipleResultsWhenTextContainsMultipleMarkedSpans(string marker, EmphasisType type)
{
IEnumerable <EmphasisSpan> results;
results = Parse($"this {marker}is{marker} marked {marker}and{marker} so is this");
Assert.Equal(
new[] {
new EmphasisSpan {
StartOffset = 5, Length = 4, Type = type
},
new EmphasisSpan {
StartOffset = 17, Length = 5, Type = type
}
},
results
);
}
