Changeset 672

Timestamp:

2008-10-06 15:02:40 (5 years ago)

Author:

bruno

Message:

DirectoryRouter?: introduce support for double extensions.

File:

• trunk/modules/kauri-routing/kauri-routing-impl/src/main/java/org/kauriproject/routing/impl/components/DirectoryRouter.java (modified) (6 diffs)

trunk/modules/kauri-routing/kauri-routing-impl/src/main/java/org/kauriproject/routing/impl/components/DirectoryRouter.java

@@ -12 +12 @@
 import org.kauriproject.runtime.rapi.ModuleSource.Resource;
 import org.kauriproject.template.service.TemplateService;
+import org.apache.commons.logging.LogFactory;
+import org.apache.commons.logging.Log;
 
 import java.util.*;
+import java.util.regex.Pattern;
+import java.util.regex.Matcher;
 
 /**
@@ -26 +30 @@
     private TemplateService templateService;
     private Context restletContext;
+    private Log log = LogFactory.getLog(getClass());
+
+    private static Pattern DOUBLE_EXT = Pattern.compile("^(.*)\\.([^.]*)\\.([^.]+)$");
 
     public DirectoryRouter(String path, Context restletContext, KauriModule module, TemplateService templateService) {
@@ -41 +48 @@
 
     private void build() {
-        List<String> paths = new ArrayList<String>();
-        scan(path, "", paths);
+        List<Page> pages = new ArrayList<Page>();
+        scan(path, "", pages);
 
         // The "best" matching algorithm of Restlet's Router cannot meaningfully
@@ -49 +56 @@
         // therefore we sort the paths on beforehand on length, since Restlet
         // will use the first route with best/maximal score.
-        Collections.sort(paths, new Comparator<String>() {
-            public int compare(String o1, String o2) {
-                if (o1.length() == o2.length())
+        Collections.sort(pages, new Comparator<Page>() {
+            public int compare(Page p1, Page p2) {
+                if (p1.patternSignificantLength == p2.patternSignificantLength)
                     return 0;
                 else
-                    return o1.length() < o2.length() ? 1 : -1;
+                    return p1.patternSignificantLength < p2.patternSignificantLength ? 1 : -1;
             }
         });
 
         Router router = new Router();
-        for (String path : paths) {
-            String templatePath = "kms:/" + this. path + path;
-            router.attach(path, new TemplateRestlet(templateService, restletContext, templatePath));
+        for (Page page : pages) {
+            if (log.isDebugEnabled()) {
+                log.info("Attaching URI pattern " + page.uriPattern + " for template " + page.templatePath);
+            }
+            router.attach(page.uriPattern, new TemplateRestlet(templateService, restletContext, page.templatePath));
         }
         this.router = router;
     }
 
-    private void scan(String parent, String mountPath, Collection<String> allPaths) {
+    private void scan(String parent, String mountPath, Collection<Page> pages) {
         Resource res = moduleSource.getResource(parent);
 
@@ -74 +83 @@
             Resource childRes = moduleSource.getResource(childPath);
             if (childRes.isDirectory()) {
-                scan(childPath, mountPath + "/" + child, allPaths);
+                scan(childPath, mountPath + "/" + child, pages);
             } else {
-                allPaths.add(mountPath + "/" + child);
+                pages.add(createPage(mountPath + "/" + child));
             }
         }
@@ -101 +110 @@
         }
     }
+
+    private Page createPage(String filePath) {
+        String templatePath = "kms:/" + this.path + filePath;
+        Matcher matcher = DOUBLE_EXT.matcher(filePath);
+        if (matcher.matches()) {
+            String base = matcher.group(1);
+            String publicExt = matcher.group(2);
+            String uriPattern = publicExt.length() > 0 ? base + "." + publicExt : base;
+            return new Page(uriPattern, templatePath);
+        } else {
+            return new Page(filePath, templatePath);
+        }
+    }
+
+    private static class Page {
+        String uriPattern;
+        String templatePath;
+        int patternSignificantLength;
+
+        public Page(String uriPattern, String templatePath) {
+            this.uriPattern = uriPattern;
+            this.templatePath = templatePath;
+            this.patternSignificantLength = uriPattern.replaceAll("\\{[^{}]*}", Matcher.quoteReplacement("{}")).length();
+        }
+    }
 }