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);
