cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,22 @@
+include_directories(BEFORE ${LEATHERMAN_CATCH_INCLUDE} ${LEATHERMAN_INCLUDE_DIRS})
+add_executable(leatherman_test main.cc ${LEATHERMAN_TEST_SRCS})
+
+if (LEATHERMAN_SHARED)
+    # Include deps first, as they may be static. If they are, linking on Windows can
+    # fail due to multiple definitions for the same symbol.
+    set(LEATHERMAN_TEST_LIBS ${LEATHERMAN_DEPS} ${LEATHERMAN_LIBS})
+else()
+    set(LEATHERMAN_TEST_LIBS ${LEATHERMAN_LIBS} ${LEATHERMAN_DEPS})
+endif()
+
+if (LEATHERMAN_USE_CURL AND LEATHERMAN_INT_CURL_LIBS AND LEATHERMAN_TEST_CURL_LIB)
+    list(REMOVE_ITEM LEATHERMAN_TEST_LIBS ${LEATHERMAN_INT_CURL_LIBS})
+    list(APPEND LEATHERMAN_TEST_LIBS ${LEATHERMAN_TEST_CURL_LIB})
+endif()
+
+# We link libmock_curl instead of real libcurl in tests
+target_link_libraries(leatherman_test ${LEATHERMAN_TEST_LIBS})
+
+leatherman_logging_namespace("leatherman.test")
+set_target_properties(leatherman_test PROPERTIES COMPILE_FLAGS "${LEATHERMAN_CXX_FLAGS}")
+add_test(NAME "leatherman\\ tests" COMMAND leatherman_test)

data/ext/facter/leatherman/tests/main.cc

@@ -0,0 +1,17 @@
+#define CATCH_CONFIG_RUNNER
+#include <catch.hpp>
+
+// To enable log messages:
+// #define ENABLE_LOGGING
+
+#ifdef ENABLE_LOGGING
+#include <leatherman/logging/logging.hpp>
+#endif
+
+int main(int argc, char **argv)
+{
+#ifdef ENABLE_LOGGING
+    leatherman::logging::set_level(leatherman::logging::log_level::debug);
+#endif
+    return Catch::Session().run( argc, argv );
+}

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

@@ -0,0 +1,36 @@
+find_package(Boost 1.54 REQUIRED date_time chrono system)
+
+add_leatherman_deps(${Boost_LIBRARIES})
+add_leatherman_includes("${Boost_INCLUDE_DIRS}")
+
+leatherman_dependency(nowide)
+
+if(WIN32)
+    set(PLATFORM_SRCS "src/windows/time.cc" "src/windows/environment.cc" "src/windows/scoped_handle.cc")
+    set(PLATFORM_TESTS "tests/windows/environment.cc")
+else()
+    set(PLATFORM_SRCS "src/posix/time.cc" "src/posix/environment.cc" "src/posix/scoped_descriptor.cc")
+    set(PLATFORM_TESTS "tests/posix/environment.cc")
+endif()
+
+add_leatherman_headers(inc/leatherman)
+
+add_leatherman_library(
+    src/strings.cc
+    src/time.cc
+    src/environment.cc
+    src/scope_exit.cc
+    src/scoped_env.cc
+    src/uri.cc
+    ${PLATFORM_SRCS}
+    )
+
+add_leatherman_test(
+    tests/scoped_env.cc
+    tests/strings_test.cc
+    tests/option_set.cc
+    tests/environment.cc
+    tests/timer.cc
+    tests/uri.cc
+    ${PLATFORM_TESTS}
+    )

data/ext/facter/leatherman/util/inc/leatherman/util/environment.hpp

@@ -0,0 +1,69 @@
+/**
+* @file
+* Declares utility functions for environment variables.
+*/
+#pragma once
+
+#include <string>
+#include <vector>
+#include <functional>
+
+namespace leatherman { namespace util {
+
+    /**
+     * Represents a platform-agnostic way for manipulating environment variables.
+     */
+    struct environment
+    {
+        /**
+         * Gets an environment variable.
+         * @param name The name of the environment variable to get.
+         * @param value Returns the value of the environment variable.
+         * @return Returns true if the environment variable is present or false if it is not.
+         */
+        static bool get(std::string const& name, std::string& value);
+
+        /**
+         * Sets an environment variable.
+         * Note that on Windows, setting an environment variable to an empty string is
+         * equivalent to clearing it.
+         * @param name The name of the environment variable to set.
+         * @param value The value of the environment variable to set.
+         * @return Returns true if the environment variable could be changed.
+         *         If false, it sets the system error state.
+         */
+        static bool set(std::string const& name, std::string const& value);
+
+        /**
+         * Unsets an environment variable.
+         * @param name The name of the environment variable to unset.
+         * @return Returns true if the environment variable could be unset.
+         *         If false, it sets the system error state.
+         */
+        static bool clear(std::string const& name);
+
+        /**
+         * Gets the platform-specific path separator.
+         * @return Returns the platform-specific path separator.
+         */
+        static char get_path_separator();
+
+        /**
+         * Gets the platform-specific search program paths.
+         * @return Returns the platform-specific program search paths.
+         */
+        static std::vector<std::string> const& search_paths();
+
+        /**
+         * Force search program paths to be reloaded.
+         */
+        static void reload_search_paths();
+
+        /**
+         * Enumerates the environment variables for the current process.
+         * @param callback The callback to call for each environment variable (passes the variable name and value).
+         */
+        static void each(std::function<bool(std::string&, std::string&)> callback);
+    };
+
+}}  // namespace leatherman::util

