validators.hpp

Go to the documentation of this file.

// -----------------------------------------------------------------------------------------------------
// Copyright (c) 2006-2019, Knut Reinert & Freie Universität Berlin
// Copyright (c) 2016-2019, Knut Reinert & MPI für molekulare Genetik
// This file may be used, modified and/or redistributed under the terms of the 3-clause BSD-License
// shipped with this file and also available at: https://github.com/seqan/seqan3/blob/master/LICENSE.md
// -----------------------------------------------------------------------------------------------------

#pragma once

#include <regex>
#include <fstream>
#include <sstream>

#include <seqan3/argument_parser/exceptions.hpp>
#include <seqan3/core/concept/core_language.hpp>
#include <seqan3/core/detail/to_string.hpp>
#include <seqan3/core/type_traits/basic.hpp>
#include <seqan3/core/type_traits/pre.hpp>
#include <seqan3/io/detail/safe_filesystem_entry.hpp>
#include <seqan3/range/container/concept.hpp>
#include <seqan3/range/view/drop.hpp>
#include <seqan3/range/view/to_lower.hpp>
#include <seqan3/std/algorithm>
#include <seqan3/std/concepts>
#include <seqan3/std/filesystem>
#include <seqan3/std/ranges>

namespace seqan3
{

template <typename validator_type>
SEQAN3_CONCEPT Validator = std::Copyable<remove_cvref_t<validator_type>> &&
                           requires(validator_type validator,
                                    typename std::remove_reference_t<validator_type>::value_type value)
{
    typename std::remove_reference_t<validator_type>::value_type;

    { validator(value) } -> void;
    { validator.get_help_page_message() } -> std::string;
};

class arithmetic_range_validator
{
public:
    using value_type = double;

    arithmetic_range_validator(value_type const min_, value_type const max_) :
        min{min_}, max{max_}
    {}

    void operator()(value_type const & cmp) const
    {
        if (!((cmp <= max) && (cmp >= min)))
            throw parser_invalid_argument(detail::to_string("Value ", cmp, " is not in range [", min, ",", max, "]."));
    }

    template <std::ranges::ForwardRange range_type>
        requires Arithmetic<value_type_t<range_type>>
    void operator()(range_type const & range) const
    {
        std::for_each(range.begin(), range.end(), [&] (auto cmp) { (*this)(cmp); });
    }

    std::string get_help_page_message() const
    {
        return detail::to_string("Value must be in range [", min, ",", max, "].");
    }

private:
    value_type min{};

    value_type max{};
};

template <typename option_value_type>
class value_list_validator
{
public:
    using value_type = option_value_type;

    value_list_validator(std::vector<value_type> v) : values{std::move(v)}
    {}

    void operator()(value_type const & cmp) const
    {
        if (!(std::find(values.begin(), values.end(), cmp) != values.end()))
            throw parser_invalid_argument(detail::to_string("Value ", cmp, " is not one of ", std::view::all(values), "."));
    }

    template <std::ranges::ForwardRange range_type>
        requires std::ConvertibleTo<value_type_t<range_type>, value_type const &>
    void operator()(range_type const & range) const
    {
        std::for_each(range.begin(), range.end(), [&] (auto cmp) { (*this)(cmp); });
    }

    std::string get_help_page_message() const
    {
        return detail::to_string("Value must be one of ", std::view::all(values), ".");
    }

private:

    std::vector<value_type> values;
};

template <Arithmetic option_value_type>
value_list_validator(std::vector<option_value_type>) -> value_list_validator<double>;

template <Arithmetic option_value_type>
value_list_validator(std::initializer_list<option_value_type>) -> value_list_validator<double>;

value_list_validator(std::vector<const char *>) -> value_list_validator<std::string>;

value_list_validator(std::initializer_list<const char *>) -> value_list_validator<std::string>;

class file_validator_base
{
public:

    using value_type = std::string;

