facter 2.5.7 → 3.9.6.cfacter.20180606

data/ext/facter/cpp-hocon/lib/inc/hocon/config_syntax.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+enum class config_syntax {
+    /**
+     * Pedantically strict <a href="http://json.org">JSON</a> format; no
+     * comments, no unexpected commas, no duplicate keys in the same object.
+     * Associated with the <code>.json</code> file extension and
+     * <code>application/json</code> Content-Type.
+     */
+    JSON,
+
+    /**
+     * The JSON-superset <a
+     * href="https://github.com/typesafehub/config/blob/master/HOCON.md"
+     * >HOCON</a> format. Associated with the <code>.conf</code> file extension
+     * and <code>application/hocon</code> Content-Type.
+     */
+    CONF,
+
+    /** Used as a default */
+    UNSPECIFIED
+
+    // Original project also supported Java's .properties formats, but we do not
+};

data/ext/facter/cpp-hocon/lib/inc/hocon/config_value.hpp

@@ -0,0 +1,267 @@
+
+#pragma once
+
+#include "config_origin.hpp"
+#include "config_render_options.hpp"
+#include "config_mergeable.hpp"
+#include "path.hpp"
+#include <string>
+#include <vector>
+#include "export.h"
+#include <leatherman/locale/locale.hpp>
+
+namespace hocon {
+
+    class unmergeable;
+    class resolve_source;
+    class resolve_context;
+
+    template<typename T>
+    struct resolve_result;
+
+    enum class resolve_status { RESOLVED, UNRESOLVED };
+
+    /**
+     * An immutable value, following the <a href="http://json.org">JSON</a> type
+     * schema.
+     *
+     * <p>
+     * Because this object is immutable, it is safe to use from multiple threads and
+     * there's no need for "defensive copies."
+     *
+     * <p>
+     * <em>Do not implement interface {@code ConfigValue}</em>; it should only be
+     * implemented by the config library. Arbitrary implementations will not work
+     * because the library internals assume a specific concrete implementation.
+     * Also, this interface is likely to grow new methods over time, so third-party
+     * implementations will break.
+     */
+    class LIBCPP_HOCON_EXPORT config_value : public config_mergeable, public std::enable_shared_from_this<config_value> {
+        friend class token;
+        friend class value;
+        friend class default_transformer;
+        friend class config;
+        friend class config_object;
+        friend class simple_config_object;
+        friend class simple_config_list;
+        friend class config_concatenation;
+        friend class resolve_context;
+        friend class config_delayed_merge;
+        friend class config_delayed_merge_object;
+    public:
+        /**
+         * The type of a configuration value (following the <a
+         * href="http://json.org">JSON</a> type schema).
+         */
+        enum class type {
+            OBJECT, LIST, NUMBER, BOOLEAN, CONFIG_NULL, STRING, UNSPECIFIED
+        };
+        static char const* type_name(type t) {
+            switch (t) {
+                case type::OBJECT: return "object";
+                case type::LIST: return "list";
+                case type::NUMBER: return "number";
+                case type::BOOLEAN: return "boolean";
+                case type::CONFIG_NULL: return "null";
+                case type::STRING: return "string";
+                case type::UNSPECIFIED: return "unspecified";
+                default: throw std::logic_error(leatherman::locale::format("Got impossible value for type enum"));
+            }
+        }
+
+        /**
+         * The origin of the value (file, line number, etc.), for debugging and
+         * error messages.
+         *
+         * @return where the value came from
+         */
+        virtual shared_origin const& origin() const;
+
+        /**
+         * The type of the value; matches the JSON type schema.
+         *
+         * @return value's type
+         */
+        virtual type value_type() const = 0;
+
+        /**
+         * The printable name of the value type.
+         *
+         * @return value's type's name
+         */
+        char const* value_type_name() const {
+            return type_name(value_type());
+        }
+
+        virtual unwrapped_value unwrapped() const = 0;
+
+        /**
+         * Renders the config value as a HOCON string. This method is primarily
+         * intended for debugging, so it tries to add helpful comments and
+         * whitespace.
+         *
+         * <p>
+         * If the config value has not been resolved (see {@link config#resolve}),
+         * it's possible that it can't be rendered as valid HOCON. In that case the
+         * rendering should still be useful for debugging but you might not be able
+         * to parse it. If the value has been resolved, it will always be parseable.
+         *
+         * <p>
+         * This method is equivalent to
+         * {@code render(config_render_options())}.
+         *
+         * @return the rendered value
+         */
+        virtual std::string render() const;
+
+        /**
+         * Renders the config value to a string, using the provided options.
+         *
+         * <p>
+         * If the config value has not been resolved (see {@link config#resolve}),
+         * it's possible that it can't be rendered as valid HOCON. In that case the
+         * rendering should still be useful for debugging but you might not be able
+         * to parse it. If the value has been resolved, it will always be parseable.
+         *
+         * <p>
+         * If the config value has been resolved and the options disable all
+         * HOCON-specific features (such as comments), the rendering will be valid
+         * JSON. If you enable HOCON-only features such as comments, the rendering
+         * will not be valid JSON.
+         *
+         * @param options
+         *            the rendering options
+         * @return the rendered value
+         */
+        virtual std::string render(config_render_options options) const;
+
+        /**
+         * Places the value inside a {@link config} at the given key. See also
+         * {@link config_value#at_path(string)}.
+         *
+         * @param key
+         *            key to store this value at.
+         * @return a {@code config} instance containing this value at the given key.
+         */
+        shared_config at_key(std::string const& key) const;
+
+        /**
+         * Places the value inside a {@link config} at the given path. See also
+         * {@link config_value#at_key(String)}.
+         *
+         * @param path
+         *            path to store this value at.
+         * @return a {@code config} instance containing this value at the given
+         *         path.
+         */
+        shared_config at_path(std::string const& path_expression) const;
+
+        /**
+         * Returns a {@code config_value} based on this one, but with the given
+         * origin. This is useful when you are parsing a new format of file or setting
+         * comments for a single config_value.
+         *
+         * @param origin the origin set on the returned value
+         * @return the new config_value with the given origin
+         */
+        virtual shared_value with_origin(shared_origin origin) const;
+
+        /**
+         * This is used when including one file in another; the included file is
+         * relativized to the path it's included into in the parent file. The point
+         * is that if you include a file at foo.bar in the parent, and the included
+         * file as a substitution ${a.b.c}, the included substitution now needs to
+         * be ${foo.bar.a.b.c} because we resolve substitutions globally only after
+         * parsing everything.
+         *
+         * @param prefix
+         * @return value relativized to the given path or the same value if nothing
+         *         to do
+         */
+        virtual shared_value relativized(std::string prefix) const { return shared_from_this(); }
+
+        virtual resolve_status get_resolve_status() const;
+
+        friend resolve_status resolve_status_from_values(std::vector<shared_value> const& v);
+
+        std::shared_ptr<const config_mergeable> with_fallback(std::shared_ptr<const config_mergeable> other) const override;
+
+        virtual bool operator==(config_value const& other) const = 0;
+
+        virtual std::string transform_to_string() const;
+
+    protected:
+        config_value(shared_origin origin);
+
+        virtual void render(std::string& result, int indent, bool at_root, std::string const& at_key, config_render_options options) const;
+        virtual void render(std::string& result, int indent, bool at_root, config_render_options options) const;
+        static void indent(std::string& result, int indent, config_render_options const& options);
+
+        shared_config at_key(shared_origin origin, std::string const& key) const;
+        shared_config at_path(shared_origin origin, path raw_path) const;
+
+        virtual shared_value new_copy(shared_origin origin) const = 0;
+
+        virtual resolve_result<shared_value>
+            resolve_substitutions(resolve_context const& context, resolve_source const& source) const;
+
+        static std::vector<shared_value> replace_child_in_list(std::vector<shared_value> const& values,
+                                                               shared_value const& child, shared_value replacement);
+        static bool has_descendant_in_list(std::vector<shared_value> const& values, shared_value const& descendant);
+
+        class modifier {
+         public:
+            virtual shared_value modify_child_may_throw(std::string key_or_null, shared_value v) = 0;
+        };
+
+        class no_exceptions_modifier : public modifier {
+        public:
+            no_exceptions_modifier(std::string prefix);
+
+            shared_value modify_child_may_throw(std::string key_or_null, shared_value v) override;
+            shared_value modify_child(std::string key, shared_value v) const;
+        private:
+            std::string _prefix;
+        };
+        void require_not_ignoring_fallbacks() const;
+
+        /* this is virtualized rather than a field because only some subclasses
+         * really need to store the boolean, and they may be able to pack it
+         * with another boolean to save space.
+         */
+        virtual bool ignores_fallbacks() const;
+        virtual shared_value with_fallbacks_ignored() const;
+
+        shared_value merged_with_the_unmergeable(std::vector<shared_value> stack,
+                                                 std::shared_ptr<const unmergeable> fallback) const;
+        shared_value merged_with_the_unmergeable(std::shared_ptr<const unmergeable> fallback) const;
+
+        shared_value merged_with_object(std::vector<shared_value> stack, shared_object fallback) const;
+        virtual shared_value merged_with_object(shared_object fallback) const;
+
+        shared_value merged_with_non_object(std::vector<shared_value> stack, shared_value fallback) const;
+        shared_value merged_with_non_object(shared_value fallback) const;
+
+        virtual shared_value construct_delayed_merge(shared_origin origin, std::vector<shared_value> stack) const;
+
+        shared_value to_fallback_value() const override;
+
+        template<typename T>
+        static bool equals(config_value const& other, std::function<bool(T const&)> checker)
+        {
+            // Use pointer casts to avoid exceptions.
+            auto other_t = dynamic_cast<T const*>(&other);
+            if (!other_t) {
+                return false;
+            }
+
+            // Pass to checker as a reference to clarify the object will exist.
+            return checker(*other_t);
+        }
+
+    private:
+        shared_value delay_merge(std::vector<shared_value> stack, shared_value fallback) const;
+
+        shared_origin _origin;
+    };
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/hocon/config_value_factory.hpp

@@ -0,0 +1,48 @@
+# pragma once
+
+#include "types.hpp"
+#include "export.h"
+#include <string>
+
+namespace hocon {
+    class LIBCPP_HOCON_EXPORT config_value_factory {
+         public:
+         /**
+          * Creates a {@link ConfigValue} from a plain value, which may be
+          * a <code>bool</code>, <code>long</code>, <code>string</code>,
+          * <code>unordered_map</code>, <code>vector</code> or <code>nullptr</code>. An
+          * <code>unordered_map</code> must be a <code>unordered_map</code> from string to more values
+          * that can be supplied to <code>from_any_ref()</code>. An <code>unordered_map</code>
+          * will become a {@link ConfigObject} and a <code>vector</code> will become a
+          * {@link ConfigList}.
+          *
+          * <p>
+          * In a <code>unordered_map</code> passed to <code>from_any_ref()</code>, the map's keys
+          * are plain keys, not path expressions. So if your <code>unordered_map</code> has a
+          * key "foo.bar" then you will get one object with a key called "foo.bar",
+          * rather than an object with a key "foo" containing another object with a
+          * key "bar".
+          *
+          * <p>
+          * The origin_description will be used to set the origin() field on the
+          * ConfigValue. It should normally be the name of the file the values came
+          * from, or something short describing the value such as "default settings".
+          * The origin_description is prefixed to error messages so users can tell
+          * where problematic values are coming from.
+          *
+          * <p>
+          * Supplying the result of ConfigValue.unwrapped() to this function is
+          * guaranteed to work and should give you back a ConfigValue that matches
+          * the one you unwrapped. The re-wrapped ConfigValue will lose some
+          * information that was present in the original such as its origin, but it
+          * will have matching values.
+          *
+          * @param unwrapped_value object
+          *         object to convert to ConfigValue
+          * @param string origin_description
+          *         name of origin file or brief description of what the value is
+          * @return shared_value a new value
+          * */
+       static shared_value from_any_ref(unwrapped_value value, std::string origin_description = "");
+    };
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/hocon/functional_list.hpp

@@ -0,0 +1,318 @@
+#pragma once
+
+#include <cassert>
+#include <memory>
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <iostream>  // print
+
+template<class T> class FwdListIter;
+
+template<class T>
+class List
+{
+    struct Item
+    {
+        Item(T v, std::shared_ptr<const Item> tail)
+                : _val(v), _next(std::move(tail))
+        {}
+        // singleton
+        explicit Item(T v) : _val(v) {}
+        // ~Item() { std::cout << "~" << _val << std::endl; }
+        T _val;
+        std::shared_ptr<const Item> _next;
+    };
+    friend Item;
+    explicit List(std::shared_ptr<const Item> items)
+            : _head(std::move(items)) {}
+public:
+    // Empty list
+    List() {}
+    // Cons
+    List(T v, List const & tail)
+            : _head(std::make_shared<Item>(v, tail._head)) {}
+    // Singleton
+    explicit List(T v) : _head(std::make_shared<Item>(v)) {}
+
+    bool isEmpty() const { return !_head; }  // conversion to bool
+    T front() const
+    {
+        assert(!isEmpty());
+        return _head->_val;
+    }
+    List popped_front() const
+    {
+        assert(!isEmpty());
+        return List(_head->_next);
+    }
+    // Additional utilities
+    List pushed_front(T v) const
+    {
+        return List(v, *this);
+    }
+    List take(int n)
+    {
+        if (n <= 0 || isEmpty()) return List();
+        return popped_front().take(n - 1).pushed_front(front());
+    }
+    List insertedAt(int i, T v) const
+    {
+        if (i == 0) {
+            return pushed_front(v);
+        } else {
+            assert(!isEmpty());
+            return List<T>(front(), popped_front().insertedAt(i - 1, v));
+        }
+    }
+    List removed(T v) const
+    {
+        if (isEmpty()) return List();
+        if (v == front())
+            return popped_front().removed(v);
+        return List(front(), popped_front().removed(v));
+    }
+    List removed1(T v) const
+    {
+        if (isEmpty()) return List();
+        if (v == front())
+            return popped_front();
+        return List(front(), popped_front().removed(v));
+    }
+    bool member(T v) const
+    {
+        if (isEmpty()) return false;
+        if (v == front()) return true;
+        return popped_front().member(v);
+    }
+    template<class F>
+    void forEach(F f) const
+    {
+        Item const * it = _head.get();
+        while (it != nullptr)
+        {
+            f(it->_val);
+            it = it->_next.get();
+        }
+    }
+
+    friend class FwdListIter<T>;
+    // For debugging
+    int headCount() const { return _head.use_count(); }
+private:
+    std::shared_ptr<const Item> _head;
+};
+
+template<class T, class P>
+bool all(List<T> const & lst, P & p)
+{
+    if (lst.isEmpty())
+        return true;
+    if (!p(lst.front()))
+        return false;
+    return all(lst.popped_front(), p);
+}
+
+template<class T>
+class FwdListIter : public std::iterator<std::forward_iterator_tag, T>
+{
+public:
+    FwdListIter() {}  // end
+    FwdListIter(List<T> const & lst) : _cur(lst._head)
+    {}
+    T operator*() const { return _cur->_val; }
+    FwdListIter & operator++()
+    {
+        _cur = _cur->_next;
+        return *this;
+    }
+    bool operator==(FwdListIter<T> const & other)
+    {
+        return _cur == other._cur;
+    }
+    bool operator!=(FwdListIter<T> const & other)
+    {
+        return !(*this == other);
+    }
+private:
+    std::shared_ptr<const typename List<T>::Item> _cur;
+};
+
+template<class T>
+class OutListIter : public std::iterator<std::output_iterator_tag, T>
+{
+public:
+    OutListIter() {}
+    T & operator*() { return _val; }
+    OutListIter & operator++()
+    {
+        _lst = List<T>(_val, _lst);
+        return *this;
+    }
+    List<T> getList() const { return _lst; }
+private:
+    T _val;
+    List<T> _lst;
+};
+
+
+namespace std
+{
+    template<class T>
+    FwdListIter<T> begin(List<T> const & lst)
+    {
+        return FwdListIter<T>(lst);
+    }
+    template<class T>
+    FwdListIter<T> end(List<T> const & lst)
+    {
+        return FwdListIter<T>();
+    }
+}
+
+template<class T>
+List<T> concat(List<T> const & a, List<T> const & b)
+{
+    if (a.isEmpty())
+        return b;
+    return List<T>(a.front(), concat(a.popped_front(), b));
+}
+
+template<class T, class F>
+auto fmap(F f, List<T> lst) -> List<decltype(f(lst.front()))>
+{
+    using U = decltype(f(lst.front()));
+    static_assert(std::is_convertible<F, std::function<U(T)>>::value,
+                  "fmap requires a function type U(T)");
+    if (lst.isEmpty())
+        return List<U>();
+    else
+        return List<U>(f(lst.front()), fmap(f, lst.popped_front()));
+}
+
+template<class T, class P>
+List<T> filter(P p, List<T> lst)
+{
+    static_assert(std::is_convertible<P, std::function<bool(T)>>::value,
+                  "filter requires a function type bool(T)");
+    if (lst.isEmpty())
+        return List<T>();
+    if (p(lst.front()))
+        return List<T>(lst.front(), filter(p, lst.popped_front()));
+    else
+        return filter(p, lst.popped_front());
+}
+
+template<class T, class U, class F>
+U foldr(F f, U acc, List<T> lst)
+{
+    static_assert(std::is_convertible<F, std::function<U(T, U)>>::value,
+                  "foldr requires a function type U(T, U)");
+    if (lst.isEmpty())
+        return acc;
+    else
+        return f(lst.front(), foldr(f, acc, lst.popped_front()));
+}
+
+template<class T, class U, class F>
+U foldl(F f, U acc, List<T> lst)
+{
+    static_assert(std::is_convertible<F, std::function<U(U, T)>>::value,
+                  "foldl requires a function type U(U, T)");
+    if (lst.isEmpty())
+        return acc;
+    else
+        return foldl(f, f(acc, lst.front()), lst.popped_front());
+}
+
+// Set difference a \ b
+template<class T>
+List<T> set_diff(List<T> const & as, List<T> const & bs)
+{
+    return foldl([](List<T> const & acc, T x) {
+        return acc.removed(x);
+    }, as, bs);
+}
+
+// Set union of two lists, xs u ys
+// Assume no duplicates inside either list
+template<class T>
+List<T> set_union(List<T> const & xs, List<T> const & ys)
+{
+    // xs u ys = (ys \ xs) ++ xs
+    // removed all xs from ys
+    auto trimmed = foldl([](List<T> const & acc, T x) {
+        return acc.removed(x);
+    }, ys, xs);
+    return concat(trimmed, xs);
+}
+
+template<class T>
+List<T> concatAll(List<List<T>> const & xss)
+{
+    if (xss.isEmpty()) return List<T>();
+    return concat(xss.front(), concatAll(xss.popped_front()));
+}
+
+// consumes the list when called:
+// forEach(std::move(lst), f);
+
+template<class T, class F>
+void forEach(List<T> lst, F f)
+{
+    static_assert(std::is_convertible<F, std::function<void(T)>>::value,
+                  "forEach requires a function type void(T)");
+    while (!lst.isEmpty()) {
+        f(lst.front());
+        lst = lst.popped_front();
+    }
+}
+
+template<class Beg, class End>
+auto fromIt(Beg it, End end) -> List<typename Beg::value_type>
+{
+    typedef typename Beg::value_type T;
+    if (it == end)
+        return List<T>();
+    T item = *it;
+    return List<T>(item, fromIt(++it, end));
+}
+
+template<class T, class F>
+List<T> iterateN(F f, T init, int count)
+{
+    if (count <= 0) return List<T>();
+    return iterateN(f, f(init), count - 1).pushed_front(init);
+}
+
+// Pass lst by value not reference!
+template<class T>
+void printRaw(List<T> lst)
+{
+    if (lst.isEmpty()) {
+        std::cout << std::endl;
+    } else {
+        std::cout << "(" << lst.front() << ", " << lst.headCount() - 1 << ") ";
+        printRaw(lst.popped_front());
+    }
+}
+
+template<class T>
+std::ostream& operator<<(std::ostream& os, List<T> const & lst)
+{
+    os << "[";
+    forEach(lst, [&os](T v) {
+        os << v << " ";
+    });
+    os << "]";
+    return os;
+}
+
+template<class T>
+List<T> reversed(List<T> const & lst)
+{
+    return foldl([](List<T> const & acc, T v)
+                 {
+                     return List<T>(v, acc);
+                 }, List<T>(), lst);
+}