MonoRail/Castle.MonoRail.Framework/Services/UrlParts.cs

   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.Services
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.Collections.Specialized;
  20         using System.Text;
  21         using Castle.MonoRail.Framework.Internal;
  22
  23         /// <summary>
  24         /// Pendent
  25         /// </summary>
  26         public class UrlParts
  27         {
  28                 private readonly StringBuilder url;
  29                 private PathInfoBuilder pathInfoBuilder;
  30                 private PathInfoDictBuilder pathInfoDictBuilder;
  31                 private bool nextPathBelongsToPathInfo;
  32                 private string queryString;
  33                 private NameValueCollection queryStringDict;
  34
  35                 /// <summary>
  36                 /// Initializes a new instance of the <see cref="UrlParts"/> class.
  37                 /// </summary>
  38                 /// <param name="pathPieces">The path pieces.</param>
  39                 public UrlParts(params string[] pathPieces)
  40                 {
  41                         url = new StringBuilder();
  42
  43                         AppendPaths(pathPieces);
  44                 }
  45
  46                 /// <summary>
  47                 /// Pendent
  48                 /// </summary>
  49                 /// <param name="url">The URL.</param>
  50                 /// <returns></returns>
  51                 public static UrlParts Parse(string url)
  52                 {
  53                         if (url == null)
  54                         {
  55                                 throw new ArgumentNullException("url");
  56                         }
  57
  58                         Uri uri = new Uri(url, UriKind.RelativeOrAbsolute);
  59
  60                         if (uri.IsAbsoluteUri)
  61                         {
  62                                 return CreateForAbsolutePath(uri);
  63                         }
  64                         else
  65                         {
  66                                 return CreateForRelativePath(url);
  67                         }
  68                 }
  69
  70                 /// <summary>
  71                 /// Gets the path info builder.
  72                 /// </summary>
  73                 /// <value>The path info.</value>
  74                 public PathInfoBuilder PathInfo
  75                 {
  76                         get
  77                         {
  78                                 if (pathInfoBuilder == null)
  79                                 {
  80                                         pathInfoBuilder = new PathInfoBuilder(this);
  81                                 }
  82                                 return pathInfoBuilder;
  83                         }
  84                 }
  85
  86                 /// <summary>
  87                 /// Gets the path info builder with dictionary api.
  88                 /// </summary>
  89                 /// <value>The path info.</value>
  90                 public PathInfoDictBuilder PathInfoDict
  91                 {
  92                         get
  93                         {
  94                                 if (pathInfoDictBuilder == null)
  95                                 {
  96                                         pathInfoDictBuilder = new PathInfoDictBuilder(this);
  97                                 }
  98                                 return pathInfoDictBuilder;
  99                         }
 100                 }
 101
 102                 /// <summary>
 103                 /// Pendent
 104                 /// </summary>
 105                 /// <param name="queryStringParam">The query string.</param>
 106                 public UrlParts SetQueryString(string queryStringParam)
 107                 {
 108                         if (queryStringParam != null && queryStringParam.StartsWith("?"))
 109                         {
 110                                 queryStringParam = queryStringParam.Substring(1);
 111                         }
 112
 113                         queryString = queryStringParam;
 114
 115                         return this;
 116                 }
 117
 118                 /// <summary>
 119                 /// Pendent
 120                 /// </summary>
 121                 /// <value>The query string.</value>
 122                 public NameValueCollection QueryString
 123                 {
 124                         get
 125                         {
 126                                 if (queryStringDict == null)
 127                                 {
 128                                         queryStringDict = CreateQueryStringNameValueCollection(queryString);
 129                                 }
 130
 131                                 return queryStringDict;
 132                         }
 133                 }
 134
 135                 /// <summary>
 136                 /// Pendent
 137                 /// </summary>
 138                 /// <returns></returns>
 139                 public string QueryStringAsString()
 140                 {
 141                         if (queryStringDict != null)
 142                         {
 143                                 queryString = CommonUtils.BuildQueryString(queryStringDict);
 144                         }
 145
 146                         return queryString;
 147                 }
 148
 149                 /// <summary>
 150                 /// Pendent
 151                 /// </summary>
 152                 /// <returns></returns>
 153                 public UrlParts ConvertPathInfoToDict()
 154                 {
 155                         if (pathInfoBuilder == null)
 156                         {
 157                                 return this;
 158                         }
 159
 160                         PathInfoDict.Parse(pathInfoBuilder.ToString());
 161
 162                         pathInfoBuilder = null;
 163
 164                         return this;
 165                 }
 166
 167                 /// <summary>
 168                 /// Builds the path.
 169                 /// </summary>
 170                 /// <returns></returns>
 171                 public string BuildPath()
 172                 {
 173                         StringBuilder sb = new StringBuilder(url.ToString());
 174
 175                         BuildPathInfo(sb);
 176
 177                         if (queryStringDict != null && queryStringDict.Count != 0)
 178                         {
 179                                 sb.Append('?');
 180                                 sb.Append(QueryStringAsString());
 181                         }
 182                         else if (!string.IsNullOrEmpty(queryString))
 183                         {
 184                                 sb.Append('?');
 185                                 sb.Append(queryString);
 186                         }
 187
 188                         return sb.ToString();
 189                 }
 190
 191                 /// <summary>
 192                 /// Builds the path.
 193                 /// </summary>
 194                 /// <returns></returns>
 195                 public string BuildPathForLink(IServerUtility serverUtiliy)
 196                 {
 197                         StringBuilder sb = new StringBuilder(url.ToString());
 198
 199                         BuildPathInfo(sb);
 200
 201                         if (queryStringDict != null && queryStringDict.Count != 0)
 202                         {
 203                                 sb.Append('?');
 204                                 sb.Append(CommonUtils.BuildQueryString(serverUtiliy, QueryString, true));
 205                         }
 206                         else if (!string.IsNullOrEmpty(queryString))
 207                         {
 208                                 sb.Append('?');
 209                                 sb.Append(serverUtiliy.HtmlEncode(queryString));
 210                         }
 211
 212                         return sb.ToString();
 213                 }
 214
 215                 /// <summary>
 216                 /// Pendent
 217                 /// </summary>
 218                 /// <param name="piece">The piece.</param>
 219                 public UrlParts AppendPath(string piece)
 220                 {
 221                         if (piece.Length != 1 && piece.EndsWith("/"))
 222                         {
 223                                 piece = piece.Substring(0, piece.Length - 1);
 224                         }
 225
 226                         if (nextPathBelongsToPathInfo)
 227                         {
 228                                 PathInfo.Add(piece);
 229                         }
 230                         else
 231                         {
 232                                 if (!piece.StartsWith("/") && HasLastChar && LastChar != '/')
 233                                 {
 234                                         url.Append('/');
 235                                 }
 236
 237                                 url.Append(piece);
 238                         }
 239
 240                         if (HasLastChar && piece.IndexOf('.') != -1) // this is fragile!
 241                         {
 242                                 nextPathBelongsToPathInfo = true;
 243                         }
 244
 245                         return this;
 246                 }
 247
 248                 private void AppendPaths(string[] pieces)
 249                 {
 250                         foreach (string piece in pieces)
 251                         {
 252                                 AppendPath(piece);
 253                         }
 254                 }
 255
 256                 private bool HasLastChar
 257                 {
 258                         get { return url.Length != 0; }
 259                 }
 260
 261                 private char LastChar
 262                 {
 263                         get
 264                         {
 265                                 if (url.Length != 0)
 266                                 {
 267                                         return url[url.Length - 1];
 268                                 }
 269
 270                                 return '\0';
 271                         }
 272                 }
 273
 274                 private void BuildPathInfo(StringBuilder sb)
 275                 {
 276                         if (pathInfoBuilder != null)
 277                         {
 278                                 pathInfoBuilder.Build(sb);
 279                         }
 280                         if (pathInfoDictBuilder != null)
 281                         {
 282                                 pathInfoDictBuilder.Build(sb);
 283                         }
 284                 }
 285
 286                 private static UrlParts CreateForRelativePath(string url)
 287                 {
 288                         string path = url;
 289                         string qs = null;
 290                         string pathInfo = null;
 291
 292                         int queryStringStartIndex = url.IndexOf('?');
 293                         int fileExtIndex = url.IndexOf('.');
 294
 295                         if (queryStringStartIndex != -1)
 296                         {
 297                                 qs = url.Substring(queryStringStartIndex);
 298                                 path = url.Substring(0, queryStringStartIndex);
 299                         }
 300
 301                         if (fileExtIndex != -1)
 302                         {
 303                                 int pathInfoStartIndex = path.IndexOf('/', fileExtIndex);
 304
 305                                 if (pathInfoStartIndex != -1)
 306                                 {
 307                                         pathInfo = path.Substring(pathInfoStartIndex);
 308                                         path = path.Substring(0, pathInfoStartIndex);
 309                                 }
 310                         }
 311
 312                         UrlParts parts = new UrlParts(path);
 313                         parts.SetQueryString(qs);
 314                         parts.PathInfoDict.Parse(pathInfo);
 315
 316                         return parts;
 317                 }
 318
 319                 private static UrlParts CreateForAbsolutePath(Uri uri)
 320                 {
 321                         string host = uri.AbsoluteUri.Substring(0, uri.AbsoluteUri.Length - uri.PathAndQuery.Length);
 322
 323                         UrlParts parts = new UrlParts(host);
 324
 325                         foreach (string segment in uri.Segments)
 326                         {
 327                                 parts.AppendPath(segment);
 328                         }
 329
 330                         parts.ConvertPathInfoToDict();
 331                         parts.SetQueryString(uri.Query);
 332
 333                         return parts;
 334                 }
 335
 336                 private static NameValueCollection CreateQueryStringNameValueCollection(string queryString)
 337                 {
 338                         NameValueCollection coll = new NameValueCollection(StringComparer.InvariantCultureIgnoreCase);
 339
 340                         if (queryString == null)
 341                         {
 342                                 return coll;
 343                         }
 344
 345                         foreach(string valuePair in queryString.Split('&'))
 346                         {
 347                                 string[] pairs = valuePair.Split(new char[] { '=' }, 2);
 348
 349                                 if (pairs.Length == 2)
 350                                 {
 351                                         coll.Add(pairs[0], pairs[1]);
 352                                 }
 353                                 else if (pairs.Length == 1)
 354                                 {
 355                                         coll.Add(pairs[0], string.Empty);
 356                                 }
 357                         }
 358
 359                         return coll;
 360                 }
 361
 362                 /// <summary>
 363                 /// Pendent
 364                 /// </summary>
 365                 public class PathInfoBuilder
 366                 {
 367                         private readonly UrlParts parent;
 368                         private readonly List<string> pieces;
 369
 370                         /// <summary>
 371                         /// Initializes a new instance of the <see cref="PathInfoBuilder"/> class.
 372                         /// </summary>
 373                         /// <param name="parent">The parent.</param>
 374                         public PathInfoBuilder(UrlParts parent)
 375                         {
 376                                 this.parent = parent;
 377                                 pieces = new List<string>();
 378                         }
 379
 380                         /// <summary>
 381                         /// Adds a path info piece.
 382                         /// </summary>
 383                         /// <param name="pathInfoPiece">The path info piece.</param>
 384                         /// <returns></returns>
 385                         public PathInfoBuilder Add(string pathInfoPiece)
 386                         {
 387                                 pieces.Add(pathInfoPiece);
 388                                 return this;
 389                         }
 390
 391                         /// <summary>
 392                         /// Returns to the previous builder context.
 393                         /// </summary>
 394                         public UrlParts Done
 395                         {
 396                                 get { return parent; }
 397                         }
 398
 399                         /// <summary>
 400                         /// Returns a <see cref="T:System.String"></see> that represents the current <see cref="T:System.Object"></see>.
 401                         /// </summary>
 402                         ///
 403                         /// <returns>
 404                         /// A <see cref="T:System.String"></see> that represents the current <see cref="T:System.Object"></see>.
 405                         /// </returns>
 406                         public override string ToString()
 407                         {
 408                                 StringBuilder sb = new StringBuilder();
 409
 410                                 pieces.ForEach(delegate(string piece) { sb.Append(piece).Append('/'); });
 411
 412                                 return sb.ToString();
 413                         }
 414
 415                         /// <summary>
 416                         /// Builds the specified URL.
 417                         /// </summary>
 418                         /// <param name="url">The URL.</param>
 419                         protected internal void Build(StringBuilder url)
 420                         {
 421                                 if (pieces.Count == 0)
 422                                 {
 423                                         return;
 424                                 }
 425
 426                                 foreach(string piece in pieces)
 427                                 {
 428                                         if (url[url.Length - 1] != '/')
 429                                         {
 430                                                 url.Append('/');
 431                                         }
 432
 433                                         url.Append(piece);
 434                                 }
 435                         }
 436                 }
 437
 438                 /// <summary>
 439                 /// Pendent
 440                 /// </summary>
 441                 public class PathInfoDictBuilder
 442                 {
 443                         private readonly UrlParts parent;
 444                         private readonly IDictionary<string, string> parameters;
 445
 446                         /// <summary>
 447                         /// Initializes a new instance of the <see cref="PathInfoBuilder"/> class.
 448                         /// </summary>
 449                         /// <param name="parent">The parent.</param>
 450                         public PathInfoDictBuilder(UrlParts parent)
 451                         {
 452                                 this.parent = parent;
 453                                 parameters = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
 454                         }
 455
 456                         /// <summary>
 457                         /// Gets or sets the <see cref="System.String"/> with the specified key.
 458                         /// </summary>
 459                         /// <value></value>
 460                         public string this[string key]
 461                         {
 462                                 get { return parameters[key]; }
 463                                 set { parameters[key] = value; }
 464                         }
 465
 466                         /// <summary>
 467                         /// Gets the count.
 468                         /// </summary>
 469                         /// <value>The count.</value>
 470                         public int Count
 471                         {
 472                                 get { return parameters.Count; }
 473                         }
 474
 475                         /// <summary>
 476                         /// Adds a path info piece.
 477                         /// </summary>
 478                         /// <param name="key">The key.</param>
 479                         /// <param name="value">The value.</param>
 480                         /// <returns></returns>
 481                         public PathInfoDictBuilder Add(string key, string value)
 482                         {
 483                                 parameters[key] = value;
 484                                 return this;
 485                         }
 486
 487                         /// <summary>
 488                         /// Parses the specified path info.
 489                         /// </summary>
 490                         /// <param name="pathInfo">The path info.</param>
 491                         public void Parse(string pathInfo)
 492                         {
 493                                 if (string.IsNullOrEmpty(pathInfo))
 494                                 {
 495                                         return;
 496                                 }
 497
 498                                 string key = null;
 499
 500                                 foreach(string piece in pathInfo.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries))
 501                                 {
 502                                         if (key == null)
 503                                         {
 504                                                 key = piece;
 505                                         }
 506                                         else
 507                                         {
 508                                                 this[key] = piece;
 509                                                 key = null;
 510                                         }
 511                                 }
 512
 513                                 if (key != null)
 514                                 {
 515                                         this[key] = string.Empty;
 516                                 }
 517
 518                         }
 519
 520                         /// <summary>
 521                         /// Returns to the previous builder context.
 522                         /// </summary>
 523                         public UrlParts Done
 524                         {
 525                                 get { return parent; }
 526                         }
 527
 528                         /// <summary>
 529                         /// Builds the specified URL.
 530                         /// </summary>
 531                         /// <param name="url">The URL.</param>
 532                         protected internal void Build(StringBuilder url)
 533                         {
 534                                 if (parameters.Count == 0)
 535                                 {
 536                                         return;
 537                                 }
 538
 539                                 foreach(KeyValuePair<string, string> pair in parameters)
 540                                 {
 541                                         if (url[url.Length - 1] != '/')
 542                                         {
 543                                                 url.Append('/');
 544                                         }
 545
 546                                         url.Append(pair.Key);
 547
 548                                         if (pair.Value != string.Empty)
 549                                         {
 550                                                 url.Append('/');
 551                                                 url.Append(pair.Value);
 552                                         }
 553                                 }
 554                         }
 555                 }
 556         }
 557 }