cfacter 3.11.0.rc.20180314

data/ext/facter/cpp-hocon/lib/src/resolve_context.cc

@@ -0,0 +1,139 @@
+#include <hocon/config_exception.hpp>
+#include <hocon/config_value.hpp>
+#include <internal/resolve_context.hpp>
+#include <internal/resolve_result.hpp>
+#include <internal/resolve_source.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 {
+
+    resolve_context::resolve_context(config_resolve_options options, path restrict_to_child, vector<shared_value> cycle_markers)
+         : _options(move(options)), _restrict_to_child(move(restrict_to_child)), _cycle_markers(move(cycle_markers)) { }
+
+    resolve_context::resolve_context(config_resolve_options options, path restrict_to_child)
+         : resolve_context(move(options), move(restrict_to_child), vector<shared_value> {}) { }
+
+    bool resolve_context::is_restricted_to_child() const
+    {
+        return !_restrict_to_child.empty();
+    }
+
+    config_resolve_options resolve_context::options() const
+    {
+        return _options;
+    }
+
+    resolve_result<shared_value> resolve_context::resolve(shared_value original, resolve_source const& source) const
+    {
+        memo_key full_key {original, {}};
+        memo_key restricted_key = {nullptr, {}};
+
+        shared_value cached;
+        auto cached_iter = _memos.find(full_key);
+        if (cached_iter != _memos.end()) {
+            cached = cached_iter->second;
+        }
+
+        if (!cached && is_restricted_to_child()) {
+            restricted_key = {original, restrict_to_child()};
+            auto cached_iter = _memos.find(full_key);
+            if (cached_iter != _memos.end()) {
+                cached = cached_iter->second;
+            }
+        }
+
+        if (cached) {
+            return make_resolve_result(*this, cached);
+        } else {
+            if (find(_cycle_markers.begin(), _cycle_markers.end(), original) != _cycle_markers.end()) {
+                throw not_possible_to_resolve_exception(_("Cycle detected, can't resolve."));
+            }
+
+            auto result = original->resolve_substitutions(*this, source);
+            auto& resolved = result.value;
+            auto& with_memo = result.context;
+
+            if (!resolved || resolved->get_resolve_status() == resolve_status::RESOLVED) {
+                with_memo = with_memo.memoize(full_key, resolved);
+            }  else {
+                if (is_restricted_to_child()) {
+                    if (restricted_key.value == nullptr && restricted_key.restrict_to_child.empty()) {
+                        throw bug_or_broken_exception(_("restricted_key should not be empty here"));
+                    }
+                    with_memo = with_memo.memoize(restricted_key, resolved);
+                } else if (options().get_allow_unresolved()) {
+                    with_memo = with_memo.memoize(full_key, resolved);
+                } else {
+                    throw bug_or_broken_exception(_("resolve_substitutions() did not give us a resolved object"));
+                }
+            }
+
+            return make_resolve_result(with_memo, resolved);
+        }
+    }
+
+    path resolve_context::restrict_to_child() const {
+        return _restrict_to_child;
+    }
+
+    resolve_context resolve_context::add_cycle_marker(shared_value value) const {
+        if (find(_cycle_markers.begin(), _cycle_markers.end(), value) != _cycle_markers.end()) {
+            throw config_exception(_("Added cycle marker twice"));
+        }
+
+        vector<shared_value> copy { _cycle_markers };
+        copy.push_back(value);
+        return resolve_context(_options, _restrict_to_child, move(copy));
+    }
+
+    resolve_context resolve_context::remove_cycle_marker(shared_value value) {
+        vector<shared_value> copy { _cycle_markers };
+        if (!copy.empty()) {
+            copy.erase(remove(copy.begin(), copy.end(), value), copy.end());
+        }
+        return resolve_context(_options, _restrict_to_child, move(copy));
+    }
+
+    resolve_context resolve_context::restrict(path restrict_to) const {
+        if (restrict_to == _restrict_to_child) {
+            return *this;
+        } else {
+            return resolve_context(_options, restrict_to, _cycle_markers);
+        }
+    }
+
+    resolve_context resolve_context::unrestricted() const {
+        return restrict({});
+    }
+
+    shared_value resolve_context::resolve(shared_value value, shared_object root, config_resolve_options options) {
+        resolve_source source { root };
+        resolve_context context { options, path(), vector<shared_value> {}};
+
+        return context.resolve(value, source).value;
+    }
+
+    resolve_context resolve_context::memoize(const resolve_context::memo_key& key, const shared_value& value) const {
+        resolve_context result {_options, _restrict_to_child, _cycle_markers};
+        result._memos = _memos;
+        result._memos.emplace(key, value);
+        return result;
+    }
+
+    std::size_t resolve_context::memo_key_hash::operator()(const hocon::resolve_context::memo_key& k) const {
+        // Treat pointer as our hash value
+        size_t h = reinterpret_cast<size_t>(k.value.get());
+        auto p = k.restrict_to_child;
+        while (!p.empty()) {
+            h += 41 * (41 + hash<string>()(*p.first()));
+            p = p.remainder();
+        }
+        return h;
+    }
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/resolve_source.cc

