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