Adding upstream version 0.19.2.upstream/0.19.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 443 insertions, 0 deletions

diff --git a/src/orcus_json_cli.cpp b/src/orcus_json_cli.cpp
new file mode 100644
index 0000000..98a4f39
--- /dev/null
+++ b/src/orcus_json_cli.cpp
@@ -0,0 +1,443 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include "orcus_json_cli.hpp"
+#include "orcus/json_document_tree.hpp"
+#include "orcus/json_parser_base.hpp"
+#include "orcus/json_structure_tree.hpp"
+#include "orcus/config.hpp"
+#include "orcus/stream.hpp"
+#include "orcus/xml_namespace.hpp"
+#include "orcus/dom_tree.hpp"
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <memory>
+#include <sstream>
+
+#include <mdds/sorted_string_map.hpp>
+#include <boost/program_options.hpp>
+
+#include "filesystem_env.hpp"
+
+using namespace std;
+using namespace orcus;
+namespace po = boost::program_options;
+
+namespace orcus { namespace detail {
+
+cmd_params::cmd_params() {}
+
+cmd_params::cmd_params(cmd_params&& other) :
+    config(std::move(other.config)),
+    os(std::move(other.os)),
+    mode(other.mode),
+    map_file(std::move(other.map_file))
+{
+}
+
+cmd_params::~cmd_params() {}
+
+}}
+
+namespace {
+
+namespace mode {
+
+using map_type = mdds::sorted_string_map<detail::mode_t, mdds::string_view_map_entry>;
+
+// Keys must be sorted.
+constexpr map_type::entry entries[] =
+{
+    { "convert",   detail::mode_t::convert   },
+    { "map",       detail::mode_t::map       },
+    { "map-gen",   detail::mode_t::map_gen   },
+    { "structure", detail::mode_t::structure },
+};
+
+const map_type& get()
+{
+    static map_type mt(entries, std::size(entries), detail::mode_t::unknown);
+    return mt;
+}
+
+} // namespace mode
+
+const char* help_program =
+"The FILE must specify the path to an existing file.";
+
+const char* help_json_output =
+"Output file path.";
+
+const char* help_json_output_format =
+"Specify the format of output file.  Supported format types are:\n"
+"\n"
+"  * XML (xml)\n"
+"  * JSON (json)\n"
+"  * YAML (yaml)\n"
+"  * flat tree dump (check)\n"
+"  * no output (none)";
+
+const char* help_json_map =
+"Path to a map file.  This parameter is only used for map mode, and it is "
+"required for map mode."
+;
+
+const char* err_no_input_file = "No input file.";
+
+void print_json_usage(std::ostream& os, const po::options_description& desc)
+{
+    os << "Usage: orcus-json [options] FILE" << endl << endl;
+    os << help_program << endl << endl << desc;
+}
+
+std::string build_mode_help_text()
+{
+    std::ostringstream os;
+    os << "Mode of operation. Select one of the following options: ";
+    auto it = mode::entries, ite = mode::entries + std::size(mode::entries);
+    --ite;
+
+    for (; it != ite; ++it)
+        os << it->key << ", ";
+
+    os << "or " << it->key << ".";
+    return os.str();
+}
+
+/**
+ * Reset params.config in case of failure.
+ */
+void parse_args_for_convert(
+    detail::cmd_params& params, const po::options_description& desc, const po::variables_map& vm)
+{
+    if (vm.count("resolve-refs"))
+        params.config->resolve_references = true;
+
+    if (vm.count("output-format"))
+    {
+        std::string s = vm["output-format"].as<string>();
+        params.config->output_format = to_dump_format_enum(s);
+
+        if (params.config->output_format == dump_format_t::unknown)
+        {
+            cerr << "Unknown output format type '" << s << "'." << endl;
+            params.config.reset();
+            return;
+        }
+    }
+    else
+    {
+        cerr << "Output format is not specified." << endl;
+        print_json_usage(cerr, desc);
+        params.config.reset();
+        return;
+    }
+}
+
+/**
+ * Reset params.config in case of failure.
+ */
+void parse_args_for_map(
+    detail::cmd_params& params, const po::options_description& desc, const po::variables_map& vm)
+{
+    if (vm.count("map"))
+    {
+        fs::path map_path = vm["map"].as<std::string>();
+        if (!fs::is_regular_file(map_path))
+        {
+            cerr << map_path.string() << " is not a valid file." << endl;
+            params.config.reset();
+            return;
+        }
+
+        params.map_file.load(map_path.string().data());
+    }
+    else
+    {
+        // Auto-mapping mode
+    }
+
+    parse_args_for_convert(params, desc, vm);
+}
+
+/**
+ * Parse the command-line options, populate the json_config object, and
+ * return that to the caller.
+ */
+detail::cmd_params parse_json_args(int argc, char** argv)
+{
+    detail::cmd_params params;
+
+    po::options_description desc("Options");
+    desc.add_options()
+        ("help,h", "Print this help.")
+        ("mode", po::value<std::string>(), build_mode_help_text().data())
+        ("resolve-refs", "Resolve JSON references to external files.")
+        ("output,o", po::value<string>(), help_json_output)
+        ("output-format,f", po::value<string>(), help_json_output_format)
+        ("map,m", po::value<string>(), help_json_map)
+    ;
+
+    po::options_description hidden("Hidden options");
+    hidden.add_options()
+        ("input", po::value<string>(), "input file");
+
+    po::options_description cmd_opt;
+    cmd_opt.add(desc).add(hidden);
+
+    po::positional_options_description po_desc;
+    po_desc.add("input", -1);
+
+    po::variables_map vm;
+    try
+    {
+        po::store(
+            po::command_line_parser(argc, argv).options(cmd_opt).positional(po_desc).run(), vm);
+        po::notify(vm);
+    }
+    catch (const exception& e)
+    {
+        // Unknown options.
+        cerr << e.what() << endl;
+        print_json_usage(cerr, desc);
+        return params;
+    }
+
+    if (vm.count("help"))
+    {
+        print_json_usage(cout, desc);
+        return params;
+    }
+
+    if (vm.count("mode"))
+    {
+        std::string s = vm["mode"].as<std::string>();
+        params.mode = mode::get().find(s);
+        if (params.mode == detail::mode_t::unknown)
+        {
+            cerr << "Unknown mode string '" << s << "'." << endl;
+            return params;
+        }
+    }
+
+    params.config = std::make_unique<json_config>();
+
+    if (vm.count("input"))
+        params.config->input_path = vm["input"].as<string>();
+
+    if (params.config->input_path.empty())
+    {
+        // No input file is given.
+        cerr << err_no_input_file << endl;
+        print_json_usage(cerr, desc);
+        params.config.reset();
+        return params;
+    }
+
+    if (!fs::exists(params.config->input_path))
+    {
+        cerr << "Input file does not exist: " << params.config->input_path << endl;
+        params.config.reset();
+        return params;
+    }
+
+    if (vm.count("output"))
+        params.config->output_path = vm["output"].as<string>();
+
+    switch (params.mode)
+    {
+        case detail::mode_t::map_gen:
+        case detail::mode_t::structure:
+            // Structure and map-gen modes only need input and output parameters.
+            params.os = std::make_unique<output_stream>(vm);
+            break;
+        case detail::mode_t::convert:
+            params.os = std::make_unique<output_stream>(vm);
+            parse_args_for_convert(params, desc, vm);
+            break;
+        case detail::mode_t::map:
+            parse_args_for_map(params, desc, vm);
+            break;
+        default:
+            assert(!"This should not happen since the mode check is done way earlier.");
+    }
+
+    return params;
+}
+
+std::unique_ptr<json::document_tree> load_doc(const orcus::file_content& content, const json_config& config)
+{
+    std::unique_ptr<json::document_tree> doc(std::make_unique<json::document_tree>());
+    doc->load(content.str(), config);
+    return doc;
+}
+
+void build_doc_and_dump(const orcus::file_content& content, detail::cmd_params& params)
+{
+    std::unique_ptr<json::document_tree> doc = load_doc(content, *params.config);
+    std::ostream& os = params.os->get();
+
+    switch (params.config->output_format)
+    {
+        case dump_format_t::xml:
+        {
+            os << doc->dump_xml();
+            break;
+        }
+        case dump_format_t::json:
+        {
+            os << doc->dump();
+            break;
+        }
+        case dump_format_t::yaml:
+        {
+            os << doc->dump_yaml();
+            break;
+        }
+        case dump_format_t::check:
+        {
+            string xml_strm = doc->dump_xml();
+            xmlns_repository repo;
+            xmlns_context ns_cxt = repo.create_context();
+            dom::document_tree dom(ns_cxt);
+            dom.load(xml_strm);
+
+            dom.dump_compact(os);
+            break;
+        }
+        default:
+            ;
+    }
+}
+
+void parse_and_write_map_file(const orcus::file_content& content, detail::cmd_params& params)
+{
+    std::vector<json::table_range_t> ranges;
+
+    json::structure_tree::range_handler_type rh = [&ranges](json::table_range_t&& range)
+    {
+        ranges.push_back(std::move(range));
+    };
+
+    json::structure_tree tree;
+    tree.parse(content.str());
+
+    tree.process_ranges(rh);
+
+    json::document_tree map_doc = {
+        {"sheets", json::array()},
+        {"ranges", json::array()}
+    };
+
+    json::node root = map_doc.get_document_root();
+    json::node sheets_node = root["sheets"];
+    json::node ranges_node = root["ranges"];
+
+    size_t range_count = 0;
+    for (const json::table_range_t& range : ranges)
+    {
+        std::ostringstream os;
+        os << "range-" << range_count++;
+        std::string sheet = os.str();
+        sheets_node.push_back(sheet);
+
+        ranges_node.push_back({
+            {"sheet", sheet},
+            {"row", 0},
+            {"column", 0},
+            {"row-header", true},
+            {"fields", json::array()},
+            {"row-groups", json::array()},
+        });
+
+        json::node range_node = ranges_node.back();
+        json::node fields_node = range_node["fields"];
+        json::node row_groups_node = range_node["row-groups"];
+
+        for (const std::string& path : range.paths)
+        {
+            fields_node.push_back(json::object());
+            json::node path_node = fields_node.back();
+            path_node["path"] = path;
+        }
+
+        for (const std::string& row_group : range.row_groups)
+        {
+            row_groups_node.push_back(json::object());
+            json::node path_node = row_groups_node.back();
+            path_node["path"] = row_group;
+        }
+    }
+
+    std::ostream& os = params.os->get();
+    os << map_doc.dump();
+}
+
+} // anonymous namespace
+
+int main(int argc, char** argv)
+{
+    file_content content;
+
+    try
+    {
+        detail::cmd_params params = parse_json_args(argc, argv);
+
+        if (!params.config || params.mode == detail::mode_t::unknown)
+            return EXIT_FAILURE;
+
+        assert(!params.config->input_path.empty());
+        content.load(params.config->input_path.data());
+
+        switch (params.mode)
+        {
+            case detail::mode_t::structure:
+            {
+                json::structure_tree tree;
+                tree.parse(content.str());
+                tree.normalize_tree();
+                tree.dump_compact(params.os->get());
+                break;
+            }
+            case detail::mode_t::map:
+            {
+                map_to_sheets_and_dump(content, params);
+                break;
+            }
+            case detail::mode_t::map_gen:
+            {
+                parse_and_write_map_file(content, params);
+                break;
+            }
+            case detail::mode_t::convert:
+            {
+                build_doc_and_dump(content, params);
+                break;
+            }
+            default:
+                cerr << "Unkonwn mode has been given." << endl;
+                return EXIT_FAILURE;
+        }
+    }
+    catch (const parse_error& e)
+    {
+        cerr << create_parse_error_output(content.str(), e.offset()) << endl;
+        cerr << e.what() << endl;
+        return EXIT_FAILURE;
+    }
+    catch (const std::exception& e)
+    {
+        cerr << e.what() << endl;
+        return EXIT_FAILURE;
+    }
+
+    return EXIT_SUCCESS;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */