public JsonResult RegexRename(int regexId, int subtypeId, string regex)
{
var regexManager = new RegexManager(regexId);
bool result = regexManager.Rename(subtypeId, regex);
return(Json(result));
}
public void Install(IServiceCollection services, IConfiguration configuration)
{
var searchRegex = configuration.GetSection(nameof(PlatformRecognizerOptions)).Get <PlatformRecognizerOptions>();
RegexManager.AddRegex(nameof(searchRegex.WindowsRegex), searchRegex.WindowsRegex);
RegexManager.AddRegex(nameof(searchRegex.LinuxRegex), searchRegex.LinuxRegex);
}
private static void ProcessComments(SyntaxNodeAnalysisContext context, List <SyntaxTrivia> comments, Location objectLocation, string objectName)
{
const int maxNumberOfLinesForComments = 5;
var singleLineComments = comments.Where(a => a.IsKind(SyntaxKind.SingleLineCommentTrivia)).ToList();
var multiLineComments = comments.Where(a => a.IsKind(SyntaxKind.MultiLineCommentTrivia)).ToList();
if (singleLineComments.Count > 0 && multiLineComments.Count > 0)
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, objectLocation, Rule, $"{objectName} has both multiline and single line comments. Please use only one type of comments.");
}
else if (singleLineComments.Count > maxNumberOfLinesForComments)
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, objectLocation, Rule, $"{objectName} has more than {maxNumberOfLinesForComments} lines comments. Please use no more than {maxNumberOfLinesForComments} lines of comments.");
}
else if (multiLineComments.Count > 1)
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, objectLocation, Rule, $"{objectName} has multiple MultiLines comments. Please use no more than 1 MultiLines of comments.");
}
else if (multiLineComments.Count == 1)
{
var numberOfLines = RegexManager.NumberOfLines(multiLineComments[0].ToFullString());
if (numberOfLines > maxNumberOfLinesForComments)
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, objectLocation, Rule, $"{objectName} has more than {maxNumberOfLinesForComments} lines comments. Please use no more than {maxNumberOfLinesForComments} lines of comments.");
}
}
}
public static object Constructor(JintRuntime runtime, object @this, JsObject callee, object[] arguments)
{
var target = (JsObject)@this;
if (target == runtime.Global.GlobalScope)
target = runtime.Global.CreateObject(callee.Prototype);
string pattern = null;
string options = null;
if (arguments.Length > 0)
{
pattern = JsValue.ToString(arguments[0]);
if (arguments.Length > 1)
options = JsValue.ToString(arguments[1]);
}
var manager = new RegexManager(pattern, options);
target.SetClass(JsNames.ClassRegexp);
target.IsClr = false;
target.Value = manager;
target.SetProperty(Id.source, pattern);
target.SetProperty(Id.lastIndex, (double)0);
target.SetProperty(Id.global, BooleanBoxes.Box(manager.IsGlobal));
return target;
}
private bool EnterCommandCanExecute(object obj)
{
return(InvestInfo.CurrentTradeType != TradeType.DEFAULT && _isNotCaptialTradeMode &&
RegexManager.IsNotBlank(SelectedCoin) &&
RegexManager.IsTextUnsignedDouble(AmountText) && RegexManager.IsNotBlank(AmountText) &&
RegexManager.IsTextUnsignedDouble(UnitPriceText) && RegexManager.IsNotBlank(UnitPriceText) &&
RegexManager.IsTextUnsignedDouble(AFeeText) && RegexManager.IsNotBlank(AFeeText) &&
RegexManager.IsTextUnsignedDouble(RFeeText) && RegexManager.IsNotBlank(RFeeText));
}
private bool StartCheckCanExecute(object obj)
{
return(!IsInProgress &&
RegexManager.IsUnsignedInt(ProductID) &&
RegexManager.IsNotBlank(ProductID) &&
ScheduleID != null &&
CookieText != null &&
RegexManager.IsUnsignedInt(Qty));
}
public void Match_True()
{
var manager = new RegexManager <bool>(() => { Assert.True(false); });
var IsMatched = manager
.AddRegex(new RegexExecute <bool>("[0-9]", (m) => { return(m.Success); }))
.AddRegex(new RegexExecute <bool>("[a-z]", (m) => { return(m.Success); }))
.Run("7");
Assert.True(IsMatched);
}
private void AnalyzeInterfaceDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsGeneratedCode())
{
return;
}
var declaration = Cast <InterfaceDeclarationSyntax>(context.Node);
RegexManager.DoesNotSatisfyInterfaceRule(context, declaration.Identifier.Text, declaration.Identifier.GetLocation(), Rule);
}
private void AnalyzeClassDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsAutomaticallyGeneratedCode())
{
return;
}
var declaration = Cast <ClassDeclarationSyntax>(context.Node);
RegexManager.DoesNotSatisfyNonPrivateNameRule(context, declaration.Identifier.Text, declaration.Identifier.GetLocation(), Rule);
}
public ActionResult RegexDelete(int regexId)
{
var regexManager = new RegexManager(regexId);
var result = regexManager.Delete();
if (result.Status == Status.Success)
{
return(PartialView("_RegexList", StaticData.RecordRegex));
}
return(Json(result));
}
public ActionResult RegexAdd(string regex, int subtypeId)
{
var result = RegexManager.CreateNew(regex, subtypeId);
if (result.Status == Status.Success)
{
return(PartialView("_RegexList", StaticData.RecordRegex));
}
return(Json(result));
}
public void Match_True_And_Equals_Value()
{
var testValue = "7";
RegexManager <Match> manager = new RegexManager <Match>(() => { Assert.True(false); });
var match = manager
.AddRegex(new RegexExecute <Match>("[0-9]", (m) => { return(m); }))
.AddRegex(new RegexExecute <Match>("[a-z]", (m) => { return(m); }))
.Run(testValue);
Assert.True(match.Success);
Assert.Equal(testValue, match.Value);
}
private static void ProcessDocumentationComments(SyntaxNodeAnalysisContext context, Location declarationLocation, string declarationName, int threshold)
{
var docummentation = CommentsManager.ExtractDocumentationComment(context.Node);
if (docummentation != null)
{
var numberOfLines = RegexManager.NumberOfLines(docummentation.Content.ToFullString());
if (numberOfLines > threshold)
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, declarationLocation, Rule, declarationName, threshold);
}
}
}
private void AnalyzeLocalDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsAutomaticallyGeneratedCode())
{
return;
}
var declaration = Cast <LocalDeclarationStatementSyntax>(context.Node);
var variableDeclarator = declaration.Declaration.Variables.FirstOrDefault()?.Identifier.Text;
RegexManager.DoesNotSatisfyLocalVariableNameRule(context, variableDeclarator, declaration.GetLocation(), Rule);
}
private void AnalyzeMethodDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsAutomaticallyGeneratedCode())
{
return;
}
var declaration = Cast <MethodDeclarationSyntax>(context.Node);
RegexManager.DoesNotSatisfyNonPrivateNameRule(context, declaration.Identifier.Text, declaration.Identifier.GetLocation(), Rule);
foreach (var parameter in declaration.ParameterList.Parameters)
{
RegexManager.DoesNotSatisfyLocalVariableNameRule(context, parameter.Identifier.Text, parameter.Identifier.GetLocation(), Rule);
}
}
private string GetCourseNames(string part)
{
var regex = RegexManager.CourseRegex();
var matches = regex.Matches(part);
var ret = new List <string>();
foreach (Match match in matches)
{
foreach (Capture capture in match.Captures)
{
ret.Add(capture.Value.TrimEnd());
}
}
ret = ret.Distinct().OrderBy(r => r).ToList();
return(String.Join(",", ret));
}
private void AnalyzePropertyDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsAutomaticallyGeneratedCode())
{
return;
}
var declaration = Cast <PropertyDeclarationSyntax>(context.Node);
if (!IsExternallyVisible(declaration.Modifiers))
{
return;
}
var propertiesString = declaration.Identifier.Text;
RegexManager.DoesNotSatisfyNonPrivateNameRule(context, propertiesString, declaration.Identifier.GetLocation(), Rule);
}
private bool ProcessMultiLineComments(SyntaxNodeAnalysisContext context, List <SyntaxTrivia> multiLineComments)
{
var multiLineCommentViolationFound = false;
if (multiLineComments?.Count > 0)
{
foreach (var multiLineComment in multiLineComments)
{
var content = multiLineComment.ToFullString();
if (RegexManager.MatchFound($@"\/[*]((.)*\n){{{MaxNoOfLinesForComments},}}", content))
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, multiLineComment.GetLocation(), Rule, Message);
multiLineCommentViolationFound = true;
break;
}
}
}
return(multiLineCommentViolationFound);
}
private void AnalyzeFieldDeclaration(SyntaxNodeAnalysisContext context)
{
if (context.IsAutomaticallyGeneratedCode())
{
return;
}
var declaration = Cast <FieldDeclarationSyntax>(context.Node);
if (!IsExternallyVisible(declaration.Modifiers))
{
return;
}
var variableDeclarator = declaration.Declaration.Variables.FirstOrDefault()?.Identifier.Text;
var location = declaration.Declaration.Variables.FirstOrDefault()?.Identifier.GetLocation();
RegexManager.DoesNotSatisfyNonPrivateNameRule(context, variableDeclarator, location, Rule);
}
/// <summary>
/// Instantiates a DieRoll obj.
/// </summary>
/// <param name="dieRollData">the string representing the dieroll</param>
public DieRoll(string dieRollData)
{
try
{
Match m = RegexManager.GetRegex("dieroll").Match(dieRollData);
if (!m.Success)
{
throw new ArgumentException("Unable to interpret die roll data: " + dieRollData);
}
Multiplier1 = m.Groups["Mult1"].Value.Length > 0? int.Parse(m.Groups["Mult1"].Value) : 0;
Multiplier2 = m.Groups["Mult2"].Value.Length > 0? int.Parse(m.Groups["Mult2"].Value) : 0;
Modifier = m.Groups["Mod"].Value.Length > 0? int.Parse(m.Groups["ModNeg"].Value + m.Groups["Mod"].Value) : 0;
Negative = m.Groups["Neg"].Value == "-" ? true : false;
}
catch (Exception parseExc)
{
throw new ArgumentException("Unable to interpret die roll data: " + dieRollData);
}
}
private void ProcessSingleLineComments(SyntaxNodeAnalysisContext context, List <SyntaxTrivia> singleLineComments, string declarationBodyText = null)
{
if (singleLineComments?.Count > 0)
{
if (!string.IsNullOrWhiteSpace(declarationBodyText) && RegexManager.MatchFound($@"((\s)*\/\/(.)*(\n)*){{{MaxNoOfLinesForComments},}}", declarationBodyText))
{
foreach (var singleLineComment in singleLineComments)
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, singleLineComment.GetLocation(), Rule, Message);
}
}
else if (singleLineComments.Count > MaxNoOfLinesForComments)
{
foreach (var singleLineComment in singleLineComments)
{
DiagnosticsManager.CreateCommentsTooLongDiagnostic(context, singleLineComment.GetLocation(), Rule, Message);
}
}
}
}
// 15.5.4.10
public static object Match(JintRuntime runtime, object @this, JsObject callee, object[] arguments)
{
RegexManager manager;
if (!TryGetRegExpManager(arguments[0], out manager))
manager = new RegexManager(JsValue.ToString(arguments[0]), null);
var input = JsValue.ToString(@this);
if (!manager.IsGlobal)
return manager.Exec(runtime, input);
var matches = manager.Regex.Matches(input);
if (matches.Count == 0)
return JsNull.Instance;
var result = runtime.Global.CreateArray();
var store = result.FindArrayStore();
for (int i = 0; i < matches.Count; i++)
{
store.DefineOrSetPropertyValue(i, matches[i].Value);
}
return result;
}
private static object ReplaceWithManager(JintRuntime runtime, RegexManager manager, object replaceValue, string source)
{
int count;
int lastIndex;
if (manager.IsGlobal)
{
count = int.MaxValue;
lastIndex = 0;
manager.LastIndex = 0;
}
else
{
count = 1;
lastIndex = Math.Max(0, manager.LastIndex - 1);
}
if (lastIndex >= source.Length)
return String.Empty;
JsDelegate function = null;
string replace = null;
bool replacePattern = false;
if (JsValue.IsFunction(replaceValue))
{
function = ((JsObject)replaceValue).Delegate;
}
else
{
replace = JsValue.ToString(replaceValue);
replacePattern = replace.IndexOf('$') != -1;
}
var sb = new StringBuilder();
int offset = 0;
foreach (Match match in manager.Regex.Matches(source, lastIndex))
{
if (count-- == 0)
break;
if (match.Index > offset)
sb.Append(source, offset, match.Index - offset);
offset = match.Index + match.Length;
if (!manager.IsGlobal)
manager.LastIndex = match.Index + 1;
if (replace != null)
{
if (replacePattern)
{
EvaluateReplacePattern(
sb,
source,
match.Value,
match.Index,
replace,
match.Groups
);
}
else
{
sb.Append(replace);
}
}
else
{
var replaceArguments = new object[match.Groups.Count + 2];
for (int i = 0; i < match.Groups.Count; i++)
{
replaceArguments[i] = match.Groups[i].Success
? (object)match.Groups[i].Value
: JsUndefined.Instance;
}
replaceArguments[replaceArguments.Length - 2] = match.Index;
replaceArguments[replaceArguments.Length - 1] = source;
sb.Append(JsValue.ToString(function.Delegate(
runtime,
runtime.GlobalScope,
(JsObject)replaceValue,
replaceArguments
)));
}
}
sb.Append(source, offset, source.Length - offset);
return sb.ToString();
}
private bool EnterCommandCanExecute(object obj)
{
return(!string.IsNullOrEmpty(InvestmentTitle) && RegexManager.IsTextUnsignedDouble(Principal));
}
public void Initialize()
{
regexManager = new RegexManager();
}
private static bool TryGetRegExpManager(object value, out RegexManager manager)
{
var @object = value as JsObject;
if (@object != null)
manager = @object.Value as RegexManager;
else
manager = null;
return manager != null;
}
// 15.5.4.12
public static object Search(JintRuntime runtime, object @this, JsObject callee, object[] arguments)
{
// Converts the arguments to a regex
RegexManager manager;
if (!TryGetRegExpManager(arguments[0], out manager))
manager = new RegexManager(JsValue.ToString(arguments[0]), null);
var input = JsValue.ToString(@this);
var match = manager.Regex.Match(input);
if (match.Success)
return (double)match.Index;
return (double)-1;
}
public void ReturnTheCorrectNumberOfLinesForTheInputString(string inputString, int expectedRowCount)
{
var lineCount = RegexManager.NumberOfLines(inputString);
lineCount.Should().Be(expectedRowCount);
}
