cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,37 @@
+#include "fixtures.hpp"
+#include <boost/filesystem.hpp>
+#include <leatherman/file_util/file.hpp>
+
+temp_directory::temp_directory() {
+    auto unique_path = unique_fixture_path();
+    dir_name = unique_path.string();
+
+    boost::filesystem::create_directory(unique_path);
+}
+
+temp_directory::~temp_directory() {
+    boost::filesystem::remove_all(dir_name);
+}
+
+std::string const& temp_directory::get_dir_name() const {
+    return dir_name;
+}
+
+temp_file::temp_file(const std::string &content) {
+    auto unique_path = unique_fixture_path();
+    file_name = unique_path.string();
+
+    leatherman::file_util::atomic_write_to_file(content, file_name);
+}
+
+temp_file::~temp_file() {
+    boost::filesystem::remove(file_name);
+}
+
+std::string const& temp_file::get_file_name() const {
+    return file_name;
+}
+
+boost::filesystem::path unique_fixture_path() {
+    return boost::filesystem::unique_path("file_util_fixture_%%%%-%%%%-%%%%-%%%%");
+}

data/ext/facter/leatherman/file_util/tests/fixtures.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <string>
+#include <boost/filesystem/path.hpp>
+
+/**
+ * Class to create a temporary directory with a unique name
+ * and destroy it once it is no longer needed.
+ * */
+class temp_directory {
+
+public:
+    temp_directory();
+    ~temp_directory();
+    std::string const& get_dir_name() const;
+
+private:
+    std::string dir_name;
+
+};
+
+/**
+ * Class to create a temporary file with a unique name and
+ * destroy it once it is no longer needed.
+ */
+class temp_file {
+
+public:
+    temp_file(std::string const& content);
+    ~temp_file();
+    std::string const& get_file_name() const;
+
+private:
+    std::string file_name;
+
+};
+
+/** Generates a unique string for use as a file path. */
+boost::filesystem::path unique_fixture_path();

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

@@ -0,0 +1,11 @@
+find_package(Boost 1.54 REQUIRED COMPONENTS regex)
+
+add_leatherman_deps("${Boost_LIBRARIES}")
+add_leatherman_includes("${Boost_INCLUDE_DIRS}")
+
+leatherman_dependency(rapidjson)
+leatherman_dependency(locale)
+
+add_leatherman_library("src/json_container.cc")
+add_leatherman_headers("inc/leatherman")
+add_leatherman_test("tests/json_container_test.cc")

data/ext/facter/leatherman/json_container/README.md

