facter 3.12.2.cfacter.20181217 → 4.0.7.pre

data/ext/facter/leatherman/file_util/CMakeLists.txt

@@ -1,18 +0,0 @@
-find_package(Boost 1.54 REQUIRED COMPONENTS regex filesystem system)
-
-add_leatherman_deps("${Boost_LIBRARIES}")
-add_leatherman_includes("${Boost_INCLUDE_DIRS}")
-
-leatherman_dependency(nowide)
-leatherman_dependency(locale)
-leatherman_dependency(logging)
-leatherman_dependency(util)
-
-if (BUILDING_LEATHERMAN)
-    leatherman_logging_namespace("leatherman.file_util")
-    leatherman_logging_line_numbers()
-endif()
-
-add_leatherman_library(src/directory.cc src/file.cc)
-add_leatherman_headers(inc/leatherman)
-add_leatherman_test(tests/file_utils_test.cc tests/directory_utils_test.cc tests/fixtures.cc)

data/ext/facter/leatherman/file_util/inc/leatherman/file_util/directory.hpp

@@ -1,28 +0,0 @@
-/**
- * @file
- * Declares utility functions for enumerating directories.
- */
-#pragma once
-
-#include <string>
-#include <functional>
-
-namespace leatherman { namespace file_util {
-
-    /**
-     * Enumerates the files that match the given pattern in the given directory.
-     * @param directory The directory to search for the files.
-     * @param callback The callback to invoke when a matching file is found.
-     * @param pattern The pattern to filter the file names by.  If empty, all files are passed.
-     */
-    void each_file(std::string const& directory, std::function<bool(std::string const&)> const& callback, std::string const& pattern = {});
-
-    /**
-     * Enumerates the subdirectories in the given directory.
-     * @param directory The directory to search for the subdirectories.
-     * @param callback The callback to invoke when a matching subdirectory is found.
-     * @param pattern The pattern to filter the subdirectory names by.  If empty, all subdirectories are passed.
-     */
-    void each_subdirectory(std::string const& directory, std::function<bool(std::string const&)> const& callback, std::string const& pattern = {});
-
-}}  // namespace leatherman::file_util

data/ext/facter/leatherman/file_util/inc/leatherman/file_util/file.hpp

@@ -1,95 +0,0 @@
-/**
- * @file
- * Declares utility functions for reading data from files.
- */
-#pragma once
-
-#include <boost/filesystem.hpp>
-#include <boost/optional.hpp>
-
-#include <string>
-#include <stdexcept>
-#include <functional>
-
-namespace leatherman { namespace file_util {
-
-    /**
-     * Reads each line from the given file.
-     * @param path The path to the file to read.
-     * @param callback The callback function that is passed each line in the file.
-     * @return Returns true if the file was opened successfully or false if it was not.
-     */
-    bool each_line(std::string const& path, std::function<bool(std::string &)> callback);
-
-    /**
-     * Reads the entire contents of the given file into a string.
-     * @param path The path of the file to read.
-     * @return Returns the file contents as a string.
-     */
-    std::string read(std::string const& path);
-
-    /**
-     * Reads the entire contents of the given file into a string.
-     * @param path The path of the file to read.
-     * @param contents The returned file contents.
-     * @return Returns true if the contents were read or false if the file is not readable.
-     */
-    bool read(std::string const& path, std::string& contents);
-
-    /**
-     *@return Returns true if the specified file exists and can
-     *      be read by the current process.
-     */
-    bool file_readable(const std::string &file_path);
-
-    /**
-     * Writes content to a temporary file in the specified mode, then
-     * renames the file to the desired path. If the file already exists,
-     * its previous content will be deleted, so appending is not
-     * possible.
-     * @param text The content to be written
-     * @param file_path The final destination and name of the file
-     * @param mode The mode in which to write the file
-     *
-     * Throws an error in case it fails to open the file to write.
-     */
-    void atomic_write_to_file(const std::string &text,
-                              const std::string &file_path,
-                              std::ios_base::openmode mode = std::ios::binary);
-
-    /**
-     * Writes content to a temporary file in the specified mode, then
-     * renames the file to the desired path. If the file already exists,
-     * its previous content will be deleted, so appending is not
-     * possible.
-     * @param text The content to be written
-     * @param file_path The final destination and name of the file
-     * @param perms The file permissions to apply to the file.
-     *              On Windows this only toggles read-only.
-     * @param mode The mode in which to write the file
-     *
-     * Throws an error in case it fails to open the file to write.
-     */
-    void atomic_write_to_file(const std::string &text,
-                              const std::string &file_path,
-                              boost::optional<boost::filesystem::perms> perms,
-                              std::ios_base::openmode mode);
-
-    /**
-     * Expands a leading tilde to the user's home directory
-     * @return Returns the expanded path, or the original string
-     *         in case the expansion fails.
-     */
-    std::string tilde_expand(std::string path);
-
-    /**
-     * @return Returns a shell-safe version of the path
-     */
-    std::string shell_quote(std::string path);
-
-    /**
-     * @return Returns the home path for the current platform.
-     */
-    std::string get_home_path();
-
-}}  // namespace leatherman::file_util

data/ext/facter/leatherman/file_util/src/directory.cc

@@ -1,51 +0,0 @@
-#include <leatherman/file_util/directory.hpp>
-#include <leatherman/util/regex.hpp>
-#include <boost/filesystem.hpp>
-
-using namespace std;
-using namespace boost::filesystem;
-using namespace leatherman::util;
-
-namespace leatherman { namespace file_util {
-
-    static void each(string const& directory, file_type type, function<bool(string const&)> const& callback, string const& pattern)
-    {
-        boost::regex regex;
-        if (!pattern.empty()) {
-            regex = pattern;
-        }
-
-        // Attempt to iterate the directory
-        boost::system::error_code ec;
-        directory_iterator it = directory_iterator(directory, ec);
-        if (ec) {
-            return;
-        }
-
-        // Call the callback for any matching entries
-        directory_iterator end;
-        for (; it != end; ++it) {
-            ec.clear();
-            auto status = it->status(ec);
-            if (ec || (status.type() != type)) {
-                continue;
-            }
-            if (regex.empty() || re_search(it->path().filename().string(), regex)) {
-                if (!callback(it->path().string())) {
-                    break;
-                }
-            }
-        }
-    }
-
-    void each_file(string const& directory, function<bool(string const&)> const& callback, string const& pattern)
-    {
-        each(directory, regular_file, callback, pattern);
-    }
-
-    void each_subdirectory(string const& directory, function<bool(string const&)> const& callback, string const& pattern)
-    {
-        each(directory, directory_file, callback, pattern);
-    }
-
-}}  // namespace leatherman::file_util

data/ext/facter/leatherman/file_util/src/file.cc

