13 changed files with 1674 additions and 267 deletions
@ -0,0 +1,404 @@
|
||||
/** |
||||
* Object that is created from *formatted string* (or `Text`) and stores |
||||
* information about formatting used in said string. Was introduced instead of |
||||
* a simple method in `MutableText` to: |
||||
* 1. Allow for reporting errors caused by badly specified colors; |
||||
* 2. Allow for a more complicated case of specifying a color gradient |
||||
* range. |
||||
* Copyright 2022 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class FormattedStringData extends AcediaObject |
||||
dependson(Text) |
||||
dependson(FormattingErrors) |
||||
dependson(FormattingCommandList); |
||||
|
||||
struct FormattingInfo |
||||
{ |
||||
var bool colored; |
||||
var Color plainColor; |
||||
var bool gradient; |
||||
var array<Color> gradientColors; |
||||
var array<float> gradientPoints; |
||||
var int gradientStart; |
||||
var float gradientLength; |
||||
}; |
||||
// Formatted `string` can have an arbitrary level of folded format definitions, |
||||
// this array is used as a stack to keep track of opened formatting blocks |
||||
// when appending formatted `string`. |
||||
var array<FormattingInfo> formattingStack; |
||||
// Keep top element copied into a separate variable for quicker access. |
||||
// Must maintain invariant: if `formattingStack.length > 0` |
||||
// then `formattingStack[formattingStack.length - 1] == formattingStackHead`. |
||||
var FormattingInfo formattingStackHead; |
||||
|
||||
var private FormattingCommandList commands; |
||||
var private MutableText result; |
||||
var private FormattingErrors errors; |
||||
|
||||
protected function Finalizer() |
||||
{ |
||||
formattingStack.length = 0; |
||||
_.memory.Free(commands); |
||||
_.memory.Free(errors); |
||||
_.memory.Free(result); |
||||
commands = none; |
||||
errors = none; |
||||
result = none; |
||||
} |
||||
|
||||
public static final function FormattedStringData FromText( |
||||
Text source, |
||||
optional bool doReportErrors) |
||||
{ |
||||
local FormattedStringData newData; |
||||
if (source == none) { |
||||
return none; |
||||
} |
||||
newData = |
||||
FormattedStringData(__().memory.Allocate(class'FormattedStringData')); |
||||
if (doReportErrors) |
||||
{ |
||||
newData.errors = |
||||
FormattingErrors(__().memory.Allocate(class'FormattingErrors')); |
||||
} |
||||
newData.commands = class'FormattingCommandList'.static |
||||
.FromText(source, newData.errors); |
||||
newData.result = __().text.Empty(); |
||||
newData.BuildSelf(); |
||||
__().memory.Free(newData.commands); |
||||
newData.commands = none; |
||||
return newData; |
||||
} |
||||
|
||||
public final function Text GetResult() |
||||
{ |
||||
return result.Copy(); |
||||
} |
||||
|
||||
public final function MutableText GetResultM() |
||||
{ |
||||
return result.MutableCopy(); |
||||
} |
||||
|
||||
public final function FormattingErrors BorrowErrors() |
||||
{ |
||||
return errors; |
||||
} |
||||
|
||||
private final function BuildSelf() |
||||
{ |
||||
local int i, j, nextCharacterIndex; |
||||
local Text.Formatting defaultFormatting; |
||||
local array<Text.Character> nextContents; |
||||
local FormattingCommandList.FormattingCommand nextCommand; |
||||
SetupFormattingStack(defaultFormatting); |
||||
// First element of color stack is special and has no color information; |
||||
// see `BuildFormattingStackCommands()` for details. |
||||
nextCommand = commands.GetCommand(0); |
||||
nextContents = nextCommand.contents; |
||||
result.AppendManyRawCharacters(nextContents); |
||||
nextCharacterIndex = nextContents.length; |
||||
_.memory.Free(nextCommand.tag); |
||||
for (i = 1; i < commands.GetAmount(); i += 1) |
||||
{ |
||||
nextCommand = commands.GetCommand(i); |
||||
if (nextCommand.type == FST_StackPush) { |
||||
PushIntoFormattingStack(nextCommand); |
||||
} |
||||
else if (nextCommand.type == FST_StackPop) { |
||||
PopFormattingStack(); |
||||
} |
||||
else if (nextCommand.type == FST_StackSwap) { |
||||
SwapFormattingStack(nextCommand.charTag); |
||||
} |
||||
nextContents = nextCommand.contents; |
||||
if (IsCurrentFormattingGradient()) |
||||
{ |
||||
for (j = 0; j < nextContents.length; j += 1) |
||||
{ |
||||
result.AppendRawCharacter(nextContents[j], GetFormattingFor(nextCharacterIndex)); |
||||
nextCharacterIndex += 1; |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
result.AppendManyRawCharacters(nextContents, GetFormattingFor(nextCharacterIndex)); |
||||
nextCharacterIndex += nextContents.length; |
||||
} |
||||
_.memory.Free(nextCommand.tag); |
||||
} |
||||
} |
||||
|
||||
// Following four functions are to maintain a "color stack" that will |
||||
// remember unclosed colors (new colors are obtained from formatting commands |
||||
// sequence) defined in formatted string, in order. |
||||
// Stack array always contains one element, defined by |
||||
// the `SetupFormattingStack()` call. It corresponds to the default formatting |
||||
// that will be used when we pop all the other elements. |
||||
// It is necessary to deal with possible folded formatting definitions in |
||||
// formatted strings. |
||||
private final function SetupFormattingStack(Text.Formatting defaultFormatting) |
||||
{ |
||||
local FormattingInfo defaultFormattingInfo; |
||||
defaultFormattingInfo.colored = defaultFormatting.isColored; |
||||
defaultFormattingInfo.plainColor = defaultFormatting.color; |
||||
if (formattingStack.length > 0) { |
||||
formattingStack.length = 0; |
||||
} |
||||
formattingStack[0] = defaultFormattingInfo; |
||||
formattingStackHead = defaultFormattingInfo; |
||||
} |
||||
|
||||
private final function bool IsCurrentFormattingGradient() |
||||
{ |
||||
if (formattingStack.length <= 0) { |
||||
return false; |
||||
} |
||||
return formattingStackHead.gradient; |
||||
} |
||||
|
||||
private final function Text.Formatting GetFormattingFor(int index) |
||||
{ |
||||
local Text.Formatting emptyFormatting; |
||||
if (formattingStack.length <= 0) return emptyFormatting; |
||||
if (!formattingStackHead.colored) return emptyFormatting; |
||||
|
||||
return _.text.FormattingFromColor(GetColorFor(index)); |
||||
} |
||||
//FormattedStringData Package.FormattedStringData (Function AcediaCore.FormattedStringData.GetColorFor:00FC) Accessed array 'gradientColors' out of bounds (2/2) |
||||
private final function Color GetColorFor(int index) |
||||
{ |
||||
local int i; |
||||
local float indexPosition, leftPosition, rightPosition; |
||||
local array<float> points; |
||||
local Color leftColor, rightColor, resultColor; |
||||
if (formattingStack.length <= 0) { |
||||
return resultColor; |
||||
} |
||||
if (!formattingStackHead.gradient) { |
||||
return formattingStackHead.plainColor; |
||||
} |
||||
indexPosition = float(index - formattingStackHead.gradientStart) / |
||||
formattingStackHead.gradientLength; |
||||
points = formattingStackHead.gradientPoints; |
||||
for (i = 1; i < points.length; i += 1) |
||||
{ |
||||
if (points[i - 1] <= indexPosition && indexPosition <= points[i]) |
||||
{ |
||||
leftPosition = points[i - 1]; |
||||
rightPosition = points[i]; |
||||
leftColor = formattingStackHead.gradientColors[i - 1]; |
||||
rightColor = formattingStackHead.gradientColors[i]; |
||||
break; |
||||
} |
||||
} |
||||
indexPosition = |
||||
(indexPosition - leftPosition) / (rightPosition - leftPosition); |
||||
resultColor.R = Lerp(indexPosition, leftColor.R, rightColor.R); |
||||
resultColor.G = Lerp(indexPosition, leftColor.G, rightColor.G); |
||||
resultColor.B = Lerp(indexPosition, leftColor.B, rightColor.B); |
||||
resultColor.A = Lerp(indexPosition, leftColor.A, rightColor.A); |
||||
return resultColor; |
||||
} |
||||
|
||||
private final function PushIntoFormattingStack( |
||||
FormattingCommandList.FormattingCommand formattingCommand) |
||||
{ |
||||
formattingStackHead = ParseFormattingInfo(formattingCommand.tag); |
||||
formattingStackHead.gradientStart = formattingCommand.openIndex; |
||||
formattingStackHead.gradientLength = |
||||
float(formattingCommand.closeIndex - formattingCommand.openIndex); |
||||
formattingStack[formattingStack.length] = formattingStackHead; |
||||
} |
||||
|
||||
private final function SwapFormattingStack(Text.Character tagCharacter) |
||||
{ |
||||
local FormattingInfo updatedFormatting; |
||||
if (formattingStack.length > 0) { |
||||
updatedFormatting = formattingStackHead; |
||||
} |
||||
if (_.color.ResolveShortTagColor(tagCharacter, updatedFormatting.plainColor)) |
||||
{ |
||||
updatedFormatting.colored = true; |
||||
updatedFormatting.gradient = false; |
||||
} |
||||
else { |
||||
Report(FSE_BadShortColorTag, _.text.FromString("^" $ Chr(tagCharacter.codePoint))); |
||||
} |
||||
formattingStackHead = updatedFormatting; |
||||
if (formattingStack.length > 0) { |
||||
formattingStack[formattingStack.length - 1] = updatedFormatting; |
||||
} |
||||
else { |
||||
formattingStack[0] = updatedFormatting; |
||||
} |
||||
} |
||||
|
||||
private final function PopFormattingStack() |
||||
{ |
||||
// Remove the top of the stack |
||||
if (formattingStack.length > 0) { |
||||
formattingStack.length = formattingStack.length - 1; |
||||
} |
||||
// Update the stack head copy |
||||
if (formattingStack.length > 0) { |
||||
formattingStackHead = formattingStack[formattingStack.length - 1]; |
||||
} |
||||
} |
||||
|
||||
private final function FormattingInfo ParseFormattingInfo(Text colorTag) |
||||
{ |
||||
local int i; |
||||
local Parser colorParser; |
||||
local Color nextColor; |
||||
local array<MutableText> specifiedColors; |
||||
local Text.Character tildeCharacter; |
||||
local array<Color> gradientColors; |
||||
local array<float> gradientPoints; |
||||
local FormattingInfo resultInfo; |
||||
if (colorTag.IsEmpty()) |
||||
{ |
||||
Report(FSE_EmptyColorTag); |
||||
return resultInfo; // not colored |
||||
} |
||||
tildeCharacter = _.text.GetCharacter("~"); |
||||
specifiedColors = colorTag.SplitByCharacter(tildeCharacter, true); |
||||
for (i = 0; i < specifiedColors.length; i += 1) |
||||
{ |
||||
colorParser = _.text.Parse(specifiedColors[i]); |
||||
if (_.color.ParseWith(colorParser, nextColor)) |
||||
{ |
||||
colorParser.Confirm(); |
||||
gradientColors[gradientColors.length] = nextColor; |
||||
gradientPoints[gradientPoints.length] = ParsePoint(colorParser); |
||||
} |
||||
else { |
||||
Report(FSE_BadColor, specifiedColors[i]); |
||||
} |
||||
_.memory.Free(colorParser); |
||||
} |
||||
_.memory.FreeMany(specifiedColors); |
||||
gradientPoints = NormalizePoints(gradientPoints); |
||||
resultInfo.colored = (gradientColors.length > 0); |
||||
resultInfo.gradient = (gradientColors.length > 1); |
||||
resultInfo.gradientColors = gradientColors; |
||||
resultInfo.gradientPoints = gradientPoints; |
||||
if (gradientColors.length > 0) { |
||||
resultInfo.plainColor = gradientColors[0]; |
||||
} |
||||
return resultInfo; |
||||
} |
||||
|
||||
private final function float ParsePoint(Parser parser) |
||||
{ |
||||
local float point; |
||||
local Parser.ParserState initialState; |
||||
if (!parser.Ok() || parser.HasFinished()) { |
||||
return -1; |
||||
} |
||||
initialState = parser.GetCurrentState(); |
||||
// [Necessary part] Should starts with "[" |
||||
if (!parser.Match(P("[")).Ok()) |
||||
{ |
||||
Report(FSE_BadGradientPoint, parser.RestoreState(initialState).GetRemainder()); |
||||
return -1; |
||||
} |
||||
// [Necessary part] Try parsing number |
||||
parser.MNumber(point).Confirm(); |
||||
if (!parser.Ok()) |
||||
{ |
||||
Report(FSE_BadGradientPoint, parser.RestoreState(initialState).GetRemainder()); |
||||
return -1; |
||||
} |
||||
// [Optional part] Check if number is a percentage |
||||
if (parser.Match(P("%")).Ok()) { |
||||
point *= 0.01; |
||||
} |
||||
// This either confirms state of parsing "%" (on success) |
||||
// or reverts to the previous state, just after parsing the number |
||||
// (on failure) |
||||
parser.Confirm(); |
||||
parser.R(); |
||||
// [Necessary part] Have to have closing parenthesis |
||||
if (!parser.HasFinished()) { |
||||
parser.Match(P("]")).Confirm(); |
||||
} |
||||
// Still return `point`, even if there was no closing parenthesis, |
||||
// since that is likely what user wants |
||||
if (!parser.Ok()) { |
||||
Report(FSE_BadGradientPoint, parser.RestoreState(initialState).GetRemainder()); |
||||
} |
||||
return point; |
||||
} |
||||
/*FIRST-POPOPOINTS 0.00 -1.00 -1.00 -1.00 1.00 5 |
||||
PRE-POPOPOINTS 0.00 -1.00 0.00 -1.00 1.00 5 */ |
||||
private final function array<float> NormalizePoints(array<float> points) |
||||
{ |
||||
local int i, j; |
||||
local int negativeSegmentStart, negativeSegmentLength; |
||||
local float lowerBound, upperBound; |
||||
local bool foundNegative; |
||||
if (points.length > 1) |
||||
{ |
||||
points[0] = 0.0; |
||||
points[points.length - 1] = 1.0; |
||||
} |
||||
for (i = 1; i < points.length - 1; i += 1) |
||||
{ |
||||
if (points[i] <= 0 || points[i] > 1 || points[i] <= points[i - 1]) { |
||||
points[i] = -1; |
||||
} |
||||
} |
||||
for (i = 1; i < points.length; i += 1) |
||||
{ |
||||
if (foundNegative && points[i] > 0) |
||||
{ |
||||
upperBound = points[i]; |
||||
for (j = negativeSegmentStart; j < i; j += 1) |
||||
{ |
||||
points[j] = Lerp( float(j - negativeSegmentStart + 1) / float(negativeSegmentLength + 1), |
||||
lowerBound, upperBound); |
||||
} |
||||
negativeSegmentLength = 0; |
||||
} |
||||
if (!foundNegative && points[i] < 0) |
||||
{ |
||||
lowerBound = points[i - 1]; |
||||
negativeSegmentStart = i; |
||||
} |
||||
foundNegative = (points[i] < 0); |
||||
if (foundNegative) { |
||||
negativeSegmentLength += 1; |
||||
} |
||||
} |
||||
return points; |
||||
} |
||||
|
||||
public final function Report( |
||||
FormattingErrors.FormattedDataErrorType type, |
||||
optional Text cause) |
||||
{ |
||||
if (errors == none) { |
||||
return; |
||||
} |
||||
errors.Report(type, cause); |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
} |
||||
@ -0,0 +1,296 @@
|
||||
/** |
||||
* Formatted string can be thought of as a string with a sequence of |
||||
* formatting-changing commands specified within it (either by opening new |
||||
* formatting block, swapping to color with "^" or by closing it and reverting |
||||
* to the previous one). |
||||
* This objects allows to directly access these commands. |
||||
* Copyright 2022 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class FormattingCommandList extends AcediaObject |
||||
dependson(Text); |
||||
|
||||
enum FormattingCommandType |
||||
{ |
||||
// Push more data onto formatted stack |
||||
FST_StackPush, |
||||
// Pop data from formatted stack |
||||
FST_StackPop, |
||||
// Swap the top value on the formatting stack |
||||
FST_StackSwap |
||||
}; |
||||
|
||||
// Formatted `string` is separated into several (possibly nested) parts, |
||||
// each with its own formatting. These can be easily handled with a formatting |
||||
// stack: |
||||
// * Each time a new section opens ("{<color_tag> ") we put another, |
||||
// current formatting on top of the stack; |
||||
// * Each time a section closes ("}") we pop the stack, returning to |
||||
// a previous formatting. |
||||
// * In a special case of "^" color swap that is supposed to last until |
||||
// current block closes we simply swap the color of the formatting on |
||||
// top of the stack. |
||||
struct FormattingCommand |
||||
{ |
||||
// Only defined for `FST_StackPush` commands that correspond to section |
||||
// openers ("{<color_tag> "). |
||||
// Indices of first and last character belonging to block it opens. |
||||
var int openIndex; |
||||
var int closeIndex; |
||||
// Did this block start by opening or closing formatted part? |
||||
// Ignored for the very first block without any formatting. |
||||
var FormattingCommandType type; |
||||
// Full text inside the block, without any formatting |
||||
var array<Text.Character> contents; |
||||
// Formatting tag for the next block |
||||
// (only used for `FST_StackPush` command type) |
||||
var MutableText tag; |
||||
// Formatting character for the "^"-type tag |
||||
// (only used for `FST_StackSwap` command type) |
||||
var Text.Character charTag; |
||||
}; |
||||
// Appending formatted `string` into the `MutableText` first requires its |
||||
// transformation into series of `FormattingCommand` and then their |
||||
// execution to assemble the `MutableText`. |
||||
// First element of `commandList` is special and is used solely as |
||||
// a container for unformatted data. It should not be used to execute |
||||
// formatting stack commands. |
||||
// This variable contains intermediary data. |
||||
var private array<FormattingCommand> commandList; |
||||
|
||||
// Stack that keeps track of which (by index inside `commandList`) command |
||||
// opened section we are currently parsing. This is needed to record positions |
||||
// at which each block is opened and closed. |
||||
var private array<int> pushCommandIndicesStack; |
||||
// Store contents for the next command here, because appending array in |
||||
// the struct is expensive |
||||
var private array<Text.Character> currentContents; |
||||
// `Parser` used to break input formatted string into commands, only used |
||||
// during building this object (inside `BuildSelf()` method). |
||||
var private Parser parser; |
||||
// `FormattingErrors` object used to reports errors during building process. |
||||
// It is "borrowed" - meaning that we do not really own it and should not |
||||
// deallocate it. Only set as a field for convenience. |
||||
var private FormattingErrors borrowedErrors; |
||||
|
||||
const CODEPOINT_ESCAPE = 27; // ASCII escape code |
||||
const CODEPOINT_OPEN_FORMAT = 123; // '{' |
||||
const CODEPOINT_CLOSE_FORMAT = 125; // '}' |
||||
const CODEPOINT_FORMAT_ESCAPE = 38; // '&' |
||||
const CODEPOINT_ACCENT = 94; // '^' |
||||
const CODEPOINT_TILDE = 126; // '~' |
||||
|
||||
protected function Finalizer() |
||||
{ |
||||
local int i; |
||||
_.memory.Free(parser); |
||||
parser = none; |
||||
borrowedErrors = none; |
||||
if (currentContents.length > 0) { |
||||
currentContents.length = 0; |
||||
} |
||||
if (pushCommandIndicesStack.length > 0) { |
||||
pushCommandIndicesStack.length = 0; |
||||
} |
||||
for (i = 0; i < commandList.length; i += 1) { |
||||
_.memory.Free(commandList[i].tag); |
||||
} |
||||
if (commandList.length > 0) { |
||||
commandList.length = 0; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Create `FormattingCommandList` based on given `Text`. |
||||
* |
||||
* @param input `Text` that should be treated as "formatted" and |
||||
* to be broken into formatting commands. |
||||
* @param errorsReporter If specified, will be used to report errors |
||||
* (can only report `FSE_UnmatchedClosingBrackets`). |
||||
* @return New `FormattingCommandList` instance that allows us to have direct |
||||
* access to formatting commands. |
||||
*/ |
||||
public final static function FormattingCommandList FromText( |
||||
Text input, |
||||
optional FormattingErrors errorsReporter) |
||||
{ |
||||
local FormattingCommandList newList; |
||||
newList = FormattingCommandList( |
||||
__().memory.Allocate(class'FormattingCommandList')); |
||||
newList.parser = __().text.Parse(input); |
||||
newList.borrowedErrors = errorsReporter; |
||||
newList.BuildSelf(); |
||||
__().memory.Free(newList.parser); |
||||
newList.parser = none; |
||||
newList.borrowedErrors = none; |
||||
return newList; |
||||
} |
||||
|
||||
/** |
||||
* Returns command with index `commandIndex`. |
||||
* |
||||
* @param commandIndex Index of the command to return. |
||||
* Must be non-negative (`>= 0`) and less than `GetAmount()`. |
||||
* @return Command with index `commandIndex`. |
||||
* If given `commandIndex` is out of bounds - returns invalid command. |
||||
* `tag` field is guaranteed to be non-`none` and should be deallocated. |
||||
*/ |
||||
public final function FormattingCommand GetCommand(int commandIndex) |
||||
{ |
||||
local MutableText resultTag; |
||||
local FormattingCommand result; |
||||
if (commandIndex < 0) return result; |
||||
if (commandIndex >= commandList.length) return result; |
||||
|
||||
result = commandList[commandIndex]; |
||||
resultTag = result.tag; |
||||
if (resultTag != none) { |
||||
result.tag = resultTag.MutableCopy(); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
/** |
||||
* Returns amount of commands inside caller `FormattingCommandList`. |
||||
* |
||||
* @return Amount of commands inside caller `FormattingCommandList`. |
||||
*/ |
||||
public final function int GetAmount() |
||||
{ |
||||
return commandList.length; |
||||
} |
||||
|
||||
// Method that turns `parser` into proper `FormattingCommandList` object. |
||||
private final function BuildSelf() |
||||
{ |
||||
//local int i; |
||||
local int characterCounter; |
||||
local Text.Character nextCharacter; |
||||
local FormattingCommand nextCommand; |
||||
while (!parser.HasFinished()) |
||||
{ |
||||
parser.MCharacter(nextCharacter); |
||||
// New command by "{<formatting_info>" |
||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_OPEN_FORMAT)) |
||||
{ |
||||
nextCommand = AddCommand(nextCommand, FST_StackPush, characterCounter); |
||||
parser.MUntil(nextCommand.tag,, true) |
||||
.MCharacter(nextCommand.charTag); // Simply to skip a char |
||||
continue; |
||||
} |
||||
// New command by "}" |
||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_CLOSE_FORMAT)) |
||||
{ |
||||
nextCommand = AddCommand(nextCommand, FST_StackPop, characterCounter); |
||||
continue; |
||||
} |
||||
// New command by "^" |
||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_ACCENT)) |
||||
{ |
||||
nextCommand = AddCommand(nextCommand, FST_StackSwap, characterCounter); |
||||
parser.MCharacter(nextCommand.charTag); |
||||
if (!parser.Ok()) { |
||||
break; |
||||
} |
||||
continue; |
||||
} |
||||
// Escaped sequence |
||||
if (_.text.IsCodePoint(nextCharacter, CODEPOINT_FORMAT_ESCAPE)) { |
||||
parser.MCharacter(nextCharacter); |
||||
} |
||||
if (!parser.Ok()) { |
||||
break; |
||||
} |
||||
currentContents[currentContents.length] = nextCharacter; |
||||
characterCounter += 1; |
||||
} |
||||
// Only put in empty command if there is nothing else. |
||||
if (currentContents.length > 0 || commandList.length == 0) |
||||
{ |
||||
nextCommand.contents = currentContents; |
||||
commandList[commandList.length] = nextCommand; |
||||
} |
||||
/*for (i = 0; i < commandList.length; i += 1) |
||||
{ |
||||
Log(">>>COMMAND LIST FOR" @ i $ "<<<"); |
||||
Log("OPEN/CLOSE:" @ commandList[i].openIndex @ "/" @ commandList[i].closeIndex); |
||||
Log("TYPE:" @ commandList[i].type); |
||||
Log("CONTETS LENGTH:" @ commandList[i].contents.length); |
||||
if (commandList[i].tag != none) { |
||||
Log("TAG:" @ commandList[i].tag.ToString()); |
||||
} |
||||
else { |
||||
Log("TAG: NONE"); |
||||
} |
||||
}*/ |
||||
} |
||||
|
||||
// Helper method for a quick creation of a new `FormattingCommand` |
||||
private final function FormattingCommand AddCommand( |
||||
FormattingCommand nextCommand, |
||||
FormattingCommandType newStackCommandType, |
||||
optional int currentCharacterIndex) |
||||
{ |
||||
local int lastPushIndex; |
||||
local FormattingCommand newCommand; |
||||
nextCommand.contents = currentContents; |
||||
if (currentContents.length > 0) { |
||||
currentContents.length = 0; |
||||
} |
||||
commandList[commandList.length] = nextCommand; |
||||
if (newStackCommandType == FST_StackPop) |
||||
{ |
||||
lastPushIndex = PopIndex(); |
||||
if (lastPushIndex >= 0) { |
||||
// BLABLA |
||||
commandList[lastPushIndex].closeIndex = currentCharacterIndex - 1; |
||||
} |
||||
else if (borrowedErrors != none) { |
||||
borrowedErrors.Report(FSE_UnmatchedClosingBrackets); |
||||
} |
||||
} |
||||
newCommand.type = newStackCommandType; |
||||
if (newStackCommandType == FST_StackPush) |
||||
{ |
||||
newCommand.openIndex = currentCharacterIndex; |
||||
newCommand.closeIndex = -1; |
||||
// BLABLA |
||||
PushIndex(commandList.length); |
||||
} |
||||
return newCommand; |
||||
} |
||||
|
||||
private final function PushIndex(int index) |
||||
{ |
||||
pushCommandIndicesStack[pushCommandIndicesStack.length] = |
||||
commandList.length; |
||||
} |
||||
|
||||
private final function int PopIndex() |
||||
{ |
||||
local int result; |
||||
if (pushCommandIndicesStack.length <= 0) { |
||||
return -1; |
||||
} |
||||
result = pushCommandIndicesStack[pushCommandIndicesStack.length - 1]; |
||||
pushCommandIndicesStack.length = pushCommandIndicesStack.length - 1; |
||||
return result; |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
} |
||||
@ -0,0 +1,179 @@
|
||||
/** |
||||
* Simple aggregator object for errors that may arise during parsing of |
||||
* formatted string. |
||||
* Copyright 2022 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class FormattingErrors extends AcediaObject; |
||||
|
||||
/** |
||||
* Errors that can occur during parsing of the formatted string. |
||||
*/ |
||||
enum FormattedDataErrorType |
||||
{ |
||||
// There was an unmatched closing figure bracket, e.g. |
||||
// "{$red Hey} you, there}!" |
||||
FSE_UnmatchedClosingBrackets, |
||||
// Color tag was empty, e.g. "Why not { just kill them}?" |
||||
FSE_EmptyColorTag, |
||||
// Color tag cannot be parsed as a color or color gradient, |
||||
// e.g. "Why not {just kill them}?" |
||||
FSE_BadColor, |
||||
// Gradient color tag contained bad point specified, e.g. |
||||
// "That is SO {$red~$orange(what?)~$red AMAZING}!!!" or |
||||
// "That is SO {$red~$orange(0.76~$red AMAZING}!!!" |
||||
FSE_BadGradientPoint, |
||||
FSE_BadShortColorTag |
||||
}; |
||||
|
||||
// `FSE_UnmatchedClosingBrackets` and `FSE_EmptyColorTag` errors never have any |
||||
// `Text` hint associated with them, so simply store how many times they were |
||||
// invoked. |
||||
var private int unmatchedClosingBracketsErrorCount; |
||||
var private int emptyColorTagErrorCount; |
||||
// `FSE_BadColor` and `FSE_BadGradientPoint` are always expected to have |
||||
// a `Text` hint reported alongside them, so simply store that hint. |
||||
var private array<Text> badColorTagErrorHints; |
||||
var private array<Text> badGradientTagErrorHints; |
||||
var private array<Text> badShortColorTagErrorHints; |
||||
|
||||
// We will report accumulated errors as an array of these structs. |
||||
struct FormattedDataError |
||||
{ |
||||
// Type of the error |
||||
var FormattedDataErrorType type; |
||||
// How many times had this error happened? |
||||
// Can be specified for `FSE_UnmatchedClosingBrackets` and |
||||
// `FSE_EmptyColorTag` error types. Never negative. |
||||
var int count; |
||||
// `Text` hint that should help user understand where the error is |
||||
// coming from. |
||||
// Can be specified for `FSE_BadColor` and `FSE_BadGradientPoint` |
||||
// error types. |
||||
var Text cause; |
||||
}; |
||||
|
||||
protected function Finalizer() |
||||
{ |
||||
unmatchedClosingBracketsErrorCount = 0; |
||||
emptyColorTagErrorCount = 0; |
||||
_.memory.FreeMany(badColorTagErrorHints); |
||||
_.memory.FreeMany(badShortColorTagErrorHints); |
||||
_.memory.FreeMany(badGradientTagErrorHints); |
||||
badColorTagErrorHints.length = 0; |
||||
badShortColorTagErrorHints.length = 0; |
||||
badGradientTagErrorHints.length = 0; |
||||
} |
||||
|
||||
/** |
||||
* Adds new error to the caller `FormattingErrors` object. |
||||
* |
||||
* @param type Type of the new error. |
||||
* @param cause Auxiliary `Text` that might give user additional hint about |
||||
* what exactly went wrong. |
||||
* If this parameter is `none` for errors `FSE_BadColor` or |
||||
* `FSE_BadGradientPoint` - method will do nothing. |
||||
*/ |
||||
public final function Report(FormattedDataErrorType type, optional Text cause) |
||||
{ |
||||
switch (type) |
||||
{ |
||||
case FSE_UnmatchedClosingBrackets: |
||||
unmatchedClosingBracketsErrorCount += 1; |
||||
break; |
||||
case FSE_EmptyColorTag: |
||||
emptyColorTagErrorCount += 1; |
||||
break; |
||||
case FSE_BadColor: |
||||
if (cause != none) { |
||||
badColorTagErrorHints[badColorTagErrorHints.length] = cause.Copy(); |
||||
} |
||||
break; |
||||
case FSE_BadShortColorTag: |
||||
if (cause != none) |
||||
{ |
||||
badShortColorTagErrorHints[badShortColorTagErrorHints.length] = |
||||
cause.Copy(); |
||||
} |
||||
break; |
||||
case FSE_BadGradientPoint: |
||||
if (cause != none) |
||||
{ |
||||
badGradientTagErrorHints[badGradientTagErrorHints.length] = |
||||
cause.Copy(); |
||||
} |
||||
break; |
||||
} |
||||
} |
||||
|
||||
/** |
||||
* Returns array of errors collected so far. |
||||
* |
||||
* @return Array of errors collected so far. |
||||
* Each `FormattedDataError` in array has either non-`none` `cause` field |
||||
* or strictly positive `count > 0` field (but not both). |
||||
* `count` field is always guaranteed to not be negative. |
||||
* WARNING: `FormattedDataError` struct may contain `Text` objects that |
||||
* should be deallocated. |
||||
*/ |
||||
public final function array<FormattedDataError> GetErrors() |
||||
{ |
||||
local int i; |
||||
local FormattedDataError newError; |
||||
local array<FormattedDataError> errors; |
||||
// We overwrite old `cause` in `newError` with new one each time we |
||||
// add new error, so it should be fine to not set it to `none` after |
||||
// "moving it" into `errors`. |
||||
newError.type = FSE_BadColor; |
||||
for (i = 0; i < badColorTagErrorHints.length; i += 1) |
||||
{ |
||||
newError.cause = badColorTagErrorHints[i].Copy(); |
||||
errors[errors.length] = newError; |
||||
} |
||||
newError.type = FSE_BadShortColorTag; |
||||
for (i = 0; i < badShortColorTagErrorHints.length; i += 1) |
||||
{ |
||||
newError.cause = badShortColorTagErrorHints[i].Copy(); |
||||
errors[errors.length] = newError; |
||||
} |
||||
newError.type = FSE_BadGradientPoint; |
||||
for (i = 0; i < badGradientTagErrorHints.length; i += 1) |
||||
{ |
||||
newError.cause = badGradientTagErrorHints[i].Copy(); |
||||
errors[errors.length] = newError; |
||||
} |
||||
// Need to reset `cause` here, to avoid duplicating it in |
||||
// following two errors |
||||
newError.cause = none; |
||||
if (unmatchedClosingBracketsErrorCount > 0) |
||||
{ |
||||
newError.type = FSE_UnmatchedClosingBrackets; |
||||
newError.count = unmatchedClosingBracketsErrorCount; |
||||
errors[errors.length] = newError; |
||||
} |
||||
if (emptyColorTagErrorCount > 0) |
||||
{ |
||||
newError.type = FSE_EmptyColorTag; |
||||
newError.count = emptyColorTagErrorCount; |
||||
errors[errors.length] = newError; |
||||
} |
||||
return errors; |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
} |
||||
@ -0,0 +1,565 @@
|
||||
/** |
||||
* Set of tests for functionality of parsing formatted strings. |
||||
* Copyright 2022 Anton Tarasenko |
||||
*------------------------------------------------------------------------------ |
||||
* This file is part of Acedia. |
||||
* |
||||
* Acedia is free software: you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License as published by |
||||
* the Free Software Foundation, version 3 of the License, or |
||||
* (at your option) any later version. |
||||
* |
||||
* Acedia is distributed in the hope that it will be useful, |
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||||
* GNU General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||
*/ |
||||
class TEST_FormattedStrings extends TestCase |
||||
abstract; |
||||
|
||||
protected static function MutableText GetRGBText( |
||||
optional bool noFormattingReset) |
||||
{ |
||||
local int wordIndex; |
||||
local MutableText result; |
||||
result = __().text.FromStringM("This is red, green and blue!"); |
||||
wordIndex = result.IndexOf(P("red")); |
||||
result.ChangeFormatting(__().text.FormattingFromColor(__().color.red), |
||||
wordIndex, 3); |
||||
wordIndex = result.IndexOf(P("green")); |
||||
result.ChangeFormatting(__().text.FormattingFromColor(__().color.lime), |
||||
wordIndex, 5); |
||||
wordIndex = result.IndexOf(P("blue")); |
||||
result.ChangeFormatting(__().text.FormattingFromColor(__().color.blue), |
||||
wordIndex, 4); |
||||
// also color ", " and " and " parts white, and "!" part blue |
||||
if (noFormattingReset) |
||||
{ |
||||
result.ChangeFormatting(__().text.FormattingFromColor(__().color.blue), |
||||
wordIndex, -1); |
||||
wordIndex = result.IndexOf(P(", ")); |
||||
result.ChangeFormatting(__().text.FormattingFromColor(__().color.white), |
||||
wordIndex, 2); |
||||
wordIndex = result.IndexOf(P(" and ")); |
||||
result.ChangeFormatting(__().text.FormattingFromColor(__().color.white), |
||||
wordIndex, 5); |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
protected static function TESTS() |
||||
{ |
||||
Test_Simple(); |
||||
Test_Gradient(); |
||||
Test_Errors(); |
||||
} |
||||
|
||||
protected static function Test_Errors() |
||||
{ |
||||
Context("Testing error reporting for formatted strings."); |
||||
SubTest_ErrorUnmatchedClosingBrackets(); |
||||
SubTest_ErrorEmptyColorTag(); |
||||
SubTest_ErrorBadColor(); |
||||
SubTest_ErrorBadShortColorTag(); |
||||
SubTest_ErrorBadGradientPoint(); |
||||
SubTest_AllErrors(); |
||||
} |
||||
|
||||
protected static function SubTest_ErrorUnmatchedClosingBrackets() |
||||
{ |
||||
local array<FormattingErrors.FormattedDataError> errors; |
||||
local FormattedStringData data; |
||||
Issue("Unmatched closing brackets are not reported."); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing {$pink pink text}}!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_UnmatchedClosingBrackets); |
||||
TEST_ExpectTrue(errors[0].count == 1); |
||||
TEST_ExpectNone(errors[0].cause); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing regular text!}"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_UnmatchedClosingBrackets); |
||||
TEST_ExpectTrue(errors[0].count == 1); |
||||
TEST_ExpectNone(errors[0].cause); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {rgb(255,0,0) red{rgb(255,255,255) , }}}" |
||||
$ "{rgb(0,255,0) gr}een{rgb(255,255,255) and }}}}{rgb(0,0,255)" |
||||
$ " blue!}}}"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_UnmatchedClosingBrackets); |
||||
TEST_ExpectTrue(errors[0].count == 6); |
||||
TEST_ExpectNone(errors[0].cause); |
||||
} |
||||
|
||||
protected static function SubTest_ErrorEmptyColorTag() |
||||
{ |
||||
local array<FormattingErrors.FormattedDataError> errors; |
||||
local FormattedStringData data; |
||||
Issue("Empty color tags are not reported."); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing { pink text}!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_EmptyColorTag); |
||||
TEST_ExpectTrue(errors[0].count == 1); |
||||
TEST_ExpectNone(errors[0].cause); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing {$red regu{ lar tex}t!}"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_EmptyColorTag); |
||||
TEST_ExpectTrue(errors[0].count == 1); |
||||
TEST_ExpectNone(errors[0].cause); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is { {rgb(255,255,255)~$green , }" |
||||
$ "{#800c37 ^ggre^gen{ and }}}^bblue!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_EmptyColorTag); |
||||
TEST_ExpectTrue(errors[0].count == 2); |
||||
TEST_ExpectNone(errors[0].cause); |
||||
} |
||||
|
||||
protected static function SubTest_ErrorBadColor() |
||||
{ |
||||
local array<FormattingErrors.FormattedDataError> errors; |
||||
local FormattedStringData data; |
||||
Issue("Bad color is not reported."); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing {$cat pink text}!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_BadColor); |
||||
TEST_ExpectTrue(errors[0].cause.ToString() == "$cat"); |
||||
TEST_ExpectTrue(errors[0].count == 0); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing {dog regular} {#wicked text!}"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 2); |
||||
TEST_ExpectTrue(errors[0].type == FSE_BadColor); |
||||
TEST_ExpectTrue(errors[1].type == FSE_BadColor); |
||||
TEST_ExpectTrue(errors[0].cause.ToString() == "dog"); |
||||
TEST_ExpectTrue(errors[1].cause.ToString() == "#wicked"); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {goat red{rgb(255,255,255)~lol~$green , }" |
||||
$ "{#800c37 ^ggre^gen{324sd and }}}^bblue!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 3); |
||||
TEST_ExpectTrue(errors[0].type == FSE_BadColor); |
||||
TEST_ExpectTrue(errors[1].type == FSE_BadColor); |
||||
TEST_ExpectTrue(errors[2].type == FSE_BadColor); |
||||
TEST_ExpectTrue(errors[0].cause.ToString() == "goat"); |
||||
TEST_ExpectTrue(errors[1].cause.ToString() == "lol"); |
||||
TEST_ExpectTrue(errors[2].cause.ToString() == "324sd"); |
||||
} |
||||
|
||||
protected static function SubTest_ErrorBadShortColorTag() |
||||
{ |
||||
local array<FormattingErrors.FormattedDataError> errors; |
||||
local FormattedStringData data; |
||||
Issue("Bad short color tag is not reported."); |
||||
data = class'FormattedStringData'.static.FromText(P("This is ^xred^w, ^ugreen^x and ^zblue!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 4); |
||||
TEST_ExpectTrue(errors[0].type == FSE_BadShortColorTag); |
||||
TEST_ExpectTrue(errors[0].cause.ToString() == "^x"); |
||||
TEST_ExpectTrue(errors[0].count == 0); |
||||
TEST_ExpectTrue(errors[1].type == FSE_BadShortColorTag); |
||||
TEST_ExpectTrue(errors[1].cause.ToString() == "^u"); |
||||
TEST_ExpectTrue(errors[1].count == 0); |
||||
TEST_ExpectTrue(errors[2].type == FSE_BadShortColorTag); |
||||
TEST_ExpectTrue(errors[2].cause.ToString() == "^x"); |
||||
TEST_ExpectTrue(errors[2].count == 0); |
||||
TEST_ExpectTrue(errors[3].type == FSE_BadShortColorTag); |
||||
TEST_ExpectTrue(errors[3].cause.ToString() == "^z"); |
||||
TEST_ExpectTrue(errors[3].count == 0); |
||||
} |
||||
|
||||
protected static function SubTest_ErrorBadGradientPoint() |
||||
{ |
||||
local array<FormattingErrors.FormattedDataError> errors; |
||||
local FormattedStringData data; |
||||
Issue("Bad gradient point is not reported."); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing {$pink[dog] pink text}!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 1); |
||||
TEST_ExpectTrue(errors[0].type == FSE_BadGradientPoint); |
||||
TEST_ExpectTrue(errors[0].cause.ToString() == "[dog]"); |
||||
TEST_ExpectTrue(errors[0].count == 0); |
||||
data = class'FormattedStringData'.static.FromText(P("Testing {45,2,241[bad] regular} {#ffaacd~rgb(2,3,4)45worse] text!}"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 2); |
||||
TEST_ExpectTrue(errors[0].type == FSE_BadGradientPoint); |
||||
TEST_ExpectTrue(errors[1].type == FSE_BadGradientPoint); |
||||
TEST_ExpectTrue(errors[0].cause.ToString() == "[bad]"); |
||||
TEST_ExpectTrue(errors[1].cause.ToString() == "45worse]"); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {$red[45%%] red{rgb(255,255,255)~45,3,128point~$green , }" |
||||
$ "{#800c37 ^ggre^gen{#43fa6b3c and }}}^bblue!"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
TEST_ExpectTrue(errors.length == 3); |
||||
TEST_ExpectTrue(errors[0].type == FSE_BadGradientPoint); |
||||
TEST_ExpectTrue(errors[1].type == FSE_BadGradientPoint); |
||||
TEST_ExpectTrue(errors[2].type == FSE_BadGradientPoint); |
||||
TEST_ExpectTrue(errors[0].cause.ToString() == "[45%%]"); |
||||
TEST_ExpectTrue(errors[1].cause.ToString() == "point"); |
||||
TEST_ExpectTrue(errors[2].cause.ToString() == "3c"); |
||||
} |
||||
|
||||
protected static function SubTest_AllErrors() |
||||
{ |
||||
local int i; |
||||
local bool foundUnmatched, foundEmpty, foundBadColor, foundBadPoint, foundBadShortTag; |
||||
local array<FormattingErrors.FormattedDataError> errors; |
||||
local FormattedStringData data; |
||||
Issue("COMPLEX."); |
||||
data = class'FormattedStringData'.static.FromText(P("This} is {$cat~$green[%7] red{$white , }{ green^z and }}{$blue blue!}}"), true); |
||||
errors = data.BorrowErrors().GetErrors(); |
||||
for (i = 0; i < errors.length; i += 1) |
||||
{ |
||||
if (errors[i].type == FSE_UnmatchedClosingBrackets) |
||||
{ |
||||
foundUnmatched = true; |
||||
TEST_ExpectTrue(errors[i].count == 2); |
||||
} |
||||
if (errors[i].type == FSE_EmptyColorTag) |
||||
{ |
||||
foundEmpty = true; |
||||
TEST_ExpectTrue(errors[i].count == 1); |
||||
} |
||||
if (errors[i].type == FSE_BadColor) |
||||
{ |
||||
foundBadColor = true; |
||||
TEST_ExpectTrue(errors[i].cause.ToString() == "$cat"); |
||||
} |
||||
if (errors[i].type == FSE_BadGradientPoint) |
||||
{ |
||||
foundBadPoint = true; |
||||
TEST_ExpectTrue(errors[i].cause.ToString() == "[%7]"); |
||||
} |
||||
if (errors[i].type == FSE_BadShortColorTag) |
||||
{ |
||||
foundBadShortTag = true; |
||||
TEST_ExpectTrue(errors[i].cause.ToString() == "^z"); |
||||
} |
||||
} |
||||
}//^z, $cat, [%7] |
||||
/* // There was an unmatched closing figure bracket, e.g. |
||||
// "{$red Hey} you, there}!" |
||||
FSE_UnmatchedClosingBrackets, |
||||
// Color tag was empty, e.g. "Why not { just kill them}?" |
||||
FSE_EmptyColorTag, |
||||
// Color tag cannot be parsed as a color or color gradient, |
||||
// e.g. "Why not {just kill them}?" |
||||
FSE_BadColor, |
||||
// Gradient color tag contained bad point specified, e.g. |
||||
// "That is SO {$red~$orange(what?)~$red AMAZING}!!!" or |
||||
// "That is SO {$red~$orange(0.76~$red AMAZING}!!!" |
||||
FSE_BadGradientPoint, |
||||
FSE_BadShortColorTag */ |
||||
protected static function Test_Simple() |
||||
{ |
||||
Context("Testing parsing formatted strings with plain colors."); |
||||
SubTest_SimpleNone(); |
||||
SubTest_SimpleAlias(); |
||||
SubTest_SimpleRGB(); |
||||
SubTest_SimpleHEX(); |
||||
SubTest_SimpleTag(); |
||||
SubTest_SimpleMix(); |
||||
} |
||||
|
||||
protected static function SubTest_SimpleNone() |
||||
{ |
||||
local FormattedStringData data; |
||||
Issue("Empty formatted strings are handled incorrectly."); |
||||
data = class'FormattedStringData'.static.FromText(P("")); |
||||
TEST_ExpectNotNone(data.GetResult()); |
||||
TEST_ExpectTrue(data.GetResult().IsEmpty()); |
||||
|
||||
Issue("Formatted strings with no content are handled incorrectly."); |
||||
data = class'FormattedStringData'.static.FromText(P("{$red }")); |
||||
TEST_ExpectNotNone(data.GetResult()); |
||||
TEST_ExpectTrue(data.GetResult().IsEmpty()); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("{#ff03a5 {$blue }}^3{$lime }")); |
||||
TEST_ExpectNotNone(data.GetResult()); |
||||
TEST_ExpectTrue(data.GetResult().IsEmpty()); |
||||
} |
||||
|
||||
protected static function SubTest_SimpleAlias() |
||||
{ |
||||
local MutableText example; |
||||
local FormattedStringData data; |
||||
Issue("Formatted strings with aliases are handled incorrectly."); |
||||
example = GetRGBText(); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {$red red}, {$lime green} and {$blue blue}!")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
example = GetRGBText(true); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {$red red{$white , }{$lime green{$white and }}}" |
||||
$ "{$blue blue!}")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
} |
||||
|
||||
protected static function SubTest_SimpleRGB() |
||||
{ |
||||
local MutableText example; |
||||
local FormattedStringData data; |
||||
Issue("Formatted strings with rgb definitions are handled incorrectly."); |
||||
example = GetRGBText(); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {rgb(255,0,0) red}, {rgb(0,255,0) green} and" |
||||
@ "{rgb(0,0,255) blue}!")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
example = GetRGBText(true); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {rgb(255,0,0) red{rgb(255,255,255) , }" |
||||
$ "{rgb(0,255,0) green{rgb(255,255,255) and }}}{rgb(0,0,255)" |
||||
$ " blue!}")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
} |
||||
|
||||
protected static function SubTest_SimpleHEX() |
||||
{ |
||||
local MutableText example; |
||||
local FormattedStringData data; |
||||
Issue("Formatted strings with hex definitions are handled incorrectly."); |
||||
example = GetRGBText(); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {#ff0000 red}, {#00ff00 green} and" |
||||
@ "{#0000ff blue}!")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
example = GetRGBText(true); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {#ff0000 red{#ffffff , }" |
||||
$ "{#00ff00 green{#ffffff and }}}{#0000ff blue!}")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
} |
||||
|
||||
protected static function SubTest_SimpleTag() |
||||
{ |
||||
local MutableText example; |
||||
local FormattedStringData data; |
||||
Issue("Formatted strings with rag definitions are handled incorrectly."); |
||||
example = GetRGBText(true); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is ^rred^w, ^2green^w and ^4blue!")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
} |
||||
|
||||
protected static function SubTest_SimpleMix() |
||||
{ |
||||
local MutableText example; |
||||
local FormattedStringData data; |
||||
Issue("Formatted strings with mixed definitions are handled incorrectly."); |
||||
example = GetRGBText(); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {rgb(255,0,0) red}, {$lime green} and" |
||||
@ "{#af4378 ^bblue}!")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
example = GetRGBText(true); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("This is {$red red{rgb(255,255,255) , }" |
||||
$ "{#800c37d ^ggre^gen{#ffffff and }}}^bblue!")); |
||||
TEST_ExpectTrue(example.Compare(data.GetResult(),, SFORM_SENSITIVE)); |
||||
} |
||||
|
||||
protected static function Test_Gradient() |
||||
{ |
||||
Context("Testing parsing formatted strings with gradient."); |
||||
SubTest_TestGradientTwoColors(); |
||||
SubTest_TestGradientThreeColors(); |
||||
SubTest_TestGradientFiveColors(); |
||||
SubTest_TestGradientPoints(); |
||||
SubTest_TestGradientPointsBad(); |
||||
} |
||||
|
||||
protected static function SubTest_TestGradientTwoColors() |
||||
{ |
||||
local int i; |
||||
local Text result; |
||||
local FormattedStringData data; |
||||
local Color previousColor, currentColor; |
||||
Issue("Simple (two color) gradient block does not color intermediate" |
||||
@ "characters correctly."); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("{rgb(255,128,56)~rgb(0,255,56)" |
||||
@ "Simple shit to test out gradient}")); |
||||
result = data.GetResult(); |
||||
previousColor = result.GetFormatting(0).color; |
||||
TEST_ExpectTrue(result.GetFormatting(0).isColored); |
||||
for (i = 1; i < result.GetLength(); i += 1) |
||||
{ |
||||
TEST_ExpectTrue(result.GetFormatting(i).isColored); |
||||
currentColor = result.GetFormatting(i).color; |
||||
TEST_ExpectTrue(previousColor.r > currentColor.r); |
||||
TEST_ExpectTrue(previousColor.g < currentColor.g); |
||||
TEST_ExpectTrue(previousColor.b == currentColor.b); |
||||
previousColor = currentColor; |
||||
} |
||||
Issue("Gradient (two color) block does not color edge characters" |
||||
@ "correctly."); |
||||
previousColor = result.GetFormatting(0).color; |
||||
currentColor = result.GetFormatting(result.GetLength() - 1).color; |
||||
TEST_ExpectTrue(previousColor.r == 255); |
||||
TEST_ExpectTrue(previousColor.g == 128); |
||||
TEST_ExpectTrue(previousColor.b == 56); |
||||
TEST_ExpectTrue(currentColor.r == 0); |
||||
TEST_ExpectTrue(currentColor.g == 255); |
||||
TEST_ExpectTrue(currentColor.b == 56); |
||||
} |
||||
|
||||
protected static function CheckRedDecrease(Text sample, int from, int to) |
||||
{ |
||||
local int i; |
||||
local Color previousColor, currentColor; |
||||
previousColor = sample.GetFormatting(from).color; |
||||
TEST_ExpectTrue(sample.GetFormatting(from).isColored); |
||||
for (i = from + 1; i < to; i += 1) |
||||
{ |
||||
TEST_ExpectTrue(sample.GetFormatting(i).isColored); |
||||
currentColor = sample.GetFormatting(i).color; |
||||
TEST_ExpectTrue(previousColor.r > currentColor.r); |
||||
previousColor = currentColor; |
||||
} |
||||
} |
||||
|
||||
protected static function CheckRedIncrease(Text sample, int from, int to) |
||||
{ |
||||
local int i; |
||||
local Color previousColor, currentColor; |
||||
previousColor = sample.GetFormatting(from).color; |
||||
TEST_ExpectTrue(sample.GetFormatting(from).isColored); |
||||
for (i = from + 1; i < to; i += 1) |
||||
{ |
||||
TEST_ExpectTrue(sample.GetFormatting(i).isColored); |
||||
currentColor = sample.GetFormatting(i).color; |
||||
TEST_ExpectTrue(previousColor.r < currentColor.r); |
||||
previousColor = currentColor; |
||||
} |
||||
} |
||||
|
||||
protected static function SubTest_TestGradientThreeColors() |
||||
{ |
||||
local Text result; |
||||
local FormattedStringData data; |
||||
local Color borderColor; |
||||
Issue("Gradient block with three colors does not color intermediate" |
||||
@ "characters correctly."); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("{rgb(255,0,0)~#000000~$red" |
||||
@ "Simple shit to test out gradient!}")); |
||||
result = data.GetResult(); |
||||
CheckRedDecrease(result, 0, 16); |
||||
CheckRedIncrease(result, 17, result.GetLength()); |
||||
Issue("Gradient block with three colors does not color edge characters" |
||||
@ "correctly."); |
||||
borderColor = result.GetFormatting(0).color; |
||||
TEST_ExpectTrue(borderColor.r == 255); |
||||
borderColor = result.GetFormatting(result.GetLength() - 1).color; |
||||
TEST_ExpectTrue(borderColor.r == 255); |
||||
borderColor = result.GetFormatting(16).color; |
||||
TEST_ExpectTrue(borderColor.r == 0); |
||||
} |
||||
|
||||
protected static function SubTest_TestGradientFiveColors() |
||||
{ |
||||
local Text result; |
||||
local FormattedStringData data; |
||||
local Color borderColor; |
||||
Issue("Gradient block with five colors does not color intermediate" |
||||
@ "characters correctly."); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("Check this wacky shit out: {rgb(255,0,0)~rgb(200,0,0)~rgb(180,0,0)~rgb(210,0,0)~rgb(97,0,0) Go f yourself}!?!?!"));//27 SHIFT |
||||
result = data.GetResult(); |
||||
CheckRedDecrease(result, 0 + 27, 6 + 27); |
||||
CheckRedIncrease(result, 7 + 27, 9 + 27); |
||||
CheckRedDecrease(result, 9 + 27, 12 + 27); |
||||
Issue("Gradient block with five colors does not color edge characters" |
||||
@ "correctly."); |
||||
borderColor = result.GetFormatting(0 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 255); |
||||
borderColor = result.GetFormatting(3 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 200); |
||||
borderColor = result.GetFormatting(6 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 180); |
||||
borderColor = result.GetFormatting(9 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 210); |
||||
borderColor = result.GetFormatting(12 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 97); |
||||
} |
||||
|
||||
protected static function SubTest_TestGradientPoints() |
||||
{ |
||||
local Text result; |
||||
local FormattedStringData data; |
||||
local Color borderColor; |
||||
Issue("Gradient points are incorrectly handled."); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("Check this wacky shit out: {rgb(255,0,0)~rgb(0,0,0)[25%]~rgb(123,0,0) Go f yourself}!?!?!")); |
||||
result = data.GetResult(); |
||||
CheckRedDecrease(result, 0 + 27, 3 + 27); |
||||
CheckRedIncrease(result, 3 + 27, 12 + 27); |
||||
borderColor = result.GetFormatting(0 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 255); |
||||
borderColor = result.GetFormatting(3 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 0); |
||||
borderColor = result.GetFormatting(12 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 123); |
||||
Issue("Gradient block does not color intermediate characters correctly."); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("Check this wacky shit out: {rgb(255,0,0)~rgb(0,0,0)[0.75]~rgb(45,0,0) Go f yourself}!?!?!")); |
||||
result = data.GetResult(); |
||||
CheckRedDecrease(result, 0 + 27, 9 + 27); |
||||
CheckRedIncrease(result, 9 + 27, 12 + 27); |
||||
borderColor = result.GetFormatting(0 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 255); |
||||
borderColor = result.GetFormatting(9 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 0); |
||||
borderColor = result.GetFormatting(12 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 45); |
||||
} |
||||
|
||||
protected static function SubTest_TestGradientPointsBad() |
||||
{ |
||||
local Text result; |
||||
local FormattedStringData data; |
||||
local Color borderColor; |
||||
Issue("Bad gradient points are incorrectly handled."); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("Check this wacky shit out: {rgb(255,0,0)~rgb(128,0,0)[50%]~rgb(150,0,0)[0.3]~rgb(123,0,0) Go f yourself}!?!?!")); |
||||
result = data.GetResult(); |
||||
CheckRedDecrease(result, 0 + 27, 6 + 27); |
||||
CheckRedIncrease(result, 6 + 27, 9 + 27); |
||||
CheckRedDecrease(result, 9 + 27, 12 + 27); |
||||
borderColor = result.GetFormatting(0 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 255); |
||||
borderColor = result.GetFormatting(6 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 128); |
||||
borderColor = result.GetFormatting(9 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 150); |
||||
borderColor = result.GetFormatting(12 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 123); |
||||
data = class'FormattedStringData'.static |
||||
.FromText(P("Check this wacky shit out: {rgb(200,0,0)~rgb(255,0,0)[EDF]~rgb(0,0,0)[0.50]~rgb(45,0,0) Go f yourself}!?!?!")); |
||||
result = data.GetResult(); |
||||
CheckRedIncrease(result, 0 + 27, 3 + 27); |
||||
CheckRedDecrease(result, 3 + 27, 6 + 27); |
||||
CheckRedIncrease(result, 6 + 27, 12 + 27); |
||||
borderColor = result.GetFormatting(0 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 200); |
||||
borderColor = result.GetFormatting(3 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 255); |
||||
borderColor = result.GetFormatting(6 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 0); |
||||
borderColor = result.GetFormatting(12 + 27).color; |
||||
TEST_ExpectTrue(borderColor.r == 45); |
||||
} |
||||
|
||||
defaultproperties |
||||
{ |
||||
caseName = "FormattedStrings" |
||||
caseGroup = "Text" |
||||
} |
||||
Binary file not shown.
Binary file not shown.
Loading…
Reference in new issue