option_parser.hpp

// The MIT License (MIT)

// Copyright (c) 2012-2014 Danny Y., Rapptz

// Permission is hereby granted, free of charge, to any person obtaining a copy of
// this software and associated documentation files (the "Software"), to deal in
// the Software without restriction, including without limitation the rights to
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do so,
// subject to the following conditions:

// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
// FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
// COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

#ifndef GEARS_OPTPARSE_OPTION_PARSER_HPP
#define GEARS_OPTPARSE_OPTION_PARSER_HPP

#include "error.hpp"
#include "formatter.hpp"
#include <iostream>
#include <cstdlib>

namespace gears {
namespace optparse {
struct option_parser {
private:
    std::vector<subcommand> subcommands;
    option_set options;
    std::unique_ptr<formatter> format = utility::make_unique<formatter>();
    option_set* active_options = &options;
    std::ptrdiff_t index = -1;

    bool is_option(const std::string& arg) const noexcept {
        return arg.size() >= 2 && arg.front() == '-';
    }

    template<typename ForwardIt>
    ForwardIt process_subcommand(ForwardIt begin, ForwardIt end) {
        if(begin == end) {
            return begin;
        }

        std::string arg = *begin;
        if(arg.empty()) {
            return begin;
        }

        auto&& it = std::find_if(subcommands.begin(), subcommands.end(), [&arg](const subcommand& sub) {
            return sub.name == arg;
        });

        if(it != subcommands.end()) {
            index = std::distance(subcommands.begin(), it);
            active_options = &(it->options);
            ++begin;
            return begin;
        }

        return begin;
    }

    template<typename ForwardIt>
    ForwardIt parse_long_option(std::string key, ForwardIt begin, ForwardIt end) {
        std::string value;
        auto&& pos = key.find('=');
        bool has_explicit_value = false;

        // check if it's --long=arg
        if(pos != std::string::npos) {
            value = key.substr(pos + 1);
            key = key.substr(0, pos);
            has_explicit_value = true;
        }

        // check if the argument exists
        auto&& it = std::find_if(active_options->begin(), active_options->end(), [&key](const option& opt) {
            return opt.is(key.substr(2));
        });

        if(it == active_options->end()) {
            throw unrecognised_option(program_name, key);
        }

        auto&& opt = *it;
        size_t argc = std::distance(begin, end);

        // option doesn't take a value but it was explicitly provided
        // so throw an error
        if(!opt.takes_value() && has_explicit_value) {
            throw option_takes_no_value(program_name, key);
        }

        if(opt.takes_value() && !has_explicit_value) {
            // check number of arguments left
            if(argc - 1 < opt.nargs()) {
                throw missing_required_value(program_name, key, opt.nargs());
            }

            // get the arguments needed
            for(size_t i = 0; i < opt.nargs(); ++i) {
                value += *(++begin);
                value.push_back('\n');
            }

            // remove extraneous newline
            if(!value.empty() && value.back() == '\n') {
                value.pop_back();
            }
        }

        // parse it
        if(opt.ptr != nullptr) {
            opt.ptr->parse(key, value);
        }

        return begin;
    }

    template<typename ForwardIt>
    ForwardIt parse_short_option(const std::string& arg, ForwardIt begin, ForwardIt end) {
        std::string value;
        // loop due to concatenation of short options
        for(size_t j = 1 ; j < arg.size(); ++j) {
            auto&& ch = arg[j];
            bool has_explicit_value = false;
            std::string key = "-";
            key.push_back(ch);

            // check for -o=stuff
            if(j + 2 < arg.size() && arg[j + 1] == '=') {
                value = arg.substr(j + 2);
                // set loop counter to end explicitly after
                // this loop
                j = arg.size();
                has_explicit_value = true;
            }

            auto&& it = std::find_if(active_options->begin(), active_options->end(), [&ch](const option& opt) {
                return opt.is(ch);
            });

            if(it == active_options->end()) {
                throw unrecognised_option(program_name, key);
            }

            auto&& opt = *it;
            size_t argc = std::distance(begin, end);

            if(has_explicit_value && !opt.takes_value()) {
                throw option_takes_no_value(program_name, key);
            }

            // check for -o stuff
            if(opt.takes_value() && !has_explicit_value) {
                // note that -ostuff doesn't work due to ambiguity.
                if(j + 1 != arg.size()) {
                    throw optparse::error(program_name, "short option \'" + key + "\' and value must not be combined", arg);
                }

                if(argc - 1 < opt.nargs()) {
                    throw missing_required_value(program_name, key, opt.nargs());
                }

                for(size_t i = 0; i < opt.nargs(); ++i) {
                    value += *(++begin);
                    value.push_back('\n');
                }

                // remove extraneous newline
                if(!value.empty() && value.back() == '\n') {
                    value.pop_back();
                }
            }

            if(opt.ptr != nullptr) {
                opt.ptr->parse(key, value);
            }
        }

        return begin;
    }

