Make VirtualDirectory redirect if the directory-path does not end with a tailing slash.

pkg/http_server/lib/src/virtual_directory.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of http_server;
 
+
+// Used for signal a directory redirecting, where a tailing slash is missing.
+class _DirectoryRedirect {
+  const _DirectoryRedirect();
+}
+
 /**
  * A [VirtualDirectory] can serve files and directory-listing from a root path,
  * to [HttpRequest]s.
  *
  * The [VirtualDirectory] providing secure handling of request uris and
  * file-system links, correct mime-types and custom error pages.
  */
 class VirtualDirectory {
   final String root;
 
@@ skipping 42 matching lines @@
   void serveRequest(HttpRequest request) {
     _locateResource('.', request.uri.pathSegments.iterator..moveNext())
         .then((entity) {
           if (entity == null) {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
             return;
           }
           if (entity is File) {
             serveFile(entity, request);
           } else if (entity is Directory) {
-            _serveDirectory(entity, request);
+            if (allowDirectoryListing) {
+              _serveDirectory(entity, request);
+            } else {
+              _serveErrorPage(HttpStatus.NOT_FOUND, request);
+            }
+          } else if (entity is _DirectoryRedirect) {
+            request.response.redirect(Uri.parse('${request.uri}/'),

[Søren Gjesse, 2014/01/06 13:18:08]

According to RFC 2616 section 14.30 the redirect location should be an absolute
URI.

[Anders Johnsen, 2014/01/09 09:32:25]

Done.

+                                      status: HttpStatus.MOVED_PERMANENTLY);
           } else {
             _serveErrorPage(HttpStatus.NOT_FOUND, request);
           }
         });
   }
 
   /**
    * Set the [callback] to override the default directory listing. The
    * [callback] will be called with the [Directory] to be listed and the
    * [HttpRequest].
    */
   void set directoryHandler(void callback(Directory dir, HttpRequest request)) {
     _dirCallback = callback;
   }
 
   /**
    * Set the [callback] to override the error page handler. When [callback] is
    * invoked, the `statusCode` property of the response is set.
    */
   void set errorPageHandler(void callback(HttpRequest request)) {
     _errorCallback = callback;
   }
 
-  Future<FileSystemEntity> _locateResource(String path,
-                                           Iterator<String> segments) {
+  Future _locateResource(String path, Iterator<String> segments) {
     // Don't allow navigating up paths.
     if (segments.current == "..") return new Future.value(null);
     path = normalize(path);
     // If we jail to root, the relative path can never go up.
     if (jailRoot && split(path).first == "..") return new Future.value(null);
-    String fullPath({bool endSlash: false}) {
-      var p = join(root, path);
-      if (endSlash && path != ".") p = "$p$separator";
-      return p;
-    }
+    String fullPath() => join(root, path);
     return FileSystemEntity.type(fullPath(), followLinks: false)
         .then((type) {
           switch (type) {
             case FileSystemEntityType.FILE:
               if (segments.current == null) {
                 return new File(fullPath());
               }
               break;
 
             case FileSystemEntityType.DIRECTORY:
-              if (segments.current == null) {
-                if (allowDirectoryListing) {
-                  return new Directory(fullPath(endSlash: true));
-                }
+              String dirFullPath() => '${fullPath()}$separator';
+              var current = segments.current;
+              if (current == null) {
+                if (path == '.') return new Directory(dirFullPath());
+                return const _DirectoryRedirect();
+              }
+              bool hasNext = segments.moveNext();
+              if (!hasNext && current == "") {
+                return new Directory(dirFullPath());
               } else {
-                if (_invalidPathRegExp.hasMatch(segments.current)) break;
-                return _locateResource(join(path, segments.current),
-                                       segments..moveNext());
+                if (_invalidPathRegExp.hasMatch(current)) break;
+                return _locateResource(join(path, current), segments);
               }
               break;
 
             case FileSystemEntityType.LINK:
               if (followLinks) {
                 return new Link(fullPath()).target()
                     .then((target) {
                       String targetPath = normalize(target);
                       if (isAbsolute(targetPath)) {
                         // If we jail to root, the path can never be absolute.
@@ skipping 248 matching lines @@
 
   Future close() => new Future.value();
 
   void setMimeType(var bytes) {
     var mimeType = lookupMimeType(path, headerBytes: bytes);
     if (mimeType != null) {
       response.headers.contentType = ContentType.parse(mimeType);
     }
   }
 }