cfacter 3.11.0.rc.20180314

data/ext/facter/cpp-hocon/lib/src/nodes/config_node_field.cc

@@ -0,0 +1,80 @@
+#include <internal/nodes/config_node_field.hpp>
+#include <hocon/config_exception.hpp>
+#include <internal/nodes/config_node_single_token.hpp>
+#include <internal/tokens.hpp>
+#include <internal/nodes/config_node_comment.hpp>
+#include <internal/nodes/config_node_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_node_field::config_node_field(shared_node_list children) :
+            _children(move(children)) { }
+
+    token_list config_node_field::get_tokens() const {
+        token_list tokens;
+        for (auto&& node : _children) {
+            token_list node_tokens = node->get_tokens();
+            tokens.insert(tokens.end(), node_tokens.begin(), node_tokens.end());
+        }
+        return tokens;
+    }
+
+    shared_ptr<const config_node_field> config_node_field::replace_value(shared_node_value new_value) const {
+        shared_node_list children_copy = _children;
+        for (size_t i = 0; i < children_copy.size(); i++) {
+            if (dynamic_pointer_cast<const abstract_config_node_value>(children_copy[i])) {
+                children_copy[i] = new_value;
+                return make_shared<config_node_field>(move(children_copy));
+            }
+        }
+        throw config_exception(_("Field doesn't have a value."));
+    }
+
+    shared_node_value config_node_field::get_value() const {
+        for (auto&& child : _children) {
+            if (auto value = dynamic_pointer_cast<const abstract_config_node_value>(child)) {
+                return value;
+            }
+        }
+        throw config_exception(_("Field node doesn't have a value."));
+    }
+
+    shared_ptr<const config_node_path> config_node_field::path() const {
+        for (auto&& node : _children) {
+            if (auto path_node = dynamic_pointer_cast<const config_node_path>(node)) {
+                return path_node;
+            }
+        }
+        throw config_exception(_("Field node does not have a path"));
+    }
+
+    shared_token config_node_field::separator() const {
+        for (auto&& child : _children) {
+            if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(child)) {
+                shared_token t = single_token->get_token();
+                if (t == tokens::plus_equals_token() || t == tokens::colon_token() || t == tokens::equals_token()) {
+                    return t;
+                }
+            }
+        }
+        return nullptr;
+     }
+
+    vector<string> config_node_field::comments() const {
+        vector<string> comments;
+        for (auto&& child : _children) {
+            auto comment = dynamic_pointer_cast<const config_node_comment>(child);
+            if (comment) {
+                comments.push_back(comment->comment_text());
+            }
+        }
+        return comments;
+    }
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/src/nodes/config_node_include.cc

@@ -0,0 +1,38 @@
+#include <internal/nodes/config_node_include.hpp>
+#include <internal/nodes/config_node_simple_value.hpp>
+
+using namespace std;
+
+namespace hocon {
+
+    config_node_include::config_node_include(shared_node_list children,
+                                             config_include_kind kind) :
+        _children(move(children)), _kind(kind) { }
+
+    token_list config_node_include::get_tokens() const {
+        token_list tokens;
+        for (auto&& node : _children) {
+            token_list node_tokens = node->get_tokens();
+            tokens.insert(tokens.end(), node_tokens.begin(), node_tokens.end());
+        }
+        return tokens;
+    }
+
+    shared_node_list const& config_node_include::children() const {
+        return _children;
+    }
+
+    config_include_kind config_node_include::kind() const {
+        return _kind;
+    }
+
+    string config_node_include::name() const {
+        for (auto&& node : _children) {
+            if (auto simple = dynamic_cast<const config_node_simple_value*>(node.get())) {
+                return simple->get_value()->transform_to_string();
+            }
+        }
+        return "";
+    }
+
+}  // namesapce hocon

data/ext/facter/cpp-hocon/lib/src/nodes/config_node_object.cc