    template<typename It>
    arguments make_args(It begin, It end) const {
        if(index == -1) {
            return { *active_options, std::vector<std::string>(begin, end), "" };
        }
        auto&& sub = subcommands[index];
        return { *active_options, std::vector<std::string>(begin, end), sub.name };
    }
public:
    std::string description;              
    std::string epilogue;                 
    std::string program_name;             
    std::string usage = "[options...]";   

    option_parser() = default;

    option_parser(option_set options): options(std::move(options)) {}

    option_parser(std::initializer_list<option> options): options(std::move(options)) {}

    template<typename... Args>
    void add(Args&&... args) {
        options.add(std::forward<Args>(args)...);
    }

    option_parser& add_subcommand(subcommand sub) {
        subcommands.push_back(std::move(sub));
        return *this;
    }

    template<typename Formatter>
    void help_formatter(const Formatter& form) {
        static_assert(std::is_base_of<formatter, Formatter>::value, "Must derive from formatter");
        format = utility::make_unique<Formatter>(form);
    }

    template<typename ForwardIt>
    arguments raw_parse(ForwardIt begin, ForwardIt end) {
        static_assert(std::is_constructible<std::string, decltype(*begin)>{},
                      "Iterator must return type convertible to std::string");

        if(begin == end) {
            return {*active_options, {}, ""};
        }

        // assign program name to argv[0] if it isn't provided
        if(program_name.empty()) {
            program_name = *begin++;
        }
        else {
            ++begin;
        }

        // check if argv[1] is a subcommand
        begin = process_subcommand(begin, end);

        // begin parsing command line arguments
        for(; begin != end; ++begin) {
            std::string arg = *begin;

            // -- is used to delimit options vs positional arguments
            if(arg == "--") {
                return make_args(++begin, end);
            }

            // check if it's an option
            if(is_option(arg)) {
                // check for long, i.e. --long
                if(arg[1] == '-') {
                    begin = parse_long_option(arg, begin, end);
                }
                else {
                    // short option, i.e. -s
                    begin = parse_short_option(arg, begin, end);
                }
            }
            else {
                // since it isn't an option, then the positional
                // arguments have begun so just stop parsing.
                break;
            }
        }

        return make_args(begin, end);
    }

    void notify() {
        for(auto&& opt : *active_options) {
            if((opt.flags & trait::required) == trait::required && !opt.is_active()) {
                throw missing_required_option(program_name, opt.name.empty() ? std::string("-").append(1, opt.alias)
                                                                             : "--" + opt.name);
            }
        }
    }

    template<typename ForwardIt>
    arguments parse(ForwardIt begin, ForwardIt end, std::ostream& out = std::cout, std::ostream& err = std::cerr) {
        try {
            auto&& args = raw_parse(begin, end);

            if(args.options.is_active("help")) {
                out << format_help();
                std::exit(EXIT_SUCCESS);
            }

            notify();

            return args;
        }
        catch(const optparse::error& e) {
            err << format_usage() << e.what() << '\n';
        }
        catch(const std::exception& e) {
            err << format_usage() << program_name << ": error: " << e.what() << '\n';
        }

        if(active_options->is_active("help")) {
            out << format_description()
                << format_subcommands()
                << format_options()
                << format_epilogue();
        }

        std::exit(EXIT_FAILURE);
    }

    std::string format_description() const noexcept {
        return format->description(index == -1 ? epilogue : subcommands[index].epilogue);
    }

    std::string format_epilogue() const noexcept {
        return format->epilogue(index == -1 ? epilogue : subcommands[index].epilogue);
    }

    std::string format_usage() const noexcept {
        return format->usage(program_name,
                             index == -1 ? "" : subcommands[index].name,
                             index == -1 ? usage : subcommands[index].usage);
    }

    std::string format_subcommands() const noexcept {
        return format->subcommands(subcommands);
    }

    std::string format_options() const noexcept {
        return format->options(*active_options);
    }

    std::string format_help() const noexcept {
        std::string result = format_usage();
        result.append(1, '\n').append(format_description());

        if(active_options == &options) {
            result.append(format_subcommands());

            if(!subcommands.empty()) {
                result.push_back('\n');
            }
        }


        result.append(format_options()).append(format_epilogue());
        return result;
    }

    void error(const std::string& message, std::ostream& err = std::cerr) {
        err << format_usage();
        err << format->wrap(program_name + ": error: " + message);
        std::exit(EXIT_FAILURE);
    }
};
} // optparse
} // gears

#endif // GEARS_OPTPARSE_OPTION_PARSER_HPP