void AddRule(ObfuscationAttributeInfo attr, Rules rules) { Debug.Assert(attr.FeatureName != null && attr.FeatureName.StartsWith("@")); var pattern = attr.FeatureName.Substring(1); PatternExpression expr; try { expr = new PatternParser().Parse(pattern); } catch (Exception ex) { throw new Exception("Error when parsing pattern " + pattern + " in ObfuscationAttribute", ex); } var ruleAdaptor = new RuleAdaptor(pattern); try { new ObfAttrParser(protections).ParseProtectionString(ruleAdaptor, attr.FeatureValue); } catch (Exception ex) { throw new Exception("Error when parsing rule " + attr.FeatureValue + " in ObfuscationAttribute", ex); } rules.Add(ruleAdaptor.Rule, expr); }
public void Parse(string source, string expectedKey, string expectedFormat, string expectedArgs) { var literalParserMock = new Mock <ILiteralParser>(); var sb = new StringBuilder(source); literalParserMock.Setup(x => x.ParseLiterals(sb)); literalParserMock.Setup(x => x.ParseLiterals(sb)) .Returns(new[] { new Literal(0, source.Length, 1, 1, new StringBuilder(source)) }); var subject = new PatternParser(literalParserMock.Object); // Warm up (JIT) Benchmark.Start("Parsing formatter patterns (first time before JIT)", this.outputHelper); subject.Parse(sb); Benchmark.End(this.outputHelper); Benchmark.Start("Parsing formatter patterns (after warm-up)", this.outputHelper); var actual = subject.Parse(sb); Benchmark.End(this.outputHelper); Assert.Equal(1, actual.Count()); var first = actual.First(); Assert.Equal(expectedKey, first.Variable); Assert.Equal(expectedFormat, first.FormatterName); Assert.Equal(expectedArgs, first.FormatterArguments); }
public void TestParseExpressionWithInt(string text, int?expected) { var actual = PatternParser.ParseExpressionWithInt(IntExpressionFormat, text); Console.WriteLine($"Success: {actual.success}, message: {actual.message}"); Assert.AreEqual(expected, actual.result); }
public static Pattern CreatePattern(string patternName) { Pattern result; Texture2D tempTexture = Resources.Load <Texture2D>("Magic/SpellPatterns/" + patternName); return(PatternParser.CreatePattern(tempTexture)); }
public void FormatMessage_caches_reused_pattern() { var parserMock = new Mock <IPatternParser>(); var realParser = new PatternParser(new LiteralParser()); parserMock.Setup(x => x.Parse(It.IsAny <StringBuilder>())) .Returns((StringBuilder sb) => realParser.Parse(sb)); var library = new FormatterLibrary(); var subject = new MessageFormatter(patternParser: parserMock.Object, library: library, useCache: true); var pattern = "Hi {gender, select, male {Sir} female {Ma'am}}!"; var actual = subject.FormatMessage(pattern, new { gender = "male" }); Assert.Equal("Hi Sir!", actual); // '2' because it did not format "Ma'am" yet. parserMock.Verify(x => x.Parse(It.IsAny <StringBuilder>()), Times.Exactly(2)); actual = subject.FormatMessage(pattern, new { gender = "female" }); Assert.Equal("Hi Ma'am!", actual); parserMock.Verify(x => x.Parse(It.IsAny <StringBuilder>()), Times.Exactly(3)); // '3' because it has cached all options actual = subject.FormatMessage(pattern, new { gender = "female" }); Assert.Equal("Hi Ma'am!", actual); parserMock.Verify(x => x.Parse(It.IsAny <StringBuilder>()), Times.Exactly(3)); }
private async void Set <T>(CommandArgs args) where T : class, ITemplate { var parameters = args.Parameters; var player = args.Player; if (parameters.Count < 1) { var commandName = args.GetCommandName(); player.SendErrorMessage($"Syntax: //{commandName.ToLowerInvariant()} <pattern>"); return; } var parser = new PatternParser(Parsers[typeof(T)]); var inputPattern = string.Join(" ", parameters); var pattern = parser.Parse(inputPattern); if (pattern == null) { player.SendErrorMessage($"Invalid pattern '{inputPattern}'."); return; } var session = Plugin.GetOrCreateSession(player); var editSession = session.CreateEditSession(); var region = session.Selection; await Task.Run(() => session.Submit(() => { var count = editSession.ModifyTiles(region, pattern); player.SendSuccessMessage($"Modified {count} tiles."); })).SendExceptions(player); }
/// <summary> /// Parses the rules' patterns. /// </summary> /// <param name="proj">The project.</param> /// <param name="module">The module description.</param> /// <param name="context">The working context.</param> /// <returns>Parsed rule patterns.</returns> /// <exception cref="System.ArgumentException"> /// One of the rules has invalid pattern. /// </exception> protected Rules ParseRules(ConfuserProject proj, ProjectModule module, ConfuserContext context) { var ret = new Rules(); var parser = new PatternParser(); foreach (Rule rule in proj.Rules.Concat(module.Rules)) { try { ret.Add(rule, parser.Parse(rule.Pattern)); } catch (InvalidPatternException ex) { context.Logger.ErrorFormat("Invalid rule pattern: " + rule.Pattern + ".", ex); throw new ConfuserException(ex); } foreach (var setting in rule) { if (!protections.ContainsKey(setting.Id)) { context.Logger.ErrorFormat("Cannot find protection with ID '{0}'.", setting.Id); throw new ConfuserException(null); } } } return(ret); }
public void It_Should_Parse_A_Single_Catch_All() { var parser = new PatternParser("GET /catchy/*"); var matches = parser.Match("GET /catchy/tune"); Assert.AreEqual("tune", matches[":star"][0]); }
private Route(HttpMethod httpMethod, string pathInfo) { HttpMethod = httpMethod; PathInfo = (pathInfo != null) ? (!string.IsNullOrWhiteSpace(pathInfo)) ? pathInfo : string.Empty : string.Empty; PatternKeys = PatternParser.GeneratePatternKeys(PathInfo); PathInfoPattern = PatternParser.GenerateRegEx(PathInfo); }
public void TestStackTracePattern() { var p = new PatternParser(GetLoggingEvent()); var s = p.Parse("%stacktrace{6}"); Assert.AreEqual("LayoutSkeleton.Format > PatternLayout.Format > PatternConverter.Format > PatternLayoutConverter.Convert > StackTracePatternConverter.Convert > LoggingEvent.get_LocationInformation", s); }
public void ReadLiteralSection_with_offset(string source, string expected, int offset) { var literal = new Literal(10, 10, 1, 1, new StringBuilder(source)); int lastIndex; Assert.Equal(expected, PatternParser.ReadLiteralSection(literal, offset, true, out lastIndex)); }
internal static int Main(string[] args) { var app = new CommandLineApplication(); app.Name = "MyMediaRenamer"; app.Description = "Bulk renamer of photo and video files."; app.HelpOption("-h|--help"); var defaultStringOption = app.Option("--default-string", "The default string used when a tag fails to produce a valid string", CommandOptionType.SingleValue); var dryRunOption = app.Option("-d|--dry-run", "Do a dry-run where the program does not actually rename any files", CommandOptionType.NoValue); var recursiveOption = app.Option("-r|--recursive", "Recursively access files under given directories", CommandOptionType.NoValue); var skipNullOption = app.Option("--skip-null", "Skip renaming a file if a tag fails to produce a valid string", CommandOptionType.NoValue); var patternArgument = app.Argument("File Name Pattern", "Pattern used to determine the new file name of each file", false); var filesArgument = app.Argument("Media Files", "File(s) to rename", true); app.OnExecute(() => { if (string.IsNullOrEmpty(patternArgument.Value) || !(filesArgument.Values.Count > 0)) { app.ShowHint(); _returnCode = 1; } if (defaultStringOption.HasValue()) { Renamer.NullTagString = defaultStringOption.Value(); } if (skipNullOption.HasValue()) { Renamer.SkipOnNullTag = true; } if (dryRunOption.HasValue()) { Renamer.DryRun = true; } try { var tags = PatternParser.Parse(patternArgument.Value); ProcessFilePaths(filesArgument.Values.ToArray(), recursiveOption.HasValue()); Renamer.Execute(MediaFiles, tags); } catch (PatternInvalidException e) { WriteError("Pattern provided by the user is invalid.", e, false); _returnCode = 1; } catch (Exception e) { WriteError("Program has encountered an unexpected error!\n", e, true); _returnCode = 1; } return(_returnCode); }); return(app.Execute(args)); }
ProtectionSettingsInfo AddRule(ObfuscationAttributeInfo attr, List<ProtectionSettingsInfo> infos) { Debug.Assert(attr.FeatureName != null); var pattern = attr.FeatureName; PatternExpression expr; try { expr = new PatternParser().Parse(pattern); } catch (Exception ex) { throw new Exception("Error when parsing pattern " + pattern + " in ObfuscationAttribute. Owner=" + attr.Owner, ex); } var info = new ProtectionSettingsInfo(); info.Condition = expr; info.Exclude = (attr.Exclude ?? true); info.ApplyToMember = (attr.ApplyToMembers ?? true); info.Settings = attr.FeatureValue; bool ok = true; try { new ObfAttrParser(protections).ParseProtectionString(null, info.Settings); } catch { ok = false; } if (!ok) context.Logger.ErrorFormat("Ignoring rule '{0}' in {1}.", info.Settings, attr.Owner); else if (infos != null) infos.Add(info); return info; }
public void MultiTagOptionsTest(string pattern, BaseTag expectedTag) { List <BaseTag> actualTags = PatternParser.Parse(pattern); Assert.AreEqual(1, actualTags.Count); Assert.AreEqual(expectedTag, actualTags[0]); }
public void ComplexPattern() { PatternParser p = new PatternParser("500,x,20,y,loop 1,2,50,z"); Assert.True(p.GetNextExecution() > 0); Assert.AreEqual("x", p.GetNextAction()); p.Next(); Assert.True(p.GetNextExecution() > 0); Assert.AreEqual("y", p.GetNextAction()); p.Next(); Assert.True(p.GetNextExecution() > 0); Assert.AreEqual("y", p.GetNextAction()); p.Next(); Assert.True(p.GetNextExecution() > 0); Assert.AreEqual("y", p.GetNextAction()); p.Next(); Assert.True(p.GetNextExecution() > 0); Assert.AreEqual("z", p.GetNextAction()); p.Next(); Assert.IsNull(p.GetNextExecution()); Assert.IsNull(p.GetNextAction()); }
public void It_Should_Parse_Multiple_Named_Tokens() { var parser = new PatternParser("GET /locator/:country/:state/:city"); var matches = parser.Match("GET /locator/usa/mi/detroit"); Assert.AreEqual("usa", matches[":country"]); }
public override Verb CreateVerb(string[] tokens) { Color(position, tokens[1].Length, Whitespaces); var fromSource = tokens[2]; Color(fromSource.Length, Numbers); Color(1, Structures); var toSource = tokens[3]; Color(toSource.Length, Numbers); var from = fromSource.ToInt(); var to = toSource.ToInt(); var parser = new PatternParser { IgnoreReplacement = true }; if (parser.Scan(source, position + length - 1)) { var newPattern = (Pattern)parser.Result.Value; Element = new RangeElement(from, to, newPattern); overridePosition = parser.Result.Position; return(new NullOp()); } return(null); }
/// <summary> /// Default ctor /// </summary> public PatternInclude(string pattern, bool applyToMembers, bool isGlobal) { if (pattern == null) { throw new ArgumentNullException("pattern"); } IsGlobal = isGlobal; _pattern = PatternParser.ParseMatcher(pattern, applyToMembers); if (IsEmpty) { return; } bool hasInclude = _pattern.Attributes.Any(a => a == "Dot42.Include"); bool hasIncludeType = _pattern.Attributes.Any(a => a == "Dot42.IncludeType"); if (hasIncludeType) { _pattern.ApplyToMembers = true; } else if (!hasInclude) { _pattern = null; } }
/// <summary> /// Parses the rules' patterns. /// </summary> /// <param name="proj">The project.</param> /// <param name="module">The module description.</param> /// <param name="context">The working context.</param> /// <returns>Parsed rule patterns.</returns> /// <exception cref="T:System.ArgumentException"> /// One of the rules has invalid pattern. /// </exception> // Token: 0x06000195 RID: 405 RVA: 0x0000D320 File Offset: 0x0000B520 protected Dictionary <Rule, PatternExpression> ParseRules(ConfuserProject proj, ProjectModule module, ConfuserContext context) { Dictionary <Rule, PatternExpression> ret = new Dictionary <Rule, PatternExpression>(); PatternParser parser = new PatternParser(); foreach (Rule rule in proj.Rules.Concat(module.Rules)) { try { ret.Add(rule, parser.Parse(rule.Pattern)); } catch (InvalidPatternException ex) { context.Logger.ErrorFormat("Invalid rule pattern: " + rule.Pattern + ".", new object[] { ex }); throw new ConfuserException(ex); } foreach (SettingItem <Protection> setting in rule) { if (!this.protections.ContainsKey(setting.Id)) { context.Logger.ErrorFormat("Cannot find protection with ID '{0}'.", new object[] { setting.Id }); throw new ConfuserException(null); } } } return(ret); }
public void Parse() { var subject = new PatternParser(new LiteralParser()); const string Source = @"Hi, {Name, select, male={guy} female={gal}}, you have {count, plural, zero {no friends}, other {# friends} }"; Benchmark.Start("First run (warm-up)", this.outputHelper); subject.Parse(new StringBuilder(Source)); Benchmark.End(this.outputHelper); Benchmark.Start("Next one (warmed up)", this.outputHelper); var actual = subject.Parse(new StringBuilder(Source)); Benchmark.End(this.outputHelper); Assert.Equal(2, actual.Count()); var formatterParam = actual.First(); Assert.Equal("Name", formatterParam.Variable); Assert.Equal("select", formatterParam.FormatterName); Assert.Equal("male={guy} female={gal}", formatterParam.FormatterArguments); formatterParam = actual.ElementAt(1); Assert.Equal("count", formatterParam.Variable); Assert.Equal("plural", formatterParam.FormatterName); Assert.Equal("zero {no friends}, other {# friends}", formatterParam.FormatterArguments); }
public void It_Should_Parse_Multiple_Catch_All_Values() { var parser = new PatternParser("GET /catchy/*/*/*"); var matches = parser.Match("GET /catchy/tunes/from/radio"); Assert.AreEqual(new[] { "tunes", "from", "radio" }, matches[":star"]); }
private static void Initialize() { if (_initialized) { return; } _initialized = true; _lexer = new Lexer(); _lexer.AddIgnore(@"\s+"); var suffix = _lexer.Add("²|³|°", "SUFFIX"); var prefix = _lexer.Add(@"√|∛|abs|acos|arg|asin|atan|cbrt|cnj|cosh?|deg|exp|im|ln|rad|rcp|re|sinh?|sqrt|tanh?", "PREFIX"); var prefix2 = _lexer.Add(@"log_|root_", "PREFIX2"); var infix0 = _lexer.Add(@"\^", "INFIX0"); var infix1 = _lexer.Add(@"[*/×÷∠]", "INFIX1"); var infix2 = _lexer.Add(@"[--++]", "INFIX2"); var number = _lexer.Add(@"[0-9]+([.][0-9]*)?i?|[.][0-9]+i?|i", "NUMBER"); var open = _lexer.Add(@"\(", "("); var close = _lexer.Add(@"\)", ")"); var variable = _lexer.Add(@"x", "x"); var constant = _lexer.Add(@"[eπ|pi]", "CONST"); var expr = Patterns.Choice <Expression>("expr"); var factor1 = Patterns.Choice( number.Map(t => Expression.Constant(ParseComplex(t.Text))), constant.Map(t => Expression.Constant(GetConst(t.Text))), variable.Map(t => (Expression)X), Patterns.Seq(open, expr, close, (_, x, __) => x), Patterns.Seq(open, expr, (_, x) => x, "")); var factor2 = Patterns.Choice <Expression>("factor"); factor2.AddRange( factor1, Patterns.Seq(factor2, suffix, (x, t) => Invoke(GetUnary(t.Text), x), "", Priority.Left(20)), Patterns.Seq(factor2, infix0, factor2, (x, t, y) => Invoke(GetBinary(t.Text), x, y), "", Priority.Right(19))); var term2 = Patterns.Choice <Expression>("term2"); var term1 = Patterns.Choice <Expression>("term1"); term1.AddRange(factor2, Patterns.Seq(factor2, term1, (left, right) => Expression.Multiply(left, right), "", Priority.Right(15)), Patterns.Seq(prefix, term2, (t, x) => Invoke(GetUnary(t.Text), x), "", Priority.Right(15)), Patterns.Seq(prefix, suffix, term2, (t, u, x) => Invoke(GetUnary(u.Text), Invoke(GetUnary(t.Text), x)), "", Priority.Right(15)), Patterns.Seq(prefix, infix0, factor2, term2, (t, u, y, x) => Invoke(GetBinary(u.Text), Invoke(GetUnary(t.Text), x), y), "", Priority.Right(15)), Patterns.Seq(prefix2, factor2, term2, (t, y, x) => Invoke(GetBinary(t.Text), x, y), "", Priority.Right(15))); term2.AddRange(term1, Patterns.Seq(infix2, term2, (t, x) => Invoke(GetUnary(t.Text), x), "", Priority.Right(15))); expr.AddRange( term2, Patterns.Seq(expr, infix1, expr, (x, t, y) => Invoke(GetBinary(t.Text), x, y), "", Priority.Left(9)), Patterns.Seq(expr, infix2, expr, (x, t, y) => Invoke(GetBinary(t.Text), x, y), "", Priority.Left(8))); _parser = expr.CreateParser(); }
public void TestStackTracePattern() { var p = new PatternParser(GetLoggingEvent()); var s = p.Parse("%stacktrace{6}"); Assert.AreEqual("log4net.Layout.LayoutSkeleton.Format > log4net.Layout.PatternLayout.Format > log4net.Util.PatternConverter.Format > log4net.Layout.Pattern.PatternLayoutConverter.Convert > log4net.Layout.Pattern.StackTracePatternConverter.Convert > log4net.Core.LoggingEvent.get_LocationInformation", s); }
/// <summary> /// Base constructor for a route /// </summary> /// <param name="httpMethod"></param> /// <param name="pathInfo"></param> private Route(HttpMethod httpMethod, string pathInfo) { Enabled = true; HttpMethod = httpMethod; PathInfo = !string.IsNullOrWhiteSpace(pathInfo) ? pathInfo : string.Empty; PatternKeys = PatternParser.GeneratePatternKeys(PathInfo); PathInfoPattern = PatternParser.GenerateRegEx(PathInfo); }
public void ReadLiteralSection(string source, string expected, int expectedLastIndex) { var literal = new Literal(10, 10, 1, 1, new StringBuilder(source)); int lastIndex; Assert.Equal(expected, PatternParser.ReadLiteralSection(literal, 0, false, out lastIndex)); Assert.Equal(expectedLastIndex, lastIndex); }
/// <summary> /// Create the pattern parser instance /// </summary> /// <param name="pattern">the pattern to parse</param> /// <returns>The <see cref="PatternParser"/> that will format the event</returns> /// <remarks> /// <para> /// Creates the <see cref="PatternParser"/> used to parse the conversion string. Sets the /// global and instance rules on the <see cref="PatternParser"/>. /// </para> /// </remarks> virtual protected PatternParser CreatePatternParser(string pattern) { PatternParser patternParser = new PatternParser(pattern); return(patternParser); }
private void UpdateRotatePattern(string value) { rotatePattern = new PatternParser(rotationFrequency, true); if (rotatePattern.GetNextExecution() != null) { nextRotateAction = Time.time + (float)rotatePattern.GetNextExecution() / 1000; } }
public void Parse_exits_early_when_no_literals_have_been_found() { var literalParserMock = new Mock <ILiteralParser>(); var subject = new PatternParser(literalParserMock.Object); literalParserMock.Setup(x => x.ParseLiterals(It.IsAny <StringBuilder>())).Returns(new Literal[0]); Assert.Empty(subject.Parse(new StringBuilder())); }
public void It_Should_Parse_Values_Unescaped() { var parser = new PatternParser("GET /:token"); var matches = parser.Match("GET /Kevin+Swiber"); Assert.AreEqual("Kevin Swiber", matches[":token"]); }
public void It_Should_Parse_A_Named_Token() { var parser = new PatternParser("GET /person/:last_name"); var matches = parser.Match("GET /person/Swiber"); Assert.AreEqual("Swiber", matches[":last_name"]); }
public void Parse_NullS_ThrowsArgumentNullException() { var parser = Mock.Of <TemplateParser>(); var patternParser = new PatternParser(parser); // ReSharper disable once AssignNullToNotNullAttribute Assert.That(() => patternParser.Parse(null), Throws.ArgumentNullException); }
public void TestMessageAsNamePattern() { var loggingEvent = GetLoggingEvent(); var p = new PatternParser(loggingEvent); p.AddConverter("message-as-name", typeof(MessageAsNamePatternConverter)); var s = p.Parse("%message-as-name{-2}"); Assert.AreEqual("Tw", s, "%message-as-name not registered"); }
internal PatternConverter(string dotNetPattern, RegexOptions options) { DotNetPattern = dotNetPattern; var isIgnorePatternWhitespace = (options & RegexOptions.IgnorePatternWhitespace) == RegexOptions.IgnorePatternWhitespace; var isExpicitCapture = (options & RegexOptions.ExplicitCapture) == RegexOptions.ExplicitCapture; var parser = new PatternParser(dotNetPattern, isIgnorePatternWhitespace, isExpicitCapture); var parseItems = parser.Parse(); patternMap = new PatternMap(parseItems); var builder = new PatternBuilder(dotNetPattern, patternMap); JavaPattern = builder.Build(parseItems); }
protected string PreProcess(LoggingEvent loggingEvent, string renderedString) { var patternParser = new PatternParser(loggingEvent); if (renderedString.Contains("%")) renderedString = patternParser.Parse(renderedString); LogLog.Debug(GetType(), string.Format("RenderedString: {0}", renderedString)); if (_dirtyParsedProperties) { ParseProperties(patternParser); if ( !loggingEvent.Properties.GetKeys() .Any(key => key.StartsWith("IsqsAppender.MetaData.") && key.EndsWith(".Error"))) _dirtyParsedProperties = false; } return renderedString; }
/// <summary> /// Read hyphenation patterns from an XML file. /// </summary> /// <param name="source"> the InputSource for the file </param> /// <exception cref="IOException"> In case the parsing fails </exception> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void loadPatterns(org.xml.sax.InputSource source) throws java.io.IOException public virtual void loadPatterns(InputSource source) { PatternParser pp = new PatternParser(this); ivalues = new TernaryTree(); pp.parse(source); // patterns/values should be now in the tree // let's optimize a bit trimToSize(); vspace.trimToSize(); classmap.trimToSize(); // get rid of the auxiliary map ivalues = null; }
protected abstract void ParseProperties(PatternParser patternParser);