cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,257 @@
+#include <internal/tokens.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/tokenizer.hpp>
+#include <iostream>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    /** Value token */
+    value::value(shared_value value) :
+            token(token_type::VALUE, nullptr, value->transform_to_string()), _value(move(value)) { }
+
+    value::value(shared_value value, string original_text) :
+            token(token_type::VALUE, nullptr, original_text),
+            _value(move(value)) { }
+
+    std::string value::to_string() const {
+        return _value->render();
+    }
+
+    shared_origin const& value::origin() const {
+        return _value->origin();
+    }
+
+    shared_value value::get_value() const {
+        return _value;
+    }
+
+    bool value::operator==(const token& other) const {
+        return other.get_token_type() == token_type::VALUE &&
+               other.to_string() == to_string();
+    }
+
+    /** Line token */
+    line::line(shared_origin origin) :
+            token(token_type::NEWLINE, move(origin), "\n") { }
+
+    string line::to_string() const {
+        return "'\\n'@" + std::to_string(line_number());
+    }
+
+    bool line::operator==(const token& other) const {
+        return (other.get_token_type() == token_type::NEWLINE) && (line_number() == other.line_number());
+    }
+
+    /** Unquoted text token */
+    unquoted_text::unquoted_text(shared_origin origin, string text) :
+            token(token_type::UNQUOTED_TEXT, move(origin), move(text)) { }
+
+    string unquoted_text::to_string() const {
+        return "'" + token_text() + "' (UNQUOTED)";
+    }
+
+    bool unquoted_text::operator==(const token& other) const {
+        return (other.get_token_type() == token_type::UNQUOTED_TEXT) &&
+                (other.token_text() == token_text());
+    }
+
+    /** Ignored whitespace token */
+    ignored_whitespace::ignored_whitespace(shared_origin origin, string whitespace) :
+        token(token_type::IGNORED_WHITESPACE, move(origin), move(whitespace)) { }
+
+    string ignored_whitespace::to_string() const {
+        return "'" + token_text() + "' (WHITESPACE)";
+    }
+
+    bool ignored_whitespace::operator==(const token& other) const {
+        return other.get_token_type() == token_type::IGNORED_WHITESPACE &&
+                other.token_text() == token_text();
+    }
+
+    /** Problem token */
+    problem::problem(shared_origin origin, string what, string message,
+        bool suggest_quotes) : token(token_type::PROBLEM, move(origin)), _what(move(what)),
+        _message(move(message)), _suggest_quotes(suggest_quotes) { }
+
+    string problem::what() const {
+        return _what;
+    }
+
+    string problem::message() const {
+        return _message;
+    }
+
+    bool problem::suggest_quotes() const {
+        return _suggest_quotes;
+    }
+
+    std::string problem::to_string() const {
+        return "'" + _what + "' (" + _message + ")";
+    }
+
+    bool problem::operator==(const token& other) const {
+        try {
+            problem const& other_problem = dynamic_cast<problem const&>(other);
+            return other_problem.what() == what() &&
+                   other_problem.message() == message() &&
+                   other_problem.suggest_quotes() == suggest_quotes();
+        } catch (bad_cast ex){
+            return false;
+        }
+    }
+
+    /** Comment token */
+    comment::comment(shared_origin origin, string text) :
+        token(token_type::COMMENT, move(origin)), _text(move(text)) { }
+
+    string comment::text() const {
+        return _text;
+    }
+
+    string comment::to_string() const {
+        return "'#" + _text + "' (COMMENT)";
+    }
+
+    bool comment::operator==(const token& other) const {
+        return other.get_token_type() == token_type::COMMENT && to_string() == other.to_string();
+    }
+
+    /** Double-slash comment token */
+    double_slash_comment::double_slash_comment(shared_origin origin, string text) :
+        comment(move(origin), move(text)) { }
+
+    string double_slash_comment::token_text() const {
+        return "//" + text();
+    }
+
+    /** Hash comment token */
+    hash_comment::hash_comment(shared_origin origin, string text) :
+        comment(move(origin), move(text)) { }
+
+    string hash_comment::token_text() const {
+        return "#" + text();
+    }
+
+    /** Substitution token */
+    substitution::substitution(shared_origin origin, bool optional,
+        token_list expression) : token(token_type::SUBSTITUTION, move(origin)), _optional(optional),
+        _expression(move(expression)) { }
+
+    bool substitution::optional() const {
+        return _optional;
+    }
+
+    token_list const& substitution::expression() const {
+        return _expression;
+    }
+
+    string substitution::token_text() const {
+        return "${" + string(optional() ? "?" : "") + token_iterator::render(_expression) + "}";
+    }
+
+    string substitution::to_string() const {
+        string result;
+        for (auto&& t : _expression) {
+            result += t->token_text();
+        }
+        return "'${" + result + "}'";
+    }
+
+    bool substitution::operator==(const token& other) const {
+        return other.get_token_type() == token_type::SUBSTITUTION &&
+               to_string() == other.to_string();
+    }
+
+    /** Singleton tokens */
+    shared_token const& tokens::start_token() {
+        static shared_token _start = make_shared<token>(
+                token_type::START, nullptr, "", "start of file");
+        return _start;
+    }
+
+    shared_token const& tokens::end_token() {
+        static shared_token _end = make_shared<token>(
+                token_type::END, nullptr, "", "end of file");
+        return _end;
+    }
+
+    shared_token const& tokens::comma_token() {
+        static shared_token _comma = make_shared<token>(
+                token_type::COMMA, nullptr, ",", "','");
+        return _comma;
+    }
+
+    shared_token const& tokens::equals_token() {
+        static shared_token _equals = make_shared<token>(
+                token_type::EQUALS, nullptr, "=", "'='");
+        return _equals;
+    }
+
+    shared_token const& tokens::colon_token() {
+        static shared_token _colon = make_shared<token>(
+                token_type::COLON, nullptr, ":", "':'");
+        return _colon;
+    }
+
+    shared_token const& tokens::open_curly_token() {
+        static shared_token _open_curly = make_shared<token>(
+                token_type::OPEN_CURLY, nullptr, "{", "'{'");
+        return _open_curly;
+    }
+
+    shared_token const& tokens::close_curly_token() {
+        static shared_token _close_curly = make_shared<token>(
+                token_type::CLOSE_CURLY, nullptr, "}", "'}'");
+        return _close_curly;
+    }
+
+    shared_token const& tokens::open_square_token() {
+        static shared_token _open_square = make_shared<token>(
+                token_type::OPEN_SQUARE, nullptr, "[", "'['");
+        return _open_square;
+    }
+
+    shared_token const& tokens::close_square_token() {
+        static shared_token _close_square = make_shared<token>(
+                token_type::CLOSE_SQUARE, nullptr, "]", "']'");
+        return _close_square;
+    }
+
+    shared_token const& tokens::plus_equals_token() {
+        static shared_token _plus_equals = make_shared<token>(
+                token_type::PLUS_EQUALS, nullptr, "+=", "'+='");
+        return _plus_equals;
+    }
+
+    bool tokens::is_newline(shared_token t) {
+        return dynamic_pointer_cast<const line>(t) != nullptr;
+    }
+
+    bool tokens::is_ignored_whitespace(shared_token t) {
+        return dynamic_pointer_cast<const ignored_whitespace>(t) != nullptr;
+    }
+
+    /** Static token handler methods */
+    shared_value tokens::get_value(shared_token t) {
+        if (auto value_token = dynamic_pointer_cast<const value>(t)) {
+            return value_token->get_value();
+        } else {
+            throw config_exception(_("Tried to get the value of a non-value token."));
+        }
+    }
+
+    bool tokens::is_value_with_type(shared_token token, config_value::type type) {
+        auto value_token = dynamic_pointer_cast<const value>(token);
+        if (value_token) {
+            return value_token->get_value()->value_type() == type;
+        }
+        return false;
+    }
+
+}  // namespace hocon

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