@@ -1,131 +0,0 @@
-#include <leatherman/file_util/file.hpp>
-#include <boost/nowide/fstream.hpp>
-#include <boost/nowide/cenv.hpp>
-#include <boost/filesystem.hpp>
-#include <sstream>
-#include <leatherman/logging/logging.hpp>
-#include <leatherman/locale/locale.hpp>
-
-// Mark string for translation (alias for leatherman::locale::format)
-using leatherman::locale::_;
-
-using namespace std;
-
-namespace leatherman { namespace file_util {
-
-namespace boost_error = boost::system::errc;
-namespace boost_file = boost::filesystem;
-
-    bool each_line(string const& path, function<bool(string &)> callback) {
-        boost::nowide::ifstream in(path.c_str());
-        if (!in) {
-            return false;
-        }
-
-        string line;
-        while (getline(in, line)) {
-            if (!callback(line)) {
-                break;
-            }
-        }
-        return true;
-    }
-
-    string read(string const& path) {
-        string contents;
-        if (!read(path, contents)) {
-            return {};
-        }
-        return contents;
-    }
-
-    bool read(string const& path, string& contents) {
-        boost::nowide::ifstream in(path.c_str(), ios::in | ios::binary);
-        ostringstream buffer;
-        if (!in) {
-            return false;
-        }
-        buffer << in.rdbuf();
-        contents = buffer.str();
-        return true;
-    }
-
-    bool file_readable(const std::string &file_path) {
-        bool exists { false };
-        if (file_path.empty()) {
-            LOG_WARNING("file path is an empty string");
-        } else {
-            boost::system::error_code ec;
-            boost_file::file_status status = boost_file::status(file_path.c_str(), ec);
-            if (boost_file::exists(status) && !boost_file::is_directory(status)) {
-                boost::nowide::ifstream file_stream(file_path.c_str());
-                exists = file_stream.good();
-                file_stream.close();
-            } else {
-                LOG_DEBUG("Error reading file: {1}", ec.message());
-                exists = false;
-            }
-        }
-        return exists;
-    }
-
-    void atomic_write_to_file(const std::string &text,
-                              const std::string &file_path,
-                              std::ios_base::openmode mode) {
-        atomic_write_to_file(text, file_path, {}, mode);
-    }
-
-    void atomic_write_to_file(const std::string &text,
-                              const std::string &file_path,
-                              boost::optional<boost_file::perms> perms,
-                              std::ios_base::openmode mode) {
-        boost::nowide::ofstream ofs;
-        std::string tmp_name = file_path + "~";
-        ofs.open(tmp_name.c_str(), mode);
-        if (!ofs.is_open()) {
-            throw boost_file::filesystem_error { _("failed to open {1}", file_path),
-                                                        boost_error::make_error_code(
-                                                                boost_error::io_error) };
-        }
-
-        if (perms) {
-            boost_file::permissions(tmp_name, *perms);
-        }
-
-        ofs << text;
-        ofs.close();
-        boost_file::rename(tmp_name.data(), file_path.data());
-    }
-
-    std::string tilde_expand(std::string path) {
-        if (path[0] == '~' && (path.size() == 1 || path[1] == '/')) {
-            auto result = get_home_path();
-            result.append(path.begin() + 1, path.end());
-            return result;
-        }
-        return path;
-    }
-
-    std::string shell_quote(std::string path) {
-        std::stringstream ss;
-        ss << boost::io::quoted(path);
-        return ss.str();
-    }
-
-    std::string get_home_path() {
-        #ifdef _WIN32
-            auto home_var = "USERPROFILE";
-            auto result = boost::nowide::getenv(home_var);
-        #else
-            auto home_var = "HOME";
-            auto result = boost::nowide::getenv(home_var);
-        #endif
-        if (result){
-            return result;
-        } else {
-            LOG_WARNING("{1} has not been set", home_var);
-            return "";
-        }
-    }
-
-}}  // namespace leatherman::file_util

data/ext/facter/leatherman/file_util/tests/directory_utils_test.cc

@@ -1,87 +0,0 @@
-#include <catch.hpp>
-#include <leatherman/file_util/file.hpp>
-#include <leatherman/file_util/directory.hpp>
-#include "fixtures.hpp"
-#include <boost/filesystem.hpp>
-
-using namespace leatherman::file_util;
-
-TEST_CASE("file_util::each_file", "[utils]") {
-
-    temp_directory directory;
-    atomic_write_to_file("1\n", directory.get_dir_name() + "/test1");
-    atomic_write_to_file("2\n", directory.get_dir_name() + "/test2");
-    atomic_write_to_file("3\n", directory.get_dir_name() + "/test3");
-
-    SECTION("each file should be visited") {
-        std::set<std::string> file_contents;
-        each_file(directory.get_dir_name(), [&file_contents](std::string const &path) {
-            file_contents.insert(read(path));
-            return true;
-        });
-        REQUIRE(file_contents.size() == 3u);
-        REQUIRE(file_contents.find("1\n") != file_contents.end());
-        REQUIRE(file_contents.find("2\n") != file_contents.end());
-        REQUIRE(file_contents.find("3\n") != file_contents.end());
-    }
-
-    SECTION("can find a file to match a pattern") {
-        std::string content = "N/A";
-        each_file(directory.get_dir_name(), [&content](std::string const &path) {
-            return read(path, content);
-        }, "[0-1]");
-        REQUIRE(content == "1\n");
-    }
-
-    SECTION("only one file returned from false callback"){
-        int count = 0;
-        each_file(directory.get_dir_name(), [&count](std::string const& path){
-            count++;
-            return false;
-        });
-        REQUIRE(count == 1);
-    }
-
-}
-
-TEST_CASE("file_util::each_subdirectory", "[utils]") {
-    temp_directory directory;
-    boost::filesystem::create_directory(directory.get_dir_name() + "/test1");
-    atomic_write_to_file("1", directory.get_dir_name() + "/test1/t1");
-    boost::filesystem::create_directory(directory.get_dir_name() + "/test2");
-    atomic_write_to_file("2a", directory.get_dir_name() + "/test2/t2a");
-    atomic_write_to_file("2b", directory.get_dir_name() + "/test2/t2b");
-
-    SECTION("each subdirectory should be visited") {
-        int counter = 0;
-        each_subdirectory(directory.get_dir_name(), [&counter](std::string const &path) {
-            each_file(path, [&counter](std::string const &file) {
-                counter++;
-                return true;
-            });
-            return true;
-        });
-        REQUIRE(counter == 3);
-    }
-
-    SECTION("can find directories that match a pattern") {
-        int counter = 0;
-        each_subdirectory(directory.get_dir_name(), [&counter](std::string const &path) {
-            each_file(path, [&counter](std::string const &file) {
-                counter++;
-                return true;
-            });
-            return true;
-        }, "[2-3]");
-        REQUIRE(counter == 2);
-    }
-
-    SECTION("only one directory found from false callback"){
-        int count = 0;
-        each_subdirectory(directory.get_dir_name(), [&count](std::string const& path){
-            count++;
-            return false;
-        });
-        REQUIRE(count == 1);
-    }
-}