    file_validator_base() = default;                                        
    file_validator_base(file_validator_base const &) = default;             
    file_validator_base(file_validator_base &&) = default;                  
    file_validator_base & operator=(file_validator_base const &) = default; 
    file_validator_base & operator=(file_validator_base &&) = default;      
    virtual ~file_validator_base() = default;                               

    explicit file_validator_base(std::vector<std::string> extensions) : extensions{std::move(extensions)}
    {}

    virtual void operator()(std::filesystem::path const & path) const = 0;

    template <std::ranges::ForwardRange range_type>
        requires std::ConvertibleTo<value_type_t<range_type>, std::filesystem::path const &>
    void operator()(range_type const & v) const
    {
         std::for_each(v.begin(), v.end(), [&] (auto cmp) { this->operator()(cmp); });
    }

protected:

    void validate_filename(std::filesystem::path const & path) const
    {
        // If no valid extensions are given we can safely return here.
        if (extensions.empty())
            return;

        // Check if extension is available.
        if (!path.has_extension())
            throw parser_invalid_argument{detail::to_string("The given filename ", path.string(),
                                                            " has no extension. Expected one of the following valid"
                                                            " extensions:", extensions, "!")};

        // Drop the dot.
        std::string tmp_str = path.extension().string();
        auto drop_less_ext = tmp_str | view::drop(1);

        // Compares the extensions in lower case.
        auto cmp_lambda = [&] (std::string const & cmp)
        {
            return std::ranges::equal(cmp | view::to_lower, drop_less_ext | view::to_lower);
        };

        // Check if requested extension is present.
        if (std::ranges::find_if(extensions, cmp_lambda) == extensions.end())
        {
            throw parser_invalid_argument{detail::to_string("Expected one of the following valid extensions: ",
                                                             extensions, "! Got ", drop_less_ext, " instead!")};
        }
    }

    void validate_readability(std::filesystem::path const & path) const
    {
        // Check if input directory is readable.
        if (std::filesystem::is_directory(path))
        {
            std::error_code ec{};
            std::filesystem::directory_iterator{path, ec};  // if directory iterator cannot be created, ec will be set.
            if (static_cast<bool>(ec))
                throw parser_invalid_argument{detail::to_string("Cannot read the directory ", path ,"!")};
        }
        else
        {
            // Must be a regular file.
            if (!std::filesystem::is_regular_file(path))
                throw parser_invalid_argument{detail::to_string("Expected a regular file ", path, "!")};

            std::ifstream file{path};
            if (!file.is_open() || !file.good())
                throw parser_invalid_argument{detail::to_string("Cannot read the file ", path, "!")};
        }
    }

    void validate_writeability(std::filesystem::path const & path) const
    {
        std::ofstream file{path};
        detail::safe_filesystem_entry file_guard{path};

        bool is_open = file.is_open();
        bool is_good = file.good();
        file.close();

        if (!is_good || !is_open)
            throw parser_invalid_argument(detail::to_string("Cannot write ", path, "!"));

        file_guard.remove();
    }

    std::vector<std::string> extensions{};
};

class input_file_validator : public file_validator_base
{
public:
    // Import from base class.
    using file_validator_base::value_type;

    input_file_validator() = default;                                         
    input_file_validator(input_file_validator const &) = default;             
    input_file_validator(input_file_validator &&) = default;                  
    input_file_validator & operator=(input_file_validator const &) = default; 
    input_file_validator & operator=(input_file_validator &&) = default;      
    virtual ~input_file_validator() = default;                                

    // Import base class constructor.
    using file_validator_base::file_validator_base;

    // Import the base::operator()
    using file_validator_base::operator();