@@ -0,0 +1,216 @@
+#include <internal/resolve_source.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/substitution_expression.hpp>
+#include <hocon/config_value.hpp>
+#include <hocon/config_object.hpp>
+#include <internal/values/simple_config_object.hpp>
+#include <internal/container.hpp>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+namespace hocon {
+
+    using namespace std;
+
+    resolve_source::resolve_source(shared_object root)
+         : _root(root) { }
+
+    resolve_source::resolve_source(shared_object root, node path_from_root)
+        : _root(root), _path_from_root(path_from_root) { }
+
+    resolve_source resolve_source::push_parent(shared_container parent) const
+    {
+        if (!parent) {
+            throw bug_or_broken_exception(_("can't push null parent"));
+        }
+
+        if ( _path_from_root.empty() ) {
+            if (dynamic_pointer_cast<const config_object>(parent) == _root) {
+                return resolve_source(_root, {parent});
+            } else {
+                return *this;
+            }
+        } else {
+            auto new_path_from_root = _path_from_root;
+            new_path_from_root.push_front(parent);
+            return resolve_source(_root, new_path_from_root);
+        }
+    }
+
+    resolve_source resolve_source::replace_current_parent(shared_ptr<const container> old, shared_ptr<const container> replacement) const
+    {
+        if (old == replacement) {
+             return *this;
+        } else if (! _path_from_root.empty()) {
+            auto new_path = replace(_path_from_root, old, dynamic_pointer_cast<const config_value>(replacement));
+            if (!new_path.empty()) {
+                return resolve_source(dynamic_pointer_cast<const config_object>(new_path.back()), new_path);
+            } else {
+                return resolve_source(simple_config_object::empty());
+            }
+        } else {
+            if (old == dynamic_pointer_cast<const container>(_root)) {
+                return resolve_source(root_must_be_obj(replacement));
+            } else {
+                throw bug_or_broken_exception(_("attempt to replace root with invalid value"));
+            }
+        }
+    }
+
+    resolve_source resolve_source::replace_within_current_parent(shared_value old, shared_value replacement) const
+    {
+        if (old == replacement) {
+             return *this;
+        } else if (!_path_from_root.empty()) {
+            auto parent = _path_from_root.front();
+            auto new_parent = parent->replace_child(old, replacement);
+            return replace_current_parent(parent, dynamic_pointer_cast<const container>(new_parent));
+        } else {
+            auto replacement_as_container = dynamic_pointer_cast<const container>(replacement);
+            if (old == _root && replacement_as_container) {
+                return resolve_source(root_must_be_obj(replacement_as_container));
+            } else {
+                throw bug_or_broken_exception(_("replace in parent not possible"));
+            }
+        }
+    }
+
+    resolve_source resolve_source::reset_parents() const
+    {
+        if (_path_from_root.empty()) {
+            return *this;
+        } else {
+            return resolve_source(_root);
+        }
+    }
+
+    resolve_source::result_with_path resolve_source::lookup_subst(resolve_context context,
+                                                                  std::shared_ptr<substitution_expression> subst,
+                                                                  int prefix_length) const {
+        auto result = find_in_object(_root, move(context), subst->get_path());
+
+        if (!result.result.value) {
+            auto unprefixed = subst->get_path().sub_path(prefix_length);
+
+            if (prefix_length > 0) {
+                result = find_in_object(_root, result.result.context, unprefixed);
+            }
+
+            if (!result.result.value && result.result.context.options().get_use_system_environment()) {
+                result = find_in_object(config::env_variables_as_config_object(), context, unprefixed);
+            }
+        }
+
+        return result;
+    }
+
+    resolve_source::result_with_path resolve_source::find_in_object(shared_object obj, resolve_context context,
+                                                                    path the_path) {
+        auto restriction = context.restrict_to_child();
+        auto partially_resolved = context.restrict(the_path).resolve(dynamic_pointer_cast<const config_value>(obj), {obj});
+        auto new_context = partially_resolved.context.restrict(restriction);
+
+        if (auto value = dynamic_pointer_cast<const config_object>(partially_resolved.value)) {
+            value_with_path pair = find_in_object(value, the_path);
+            return {make_resolve_result(new_context, pair.value), pair.path_from_root};
+
+        } else {
+            throw bug_or_broken_exception(_("resolved object to non-object"));
+        }
+    }
+
+    not_resolved_exception resolve_source::improve_not_resolved(path what, not_resolved_exception const& original) {
+        string new_message = _("{1} has not been resolved, you need to call config::resolve() see API docs for config::resolve()", what.render());
+        if (new_message == original.what()) {
+            return original;
+        } else {
+            return not_resolved_exception(new_message);
+        }
+    }
+
+    resolve_source::value_with_path resolve_source::find_in_object(shared_object obj, path the_path) {
+        try {
+            return find_in_object(obj, the_path, {});
+        } catch (const not_resolved_exception &e) {
+            throw improve_not_resolved(move(the_path), e);
+        }
+    }
+
+    resolve_source::value_with_path resolve_source::find_in_object(shared_object obj, path the_path, node parents) {
+        auto key = the_path.first();
+        auto next = the_path.remainder();
+
+        auto v = obj->attempt_peek_with_partial_resolve(*key);
+
+        parents.push_front(dynamic_pointer_cast<const container>(obj));
+
+        if (next.empty()) {
+            return {v, parents};
+        } else {
+            if (auto value = dynamic_pointer_cast<const config_object>(v)) {
+                return find_in_object(value, next, parents);
+            } else {
+                return {nullptr, parents};
+            }
+        }
+    }
+
+    shared_object resolve_source::root_must_be_obj(shared_ptr<const container> value) const {
+        auto value_as_obj = dynamic_pointer_cast<const config_object>(value);
+        if (value_as_obj) {
+            return value_as_obj;
+        } else {
+            return simple_config_object::empty();
+        }
+    }
+
+    resolve_source::node resolve_source::replace(const resolve_source::node& list, shared_ptr<const container> old, shared_value replacement)
+    {
+        auto child = list.front();
+        if (child != old) {
+            throw bug_or_broken_exception(_("Can only replace() the top node we're resolving"));
+        }
+
+        shared_ptr<const container> parent;
+        if (list.size() > 1) {
+            node copy(list);
+            copy.pop_front();
+            parent = copy.front();
+        }
+
+        auto replacement_as_container = dynamic_pointer_cast<const container>(replacement);
+        if (!replacement || !replacement_as_container) {
+            if (!parent) {
+                return {};
+            } else {
+                auto new_parent = parent->replace_child(dynamic_pointer_cast<const config_value>(old), nullptr);
+                node copy(list);
+                copy.pop_front();
+                return replace(copy, parent, new_parent);
+            }
+        } else {
+            if (!parent) {
+                return {replacement_as_container};
+            } else {
+                auto new_parent = parent->replace_child(dynamic_pointer_cast<const config_value>(old), replacement);
+                node copy(list);
+                copy.pop_front();
+                auto new_tail = replace(copy, parent, new_parent);
+                if (!new_tail.empty()) {
+                    new_tail.push_front(replacement_as_container);
+                    return new_tail;
+                } else {
+                    return {replacement_as_container};
+                }
+            }
+        }
+    }
+
+    resolve_source::value_with_path::value_with_path(shared_value v, node path_from_root_value)
+        : value(move(v)), path_from_root(move(path_from_root_value)) { }
+
+    resolve_source::result_with_path::result_with_path(resolve_result<shared_value> result_value, node path_from_root_value)
+        : result(move(result_value)), path_from_root(move(path_from_root_value)) { }
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/simple_config_document.cc

