cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,184 @@
+#pragma once
+
+#include <stdexcept>
+#include <string>
+#include "config_origin.hpp"
+#include <leatherman/locale/locale.hpp>
+
+namespace hocon {
+
+    /**
+     * All exceptions thrown by the library are subclasses of
+     * <code>config_exception</code>.
+     */
+    struct config_exception : public std::runtime_error {
+        config_exception(config_origin const& origin, std::string const& message) :
+                runtime_error(leatherman::locale::format("{1}: {2}", origin.description(), message)) { }
+        config_exception(std::string const& message) : runtime_error(message) { }
+
+        config_exception(std::string const& message, std::exception const& e) : runtime_error(leatherman::locale::format("{1} {2}", message, e.what())) { }
+    };
+
+    /**
+     * Exception indicating that the type of a value does not match the type you
+     * requested.
+     *
+     */
+    struct wrong_type_exception : public config_exception {
+        wrong_type_exception(config_origin const& origin,
+                             std::string const& path, std::string const& expected, std::string const& actual) :
+                config_exception(origin, leatherman::locale::format("{1} has type {2} rather than {3}", path, actual, expected)) { }
+        using config_exception::config_exception;
+    };
+
+    /**
+     * Exception indicates that the setting was never set to anything, not even
+     * null.
+     */
+    struct missing_exception : public config_exception {
+        missing_exception(std::string const& path) :
+                config_exception(leatherman::locale::format("No configuration setting found for key '{1}'", path)) { }
+        using config_exception::config_exception;
+    };
+
+    /**
+     * Exception indicates that the setting was treated as missing because it
+     * was set to null.
+     */
+    struct null_exception : public missing_exception {
+        null_exception(config_origin const& origin, std::string const& path, std::string const& expected = "") :
+                missing_exception(origin, (expected.empty() ? leatherman::locale::format("Configuration key \"{1}\" is null", path)
+                                           : leatherman::locale::format("Configuration key \"{1}\" is set to null but expected {2}", path, expected))) { }
+    };
+
+    /**
+     * Exception indicating that a value was messed up, for example you may have
+     * asked for a duration and the value can't be sensibly parsed as a
+     * duration.
+     */
+    struct bad_value_exception : public config_exception {
+        bad_value_exception(config_origin const& origin, std::string const& path, std::string const& message) :
+                config_exception(origin, leatherman::locale::format("Invalid value at '{1}': {2}", path, message)) { }
+        bad_value_exception(std::string const& path, std::string const& message) :
+                config_exception(leatherman::locale::format("Invalid value at '{1}': {2}", path, message)) { }
+    };
+
+    /**
+     * Exception indicating that a path expression was invalid. Try putting
+     * double quotes around path elements that contain "special" characters.
+     *
+     */
+    struct bad_path_exception : public config_exception {
+        bad_path_exception(config_origin const& origin, std::string const& path, std::string const& message) :
+                config_exception(origin, path.empty() ? message : leatherman::locale::format("Invalid path '{1}': {2}", path, message)) { }
+        bad_path_exception(std::string const& path, std::string const& message) :
+                config_exception(path.empty() ? message : leatherman::locale::format("Invalid path '{1}': {2}", path, message)) { }
+    };
+
+    /**
+     * Exception indicating that there's a bug in something (possibly the
+     * library itself) or the runtime environment is broken. This exception
+     * should never be handled; instead, something should be fixed to keep the
+     * exception from occurring. This exception can be thrown by any method in
+     * the library.
+     */
+    struct bug_or_broken_exception : public config_exception {
+        bug_or_broken_exception(std::string const& message) : config_exception(message) { }
+    };
+
+    /**
+     * Exception indicating that there was an IO error.
+     *
+     */
+    struct io_exception : public config_exception {
+        io_exception(config_origin const& origin, std::string const& message) : config_exception(origin, message) { }
+    };
+
+    /**
+     * Exception indicating that there was a parse error.
+     *
+     */
+    struct parse_exception : public config_exception {
+        parse_exception(config_origin const& origin, std::string const& message) : config_exception(origin, message) { }
+    };
+
+
+    /**
+     * Exception indicating that a substitution did not resolve to anything.
+     * Thrown by {@link config#resolve}.
+     */
+    struct unresolved_substitution_exception : public parse_exception {
+        unresolved_substitution_exception(config_origin const& origin, std::string const& detail) :
+                parse_exception(origin, leatherman::locale::format("Could not resolve subtitution to a value: {1}", detail)) { }
+    };
+
+    /**
+     * Exception indicating that you tried to use a function that requires
+     * substitutions to be resolved, but substitutions have not been resolved
+     * (that is, {@link config#resolve} was not called). This is always a bug in
+     * either application code or the library; it's wrong to write a handler for
+     * this exception because you should be able to fix the code to avoid it by
+     * adding calls to {@link config#resolve}.
+     */
+    struct not_resolved_exception : public bug_or_broken_exception {
+        not_resolved_exception(std::string const& message) : bug_or_broken_exception(message) { }
+    };
+
+    struct not_possible_to_resolve_exception : public bug_or_broken_exception {
+        not_possible_to_resolve_exception(std::string const& message) : bug_or_broken_exception(message) { }
+    };
+
+    /**
+     * Information about a problem that occurred in {@link config#check_valid}. A
+     * {@link validation_failed_exception} thrown from
+     * <code>check_valid()</code> includes a list of problems encountered.
+     */
+    struct validation_problem {
+        validation_problem(std::string path_, shared_origin origin_, std::string problem_) :
+                path(std::move(path_)), origin(std::move(origin_)), problem(std::move(problem_)) { }
+
+        const std::string path;
+        const shared_origin origin;
+        const std::string problem;
+
+        std::string to_string() {
+            return leatherman::locale::format("ValidationProblem({1},{2},{3})", path, origin->description(), problem);
+        }
+    };
+
+    /**
+     * Exception indicating that {@link config#check_valid} found validity
+     * problems. The problems are available via the {@link #problems()} method.
+     * The <code>get_message()</code> of this exception is a potentially very
+     * long string listing all the problems found.
+     */
+    struct validation_failed_exception : public config_exception {
+        validation_failed_exception(std::vector<validation_problem> problems_) :
+                config_exception(make_message(problems_)), problems(std::move(problems_)) { }
+
+        const std::vector<validation_problem> problems;
+
+    private:
+        static std::string make_message(std::vector<validation_problem> const& problems_) {
+            std::string msg;
+            for (auto &p : problems_) {
+                auto sep = std::string(": ");
+                for (auto &s : {p.origin->description(), sep, p.path, sep, p.problem, std::string(", ")}) {
+                    msg.append(s);
+                }
+            }
+            if (msg.empty()) {
+                throw bug_or_broken_exception(leatherman::locale::format("validation_failed_exception must have a non-empty list of problems"));
+            }
+            msg.resize(msg.length() - 2);
+            return msg;
+        }
+    };
+
+    /**
+     * Exception that doesn't fall into any other category.
+     */
+    struct generic_exception : public config_exception {
+        generic_exception(std::string const& message) : config_exception(message) { }
+    };
+}  // namespace hocon

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

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "types.hpp"
+#include "config_parse_options.hpp"
+#include "export.h"
+
+namespace hocon {
+
+    /**
+     * Context provided to a {@link config_includer}; this interface is only useful
+     * inside a {@code config_includer} implementation, and is not intended for apps
+     * to implement.
+     *
+     * <p>
+     * <em>Do not implement this interface</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_include_context {
+    public:
+        /**
+         * Tries to find a name relative to whatever is doing the including, for
+         * example in the same directory as the file doing the including. Returns
+         * null if it can't meaningfully create a relative name. The returned
+         * parseable may not exist; this function is not required to do any IO, just
+         * compute what the name would be.
+         *
+         * The passed-in filename has to be a complete name (with extension), not
+         * just a basename. (Include statements in config files are allowed to give
+         * just a basename.)
+         *
+         * @param filename
+         *            the name to make relative to the resource doing the including
+         * @return parseable item relative to the resource doing the including, or
+         *         null
+         */
+        virtual shared_parseable relative_to(std::string file_name) const = 0;
+
+        /**
+         * Parse options to use (if you use another method to get a
+         * {@link config_parseable} then use {@link config_parseable#options()}
+         * instead though).
+         *
+         * @return the parse options
+         */
+        virtual config_parse_options parse_options() const = 0;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "types.hpp"
+#include <string>
+#include <memory>
+#include "export.h"
+
+namespace hocon {
+    /**
+     * Implement this interface and provide an instance to
+     * {@link config_parse_options#set_includer config_parse_options.set_includer()} to
+     * customize handling of {@code include} statements in config files. You may
+     * also want to implement {@link config_includer_file} and {@link config_includer_URL}, or not.
+     */
+    class LIBCPP_HOCON_EXPORT config_includer {
+    public:
+        /**
+         * Returns a new includer that falls back to the given includer. This is how
+         * you can obtain the default includer; it will be provided as a fallback.
+         * It's up to your includer to chain to it if you want to. You might want to
+         * merge any files found by the fallback includer with any objects you load
+         * yourself.
+         *
+         * It's important to handle the case where you already have the fallback
+         * with a "return this", i.e. this method should not create a new object if
+         * the fallback is the same one you already have. The same fallback may be
+         * added repeatedly.
+         *
+         * @param fallback the previous includer for chaining
+         * @return a new includer
+         */
+        virtual shared_includer with_fallback(shared_includer fallback) const = 0;
+
+        /**
+         * Parses another item to be included. The returned object typically would
+         * not have substitutions resolved. You can throw a config_exception here to
+         * abort parsing, or return an empty object, but may not return null.
+         * 
+         * This method is used for a "heuristic" include statement that does not
+         * specify file, or URL resource. If the include statement does
+         * specify, then the same class implementing {@link config_includer} must
+         * also implement {@link config_includer_file} or {@link config_includer_URL} as needed, or a
+         * default includer will be used.
+         * 
+         * @param context
+         *            some info about the include context
+         * @param what
+         *            the include statement's argument
+         * @return a non-null config_object
+         */
+        virtual shared_object include(shared_include_context context, std::string what) const = 0;
+    };
+}  // namespace hocon

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

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "export.h"
+#include "types.hpp"
+
+namespace hocon {
+
+    /**
+     * Implement this <em>in addition to</em> {@link config_includer} if you want to
+     * support inclusion of files with the {@code include file("filename")} syntax.
+     * If you do not implement this but do implement {@link config_includer},
+     * attempts to load files will use the default includer.
+     */
+    class LIBCPP_HOCON_EXPORT config_includer_file {
+    public:
+        /**
+         * Parses another item to be included. The returned object typically would
+         * not have substitutions resolved. You can throw a config_exception here to
+         * abort parsing, or return an empty object, but may not return null.
+         *
+         * @param context
+         *            some info about the include context
+         * @param what
+         *            the include statement's argument (a file path)
+         * @return a non-null config_object
+         */
+        virtual shared_object include_file(shared_include_context context, std::string what) const = 0;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "types.hpp"
+#include "export.h"
+#include <vector>
+
+namespace hocon {
+
+    /**
+     * Subtype of {@link ConfigValue} representing a list value, as in JSON's
+     * {@code [1,2,3]} syntax.
+     *
+     * <p>
+     * {@code ConfigList} implements {@code java.util.List<ConfigValue>} so you can
+     * use it like a regular Java list. Or call {@link #unwrapped()} to unwrap the
+     * list elements into plain Java values.
+     *
+     * <p>
+     * Like all {@link ConfigValue} subtypes, {@code ConfigList} is immutable. This
+     * makes it threadsafe and you never have to create "defensive copies." The
+     * mutator methods from {@link java.util.List} all throw
+     * {@link java.lang.UnsupportedOperationException}.
+     *
+     * <p>
+     * The {@link ConfigValue#valueType} method on a list returns
+     * {@link ConfigValueType#LIST}.
+     *
+     * <p>
+     * <em>Do not implement {@code ConfigList}</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_list : public config_value {
+    public:
+        config_list(shared_origin origin) : config_value(move(origin)) {}
+
+        // list interface
+        using iterator = std::vector<shared_value>::const_iterator;
+        virtual bool is_empty() const = 0;
+        virtual size_t size() const = 0;
+        virtual shared_value operator[](size_t index) const = 0;
+        virtual shared_value get(size_t index) const = 0;
+        virtual iterator begin() const = 0;
+        virtual iterator end() const = 0;
+        virtual unwrapped_value unwrapped() const = 0;
+    };
+}  // namespace hocon

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

@@ -0,0 +1,72 @@
+#pragma once
+
+#include <memory>
+#include "export.h"
+
+namespace hocon {
+
+    class LIBCPP_HOCON_EXPORT config_mergeable {
+        friend class config_value;
+    public:
+        /**
+         * Returns a new value computed by merging this value with another, with
+         * keys in this value "winning" over the other one.
+         *
+         * <p>
+         * This associative operation may be used to combine configurations from
+         * multiple sources (such as multiple configuration files).
+         *
+         * <p>
+         * The semantics of merging are described in the <a
+         * href="https://github.com/typesafehub/config/blob/master/HOCON.md">spec
+         * for HOCON</a>. Merging typically occurs when either the same object is
+         * created twice in the same file, or two config files are both loaded. For
+         * example:
+         *
+         * <pre>
+         *  foo = { a: 42 }
+         *  foo = { b: 43 }
+         * </pre>
+         *
+         * Here, the two objects are merged as if you had written:
+         *
+         * <pre>
+         *  foo = { a: 42, b: 43 }
+         * </pre>
+         *
+         * <p>
+         * Only {@link ConfigObject} and {@link Config} instances do anything in
+         * this method (they need to merge the fallback keys into themselves). All
+         * other values just return the original value, since they automatically
+         * override any fallback. This means that objects do not merge "across"
+         * non-objects; if you write
+         * <code>object.withFallback(nonObject).withFallback(otherObject)</code>,
+         * then <code>otherObject</code> will simply be ignored. This is an
+         * intentional part of how merging works, because non-objects such as
+         * strings and integers replace (rather than merging with) any prior value:
+         *
+         * <pre>
+         * foo = { a: 42 }
+         * foo = 10
+         * </pre>
+         *
+         * Here, the number 10 "wins" and the value of <code>foo</code> would be
+         * simply 10. Again, for details see the spec.
+         *
+         * @param other
+         *            an object whose keys should be used as fallbacks, if the keys
+         *            are not present in this one
+         * @return a new object (or the original one, if the fallback doesn't get
+         *         used)
+         */
+        virtual std::shared_ptr<const config_mergeable> with_fallback(std::shared_ptr<const config_mergeable> other) const = 0;
+
+    protected:
+        /**
+         * Converts a config to its root object and a config_value to itself.
+         * Originally in the MergeableValue interface, squashing to ease C++ public API separation
+         */
+        virtual shared_value to_fallback_value() const = 0;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "config_value.hpp"
+#include "config_mergeable.hpp"
+#include "path.hpp"
+#include <unordered_map>
+#include "export.h"
+
+namespace hocon {
+
+    class LIBCPP_HOCON_EXPORT config_object : public config_value {
+        friend class config;
+        friend class config_value;
+        friend class simple_config_object;
+        friend class resolve_source;
+        friend class config_delayed_merge_object;
+    public:
+        /**
+         * Converts this object to a {@link Config} instance, enabling you to use
+         * path expressions to find values in the object. This is a constant-time
+         * operation (it is not proportional to the size of the object).
+         *
+         * @return a {@link Config} with this object as its root
+         */
+        virtual std::shared_ptr<const config> to_config() const;
+
+        config_object(shared_origin origin);
+
+        config_value::type value_type() const override;
+
+        virtual shared_object with_value(path raw_path, shared_value value) const = 0;
+        virtual shared_object with_value(std::string key, shared_value value) const = 0;
+
+        /**
+         * Look up the key on an only-partially-resolved object, with no
+         * transformation or type conversion of any kind; if 'this' is not resolved
+         * then try to look up the key anyway if possible.
+         *
+         * @param key
+         *            key to look up
+         * @return the value of the key, or null if known not to exist
+         * @throws config_exception
+         *             if can't figure out key's value (or existence) without more
+         *             resolving
+         */
+        virtual shared_value attempt_peek_with_partial_resolve(std::string const& key) const = 0;
+
+        /**
+         * Construct a list of keys in the _value map.
+         * Use a vector rather than set, because most of the time we just want to iterate over them.
+         */
+        virtual std::vector<std::string> key_set() const = 0;
+
+        // map interface
+        using iterator = std::unordered_map<std::string, shared_value>::const_iterator;
+        virtual bool is_empty() const = 0;
+        virtual size_t size() const = 0;
+        virtual shared_value operator[](std::string const& key) const = 0;
+        virtual shared_value get(std::string const& key) const = 0;
+        virtual iterator begin() const = 0;
+        virtual iterator end() const = 0;
+
+    protected:
+        shared_value peek_path(path desired_path) const;
+        shared_value peek_assuming_resolved(std::string const& key, path original_path) const;
+
+        virtual shared_object new_copy(resolve_status const& status, shared_origin origin) const = 0;
+        shared_value new_copy(shared_origin origin) const override;
+
+        shared_value construct_delayed_merge(shared_origin origin, std::vector<shared_value> stack) const override;
+
+        virtual std::unordered_map<std::string, shared_value> const& entry_set() const = 0;
+        virtual shared_object without_path(path raw_path) const = 0;
+        virtual shared_object with_only_path(path raw_path) const = 0;
+        virtual shared_object with_only_path_or_null(path raw_path) const = 0;
+
+        static shared_value peek_path(const config_object* self, path desired_path);
+        static shared_origin merge_origins(std::vector<shared_value> const& stack);
+    };
+
+}  // namespace hocon