    virtual void operator()(std::filesystem::path const & file) const override
    {
        try
        {
            if (!std::filesystem::exists(file))
                throw parser_invalid_argument(detail::to_string("The file ", file, " does not exist!"));

            // Check if file is regular and can be opened for reading.
            validate_readability(file);

            // Check extension.
            validate_filename(file);
        }
        catch (std::filesystem::filesystem_error & ex)
        {
            std::throw_with_nested(parser_invalid_argument("Unhandled filesystem error!"));
        }
        catch (...)
        {
            std::rethrow_exception(std::current_exception());
        }
    }

    std::string get_help_page_message() const
    {
        return detail::to_string("Valid input file formats: ",
                                 file_validator_base::extensions | std::view::join(std::string{", "}),
                                 ".");
    }
};

class output_file_validator : public file_validator_base
{
public:
    // Import from base class.
    using file_validator_base::value_type;

    output_file_validator() = default;                                            
    output_file_validator(output_file_validator const &) = default;               
    output_file_validator(output_file_validator &&) = default;                    
    output_file_validator & operator=(output_file_validator const &) = default;   
    output_file_validator & operator=(output_file_validator &&) = default;        
    virtual ~output_file_validator() = default;                                   

    // Import base constructor.
    using file_validator_base::file_validator_base;

    // Import the base::operator()
    using file_validator_base::operator();

    virtual void operator()(std::filesystem::path const & file) const override
    {
        try
        {
            if (std::filesystem::exists(file))
                throw parser_invalid_argument(detail::to_string("The file ", file, " already exists!"));

            // Check if file has any write permissions.
            validate_writeability(file);

            validate_filename(file);
        }
        catch (std::filesystem::filesystem_error & ex)
        {
            std::throw_with_nested(parser_invalid_argument("Unhandled filesystem error!"));
        }
        catch (...)
        {
            std::rethrow_exception(std::current_exception());
        }
    }

    std::string get_help_page_message() const
    {
        return detail::to_string("Valid output file formats: ",
                                 file_validator_base::extensions | std::view::join(std::string{", "}), ".");
    }
};

class input_directory_validator : public file_validator_base
{
public:
    // Import from base class.
    using file_validator_base::value_type;

    input_directory_validator() = default;                                              
    input_directory_validator(input_directory_validator const &) = default;             
    input_directory_validator(input_directory_validator &&) = default;                  
    input_directory_validator & operator=(input_directory_validator const &) = default; 
    input_directory_validator & operator=(input_directory_validator &&) = default;      
    virtual ~input_directory_validator() = default;                                     

    // Import base constructor.
    using file_validator_base::file_validator_base;

    // Import the base::operator()
    using file_validator_base::operator();

    virtual void operator()(std::filesystem::path const & dir) const override
    {
        try
        {
            if (!std::filesystem::exists(dir))
                throw parser_invalid_argument(detail::to_string("The directory ", dir, " does not exists!"));

            if (!std::filesystem::is_directory(dir))
                throw parser_invalid_argument(detail::to_string("The path ", dir, " is not a directory!"));

            // Check if directory has any read permissions.
            validate_readability(dir);
        }
        catch (std::filesystem::filesystem_error & ex)
        {
            std::throw_with_nested(parser_invalid_argument("Unhandled filesystem error!"));
        }
        catch (...)
        {
            std::rethrow_exception(std::current_exception());
        }
    }

    std::string get_help_page_message() const
    {
        return detail::to_string("An existing, readable path for the input directory.");
    }
};

class output_directory_validator : public file_validator_base
{
public:
    // Imported from base class.
    using file_validator_base::value_type;

    output_directory_validator() = default;                                               
    output_directory_validator(output_directory_validator const &) = default;             
    output_directory_validator(output_directory_validator &&) = default;                  
    output_directory_validator & operator=(output_directory_validator const &) = default; 
    output_directory_validator & operator=(output_directory_validator &&) = default;      
    virtual ~output_directory_validator() = default;                                      

    // Import base constructor.
    using file_validator_base::file_validator_base;

    // Import the base::operator().
    using file_validator_base::operator();

