source/ch/cyberduck/core/PathNormalizer.java

   1 package ch.cyberduck.core;
   2
   3 /*
   4  * Copyright (c) 2002-2013 David Kocher. All rights reserved.
   5  * http://cyberduck.ch/
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * Bug fixes, suggestions and comments should be sent to feedback@cyberduck.ch
  18  */
  19
  20 import ch.cyberduck.core.preferences.PreferencesFactory;
  21 import ch.cyberduck.core.unicode.NFCNormalizer;
  22
  23 import org.apache.commons.io.FilenameUtils;
  24 import org.apache.commons.lang3.StringUtils;
  25
  26 import java.util.List;
  27
  28 /**
  29  * @version $Id$
  30  */
  31 public final class PathNormalizer {
  32
  33     private PathNormalizer() {
  34         //
  35     }
  36
  37     public static String name(final String path) {
  38         final String normalized = normalize(path, true);
  39         if(String.valueOf(Path.DELIMITER).equals(normalized)) {
  40             return path;
  41         }
  42         return FilenameUtils.getName(normalized);
  43     }
  44
  45     public static String parent(final String absolute, final char delimiter) {
  46         if(absolute.equals(String.valueOf(delimiter))) {
  47             return null;
  48         }
  49         int index = absolute.length() - 1;
  50         if(absolute.charAt(index) == delimiter) {
  51             if(index > 0) {
  52                 index--;
  53             }
  54         }
  55         int cut = absolute.lastIndexOf(delimiter, index);
  56         if(cut > 0) {
  57             return absolute.substring(0, cut);
  58         }
  59         //if (index == 0) parent is root
  60         return String.valueOf(delimiter);
  61     }
  62
  63     public static String normalize(final String path) {
  64         return normalize(path, true);
  65     }
  66
  67     /**
  68      * Return a context-relative path, beginning with a "/", that represents
  69      * the canonical version of the specified path after ".." and "." elements
  70      * are resolved out.
  71      *
  72      * @param path     The path to parse
  73      * @param absolute If the path is absolute
  74      * @return the normalized path.
  75      */
  76     public static String normalize(final String path, final boolean absolute) {
  77         if(null == path) {
  78             return String.valueOf(Path.DELIMITER);
  79         }
  80         String normalized = path;
  81         if(PreferencesFactory.get().getBoolean("path.normalize")) {
  82             if(absolute) {
  83                 while(!normalized.startsWith(String.valueOf(Path.DELIMITER))) {
  84                     normalized = Path.DELIMITER + normalized;
  85                 }
  86             }
  87             while(!normalized.endsWith(String.valueOf(Path.DELIMITER))) {
  88                 normalized += Path.DELIMITER;
  89             }
  90             // Resolve occurrences of "/./" in the normalized path
  91             while(true) {
  92                 int index = normalized.indexOf("/./");
  93                 if(index < 0) {
  94                     break;
  95                 }
  96                 normalized = normalized.substring(0, index) +
  97                         normalized.substring(index + 2);
  98             }
  99             // Resolve occurrences of "/../" in the normalized path
 100             while(true) {
 101                 int index = normalized.indexOf("/../");
 102                 if(index < 0) {
 103                     break;
 104                 }
 105                 if(index == 0) {
 106                     // The only left path is the root.
 107                     return String.valueOf(Path.DELIMITER);
 108                 }
 109                 normalized = normalized.substring(0, normalized.lastIndexOf(Path.DELIMITER, index - 1)) +
 110                         normalized.substring(index + 3);
 111             }
 112             StringBuilder n = new StringBuilder();
 113             if(normalized.startsWith("//")) {
 114                 // see #972. Omit leading delimiter
 115                 n.append(Path.DELIMITER);
 116                 n.append(Path.DELIMITER);
 117             }
 118             else if(absolute) {
 119                 // convert to absolute path
 120                 n.append(Path.DELIMITER);
 121             }
 122             else if(normalized.startsWith(String.valueOf(Path.DELIMITER))) {
 123                 // Keep absolute path
 124                 n.append(Path.DELIMITER);
 125             }
 126             // Remove duplicated Path.DELIMITERs
 127             final String[] segments = normalized.split(String.valueOf(Path.DELIMITER));
 128             for(String segment : segments) {
 129                 if(segment.equals(StringUtils.EMPTY)) {
 130                     continue;
 131                 }
 132                 n.append(segment);
 133                 n.append(Path.DELIMITER);
 134             }
 135             normalized = n.toString();
 136             while(normalized.endsWith(String.valueOf(Path.DELIMITER)) && normalized.length() > 1) {
 137                 //Strip any redundant delimiter at the end of the path
 138                 normalized = normalized.substring(0, normalized.length() - 1);
 139             }
 140         }
 141         if(PreferencesFactory.get().getBoolean("path.normalize.unicode")) {
 142             return new NFCNormalizer().normalize(normalized);
 143         }
 144         // Return the normalized path that we have completed
 145         return normalized;
 146     }
 147
 148     /**
 149      * Prunes the list of selected files. Files which are a child of an already included directory
 150      * are removed from the returned list.
 151      *
 152      * @param selected Selected files for transfer
 153      * @return Normalized
 154      */
 155     public static List<Path> normalize(final List<Path> selected) {
 156         final List<Path> normalized = new Collection<Path>();
 157         for(Path f : selected) {
 158             boolean duplicate = false;
 159             for(Path n : normalized) {
 160                 if(f.isChild(n)) {
 161                     // The selected file is a child of a directory already included
 162                     duplicate = true;
 163                     break;
 164                 }
 165             }
 166             if(!duplicate) {
 167                 normalized.add(f);
 168             }
 169         }
 170         return normalized;
 171     }
 172 }