| OLD | NEW | 
|---|
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 
| 2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be | 
| 3 // found in the LICENSE file. | 3 // found in the LICENSE file. | 
| 4 | 4 | 
| 5 'use strict'; | 5 'use strict'; | 
| 6 | 6 | 
| 7 /** | 7 /** | 
| 8  * Type of a root directory. | 8  * Type of a root directory. | 
| 9  * @enum {string} | 9  * @enum {string} | 
| 10  * @const | 10  * @const | 
| (...skipping 21 matching lines...) Expand all  Loading... | 
| 32   // Fake root for offline available files on the drive. | 32   // Fake root for offline available files on the drive. | 
| 33   DRIVE_OFFLINE: 'drive_offline', | 33   DRIVE_OFFLINE: 'drive_offline', | 
| 34 | 34 | 
| 35   // Fake root for shared files on the drive. | 35   // Fake root for shared files on the drive. | 
| 36   DRIVE_SHARED_WITH_ME: 'drive_shared_with_me', | 36   DRIVE_SHARED_WITH_ME: 'drive_shared_with_me', | 
| 37 | 37 | 
| 38   // Fake root for recent files on the drive. | 38   // Fake root for recent files on the drive. | 
| 39   DRIVE_RECENT: 'drive_recent' | 39   DRIVE_RECENT: 'drive_recent' | 
| 40 }); | 40 }); | 
| 41 | 41 | 
| 42 /** |  | 
| 43  * Top directory for each root type. |  | 
| 44  * TODO(mtomasz): Deprecated. Remove this. |  | 
| 45  * @enum {string} |  | 
| 46  * @const |  | 
| 47  */ |  | 
| 48 var RootDirectory = Object.freeze({ |  | 
| 49   DOWNLOADS: '/Downloads', |  | 
| 50   ARCHIVE: '/archive', |  | 
| 51   REMOVABLE: '/removable', |  | 
| 52   DRIVE: '/drive', |  | 
| 53   CLOUD_DEVICE: '/privet', |  | 
| 54   DRIVE_OFFLINE: '/drive_offline',  // A fake root. Not the actual filesystem. |  | 
| 55   DRIVE_SHARED_WITH_ME: '/drive_shared_with_me',  // A fake root. |  | 
| 56   DRIVE_RECENT: '/drive_recent'  // A fake root. |  | 
| 57 }); |  | 
| 58 |  | 
| 59 var PathUtil = {}; | 42 var PathUtil = {}; | 
| 60 | 43 | 
| 61 /** | 44 /** | 
| 62  * Checks if the given path represents a special search. Fake entries in |  | 
| 63  * RootDirectory correspond to special searches. |  | 
| 64  * @param {string} path Path to check. |  | 
| 65  * @return {boolean} True if the given path represents a special search. |  | 
| 66  */ |  | 
| 67 PathUtil.isSpecialSearchRoot = function(path) { |  | 
| 68   var type = PathUtil.getRootType(path); |  | 
| 69   return type == RootType.DRIVE_OFFLINE || |  | 
| 70       type == RootType.DRIVE_SHARED_WITH_ME || |  | 
| 71       type == RootType.DRIVE_RECENT; |  | 
| 72 }; |  | 
| 73 |  | 
| 74 /** |  | 
| 75  * Checks |path| and return true if it is under Google Drive or a special |  | 
| 76  * search root which represents a special search from Google Drive. |  | 
| 77  * @param {string} path Path to check. |  | 
| 78  * @return {boolean} True if the given path represents a Drive based path. |  | 
| 79  */ |  | 
| 80 PathUtil.isDriveBasedPath = function(path) { |  | 
| 81   var rootType = PathUtil.getRootType(path); |  | 
| 82   return rootType === RootType.DRIVE || |  | 
| 83       rootType === RootType.DRIVE_SHARED_WITH_ME || |  | 
| 84       rootType === RootType.DRIVE_RECENT || |  | 
| 85       rootType === RootType.DRIVE_OFFLINE; |  | 
| 86 }; |  | 
| 87 |  | 
| 88 /** |  | 
| 89  * @param {string} path Path starting with '/'. |  | 
| 90  * @return {string} Top directory (starting with '/'). |  | 
| 91  */ |  | 
| 92 PathUtil.getTopDirectory = function(path) { |  | 
| 93   var i = path.indexOf('/', 1); |  | 
| 94   return i === -1 ? path : path.substring(0, i); |  | 
| 95 }; |  | 
| 96 |  | 
| 97 /** |  | 
| 98  * Obtains the parent path of the specified path. |  | 
| 99  * @param {string} path Path string. |  | 
| 100  * @return {string} Parent path. |  | 
| 101  */ |  | 
| 102 PathUtil.getParentDirectory = function(path) { |  | 
| 103   if (path[path.length - 1] == '/') |  | 
| 104     return PathUtil.getParentDirectory(path.substring(0, path.length - 1)); |  | 
| 105   var index = path.lastIndexOf('/'); |  | 
| 106   if (index == 0) |  | 
| 107     return '/'; |  | 
| 108   else if (index == -1) |  | 
| 109     return '.'; |  | 
| 110   return path.substring(0, index); |  | 
| 111 }; |  | 
| 112 |  | 
| 113 /** |  | 
| 114  * @param {string} path Any unix-style path (may start or not start from root). |  | 
| 115  * @return {Array.<string>} Path components. |  | 
| 116  */ |  | 
| 117 PathUtil.split = function(path) { |  | 
| 118   var fromRoot = false; |  | 
| 119   if (path[0] === '/') { |  | 
| 120     fromRoot = true; |  | 
| 121     path = path.substring(1); |  | 
| 122   } |  | 
| 123 |  | 
| 124   var components = path.split('/'); |  | 
| 125   if (fromRoot) |  | 
| 126     components[0] = '/' + components[0]; |  | 
| 127   return components; |  | 
| 128 }; |  | 
| 129 |  | 
| 130 /** |  | 
| 131  * Returns a directory part of the given |path|. In other words, the path |  | 
| 132  * without its base name. |  | 
| 133  * |  | 
| 134  * Examples: |  | 
| 135  * PathUtil.dirname('abc') -> '' |  | 
| 136  * PathUtil.dirname('a/b') -> 'a' |  | 
| 137  * PathUtil.dirname('a/b/') -> 'a/b' |  | 
| 138  * PathUtil.dirname('a/b/c') -> 'a/b' |  | 
| 139  * PathUtil.dirname('/') -> '/' |  | 
| 140  * PathUtil.dirname('/abc') -> '/' |  | 
| 141  * PathUtil.dirname('/abc/def') -> '/abc' |  | 
| 142  * PathUtil.dirname('') -> '' |  | 
| 143  * |  | 
| 144  * @param {string} path The path to be parsed. |  | 
| 145  * @return {string} The directory path. |  | 
| 146  */ |  | 
| 147 PathUtil.dirname = function(path) { |  | 
| 148   var index = path.lastIndexOf('/'); |  | 
| 149   if (index < 0) |  | 
| 150     return ''; |  | 
| 151   if (index == 0) |  | 
| 152     return '/'; |  | 
| 153   return path.substring(0, index); |  | 
| 154 }; |  | 
| 155 |  | 
| 156 /** |  | 
| 157  * Returns the base name (the last component) of the given |path|. If the |  | 
| 158  * |path| ends with '/', returns an empty component. |  | 
| 159  * |  | 
| 160  * Examples: |  | 
| 161  * PathUtil.basename('abc') -> 'abc' |  | 
| 162  * PathUtil.basename('a/b') -> 'b' |  | 
| 163  * PathUtil.basename('a/b/') -> '' |  | 
| 164  * PathUtil.basename('a/b/c') -> 'c' |  | 
| 165  * PathUtil.basename('/') -> '' |  | 
| 166  * PathUtil.basename('/abc') -> 'abc' |  | 
| 167  * PathUtil.basename('/abc/def') -> 'def' |  | 
| 168  * PathUtil.basename('') -> '' |  | 
| 169  * |  | 
| 170  * @param {string} path The path to be parsed. |  | 
| 171  * @return {string} The base name. |  | 
| 172  */ |  | 
| 173 PathUtil.basename = function(path) { |  | 
| 174   var index = path.lastIndexOf('/'); |  | 
| 175   return index >= 0 ? path.substring(index + 1) : path; |  | 
| 176 }; |  | 
| 177 |  | 
| 178 /** |  | 
| 179  * Join path components into a single path. Can be called either with a list of |  | 
| 180  * components as arguments, or with an array of components as the only argument. |  | 
| 181  * |  | 
| 182  * Examples: |  | 
| 183  * Path.join('abc', 'def') -> 'abc/def' |  | 
| 184  * Path.join('/', 'abc', 'def/ghi') -> '/abc/def/ghi' |  | 
| 185  * Path.join(['/abc/def', 'ghi']) -> '/abc/def/ghi' |  | 
| 186  * |  | 
| 187  * @return {string} Resulting path. |  | 
| 188  */ |  | 
| 189 PathUtil.join = function() { |  | 
| 190   var components; |  | 
| 191 |  | 
| 192   if (arguments.length === 1 && typeof(arguments[0]) === 'object') { |  | 
| 193     components = arguments[0]; |  | 
| 194   } else { |  | 
| 195     components = arguments; |  | 
| 196   } |  | 
| 197 |  | 
| 198   var path = ''; |  | 
| 199   for (var i = 0; i < components.length; i++) { |  | 
| 200     if (components[i][0] === '/') { |  | 
| 201       path = components[i]; |  | 
| 202       continue; |  | 
| 203     } |  | 
| 204     if (path.length === 0 || path[path.length - 1] !== '/') |  | 
| 205       path += '/'; |  | 
| 206     path += components[i]; |  | 
| 207   } |  | 
| 208   return path; |  | 
| 209 }; |  | 
| 210 |  | 
| 211 /** |  | 
| 212  * @param {string} path Path starting with '/'. |  | 
| 213  * @return {RootType} RootType.DOWNLOADS, RootType.DRIVE etc. |  | 
| 214  */ |  | 
| 215 PathUtil.getRootType = function(path) { |  | 
| 216   var rootDir = PathUtil.getTopDirectory(path); |  | 
| 217   for (var type in RootDirectory) { |  | 
| 218     if (rootDir === RootDirectory[type]) |  | 
| 219       return RootType[type]; |  | 
| 220   } |  | 
| 221 }; |  | 
| 222 |  | 
| 223 /** |  | 
| 224  * @param {string} path Any path. |  | 
| 225  * @return {string} The root path. |  | 
| 226  */ |  | 
| 227 PathUtil.getRootPath = function(path) { |  | 
| 228   var type = PathUtil.getRootType(path); |  | 
| 229 |  | 
| 230   if (type == RootType.DOWNLOADS || type == RootType.DRIVE_OFFLINE || |  | 
| 231       type == RootType.DRIVE_SHARED_WITH_ME || type == RootType.DRIVE_RECENT) |  | 
| 232     return PathUtil.getTopDirectory(path); |  | 
| 233 |  | 
| 234   if (type == RootType.DRIVE || type == RootType.ARCHIVE || |  | 
| 235       type == RootType.REMOVABLE) { |  | 
| 236     var components = PathUtil.split(path); |  | 
| 237     if (components.length > 1) { |  | 
| 238       return PathUtil.join(components[0], components[1]); |  | 
| 239     } else { |  | 
| 240       return components[0]; |  | 
| 241     } |  | 
| 242   } |  | 
| 243 |  | 
| 244   return '/'; |  | 
| 245 }; |  | 
| 246 |  | 
| 247 /** |  | 
| 248  * @param {string} path A path. |  | 
| 249  * @return {boolean} True if it is a path to the root. |  | 
| 250  */ |  | 
| 251 PathUtil.isRootPath = function(path) { |  | 
| 252   return PathUtil.getRootPath(path) === path; |  | 
| 253 }; |  | 
| 254 |  | 
| 255 /** |  | 
| 256  * Returns the localized name for the root type. If not available, then returns | 45  * Returns the localized name for the root type. If not available, then returns | 
| 257  * null. | 46  * null. | 
| 258  * | 47  * | 
| 259  * @param {RootType} rootType The root type. | 48  * @param {RootType} rootType The root type. | 
| 260  * @return {?string} The localized name, or null if not available. | 49  * @return {?string} The localized name, or null if not available. | 
| 261  */ | 50  */ | 
| 262 PathUtil.getRootTypeLabel = function(rootType) { | 51 PathUtil.getRootTypeLabel = function(rootType) { | 
| 263   var str = function(id) { | 52   var str = function(id) { | 
| 264     return loadTimeData.getString(id); | 53     return loadTimeData.getString(id); | 
| 265   }; | 54   }; | 
| (...skipping 30 matching lines...) Expand all  Loading... | 
| 296  */ | 85  */ | 
| 297 PathUtil.splitExtension = function(path) { | 86 PathUtil.splitExtension = function(path) { | 
| 298   var dotPosition = path.lastIndexOf('.'); | 87   var dotPosition = path.lastIndexOf('.'); | 
| 299   if (dotPosition <= path.lastIndexOf('/')) | 88   if (dotPosition <= path.lastIndexOf('/')) | 
| 300     dotPosition = -1; | 89     dotPosition = -1; | 
| 301 | 90 | 
| 302   var filename = dotPosition != -1 ? path.substr(0, dotPosition) : path; | 91   var filename = dotPosition != -1 ? path.substr(0, dotPosition) : path; | 
| 303   var extension = dotPosition != -1 ? path.substr(dotPosition) : ''; | 92   var extension = dotPosition != -1 ? path.substr(dotPosition) : ''; | 
| 304   return [filename, extension]; | 93   return [filename, extension]; | 
| 305 }; | 94 }; | 
| OLD | NEW | 
|---|