    virtual void operator()(std::filesystem::path const & dir) const override
    {
        bool dir_exists = std::filesystem::exists(dir);
        // Make sure the created dir is deleted after we are done.
        std::error_code ec;
        std::filesystem::create_directory(dir, ec); // does nothing and is not treated as error if path already exists.
        // if error code was set or if dummy.txt could not be created within the output dir, throw an error.
        if (static_cast<bool>(ec))
            throw parser_invalid_argument(detail::to_string("Cannot create directory: ", dir, "!"));

        try
        {
            if (!dir_exists)
            {
                detail::safe_filesystem_entry dir_guard{dir};
                validate_writeability(dir / "dummy.txt");
                dir_guard.remove_all();
            }
            else
            {
                validate_writeability(dir / "dummy.txt");
            }
        }
        catch (std::filesystem::filesystem_error & ex)
        {
            std::throw_with_nested(parser_invalid_argument("Unhandled filesystem error!"));
        }
        catch (...)
        {
            std::rethrow_exception(std::current_exception());
        }
    }

    std::string get_help_page_message() const
    {
        return detail::to_string("A valid path for the output directory.");
    }
};

class regex_validator
{
public:
    using value_type = std::string;

    regex_validator(std::string const & pattern_) :
        pattern{pattern_}
    {}

    void operator()(value_type const & cmp) const
    {
        std::regex rgx(pattern);
        if (!std::regex_match(cmp, rgx))
            throw parser_invalid_argument(detail::to_string("Value ", cmp, " did not match the pattern ", pattern, "."));
    }

    template <std::ranges::ForwardRange range_type>
        requires std::ConvertibleTo<value_type_t<range_type>, value_type const &>
    void operator()(range_type const & v) const
    {
         std::for_each(v.begin(), v.end(), [&] (auto cmp) { (*this)(cmp); });
    }

    std::string get_help_page_message() const
    {
        return detail::to_string("Value must match the pattern '", pattern, "'.");
    }

private:
    std::string pattern;
};

namespace detail
{

template <typename option_value_type>
struct default_validator
{
    using value_type = option_value_type;

    void operator()(option_value_type const & /*cmp*/) const noexcept
    {}

    std::string get_help_page_message() const
    {
        return "";
    }
};

template <Validator validator1_type, Validator validator2_type>
    requires std::Same<typename validator1_type::value_type, typename validator2_type::value_type>
class validator_chain_adaptor
{
public:
    using value_type = typename validator1_type::value_type;

    validator_chain_adaptor() = delete;                                                
    validator_chain_adaptor(validator_chain_adaptor const & pf) = default;             
    validator_chain_adaptor & operator=(validator_chain_adaptor const & pf) = default; 
    validator_chain_adaptor(validator_chain_adaptor &&) = default;                     
    validator_chain_adaptor & operator=(validator_chain_adaptor &&) = default;         

    validator_chain_adaptor(validator1_type vali1_, validator2_type vali2_) :
        vali1{std::move(vali1_)}, vali2{std::move(vali2_)}
    {}

    ~validator_chain_adaptor() = default;

    template <typename cmp_type>
        requires std::Invocable<validator1_type, cmp_type const> && std::Invocable<validator2_type, cmp_type const>
    void operator()(cmp_type const & cmp) const
    {
        vali1(cmp);
        vali2(cmp);
    }

    std::string get_help_page_message() const
    {
        return detail::to_string(vali1.get_help_page_message(), " ", vali2.get_help_page_message());
    }

private:
    validator1_type vali1;
    validator2_type vali2;
};

} // namespace detail

template <Validator validator1_type, Validator validator2_type>
    requires std::Same<typename std::remove_reference_t<validator1_type>::value_type,
                       typename std::remove_reference_t<validator2_type>::value_type>
auto operator|(validator1_type && vali1, validator2_type && vali2)
{
    return detail::validator_chain_adaptor{std::forward<validator1_type>(vali1),
                                           std::forward<validator2_type>(vali2)};
}

} // namespace seqan3