@@ -0,0 +1,108 @@
+## JsonContainer
+
+The JsonContainer class provides a simplified abstraction around complex JSON C++
+libraries. It has the following constructors:
+
+    JsonContainer() // Creates an empty container
+    JsonContainer(std::string json_txt) // creates a JsonContainer from a JSON string
+
+Consider the following JSON string wrapped in a JsonContainer object, data.
+
+```
+    {
+      "module" : "puppet",
+      "action" : "run",
+      "params" : {
+        "first" : "--module-path=/home/alice/modules"
+      }
+    }
+```
+
+You can construct a JsonContainer as follows:
+
+```
+    JsonContainer data { jsons_string };
+```
+
+The JsonContainer's constructor can throw the following exception:
+
+ - data_parse_error - This error is thrown when invalid JSON is passed to the constructor.
+
+Note that you can instantiate JsonContainer by passing a non-empty `std::string`
+representing a JSON object, array, or value. In case you want to pass a JSON
+string, you must include escaped double quotes. For example:
+
+```
+    JsonContainer { "4" };  // a number
+    JsonContainer { "\"fast'n bulbous\"" };  // a string
+    JsonContainer { "null" };  // the null value
+    JsonContainer { "" };  // JsonContainer will throw a data_parse_error!
+```
+
+The following calls to the _get_ method will retrieve values from the JsonContainer.
+
+```
+    data.get<std::string>("module"); // == "puppet"
+    data.get<std::string>({ "params", "first" }); // == "--module-path=/home/alice/modules"
+```
+
+Note that when the _get_ method is invoked with an initialiser list it will use
+each argument to descend a level into the object tree. Also, when an unsigned
+integer is provided as index, _get_ will verify that the specified in an array
+and return its requested element.
+
+The _get_ method can throw the following exception:
+
+ - data_key_error - Thrown when the specified entry does not exist.
+ - data_type_error - Thrown when an index is provided but the parent element is not an array.
+ - data_index_error - Thrown when the provided index is out of bounds.
+
+The supported scalar types are: int, double, bool, std::string, and JsonContainer.
+Elements of such types can be grouped in an array, represented by a std::vector
+instance.
+
+You can also set the value of fields and create new fields with the _set_ method.
+```
+    data.set<int>("foo", 42);
+    data.set<bool>({ "params", "second" }, false);
+```
+
+This will change the internal JSON representation to
+
+```
+    {
+      "module" : "puppet",
+      "action" : "run",
+      "params" : {
+        "first" : "--module-path=/home/alice/modules",
+        "second" : false
+      },
+      "foo" : 42
+    }
+```
+
+Note that the _set_ method uses the initialiser list in the same way as the _get_
+method. Each argument to the list is one level to descend.
+
+The _set_ method can throw the following exception:
+
+ - data_key_error - thrown when a nested message key is invalid (i.e. the
+ associated value is not a valid JSON object, so that is not possible to
+ iterate the remaining nested keys) or when the root element is not a valid
+ JSON object, so that is not possible to set the specified key-value entry.
+
+You can use the _type_ method to retrieve the type of a given value. As done for
+_get_ and _set_, you can specify the value's key with an initialiser list, in
+order to navigate multiple levels within a JSON object.
+
+The _type_ method returns a value of the DataType enumeration, defined as:
+
+```
+    enum DataType { Object, Array, String, Int, Bool, Double, Null };
+```
+
+As for the _get_ method, _type_ can throw the following exceptions:
+
+ - data_key_error - Thrown when the specified entry does not exist.
+ - data_type_error - Thrown when an index is provided but the parent element is not an array.
+ - data_index_error - Thrown when the provided index is out of bounds.

data/ext/facter/leatherman/json_container/inc/leatherman/json_container/json_container.hpp