@@ -0,0 +1,69 @@
+#include <hocon/config_parse_options.hpp>
+#include <internal/simple_config_document.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/tokenizer.hpp>
+#include <internal/config_document_parser.hpp>
+#include <sstream>
+#include <boost/algorithm/string.hpp>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+    simple_config_document::simple_config_document(shared_ptr<const config_node_root> root,
+                                                   config_parse_options opts)
+        : _config_node_tree(move(root)), _parse_options(move(opts)) {}
+
+    unique_ptr<config_document> simple_config_document::with_value_text(string path, string new_value) const
+    {
+        if (new_value.empty()) {
+            throw new config_exception(_("empty value for {1} passed to with_value_text", path));
+        }
+
+        shared_origin origin = make_shared<simple_config_origin>("single value parsing");
+        token_iterator tokens {origin, unique_ptr<istream>{new stringstream(new_value)}, _parse_options.get_syntax()};
+        shared_node_value parsed_value = config_document_parser::parse_value(move(tokens), origin, _parse_options);
+
+        return unique_ptr<config_document>{new simple_config_document(
+                _config_node_tree->set_value(path, parsed_value, _parse_options.get_syntax()),
+                _parse_options)};
+    }
+
+    unique_ptr<config_document> simple_config_document::with_value(string path,
+                                                                   shared_ptr<config_value> new_value) const
+    {
+        if (!new_value) {
+            throw config_exception(_("null value for {1} passed to with_value", path));
+        }
+        config_render_options options = config_render_options();
+        options = options.set_origin_comments(false);
+        string rendered = new_value->render(options);
+        boost::trim(rendered);
+        return with_value_text(path, rendered);
+    }
+
+    unique_ptr<config_document> simple_config_document::without_path(string path) const
+    {
+        return unique_ptr<config_document>{new simple_config_document(
+                _config_node_tree->set_value(path, nullptr, _parse_options.get_syntax()), _parse_options)};
+    }
+
+    bool simple_config_document::has_path(string const& path) const
+    {
+        return _config_node_tree->has_value(path);
+    }
+
+    string simple_config_document::render() const
+    {
+        return _config_node_tree->render();
+    }
+
+    bool operator==(config_document const& lhs, config_document const& rhs)
+    {
+        return lhs.render() == rhs.render();
+    }
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/simple_config_origin.cc

