cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,28 @@
+/**
+ * @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

@@ -0,0 +1,95 @@
+/**
+ * @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

@@ -0,0 +1,51 @@
+#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

@@ -0,0 +1,131 @@
+#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

@@ -0,0 +1,87 @@
+#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

@@ -0,0 +1,195 @@
+#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");
+    }
+}