#include <shared_core/FilePath.hpp>

#include <algorithm>

#include <fstream>

#ifdef _WIN32

#include <windows.h>

#include <boost/iostreams/stream.hpp>

#include <boost/iostreams/device/file_descriptor.hpp>

#include <boost/system/windows_error.hpp>

#include <shared_core/system/Win32StringUtils.hpp>

#else

#include <sys/stat.h>

#include <sys/unistd.h>

#include <shared_core/system/PosixSystem.hpp>

#endif

#define BOOST_NO_CXX11_SCOPED_ENUMS

#include <boost/filesystem.hpp>

#undef BOOST_NO_CXX11_SCOPED_ENUMS

#include <boost/bind/bind.hpp>

#include <boost/make_shared.hpp>

#include <boost/algorithm/string/case_conv.hpp>

#include <boost/algorithm/string/predicate.hpp>

#include <shared_core/Logger.hpp>

#include <shared_core/Error.hpp>

#include <shared_core/SafeConvert.hpp>

#include <shared_core/system/User.hpp>

typedef boost::filesystem::path path_t;

using namespace boost::placeholders;

namespace rstudio {

namespace core {

namespace {

struct MimeType

};

MimeType s_mimeTypes[] =

{

// most common web types

{ "htm", "text/html" },

{ "html", "text/html" },

{ "css", "text/css" },

{ "sass", "text/sass" },

{ "scss", "text/scss" },

{ "less", "text/less" },

{ "gif", "image/gif" },

{ "jpg", "image/jpeg" },

{ "jpeg", "image/jpeg" },

{ "jpe", "image/jpeg" },

{ "png", "image/png" },

{ "webp", "image/webp" },

{ "js", "text/javascript" },

{ "pdf", "application/pdf" },

{ "svg", "image/svg+xml" },

{ "swf", "application/x-shockwave-flash" },

{ "ttf", "application/x-font-ttf" },

{ "woff", "application/font-woff" },

{ "woff2", "application/font-woff2" },

{ "wasm", "application/wasm"},

// markdown types

{ "md", "text/x-markdown" },

{ "mdtxt", "text/x-markdown" },

{ "markdown", "text/x-markdown" },

{ "yaml", "text/x-yaml" },

{ "yml", "text/x-yaml" },

// programming language types

{ "f", "text/x-fortran" },

{ "py", "text/x-python" },

{ "smk", "text/x-python" },

{ "sh", "text/x-shell" },

{ "sql", "text/x-sql" },

{ "stan", "text/x-stan" },

{ "clj", "text/x-clojure" },

{ "ts", "text/x-typescript"},

{ "ojs", "text/javascript" },

{ "lua", "text/x-lua"},

{ "groovy", "text/x-groovy"},

{ "nf", "text/x-groovy"},

// other types we are likely to serve

{ "xml", "text/xml" },

{ "csv", "text/csv" },

{ "ico", "image/x-icon" },

{ "zip", "application/zip" },

{ "bz", "application/x-bzip" },

{ "bz2", "application/x-bzip2" },

{ "gz", "application/x-gzip" },

{ "tar", "application/x-tar" },

{ "json", "application/json" },

{ "rstheme", "text/css" },

// yet more types...

{ "shtml", "text/html" },

{ "tsv", "text/tab-separated-values" },

{ "tab", "text/tab-separated-values" },

{ "cl", "text/plain" },

{ "dcf", "text/debian-control-file" },

{ "i", "text/plain" },

{ "ini", "text/plain" },

{ "txt", "text/plain" },

{ "mml", "text/mathml" },

{ "log", "text/plain" },

{ "lintr", "text/plain" },

{ "out", "text/plain" },

{ "csl", "text/x-csl" },

{ "R", "text/x-r-source" },

{ "S", "text/x-r-source" },

{ "q", "text/x-r-source" },

{ "Rd", "text/x-r-doc" },

{ "Rnw", "text/x-r-sweave" },

{ "Rmd", "text/x-r-markdown" },

{ "Rhtml", "text/x-r-html" },

{ "Rpres", "text/x-r-presentation" },

{ "qmd", "text/x-quarto-markdown"},

{ "Rout", "text/plain" },

{ "po", "text/plain" },

{ "pot", "text/plain" },

{ "ps1", "text/plain" },

{ "rst", "text/plain" },

{ "gitignore", "text/plain" },

{ "Rbuildignore", "text/plain" },

{ "Rprofile", "text/x-r-source" },

{ "Renviron", "text/x-shell" },

{ "rprofvis", "text/x-r-profile" },

{ "vcxproj", "text/xml" },

{ "tif", "image/tiff" },

{ "tiff", "image/tiff" },

{ "bmp", "image/bmp" },

{ "ps", "application/postscript" },

{ "eps", "application/postscript" },

{ "dvi", "application/x-dvi" },

{ "atom", "application/atom+xml" },

{ "rss", "application/rss+xml" },

{ "doc", "application/msword" },

{ "docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },

{ "odt", "application/vnd.oasis.opendocument.text" },

{ "rtf", "application/rtf" },

{ "xls", "application/vnd.ms-excel" },

{ "xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },

{ "ods", "application/x-vnd.oasis.opendocument.spreadsheet" },

{ "ppt", "application/vnd.ms-powerpoint" },

{ "pps", "application/vnd.ms-powerpoint" },

{ "pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },

{ "sit", "application/x-stuffit" },

{ "sxw", "application/vnd.sun.xml.writer" },

{ "iso", "application/octet-stream" },

{ "dmg", "application/octet-stream" },

{ "exe", "application/octet-stream" },

{ "dll", "application/octet-stream" },

{ "deb", "application/octet-stream" },

{ "otf", "application/octet-stream" },

{ "xpi", "application/x-xpinstall" },

{ "mp2", "audio/mpeg" },

{ "mpg", "video/mpeg" },

{ "mpeg", "video/mpeg" },

{ "flv", "video/x-flv" },

{ "mp4", "video/mp4" },

{ "webm", "video/webm" },

{ "ogv", "video/ogg" },

{ "mp3", "audio/mp3" },

{ "wav", "audio/wav" },

{ "oga", "audio/ogg" },

{ "ogg", "audio/ogg" },

{ nullptr, nullptr }

};

const std::string& homePathAlias()

{

static const std::string homePathAlias = "~/";

return homePathAlias;

}

const std::string& homePathLeafAlias()

{

static const std::string homePathLeafAlias = "~";

return homePathLeafAlias;

}

#ifdef _WIN32

#define BOOST_FS_STRING(path) toString((path).generic_wstring())

#define BOOST_FS_PATH2STR(path) toString((path).generic_wstring())

#define BOOST_FS_PATH2STRNATIVE(path) toString((path).wstring())

#define BOOST_FS_COMPLETE(p, base) boost::filesystem::absolute(fromString(p), base)

typedef boost::filesystem::directory_iterator dir_iterator;

typedef boost::filesystem::recursive_directory_iterator recursive_dir_iterator;

#elif defined(BOOST_FILESYSTEM_VERSION) && BOOST_FILESYSTEM_VERSION != 2

#define BOOST_FS_STRING(path) ((path).generic_string())

#define BOOST_FS_PATH2STR(path) ((path).generic_string())

#define BOOST_FS_PATH2STRNATIVE(path) ((path).generic_string())

#define BOOST_FS_COMPLETE(p, base) boost::filesystem::absolute(p, base)

typedef boost::filesystem::directory_iterator dir_iterator;

typedef boost::filesystem::recursive_directory_iterator recursive_dir_iterator;

#else

#error FilePath requires Filesystem v3

#endif

#ifdef _WIN32

typedef std::wstring internal_string;

std::string toString(const internal_string& value)

{

return string_utils::wideToUtf8(value);

}

internal_string fromString(const std::string& value)

{

return string_utils::utf8ToWide(value);

}

#else

typedef std::string internal_string;

inline internal_string fromString(const std::string& in_value)

{

return in_value;

}

#endif

void addErrorProperties(path_t path, Error* pError)

{

pError->addProperty("path", BOOST_FS_PATH2STR(path));

}

bool addItemSize(const FilePath& item, boost::shared_ptr<uintmax_t> pTotal)

}

#ifndef _WIN32

int octalStrToFileMode(const std::string& fileModeStr)

{

return safe_convert::stringTo<int>(fileModeStr, 0666, std::oct);

}

inline Error changeFileModeImpl(const std::string& filePath, mode_t mode)

}

#endif

bool copySingleItem(const FilePath& from, const FilePath& to,

}

void logError(path_t path,

}

Error notFoundError(const FilePath& filePath,

}

} // anonymous namespace

struct FilePath::Impl

{

/**

Impl() = default;

/**

explicit Impl(path_t in_path) :

Path(std::move(in_path))

{

}

/** The underlying path of this FilePath. */

path_t Path;

};

FilePath::FilePath() :

m_impl(new Impl())

{

}

FilePath::FilePath(const std::string& in_absolutePath) :

m_impl(new Impl(fromString(std::string(in_absolutePath.c_str())))) // thwart ref-count

{

}

#ifdef _WIN32

FilePath::FilePath(const std::wstring& absolutePath)

: m_impl(new Impl(absolutePath)) // thwart ref-count

{

}

#endif

FilePath::FilePath(const char* in_absolutePath) :

}

#ifdef _WIN32

FilePath::FilePath(const wchar_t* in_absolutePath)

}

