public override BlockClosingAction Render(TemplateParser templateParser)
{
var text = templateParser.CurrentInputLine.NormalizedText;
var dictionary = string.Empty;
string componentName;
if (text.Contains("{"))
{
var indexOf = text.IndexOf(' ');
dictionary = text.Substring(indexOf + 2, text.Length - indexOf - 3);
componentName = text.Substring(0, indexOf);
}
else
{
componentName = text;
}
var builder = (CodeDomClassBuilder)templateParser.TemplateClassBuilder;
var dictionaryLocalVariable = AppendCreateDictionaryLocalVariable(dictionary, builder);
builder.CurrentTextWriterVariableName = "x";
var code = string.Format("{0}Component(\"{1}\", {2}, (x) =>",
templateParser.CurrentInputLine.Indent, componentName, dictionaryLocalVariable);
builder.AppendSilentCode(code, false);
builder.BeginCodeBlock();
return () =>
{
builder.EndCodeBlock();
builder.AppendSilentCode(").Render();", false);
builder.CurrentTextWriterVariableName = TemplateClassBuilder.DefaultTextWriterVariableName;
};
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc != null
&& parser != null
&& tc.Count > 3
&& Common.Utility.IsEqual(tc.First.Text, Field.KEY_ELSEIF))
{
if (tc[1].TokenKind == TokenKind.LeftParentheses
&& tc.Last.TokenKind == TokenKind.RightParentheses)
{
ElseifTag tag = new ElseifTag();
TokenCollection coll = new TokenCollection();
coll.Add(tc, 2, tc.Count - 2);
tag.Test = parser.Read(coll);
return tag;
}
else
{
throw new Exception.ParseException(String.Concat("syntax error near if:", tc), tc.First.BeginLine, tc.First.BeginColumn);
}
}
return null;
}
public override void Init (TemplateParser parser, ControlBuilder parentBuilder, Type type,
string tagName, string ID, IDictionary attribs)
{
base.Init (parser, parentBuilder, type, tagName, ID, attribs);
placeHolderID = attribs ["ContentPlaceHolderID"] as string;
if (String.IsNullOrEmpty (placeHolderID))
throw new HttpException ("Missing required 'ContentPlaceHolderID' attribute");
}
public void ParsesSinglePlainTextSegment()
{
var parser = new TemplateParser();
ReadOnlyCollection<TemplateSegment> segments = parser.Parse("foo");
Assert.AreEqual(1, segments.Count);
Assert.AreEqual("foo", segments[0].Content);
Assert.AreEqual(TemplateSegmentType.PlainText, segments[0].Type);
}
public void ExceptionThrownIfValueNotSuppliedForToken()
{
string inputText = "My name is {%=name%}";
var values = new Dictionary<string, string> {{"Something", "Bill Gates"}};
var parser = new TemplateParser();
string outputText = parser.ReplaceTokens(inputText, values);
}
public void ParsesSingleCodeSegment()
{
var parser = new TemplateParser();
ReadOnlyCollection<TemplateSegment> segments = parser.Parse("<% foo %>");
Assert.AreEqual(1, segments.Count);
Assert.AreEqual(" foo ", segments[0].Content);
Assert.AreEqual(TemplateSegmentType.CodeBlock, segments[0].Type);
}
public void CanReplaceManyOfSameToken()
{
string inputText = "My first name is {%=firstname%}. Let me repeat that: {%=firstname%}.";
var values = new Dictionary<string, string> {{"FirstName", "Bill"}};
var parser = new TemplateParser();
string outputText = parser.ReplaceTokens(inputText, values);
Assert.That(outputText, Is.EqualTo("My first name is Bill. Let me repeat that: Bill."));
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc != null
&& tc.Count == 1
&& Common.Utility.IsEqual(tc.First.Text, Field.KEY_END))
{
return new EndTag();
}
return null;
}
public void CanReplaceToken()
{
string inputText = "My name is {%=name%}";
var values = new Dictionary<string, string> {{"Name", "Bill Gates"}};
var parser = new TemplateParser();
string outputText = parser.ReplaceTokens(inputText, values);
Assert.That(outputText, Is.EqualTo("My name is Bill Gates"));
}
public ParameterizedCommandBuilder(IDatabaseEngine engine, string commandTemplate)
{
_engine = engine;
_commandTemplate = commandTemplate;
_parameters = new ParameterCollection();
var parser = new TemplateParser(_commandTemplate);
_parameterNames = parser.Parse();
_commandTextBuilder = new StringBuilder(_commandTemplate);
_command = _engine.GetCommand();
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns>标签</returns>
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc != null
&& tc.Count == 1
&& tc.First.TokenKind == TokenKind.TextData)
{
VariableTag tag = new VariableTag();
tag.Name = tc.First.Text;
return tag;
}
return null;
}
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc.Count == 1
&& (tc.First.Text == "true" || tc.First.Text == "false"))
{
BooleanTag tag = new BooleanTag();
tag.Value = tc.First.Text == "true";
return tag;
}
return null;
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc != null
&& parser != null
&& tc.Count == 1
&& Common.ParserHelpers.IsEqual(tc.First.Text, Field.KEY_ELSE))
{
return new ElseTag();
}
return null;
}
public override void Parse(TemplateContext context, System.IO.TextWriter writer)
{
String path = this.Path.Parse(context).ToString();
if (!String.IsNullOrEmpty(path))
{
TemplateLexer lexer = new TemplateLexer(Resources.LoadResource(context.Paths.ToArray(), path, context.Charset));
TemplateParser parser = new TemplateParser(lexer.Parse(), context.Analyzer);
while (parser.MoveNext())
{
parser.Current.Parse(context, writer);
}
}
}
public virtual void Render(TextWriter writer)
{
if (!String.IsNullOrEmpty(TemplateContent))
{
TemplateLexer lexer = new TemplateLexer(TemplateContent);
TemplateParser parser = new TemplateParser(lexer.Parse(), this.Context.Analyzer);
while (parser.MoveNext())
{
parser.Current.Parse(this.Context, writer);
}
}
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc != null
&& parser != null
&& tc.Count > 3
&& Common.Utility.IsEqual(tc.First.Text, Field.KEY_IF))
{
if (tc[1].TokenKind == TokenKind.LeftParentheses
&& tc.Last.TokenKind == TokenKind.RightParentheses)
{
IfTag tag = new IfTag();
ElseifTag t = new ElseifTag();
TokenCollection coll = new TokenCollection();
coll.Add(tc, 2, tc.Count - 2);
t.Test = parser.Read(coll);
t.FirstToken = coll.First;
//t.LastToken = coll.Last;
tag.AddChild(t);
while (parser.MoveNext())
{
if (parser.Current is EndTag)
{
tag.AddChild(parser.Current);
return tag;
}
else if (parser.Current is ElseifTag
|| parser.Current is ElseTag)
{
tag.AddChild(parser.Current);
}
else
{
tag.Children[tag.Children.Count - 1].AddChild(parser.Current);
}
}
throw new Exception.ParseException(String.Concat("if is not properly closed by a end tag:", tc), tc.First.BeginLine, tc.First.BeginColumn);
}
else
{
throw new Exception.ParseException(String.Concat("syntax error near if:", tc), tc.First.BeginLine, tc.First.BeginColumn);
}
}
return null;
}
public static void Main(string[] args)
{
if (args.Length > 0) {
Console.WriteLine ("Parsing " + args [0]);
Console.WriteLine ("----------------------------------");
double start = unixts();
TemplateParser parser = new TemplateParser ();
parser.parse (args [0]);
double end = unixts ();
Console.WriteLine ("----------------------------------");
Console.WriteLine("Parsed in: " + (end - start).ToString() + " seconds");
} else {
Console.WriteLine ("No input specified");
}
}
public override BlockClosingAction Render(TemplateParser templateParser)
{
var sectionName = templateParser.CurrentInputLine.NormalizedText;
var code = string.Format("{0}).AddSection(\"{1}\", x =>", templateParser.CurrentInputLine.Indent,
sectionName);
templateParser.TemplateClassBuilder.EndCodeBlock();
templateParser.TemplateClassBuilder.Indent();
templateParser.TemplateClassBuilder.AppendSilentCode(code, false);
templateParser.TemplateClassBuilder.BeginCodeBlock();
return templateParser.TemplateClassBuilder.Unindent;
}
public void CanReplaceMultipleTokens()
{
string inputText = "My first name is {%=firstname%}. My second name is {%=secondname%}.";
var values = new Dictionary<string, string>
{
{"FirstName", "Bill"},
{"SecondName", "Gates"}
};
var parser = new TemplateParser();
string outputText = parser.ReplaceTokens(inputText, values);
Assert.That(outputText, Is.EqualTo("My first name is Bill. My second name is Gates."));
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc!=null
&& tc.Count == 3
&& tc.First.TokenKind == TokenKind.StringStart
&& tc[1].TokenKind == TokenKind.String
&& tc.Last.TokenKind == TokenKind.StringEnd
)
{
StringTag tag = new StringTag();
tag.Value = tc[1].Text;
return tag;
}
return null;
}
public string Generate(bool minify = false)
{
string proxyTemplate = ResourceHelper.GetEmbeddedResource(PROXY_TEMPLATE_RESOURCE_KEY);
var serviceModel = GetServiceModelFromService(Service);
TemplateParser template = new TemplateParser(proxyTemplate, serviceModel, SyntaxOptions.JavaScriptSyntax);
template.Parse();
var source = template.ToString();
if (minify)
source = JavaScriptCompressor.Compress(template.ToString());
return source;
}
/// <summary>
/// 呈现内容
/// </summary>
/// <param name="writer">TextWriter</param>
public virtual void Render(System.IO.TextWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
Tag[] collection;
//缓存功能，待添加
if (this._content == null)
{
writer.Write(this.TemplateContent);
return;
}
if (!String.IsNullOrEmpty(this._content))
{
TemplateLexer lexer = new TemplateLexer(this._content);
TemplateParser parser = new TemplateParser(lexer.Parse());
collection = parser.ToArray();
}
else
{
collection = new Tag[0];
}
if (collection.Length > 0)
{
for (Int32 i = 0; i < collection.Length; i++)
{
try
{
collection[i].Parse(this._context, writer);
}
catch (Exception.TemplateException e)
{
ThrowException(e, collection[i],writer);
}
catch (System.Exception e)
{
System.Exception baseException = e.GetBaseException();
Exception.ParseException ex = new Exception.ParseException(baseException.Message, baseException);
ThrowException(ex, collection[i], writer);
}
}
}
}
protected override void Given() {
var assemblies = new string[] { "ScheduMail.API" };
var namespaces = new string[] { "ScheduMail.API.Contracts", "System.Linq","System.Xml.Linq" };
sut = new TemplateParser(assemblies, namespaces);
var promotion = @"<promotions>
<promotion>
<product>Widget 1</product>
<discount>20%</discount>
<expires>this month</expires>
</promotion>
</promotions>";
var userData = XElement.Parse(promotion);
templateData = new User
{
Title = "Mrs.",
FirstName = "Nancy",
Surname = "Davilio",
EmailAddress = "*****@*****.**",
Data = userData
};
template = @"
<viewdata User = ""ScheduMail.API.Contracts.User""/>
<var promotion = ""(from p in User.Data.Elements('promotion')
select new {
Product = (string)p.Element('product'),
Discount = (string)p.Element('discount'),
Expires = (string)p.Element('expires')
}).FirstOrDefault()""/>
Dear ${User.FirstName},
We are excited to tell you about our latest offerings. Due to your long standing account with us we would
like to give you a sneak peak at our latest product before commercial release. The ${promotion.Product} is the
best thing since slice bread and for a limited time only we would like to extend you a discount of ${promotion.Discount}.
Act soon because the offer is only good until the end of ${promotion.Expires}.
Happy Buying!
Click <a href='http://somecompany.com/unsubscribe?user=${User.EmailAddress}'>here</a> to unsubscribe from out mailings.
";
}
public void ParsesMultiLineTextSegment()
{
const string Template =
@"foo
bar";
var parser = new TemplateParser();
ReadOnlyCollection<TemplateSegment> segments = parser.Parse(Template);
const string ExpectedSegmentContent =
@"foo
bar";
Assert.AreEqual(1, segments.Count);
Assert.AreEqual(ExpectedSegmentContent, segments[0].Content);
Assert.AreEqual(TemplateSegmentType.PlainText, segments[0].Type);
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (Common.Utility.IsEqual(tc.First.Text, Field.KEY_LOAD))
{
if (tc != null
&& parser != null
&& tc.Count > 2
&& (tc[1].TokenKind == TokenKind.LeftParentheses)
&& tc.Last.TokenKind == TokenKind.RightParentheses)
{
LoadTag tag = new LoadTag();
tag.Path = parser.Read(new TokenCollection(tc, 2, tc.Count - 2));
return tag;
}
}
return null;
}
protected void Render(TemplateContext context, StringBuilder writer)
{
if (!String.IsNullOrEmpty(this.TemplateContent))
{
TemplateLexer lexer = new TemplateLexer(this.TemplateContent);
TemplateParser parser = new TemplateParser(lexer.Parse());
while (parser.MoveNext())
{
//try
//{
parser.Current.Parse(context, writer);
//}
//catch (Exception.TemplateException e)
//{
// if (context.ThrowExceptions)
// {
// throw e;
// }
// else
// {
// context.AddError(e);
// writer.Append(parser.Current.ToString());
// }
//}
//catch (System.Exception e)
//{
// System.Exception baseException = e.GetBaseException();
// Exception.ParseException ex = new Exception.ParseException(baseException.Message, baseException);
// if (context.ThrowExceptions)
// {
// throw ex;
// }
// else
// {
// context.AddError(ex);
// writer.Append(parser.Current.ToString());
// }
//}
}
}
}
public Tag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc.Count == 1 && tc.First.TokenKind == TokenKind.Number)
{
NumberTag tag = new NumberTag();
if (tc.First.Text.IndexOf('.') == -1)
{
tag.Value = Int32.Parse(tc.First.Text);
}
else
{
tag.Value = Double.Parse(tc.First.Text);
}
return tag;
}
return null;
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public static Tag Parse(TemplateParser parser, TokenCollection tc)
{
Tag t;
for (Int32 i = 0; i < collection.Count; i++)
{
t = collection[i].Parse(parser, tc);
if (t != null)
{
t.FirstToken = tc.First;
if (t.Children.Count == 0 || (t.LastToken = t.Children[t.Children.Count - 1].LastToken ?? t.Children[t.Children.Count - 1].FirstToken) == null || tc.Last.CompareTo(t.LastToken) > 0)
{
t.LastToken = tc.Last;
}
return t;
}
}
return null;
}
protected override void Given()
{
var assemblies = new string[] { "ScheduMail.API" };
var namespaces = new string[] { "ScheduMail.API.Contracts" };
sut = new TemplateParser(assemblies,namespaces);
templateData = new User
{
Title = "Mrs.",
FirstName = "Nancy",
Surname = "Davilio",
EmailAddress = "*****@*****.**"
};
template = @"
<viewdata User = ""ScheduMail.API.Contracts.User""/>
Name: ${User.Title} ${User.FirstName} ${User.Surname}";
}
public override void Init (TemplateParser parser, ControlBuilder parentBuilder, Type type,
string tagName, string ID, IDictionary attribs)
{
string id = null, s;
foreach (object k in attribs.Keys) {
s = k as string;
if (String.IsNullOrEmpty (s))
continue;
if (String.Compare (s, "id", StringComparison.OrdinalIgnoreCase) == 0) {
id = attribs [s] as string;
break;
}
}
base.Init (parser, parentBuilder, type, tagName, ID, attribs);
MasterPageParser mpp = parser as MasterPageParser;
if (mpp == null || String.IsNullOrEmpty (id))
return;
mpp.AddContentPlaceHolderId (id);
}
public void InvalidTemplate_InvalidParameterNameWithOpenBracketThrows()
{
ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("{a}/{a{aa}/{z}"),
"In a route parameter, '{' and '}' must be escaped with '{{' and '}}'. (Parameter 'routeTemplate')");
}
public PathRouteValuesTransform(string pattern, TemplateBinderFactory binderFactory)
{
_ = pattern ?? throw new ArgumentNullException(nameof(pattern));
_binderFactory = binderFactory ?? throw new ArgumentNullException(nameof(binderFactory));
_template = TemplateParser.Parse(pattern);
}
public void InvalidTemplate_WithCatchAllNotAtTheEndThrows()
{
ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("foo/{p1}/{*p2}/{p3}"),
"A catch-all parameter can only appear as the last segment of the route template. (Parameter 'routeTemplate')");
}
public List <TemplateDefinition> GetTemplates()
{
return(TemplateParser.ParseAll(WorkDir));
}
// /instances/{instanceId}/raiseEvent/{eventName}
private static TemplateMatcher GetInstanceRaiseEventRoute()
{
return(new TemplateMatcher(TemplateParser.Parse($"{InstancesControllerSegment}{{{InstanceIdRouteParameter}?}}/{RaiseEventOperation}/{{{EventNameRouteParameter}}}"), new RouteValueDictionary()));
}
public void InvalidTemplate_WithRepeatedParameter()
{
var ex = ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("{Controller}.mvc/{id}/{controller}"),
"The route parameter name 'controller' appears more than one time in the route template. (Parameter 'routeTemplate')");
}
private static RouteTemplate ParseRouteTemplate(string template)
{
var _constraintResolver = GetConstraintResolver();
return(TemplateParser.Parse(template));
}
public void ThrowsArgumentNullException(string input)
{
Assert.Throws <ArgumentNullException>(() => TemplateParser.Parse(input));
}
public void ThrowsTemplateParserException(string input)
{
Assert.Throws <TemplateParserException>(() => TemplateParser.Parse(input));
}
public void ParseAndPrint(string input)
{
var template = TemplateParser.Parse(input);
Assert.Equal(input, template.Rebuild());
}
private List <Endpoint> CreateEndpoints()
{
List <Endpoint> endpoints = new List <Endpoint>();
foreach (var action in _actions.ActionDescriptors.Items)
{
if (action.AttributeRouteInfo == null)
{
// In traditional conventional routing setup, the routes defined by a user have a static order
// defined by how they are added into the list. We would like to maintain the same order when building
// up the endpoints too.
//
// Start with an order of '1' for conventional routes as attribute routes have a default order of '0'.
// This is for scenarios dealing with migrating existing Router based code to Global Routing world.
var conventionalRouteOrder = 0;
// Check each of the conventional templates to see if the action would be reachable
// If the action and template are compatible then create an endpoint with the
// area/controller/action parameter parts replaced with literals
//
// e.g. {controller}/{action} with HomeController.Index and HomeController.Login
// would result in endpoints:
// - Home/Index
// - Home/Login
foreach (var endpointInfo in ConventionalEndpointInfos)
{
var actionRouteValues = action.RouteValues;
var endpointTemplateSegments = endpointInfo.ParsedTemplate.Segments;
if (MatchRouteValue(action, endpointInfo, "Area") &&
MatchRouteValue(action, endpointInfo, "Controller") &&
MatchRouteValue(action, endpointInfo, "Action"))
{
var newEndpointTemplate = TemplateParser.Parse(endpointInfo.Template);
for (var i = 0; i < newEndpointTemplate.Segments.Count; i++)
{
// Check if the template can be shortened because the remaining parameters are optional
//
// e.g. Matching template {controller=Home}/{action=Index}/{id?} against HomeController.Index
// can resolve to the following endpoints:
// - /Home/Index/{id?}
// - /Home
// - /
if (UseDefaultValuePlusRemainingSegementsOptional(i, action, endpointInfo, newEndpointTemplate))
{
var subTemplate = RouteTemplateWriter.ToString(newEndpointTemplate.Segments.Take(i));
var subEndpoint = CreateEndpoint(
action,
endpointInfo.Name,
subTemplate,
endpointInfo.Defaults,
++conventionalRouteOrder,
endpointInfo,
suppressLinkGeneration: false);
endpoints.Add(subEndpoint);
}
var segment = newEndpointTemplate.Segments[i];
for (var j = 0; j < segment.Parts.Count; j++)
{
var part = segment.Parts[j];
if (part.IsParameter && IsMvcParameter(part.Name))
{
// Replace parameter with literal value
segment.Parts[j] = TemplatePart.CreateLiteral(action.RouteValues[part.Name]);
}
}
}
var newTemplate = RouteTemplateWriter.ToString(newEndpointTemplate.Segments);
var endpoint = CreateEndpoint(
action,
endpointInfo.Name,
newTemplate,
endpointInfo.Defaults,
++conventionalRouteOrder,
endpointInfo,
suppressLinkGeneration: false);
endpoints.Add(endpoint);
}
}
}
else
{
var endpoint = CreateEndpoint(
action,
action.AttributeRouteInfo.Name,
action.AttributeRouteInfo.Template,
nonInlineDefaults: null,
action.AttributeRouteInfo.Order,
action.AttributeRouteInfo,
suppressLinkGeneration: action.AttributeRouteInfo.SuppressLinkGeneration);
endpoints.Add(endpoint);
}
}
return(endpoints);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app)
{
//The order of these things are important.
app.Use(async(context, next) =>
{
var path1 = "/page/10";
RouteTemplate template = TemplateParser.Parse("page/{id}");
var templateMatcher = new TemplateMatcher(template, new RouteValueDictionary());
var routeData = new RouteValueDictionary();//This dictionary will be populated by the parameter template part (in this case "title")
var isMatch1 = templateMatcher.TryMatch(path1, routeData);
await context.Response.WriteAsync($"{path1} is match? {isMatch1} => route data value for 'id' is {routeData["id"]} \n");
await next.Invoke();
});
app.Use(async(context, next) =>
{
var path = "/page/gone/a";
RouteTemplate template = TemplateParser.Parse("page/gone/{id}");
var templateMatcher = new TemplateMatcher(template, new RouteValueDictionary());
var routeData = new RouteValueDictionary();//This dictionary will be populated by the parameter template part (in this case "title")
var isMatch1 = templateMatcher.TryMatch(path, routeData);
await context.Response.WriteAsync($"{path} is match? {isMatch1} => route data value for 'id' is {routeData["id"]} \n");
});
var routes = new RouteBuilder(app);
routes.MapGet("", (context) => {
return(context.Response.WriteAsync($"Home Page. Try /good or /good/morning."));
});
routes.MapGet("{*path}", (context) => {
var routeData = context.GetRouteData();
var path = routeData.Values;
return(context.Response.WriteAsync($"Path: {string.Join(",", path)}"));
});
app.UseRouter(routes.Build());
var defaultHandler = new RouteHandler(context =>
{
var routeValues = context.GetRouteData().Values;
context.Response.Headers.Add("Content-Type", "text/html");
return(context.Response.WriteAsync(
$@"
<html><head><body>
<h1>Routing</h1>
Click on the following links to see the changes
<ul>
<li><a href=""/try"">/try</a></li>
<li><a href=""/do/33"">/do/33</a></li>
<li><a href=""/values/11/again"">/values/11/again</a></li>
</ul>
<br/>
Path: {context.Request.Path}.
<br/>
<br/>
Route values from context.GetRouteData().Values: {string.Join(", ", routeValues)}
<br/>
Note:
<br/>
context.GetRouteData() returns nothing regardless what kind of path you are requesting, e.g. '/hello-x'
</body></html>
"));
});
app.UseRouter(defaultHandler);
app.Use(async(context, next) =>
{
context.Items["Greeting"] = "Hello World";
await next.Invoke();
await context.Response.WriteAsync($"{context.Items["Goodbye"]}\n");
});
app.Use(async(context, next) =>
{
await context.Response.WriteAsync($"{context.Items["Greeting"]}\n");
context.Items["Goodbye"] = "Goodbye for now";
});
app.UseStaticFiles();
}
public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, IDictionary attribs)
{
base.Init(parser, parentBuilder, type, tagName, id, attribs);
_typeName = (string)attribs["typename"];
}
private TemplateMatcher CreateMatcher(string template, object defaults = null)
{
return(new TemplateMatcher(
TemplateParser.Parse(template),
new RouteValueDictionary(defaults)));
}
public void InvalidTemplate_SameParameterTwiceAndOneCatchAllThrows()
{
ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("{aaa}/{*AAA}"),
"The route parameter name 'AAA' appears more than one time in the route template. (Parameter 'routeTemplate')");
}
public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, System.Collections.IDictionary attribs)
{
attribs["TemplateIndex"] = Interlocked.Increment(ref templateIndex);
base.Init(parser, parentBuilder, type, tagName, id, attribs);
}
public void InvalidTemplate_CannotHaveMoreThanOneCatchAll()
{
ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("{*p1}/{*p2}"),
"A catch-all parameter can only appear as the last segment of the route template. (Parameter 'routeTemplate')");
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public ITag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc == null ||
parser == null)
{
return(null);
}
//支持写法：简写格式：
//常规格式：
if (tc.Count > 5 &&
Utility.IsEqual(tc.First.Text, Field.KEY_SET) &&
tc[1].TokenKind == TokenKind.LeftParentheses &&
tc[3].Text == "=" &&
tc.Last.TokenKind == TokenKind.RightParentheses)
{
SetTag tag = new SetTag();
tag.Name = tc[2].Text;
tag.Value = parser.Read(tc[4, -1]);
return(tag);
}
if (tc.Count == 2 &&
tc.First.TokenKind == TokenKind.TextData &&
tc.Last.TokenKind == TokenKind.Operator &&
(tc.Last.Text == "++" || tc.Last.Text == "--"))
{
SetTag tag = new SetTag();
tag.Name = tc.First.Text;
ExpressionTag c = new ExpressionTag();
c.AddChild(new VariableTag()
{
FirstToken = tc.First,
Name = tc.First.Text
});
c.AddChild(new TextTag()
{
FirstToken = new Token(TokenKind.Operator, tc.Last.Text[0].ToString())
});
c.AddChild(new NumberTag()
{
Value = 1,
FirstToken = new Token(TokenKind.Number, "1")
});
tag.Value = c;
return(tag);
}
if (tc.Count > 2 &&
tc.First.TokenKind == TokenKind.TextData &&
tc[1].Text == "=")
{
SetTag tag = new SetTag();
tag.Name = tc.First.Text;
tag.Value = parser.Read(tc[2, tc.Count]);
return(tag);
}
return(null);
}
/// <summary>
/// 分析标签
/// </summary>
/// <param name="parser">TemplateParser</param>
/// <param name="tc">Token集合</param>
/// <returns></returns>
public ITag Parse(TemplateParser parser, TokenCollection tc)
{
if (tc != null &&
parser != null &&
tc.Count > 2)
{
List <ITag> tags = new List <ITag>();
TokenCollection[] tcs = tc.Split(0, tc.Count, TokenKind.Dot, TokenKind.Operator);
bool isLogical = false;
if (tcs.Length == 1)
{
return(null);
}
for (int i = 0; i < tcs.Length; i++)
{
if (tcs[i].Count == 1 && tcs[i][0].TokenKind == TokenKind.Dot)
{
if (tags.Count == 0 || i == tcs[i].Count - 1 || (tcs[i + 1].Count == 1 && (tcs[i + 1][0].TokenKind == TokenKind.Dot || tcs[i + 1][0].TokenKind == TokenKind.Operator)))
{
throw new Exception.ParseException(string.Concat("syntax error near .:", tc), tcs[i][0].BeginLine, tcs[i][0].BeginColumn);
}
if (tags[tags.Count - 1] is ReferenceTag)
{
tags[tags.Count - 1].AddChild(parser.Read(tcs[i + 1]));
}
else
{
ReferenceTag t = new ReferenceTag();
t.AddChild(tags[tags.Count - 1]);
t.AddChild(parser.Read(tcs[i + 1]));
tags[tags.Count - 1] = t;
}
i++;
}
else if (tcs[i].Count == 1 && tcs[i][0].TokenKind == TokenKind.Operator)
{
tags.Add(new OperatorTag(tcs[i][0]));
Operator op = Dynamic.OperatorConvert.Parse(tcs[i][0].Text);
switch (op)
{
case Operator.Or:
case Operator.And:
case Operator.LessThan:
case Operator.LessThanOrEqual:
case Operator.Equal:
case Operator.GreaterThan:
case Operator.GreaterThanOrEqual:
case Operator.NotEqual:
isLogical = true;
break;
}
}
else if (tcs[i][0].TokenKind == TokenKind.LeftBracket)
{
if (tags[tags.Count - 1] is ReferenceTag)
{
tags[tags.Count - 1].AddChild(parser.Read(tcs[i]));
}
else
{
if (tags.Count == 0)
{
throw new Exception.ParseException(string.Concat("syntax error near [:", tc), tcs[i][0].BeginLine, tcs[i][0].BeginColumn);
}
ReferenceTag t = new ReferenceTag();
t.AddChild(tags[tags.Count - 1]);
t.AddChild(parser.Read(tcs[i]));
tags[tags.Count - 1] = t;
}
}
else if (tcs[i].Count > 0)
{
if (tcs[i].First.TokenKind == TokenKind.LeftParentheses && tcs[i].Last.TokenKind == TokenKind.RightParentheses)
{
tcs[i].RemoveAt(0);
tcs[i].RemoveAt(tcs[i].Count - 1);
}
tags.Add(parser.Read(tcs[i]));
}
}
if (tags.Count == 1)
{
return(tags[0]);
}
if (tags.Count > 1)
{
var list = new List <List <ITag> >();
ITag t;
if (isLogical)
{
t = new LogicTag();
var arr = Analysis(tags, new List <Operator>(new Operator[] { Operator.And, Operator.Or }));
if (arr.Length == 1)
{
return(arr[0]);
}
AddRange(t, arr);
}
else
{
t = new ArithmeticTag();
for (int i = 0; i < tags.Count; i++)
{
t.AddChild(tags[i]);
}
}
tags.Clear();
return(t);
}
}
return(null);
}
public void EmptyText()
{
var result = new TemplateParser("").ToList();
Assert.Empty(result);
}
private static void RunTest(
string template,
RouteValueDictionary defaults,
RouteValueDictionary ambientValues,
RouteValueDictionary values,
string expected)
{
// Arrange
var binder = new TemplateBinder(
UrlEncoder.Default,
new DefaultObjectPoolProvider().Create(new UriBuilderContextPooledObjectPolicy()),
TemplateParser.Parse(template),
defaults);
// Act & Assert
var result = binder.GetValues(ambientValues, values);
if (result == null)
{
if (expected == null)
{
return;
}
else
{
Assert.NotNull(result);
}
}
var boundTemplate = binder.BindValues(result.AcceptedValues);
if (expected == null)
{
Assert.Null(boundTemplate);
}
else
{
Assert.NotNull(boundTemplate);
// We want to chop off the query string and compare that using an unordered comparison
var expectedParts = new PathAndQuery(expected);
var actualParts = new PathAndQuery(boundTemplate);
Assert.Equal(expectedParts.Path, actualParts.Path);
if (expectedParts.Parameters == null)
{
Assert.Null(actualParts.Parameters);
}
else
{
Assert.Equal(expectedParts.Parameters.Count, actualParts.Parameters.Count);
foreach (var kvp in expectedParts.Parameters)
{
string value;
Assert.True(actualParts.Parameters.TryGetValue(kvp.Key, out value));
Assert.Equal(kvp.Value, value);
}
}
}
}
public void ParseNominal(string input)
{
var template = TemplateParser.Parse(input);
Assert.False(template.IsPositional);
}
public RouteTable Build() => new RouteTable(_routeTemplates
.Select(rt => new RouteEntry(TemplateParser.ParseTemplate(rt.Item1), rt.Item2))
.OrderBy(id => id, RouteTable.RoutePrecedence)
.ToArray());
public void InvalidTemplate_CatchAllMarkedOptional()
{
ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("{a}/{*b?}"),
"A catch-all parameter cannot be marked optional. (Parameter 'routeTemplate')");
}
public void InvalidTemplate_WithRepeatedParameter()
{
var ex = ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("{Controller}.mvc/{id}/{controller}", _inlineConstraintResolver),
"The route parameter name 'controller' appears more than one time in the route template." + Environment.NewLine + "Parameter name: routeTemplate");
}
public void InvalidTemplate_CannotContainQuestionMark()
{
ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("foor?bar"),
"The literal section 'foor?bar' is invalid. Literal sections cannot contain the '?' character. (Parameter 'routeTemplate')");
}
//this method sets context for this util class, this is called for every iteration
//and for every iteration output list is reseted
public void setContext(TemplateParser parser)
{
outputStringList = new List <String>();
this.templateParser = parser;
this.exportCore = (SmartExportTemplates.SmartExport)Globals.Instance.GetData(Constants.GE_EXPORT_CORE);
}
public void InvalidTemplate_CannotStartWithTilde()
{
ExceptionAssert.Throws <ArgumentException>(
() => TemplateParser.Parse("~foo"),
"The route template cannot start with a '~' character unless followed by a '/'. (Parameter 'routeTemplate')");
}
public ContentProcessorWithDoc(TemplateParser parser)
{
this.templateParser = parser;
}
public void ParseName(string input, string name)
{
var template = TemplateParser.Parse(input);
Assert.Equal(name, template.Holes[0].Name);
}