@@ -0,0 +1,246 @@
+#include <hocon/config_value.hpp>
+#include <internal/simple_config_origin.hpp>
+#include <hocon/config_exception.hpp>
+#include <boost/algorithm/string/predicate.hpp>
+#include <leatherman/locale/locale.hpp>
+#include <algorithm>
+#include <stdexcept>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    simple_config_origin::simple_config_origin(string description, int line_number, int end_line_number,
+                                               origin_type org_type, string resource, vector<string> comments) :
+        _description(move(description)), _line_number(line_number), _end_line_number(end_line_number),
+        _origin_type(org_type), _resource_or_null(move(resource)), _comments_or_null(move(comments)) { }
+
+    simple_config_origin::simple_config_origin(string description, int line_number, int end_line_number,
+                                               origin_type org_type) :
+        _description(move(description)), _line_number(line_number), _end_line_number(end_line_number),
+        _origin_type(org_type) { }
+
+    int simple_config_origin::line_number() const {
+        return _line_number;
+    }
+
+    string const& simple_config_origin::description() const {
+        return _description;
+    }
+
+    vector<string> const& simple_config_origin::comments() const {
+        return _comments_or_null;
+    }
+
+    shared_origin simple_config_origin::with_line_number(int line_number) const {
+        if (line_number == _line_number && line_number == _end_line_number) {
+            return shared_from_this();
+        } else {
+            return make_shared<simple_config_origin>(_description, line_number, line_number, _origin_type,
+                    _resource_or_null, _comments_or_null);
+        }
+    }
+
+    shared_origin simple_config_origin::with_comments(std::vector<std::string> comments) const {
+        if (comments == _comments_or_null || comments.empty()) {
+            return shared_from_this();
+        } else {
+            return make_shared<simple_config_origin>(_description, _line_number, _end_line_number, _origin_type,
+                                                     _resource_or_null, move(comments));
+        }
+    }
+
+    shared_ptr<const simple_config_origin> simple_config_origin::append_comments(vector<string> comments) const {
+        if (comments == _comments_or_null || comments.empty()) {
+            return shared_from_this();
+        } else {
+            // Don't re-use with_comments, because we've already checked whether they're equal.
+            // If they're not equal now, the concatenated comments won't be equal either.
+            comments.insert(comments.begin(), _comments_or_null.begin(), _comments_or_null.end());
+            return make_shared<simple_config_origin>(_description, _line_number, _line_number, _origin_type,
+                                                     _resource_or_null, move(comments));
+        }
+    }
+
+    shared_ptr<const simple_config_origin> simple_config_origin::prepend_comments(vector<string> comments) const {
+        if (comments == _comments_or_null || comments.empty()) {
+            return shared_from_this();
+        } else {
+            // Don't re-use with_comments, because we've already checked whether they're equal.
+            // If they're not equal now, the concatenated comments won't be equal either.
+            comments.insert(comments.end(), _comments_or_null.begin(), _comments_or_null.end());
+            return make_shared<simple_config_origin>(_description, _line_number, _line_number, _origin_type,
+                                                     _resource_or_null, move(comments));
+        }
+    }
+
+    shared_origin simple_config_origin::merge_origins(shared_origin a, shared_origin b) {
+        return merge_two(dynamic_pointer_cast<const simple_config_origin>(a), dynamic_pointer_cast<const simple_config_origin>(b));
+    }
+
+    shared_origin simple_config_origin::merge_origins(std::vector<shared_value> const& stack) {
+        vector<shared_origin> origins;
+        origins.reserve(stack.size());
+
+        for (auto& v : stack) {
+            origins.push_back(v->origin());
+        }
+
+        return merge_origins(origins);
+    }
+
+    shared_origin simple_config_origin::merge_origins(std::vector<shared_origin> const& stack) {
+        if (stack.empty()) {
+            throw config_exception(_("can't merge empty list of origins"));
+        } else if (stack.size() == 1) {
+            return stack.front();
+        } else if (stack.size() == 2) {
+            return(merge_two(dynamic_pointer_cast<const simple_config_origin>(stack[0]),
+                             dynamic_pointer_cast<const simple_config_origin>(stack[1])));
+        } else {
+            vector<shared_origin> remaining;
+            for (auto& o : stack) {
+                remaining.push_back(dynamic_pointer_cast<const simple_config_origin>(o));
+            }
+            while (remaining.size() > 2) {
+                auto c = dynamic_pointer_cast<const simple_config_origin>(remaining.back());
+                remaining.pop_back();
+                auto b = dynamic_pointer_cast<const simple_config_origin>(remaining.back());
+                remaining.pop_back();
+                auto a = dynamic_pointer_cast<const simple_config_origin>(remaining.back());
+                remaining.pop_back();
+
+                shared_origin merged = merge_three(a, b, c);
+                remaining.push_back(merged);
+            }
+
+            //  should be down to either 1 or 2
+            return merge_origins(remaining);
+        }
+    }
+
+    shared_ptr<const simple_config_origin> simple_config_origin::merge_two(shared_ptr<const simple_config_origin> a,
+                                                                           shared_ptr<const simple_config_origin> b) {
+        string merged_desc;
+        int merged_start_line;
+        int merged_end_line;
+
+        origin_type merged_type;
+        if (a->_origin_type == b->_origin_type) {
+            merged_type = a->_origin_type;
+        } else {
+            merged_type = origin_type::GENERIC;
+        }
+
+        static const string MERGE_OF_PREFIX { "merge of " };
+        // first use the "description" field which has no line numbers
+        // cluttering it.
+        string a_desc { a->description() };
+        string b_desc { b->description() };
+        if (boost::starts_with(a_desc, MERGE_OF_PREFIX)) {
+            a_desc = a_desc.substr(MERGE_OF_PREFIX.length());
+        }
+
+        if (boost::starts_with(b_desc, MERGE_OF_PREFIX)) {
+            b_desc = b_desc.substr(MERGE_OF_PREFIX.length());
+        }
+
+        if (a_desc == b_desc) {
+            merged_desc = a_desc;
+
+            if (a->line_number() < 0) {
+                merged_start_line = b->line_number();
+            } else if (b->line_number() < 0) {
+                merged_start_line = a->line_number();
+            } else {
+                merged_start_line = min(a->_end_line_number, b->_end_line_number);
+            }
+
+            merged_end_line = max(a->_end_line_number, b->_end_line_number);
+        } else {
+            // this whole merge song-and-dance was intended to avoid this case
+            // whenever possible, but we've lost. Now we have to lose some
+            // structured information and cram into a string.
+
+            merged_desc = MERGE_OF_PREFIX + a_desc + "," + b_desc;
+            merged_start_line = -1;
+            merged_end_line = -1;
+        }
+
+        string merged_resource;
+        if (a->_resource_or_null == b->_resource_or_null) {
+            merged_resource = a->_resource_or_null;
+        }
+
+        vector<string> merged_comments;
+        if (a->_comments_or_null == b->_comments_or_null) {
+            merged_comments = a->_comments_or_null;
+        } else {
+            if (!a->_comments_or_null.empty())
+            {
+                merged_comments.insert(merged_comments.end(), a->_comments_or_null.begin(), a->_comments_or_null.end());
+            }
+            if (!b->_comments_or_null.empty())
+            {
+                merged_comments.insert(merged_comments.end(), b->_comments_or_null.begin(), b->_comments_or_null.end());
+            }
+        }
+
+        return make_shared<simple_config_origin>(move(merged_desc), move(merged_start_line), move(merged_end_line), move(merged_type),
+                                                 move(merged_resource), move(merged_comments));
+    }
+
+    shared_ptr<const simple_config_origin> simple_config_origin::merge_three(shared_ptr<const simple_config_origin> a,
+                                                                             shared_ptr<const simple_config_origin> b,
+                                                                             shared_ptr<const simple_config_origin> c) {
+        if (similarity(a, b) >= similarity(b, c)) {
+            return merge_two(merge_two(a, b), c);
+        } else {
+            return merge_two(a, merge_two(b, c));
+        }
+    }
+
+    int simple_config_origin::similarity(shared_ptr<const simple_config_origin> a,
+                                         shared_ptr<const simple_config_origin> b) {
+        int count = 0;
+
+        if (a->_origin_type == b->_origin_type) {
+            count += 1;
+        }
+        if (a->_description == b->_description) {
+            count += 1;
+        }
+
+        // only count these if the description field (which is the file
+        // or resource name) also matches.
+        if (a->_line_number == b->_line_number) {
+            count += 1;
+        }
+        if (a->_end_line_number == b->_end_line_number) {
+            count += 1;
+        }
+        if (a->_resource_or_null == b->_resource_or_null) {
+            count += 1;
+        }
+
+        return count;
+    }
+
+
+    bool simple_config_origin::operator==(const simple_config_origin &other) const {
+        return (other._description == _description) &&
+                (other._line_number == _line_number) &&
+                (other._end_line_number == _end_line_number) &&
+                (other._origin_type == _origin_type) &&
+                (other._resource_or_null == _resource_or_null) &&
+                (other._comments_or_null == _comments_or_null);
+    }
+
+    bool simple_config_origin::operator!=(const simple_config_origin &other) const {
+        return !(*this == other);
+    }
+
+}  // namespace hocon