#endif

bool FilePath::operator==(const FilePath& in_other) const

{

return m_impl->Path == in_other.m_impl->Path;

}

bool FilePath::operator!=(const FilePath& in_other) const

{

return m_impl->Path != in_other.m_impl->Path;

}

bool FilePath::operator<(const FilePath& in_other) const

{

return m_impl->Path < in_other.m_impl->Path;

}

std::string FilePath::createAliasedPath(const FilePath& in_filePath, const FilePath& in_userHomePath)

}

bool FilePath::exists(const std::string& in_filePath)

}

bool FilePath::isEqualCaseInsensitive(const FilePath& in_filePath1, const FilePath& in_filePath2)

}

bool FilePath::isRootPath(const std::string& in_filePath)

}

Error FilePath::makeCurrent(const std::string& in_filePath)

{

return FilePath(in_filePath).makeCurrentPath();

}

FilePath FilePath::resolveAliasedPath(const std::string& in_aliasedPath, const FilePath& in_userHomePath)

}

FilePath FilePath::safeCurrentPath(const FilePath& in_revertToPath)

}

Error FilePath::tempFilePath(FilePath& out_filePath)

{

return tempFilePath(std::string(), out_filePath);

}

Error FilePath::tempFilePath(const std::string& in_extension, FilePath& out_filePath)

}