@@ -0,0 +1,443 @@
+#pragma once
+
+#include <vector>
+#include <cstdarg>
+#include <iostream>
+#include <tuple>
+#include <typeinfo>
+#include <memory>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+// Forward declarations for rapidjson
+namespace rapidjson {
+    class CrtAllocator;
+    template <typename Encoding, typename Allocator> class GenericValue;
+    template <typename CharType> struct UTF8;
+    template <typename Encoding, typename Allocator, typename StackAllocator> class GenericDocument;
+}  // namespace rapidjson
+
+namespace leatherman { namespace json_container {
+    // Constants
+    constexpr size_t DEFAULT_LEFT_PADDING { 4 };
+
+    // Errors
+
+    /// Parent error class.
+    class data_error : public std::runtime_error  {
+    public:
+        explicit data_error(std::string const& msg) : std::runtime_error(msg) {}
+    };
+
+    /// Error thrown when trying to parse an invalid JSON string.
+    class data_parse_error : public data_error  {
+    public:
+        explicit data_parse_error(std::string const& msg) : data_error(msg) {}
+    };
+
+    /// Error due to an operation involving a key.
+    class data_key_error : public data_error  {
+    public:
+        explicit data_key_error(std::string const& msg) : data_error(msg) {}
+    };
+
+    /// Error due to an operation involving an array index.
+    class data_index_error : public data_error  {
+    public:
+        explicit data_index_error(std::string const& msg) : data_error(msg) {}
+    };
+
+    /// Error due to wrongly specified type.
+    class data_type_error : public data_error  {
+    public:
+        explicit data_type_error(std::string const& msg) : data_error(msg) {}
+    };
+
+    // Types
+
+    enum DataType { Object, Array, String, Int, Bool, Double, Null };
+
+    struct JsonContainerKey : public std::string {
+        JsonContainerKey(const std::string& value) : std::string(value) {}
+        JsonContainerKey(const char* value) : std::string(value) {}
+        JsonContainerKey(std::initializer_list<char> il) = delete;
+    };
+
+    /**
+     * Typedef for RapidJSON allocator.
+     */
+    using json_allocator = rapidjson::CrtAllocator;
+    /**
+     * Typedef for RapidJSON value.
+     */
+    using json_value = rapidjson::GenericValue<rapidjson::UTF8<char>, json_allocator>;
+    /**
+     * Typedef for RapidJSON document.
+     */
+    using json_document = rapidjson::GenericDocument<rapidjson::UTF8<char>, json_allocator, json_allocator>;
+
+    // Usage:
+    //
+    // SUPPORTED SCALARS:
+    //    int, float, double, bool, std::string, nullptr
+    //
+    // To set a key to a scalar value in object x
+    //    x.set<int>("foo", 1);
+    //    x.set<std::string>(foo", "bar");
+    //
+    // To set a nested key to a scalar value in object x
+    //    x.set<bool>({ "foo", "bar", "baz" }, true);
+    //
+    // To set a key to a vector value in object x
+    //    std::vector<int> tmp { 1, 2, 3 };
+    //    x.set<std::vector<int>>("foo", tmp);
+    //
+    // To get a scalar value from a key in object x
+    //    x.get<std::string>("foo");
+    //    x.get<int>("bar");
+    //
+    // To get a vector from a key in object x
+    //    x.get<std::vector<float>>("foo");
+    //
+    // To get the int entry with index i from the array a in object x
+    //    x.get<int>("a", 1);
+    //
+    // To get a result object (json object) from object x
+    //    x.get<Data>("foo");
+    //
+    // To get a null value from a key in object x
+    //    x.get<std::string>("foo") == "";
+    //    x.get<int>("foo") == 0;
+    //    x.get<bool>("foo") == false;
+    //    x.get<float>("foo") == 0.0f;
+    //    x.get<double>("foo") == 0.0;
+    //
+    // To get a json string representation of object x
+    //    x.toString();
+    //
+    // To check if a key is set in object x
+    //    x.includes("foo");
+    //    x.includes({ "foo", "bar", "baz" });
+
+    class JsonContainer {
+    public:
+        JsonContainer();
+        explicit JsonContainer(const std::string& json_txt);
+        explicit JsonContainer(const json_value& value);
+        JsonContainer(const JsonContainer& data);
+        JsonContainer(const JsonContainer&& data);
+        JsonContainer& operator=(JsonContainer other);
+
+        ~JsonContainer();
+
+        const json_document& getRaw() const;
+
+        std::string toString() const;
+
+        /// Throw a data_key_error in case the specified key is unknown.
+        std::string toString(const JsonContainerKey& key) const;
+
+        /// Throw a data_key_error in case the specified key is unknown.
+        std::string toString(const std::vector<JsonContainerKey>& keys) const;
+
+        // TODO: Refactor this to use a default parameter of DEFAULT_LEFT_PADDING
+        // for left_padding to remove the empty-argument variant.
+        std::string toPrettyString(size_t left_padding) const;
+        std::string toPrettyString() const;
+
+        std::string toPrettyJson(size_t left_padding = DEFAULT_LEFT_PADDING) const;
+
+        /// Return true if the root is an empty JSON array or an empty
+        /// JSON object, false otherwise.
+        bool empty() const;
+
+        /// Return the number of entries of the root element in case
+        /// is an object or array; returns 0 in case of a scalar
+        size_t size() const;
+
+        /// Return the number of entries of the specified element;
+        /// returns 0 in case it's scalar
+        /// Throw a data_key_error in case the specified key is unknown.
+        size_t size(const JsonContainerKey& key) const;
+
+        /// Return the number of entries of the specified element;
+        /// return 0 in case it's scalar
+        /// Throw a data_key_error in case of unknown keys.
+        size_t size(const std::vector<JsonContainerKey>& keys) const;
+
+        /// In case the root entry is an object, returns its keys,
+        /// otherwise an empty vector.
+        std::vector<std::string> keys() const;
+
+        /// Whether the specified entry exists.
+        bool includes(const JsonContainerKey& key) const;
+
+        /// Whether the specified entry exists.
+        bool includes(const std::vector<JsonContainerKey>& keys) const;
+
+        DataType type() const;
+
+        /// Throw a data_key_error in case the specified key is unknown.
+        DataType type(const JsonContainerKey& key) const;
+
+        /// Throw a data_key_error in case of unknown keys.
+        DataType type(const std::vector<JsonContainerKey>& keys) const;
+
+        /// Throw a data_type_error in case the root entry is not an array.
+        /// Throw a data_index_error in case the index is out of bounds.
+        DataType type(const size_t idx) const;
+
+        /// Throw a data_key_error in case the specified key is unknown.
+        /// Throw a data_type_error in case the specified entry is not an array.
+        /// Throw a data_index_error in case the index is out of bound.
+        DataType type(const JsonContainerKey& key, const size_t idx) const;
+
+        /// Throw a data_key_error in case of unknown keys.
+        /// Throw a data_type_error in case the specified entry is not an array.
+        /// Throw a data_index_error in case the index is out of bound.
+        DataType type(const std::vector<JsonContainerKey>& keys, const size_t idx) const;
+
+        /// Return the value of the root entry.
+        /// Throw a data_type_error in case the type of the root entry
+        /// does not match the specified one.
+        template <typename T>
+        T get() const {
+            return getValue<T>(*getValueInJson());
+        }
+
+        /// Return the value of the specified entry of the root object.
+        /// Throw a data_key_error in case the entry does not exist.
+        /// Throw a data_type_error in case the type T doesn't match
+        /// the specified one.
+        template <typename T>
+        T get(const JsonContainerKey& key) const {
+            return getValue<T>(*getValueInJson(std::vector<JsonContainerKey> { key }));
+        }
+
+        /// Return the value of the specified nested entry.
+        /// Throw a data_key_error in case the entry does not exist.
+        /// Throw a data_type_error in case the type T doesn't match
+        /// the specified one.
+        template <typename T>
+        T get(std::vector<JsonContainerKey> keys) const {
+            return getValue<T>(*getValueInJson(keys));
+        }
+
+        /// Return the indexed value of root array.
+        /// Throw a data_index_error in case the index is out of bound.
+        /// Throw a data_type_error in case the type T doesn't match
+        /// the one of the specified value or if the root entry is not
+        /// an array.
+        template <typename T>
+        T get(const size_t idx) const {
+            return getValue<T>(*getValueInJson(std::vector<JsonContainerKey> {},
+                                               true, idx));
+        }
+
+        /// Return the indexed value of the specified array entry.
+        /// Throw a data_key_error in case the array entry is unknown.
+        /// Throw a data_index_error in case the index is out of bound.
+        /// Throw a data_type_error in case the type T doesn't match
+        /// the one of the specified entry or in case the specified
+        /// entry is not an array.
+        template <typename T>
+        T get(const JsonContainerKey& key, const size_t idx) const {
+            return getValue<T>(*getValueInJson(std::vector<JsonContainerKey> { key },
+                                               true, idx));
+        }
+
+        /// Return the indexed value of the specified nested array
+        /// entry.
+        /// Throw a data_key_error in case the array entry is unknown.
+        /// Throw a data_index_error in case the index is out of bound.
+        /// Throw a data_type_error in case the type T doesn't match
+        /// the one of the specified entry or in case the specified
+        /// entry is not an array.
+        template <typename T>
+        T get(std::vector<JsonContainerKey> keys, const size_t idx) const {
+            return getValue<T>(*getValueInJson(keys, true, idx));
+        }
+
+        /// Return the value of the specified entry of the root object,
+        /// or default_value if the entry doesn't exist.
+        /// Throw a data_type_error in case the type T doesn't match
+        /// the specified one or if the root entry is not an object.
+        template <typename T>
+        T getWithDefault(const JsonContainerKey& key, const T default_value) const {
+            auto jval = getValueInJson();
+            auto key_data = key.data();
+
+            if (!isObject(*jval)) {
+                throw data_type_error { _("not an object") };
+            }
+
+            if (!hasKey(*jval, key_data)) {
+                return default_value;
+            }
+
+            return getValue<T>(*getValueInJson(*jval, key_data));
+        }
+
+        /// Return the value of the specified nested entry or
+        /// default_value if the entry doesn't exist but its parent is
+        /// an object.
+        /// Throw a data_type_error in case the type T doesn't match
+        /// the specified one or in case the parent of the specified
+        /// entry is not an object.
+        template <typename T>
+        T getWithDefault(const std::vector<JsonContainerKey>& keys, const T& default_value) const {
+            auto key_data = keys.back().data();
+            auto jval_obj = getValueInJson(keys.cbegin(), keys.cend()-1);
+
+            if (!isObject(*jval_obj)) {
+                throw data_type_error { _("not an object") };
+            }
+
+            if (!hasKey(*jval_obj, key_data)) {
+                return default_value;
+            }
+
+            return getValue<T>(*getValueInJson(*jval_obj, key_data));
+        }
+
+        /// Throw a data_key_error in case the root is not a valid JSON
+        /// object, so that is not possible to set the entry.
+        template <typename T>
+        void set(const JsonContainerKey& key, T value) {
+            auto jval = getValueInJson();
+            auto key_data = key.data();
+
+            if (!isObject(*jval)) {
+                throw data_key_error { _("root is not a valid JSON object") };
+            }
+
+            if (!hasKey(*jval, key_data)) {
+                createKeyInJson(key_data, *jval);
+            }
+
+            setValue<T>(*getValueInJson(*jval, key_data), value);
+        }
+
+        /// Throw a data_key_error if a known nested key is not associated
+        /// with a valid JSON object, so that it is not  possible to
+        /// iterate the remaining keys.
+        template <typename T>
+        void set(std::vector<JsonContainerKey> keys, T value) {
+            auto jval = getValueInJson();
+
+            for (const auto& key : keys) {
+                const char* key_data = key.data();
+
+                if (!isObject(*jval)) {
+                    throw data_key_error { _("invalid key supplied; cannot navigate the provided path") };
+                }
+
+                if (!hasKey(*jval, key_data)) {
+                    createKeyInJson(key_data, *jval);
+                }
+
+                jval = getValueInJson(*jval, key_data);
+            }
+
+            setValue<T>(*jval, value);
+        }
+
+    private:
+        std::unique_ptr<json_document> document_root_;
+
+        size_t getSize(const json_value& jval) const;
+
+        DataType getValueType(const json_value& jval) const;
+
+        bool hasKey(const json_value& jval, const char* key) const;
+
+        // NOTE(ale): we cant' use json_value::IsObject directly
+        // since we have forward declarations for rapidjson; otherwise
+        // we would have an implicit template instantiation error
+        bool isObject(const json_value& jval) const;
+
+        // Root object entry accessor
+        // Throws a data_type_error in case the specified value is not
+        // an object.
+        // Throws a data_key_error or if the key is unknown.
+        json_value* getValueInJson(const json_value& jval,
+                                   const char* key) const;
+
+        // Root array entry accessor
+        // Throws a data_type_error in case the specified value is not
+        // an array.
+        // Throws a data_index_error in case the arraye index is out
+        // of bounds.
+        json_value* getValueInJson(const json_value& jval,
+                                   const size_t& idx) const;
+
+        // Generic entry accessor
+        // In case any key is specified, throws a data_type_error if
+        // the specified entry is not an object; throws a
+        // data_key_error or if the key is unknown.
+        // In case an array element is specified, throws a
+        // data_index_error if the index is out of bounds.
+        json_value* getValueInJson(
+            std::vector<JsonContainerKey>::const_iterator begin,
+            std::vector<JsonContainerKey>::const_iterator end,
+            const bool is_array = false,
+            const size_t idx = 0) const;
+
+        // Generic entry accessor
+        // In case any key is specified, throws a data_type_error if
+        // the specified entry is not an object; throws a
+        // data_key_error or if the key is unknown.
+        // In case an array element is specified, throws a
+        // data_index_error if the index is out of bounds.
+        json_value* getValueInJson(
+            const std::vector<JsonContainerKey>& keys = std::vector<JsonContainerKey> {},
+            const bool is_array = false,
+            const size_t idx = 0) const {
+            return getValueInJson(keys.cbegin(), keys.cend(), is_array, idx);
+        }
+
+        void createKeyInJson(const char* key, json_value& jval);
+
+        template<typename T>
+        T getValue(const json_value& value) const;
+
+        template<typename T>
+        void setValue(json_value& jval, T new_value);
+    };
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, const std::string& new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, const char* new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, bool new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, int new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, double new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, std::vector<std::string> new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, std::vector<bool> new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, std::vector<int> new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, std::vector<double> new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, std::vector<JsonContainer> new_value);
+
+    template<>
+    void JsonContainer::setValue<>(json_value& jval, JsonContainer new_value);
+
+}}  // namespace leatherman::json_container