@@ -0,0 +1,34 @@
+#include <internal/values/config_boolean.hpp>
+
+using namespace std;
+
+namespace hocon {
+
+    config_boolean::config_boolean(shared_origin origin, bool value) :
+        config_value(move(origin)), _value(value) { }
+
+    config_value::type config_boolean::value_type() const {
+        return config_value::type::BOOLEAN;
+    }
+
+    string config_boolean::transform_to_string() const {
+        return _value ? "true" : "false";
+    }
+
+    bool config_boolean::bool_value() const {
+        return _value;
+    }
+
+    unwrapped_value config_boolean::unwrapped() const {
+        return _value;
+    }
+
+    shared_value config_boolean::new_copy(shared_origin origin) const {
+        return make_shared<config_boolean>(move(origin), _value);
+    }
+
+    bool config_boolean::operator==(config_value const& other) const {
+        return equals<config_boolean>(other, [&](config_boolean const& o) { return _value == o._value; });
+    }
+
+}  // namespace hocon

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

@@ -0,0 +1,260 @@
+#include <hocon/config_object.hpp>
+#include <hocon/path.hpp>
+#include <internal/values/config_concatenation.hpp>
+#include <internal/values/config_string.hpp>
+#include <internal/default_transformer.hpp>
+#include <internal/values/simple_config_list.hpp>
+#include <internal/simple_config_origin.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/values/config_string.hpp>
+#include <internal/resolve_result.hpp>
+#include <internal/resolve_source.hpp>
+#include <internal/resolve_context.hpp>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    config_concatenation::config_concatenation(shared_origin origin, std::vector<shared_value> pieces) :
+            config_value(move(origin)), _pieces(move(pieces)) {
+        if (_pieces.size() < 2) {
+            throw config_exception(_("Created concatenation with less than 2 items"));
+        }
+
+        bool had_unmergeable = false;
+        for (shared_value p : _pieces) {
+            if (dynamic_pointer_cast<const config_concatenation>(p)) {
+                throw config_exception(_("config_concatenation should never be nested"));
+            }
+
+            if (dynamic_pointer_cast<const unmergeable>(p)) {
+                had_unmergeable = true;
+            }
+        }
+
+        if (!had_unmergeable) {
+            throw config_exception(_("Created concatenation without an unmergeable in it"));
+        }
+    }
+
+    config_value::type config_concatenation::value_type() const {
+        throw not_resolved();
+    }
+
+    vector<shared_value> config_concatenation::unmerged_values() const {
+        return { shared_from_this() };
+    }
+
+    resolve_status config_concatenation::get_resolve_status() const {
+        return resolve_status::UNRESOLVED;
+    }
+
+    shared_value config_concatenation::replace_child(shared_value const& child, shared_value replacement) const {
+        auto new_list = config_value::replace_child_in_list(_pieces, child, replacement);
+        if (new_list.empty()) {
+            return nullptr;
+        } else {
+            return make_shared<config_concatenation>(origin(), move(new_list));
+        }
+    }
+
+    bool config_concatenation::has_descendant(shared_value const &descendant) const {
+        return has_descendant_in_list(_pieces, descendant);
+    }
+
+    resolve_result<shared_value>
+    config_concatenation::resolve_substitutions(resolve_context const& context,
+                                                resolve_source const& source) const
+    {
+        // Right now there's no reason to pushParent here because the
+        // content of ConfigConcatenation should not need to replaceChild,
+        // but if it did we'd have to do this.
+        resolve_context new_context { context };
+
+        vector<shared_value> resolved;
+        resolved.reserve(_pieces.size());
+
+        for (auto& p : _pieces) {
+            // to concat into a string we have to do a full resolve,
+            // so unrestrict the context, then put restriction back afterward
+            auto restriction = new_context.restrict_to_child();
+            resolve_result<shared_value> result {new_context.unrestricted().resolve(p, source)};
+            auto r = result.value;
+            new_context = result.context.restrict(restriction);
+
+            if (r == nullptr) {
+                // it was optional... omit
+            } else {
+                resolved.push_back(r);
+            }
+        }
+
+        // now need to concat everything
+        vector<shared_value> joined { consolidate(resolved) };
+        // if unresolved is allowed we can just become another
+        // ConfigConcatenation
+        if (joined.size() > 1 && context.options().get_allow_unresolved()) {
+            return make_resolve_result(move(new_context), make_shared<config_concatenation>(origin(), move(joined)));
+        } else if (joined.empty()) {
+            // we had just a list of optional references using ${?}
+            return make_resolve_result(move(new_context), shared_value {});
+        } else if (joined.size() == 1) {
+            return make_resolve_result(new_context, joined.front());
+        } else {
+            throw config_exception(_("Bug in the library: resolved list was joined to too many values"));
+        }
+    }
+
+    vector<shared_value> config_concatenation::consolidate(vector<shared_value> pieces) {
+        if (pieces.size() < 2) {
+            return pieces;
+        } else {
+            vector<shared_value> flattened;
+            flattened.reserve(pieces.size());
+            for (auto& v : pieces) {
+                if (auto v_concat = dynamic_pointer_cast<const config_concatenation>(v)) {
+                    flattened.insert(flattened.end(), v_concat->_pieces.begin(), v_concat->_pieces.end());
+                } else {
+                    flattened.push_back(v);
+                }
+            }
+
+            vector<shared_value> consolidated;
+            consolidated.reserve(flattened.size());
+
+            for (auto& v : flattened) {
+                if (consolidated.empty()) {
+                    consolidated.push_back(v);
+                } else {
+                    join(consolidated, v);
+                }
+            }
+
+            return consolidated;
+        }
+    }
+
+    shared_value config_concatenation::concatenate(std::vector<shared_value> pieces) {
+        vector<shared_value> consolidated { consolidate(pieces) };
+        if (consolidated.empty()) {
+            return nullptr;
+        } else if (consolidated.size() == 1) {
+            return consolidated.front();
+        } else {
+            shared_origin merged_origin = simple_config_origin::merge_origins(consolidated);
+            return make_shared<config_concatenation>(move(merged_origin), move(consolidated));
+        }
+    }
+
+    // when you graft a substitution into another object,
+    // you have to prefix it with the location in that object
+    // where you grafted it; but save prefixLength so
+    // system property and env variable lookups don't get
+    // broken.
+    shared_value config_concatenation::relativized(std::string prefix) const {
+        vector<shared_value> new_pieces;
+        new_pieces.reserve(_pieces.size());
+        for (auto& p : _pieces) {
+            new_pieces.push_back(p->relativized(prefix));
+        }
+
+        return make_shared<config_concatenation>(origin(), move(new_pieces));
+    }
+
+    bool config_concatenation::operator==(config_value const& other) const {
+        // note that "origin" is deliberately NOT part of equality
+        return equals<config_concatenation>(other, [&](config_concatenation const& o) {
+            if (_pieces.size() != o._pieces.size()) { return false; }
+            bool result = true;
+            for (unsigned long i = 0; i < _pieces.size(); i++) {
+                result = *_pieces[i] == *o._pieces[i];
+            }
+            return result;
+        });
+    }
+
+    shared_value config_concatenation::new_copy(shared_origin origin) const {
+        return make_shared<config_concatenation>(move(origin), _pieces);
+    }
+
+    unwrapped_value config_concatenation::unwrapped() const {
+        throw config_exception(_("Not resolved, call config::resolve() before attempting to unwrap. See API docs."));
+    }
+
+    bool config_concatenation::ignores_fallbacks() const {
+        // we can never ignore fallbacks because if a child ConfigReference
+        // is self-referential we have to look lower in the merge stack
+        // for its value.
+        return false;
+    }
+
+    void config_concatenation::render(std::string& result, int indent, bool at_root, config_render_options options) const {
+        for (auto& p : _pieces) {
+            p->render(result, indent, at_root, options);
+        }
+    }
+
+    config_exception config_concatenation::not_resolved() const {
+        return config_exception(_("need to config#resolve(), see the API docs for config#resolve; substitution not resolved"));
+    }
+
+    bool config_concatenation::is_ignored_whitespace(shared_value value) {
+        auto value_string = dynamic_pointer_cast<const config_string>(value);
+        return (value_string && !value_string->was_quoted());
+    }
+
+    /**
+     * Add left and right, or their merger, to builder.
+     */
+    void config_concatenation::join(std::vector<shared_value> & builder, shared_value right) {
+        auto left = builder.back();
+
+        // check for an object which can be converted to a list
+        // (this will be an object with numeric keys, like foo.0, foo.1)
+        if (dynamic_pointer_cast<const config_object>(left) && dynamic_pointer_cast<const simple_config_list>(right)) {
+            left = default_transformer::transform(left, config_value::type::LIST);
+        } else if (dynamic_pointer_cast<const simple_config_list>(left) && dynamic_pointer_cast<const config_object>(right)) {
+            right = default_transformer::transform(right, config_value::type::LIST);
+        }
+
+        // Since this depends on the type of two instances, I couldn't think
+        // of much alternative to an instanceof chain. Visitors are sometimes
+        // used for multiple dispatch but seems like overkill.
+        shared_value joined = nullptr;
+
+        if (dynamic_pointer_cast<const config_object>(left) && dynamic_pointer_cast<const config_object>(right)) {
+            joined = dynamic_pointer_cast<const config_value>(right->with_fallback(left));
+        } else if (dynamic_pointer_cast<const simple_config_list>(left) && dynamic_pointer_cast<const simple_config_list>(right)) {
+            joined = dynamic_pointer_cast<const simple_config_list>(left)->concatenate(dynamic_pointer_cast<const simple_config_list>(right));
+        } else if ((dynamic_pointer_cast<const simple_config_list>(left) || dynamic_pointer_cast<const config_object>(left)) &&
+                is_ignored_whitespace(right)) {
+            joined = left;
+            // it should be impossible that left is whitespace and right is a list or object
+        } else if (dynamic_pointer_cast<const config_concatenation>(left) || dynamic_pointer_cast<const config_concatenation>(right)) {
+            throw config_exception(_("unflattened config_concatenation"));
+        } else if (dynamic_pointer_cast<const unmergeable>(left) || dynamic_pointer_cast<const unmergeable>(right)) {
+            // leave joined=null, cannot join
+        } else {
+            // handle primitive type or primitive type mixed with object or list
+            string s1 { left->transform_to_string() };
+            string s2 { right->transform_to_string() };
+            if (s1.empty() || s2.empty()) {
+                throw config_exception(_("Cannot concatenate object or list with a non-object-or-list: {1} and {2} are not compatible", s1, s2));
+            } else {
+                auto joined_origin = simple_config_origin::merge_origins(left->origin(), right->origin());
+                joined = make_shared<config_string>(move(joined_origin), s1 + s2, config_string_type::QUOTED);
+            }
+        }
+
+        if (joined) {
+            builder.pop_back();
+            builder.push_back(joined);
+        } else {
+            builder.push_back(right);
+        }
+    }
+}  // namespace hocon