FileValidator.cpp

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2018 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#include "MantidKernel/FileValidator.h"
#include "MantidKernel/Logger.h"
#include <boost/algorithm/string/case_conv.hpp>
#include <filesystem>
#include <fstream>
#include <memory>
#include <sstream>
 
namespace Mantid::Kernel {
 
namespace {
// Initialize the static logger
Logger g_log("FileValidator");
} // namespace
 
FileValidator::FileValidator(const std::vector<std::string> &extensions, bool testFileExists)
    : TypedValidator<std::string>(), m_testExist(testFileExists) {
  for (const auto &extension : extensions) {
    const std::string ext = boost::to_lower_copy(extension);
    if (std::find(m_extensions.begin(), m_extensions.end(), ext) == m_extensions.end()) {
      m_extensions.emplace_back(ext);
    }
  }
}
 
std::vector<std::string> FileValidator::allowedValues() const { return m_extensions; }
 
IValidator_sptr FileValidator::clone() const { return std::make_shared<FileValidator>(*this); }
 
std::string FileValidator::checkValidity(const std::string &value) const {
  // Check if the path is syntactically valid
  try {
    std::filesystem::path testPath(value);
    // Just creating a path object validates syntax in most cases
  } catch (const std::exception &) {
    return "Error in path syntax: \"" + value + "\".";
  }
 
  // Check the extension but just issue a warning if it is not one of the
  // suggested values
  if (!(value.empty())) {
    if (!(this->endswith(value))) {
      // Dropped from warning to debug level as it was printing out on every
      // search of the archive, even when successful. re #5998
      g_log.debug() << "Unrecognised extension in file \"" << value << "\"";
      if (!this->m_extensions.empty()) {
        g_log.debug() << " [ ";
        for (const auto &extension : this->m_extensions)
          g_log.debug() << extension << " ";
        g_log.debug() << "]";
      }
      g_log.debug() << "\".\n";
    }
  }
 
  // create a variable for the absolute path to be used in error messages
  std::string abspath(value);
  if (!value.empty()) {
    std::filesystem::path path(value);
    if (path.is_absolute())
      abspath = std::filesystem::absolute(path).string();
  }
 
  // If the file is required to exist check it is there
  if (m_testExist && (value.empty() || !std::filesystem::exists(value))) {
    return "File \"" + abspath + "\" not found";
  }
 
  if (m_testExist && (std::filesystem::exists(value))) {
    std::ifstream in;
    in.open(value.c_str());
    if (!in) {
      std::stringstream error;
      error << "Failed to open " + value + ": " << strerror(errno);
      return error.str();
    }
  }
 
  // Otherwise we are okay, file extensions are just a suggestion so no
  // validation on them is necessary
  return "";
}
 
bool has_ending(const std::string &value, const std::string &ending) {
  if (ending.empty()) // always match against an empty extension
    return true;
  if (value.length() < ending.length()) // filename is not long enough
    return false;
  int result = value.compare(value.length() - ending.length(), ending.length(), ending);
  return (result == 0); // only care if it matches
}
 
bool FileValidator::endswith(const std::string &value) const {
  if (m_extensions.empty()) // automatically match a lack of extensions
    return true;
  if ((m_extensions.size() == 1) && (m_extensions.begin()->empty()))
    return true;
 
  // create a lowercase copy of the filename
  std::string value_copy(value);
  std::transform(value_copy.begin(), value_copy.end(), value_copy.begin(), tolower);
 
  // check for the ending
  return std::any_of(m_extensions.cbegin(), m_extensions.cend(), [&](const auto extension) {
    return has_ending(value, extension) || has_ending(value_copy, extension);
  });
}
 
} // namespace Mantid::Kernel