data/ext/facter/leatherman/file_util/tests/file_utils_test.cc

@@ -1,195 +0,0 @@
-#include <catch.hpp>
-#include <leatherman/file_util/file.hpp>
-#include "fixtures.hpp"
-#include <boost/filesystem.hpp>
-
-#ifdef _WIN32
-#include <windows.h>
-#endif
-
-using namespace leatherman::file_util;
-
-TEST_CASE("file_util::tilde_expand", "[utils]") {
-
-#ifdef _WIN32
-    _putenv("USERPROFILE=/testhome");
-#else
-    setenv("HOME", "/testhome", 1);
-#endif
-
-    SECTION("empty path should be empty") {
-        REQUIRE(tilde_expand("") == "");
-    }
-
-    SECTION("spaces should be preserved") {
-        REQUIRE(tilde_expand("i like spaces") == "i like spaces");
-    }
-
-    SECTION("should expand using environment variable") {
-        CHECK(tilde_expand("~") == "/testhome");
-        CHECK(tilde_expand("~/") == "/testhome/");
-        CHECK(tilde_expand("~/foo") == "/testhome/foo");
-    }
-
-    SECTION("only a ~ at the start") {
-        REQUIRE(tilde_expand("/foo/bar~") == "/foo/bar~");
-    }
-
-    SECTION("~baz/foo does not expand") {
-        REQUIRE(tilde_expand("~baz/foo") == "~baz/foo");
-    }
-
-    SECTION("it should expand the home directory path") {
-        REQUIRE(tilde_expand("~/foo") != "~/foo");
-    }
-
-    SECTION("it should not expand the working directory path") {
-        REQUIRE(tilde_expand("./foo") == "./foo");
-    }
-
-    auto home_path = get_home_path();
-
-    SECTION("it should expand ~ to the HOME env var") {
-        REQUIRE(tilde_expand("~") == home_path);
-    }
-
-    SECTION("it should expand ~ as the base directory") {
-        std::string expected_path{home_path + "/spam"};
-        std::string expanded_path{tilde_expand("~/spam")};
-        REQUIRE(expanded_path == expected_path);
-    }
-}
-
-TEST_CASE("shell_quote", "[utils]") {
-    SECTION("empty string") {
-        REQUIRE(shell_quote("") == "\"\"");
-    }
-
-    SECTION("single word") {
-        REQUIRE(shell_quote("plain") == "\"plain\"");
-    }
-
-    SECTION("words separated by space") {
-        REQUIRE(shell_quote("a space") == "\"a space\"");
-    }
-
-    SECTION("exclamation mark") {
-        REQUIRE(shell_quote("!csh") == "\"!csh\"");
-    }
-
-    SECTION("single quote before expression") {
-        REQUIRE(shell_quote("'open quote") == "\"'open quote\"");
-    }
-
-    SECTION("single quote after expression") {
-        REQUIRE(shell_quote("close quote'") == "\"close quote'\"");
-    }
-
-    SECTION("double quote before expression") {
-        REQUIRE(shell_quote("\"open doublequote")
-                == "\"\\\"open doublequote\"");
-    }
-
-    SECTION("double quote after expression") {
-        REQUIRE(shell_quote("close doublequote\"")
-                == "\"close doublequote\\\"\"");
-    }
-}
-
-TEST_CASE("lth_file::file_readable", "[utils]") {
-    SECTION("it can check that a file does not exist") {
-        auto file_path = unique_fixture_path().string();
-        CAPTURE(file_path);
-        REQUIRE_FALSE(file_readable(file_path));
-    }
-
-    SECTION("directories are not readable") {
-        temp_directory dir_path;
-        REQUIRE_FALSE(file_readable(dir_path.get_dir_name()));
-    }
-}
-
-TEST_CASE("lth_file::atomic_write_to_file", "[utils]") {
-    SECTION("it can write to a regular file, ensure it exists, and delete it") {
-        auto file_path = unique_fixture_path().string();
-        REQUIRE_FALSE(file_readable(file_path));
-        atomic_write_to_file("test\n", file_path);
-        REQUIRE(file_readable(file_path));
-        boost::filesystem::remove(file_path);
-        REQUIRE_FALSE(file_readable(file_path));
-    }
-
-    SECTION("can write to an existing file") {
-        temp_file file("existing file");
-        REQUIRE(file_readable(file.get_file_name()));
-        atomic_write_to_file("test", file.get_file_name());
-        REQUIRE(file_readable(file.get_file_name()));
-        REQUIRE(read(file.get_file_name()) == "test");
-    }
-
-#ifndef _WIN32
-    SECTION("can write a file with permissions") {
-        auto file_path = unique_fixture_path().string();
-        REQUIRE_FALSE(file_readable(file_path));
-        auto perms = boost::filesystem::owner_read | boost::filesystem::owner_write;
-        atomic_write_to_file("test\n", file_path, perms, std::ios::binary);
-        REQUIRE(file_readable(file_path));
-        auto stat = boost::filesystem::status(file_path);
-        REQUIRE(stat.permissions() == perms);
-        boost::filesystem::remove(file_path);
-        REQUIRE_FALSE(file_readable(file_path));
-    }
-#endif
-}
-
-TEST_CASE("file_util::read", "[utils]") {
-
-    SECTION("trying to read a nonexistent file returns the empty string"){
-        std::string contents;
-        REQUIRE(read("does_not_exist") == "");
-        REQUIRE_FALSE(read("does_not_exist", contents));
-        REQUIRE(contents.empty());
-    }
-
-    SECTION("it can read from a file") {
-        auto file_path = unique_fixture_path().string();
-        atomic_write_to_file("test\n", file_path);
-        REQUIRE(file_readable(file_path));
-        std::string contents;
-        REQUIRE(read(file_path, contents));
-        REQUIRE(contents == "test\n");
-        REQUIRE(read(file_path) == "test\n");
-        boost::filesystem::remove(file_path);
-    }
-}
-
-TEST_CASE("file_util::each_line", "[utils]") {
-
-    SECTION("trying to read a nonexistent file returns false") {
-        REQUIRE_FALSE(each_line("does_not_exist", [](std::string &line) {
-            FAIL("should not be called");
-            return true;
-        }));
-    }
-
-    SECTION("an action is performed on each line of a file") {
-        temp_file file("test1\ntest2\ntest3\n");
-        int i = 0;
-        REQUIRE(each_line(file.get_file_name(), [&i](std::string const &line) {
-            i++;
-            return line == ("test" + std::to_string(i));
-        }));
-        REQUIRE(i == 3);
-    }
-
-    SECTION("a callback that returns false stops at the first line"){
-        temp_file file("test1\ntest2\ntest3\n");
-        std::vector<std::string> lines;
-        REQUIRE(each_line(file.get_file_name(), [&](std::string& line) {
-            lines.emplace_back(move(line));
-            return false;
-        }));
-        REQUIRE(lines.size() == 1u);
-        REQUIRE(lines[0] == "test1");
-    }
-}