cfacter 3.11.0.rc.20180314

data/ext/facter/cpp-hocon/lib/src/values/config_long.cc

@@ -0,0 +1,35 @@
+#include <internal/values/config_long.hpp>
+
+using namespace std;
+
+namespace hocon {
+
+    config_long::config_long(shared_origin origin, int64_t value, string original_text) :
+            config_number(move(origin), move(original_text)), _value(value) { }
+
+    std::string config_long::transform_to_string() const {
+        string s = config_number::transform_to_string();
+        if (s.empty()) {
+            return to_string(_value);
+        } else {
+            return s;
+        }
+    }
+
+    unwrapped_value config_long::unwrapped() const {
+        return _value;
+    }
+
+    int64_t config_long::long_value() const {
+        return _value;
+    }
+
+    double config_long::double_value() const {
+        return _value;
+    }
+
+    shared_value config_long::new_copy(shared_origin origin) const {
+        return make_shared<config_long>(move(origin), _value, _original_text);
+    }
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/values/config_null.cc

@@ -0,0 +1,35 @@
+#include <internal/values/config_null.hpp>
+#include <boost/blank.hpp>
+
+using namespace std;
+
+namespace hocon {
+
+    config_null::config_null(shared_origin origin) :
+            config_value(move(origin)) { }
+
+    config_value::type config_null::value_type() const {
+        return config_value::type::CONFIG_NULL;
+    }
+
+    string config_null::transform_to_string() const {
+        return "null";
+    }
+
+    shared_value config_null::new_copy(shared_origin origin) const {
+        return make_shared<config_null>(move(origin));
+    }
+
+    unwrapped_value config_null::unwrapped() const {
+        return boost::blank();
+    }
+
+    bool config_null::operator==(config_value const& other) const {
+        return dynamic_cast<config_null const*>(&other);
+    }
+
+    void config_null::render(string& result, int indent, bool at_root, config_render_options options) const {
+        result += "null";
+    }
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/values/config_number.cc

@@ -0,0 +1,78 @@
+#include <internal/values/config_number.hpp>
+#include <internal/values/config_int.hpp>
+#include <internal/values/config_long.hpp>
+#include <internal/values/config_double.hpp>
+#include <hocon/config_exception.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <limits>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    config_number::config_number(shared_origin origin, string original_text) :
+            config_value(move(origin)), _original_text(move(original_text)) { }
+
+    config_value::type config_number::value_type() const {
+        return config_value::type::NUMBER;
+    }
+
+    string config_number::transform_to_string() const {
+        return _original_text;
+    }
+
+    bool config_number::is_whole() const {
+        long as_long = long_value();
+        return as_long == double_value();
+    }
+
+    bool config_number::operator==(const config_number &other) const {
+        if (is_whole()) {
+            return other.is_whole() && long_value() == other.long_value();
+        } else {
+            return !other.is_whole() && double_value() == other.double_value();
+        }
+    }
+
+    bool config_number::operator!=(const config_number &other) const {
+        return !(*this == other);
+    }
+
+    int config_number::int_value_range_checked(std::string const& path) const {
+        long l = long_value();
+        if (l < numeric_limits<int>::min() || l > numeric_limits<int>::max()) {
+            throw config_exception(_("Tried to get int from out of range value {1}", to_string(l)));
+        }
+        return static_cast<int>(l);
+    }
+
+    shared_ptr<config_number> config_number::new_number(
+            shared_origin origin, int64_t value, std::string original_text) {
+        if (value >= numeric_limits<int>::min() && value <= numeric_limits<int>::max()) {
+            return make_shared<config_int>(move(origin), static_cast<int>(value),
+                                                         move(original_text));
+        } else {
+            return make_shared<config_long>(move(origin), value, move(original_text));
+        }
+    }
+
+    shared_ptr<config_number> config_number::new_number(
+            shared_origin origin, double value, std::string original_text) {
+        int64_t as_long = static_cast<int64_t>(value);
+        if (as_long == value) {
+            return new_number(move(origin), as_long, move(original_text));
+        } else {
+            return unique_ptr<config_double>(new config_double(move(origin), value, move(original_text)));
+        }
+    }
+
+    bool config_number::operator==(config_value const& other) const {
+        return equals<config_number>(other, [&](config_number const& o) {
+            return long_value() == o.long_value() && double_value() == o.double_value();
+        });
+    }
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/values/config_object.cc

@@ -0,0 +1,97 @@
+#include <hocon/config_object.hpp>
+#include <hocon/config.hpp>
+#include <internal/simple_config_origin.hpp>
+#include <internal/values/config_delayed_merge_object.hpp>
+#include <hocon/config_exception.hpp>
+#include <hocon/path.hpp>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    config_object::config_object(shared_origin origin) : config_value(move(origin)) { }
+
+    shared_value config_object::peek_path(path desired_path) const {
+        return peek_path(this, move(desired_path));
+    }
+
+    shared_value config_object::peek_path(const config_object* self, path desired_path) {
+        try {
+            path next = desired_path.remainder();
+            shared_value v = self->attempt_peek_with_partial_resolve(*desired_path.first());
+
+            if (next.empty()) {
+                return v;
+            } else {
+                if (auto object = dynamic_pointer_cast<const config_object>(v)) {
+                    return peek_path(object.get(), next);
+                } else {
+                    return nullptr;
+                }
+            }
+        } catch (config_exception& ex) {
+            throw config_exception(_("{1} has not been resolved, you need to call config::resolve()", desired_path.render()));
+        }
+    }
+
+    shared_value config_object::peek_assuming_resolved(std::string const& key, path original_path) const {
+        try {
+            return attempt_peek_with_partial_resolve(key);
+        } catch (config_exception& ex) {
+            throw config_exception(_("{1} has not been resolved, you need to call config::resolve()", original_path.render()));
+        }
+    }
+
+    shared_value config_object::new_copy(shared_origin origin) const {
+        return new_copy(get_resolve_status(), origin);
+    }
+
+    shared_value config_object::construct_delayed_merge(shared_origin origin, std::vector<shared_value> stack) const {
+        return make_shared<config_delayed_merge_object>(move(origin), move(stack));
+    }
+
+    std::shared_ptr<const config> config_object::to_config() const {
+        return make_shared<config>(dynamic_pointer_cast<const config_object>(shared_from_this()));
+    }
+
+    config_value::type config_object::value_type() const {
+        return config_value::type::OBJECT;
+    }
+
+    shared_origin config_object::merge_origins(std::vector<shared_value> const& stack) {
+        if (stack.empty()) {
+            throw config_exception(_("can't merge origins on empty list"));
+        }
+
+        vector<shared_origin> origins;
+        shared_origin first_origin = nullptr;
+
+        for (shared_value v : stack) {
+            if (first_origin == nullptr) {
+                first_origin = v->origin();
+            }
+
+            auto cv = dynamic_pointer_cast<const config_object>(v);
+            if (cv && cv->get_resolve_status() == resolve_status::RESOLVED && cv->is_empty()) {
+                // don't include empty files or the .empty()
+                // config in the description, since they are
+                // likely to be "implementation details"
+            } else {
+                origins.push_back(v->origin());
+            }
+        }
+
+        if (origins.size() == 0) {
+            // the configs were all empty, so just use the first one
+            origins.push_back(first_origin);
+        }
+
+        return simple_config_origin::merge_origins(origins);
+    }
+
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/values/config_reference.cc

@@ -0,0 +1,85 @@
+#include <internal/values/config_reference.hpp>
+#include <hocon/config_exception.hpp>
+#include <hocon/config_object.hpp>
+#include <internal/resolve_source.hpp>
+#include <internal/container.hpp>
+#include <internal/substitution_expression.hpp>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    config_reference::config_reference(shared_origin origin, std::shared_ptr<substitution_expression> expr, int prefix_length)
+            : config_value(origin), _expr(expr), _prefix_length(prefix_length) { }
+
+    config_reference::type config_reference::value_type() const {
+        throw not_resolved_exception(_("ur lame"));
+    }
+
+    vector<shared_value> config_reference::unmerged_values() const {
+        return {shared_from_this()};
+    }
+
+    unwrapped_value config_reference::unwrapped() const {
+        throw not_resolved_exception(_("Can't unwrap a config reference."));
+    }
+
+    shared_value config_reference::new_copy(shared_origin origin) const {
+        return make_shared<config_reference>(origin, _expr, _prefix_length);
+    }
+
+    shared_ptr<substitution_expression> config_reference::expression() const {
+        return _expr;
+    }
+
+    bool config_reference::operator==(config_value const &other) const {
+        return equals<config_reference>(other, [&](config_reference const& o) { return *_expr == *o._expr; });
+    }
+
+    resolve_status config_reference::get_resolve_status() const {
+        return resolve_status::UNRESOLVED;
+    }
+
+    resolve_result<shared_value> config_reference::resolve_substitutions(resolve_context const &context, resolve_source const &source) const {
+        resolve_context new_context = context.add_cycle_marker(shared_from_this());
+        shared_value v;
+
+        try {
+            auto result_with_path = source.lookup_subst(move(new_context), _expr, _prefix_length);
+            new_context = result_with_path.result.context;
+
+            if (result_with_path.result.value) {
+                resolve_source recursive_resolve_source {dynamic_pointer_cast<const config_object>(result_with_path.path_from_root.back()), result_with_path.path_from_root};
+                auto result = new_context.resolve(result_with_path.result.value, recursive_resolve_source);
+                v = result.value;
+                new_context = result.context;
+            } else {
+                v = nullptr;
+            }
+        } catch (not_possible_to_resolve_exception& ex) {
+            if (_expr->optional()) {
+                v = nullptr;
+            } else {
+                throw config_exception(_("{1} was part of a cycle of substitutions.", _expr->to_string()));
+            }
+        }
+
+        if (!v && !_expr->optional()) {
+            if (new_context.options().get_allow_unresolved()) {
+                return make_resolve_result(new_context.remove_cycle_marker(shared_from_this()), shared_from_this());
+            } else {
+                throw unresolved_substitution_exception(*origin(), _expr->to_string());
+            }
+        } else {
+            return make_resolve_result(new_context.remove_cycle_marker(shared_from_this()), v);
+        }
+    }
+
+    void config_reference::render(std::string& s, int indent, bool at_root, config_render_options options) const {
+        s += _expr->to_string();
+    }
+}

data/ext/facter/cpp-hocon/lib/src/values/config_string.cc

@@ -0,0 +1,47 @@
+#include <internal/values/config_string.hpp>
+
+using namespace std;
+
+namespace hocon {
+
+    config_string::config_string(shared_origin origin, string text, config_string_type quoted) :
+        config_value(move(origin)), _text(move(text)), _quoted(quoted) { }
+
+    config_value::type config_string::value_type() const {
+        return config_value::type::STRING;
+    }
+
+    string config_string::transform_to_string() const {
+        return _text;
+    }
+
+    shared_value config_string::new_copy(shared_origin origin) const {
+        return make_shared<config_string>(move(origin), _text, _quoted);
+    }
+
+    unwrapped_value config_string::unwrapped() const {
+        return _text;
+    }
+
+    bool config_string::was_quoted() const {
+        return _quoted == config_string_type::QUOTED;
+    }
+
+    bool config_string::operator==(config_value const& other) const {
+        return equals<config_string>(other, [&](config_string const& o) { return _text == o._text; });
+    }
+
+    void config_string::render(std::string& s, int indent, bool at_root, config_render_options options) const {
+        string rendered;
+
+        if (options.get_json()) {
+            rendered = hocon::render_json_string(_text);
+        } else  {
+            rendered = hocon::render_string_unquoted_if_possible(_text);
+        }
+
+        s += rendered;
+    }
+
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/values/config_value.cc

@@ -0,0 +1,289 @@
+#include <hocon/config_value.hpp>
+#include <internal/config_util.hpp>
+#include <hocon/config_object.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/values/simple_config_object.hpp>
+#include <internal/simple_config_origin.hpp>
+#include <internal/container.hpp>
+#include <internal/values/config_delayed_merge.hpp>
+#include <internal/resolve_result.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <algorithm>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    config_value::config_value(shared_origin origin) :
+        _origin(move(origin)) { }
+
+    string config_value::transform_to_string() const {
+        return "";
+    }
+
+    shared_origin const& config_value::origin() const {
+        return _origin;
+    }
+
+    resolve_status config_value::get_resolve_status() const {
+        return resolve_status::RESOLVED;
+    }
+
+    string config_value::render() const {
+        return render(config_render_options());
+    }
+
+    string config_value::render(config_render_options options) const {
+        string result;
+        render(result, 0, true, "", options);
+        return result;
+    }
+
+    resolve_status resolve_status_from_values(std::vector<shared_value> const& values) {
+        for (auto& v : values) {
+            if (v->get_resolve_status() == resolve_status::UNRESOLVED) {
+                return resolve_status::UNRESOLVED;
+            }
+        }
+        return resolve_status::RESOLVED;
+    }
+
+    void config_value::render(std::string &result, int indent, bool at_root, std::string const& at_key, config_render_options options) const {
+        if (!at_key.empty()) {
+            string rendered_key;
+            if (options.get_json()) {
+                rendered_key = render_json_string(at_key);
+            } else {
+                rendered_key = render_string_unquoted_if_possible(at_key);
+            }
+
+            result += rendered_key;
+            if (options.get_json()) {
+                result += options.get_formatted() ? " : " : ":";
+            } else {
+                // in non-JSON we can omit the colon or equals before an object
+                if (dynamic_cast<const config_object*>(this)) {
+                    if (options.get_formatted()) {
+                        result += " ";
+                    }
+                } else {
+                    result += "=";
+                }
+            }
+        }
+        render(result, indent, at_root, options);
+    }
+
+    void config_value::render(std::string &result, int indent, bool at_root,
+                                       config_render_options options) const {
+        result += transform_to_string();
+    }
+
+    void config_value::indent(std::string &result, int indent, config_render_options const& options) {
+        if (options.get_formatted()) {
+            result.append(indent*4, ' ');
+        }
+    }
+
+    shared_config config_value::at_path(shared_origin origin, path raw_path) const {
+        path parent = raw_path.parent();
+        shared_config result = at_key(origin, *raw_path.last());
+        while (!parent.empty()) {
+            string key = *parent.last();
+            result = result->at_key(origin, key);
+            parent = parent.parent();
+        }
+        return result;
+    }
+
+    shared_config config_value::at_key(shared_origin origin, std::string const& key) const {
+        unordered_map<string, shared_value> map { make_pair(key, shared_from_this()) };
+        return simple_config_object(origin, map).to_config();
+    }
+
+    shared_config config_value::at_key(std::string const& key) const {
+        return at_key(make_shared<simple_config_origin>("at_key(" + key + ")"), key);
+    }
+
+    shared_config config_value::at_path(std::string const& path_expression) const {
+        shared_origin origin = make_shared<simple_config_origin>("at_path(" + path_expression + ")");
+        return at_path(move(origin), path::new_path(path_expression));
+    }
+
+    shared_value config_value::with_origin(shared_origin origin) const {
+        if (_origin == origin) {
+            return shared_from_this();
+        } else {
+            return new_copy(move(origin));
+        }
+    }
+
+    resolve_result<shared_value>
+    config_value::resolve_substitutions(resolve_context const& context,
+                                        resolve_source const& source) const
+    {
+        return resolve_result<shared_value>(context, shared_from_this());
+    }
+
+    std::vector<shared_value> config_value::replace_child_in_list(std::vector<shared_value> const& values,
+                                                                  shared_value const& child, shared_value replacement)
+    {
+        vector<shared_value> new_list = values;
+        auto it = find(new_list.begin(), new_list.end(), child);
+        assert(it != values.end());
+
+        if (replacement) {
+            *it = move(replacement);
+        } else {
+            new_list.erase(it);
+        }
+        return new_list;
+    }
+
+    bool config_value::has_descendant_in_list(std::vector<shared_value> const& values, shared_value const& descendant)
+    {
+        // Simple breadth-first-search for descendants
+        // We look for the same object via pointer comparison, not equivalent objects.
+        if (find(values.begin(), values.end(), descendant) != values.end()) {
+            return true;
+        }
+
+        for (auto& v : values) {
+            if (auto c = dynamic_pointer_cast<const container>(v)) {
+                if (c->has_descendant(descendant)) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    config_value::no_exceptions_modifier::no_exceptions_modifier(string prefix): _prefix(std::move(prefix)) {}
+
+    shared_value config_value::no_exceptions_modifier::modify_child_may_throw(string key_or_null, shared_value v) {
+        try {
+            return modify_child(key_or_null, v);
+        } catch (runtime_error& e) {
+            throw e;
+        } catch (exception& e) {
+            throw config_exception(_("Unexpected exception:{1}", e.what()));
+        }
+    }
+
+    shared_value config_value::no_exceptions_modifier::modify_child(string key, shared_value v) const {
+        return v->relativized(_prefix);
+    }
+
+    shared_ptr<const config_mergeable> config_value::with_fallback(std::shared_ptr<const config_mergeable> mergeable) const {
+        if (ignores_fallbacks()) {
+            return shared_from_this();
+        } else {
+            auto other = dynamic_pointer_cast<const config_mergeable>(mergeable)->to_fallback_value();
+
+            if (auto unmergeable_other = dynamic_pointer_cast<const unmergeable>(other)) {
+                return merged_with_the_unmergeable(unmergeable_other);
+            } else if (auto object_other = dynamic_pointer_cast<const config_object>(other)) {
+                return merged_with_object(object_other);
+            } else {
+                return merged_with_non_object(dynamic_pointer_cast<const config_value>(other));
+            }
+        }
+    }
+
+    void config_value::require_not_ignoring_fallbacks() const {
+        if (ignores_fallbacks()) {
+            throw config_exception(_("method should not have been called with ignores_fallbacks=true"));
+        }
+    }
+
+    bool config_value::ignores_fallbacks() const {
+        return get_resolve_status() == resolve_status::RESOLVED;
+    }
+
+    shared_value config_value::with_fallbacks_ignored() const {
+        if (ignores_fallbacks()) {
+            return shared_from_this();
+        } else {
+            throw config_exception(_("value class doesn't implement forced fallback-ignoring"));
+        }
+    }
+
+    shared_value config_value::construct_delayed_merge(shared_origin origin, std::vector<shared_value> stack) const {
+        return make_shared<config_delayed_merge>(move(origin), move(stack));
+    }
+
+    shared_value config_value::merged_with_the_unmergeable(std::vector<shared_value> stack,
+                                                           std::shared_ptr<const unmergeable> fallback) const {
+        require_not_ignoring_fallbacks();
+
+        // if we turn out to be an object, and the fallback also does,
+        // then a merge may be required; delay until we resolve.
+
+        auto unmerged_values = fallback->unmerged_values();
+        stack.insert(stack.end(), make_move_iterator(unmerged_values.begin()), make_move_iterator(unmerged_values.end()));
+        auto merged = config_object::merge_origins(stack);
+        return construct_delayed_merge(merged, move(stack));
+    }
+
+    shared_value config_value::merged_with_the_unmergeable(std::shared_ptr<const unmergeable> fallback) const {
+        require_not_ignoring_fallbacks();
+
+        return merged_with_the_unmergeable({ shared_from_this() }, move(fallback));
+    }
+
+    shared_value config_value::merged_with_object(vector<shared_value> stack, shared_object fallback) const {
+        require_not_ignoring_fallbacks();
+
+        if (dynamic_cast<const config_object*>(this)) {
+            throw config_exception(_("Objects must reimplement merged_with_object"));
+        }
+
+        return merged_with_non_object(move(stack), move(fallback));
+    }
+
+    shared_value config_value::merged_with_non_object(vector<shared_value> stack, shared_value fallback) const {
+        require_not_ignoring_fallbacks();
+
+        if (get_resolve_status() == resolve_status::RESOLVED) {
+            // falling back to a non-object doesn't merge anything, and also
+            // prohibits merging any objects that we fall back to later.
+            // so we have to switch to ignoresFallbacks mode.
+            return with_fallbacks_ignored();
+        } else {
+            // if unresolved, we may have to look back to fallbacks as part of
+            // the resolution process, so always delay
+            return delay_merge(move(stack), move(fallback));
+        }
+    }
+
+    shared_value config_value::merged_with_non_object(shared_value fallback) const {
+        require_not_ignoring_fallbacks();
+
+        return merged_with_non_object({shared_from_this()}, move(fallback));
+    }
+
+    shared_value config_value::merged_with_object(shared_object fallback) const {
+        require_not_ignoring_fallbacks();
+
+        return merged_with_object({shared_from_this()}, move(fallback));
+    }
+
+    shared_value config_value::to_fallback_value() const {
+        return shared_from_this();
+    }
+
+    shared_value config_value::delay_merge(std::vector<shared_value> stack, shared_value fallback) const {
+        // if we turn out to be an object, and the fallback also does,
+        // then a merge may be required.
+        // if we contain a substitution, resolving it may need to look
+        // back to the fallback.
+        stack.push_back(move(fallback));
+        auto merged = config_object::merge_origins(stack);
+        return construct_delayed_merge(merged, move(stack));
+    }
+
+}  // namespace hocon