cfacter 3.11.0.rc.20180314

data/ext/facter/cpp-hocon/lib/inc/internal/path_builder.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <hocon/path.hpp>
+#include <stack>
+
+namespace hocon {
+
+    class path_builder {
+    public:
+        void append_key(std::string key);
+        void append_path(path path_to_append);
+
+        /** Returns null if keys is empty. */
+        path result();
+
+    private:
+        std::stack<std::string> _keys;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/path_parser.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "path_builder.hpp"
+#include "simple_config_origin.hpp"
+#include "tokenizer.hpp"
+#include <hocon/config_syntax.hpp>
+#include <internal/nodes/config_node_path.hpp>
+
+#include <string>
+#include <vector>
+
+namespace hocon  {
+
+    class path_parser {
+    public:
+        static config_node_path parse_path_node(std::string const& path_string,
+                                                config_syntax flavor = config_syntax::CONF);
+
+        static path parse_path(std::string const& path_string);
+
+        static path parse_path_expression(iterator& expression, shared_origin origin,
+                                          std::string const& original_text = "",
+                                          token_list* path_tokens = nullptr,
+                                          config_syntax flavor = config_syntax::CONF);
+
+        static config_node_path parse_path_node_expression(iterator& expression,
+                                                           shared_origin origin,
+                                                           std::string const& original_text = "",
+                                                           config_syntax flavor = config_syntax::CONF);
+
+    private:
+        class element {
+        public:
+            element(std::string initial, bool can_be_empty);
+
+            std::string to_string() const;
+
+            std::string _value;
+            bool _can_be_empty;
+        };
+
+        static token_list split_token_on_period(shared_token t, config_syntax flavor);
+
+        static void add_path_text(std::vector<element>& buff, bool was_quoted, std::string new_text);
+
+        static bool looks_unsafe_for_fast_parser(std::string s);
+
+        static path fast_path_build(path tail, std::string s);
+
+        static path speculative_fast_parse_path(std::string const& path);
+
+        static const shared_origin api_origin;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/replaceable_merge_stack.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <internal/resolve_context.hpp>
+#include <internal/container.hpp>
+
+namespace hocon {
+
+    // This is a faithful port of the Java ReplaceableMergeStack interface
+    class replaceable_merge_stack : public container {
+    public:
+        virtual shared_value make_replacement(resolve_context const& context, int skipping) const = 0;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/resolve_context.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <hocon/types.hpp>
+#include <hocon/config_resolve_options.hpp>
+#include <hocon/path.hpp>
+
+#include <unordered_map>
+
+namespace hocon {
+
+    class resolve_source;
+
+    template<typename T>
+    struct resolve_result;
+
+    class resolve_context {
+    public:
+        resolve_context(config_resolve_options options, path restrict_to_child, std::vector<shared_value> cycle_markers);
+        resolve_context(config_resolve_options options, path restrict_to_child);
+        bool is_restricted_to_child() const;
+        config_resolve_options options() const;
+
+        resolve_result<shared_value> resolve(shared_value original, resolve_source const& source) const;
+        path restrict_to_child() const;
+
+        resolve_context add_cycle_marker(shared_value value) const;
+        resolve_context remove_cycle_marker(shared_value value);
+        resolve_context restrict(path restrict_to) const;
+        resolve_context unrestricted() const;
+
+        static shared_value resolve(shared_value value, shared_object root, config_resolve_options options);
+
+    private:
+        struct memo_key {
+            shared_value value;
+            path restrict_to_child;
+            bool operator==(const memo_key& other) const {
+                return value == other.value && restrict_to_child == other.restrict_to_child;
+            }
+        };
+
+        struct memo_key_hash {
+            std::size_t operator()(const memo_key&) const;
+        };
+        using resolve_memos = std::unordered_map<memo_key, shared_value, memo_key_hash>;
+        config_resolve_options _options;
+        path _restrict_to_child;
+        resolve_memos _memos;
+        std::vector<shared_value> _cycle_markers;
+
+        resolve_context memoize(const memo_key& key, const shared_value& value) const;
+    };
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/resolve_result.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <internal/resolve_context.hpp>
+#include <memory>
+
+namespace hocon {
+
+    template<typename V>
+    struct resolve_result {
+        resolve_result(resolve_context c, V v) :
+            context(std::move(c)), value(std::move(v)) {}
+
+        resolve_context context;
+        V value;
+    };
+
+    template<typename T>
+    static resolve_result<shared_value> make_resolve_result(resolve_context context, T value) {
+        return resolve_result<shared_value>(std::move(context), std::move(value));
+    }
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/resolve_source.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <memory>
+#include <list>
+#include <hocon/types.hpp>
+#include <internal/resolve_result.hpp>
+#include <hocon/config_exception.hpp>
+
+namespace hocon {
+
+    class container;
+    class resolve_context;
+    class substitution_expression;
+
+    class resolve_source {
+    public:
+        typedef std::list<std::shared_ptr<const container>> node;
+
+        struct result_with_path {
+            resolve_result<shared_value> result;
+            node path_from_root;
+
+            result_with_path(resolve_result<shared_value> result_value, node path_from_root_value);
+        };
+
+        resolve_source(shared_object root);
+        resolve_source(shared_object root, node path_from_root);
+        resolve_source push_parent(std::shared_ptr<const container> parent) const;
+        result_with_path lookup_subst(resolve_context context, std::shared_ptr<substitution_expression> subst, int prefix_length) const;
+
+        resolve_source replace_current_parent(std::shared_ptr<const container> old, std::shared_ptr<const container> replacement) const;
+        resolve_source replace_within_current_parent(shared_value old, shared_value replacement) const;
+        resolve_source reset_parents() const;
+
+    private:
+        struct value_with_path {
+            shared_value value;
+            node path_from_root;
+
+            value_with_path(shared_value v, node path_from_root_value);
+        };
+
+        shared_object _root;
+        node _path_from_root;
+
+        static value_with_path find_in_object(shared_object obj, path the_path);
+        static result_with_path find_in_object(shared_object obj, resolve_context context, path the_path);
+        static value_with_path find_in_object(shared_object obj, path the_path, node parents);
+        static not_resolved_exception improve_not_resolved(path what, not_resolved_exception const& original);
+
+        shared_object root_must_be_obj(std::shared_ptr<const container> value) const;
+
+        static node replace(const node& list, std::shared_ptr<const container> old, shared_value replacement);
+    };
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/simple_config_document.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <hocon/parser/config_document.hpp>
+#include <internal/nodes/config_node_root.hpp>
+#include <hocon/config_parse_options.hpp>
+#include <memory>
+
+namespace hocon {
+
+    class simple_config_document : public config_document {
+    public:
+        simple_config_document(std::shared_ptr<const config_node_root> root,
+                               config_parse_options opts);
+
+        std::unique_ptr<config_document> with_value_text(std::string path, std::string new_value) const override;
+        std::unique_ptr<config_document> with_value(std::string path,
+                                                    std::shared_ptr<config_value> new_value) const override;
+        std::unique_ptr<config_document> without_path(std::string path) const override;
+
+        bool has_path(std::string const& path) const override;
+
+        std::string render() const override;
+
+    private:
+        std::shared_ptr<const config_node_root> _config_node_tree;
+        config_parse_options _parse_options;
+    };
+}

data/ext/facter/cpp-hocon/lib/inc/internal/simple_config_origin.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <hocon/config_origin.hpp>
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace hocon {
+
+    enum class origin_type { GENERIC, FILE, RESOURCE };
+
+    class simple_config_origin : public config_origin, public std::enable_shared_from_this<simple_config_origin> {
+    public:
+        simple_config_origin(std::string description, int line_number, int end_line_number,
+            origin_type org_type, std::string resource_or_null, std::vector<std::string> comments_or_null);
+
+        /** This constructor replaces the new_simple method in the original library. */
+        simple_config_origin(std::string description, int line_number = -1, int end_line_number = -1,
+                             origin_type org_type = origin_type::GENERIC);
+
+        int line_number() const override;
+
+        std::string const& description() const override;
+        std::vector<std::string> const& comments() const override;
+
+        /**
+         * Returns a pointer to a copy of this origin with the specified line number
+         * as both starting and ending line.
+         */
+        shared_origin with_line_number(int line_number) const override;
+
+        shared_origin with_comments(std::vector<std::string> comments) const override;
+        std::shared_ptr<const simple_config_origin> append_comments(std::vector<std::string> comments) const;
+        std::shared_ptr<const simple_config_origin> prepend_comments(std::vector<std::string> comments) const;
+
+        static shared_origin merge_origins(shared_origin a, shared_origin b);
+        static shared_origin merge_origins(std::vector<shared_value> const& stack);
+        static shared_origin merge_origins(std::vector<shared_origin> const& stack);
+
+        bool operator==(const simple_config_origin &other) const;
+        bool operator!=(const simple_config_origin &other) const;
+
+    private:
+        static std::shared_ptr<const simple_config_origin> merge_two(std::shared_ptr<const simple_config_origin> a,
+                                                                     std::shared_ptr<const simple_config_origin> b);
+
+        // this picks the best pair to merge, because the pair has the most in
+        // common. we want to merge two lines in the same file rather than something
+        // else with one of the lines; because two lines in the same file can be
+        // better consolidated.
+        static std::shared_ptr<const simple_config_origin> merge_three(std::shared_ptr<const simple_config_origin> a,
+                                                                       std::shared_ptr<const simple_config_origin> b,
+                                                                       std::shared_ptr<const simple_config_origin> c);
+
+        static int similarity(std::shared_ptr<const simple_config_origin> a,
+                              std::shared_ptr<const simple_config_origin> b);
+
+        std::string _description;
+        int _line_number;
+        int _end_line_number;
+        origin_type _origin_type;
+        std::string _resource_or_null;
+        std::vector<std::string> _comments_or_null;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/simple_include_context.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <hocon/config_include_context.hpp>
+#include "parseable.hpp"
+
+namespace hocon {
+
+    class simple_include_context : public config_include_context {
+    public:
+        // Include context is part of a parseable, so it can always expect a valid parseable reference.
+        simple_include_context(parseable const& parseable);
+
+        // Unused method
+        // shared_include_context with_parseable(weak_parseable new_parseable) const;
+
+        shared_parseable relative_to(std::string file_name) const override;
+        config_parse_options parse_options() const override;
+
+    private:
+        parseable const& _parseable;
+    };
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/simple_includer.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <hocon/config_includer.hpp>
+#include <hocon/config_includer_file.hpp>
+#include <hocon/config_parse_options.hpp>
+#include <internal/full_includer.hpp>
+
+namespace hocon {
+
+    class name_source;
+
+    class simple_includer : public config_includer, public config_includer_file, public std::enable_shared_from_this<simple_includer> {
+    public:
+        simple_includer(shared_includer fallback);
+
+        shared_includer with_fallback(shared_includer fallback) const override;
+
+        shared_object include(shared_include_context context, std::string what) const override;
+
+        shared_object include_without_fallback(shared_include_context context, std::string what) const;
+
+        shared_object include_file(shared_include_context context, std::string what) const override;
+
+        static shared_object include_file_without_fallback(shared_include_context context, std::string what);
+
+        static config_parse_options clear_for_include(config_parse_options const& options);
+
+        static shared_object from_basename(std::shared_ptr<name_source> source,
+                                           std::string name,
+                                           config_parse_options options);
+
+        static std::shared_ptr<const full_includer> make_full(std::shared_ptr<const config_includer> includer);
+
+    private:
+        shared_includer _fallback;
+
+        // the Proxy is a proxy for an application-provided includer that uses our
+        // default implementations when the application-provided includer doesn't
+        // have an implementation.
+        class proxy : public full_includer, public std::enable_shared_from_this<proxy> {
+        public:
+            proxy(std::shared_ptr<const config_includer> delegate);
+
+            shared_includer with_fallback(shared_includer fallback) const;
+
+            shared_object include(shared_include_context context, std::string what) const;
+
+            shared_object include_file(shared_include_context context, std::string what) const;
+
+            static std::shared_ptr<const full_includer> make_full(shared_includer includer);
+
+        private:
+            std::shared_ptr<const config_includer> _delegate;
+        };
+    };
+
+    class name_source {
+    public:
+        virtual shared_parseable name_to_parseable(std::string name,
+                                                   config_parse_options parse_options) const = 0;
+    };
+
+    class relative_name_source : public name_source {
+    public:
+        relative_name_source(shared_include_context context);
+
+        shared_parseable name_to_parseable(std::string name,
+                                           config_parse_options parse_options) const override;
+    private:
+        const shared_include_context _context;
+    };
+
+    class file_name_source : public name_source {
+    public:
+        shared_parseable name_to_parseable(std::string name,
+                                           config_parse_options parse_options) const override;
+    };
+
+}  // namespace hocon

data/ext/facter/cpp-hocon/lib/inc/internal/substitution_expression.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string>
+#include <memory>
+#include <hocon/path.hpp>
+
+namespace hocon {
+
+    class substitution_expression : public std::enable_shared_from_this<substitution_expression> {
+    public:
+        substitution_expression(path the_path, bool optional);
+
+        path get_path() const;
+        bool optional() const;
+
+        std::shared_ptr<substitution_expression> change_path(path new_path);
+
+        std::string to_string() const;
+
+        bool operator==(substitution_expression const& other) const;
+
+    private:
+        const path _path;
+        const bool _optional;
+    };
+
+}  // namespace hocon
+