data/ext/facter/leatherman/util/inc/leatherman/util/option_set.hpp

@@ -0,0 +1,228 @@
+/**
+ * @file
+ * Declares utility type for passing a set of options.
+ */
+#pragma once
+
+#include <numeric>
+#include <string>
+#include <initializer_list>
+
+namespace leatherman { namespace util {
+    /**
+     * Represents a set of options (flags).
+     * Adapted from http://stackoverflow.com/a/4226975/530189
+     * @tparam T The enum class type that makes up the available options.
+     */
+    template <typename T>
+    struct option_set
+    {
+        /**
+         * The underlying enum type for the option set.
+         */
+        typedef T enum_type;
+
+        /**
+         * The value type for the enum type.
+         */
+        typedef typename std::underlying_type<T>::type value_type;
+
+        /**
+         * Constructs an empty option_set.
+         */
+        option_set() : option_set(value_type(0))
+        {
+        }
+
+        /**
+         * Constructs an option_set with the given list of options.
+         * @param values The option values to store in the list.
+         */
+        option_set(std::initializer_list<enum_type> const& values)
+        {
+            // Simply bitwise OR all the values together.
+            _value = std::accumulate(
+                std::begin(values),
+                std::end(values),
+                value_type(0),
+                [](value_type acc, enum_type value) {
+                    return acc | static_cast<value_type>(value);
+                });
+        }
+
+        /**
+         * Constructs an option_set with an existing bitfield value.
+         * @param value
+         */
+        explicit option_set(value_type value) : _value(value)
+        {
+        }
+
+        /**
+         * Gets the underlying value of the set.
+         * @return Returns the underlying value of the set.
+         */
+        value_type value() const
+        {
+            return _value;
+        }
+
+        /**
+         * Used to test if an option is present in the set.
+         * @param option The option to check for.
+         * @return Returns true if the option is in the set or false if it is not.
+         */
+        bool operator [](enum_type option) const
+        {
+           return test(option);
+        }
+
+        /**
+         * Sets all options to true.
+         * @return Returns this option_set.
+         */
+        option_set& set_all()
+        {
+            _value = ~value_type(0);
+            return *this;
+        }
+
+        /**
+         * Sets the given option to true.
+         * @param option The option to set to true.
+         * @return Returns this option_set.
+         */
+        option_set& set(enum_type option)
+        {
+            _value |= static_cast<value_type>(option);
+            return *this;
+        }
+
+        /**
+         * Clears the given option from the set.
+         * @param option The option to clear.
+         * @return Returns this option_set.
+         */
+        option_set& clear(enum_type option)
+        {
+            _value &= ~static_cast<value_type>(option);
+            return *this;
+        }
+
+        /**
+         * Resets the option_set by clearing all options.
+         * @return Returns this option_set.
+         */
+        option_set& reset()
+        {
+            _value = value_type(0);
+            return *this;
+        }
+
+        /**
+         * Toggles all options in the set.
+         * @return Returns this option_set.
+         */
+        option_set& toggle()
+        {
+            _value = ~_value;
+            return *this;
+        }
+
+        /**
+         * Toggles a specific option in the set.
+         * @param option The option to toggle.
+         * @return Returns this option_set.
+         */
+        option_set& toggle(enum_type option)
+        {
+            _value ^= static_cast<value_type>(option);
+            return *this;
+        }
+
+        /**
+         * Gets the count of options in the set.
+         * @return Returns the count of options in the set.
+         */
+        size_t count() const
+        {
+            // Do a simple bit count
+            value_type bits = _value;
+            size_t total = 0;
+            for (; bits != 0; ++total)
+            {
+                bits &= bits - 1;  // clear the least significant bit set
+            }
+            return total;
+        }
+
+        /**
+         * Gets the bit size of the option_set.
+         * The size is based on how many bits are present in the underlying value_type.
+         * @return Returns the bit size of the option_set.
+         */
+        constexpr size_t size() const
+        {
+            return sizeof(value_type)*8;
+        }
+
+        /**
+         * Tests if the given option is in the set.
+         * @param option The option to test for.
+         * @return Returns true if the option is in the set or false if it is not.
+         */
+        bool test(enum_type option) const
+        {
+            return _value & static_cast<value_type>(option);
+        }
+
+        /**
+         * Checks to see if the option_set is empty.
+         * @return Returns true if the set is empty (no options) or false if there are options in the set.
+         */
+        bool empty() const
+        {
+            return _value == 0;
+        }
+
+     private:
+        value_type _value;
+    };
+
+    /**
+     * Bitwise AND operator for option_set.
+     * @param lhs The lefthand option_set.
+     * @param rhs The righthand option_set.
+     * @return Returns an option_set that is the bitwise AND of the two given option_sets.
+     */
+    template<typename T>
+    option_set<T> operator &(option_set<T> const& lhs, option_set<T> const& rhs)
+    {
+        return option_set<T>(lhs.value() & rhs.value());
+    }
+
+    /**
+     * Bitwise OR operator for option_set.
+     * @param lhs The lefthand option_set.
+     * @param rhs The righthand option_set.
+     * @return Returns an option_set that is the bitwise OR of the two given option_sets.
+     */
+    template<typename T>
+    option_set<T> operator |(option_set<T> const& lhs, option_set<T> const& rhs)
+    {
+        return option_set<T>(lhs.value() | rhs.value());
+    }
+
+    /**
+     * Bitwise XOR operator for option_set.
+     * @param lhs The lefthand option_set.
+     * @param rhs The righthand option_set.
+     * @return Returns an option_set that is the bitwise XOR of the two given option_sets.
+     */
+    template<typename T>
+    option_set<T> operator ^(option_set<T> const& lhs, option_set<T> const& rhs)
+    {
+        return option_set<T>(lhs.value() ^ rhs.value());
+    }
+
+}}  // namespace leatherman::execution

