?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
More working tests.
[castle.git] / MonoRail / Castle.MonoRail.Framework / Routing / PatternRoute.cs
blob203cfb0f2b6b82b28654c036833f508630c0b3cd
1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 namespace Castle.MonoRail.Framework.Routing
16 {
17 using System;
18 using System.Collections;
19 using System.Collections.Generic;
20 using System.Diagnostics;
21 using System.Text;
22 using System.Text.RegularExpressions;
23 using Castle.MonoRail.Framework.Services.Utils;
24 using Descriptors;
25
26 /// <summary>
27 /// Pendent
28 /// </summary>
29 [DebuggerDisplay("PatternRoute {pattern}")]
30 public class PatternRoute : IRoutingRule
31 {
32 private readonly string name;
33 private readonly string pattern;
34 private readonly List<DefaultNode> nodes = new List<DefaultNode>();
35 private readonly Dictionary<string, string> defaults = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
36
37 /// <summary>
38 /// Initializes a new instance of the <see cref="PatternRoute"/> class.
39 /// </summary>
40 /// <param name="pattern">The pattern.</param>
41 public PatternRoute(string pattern)
42 {
43 this.pattern = pattern;
44 CreatePatternNodes();
45 }
46
47 /// <summary>
48 /// Initializes a new instance of the <see cref="PatternRoute"/> class.
49 /// </summary>
50 /// <param name="name">The route name.</param>
51 /// <param name="pattern">The pattern.</param>
52 public PatternRoute(string name, string pattern) : this(pattern)
53 {
54 this.name = name;
55 }
56
57 /// <summary>
58 /// Gets the name of the route.
59 /// </summary>
60 /// <value>The name of the route.</value>
61 public string RouteName
62 {
63 get { return name; }
64 }
65
66 /// <summary>
67 /// Pendent
68 /// </summary>
69 /// <param name="hostname">The hostname.</param>
70 /// <param name="virtualPath">The virtual path.</param>
71 /// <param name="parameters">The parameters.</param>
72 /// <returns></returns>
73 public string CreateUrl(string hostname, string virtualPath, IDictionary parameters)
74 {
75 StringBuilder text = new StringBuilder(virtualPath);
76 IList<string> checkedParameters = new List<string>();
77
78 bool hasNamed = false;
79
80 foreach(DefaultNode node in nodes)
81 {
82 AppendSlashOrDot(text, node);
83
84 if (node.name == null)
85 {
86 text.Append(node.start);
87 }
88 else
89 {
90 hasNamed = true;
91 checkedParameters.Add(node.name);
92
93 object value = parameters[node.name];
94 string valAsString = value != null ? value.ToString() : null;
95
96 if (string.IsNullOrEmpty(valAsString))
97 {
98 if (!node.optional)
99 {
100 return null;
101 }
102 else
103 {
104 break;
105 }
106 }
107 else
108 {
109 if (node.hasRestriction && !node.Accepts(value.ToString()))
110 {
111 return null;
112 }
113
114 if (node.optional && StringComparer.InvariantCultureIgnoreCase.Compare(node.DefaultVal, value.ToString()) == 0)
115 {
116 break; // end as there can't be more required nodes after an optional one
117 }
118
119 text.Append(value.ToString());
120 }
121 }
122 }
123
124 // Validate that default parameters match parameters passed into to create url.
125 foreach (KeyValuePair<string, string> defaultParameter in defaults)
126 {
127 // Skip parameters we already checked.
128 if(checkedParameters.Contains(defaultParameter.Key))
129 {
130 continue;
131 }
132
133 object value = parameters[defaultParameter.Key];
134 string valAsString = value != null ? value.ToString() : null;
135 if(!string.IsNullOrEmpty(valAsString) && !defaultParameter.Value.Equals(valAsString, StringComparison.OrdinalIgnoreCase))
136 {
137 return null;
138 }
139 }
140
141 if (text.Length == 0 || text[text.Length - 1] == '/' || text[text.Length -1] == '.')
142 {
143 text.Length = text.Length - 1;
144 }
145
146 return hasNamed ? text.ToString() : null;
147 }
148
149 /// <summary>
150 /// Determines if the specified URL matches the
151 /// routing rule.
152 /// </summary>
153 /// <param name="url">The URL.</param>
154 /// <param name="context">The context</param>
155 /// <param name="match">The match.</param>
156 /// <returns></returns>
157 public bool Matches(string url, IRouteContext context, RouteMatch match)
158 {
159 string[] parts = url.Split(new char[] {'/', '.'}, StringSplitOptions.RemoveEmptyEntries);
160 int index = 0;
161
162 foreach(DefaultNode node in nodes)
163 {
164 string part = index < parts.Length ? parts[index] : null;
165
166 if (!node.Matches(part, match))
167 {
168 return false;
169 }
170
171 index++;
172 }
173
174 foreach(KeyValuePair<string, string> pair in defaults)
175 {
176 if (!match.Parameters.ContainsKey(pair.Key))
177 {
178 match.Parameters.Add(pair.Key, pair.Value);
179 }
180 }
181
182 return true;
183 }
184
185 private void CreatePatternNodes()
186 {
187 string[] parts = pattern.Split(new char[] {'/'}, StringSplitOptions.RemoveEmptyEntries);
188
189 foreach(string part in parts)
190 {
191 string[] subparts = part.Split(new char[] { '.' }, 2, StringSplitOptions.RemoveEmptyEntries);
192
193 if (subparts.Length == 2)
194 {
195 bool afterDot = false;
196
197 foreach(string subpart in subparts)
198 {
199 if (subpart.Contains("["))
200 {
201 nodes.Add(CreateNamedOptionalNode(subpart, afterDot));
202 }
203 else
204 {
205 nodes.Add(CreateRequiredNode(subpart, afterDot));
206 }
207
208 afterDot = true;
209 }
210 }
211 else
212 {
213 if (part.Contains("["))
214 {
215 nodes.Add(CreateNamedOptionalNode(part, false));
216 }
217 else
218 {
219 nodes.Add(CreateRequiredNode(part, false));
220 }
221 }
222 }
223 }
224
225 /// <summary>
226 /// Adds a default entry.
227 /// </summary>
228 /// <param name="key">The key.</param>
229 /// <param name="value">The value.</param>
230 public void AddDefault(string key, string value)
231 {
232 defaults[key] = value;
233 }
234
235 private DefaultNode CreateNamedOptionalNode(string part, bool afterDot)
236 {
237 return new DefaultNode(part, true, afterDot);
238 }
239
240 private DefaultNode CreateRequiredNode(string part, bool afterDot)
241 {
242 return new DefaultNode(part, false, afterDot);
243 }
244
245 private static void AppendSlashOrDot(StringBuilder text, DefaultNode node)
246 {
247 if (text.Length == 0 || text[text.Length - 1] != '/')
248 {
249 if (node.afterDot)
250 {
251 text.Append('.');
252 }
253 else
254 {
255 text.Append('/');
256 }
257 }
258 }
259
260 #region DefaultNode
261
262 [DebuggerDisplay("Node {name} Opt: {optional} default: {defaultVal} Regular exp: {exp}")]
263 private class DefaultNode
264 {
265 public readonly string name, start, end;
266 public readonly bool optional;
267 public readonly bool afterDot;
268 public bool hasRestriction;
269 private string defaultVal;
270 private string[] acceptedTokens;
271 private Regex exp;
272 private string acceptedRegex;
273
274 public DefaultNode(string part, bool optional, bool afterDot)
275 {
276 this.optional = optional;
277 this.afterDot = afterDot;
278 int indexStart = part.IndexOfAny(new char[] {'<', '['});
279 int indexEndStart = -1;
280
281 if (indexStart != -1)
282 {
283 indexEndStart = part.IndexOfAny(new char[] {'>', ']'}, indexStart);
284 name = part.Substring(indexStart + 1, indexEndStart - indexStart - 1);
285 }
286
287 if (indexStart != -1)
288 {
289 start = part.Substring(0, indexStart);
290 }
291 else
292 {
293 start = part;
294 }
295
296 end = "";
297
298 if (indexEndStart != -1)
299 {
300 end = part.Substring(indexEndStart + 1);
301 }
302
303 ReBuildRegularExpression();
304 }
305
306 private void ReBuildRegularExpression()
307 {
308 RegexOptions options = RegexOptions.Compiled | RegexOptions.Singleline;
309
310 if (name != null)
311 {
312 exp = new Regex("^" + CharClass(start) + "(" + GetExpression() + ")" + CharClass(end) + "$", options);
313 }
314 else
315 {
316 exp = new Regex("^(" + CharClass(start) + ")$");
317 }
318 }
319
320 private string GetExpression()
321 {
322 if (!string.IsNullOrEmpty(acceptedRegex))
323 {
324 return acceptedRegex;
325 }
326 else if (acceptedTokens != null && acceptedTokens.Length != 0)
327 {
328 StringBuilder text = new StringBuilder();
329
330 foreach(string token in acceptedTokens)
331 {
332 if (text.Length != 0)
333 {
334 text.Append("|");
335 }
336 text.Append("(");
337 text.Append(CharClass(token));
338 text.Append(")");
339 }
340
341 return text.ToString();
342 }
343 else
344 {
345 return "[a-zA-Z,_,0-9,-]+";
346 }
347 }
348
349 public bool Matches(string part, RouteMatch match)
350 {
351 if (part == null)
352 {
353 if (optional)
354 {
355 if (name != null)
356 {
357 match.AddNamed(name, defaultVal);
358 }
359 return true;
360 }
361 else
362 {
363 return false;
364 }
365 }
366
367 Match regExpMatch = exp.Match(part);
368
369 if (regExpMatch.Success)
370 {
371 if (name != null)
372 {
373 match.AddNamed(name, part);
374 }
375
376 return true;
377 }
378
379 return false;
380 }
381
382 public void AcceptsAnyOf(string[] names)
383 {
384 hasRestriction = true;
385 acceptedTokens = names;
386 ReBuildRegularExpression();
387 }
388
389 public string DefaultVal
390 {
391 get { return defaultVal; }
392 set { defaultVal = value; }
393 }
394
395 public bool AcceptsIntOnly
396 {
397 set
398 {
399 AcceptsRegex("[0-9]+");
400 }
401 }
402
403 public bool AcceptsGuidsOnly
404 {
405 set
406 {
407 AcceptsRegex("[A-Fa-f0-9]{32}|" +
408 "({|\\()?[A-Fa-f0-9]{8}-([A-Fa-f0-9]{4}-){3}[A-Fa-f0-9]{12}(}|\\))?|" +
409 "({)?[0xA-Fa-f0-9]{3,10}(, {0,1}[0xA-Fa-f0-9]{3,6}){2}, {0,1}({)([0xA-Fa-f0-9]{3,4}, {0,1}){7}[0xA-Fa-f0-9]{3,4}(}})");
410 }
411 }
412
413 public void AcceptsRegex(string regex)
414 {
415 hasRestriction = true;
416 acceptedRegex = regex;
417 ReBuildRegularExpression();
418 }
419
420 public bool Accepts(string val)
421 {
422 Match regExpMatch = exp.Match(val);
423
424 return (regExpMatch.Success);
425 }
426 }
427
428 #endregion
429
430 /// <summary>
431 /// Configures the default for the named pattern part.
432 /// </summary>
433 /// <param name="namedPatternPart">The named pattern part.</param>
434 /// <returns></returns>
435 public DefaultConfigurer DefaultFor(string namedPatternPart)
436 {
437 return new DefaultConfigurer(this, namedPatternPart);
438 }
439
440 /// <summary>
441 /// Configures the default for the named pattern part.
442 /// </summary>
443 /// <returns></returns>
444 public DefaultConfigurer DefaultForController()
445 {
446 return new DefaultConfigurer(this, "controller");
447 }
448
449 /// <summary>
450 /// Configures the default for the named pattern part.
451 /// </summary>
452 /// <returns></returns>
453 public DefaultConfigurer DefaultForAction()
454 {
455 return new DefaultConfigurer(this, "action");
456 }
457
458 /// <summary>
459 /// Configures the default for the named pattern part.
460 /// </summary>
461 /// <returns></returns>
462 public DefaultConfigurer DefaultForArea()
463 {
464 return new DefaultConfigurer(this, "area");
465 }
466
467 /// <summary>
468 /// Configures restrictions for the named pattern part.
469 /// </summary>
470 /// <param name="namedPatternPart">The named pattern part.</param>
471 /// <returns></returns>
472 public RestrictionConfigurer Restrict(string namedPatternPart)
473 {
474 return new RestrictionConfigurer(this, namedPatternPart);
475 }
476
477 /// <summary>
478 /// Pendent
479 /// </summary>
480 public class RestrictionConfigurer
481 {
482 private readonly PatternRoute route;
483 private readonly DefaultNode targetNode;
484
485 /// <summary>
486 /// Initializes a new instance of the <see cref="RestrictionConfigurer"/> class.
487 /// </summary>
488 /// <param name="route">The route.</param>
489 /// <param name="namedPatternPart">The named pattern part.</param>
490 public RestrictionConfigurer(PatternRoute route, string namedPatternPart)
491 {
492 this.route = route;
493 targetNode = route.GetNamedNode(namedPatternPart, true);
494 }
495
496 /// <summary>
497 /// Restricts this named pattern part to only accept one of the
498 /// strings passed in.
499 /// </summary>
500 /// <param name="validNames">The valid names.</param>
501 /// <returns></returns>
502 public PatternRoute AnyOf(params string[] validNames)
503 {
504 targetNode.AcceptsAnyOf(validNames);
505 return route;
506 }
507
508 /// <summary>
509 /// Restricts this named pattern part to only accept integers.
510 /// </summary>
511 /// <value>The valid integer.</value>
512 public PatternRoute ValidInteger
513 {
514 get
515 {
516 targetNode.AcceptsIntOnly = true;
517 return route;
518 }
519 }
520
521 /// <summary>
522 /// Restricts this named pattern part to only accept guids.
523 /// </summary>
524 public PatternRoute ValidGuid
525 {
526 get
527 {
528 targetNode.AcceptsGuidsOnly = true;
529 return route;
530 }
531 }
532
533 /// <summary>
534 /// Restricts this named pattern part to only accept strings
535 /// matching the regular expression passed in.
536 /// </summary>
537 /// <param name="regex"></param>
538 /// <returns></returns>
539 public PatternRoute ValidRegex(string regex)
540 {
541 targetNode.AcceptsRegex(regex);
542 return route;
543 }
544 }
545
546 /// <summary>
547 /// Pendent
548 /// </summary>
549 public class DefaultConfigurer
550 {
551 private readonly PatternRoute route;
552 private readonly string namedPatternPart;
553 private readonly DefaultNode targetNode;
554
555 /// <summary>
556 /// Initializes a new instance of the <see cref="DefaultConfigurer"/> class.
557 /// </summary>
558 /// <param name="patternRoute">The pattern route.</param>
559 /// <param name="namedPatternPart">The named pattern part.</param>
560 public DefaultConfigurer(PatternRoute patternRoute, string namedPatternPart)
561 {
562 route = patternRoute;
563 this.namedPatternPart = namedPatternPart;
564 targetNode = route.GetNamedNode(namedPatternPart, false);
565 }
566
567 /// <summary>
568 /// Sets the default value for this named pattern part.
569 /// </summary>
570 /// <returns></returns>
571 public PatternRoute Is<T>() where T : class, IController
572 {
573 ControllerDescriptor desc = ControllerInspectionUtil.Inspect(typeof(T));
574 if (targetNode != null)
575 {
576 targetNode.DefaultVal = desc.Name;
577 }
578 route.AddDefault(namedPatternPart, desc.Name);
579 return route;
580 }
581
582 /// <summary>
583 /// Sets the default value for this named pattern part.
584 /// </summary>
585 /// <param name="value">The value.</param>
586 /// <returns></returns>
587 public PatternRoute Is(string value)
588 {
589 if (targetNode != null)
590 {
591 targetNode.DefaultVal = value;
592 }
593 route.AddDefault(namedPatternPart, value);
594 return route;
595 }
596
597 /// <summary>
598 /// Sets the default value as empty for this named pattern part.
599 /// </summary>
600 /// <value>The is empty.</value>
601 public PatternRoute IsEmpty
602 {
603 get { return Is(string.Empty); }
604 }
605 }
606
607 // See http://weblogs.asp.net/justin_rogers/archive/2004/03/20/93379.aspx
608 private static string CharClass(string content)
609 {
610 if (content == String.Empty)
611 {
612 return string.Empty;
613 }
614
615 StringBuilder builder = new StringBuilder();
616
617 foreach(char c in content)
618 {
619 if (char.IsLetter(c))
620 {
621 builder.AppendFormat("[{0}{1}]", char.ToLower(c), char.ToUpper(c));
622 }
623 else
624 {
625 builder.Append(c);
626 }
627 }
628
629 return builder.ToString();
630 }
631
632 /// <summary>
633 /// Gets the named node.
634 /// </summary>
635 /// <param name="part">The part.</param>
636 /// <param name="mustFind">if set to <c>true</c> [must find].</param>
637 /// <returns></returns>
638 private DefaultNode GetNamedNode(string part, bool mustFind)
639 {
640 DefaultNode found = nodes.Find(delegate(DefaultNode node) { return node.name == part; });
641
642 if (found == null && mustFind)
643 {
644 throw new ArgumentException("Could not find pattern node for name " + part);
645 }
646
647 return found;
648 }
649 }
650 }
Git import of castle svn