POSIX: treat multiple extensions like .tar.gz as a single extension.

base/file_path.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/file_path.h"
 
 #if defined(OS_MACOSX)
 #include <CoreServices/CoreServices.h>
 #endif
 
@@ skipping 18 matching lines @@
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("\\/");
 #else  // FILE_PATH_USES_WIN_SEPARATORS
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("/");
 #endif  // FILE_PATH_USES_WIN_SEPARATORS
 
 const FilePath::CharType FilePath::kCurrentDirectory[] = FILE_PATH_LITERAL(".");
 const FilePath::CharType FilePath::kParentDirectory[] = FILE_PATH_LITERAL("..");
 
 const FilePath::CharType FilePath::kExtensionSeparator = FILE_PATH_LITERAL('.');
 
+typedef FilePath::StringType StringType;
 
 namespace {
 
+const char* kCommonDoubleExtensions[] = { "gz", "z", "bz2" };
+
 // If this FilePath contains a drive letter specification, returns the
 // position of the last character of the drive letter specification,
 // otherwise returns npos.  This can only be true on Windows, when a pathname
 // begins with a letter followed by a colon.  On other platforms, this always
 // returns npos.
-FilePath::StringType::size_type FindDriveLetter(
-    const FilePath::StringType& path) {
+StringType::size_type FindDriveLetter(const StringType& path) {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   // This is dependent on an ASCII-based character set, but that's a
   // reasonable assumption.  iswalpha can be too inclusive here.
   if (path.length() >= 2 && path[1] == L':' &&
       ((path[0] >= L'A' && path[0] <= L'Z') ||
        (path[0] >= L'a' && path[0] <= L'z'))) {
     return 1;
   }
 #endif  // FILE_PATH_USES_DRIVE_LETTERS
-  return FilePath::StringType::npos;
+  return StringType::npos;
 }
 
-
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
-bool EqualDriveLetterCaseInsensitive(const FilePath::StringType a,
-                                     const FilePath::StringType b) {
+bool EqualDriveLetterCaseInsensitive(const StringType a,
+                                     const StringType b) {
   size_t a_letter_pos = FindDriveLetter(a);
   size_t b_letter_pos = FindDriveLetter(b);
 
-  if ((a_letter_pos == FilePath::StringType::npos) ||
-      (b_letter_pos == FilePath::StringType::npos))
+  if (a_letter_pos == StringType::npos || b_letter_pos == StringType::npos)
     return a == b;
 
-  FilePath::StringType a_letter(a.substr(0, a_letter_pos + 1));
-  FilePath::StringType b_letter(b.substr(0, b_letter_pos + 1));
+  StringType a_letter(a.substr(0, a_letter_pos + 1));
+  StringType b_letter(b.substr(0, b_letter_pos + 1));
   if (!StartsWith(a_letter, b_letter, false))
     return false;
 
-  FilePath::StringType a_rest(a.substr(a_letter_pos + 1));
-  FilePath::StringType b_rest(b.substr(b_letter_pos + 1));
+  StringType a_rest(a.substr(a_letter_pos + 1));
+  StringType b_rest(b.substr(b_letter_pos + 1));
   return a_rest == b_rest;
 }
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 
-bool IsPathAbsolute(const FilePath::StringType& path) {
+bool IsPathAbsolute(const StringType& path) {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
-  FilePath::StringType::size_type letter = FindDriveLetter(path);
-  if (letter != FilePath::StringType::npos) {
+  StringType::size_type letter = FindDriveLetter(path);
+  if (letter != StringType::npos) {
     // Look for a separator right after the drive specification.
     return path.length() > letter + 1 &&
         FilePath::IsSeparator(path[letter + 1]);
   }
   // Look for a pair of leading separators.
   return path.length() > 1 &&
       FilePath::IsSeparator(path[0]) && FilePath::IsSeparator(path[1]);
 #else  // FILE_PATH_USES_DRIVE_LETTERS
   // Look for a separator in the first position.
   return path.length() > 0 && FilePath::IsSeparator(path[0]);
 #endif  // FILE_PATH_USES_DRIVE_LETTERS
 }
 
-bool AreAllSeparators(const FilePath::StringType& input) {
-  for (FilePath::StringType::const_iterator it = input.begin();
+bool AreAllSeparators(const StringType& input) {
+  for (StringType::const_iterator it = input.begin();
       it != input.end(); ++it) {
     if (!FilePath::IsSeparator(*it))
       return false;
   }
 
   return true;
 }
 
+// Find the position of the '.' that separates the extension from the rest
+// of the file name. The position is relative to BaseName(), not value().
+// This allows a second extension component of up to 4 characters when the
+// rightmost extension component is a common double extension (gz, bz2, Z).
+// For example, foo.tar.gz or foo.tar.Z would have extension components of
+// '.tar.gz' and '.tar.Z' respectively. Returns npos if it can't find an
+// extension.
+StringType::size_type ExtensionSeparatorPosition(const StringType& path) {
+  // Special case "." and ".."
+  if (path == FilePath::kCurrentDirectory || path == FilePath::kParentDirectory)
+    return StringType::npos;
+
+  const StringType::size_type last_dot =
+      path.rfind(FilePath::kExtensionSeparator);
+
+  // No extension, or the extension is the whole filename.
+  if (last_dot == StringType::npos || last_dot == 0U)
+    return last_dot;
+
+  // Special case .<extension1>.<extension2>, but only if the final extension
+  // is one of a few common double extensions.
+  StringType extension(path, last_dot + 1);
+  bool is_common_double_extension = false;
+  for (size_t i = 0; i < arraysize(kCommonDoubleExtensions); ++i) {
+    if (LowerCaseEqualsASCII(extension, kCommonDoubleExtensions[i]))
+      is_common_double_extension = true;
+  }
+  if (!is_common_double_extension)
+    return last_dot;
+
+  // Check that <extension1> is 1-4 characters, otherwise fall back to
+  // <extension2>.
+  const StringType::size_type penultimate_dot =
+      path.rfind(FilePath::kExtensionSeparator, last_dot - 1);
+  const StringType::size_type last_separator =
+      path.find_last_of(FilePath::kSeparators, last_dot - 1,
+                        arraysize(FilePath::kSeparators) - 1);
+  if (penultimate_dot != StringType::npos &&
+      (last_separator == StringType::npos ||
+      penultimate_dot > last_separator) &&
+      last_dot - penultimate_dot <= 5U &&
+      last_dot - penultimate_dot > 1U) {
+    return penultimate_dot;
+  }
+
+  return last_dot;
+}
+
 }  // namespace
 
 FilePath::FilePath() {
 }
 
 FilePath::FilePath(const FilePath& that) : path_(that.path_) {
 }
 
 FilePath::FilePath(const StringType& path) : path_(path) {
 }
 
 FilePath::~FilePath() {
 }
 
 FilePath& FilePath::operator=(const FilePath& that) {
   path_ = that.path_;
   return *this;
 }
 
 bool FilePath::IsSeparator(CharType character) {
   for (size_t i = 0; i < arraysize(kSeparators) - 1; ++i) {
     if (character == kSeparators[i]) {
       return true;
     }
   }
 
   return false;
 }
 
-void FilePath::GetComponents(std::vector<FilePath::StringType>* components)
-    const {
+void FilePath::GetComponents(std::vector<StringType>* components) const {
   DCHECK(components);
   if (!components)
     return;
   components->clear();
   if (value().empty())
     return;
 
-  std::vector<FilePath::StringType> ret_val;
+  std::vector<StringType> ret_val;
   FilePath current = *this;
   FilePath base;
 
   // Capture path components.
   while (current != current.DirName()) {
     base = current.BaseName();
     if (!AreAllSeparators(base.value()))
       ret_val.push_back(base.value());
     current = current.DirName();
   }
 
   // Capture root, if any.
   base = current.BaseName();
   if (!base.value().empty() && base.value() != kCurrentDirectory)
     ret_val.push_back(current.BaseName().value());
 
   // Capture drive letter, if any.
   FilePath dir = current.DirName();
   StringType::size_type letter = FindDriveLetter(dir.value());
-  if (letter != FilePath::StringType::npos) {
-    ret_val.push_back(FilePath::StringType(dir.value(), 0, letter + 1));
+  if (letter != StringType::npos) {
+    ret_val.push_back(StringType(dir.value(), 0, letter + 1));
   }
 
-  *components = std::vector<FilePath::StringType>(ret_val.rbegin(),
-                                                  ret_val.rend());
+  *components = std::vector<StringType>(ret_val.rbegin(), ret_val.rend());
 }
 
 bool FilePath::operator==(const FilePath& that) const {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   return EqualDriveLetterCaseInsensitive(this->path_, that.path_);
 #else  // defined(FILE_PATH_USES_DRIVE_LETTERS)
   return path_ == that.path_;
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 }
 
 bool FilePath::operator!=(const FilePath& that) const {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   return !EqualDriveLetterCaseInsensitive(this->path_, that.path_);
 #else  // defined(FILE_PATH_USES_DRIVE_LETTERS)
   return path_ != that.path_;
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 }
 
 bool FilePath::IsParent(const FilePath& child) const {
   return AppendRelativePath(child, NULL);
 }
 
 bool FilePath::AppendRelativePath(const FilePath& child,
                                   FilePath* path) const {
-  std::vector<FilePath::StringType> parent_components;
-  std::vector<FilePath::StringType> child_components;
+  std::vector<StringType> parent_components;
+  std::vector<StringType> child_components;
   GetComponents(&parent_components);
   child.GetComponents(&child_components);
 
   if (parent_components.size() >= child_components.size())
     return false;
   if (parent_components.size() == 0)
     return false;
 
-  std::vector<FilePath::StringType>::const_iterator parent_comp =
+  std::vector<StringType>::const_iterator parent_comp =
       parent_components.begin();
-  std::vector<FilePath::StringType>::const_iterator child_comp =
+  std::vector<StringType>::const_iterator child_comp =
       child_components.begin();
 
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   // Windows can access case sensitive filesystems, so component
   // comparisions must be case sensitive, but drive letters are
   // never case sensitive.
-  if ((FindDriveLetter(*parent_comp) != FilePath::StringType::npos) &&
-      (FindDriveLetter(*child_comp) != FilePath::StringType::npos)) {
+  if ((FindDriveLetter(*parent_comp) != StringType::npos) &&
+      (FindDriveLetter(*child_comp) != StringType::npos)) {
     if (!StartsWith(*parent_comp, *child_comp, false))
       return false;
     ++parent_comp;
     ++child_comp;
   }
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 
   while (parent_comp != parent_components.end()) {
     if (*parent_comp != *child_comp)
       return false;
@@ skipping 65 matching lines @@
       new_path.path_.find_last_of(kSeparators, StringType::npos,
                                   arraysize(kSeparators) - 1);
   if (last_separator != StringType::npos &&
       last_separator < new_path.path_.length() - 1) {
     new_path.path_.erase(0, last_separator + 1);
   }
 
   return new_path;
 }
 
-FilePath::StringType FilePath::Extension() const {
-  // BaseName() calls StripTrailingSeparators, so cases like /foo.baz/// work.
-  StringType base = BaseName().value();
-
-  // Special case "." and ".."
-  if (base == kCurrentDirectory || base == kParentDirectory)
+StringType FilePath::Extension() const {
+  FilePath base(BaseName());
+  const StringType::size_type dot = ExtensionSeparatorPosition(base.path_);
+  if (dot == StringType::npos)
     return StringType();
 
-  const StringType::size_type last_dot = base.rfind(kExtensionSeparator);
-  if (last_dot == StringType::npos)
-    return StringType();
-  return StringType(base, last_dot);
+  return base.path_.substr(dot, StringType::npos);
 }
 
 FilePath FilePath::RemoveExtension() const {
-  StringType ext = Extension();
-  // It's important to check Extension() since that verifies that the
-  // kExtensionSeparator actually appeared in the last path component.
-  if (ext.empty())
-    return FilePath(path_);
-  // Since Extension() verified that the extension is in fact in the last path
-  // component, this substr will effectively strip trailing separators.
-  const StringType::size_type last_dot = path_.rfind(kExtensionSeparator);
-  return FilePath(path_.substr(0, last_dot));
+  if (Extension().empty())
+    return *this;
+
+  const StringType::size_type dot = ExtensionSeparatorPosition(path_);
+  if (dot == StringType::npos)
+    return *this;
+
+  return FilePath(path_.substr(0, dot));
 }
 
 FilePath FilePath::InsertBeforeExtension(const StringType& suffix) const {
   if (suffix.empty())
     return FilePath(path_);
 
   if (path_.empty())
     return FilePath();
 
   StringType base = BaseName().value();
@@ skipping 45 matching lines @@
   StringType str = no_ext.value();
   if (extension[0] != kExtensionSeparator)
     str.append(1, kExtensionSeparator);
   str.append(extension);
   return FilePath(str);
 }
 
 bool FilePath::MatchesExtension(const StringType& extension) const {
   DCHECK(extension.empty() || extension[0] == kExtensionSeparator);
 
-  FilePath::StringType current_extension = Extension();
+  StringType current_extension = Extension();
 
   if (current_extension.length() != extension.length())
     return false;
 
   return FilePath::CompareEqualIgnoreCase(extension, current_extension);
 }
 
 FilePath FilePath::Append(const StringType& component) const {
   DCHECK(!IsPathAbsolute(component));
   if (path_.compare(kCurrentDirectory) == 0) {
@@ skipping 539 matching lines @@
     if (codepoint1 != codepoint2)
       return (codepoint1 < codepoint2) ? -1 : 1;
     if (codepoint1 == 0) {
       DCHECK_EQ(index1, length1);
       DCHECK_EQ(index2, length2);
       return 0;
     }
   }
 }
 
-FilePath::StringType FilePath::GetHFSDecomposedForm(const StringType& string) {
+StringType FilePath::GetHFSDecomposedForm(const StringType& string) {
   scoped_cftyperef<CFStringRef> cfstring(
       CFStringCreateWithBytesNoCopy(
           NULL,
           reinterpret_cast<const UInt8*>(string.c_str()),
           string.length(),
           kCFStringEncodingUTF8,
           false,
           kCFAllocatorNull));
   // Query the maximum length needed to store the result. In most cases this
   // will overestimate the required space. The return value also already
@@ skipping 100 matching lines @@
 
 FilePath FilePath::StripTrailingSeparators() const {
   FilePath new_path(path_);
   new_path.StripTrailingSeparatorsInternal();
 
   return new_path;
 }
 
 // static.
 void FilePath::WriteStringTypeToPickle(Pickle* pickle,
-                                       const FilePath::StringType& path) {
+                                       const StringType& path) {
 #if defined(WCHAR_T_IS_UTF16)
   pickle->WriteWString(path);
 #elif defined(WCHAR_T_IS_UTF32)
   pickle->WriteString(path);
 #else
   NOTIMPLEMENTED() << "Impossible encoding situation!";
 #endif
 }
 
 // static.
 bool FilePath::ReadStringTypeFromPickle(Pickle* pickle, void** iter,
-                                        FilePath::StringType* path) {
+                                        StringType* path) {
 #if defined(WCHAR_T_IS_UTF16)
   if (!pickle->ReadWString(iter, path))
     return false;
 #elif defined(WCHAR_T_IS_UTF32)
   if (!pickle->ReadString(iter, path))
     return false;
 #else
   NOTIMPLEMENTED() << "Impossible encoding situation!";
   return false;
 #endif
@@ skipping 25 matching lines @@
     // don't strip them, unless the string began with more than two separators.
     if (pos != start + 1 || last_stripped == start + 2 ||
         !IsSeparator(path_[start - 1])) {
       path_.resize(pos - 1);
       last_stripped = pos;
     }
   }
 }
 
 bool FilePath::ReferencesParent() const {
-  std::vector<FilePath::StringType> components;
+  std::vector<StringType> components;
   GetComponents(&components);
 
-  std::vector<FilePath::StringType>::const_iterator it = components.begin();
+  std::vector<StringType>::const_iterator it = components.begin();
   for (; it != components.end(); ++it) {
-    const FilePath::StringType& component = *it;
+    const StringType& component = *it;
     if (component == kParentDirectory)
       return true;
   }
   return false;
 }
 
 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 FilePath FilePath::NormalizeWindowsPathSeparators() const {
   StringType copy = path_;
   for (size_t i = 1; i < arraysize(kSeparators); ++i) {
     std::replace(copy.begin(), copy.end(), kSeparators[i], kSeparators[0]);
   }
   return FilePath(copy);
 }
 #endif