data/ext/facter/leatherman/util/inc/leatherman/util/posix/scoped_descriptor.hpp

@@ -0,0 +1,32 @@
+/**
+ * @file
+ * Declares the scoped descriptor resource for managing file/socket descriptors.
+ */
+#pragma once
+
+#include <leatherman/util/scoped_resource.hpp>
+#include <unistd.h>
+
+namespace leatherman { namespace util { namespace posix {
+    /**
+     * Represents a scoped file descriptor for POSIX systems.
+     * Automatically closes the file descriptor when it goes out of scope.
+    */
+    struct scoped_descriptor : scoped_resource<int>
+    {
+        /**
+         * Constructs a scoped_descriptor.
+         * @param descriptor The file descriptor to close when destroyed.
+         */
+        explicit scoped_descriptor(int descriptor);
+
+        /**
+         * Constructs a closed scoped_descriptor.
+         */
+        scoped_descriptor();
+
+     private:
+        static void close(int descriptor);
+    };
+
+}}}  // namespace leatherman::util::posix

data/ext/facter/leatherman/util/inc/leatherman/util/regex.hpp

@@ -0,0 +1,80 @@
+/**
+ * @file
+ * Defines an abstraction for using regular expression calls.
+ */
+#pragma once
+
+#include <boost/regex.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace leatherman { namespace util {
+
+    /**
+     * Helper function for resolving variadic arguments to re_search.
+     * @tparam Text The type of the text to search.
+     * @param txt The text to search.
+     * @param what The pattern to search the text with.
+     * @param depth The current argument depth.
+     * @return Returns true if the match group was found or false if it was not.
+     */
+    template <typename Text>
+    inline bool re_search_helper(Text &txt, const boost::smatch &what, size_t depth)
+    {
+        return true;
+    }
+
+    /**
+     * Helper function for resolving variadic arguments to re_search.
+     * @tparam Text The type of the text to search.
+     * @tparam Arg The type of the current match group argument.
+     * @tparam Args The variadic types of the remaining match group arguments.
+     * @param txt The text to search.
+     * @param what The pattern to search the text with.
+     * @param depth The current argument depth.
+     * @param arg The current match group argument.
+     * @param args The remaining match group arguments.
+     * @return Returns true if the match group was found or false if it was not.
+     */
+    template <typename Text, typename Arg, typename... Args>
+    inline bool re_search_helper(Text const& txt, const boost::smatch &what, size_t depth, Arg arg, Args&&... args)
+    {
+        if (depth >= what.size()) {
+            return false;
+        }
+
+        // If the match was optional and unmatched, skip it and leave the variable uninitialized.
+        if (what[depth].matched) {
+            try {
+                using ArgType = typename std::pointer_traits<Arg>::element_type;
+                auto val = boost::lexical_cast<ArgType>(what[depth]);
+                *arg = val;
+            } catch (const boost::bad_lexical_cast &e) {
+                return false;
+            }
+        }
+
+        return re_search_helper(txt, what, depth+1, std::forward<Args>(args)...);
+    }
+
+    /**
+     * Searches the given text for the given pattern. Optional variadic arguments return matched
+     * subgroups. If a subgroup is optional and unmatched, leaves the argument uninitialized.
+     * @tparam Text The type of the text.
+     * @tparam Args The variadic type of the match group arguments.
+     * @param txt The text to search.
+     * @param pattern The pattern to search the text with.
+     * @param args The returned match groups.
+     * @return Returns true if the text matches the given pattern or false if it does not.
+     */
+    template <typename Text, typename... Args>
+    inline bool re_search(Text const& txt, boost::regex const& pattern, Args&&... args)
+    {
+        boost::smatch what;
+        if (!boost::regex_search(txt, what, pattern)) {
+            return false;
+        }
+
+        return re_search_helper(txt, what, 1, std::forward<Args>(args)...);
+    }
+
+}}  // namespace leatherman::util