FileProperty.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 "MantidAPI/FileProperty.h"
 
#include "MantidAPI/FileFinder.h"
#include "MantidKernel/ConfigService.h"
#include "MantidKernel/DirectoryValidator.h"
#include "MantidKernel/Exception.h"
#include "MantidKernel/FacilityInfo.h"
#include "MantidKernel/PropertyWithValue.h"
#include "MantidKernel/Strings.h"
 
#include <filesystem>
#include <iterator>
#include <memory>
 
namespace Mantid::API {
 
using Mantid::Kernel::ConfigService;
using Mantid::Kernel::DirectoryValidator;
using Mantid::Kernel::FileValidator;
using Mantid::Kernel::IValidator_sptr;
 
namespace {
IValidator_sptr createValidator(unsigned int action, const std::vector<std::string> &exts) {
  if (action == FileProperty::Directory || action == FileProperty::OptionalDirectory) {
    return std::make_shared<DirectoryValidator>(action == FileProperty::Directory);
  } else {
    return std::make_shared<FileValidator>(exts, (action == FileProperty::Load));
  }
}
 
void addExtension(const std::string &extension, std::vector<std::string> &extensions) {
  if (std::find(extensions.begin(), extensions.end(), extension) != extensions.end())
    return;
  else
    extensions.emplace_back(extension);
}
 
const std::string &getHomePath() {
  static std::string homePath;
  static bool initialised(false);
 
  if (initialised) {
    return homePath;
  }
  initialised = true;
 
  char *home = std::getenv("HOME"); // Usually set on Windows and UNIX
  if (home) {
    homePath = std::string(home);
    return homePath;
  }
 
  char *userProfile = std::getenv("USERPROFILE"); // Not usually set on UNIX
  // Return even if it's an empty string, as we can do no better
  homePath = userProfile ? std::string(userProfile) : "";
  return homePath;
}
 
std::string expandUser(const std::string &filepath) {
  // return immediately if empty
  if (filepath.empty())
    return filepath;
 
  auto const start = filepath.begin();
  auto const end = filepath.end();
 
  // Filepath empty or contains no user variables
  if (*start != '~')
    return filepath;
 
  // Position of the first slash after the variable
  auto nextSlash = find_if(start, end, [](const char &c) { return c == '/' || c == '\\'; });
 
  // ~user/blah format - no support for this as yet
  if (std::distance(start, nextSlash) != 1)
    return filepath;
 
  return getHomePath() + std::string(nextSlash, end);
}
 
std::string resolveCurrentDirectory(const std::string &filepath) {
  if (filepath.empty())
    return filepath;
  // only care about things that start with ./
  if (filepath[0] != '.') // already know at least one character
    return filepath;
  if (filepath.size() > 1 && !(filepath.starts_with("./"))) {
    return filepath;
  }
 
  std::filesystem::path path(filepath);
  if (!path.is_absolute()) {
    std::filesystem::path currentPath = std::filesystem::current_path();
    path = currentPath / path;
  }
  return path.string();
}
 
std::string createDirectory(const std::filesystem::path &path) {
  std::filesystem::path stempath(path);
  // If the path doesn't end with a separator, assume it includes a filename component
  // and we should create the parent directory instead
  if (std::filesystem::is_regular_file(stempath)) {
    stempath = stempath.parent_path();
  }
 
  if (!stempath.empty()) {
    if (!std::filesystem::exists(stempath)) {
      try {
        std::filesystem::create_directories(stempath);
      } catch (const std::exception &e) {
        std::stringstream msg;
        msg << "Failed to create directory \"" << stempath << "\": " << e.what();
        return msg.str();
      }
    }
  } else {
    return "Invalid directory.";
  }
  return ""; // no error
}
} // Anonymous namespace
 
//-----------------------------------------------------------------
// Public member functions
//-----------------------------------------------------------------
FileProperty::FileProperty(const std::string &name, const std::string &defaultValue, unsigned int action,
                           const std::vector<std::string> &exts, unsigned int direction)
    : PropertyWithValue<std::string>(name, defaultValue, createValidator(action, exts), direction), m_action(action),
      m_defaultExt((!exts.empty()) ? exts.front() : ""), m_runFileProp(isLoadProperty() && extsMatchRunFiles()),
      m_oldLoadPropValue(""), m_oldLoadFoundFile("") {}
 
FileProperty::FileProperty(const std::string &name, const std::string &default_value, unsigned int action,
                           const std::string &ext, unsigned int direction)
    : FileProperty(name, default_value, action, std::vector<std::string>(1, ext), direction) {}
 
FileProperty::FileProperty(const std::string &name, const std::string &default_value, unsigned int action,
                           std::initializer_list<std::string> exts, unsigned int direction)
    : FileProperty(name, default_value, action, std::vector<std::string>(exts), direction) {}
 
bool FileProperty::isLoadProperty() const { return m_action == Load || m_action == OptionalLoad; }
 
bool FileProperty::isSaveProperty() const { return m_action == Save || m_action == OptionalSave; }
 
bool FileProperty::isDirectoryProperty() const { return m_action == Directory || m_action == OptionalDirectory; }
 
bool FileProperty::isOptional() const {
  return (m_action == OptionalLoad || m_action == OptionalSave || m_action == OptionalDirectory);
}
 
std::string FileProperty::setValue(const std::string &propValue) {
  std::string strippedValue = Kernel::Strings::strip(propValue);
 
  // Empty value is allowed if optional
  if (strippedValue.empty()) {
    PropertyWithValue<std::string>::setValue("");
    return isEmptyValueValid();
  }
 
  // Expand user variables, if there are any
  strippedValue = expandUser(strippedValue);
  strippedValue = resolveCurrentDirectory(strippedValue);
  std::filesystem::path strippedPath(strippedValue);
 
  // If this looks like an absolute path then don't do any searching but make
  // sure the
  // directory exists for a Save property
  if (strippedPath.is_absolute()) {
    if (isSaveProperty()) {
      std::string error = createDirectory(strippedPath.parent_path());
      if (!error.empty())
        return error;
    }
 
    return PropertyWithValue<std::string>::setValue(strippedValue);
  }
 
  std::string errorMsg;
  // For relative paths, differentiate between load and save types
  if (isLoadProperty()) {
    errorMsg = setLoadProperty(strippedValue);
  } else {
    errorMsg = setSaveProperty(strippedValue);
  }
  return errorMsg;
}
 
std::string FileProperty::isValid() const {
  const std::string &value = (*this)();
  if (value.empty()) {
    return isEmptyValueValid();
  } else {
    return PropertyWithValue<std::string>::isValid();
  }
}
 
std::string FileProperty::isEmptyValueValid() const {
  if (isOptional()) {
    return "";
  } else {
    return "No file specified.";
  }
}
 
bool FileProperty::extsMatchRunFiles() {
  bool match(false);
  try {
    Kernel::FacilityInfo facilityInfo = Kernel::ConfigService::Instance().getFacility();
    const std::vector<std::string> facilityExts = facilityInfo.extensions();
    const std::vector<std::string> allowedExts = this->allowedValues();
    match = std::any_of(allowedExts.cbegin(), allowedExts.cend(), [&facilityExts](const auto &ext) {
      return std::find(facilityExts.cbegin(), facilityExts.cend(), ext) != facilityExts.cend();
    });
 
  } catch (Mantid::Kernel::Exception::NotFoundError &) {
  } // facility could not be found, do nothing this will return the default
  // match of false
 
  return match;
}
 
std::string FileProperty::setLoadProperty(const std::string &propValue) {
  // determine the initial version of foundFile
  std::string foundFile;
  if ((propValue == m_oldLoadPropValue) && (!m_oldLoadFoundFile.empty())) {
    foundFile = m_oldLoadFoundFile;
  }
 
  // cache the new version of propValue
  m_oldLoadPropValue = propValue;
 
  // if foundFile is not empty then it is the cached file
  if (foundFile.empty()) {
    if (m_runFileProp) // runfiles go through FileFinder::findRun
    {
      std::vector<std::string> allowedExts(allowedValues());
      std::vector<std::string> exts;
      if (!m_defaultExt.empty()) {
        addExtension(m_defaultExt, exts);
 
        std::string lower = Mantid::Kernel::Strings::toLower(m_defaultExt);
        addExtension(lower, exts);
 
        std::string upper = Mantid::Kernel::Strings::toUpper(m_defaultExt);
        addExtension(upper, exts);
      }
      for (auto &ext : allowedExts) {
        std::string lower(ext);
        std::string upper(ext);
        std::transform(ext.begin(), ext.end(), lower.begin(), tolower);
        std::transform(ext.begin(), ext.end(), upper.begin(), toupper);
        addExtension(ext, exts);
        addExtension(lower, exts);
        addExtension(upper, exts);
      }
      foundFile = FileFinder::Instance().findRun(propValue, exts).result();
    } else // non-runfiles go through FileFinder::getFullPath
    {
      foundFile = FileFinder::Instance().getFullPath(propValue);
    }
  }
 
  // cache the new version of foundFile
  m_oldLoadFoundFile = foundFile;
 
  if (foundFile.empty()) {
    return PropertyWithValue<std::string>::setValue(propValue);
  } else {
    return PropertyWithValue<std::string>::setValue(foundFile);
  }
}
 
std::string FileProperty::setSaveProperty(const std::string &propValue) {
  if (propValue.empty()) {
    if (m_action == OptionalSave) {
      return PropertyWithValue<std::string>::setValue("");
    } else
      return "Empty filename not allowed.";
  }
  std::string errorMsg;
  // We have a relative save path so just prepend the path that is in the
  // 'defaultsave.directory'
  // Note that this catches exceptions and returns an empty string in that case
  std::string save_path = ConfigService::Instance().getString("defaultsave.directory");
  std::filesystem::path save_dir;
  if (save_path.empty()) {
    save_dir = std::filesystem::path(propValue).parent_path();
    // If we only have a stem filename, parent_path() will make save_dir empty
    if (save_dir.empty()) {
      save_dir = std::filesystem::current_path();
    }
  } else {
    save_dir = std::filesystem::path(save_path);
  }
  errorMsg = createDirectory(save_dir);
  if (errorMsg.empty()) {
    std::string fullpath = (save_dir / propValue).string();
    errorMsg = PropertyWithValue<std::string>::setValue(fullpath);
  }
  return errorMsg;
}
} // namespace Mantid::API