public override SyntaxToken VisitToken(SyntaxToken token)
{
var res = base.VisitToken(token);
var kind = token.Kind();
var previous = token.GetPreviousToken().Kind();
var next = token.GetNextToken().Kind();
// LeadingTrivia
switch (kind)
{
case SyntaxKind.EqualsGreaterThanToken:
if (PreEqualsToken.Contains(previous))
{
return(res.WithLeadingTrivia(SyntaxFactory.Space).WithTrailingTrivia(SyntaxFactory.ElasticMarker));
}
return(res.WithoutTrivia());
}
if (SplitToken.Contains(kind))
{
return(res.WithoutTrivia());
}
if (SplitToken.Contains(previous))
{
res = res.WithLeadingTrivia(SyntaxFactory.ElasticMarker);
}
if (SplitToken.Contains(next))
{
res = res.WithTrailingTrivia(SyntaxFactory.ElasticMarker);
}
return(res);
}
void Verify_Check(bool isValid, params string[] values)
{
//------------Setup for test--------------------------
const char SplitToken = ',';
Func <string> getValue = () => string.Join(SplitToken.ToString(CultureInfo.InvariantCulture), values);
var rule = new IsValidEmailAddressRule(getValue, SplitToken)
{
LabelText = "The item"
};
//------------Execute Test---------------------------
var result = rule.Check();
//------------Assert Results-------------------------
if (isValid)
{
Assert.IsNull(result);
}
else
{
StringAssert.Contains("The item contains an invalid email address", result.Message);
}
}
public static List<SplitToken> SplitBlockquoteTokens(ImmutableArray<IMarkdownToken> tokens)
{
var splitTokens = new List<SplitToken>();
SplitToken splitToken = null;
foreach (var token in tokens)
{
if (token is DfmSectionBlockToken || token is DfmNoteBlockToken)
{
splitToken = new SplitToken(token);
splitTokens.Add(splitToken);
}
else
{
if (splitToken != null)
{
splitToken.InnerTokens.Add(token);
continue;
}
splitToken = new SplitToken(token);
splitToken.InnerTokens.Add(token);
splitTokens.Add(splitToken);
}
}
return splitTokens;
}
public static List <SplitToken> SplitBlockquoteTokens(ImmutableArray <IMarkdownToken> tokens)
{
var splitTokens = new List <SplitToken>();
SplitToken splitToken = null;
foreach (var token in tokens)
{
if (token is DfmSectionBlockToken || token is DfmNoteBlockToken)
{
splitToken = new SplitToken(token);
splitTokens.Add(splitToken);
}
else
{
if (splitToken != null)
{
splitToken.InnerTokens.Add(token);
continue;
}
splitToken = new SplitToken(token);
splitToken.InnerTokens.Add(token);
splitTokens.Add(splitToken);
}
}
return(splitTokens);
}
bool ValidateFields()
{
_errorColletion.Clear();
if (SplitType == "Index")
{
if (!SplitToken.IsWholeNumber())
{
_errorColletion.Add(new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Please supply a whole positive number for an Index split"));
return(false);
}
if (!int.TryParse(SplitToken, out int indexToSplitOn))
{
_errorColletion.Add(double.TryParse(SplitToken, out double doubleToSplitOn) ? new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Please supply a number less then 2,147,483,647 for an Index split") : new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Please supply a whole positive number for an Index split"));
return(false);
}
if (indexToSplitOn < 1)
{
_errorColletion.Add(new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Please supply a whole positive number for an Index split"));
return(false);
}
}
else
{
if (SplitType == "Chars")
{
if (string.IsNullOrEmpty(SplitToken))
{
_errorColletion.Add(new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Please supply a value for a Character split"));
return(false);
}
}
}
if (string.IsNullOrWhiteSpace(VariableListString))
{
_errorColletion.Add(new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Variable List String can not be blank/empty"));
return(false);
}
if (!string.IsNullOrEmpty(Prefix) && !ValidateRecordsetPrefix(Prefix))
{
_errorColletion.Add(new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Prefix contains invalid characters"));
return(false);
}
if (!string.IsNullOrEmpty(Suffix) && !ValidateName(Suffix))
{
_errorColletion.Add(new KeyValuePair <ErrorType, string>(ErrorType.Critical, "Suffix contains invalid characters"));
return(false);
}
return(true);
}
IEnumerable <IActionableErrorInfo> ValidationErrorsForIndexSplit()
{
var doFocused = new Action(() => { IsSplitOnFocused = true; });
if (!SplitToken.IsWholeNumber())
{
yield return(new ActionableErrorInfo(doFocused)
{
ErrorType = ErrorType.Critical, Message = "Please supply a whole positive number for an Index split"
});
}
else
{
int indexToSplitOn;
if (!int.TryParse(SplitToken, out indexToSplitOn))
{
double doubleToSplitOn;
if (double.TryParse(SplitToken, out doubleToSplitOn))
{
yield return(new ActionableErrorInfo(doFocused)
{
ErrorType = ErrorType.Critical, Message = "Please supply a number less then 2,147,483,647 for an Index split"
});
}
else
{
yield return(new ActionableErrorInfo(doFocused)
{
ErrorType = ErrorType.Critical, Message = "Please supply a whole positive number for an Index split"
});
}
}
if (indexToSplitOn < 1)
{
yield return(new ActionableErrorInfo(doFocused)
{
ErrorType = ErrorType.Critical, Message = "Please supply a whole positive number for an Index split"
});
}
}
}
public void IncompleteJoinTransition(int index)
{
// Arrange
var trans = new JoinTransition
{
Id = 1,
Inputs = _inputs,
Outputs = new[] { _outputs[0] }
};
var split = new SplitToken(_token);
// Act
trans.Initialize();
_inputs[index].Add(split);
// Assert
Assert.AreEqual(1, _inputs[index].Tokens.Count());
Assert.AreEqual(0, _inputs[(index + 1) % 2].Tokens.Count());
Assert.AreEqual(0, _outputs[0].Tokens.Count());
}
public void JoinTransition()
{
// Arrange
var trans = new JoinTransition
{
Id = 1,
Inputs = _inputs,
Outputs = new[] { _outputs[0] }
};
var split1 = new SplitToken(_token);
var split2 = new SplitToken(_token);
// Act
trans.Initialize();
_inputs[0].Add(split1);
_inputs[1].Add(split2);
// Assert
Assert.IsTrue(_inputs.All(i => !i.Tokens.Any()));
Assert.AreEqual(1, _outputs[0].Tokens.Count());
Assert.AreEqual(_token, _outputs[0].Tokens.First());
}
public void AddToSplitToken(SplitToken splitToken)
{
base.AddObject("SplitToken", splitToken);
}
public static SplitToken CreateSplitToken(global::System.Guid ID)
{
SplitToken splitToken = new SplitToken();
splitToken.ID = ID;
return splitToken;
}
static IExecutionCommand Parse(bool executable, IParseElement element, out bool isGroup)
{
isGroup = false;
if (element is Group)
{
Group group = (Group)element;
if (group.GroupInfo == internalExpression)
{
isGroup = true;
return(Parse(true, group.InternalElement));
}
else if (group.GroupInfo == groupExpression)
{
isGroup = true;
// We skip group expression.
return(Parse(true, group.InternalElement));
}
}
else if (element is Identifier)
{
Identifier id = (Identifier)element;
if (!executable)
{
return(new ConstantCommand(id.Token.TokenValue));
}
else
{
return(new MethodCallCommand(new ConstantCommand(id.Token.TokenValue), new IExecutionCommand[0]));
}
}
else if (element is SplitToken)
{
SplitToken token = (SplitToken)element;
if (token.TokenInfo == logicalAnd)
{
return(new AndCommand(Parse(true, token.LeftElement), Parse(true, token.RightElement)));
}
else if (token.TokenInfo == logicalOr)
{
return(new OrCommand(Parse(true, token.LeftElement), Parse(true, token.RightElement)));
}
else if (token.TokenInfo == parallel)
{
return(new ParallelCommand(Parse(true, token.LeftElement), Parse(true, token.RightElement)));
}
else if (token.TokenInfo == pipe)
{
return(new PipeCommand(Parse(true, token.LeftElement), Parse(true, token.RightElement)));
}
}
else if (element is ElementSequence)
{
ElementSequence token = (ElementSequence)element;
// We have a method call.
IExecutionCommand methodName = Parse(false, token.Elements[0]);
List <IExecutionCommand> parameters = new List <IExecutionCommand>();
for (int i = 1; i < token.Elements.Length; i++)
{
parameters.Add(Parse(false, token.Elements[i]));
}
return(new MethodCallCommand(methodName, parameters.ToArray()));
}
throw new Exception("Could not parse command.");
}
