mcs/class/System.ServiceModel.Web/System/UriTemplate.cs

   1 //
   2 // UriTemplate.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto  <atsushi@ximian.com>
   6 //
   7 // Copyright (C) 2008 Novell, Inc (http://www.novell.com)
   8 //
   9 // Permission is hereby granted, free of charge, to any person obtaining
  10 // a copy of this software and associated documentation files (the
  11 // "Software"), to deal in the Software without restriction, including
  12 // without limitation the rights to use, copy, modify, merge, publish,
  13 // distribute, sublicense, and/or sell copies of the Software, and to
  14 // permit persons to whom the Software is furnished to do so, subject to
  15 // the following conditions:
  16 //
  17 // The above copyright notice and this permission notice shall be
  18 // included in all copies or substantial portions of the Software.
  19 //
  20 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  24 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  25 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  26 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27 //
  28 using System;
  29 using System.Collections.Generic;
  30 using System.Collections.ObjectModel;
  31 using System.Collections.Specialized;
  32 using System.Globalization;
  33 using System.Text;
  34
  35 #if NET_2_1
  36 using NameValueCollection = System.Object;
  37 #endif
  38
  39 namespace System
  40 {
  41         public class UriTemplate
  42         {
  43                 static readonly ReadOnlyCollection<string> empty_strings = new ReadOnlyCollection<string> (new string [0]);
  44
  45                 string template;
  46                 ReadOnlyCollection<string> path, query;
  47                 Dictionary<string,string> query_params = new Dictionary<string,string> ();
  48
  49                 public UriTemplate (string template)
  50                         : this (template, false)
  51                 {
  52                 }
  53
  54                 public UriTemplate (string template, IDictionary<string,string> additionalDefaults)
  55                         : this (template, false, additionalDefaults)
  56                 {
  57                 }
  58
  59                 public UriTemplate (string template, bool ignoreTrailingSlash)
  60                         : this (template, ignoreTrailingSlash, null)
  61                 {
  62                 }
  63
  64                 public UriTemplate (string template, bool ignoreTrailingSlash, IDictionary<string,string> additionalDefaults)
  65                 {
  66                         if (template == null)
  67                                 throw new ArgumentNullException ("template");
  68                         this.template = template;
  69                         IgnoreTrailingSlash = ignoreTrailingSlash;
  70                         Defaults = new Dictionary<string,string> (StringComparer.InvariantCultureIgnoreCase);
  71                         if (additionalDefaults != null)
  72                                 foreach (var pair in additionalDefaults)
  73                                         Defaults.Add (pair.Key, pair.Value);
  74
  75                         string p = template;
  76                         // Trim scheme, host name and port if exist.
  77                         if (CultureInfo.InvariantCulture.CompareInfo.IsPrefix (template, "http")) {
  78                                 int idx = template.IndexOf ('/', 8); // after "http://x" or "https://"
  79                                 if (idx > 0)
  80                                         p = template.Substring (idx);
  81                         }
  82                         int q = p.IndexOf ('?');
  83                         path = ParsePathTemplate (p, 0, q >= 0 ? q : p.Length);
  84                         if (q >= 0)
  85                                 ParseQueryTemplate (p, q, p.Length);
  86                         else
  87                                 query = empty_strings;
  88                 }
  89
  90                 public bool IgnoreTrailingSlash { get; private set; }
  91
  92                 public IDictionary<string,string> Defaults { get; private set; }
  93
  94                 public ReadOnlyCollection<string> PathSegmentVariableNames {
  95                         get { return path; }
  96                 }
  97
  98                 public ReadOnlyCollection<string> QueryValueVariableNames {
  99                         get { return query; }
 100                 }
 101
 102                 public override string ToString ()
 103                 {
 104                         return template;
 105                 }
 106
 107                 // Bind
 108
 109 #if !NET_2_1
 110                 public Uri BindByName (Uri baseAddress, NameValueCollection parameters)
 111                 {
 112                         return BindByName (baseAddress, parameters, false);
 113                 }
 114
 115                 public Uri BindByName (Uri baseAddress, NameValueCollection parameters, bool omitDefaults)
 116                 {
 117                         return BindByNameCommon (baseAddress, parameters, null, omitDefaults);
 118                 }
 119 #endif
 120
 121                 public Uri BindByName (Uri baseAddress, IDictionary<string,string> parameters)
 122                 {
 123                         return BindByName (baseAddress, parameters, false);
 124                 }
 125
 126                 public Uri BindByName (Uri baseAddress, IDictionary<string,string> parameters, bool omitDefaults)
 127                 {
 128                         return BindByNameCommon (baseAddress, null, parameters, omitDefaults);
 129                 }
 130
 131                 string TrimRenderedUri (StringBuilder sb)
 132                 {
 133                         if (sb.Length == 0)
 134                                 return String.Empty;
 135
 136                         if (sb [0] == '/')
 137                                 sb.Remove (0, 1);
 138
 139                         return sb.ToString ();
 140                 }
 141
 142                 Uri BindByNameCommon (Uri baseAddress, NameValueCollection nvc, IDictionary<string,string> dic, bool omitDefaults)
 143                 {
 144                         CheckBaseAddress (baseAddress);
 145
 146                         // take care of case sensitivity.
 147                         if (dic != null)
 148                                 dic = new Dictionary<string,string> (dic, StringComparer.OrdinalIgnoreCase);
 149
 150                         int src = 0;
 151                         StringBuilder sb = new StringBuilder (template.Length);
 152                         BindByName (ref src, sb, path, nvc, dic, omitDefaults, false);
 153                         BindByName (ref src, sb, query, nvc, dic, omitDefaults, true);
 154                         sb.Append (template.Substring (src));
 155                         return new Uri (baseAddress.ToString () + TrimRenderedUri (sb));
 156                 }
 157
 158                 void BindByName (ref int src, StringBuilder sb, ReadOnlyCollection<string> names, NameValueCollection nvc, IDictionary<string,string> dic, bool omitDefaults, bool query)
 159                 {
 160                         foreach (string name in names) {
 161                                 int s = template.IndexOf ('{', src);
 162                                 int e = template.IndexOf ('}', s + 1);
 163 #if NET_2_1
 164                                 string value = null;
 165 #else
 166                                 string value = nvc != null ? nvc [name] : null;
 167 #endif
 168                                 if (dic != null)
 169                                         dic.TryGetValue (name, out value);
 170                                 if (query) {
 171                                         if (value != null || (!omitDefaults && Defaults.TryGetValue (name, out value))) {
 172                                                 sb.Append (template.Substring (src, s - src));
 173                                                 sb.Append (value);
 174                                         }
 175                                 } else
 176                                         if (value == null && (omitDefaults || !Defaults.TryGetValue(name, out value)))
 177                                                 throw new ArgumentException(string.Format("The argument name value collection does not contain non-nul vaalue for '{0}'", name), "parameters");
 178                                         else {
 179                                                 sb.Append (template.Substring (src, s - src));
 180                                                 sb.Append (value);
 181                                         }
 182                                 src = e + 1;
 183                         }
 184                 }
 185
 186                 public Uri BindByPosition (Uri baseAddress, params string [] values)
 187                 {
 188                         CheckBaseAddress (baseAddress);
 189
 190                         if (values.Length != path.Count + query.Count)
 191                                 throw new FormatException (String.Format ("Template '{0}' contains {1} parameters but the argument values to bind are {2}", template, path.Count + query.Count, values.Length));
 192
 193                         int src = 0, index = 0;
 194                         StringBuilder sb = new StringBuilder (template.Length);
 195                         BindByPosition (ref src, sb, path, values, ref index);
 196                         BindByPosition (ref src, sb, query, values, ref index);
 197                         sb.Append (template.Substring (src));
 198                         return new Uri (baseAddress.ToString () + TrimRenderedUri (sb));
 199                 }
 200
 201                 void BindByPosition (ref int src, StringBuilder sb, ReadOnlyCollection<string> names, string [] values, ref int index)
 202                 {
 203                         for (int i = 0; i < names.Count; i++) {
 204                                 int s = template.IndexOf ('{', src);
 205                                 int e = template.IndexOf ('}', s + 1);
 206                                 sb.Append (template.Substring (src, s - src));
 207                                 string value = values [index++];
 208                                 if (value == null)
 209                                         throw new FormatException (String.Format ("The argument value collection contains null at {0}", index - 1));
 210                                 sb.Append (value);
 211                                 src = e + 1;
 212                         }
 213                 }
 214
 215                 // Compare
 216
 217                 public bool IsEquivalentTo (UriTemplate other)
 218                 {
 219                         if (other == null)
 220                                 throw new ArgumentNullException ("other");
 221                         return this.template == other.template;
 222                 }
 223
 224                 // Match
 225
 226                 static readonly char [] slashSep = {'/'};
 227
 228                 public UriTemplateMatch Match (Uri baseAddress, Uri candidate)
 229                 {
 230                         CheckBaseAddress (baseAddress);
 231                         if (candidate == null)
 232                                 throw new ArgumentNullException ("candidate");
 233
 234                         var us = baseAddress.LocalPath;
 235                         if (us [us.Length - 1] != '/')
 236                                 baseAddress = new Uri (baseAddress.GetComponents (UriComponents.SchemeAndServer | UriComponents.Path, UriFormat.Unescaped) + '/' + baseAddress.Query, baseAddress.IsAbsoluteUri ? UriKind.Absolute : UriKind.RelativeOrAbsolute);
 237                         if (IgnoreTrailingSlash) {
 238                                 us = candidate.LocalPath;
 239                                 if (us.Length > 0 && us [us.Length - 1] != '/')
 240                                         candidate = new Uri(candidate.GetComponents (UriComponents.SchemeAndServer | UriComponents.Path, UriFormat.Unescaped) + '/' + candidate.Query, candidate.IsAbsoluteUri ? UriKind.Absolute : UriKind.RelativeOrAbsolute);
 241                         }
 242
 243                         if (Uri.Compare (baseAddress, candidate, UriComponents.StrongAuthority, UriFormat.SafeUnescaped, StringComparison.Ordinal) != 0)
 244                                 return null;
 245
 246                         int i = 0, c = 0;
 247                         UriTemplateMatch m = new UriTemplateMatch ();
 248                         m.BaseUri = baseAddress;
 249                         m.Template = this;
 250                         m.RequestUri = candidate;
 251                         var vc = m.BoundVariables;
 252
 253                         string cp = Uri.UnescapeDataString (baseAddress.MakeRelativeUri (candidate).ToString ());
 254                         if (IgnoreTrailingSlash && cp [cp.Length - 1] == '/')
 255                                 cp = cp.Substring (0, cp.Length - 1);
 256
 257                         int tEndCp = cp.IndexOf ('?');
 258                         if (tEndCp >= 0)
 259                                 cp = cp.Substring (0, tEndCp);
 260
 261                         if (template.Length > 0 && template [0] == '/')
 262                                 i++;
 263                         if (cp.Length > 0 && cp [0] == '/')
 264                                 c++;
 265
 266                         foreach (string name in path) {
 267                                 int n = StringIndexOf (template, '{' + name + '}', i);
 268                                 if (String.CompareOrdinal (cp, c, template, i, n - i) != 0)
 269                                         return null; // doesn't match before current template part.
 270                                 c += n - i;
 271                                 i = n + 2 + name.Length;
 272                                 int ce = cp.IndexOf ('/', c);
 273                                 if (ce < 0)
 274                                         ce = cp.Length;
 275                                 string value = cp.Substring (c, ce - c);
 276                                 if (value.Length == 0)
 277                                         return null; // empty => mismatch
 278                                 vc [name] = value;
 279                                 m.RelativePathSegments.Add (value);
 280                                 c += value.Length;
 281                         }
 282                         int tEnd = template.IndexOf ('?');
 283                         if (tEnd < 0)
 284                                 tEnd = template.Length;
 285                         bool wild = (template [tEnd - 1] == '*');
 286                         if (wild)
 287                                 tEnd--;
 288                         if (!wild && (cp.Length - c) != (tEnd - i) ||
 289                             String.CompareOrdinal (cp, c, template, i, tEnd - i) != 0)
 290                                 return null; // suffix doesn't match
 291                         if (wild) {
 292                                 c += tEnd - i;
 293                                 foreach (var pe in cp.Substring (c).Split (slashSep, StringSplitOptions.RemoveEmptyEntries))
 294                                         m.WildcardPathSegments.Add (pe);
 295                         }
 296                         if (candidate.Query.Length == 0)
 297                                 return m;
 298
 299
 300                         string [] parameters = Uri.UnescapeDataString (candidate.Query.Substring (1)).Split ('&'); // chop first '?'
 301                         foreach (string parameter in parameters) {
 302                                 string [] pair = parameter.Split ('=');
 303                                 m.QueryParameters.Add (pair [0], pair [1]);
 304                                 if (!query_params.ContainsKey (pair [0]))
 305                                         continue;
 306                                 string templateName = query_params [pair [0]];
 307                                 vc.Add (templateName, pair [1]);
 308                         }
 309
 310                         return m;
 311                 }
 312
 313                 int StringIndexOf (string s, string pattern, int idx)
 314                 {
 315                         return CultureInfo.InvariantCulture.CompareInfo.IndexOf (s, pattern, idx, CompareOptions.OrdinalIgnoreCase);
 316                 }
 317
 318                 // Helpers
 319
 320                 void CheckBaseAddress (Uri baseAddress)
 321                 {
 322                         if (baseAddress == null)
 323                                 throw new ArgumentNullException ("baseAddress");
 324                         if (!baseAddress.IsAbsoluteUri)
 325                                 throw new ArgumentException ("baseAddress must be an absolute URI.");
 326                         if (baseAddress.Scheme == Uri.UriSchemeHttp ||
 327                             baseAddress.Scheme == Uri.UriSchemeHttps)
 328                                 return;
 329                         throw new ArgumentException ("baseAddress scheme must be either http or https.");
 330                 }
 331
 332                 ReadOnlyCollection<string> ParsePathTemplate (string template, int index, int end)
 333                 {
 334                         int widx = template.IndexOf ('*', index, end);
 335                         if (widx >= 0 && widx != end - 1)
 336                                 throw new FormatException (String.Format ("Wildcard in UriTemplate is valid only if it is placed at the last part of the path: '{0}'", template));
 337                         List<string> list = null;
 338                         int prevEnd = -2;
 339                         for (int i = index; i <= end; ) {
 340                                 i = template.IndexOf ('{', i);
 341                                 if (i < 0 || i > end)
 342                                         break;
 343                                 if (i == prevEnd + 1)
 344                                         throw new ArgumentException (String.Format ("The UriTemplate '{0}' contains adjacent templated segments, which is invalid.", template));
 345                                 int e = template.IndexOf ('}', i + 1);
 346                                 if (e < 0 || i > end)
 347                                         throw new FormatException (String.Format ("Missing '}' in URI template '{0}'", template));
 348                                 prevEnd = e;
 349                                 if (list == null)
 350                                         list = new List<string> ();
 351                                 i++;
 352                                 string name = template.Substring (i, e - i);
 353                                 string uname = name.ToUpper (CultureInfo.InvariantCulture);
 354                                 if (list.Contains (uname) || (path != null && path.Contains (uname)))
 355                                         throw new InvalidOperationException (String.Format ("The URI template string contains duplicate template item {{'{0}'}}", name));
 356                                 list.Add (uname);
 357                                 i = e + 1;
 358                         }
 359                         return list != null ? new ReadOnlyCollection<string> (list) : empty_strings;
 360                 }
 361
 362                 void ParseQueryTemplate (string template, int index, int end)
 363                 {
 364                         // template starts with '?'
 365                         string [] parameters = template.Substring (index + 1, end - index - 1).Split ('&');
 366                         List<string> list = null;
 367                         foreach (string parameter in parameters) {
 368                                 string [] pair = parameter.Split ('=');
 369                                 if (pair.Length != 2)
 370                                         throw new FormatException ("Invalid URI query string format");
 371                                 string pname = pair [0];
 372                                 string pvalue = pair [1];
 373                                 if (pvalue.Length >= 2 && pvalue [0] == '{' && pvalue [pvalue.Length - 1] == '}') {
 374                                         string ptemplate = pvalue.Substring (1, pvalue.Length - 2).ToUpper (CultureInfo.InvariantCulture);
 375                                         query_params.Add (pname, ptemplate);
 376                                         if (list == null)
 377                                                 list = new List<string> ();
 378                                         if (list.Contains (ptemplate) || (path != null && path.Contains (ptemplate)))
 379                                                 throw new InvalidOperationException (String.Format ("The URI template string contains duplicate template item {{'{0}'}}", pvalue));
 380                                         list.Add (ptemplate);
 381                                 }
 382                         }
 383                         query = list != null ? new ReadOnlyCollection<string> (list.ToArray ()) : empty_strings;
 384                 }
 385         }
 386 }