cfacter 3.11.0.rc.20180314

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

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+#include <hocon/config_syntax.hpp>
+#include <hocon/config_include_context.hpp>
+#include <hocon/config_parse_options.hpp>
+#include <hocon/path.hpp>
+#include <internal/nodes/config_node_concatenation.hpp>
+#include <internal/nodes/config_node_root.hpp>
+#include <internal/nodes/abstract_config_node_value.hpp>
+#include <internal/nodes/config_node_object.hpp>
+#include <internal/nodes/config_node_array.hpp>
+#include <internal/nodes/config_node_include.hpp>
+#include <internal/full_includer.hpp>
+#include <memory>
+#include <vector>
+#include <unordered_map>
+#include <string>
+
+namespace hocon { namespace config_parser {
+
+    shared_value parse(std::shared_ptr<const config_node_root> document,
+            shared_origin origin,
+            config_parse_options options,
+            shared_include_context include_context);
+
+    class parse_context {
+        int _line_number;
+        std::shared_ptr<const config_node_root> _document;
+        std::shared_ptr<const full_includer> _includer;
+        shared_include_context _include_context;
+        config_syntax _flavor;
+        shared_origin _base_origin, _line_origin;
+        std::vector<path> _path_stack;
+
+    public:
+        parse_context(config_syntax flavor, shared_origin origin, std::shared_ptr<const config_node_root> document,
+                std::shared_ptr<const full_includer> includer, shared_include_context include_context);
+
+        shared_value parse();
+
+        int array_count;
+
+    private:
+        static shared_object create_value_under_path(path p, shared_value value);
+        shared_origin line_origin() const;
+        path full_current_path() const;
+        shared_value parse_value(shared_node_value n, std::vector<std::string>& comments);
+        void parse_include(std::unordered_map<std::string, shared_value> &values, std::shared_ptr<const config_node_include> n);
+        shared_object parse_object(shared_node_object n);
+        shared_value parse_array(shared_node_array n);
+        shared_value parse_concatenation(shared_node_concatenation n);
+    };
+
+}}  // namespace hocon::config_parser

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <string>
+
+namespace hocon {
+
+    bool is_whitespace(char codepoint);
+
+    bool is_whitespace_not_newline(char codepoint);
+
+    bool is_C0_control(char c);
+
+    std::string render_json_string(std::string const& s);
+
+    std::string render_string_unquoted_if_possible(std::string const& s);
+
+}  // namespace hocon

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

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+namespace hocon {
+
+    /**
+     * An AbstractConfigValue which contains other values. Java has no way to
+     * express "this has to be an AbstractConfigValue also" other than making
+     * AbstractConfigValue an interface which would be aggravating. But we can say
+     * we are a ConfigValue.
+     */
+    class container {
+    public:
+        /**
+         * Replace a child of this value. CAUTION if replacement is null, delete the
+         * child, which may also delete the parent, or make the parent into a
+         * non-container.
+         */
+        virtual shared_value replace_child(shared_value const& child, shared_value replacement) const = 0;
+
+        /**
+         * Super-expensive full traversal to see if descendant is anywhere
+         * underneath this container.
+         */
+        virtual bool has_descendant(shared_value const& descendant) const = 0;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <hocon/config_value.hpp>
+
+namespace hocon {
+
+    class default_transformer {
+    public:
+        static shared_value transform(shared_value value, config_value::type requested);
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <hocon/config_includer.hpp>
+#include <hocon/config_includer_file.hpp>
+
+
+namespace hocon {
+
+    class full_includer : public config_includer, public config_includer_file {
+        // This is a faithful port of the Java fullIncluder interface
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <hocon/parser/config_node.hpp>
+#include <internal/token.hpp>
+#include <vector>
+
+namespace hocon {
+
+    class abstract_config_node : public config_node {
+    public:
+        std::string render() const;
+        bool operator==(const abstract_config_node &other) const;
+        virtual token_list get_tokens() const = 0;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,12 @@
+#pragma once
+
+#include "abstract_config_node.hpp"
+
+namespace hocon {
+
+    /** This is used to classify certain abstract_config_node subclasses. */
+    class abstract_config_node_value : public abstract_config_node { };
+
+    using shared_node_value = std::shared_ptr<const abstract_config_node_value>;
+
+}  // namespace hocon

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

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "config_node_complex_value.hpp"
+
+namespace hocon {
+
+    class config_node_array;
+    using shared_node_array = std::shared_ptr<const config_node_array>;
+
+    class config_node_array : public config_node_complex_value {
+    public:
+        config_node_array(shared_node_list children);
+
+        std::shared_ptr<const config_node_complex_value> new_node(shared_node_list nodes) const override;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "config_node_single_token.hpp"
+
+namespace hocon {
+
+    class config_node_comment : public config_node_single_token {
+    public:
+        config_node_comment(shared_token comment);
+
+        std::string comment_text() const;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "abstract_config_node_value.hpp"
+
+namespace hocon {
+
+    class config_node_complex_value : public abstract_config_node_value {
+    public:
+        config_node_complex_value(shared_node_list children);
+
+        token_list get_tokens() const override;
+
+        shared_node_list const& children() const;
+
+        std::shared_ptr<const config_node_complex_value> indent_text(
+                shared_node indentation) const;
+
+        virtual std::shared_ptr<const config_node_complex_value> new_node(
+                shared_node_list nodes) const = 0;
+
+    private:
+        shared_node_list _children;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "config_node_complex_value.hpp"
+
+namespace hocon {
+
+    class config_node_concatenation : public config_node_complex_value {
+    public:
+        config_node_concatenation(shared_node_list children);
+
+        std::shared_ptr<const config_node_complex_value> new_node(shared_node_list nodes) const override;
+    };
+
+    using shared_node_concatenation = std::shared_ptr<const config_node_concatenation>;
+
+}  // namespace hocon

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

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "abstract_config_node_value.hpp"
+#include "config_node_path.hpp"
+
+
+namespace hocon {
+
+    /**
+     * A field represents a key-value pair of the format "key : value",
+     * where key is a quoted or unquoted string, and value can be any node type.
+     */
+    class config_node_field : public abstract_config_node_value {
+    public:
+        config_node_field(shared_node_list children);
+
+        token_list get_tokens() const override;
+
+        std::shared_ptr<const config_node_field> replace_value(shared_node_value new_value) const;
+        shared_node_value get_value() const;
+        shared_token separator() const;
+        std::vector<std::string> comments() const;
+        std::shared_ptr<const config_node_path> path() const;
+
+    private:
+        shared_node_list _children;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "abstract_config_node.hpp"
+
+namespace hocon {
+
+    enum class config_include_kind { URL, FILE, CLASSPATH, HEURISTIC };
+
+    /** Represents an include statement of the form "include include_kind(include_path)". */
+    class config_node_include : public abstract_config_node {
+    public:
+        config_node_include(shared_node_list children,
+                            config_include_kind kind);
+
+        token_list get_tokens() const override;
+
+        shared_node_list const& children() const;
+        config_include_kind kind() const;
+        std::string name() const;
+
+    private:
+        shared_node_list _children;
+        config_include_kind _kind;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "config_node_complex_value.hpp"
+#include "config_node_path.hpp"
+#include <hocon/path.hpp>
+#include <hocon/config_syntax.hpp>
+
+namespace hocon {
+
+    class config_node_object;
+    using shared_node_object = std::shared_ptr<const config_node_object>;
+
+    class config_node_object : public config_node_complex_value {
+    public:
+        config_node_object(shared_node_list children);
+
+        std::shared_ptr<const config_node_complex_value> new_node(
+                shared_node_list nodes) const override;
+
+        bool has_value(path desired_path) const;
+
+        shared_node_object change_value_on_path(path desired_path,
+                                                shared_node_value value,
+                                                config_syntax flavor) const;
+
+        shared_node_object set_value_on_path(std::string desired_path,
+                                             shared_node_value value,
+                                             config_syntax flavor = config_syntax::CONF) const;
+
+        shared_node_object set_value_on_path(config_node_path desired_path,
+                                             shared_node_value value,
+                                             config_syntax flavor = config_syntax::CONF) const;
+
+        shared_node_list indentation() const;
+
+        shared_node_object add_value_on_path(config_node_path desired_path,
+                                             shared_node_value value,
+                                             config_syntax flavor) const;
+
+        shared_node_object remove_value_on_path(std::string desired_path, config_syntax flavor) const;
+
+        static bool contains_token(shared_node node, token_type token);
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <internal/nodes/abstract_config_node.hpp>
+#include <hocon/path.hpp>
+#include <internal/token.hpp>
+
+namespace hocon {
+
+    class config_node_path : public abstract_config_node {
+    public:
+        config_node_path(path node_path, token_list tokens);
+
+        token_list get_tokens() const override;
+        path get_path() const;
+
+        config_node_path sub_path(int to_remove);
+        config_node_path first();
+
+
+    private:
+        path _path;
+        token_list _tokens;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "config_node_complex_value.hpp"
+#include <hocon/config_syntax.hpp>
+
+namespace hocon {
+
+    class config_node_root : public config_node_complex_value {
+    public:
+        config_node_root(shared_node_list children, shared_origin origin);
+
+        std::shared_ptr<const config_node_complex_value> new_node(shared_node_list nodes) const override;
+
+        std::shared_ptr<const config_node_complex_value> value() const;
+        std::shared_ptr<const config_node_root> set_value(std::string desired_path,
+                                                          shared_node_value,
+                                                          config_syntax flavor) const;
+        bool has_value(std::string desired_path) const;
+
+    private:
+        shared_origin _origin;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "abstract_config_node_value.hpp"
+#include <hocon/config_value.hpp>
+
+namespace hocon {
+
+    class config_node_simple_value : public abstract_config_node_value {
+    public:
+        config_node_simple_value(shared_token value);
+
+        shared_token get_token() const;
+        shared_value get_value() const;
+
+        token_list get_tokens() const override;
+
+    private:
+        shared_token _token;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <internal/token.hpp>
+#include "abstract_config_node.hpp"
+
+namespace hocon {
+
+    class config_node_single_token : public abstract_config_node {
+    public:
+        config_node_single_token(shared_token t);
+
+        token_list get_tokens() const override;
+
+        shared_token get_token() const;
+
+    private:
+        shared_token _token;
+    };
+
+}  // namespace hocon

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

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <hocon/config_parseable.hpp>
+#include <boost/nowide/fstream.hpp>
+#include <internal/simple_config_origin.hpp>
+#include <hocon/config_object.hpp>
+#include <hocon/config_include_context.hpp>
+
+namespace hocon {
+
+    class config_document;
+
+    class parseable : public config_parseable, public std::enable_shared_from_this<parseable> {
+    public:
+        static std::shared_ptr<parseable> new_file(std::string input_file_path, config_parse_options options);
+        static std::shared_ptr<parseable> new_string(std::string s, config_parse_options options);
+        static std::shared_ptr<parseable> new_not_found(std::string what_not_found, std::string message,
+                                                        config_parse_options options);
+
+        static config_syntax syntax_from_extension(std::string name);
+
+        void post_construct(config_parse_options const& base_options);
+
+        std::shared_ptr<config_document> parse_config_document();
+        shared_object parse(config_parse_options const& options) const override;
+        shared_object parse() const;
+
+        shared_value parse_value() const;
+
+        config_parse_options const& options() const override;
+        std::shared_ptr<const config_origin> origin() const override;
+
+        virtual std::unique_ptr<std::istream> reader(config_parse_options const& options) const;
+        virtual std::unique_ptr<std::istream> reader() const = 0;
+        virtual shared_origin create_origin() const = 0;
+
+        virtual config_syntax guess_syntax() const;
+        virtual config_syntax content_type() const;
+        virtual std::shared_ptr<config_parseable> relative_to(std::string file_name) const;
+
+        std::string to_string() const;
+
+        // Disable copy constructors, as include_context assumes it can hold a reference to parseable.
+        parseable() = default;
+        parseable(parseable const&) = delete;
+        parseable& operator=(parseable const&) = delete;
+
+    private:
+        std::shared_ptr<config_document> parse_document(config_parse_options const& base_options) const;
+        std::shared_ptr<config_document> parse_document(shared_origin origin,
+                                                        config_parse_options const& final_options) const;
+        std::shared_ptr<config_document> raw_parse_document(std::unique_ptr<std::istream> stream, shared_origin origin,
+                                                            config_parse_options const& options) const;
+        std::shared_ptr<config_document> raw_parse_document(shared_origin origin,
+                                                            config_parse_options const& options) const;
+
+        shared_value parse_value(config_parse_options const& base_options) const;
+        shared_value parse_value(shared_origin origin, config_parse_options const& options) const;
+        shared_value raw_parse_value(std::unique_ptr<std::istream> stream,
+                                     shared_origin origin,
+                                     config_parse_options const& options) const;
+        shared_value raw_parse_value(shared_origin origin, config_parse_options const& options) const;
+
+        config_parse_options fixup_options(config_parse_options const& base_options) const;
+
+        std::vector<parseable> _parse_stack;
+
+        shared_origin _initial_origin;
+        config_parse_options _initial_options;
+        shared_include_context _include_context;
+
+        static const int MAX_INCLUDE_DEPTH;
+    };
+
+    class parseable_file : public parseable {
+    public:
+        parseable_file(std::string input_file_path, config_parse_options options);
+        std::unique_ptr<std::istream> reader() const override;
+        shared_origin create_origin() const override;
+        config_syntax guess_syntax() const override;
+
+    private:
+        std::string _input;
+    };
+
+    class parseable_string : public parseable {
+    public:
+        parseable_string(std::string s, config_parse_options options);
+        std::unique_ptr<std::istream> reader() const override;
+        shared_origin create_origin() const override;
+
+    private:
+        std::string _input;
+    };
+
+    // NOTE: this is not a faithful port of the `ParseableResources` class from the
+    // upstream, because at least for now we're not going to try to do anything
+    // crazy like look for files on the ruby load path.  However, there is a decent
+    // chunk of logic elsewhere in the codebase that is written with the assumption
+    // that this class will provide the 'last resort' attempt to find a config file
+    // before giving up, so we're basically port just enough to have it provide
+    // that last resort behavior
+    class parseable_resources : public parseable {
+    public:
+        parseable_resources(std::string resource, config_parse_options options);
+
+        std::unique_ptr<std::istream> reader() const override;
+        shared_origin create_origin() const override;
+
+    private:
+        std::string _resource;
+    };
+
+    // this is a parseable that doesn't exist and just throws when you try to
+    // parse it
+    class parseable_not_found : public parseable {
+    public:
+        parseable_not_found(std::string what, std::string message, config_parse_options options);
+
+        std::unique_ptr<std::istream> reader() const override;
+        shared_origin create_origin() const override;
+
+    private:
+        std::string _what;
+        std::string _message;
+    };
+
+}  // namespace hocon