@@ -0,0 +1,318 @@
+#include <internal/nodes/config_node_object.hpp>
+#include <internal/nodes/config_node_field.hpp>
+#include <internal/nodes/config_node_single_token.hpp>
+#include <internal/tokens.hpp>
+#include <internal/path_parser.hpp>
+#include <internal/nodes/config_node_include.hpp>
+#include <boost/range/iterator_range_core.hpp>
+
+using namespace std;
+
+namespace hocon {
+
+    config_node_object::config_node_object(shared_node_list children) :
+            config_node_complex_value(move(children)) { }
+
+    shared_ptr<const config_node_complex_value> config_node_object::new_node(shared_node_list nodes) const {
+        return make_shared<config_node_object>(move(nodes));
+    }
+
+    bool config_node_object::has_value(path desired_path) const {
+        for (auto&& node : children()) {
+            if (auto field = dynamic_pointer_cast<const config_node_field>(node)) {
+                path key = field->path()->get_path();
+                if (key == desired_path || key.starts_with(desired_path)) {
+                    return true;
+                } else if (desired_path.starts_with(key)) {
+                    if (auto object = dynamic_pointer_cast<const config_node_object>(field->get_value())) {
+                        path remaining_path = desired_path.sub_path(key.length());
+                        if (object->has_value(remaining_path)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    shared_ptr<const config_node_object> config_node_object::change_value_on_path(path desired_path, shared_node_value value,
+                                                                            config_syntax flavor) const
+    {
+        shared_node_list children_copy = children();
+        bool seen_non_matching = false;
+        shared_node_value value_copy = value;
+        for (int i = static_cast<int>(children_copy.size() - 1); i >= 0; i--) {
+            auto&& child = children_copy[i];
+            if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(child)) {
+                shared_token t = single_token->get_token();
+                // Ensure that, when we are removing settings in JSON, we don't end up with a trailing comma
+                if (flavor == config_syntax::JSON && !seen_non_matching && t == tokens::comma_token()) {
+                    children_copy.erase(children_copy.begin() + i);
+                }
+                continue;
+            } else if (dynamic_pointer_cast<const config_node_field>(child) == nullptr) {
+                continue;
+            }
+            auto field = dynamic_pointer_cast<const config_node_field>(child);
+            path key = field->path()->get_path();
+
+            // Delete all multi-element paths that start with the desired path, since technically they are duplicates
+            if ((value_copy == nullptr && key == desired_path) ||
+                    (key.starts_with(desired_path) && !(key == desired_path)))
+            {
+                children_copy.erase(children_copy.begin() + i);
+                //  Remove any whitespace or commas after the deleted setting
+                for (size_t j = i; j < children_copy.size(); j++) {
+                    if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(children_copy[j])) {
+                        shared_token t = single_token->get_token();
+                        if (t->get_token_type() == token_type::IGNORED_WHITESPACE || t == tokens::comma_token()) {
+                            children_copy.erase(children_copy.begin() + j);
+                            j--;
+                        } else {
+                            break;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            } else if (key == desired_path) {
+                seen_non_matching = true;
+                shared_node_value indented_value;
+                shared_node before = i - 1 > 0 ? children_copy[i - 1] : nullptr;
+                if (auto complex = dynamic_pointer_cast<const config_node_complex_value>(value)) {
+                    if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(before)) {
+                        if (single_token->get_token()->get_token_type() == token_type::IGNORED_WHITESPACE) {
+                            indented_value = complex->indent_text(before);
+                        } else {
+                            indented_value = value;
+                        }
+                    } else {
+                        indented_value = value;
+                    }
+                } else {
+                    indented_value = value;
+                }
+                children_copy[i] = field->replace_value(indented_value);
+                value_copy = nullptr;
+            } else if (desired_path.starts_with(key)) {
+                seen_non_matching = true;
+                if (auto node_object = dynamic_pointer_cast<const config_node_object>(field->get_value())) {
+                    path remaining_path = desired_path.sub_path(key.length());
+                    children_copy[i] = field->replace_value(
+                            node_object->change_value_on_path(remaining_path, value_copy, flavor));
+                    if (value_copy != nullptr && !(*field == *children()[i])) {
+                        value_copy = nullptr;
+                    }
+                }
+            } else {
+                seen_non_matching = true;
+            }
+        }
+        return make_shared<config_node_object>(children_copy);
+    }
+
+    shared_ptr<const config_node_object> config_node_object::set_value_on_path(string desired_path, shared_node_value value,
+                                                                            config_syntax flavor) const {
+        config_node_path path = path_parser::parse_path_node(desired_path, flavor);
+        return set_value_on_path(path, value, flavor);
+    }
+
+    shared_ptr<const config_node_object> config_node_object::set_value_on_path(config_node_path desired_path, shared_node_value value,
+                                                                         config_syntax flavor) const {
+        auto node = change_value_on_path(desired_path.get_path(), value, flavor);
+
+        // If desired path did not exist, create it
+        if (!node->has_value(desired_path.get_path())) {
+            return node->add_value_on_path(desired_path, value, flavor);
+        }
+        return node;
+    }
+
+    shared_node_list config_node_object::indentation() const {
+        bool seen_new_line = false;
+        shared_node_list indentation;
+        if (children().empty()) {
+            return indentation;
+        }
+        for (size_t i = 0; i < children().size(); i++) {
+            if (!seen_new_line) {
+                if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(children()[i])) {
+                    if (single_token->get_token()->get_token_type() == token_type::NEWLINE) {
+                        seen_new_line = true;
+                        indentation.push_back(make_shared<config_node_single_token>(make_shared<line>(nullptr)));
+                    }
+                }
+            } else {
+                if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(children()[i])) {
+                    if (single_token->get_token()->get_token_type() == token_type::IGNORED_WHITESPACE &&
+                            (i + 1) < children().size()) {
+                        if (dynamic_pointer_cast<const config_node_field>(children()[i + 1]) ||
+                                dynamic_pointer_cast<const config_node_include>(children()[i + 1])) {
+                            indentation.push_back(children()[i]);
+                            return indentation;
+                        }
+                    }
+                }
+            }
+        }
+        if (indentation.empty()) {
+            indentation.push_back(make_shared<config_node_single_token>(make_shared<ignored_whitespace>(nullptr, " ")));
+        } else {
+            // Calculate the indentation of the ending curly brace to get the indentation of the root
+            shared_node last = children().back();
+            auto single_token = dynamic_pointer_cast<const config_node_single_token>(last);
+            if (single_token && single_token->get_token()->get_token_type() == token_type::CLOSE_CURLY) {
+                shared_node before_last = children()[children().size() - 2];
+                string indent = "";
+                auto single = dynamic_pointer_cast<const config_node_single_token>(before_last);
+                if (single && single->get_token()->get_token_type() == token_type::IGNORED_WHITESPACE) {
+                    indent = single->get_token()->token_text();
+                }
+                indent += "  ";
+                indentation.push_back(make_shared<config_node_single_token>(
+                        make_shared<ignored_whitespace>(nullptr, indent)));
+                return indentation;
+            }
+        }
+        // The object has no curly braces and is at the root level, so don't indent
+        return indentation;
+    }
+
+    shared_ptr<const config_node_object> config_node_object::add_value_on_path(config_node_path desired_path,
+                                                                         shared_node_value value,
+                                                                         config_syntax flavor) const
+    {
+        path raw_path = desired_path.get_path();
+        shared_node_list children_copy = children();
+        shared_node_list indent = indentation();
+
+        // If the value we're inserting is a complex value, we'll need to indent it for insertion
+        shared_node_value indented_value;
+        auto complex = dynamic_pointer_cast<const config_node_complex_value>(value);
+        if (complex && !indent.empty()) {
+            indented_value = complex->indent_text(indent.back());
+        } else {
+            indented_value = value;
+        }
+        bool same_line = true;
+        if (indent.size() > 0) {
+            if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(indent.front())) {
+                same_line = (single_token->get_token()->get_token_type() != token_type::NEWLINE);
+            }
+        }
+
+        // If the path is of length greater than one, see if the value needs to be added further down
+        if (raw_path.length() > 1) {
+            for (int i = children().size() - 1; i >= 0; i--) {
+                if (auto field = dynamic_pointer_cast<const config_node_field>(children()[i])) {
+                    path key = field->path()->get_path();
+                    if (raw_path.starts_with(key)) {
+                        if (auto object = dynamic_pointer_cast<const config_node_object>(field->get_value())) {
+                            config_node_path remaining_path = desired_path.sub_path(key.length());
+                            children_copy[i] = field->replace_value(object->add_value_on_path(
+                                                         remaining_path, value, flavor));
+                            return make_shared<config_node_object>(children_copy);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Otherwise, construct the new setting
+        bool starts_with_brace = !children().empty();
+        if (auto single_token = dynamic_pointer_cast<const config_node_single_token>(children().front())) {
+            starts_with_brace = starts_with_brace && single_token->get_token() == tokens::open_curly_token();
+        } else {
+            starts_with_brace = false;
+        }
+
+        shared_node_list new_nodes;
+        new_nodes.insert(new_nodes.end(), indent.begin(), indent.end());
+        new_nodes.push_back(make_shared<config_node_path>(desired_path.first()));
+        new_nodes.push_back(make_shared<config_node_single_token>(make_shared<ignored_whitespace>(nullptr, " ")));
+        new_nodes.push_back(make_shared<config_node_single_token>(tokens::colon_token()));
+        new_nodes.push_back(make_shared<config_node_single_token>(make_shared<ignored_whitespace>(nullptr, " ")));
+
+        if (raw_path.length() == 1) {
+            new_nodes.push_back(indented_value);
+        } else {
+            // If the path is of length greater than one add the required new objects along the path
+            shared_node_list new_object_nodes;
+            new_object_nodes.push_back(make_shared<config_node_single_token>(tokens::open_curly_token()));
+            if (indent.empty()) {
+                new_object_nodes.push_back(make_shared<config_node_single_token>(make_shared<line>(nullptr)));
+            }
+            new_object_nodes.insert(new_object_nodes.end(), indent.begin(), indent.end());
+            new_object_nodes.push_back(make_shared<config_node_single_token>(tokens::close_curly_token()));
+            config_node_object new_object { new_object_nodes };
+            new_nodes.push_back(new_object.add_value_on_path(desired_path.sub_path(1), indented_value, flavor));
+        }
+
+        // Combine these cases so that we only have to iterate once
+        if (flavor == config_syntax::JSON || starts_with_brace || same_line) {
+            for (int i = static_cast<int>(children_copy.size() - 1); i >= 0; i--) {
+                // If we are in JSON or are adding a setting on the same line,
+                // we need to add a comma to the last setting
+                if ((flavor == config_syntax::JSON || same_line) &&
+                        dynamic_pointer_cast<const config_node_field>(children_copy[i])) {
+                    if ((i + 1) >= static_cast<int>(children_copy.size()) ||
+                            !contains_token(children_copy[i + 1], token_type::COMMA)) {
+                        children_copy.insert(children_copy.begin() + i + 1,
+                                             make_shared<config_node_single_token>(tokens::comma_token()));
+                        break;
+                    }
+                }
+
+                // Add the value into the copy of the children map, keeping any whitespace/newlines
+                // before the close curly brace
+                if (starts_with_brace && contains_token(children_copy[i], token_type::CLOSE_CURLY)) {
+                    auto previous = children_copy[i - 1];
+                    if (contains_token(previous, token_type::NEWLINE)) {
+                        children_copy.insert(children_copy.begin() + i - 1, make_shared<config_node_field>(new_nodes));
+                        i--;
+                    } else if (contains_token(previous, token_type::IGNORED_WHITESPACE)) {
+                        auto before_prev = children_copy[i - 2];
+                        if (same_line) {
+                            children_copy.insert(children_copy.begin() + i - 1, make_shared<config_node_field>(new_nodes));
+                            i--;
+                        } else if (contains_token(before_prev, token_type::NEWLINE)) {
+                            children_copy.insert(children_copy.begin() + i - 2,
+                                                 make_shared<config_node_field>(new_nodes));
+                            i -= 2;
+                        } else {
+                            children_copy.insert(children_copy.begin() + i, make_shared<config_node_field>(new_nodes));
+                        }
+                    } else {
+                        children_copy.insert(children_copy.begin() + i, make_shared<config_node_field>(new_nodes));
+                    }
+                }
+            }
+        }
+
+        if (!starts_with_brace) {
+            if (!children_copy.empty() && contains_token(children_copy.back(), token_type::NEWLINE)) {
+                children_copy.insert(children_copy.end() - 1, make_shared<config_node_field>(new_nodes));
+            } else {
+                children_copy.push_back(make_shared<config_node_field>(new_nodes));
+            }
+        }
+        return make_shared<config_node_object>(children_copy);
+    }
+
+    shared_ptr<const config_node_object> config_node_object::remove_value_on_path(std::string desired_path,
+                                                                                  config_syntax flavor) const
+    {
+        path raw_path = path_parser::parse_path_node(desired_path, flavor).get_path();
+        return change_value_on_path(raw_path, nullptr, flavor);
+    }
+
+    bool config_node_object::contains_token(shared_node node, token_type type) {
+        auto single = dynamic_pointer_cast<const config_node_single_token>(node);
+        if (single) {
+            return single->get_token()->get_token_type() == type;
+        }
+        return false;
+    }
+
+}  // namesapce hocon

data/ext/facter/cpp-hocon/lib/src/nodes/config_node_path.cc

@@ -0,0 +1,47 @@
+#include <internal/nodes/config_node_path.hpp>
+#include <hocon/config_exception.hpp>
+#include <leatherman/locale/locale.hpp>
+
+// Mark string for translation (alias for leatherman::locale::format)
+using leatherman::locale::_;
+
+using namespace std;
+
+namespace hocon {
+
+    config_node_path::config_node_path(path node_path, token_list tokens) :
+        _path(move(node_path)), _tokens(move(tokens)) { }
+
+    token_list config_node_path::get_tokens() const {
+        return _tokens;
+    }
+
+    path config_node_path::get_path() const {
+        return _path;
+    }
+
+    config_node_path config_node_path::sub_path(int to_remove) {
+        int period_count = 0;
+        token_list tokens_copy = _tokens;
+        for (auto it = tokens_copy.begin(); it != tokens_copy.end(); it++) {
+            if ((*it)->get_token_type() == token_type::UNQUOTED_TEXT && (*it)->token_text() == ".") {
+                period_count++;
+            }
+
+            if (period_count == to_remove) {
+                return config_node_path(_path.sub_path(to_remove), token_list { it + 1, tokens_copy.end() });
+            }
+        }
+        throw config_exception(_("Tried to remove too many elements from a path node."));
+    }
+
+    config_node_path config_node_path::first() {
+        token_list tokens_copy = _tokens;
+        for (auto it = tokens_copy.begin(); it != tokens_copy.end(); it++) {
+            if ((*it)->get_token_type() == token_type::UNQUOTED_TEXT && (*it)->token_text() == ".") {
+                return config_node_path(_path.sub_path(0, 1), token_list { tokens_copy.begin(), it });
+            }
+        }
+        return *this;
+    }
+}  // namespace hocon