Error FilePath::uniqueFilePath(const std::string& in_basePath, FilePath& out_filePath)

{

return uniqueFilePath(in_basePath, std::string(), out_filePath);

}

Error FilePath::uniqueFilePath(const std::string& in_basePath, const std::string& in_extension, FilePath& out_filePath)

}

#ifndef _WIN32

Error FilePath::changeFileMode(const std::string& fileModeStr) const

{

return changeFileModeImpl(getAbsolutePath(), octalStrToFileMode(fileModeStr));

}

Error FilePath::changeFileMode(FileMode in_fileMode, bool in_setStickyBit) const

}

Error FilePath::changeOwnership(

}

#endif

FilePath FilePath::completeChildPath(const std::string& in_filePath) const

}

Error FilePath::completeChildPath(const std::string& in_filePath, FilePath& out_childPath) const

}

FilePath FilePath::completePath(const std::string& in_filePath) const

}

Error FilePath::copy(const FilePath& in_targetPath, bool overwrite) const

}

Error FilePath::copyDirectoryRecursive(const FilePath& in_targetPath, bool overwrite) const

}

Error FilePath::createDirectory(const std::string& in_filePath) const

}

Error FilePath::ensureDirectory() const

}

Error FilePath::ensureFile() const

}

bool FilePath::exists() const

}

std::string FilePath::getAbsolutePath() const

}

std::string FilePath::getAbsolutePathNative() const

}

#ifdef _WIN32

std::wstring FilePath::getAbsolutePathW() const

}

#endif

std::string FilePath::getCanonicalPath() const

}

Error FilePath::getChildren(std::vector<FilePath>& out_filePaths) const

}

Error FilePath::getChildrenRecursive(const RecursiveIterationFunction& in_iterationFunction) const

}

std::string FilePath::getExtension() const

{

return BOOST_FS_STRING(m_impl->Path.extension());

}

std::string FilePath::getExtensionLowerCase() const

{

return boost::algorithm::to_lower_copy(getExtension());

}

#ifndef _WIN32

Error FilePath::getFileMode(FileMode& out_fileMode) const