utils.cpp

Go to the documentation of this file.

// Copyright (c) 2006-2024  Made to Order Software Corp.  All Rights Reserved
//
// https://snapwebsites.org/project/advgetopt
// contact@m2osw.com
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 
// self
//
#include    "advgetopt/utils.h"
 
#include    "advgetopt/exception.h"
 
 
// snapdev
//
#include    <snapdev/glob_to_list.h>
#include    <snapdev/isatty.h>
#include    <snapdev/not_used.h>
#include    <snapdev/trim_string.h>
 
 
// cppthread
//
#include    <cppthread/guard.h>
#include    <cppthread/mutex.h>
 
 
// C++
//
#include    <cstring>
#include    <iomanip>
#include    <set>
#include    <sstream>
 
 
// C
//
#include    <sys/ioctl.h>
#include    <sys/stat.h>
#include    <unistd.h>
 
 
 
 
// last include
//
#include    <snapdev/poison.h>
 
 
 
namespace advgetopt
{
 
 
 
namespace
{
 
 
 
cppthread::mutex *      g_mutex;
 
 
 
constexpr char const    g_single_quote = '\'';
constexpr char const *  g_empty_string = "\"\"";
constexpr char const *  g_escaped_single_quotes = "'\\''";
constexpr char const *  g_simple_characters = "+-./0123456789=ABCEFGHIJKLMNOPQRSTUVWXYZabcefghijklmnopqrstuvwxyz_";
 
 
 
}
// no name namespace
 
 
 
cppthread::mutex & get_global_mutex()
{
    {
        cppthread::guard lock(*cppthread::g_system_mutex);
 
        if(g_mutex == nullptr)
        {
            g_mutex = new cppthread::mutex();
        }
    }
 
    return *g_mutex;
}
 
 
 
std::string unquote(std::string const & s, std::string const & pairs)
{
    if(s.length() >= 2)
    {
        std::string::size_type const max(pairs.length() - 1);
        for(std::string::size_type pos(0); pos < max; pos += 2)
        {
            if(s.front() == pairs[pos + 0]
            && s.back()  == pairs[pos + 1])
            {
                return s.substr(1, s.length() - 2);
            }
        }
    }
 
    return s;
}
 
 
std::string quote(std::string const & s, char open, char close)
{
    std::string result;
 
    if(close == '\0')
    {
        close = open;
    }
 
    result += open;
    for(auto const c : s)
    {
        if(c == open
        || c == close)
        {
            result += '\\';
        }
        result += c;
    }
    result += close;
 
    return result;
}
 
 
std::string option_with_dashes(std::string const & s)
{
    std::string result;
    result.reserve(s.length());
    for(auto const & c : s)
    {
        if(c == '_')
        {
            result += '-';
        }
        else
        {
            result += c;
        }
    }
    return result;
}
 
 
std::string option_with_underscores(std::string const & s)
{
    std::string result;
    result.reserve(s.length());
    for(auto const & c : s)
    {
        if(c == '-')
        {
            result += '_';
        }
        else
        {
            result += c;
        }
    }
    return result;
}
 
 
void split_string(std::string const & str
                , string_list_t & result
                , string_list_t const & separators)
{
    std::string::size_type pos(0);
    std::string::size_type start(0);
    while(pos < str.length())
    {
        if(str[pos] == '\'' || str[pos] == '"')
        {
            if(start < pos)
            {
                std::string const v(snapdev::trim_string(str.substr(start, pos - start)));
                if(!v.empty())
                {
                    result.push_back(v);
                }
                start = pos;
            }
 
            // quoted parameters are handled without the separators
            //
            char const quote(str[pos]);
            for(++pos; pos < str.length() && str[pos] != quote; ++pos);
 
            std::string const v(str.substr(start + 1, pos - (start + 1)));
            if(!v.empty())
            {
                result.push_back(v);
            }
            if(pos < str.length())
            {
                // skip the closing quote
                //
                ++pos;
            }
            start = pos;
        }
        else
        {
            bool found(false);
            for(auto const & sep : separators)
            {
                if(str.length() - pos >= sep.length())
                {
                    if(str.compare(pos, sep.length(), sep) == 0)
                    {
                        // match! cut here
                        //
                        if(start < pos)
                        {
                            std::string const v(snapdev::trim_string(str.substr(start, pos - start)));
                            if(!v.empty())
                            {
                                result.push_back(v);
                            }
                        }
                        pos += sep.length();
                        start = pos;
                        found = true;
                        break;
                    }
                }
            }
 
            if(!found)
            {
                ++pos;
            }
        }
    }
 
    if(start < pos)
    {
        std::string const v(snapdev::trim_string(str.substr(start, pos - start)));
        if(!v.empty())
        {
            result.push_back(v);
        }
    }
}
 
 
string_list_t insert_group_name(
          std::string const & filename
        , char const * group_name
        , char const * project_name
        , bool add_default_on_empty)
{
    if(filename.empty())
    {
        return string_list_t();
    }
 
    std::string name;
    if(group_name == nullptr
    || *group_name == '\0')
    {
        if(project_name == nullptr
        || *project_name == '\0')
        {
            return string_list_t();
        }
        name = project_name;
    }
    else
    {
        name = group_name;
    }
 
    std::string pattern;
    std::string::size_type const pos(filename.find_last_of('/'));
    if(pos == 0)
    {
        throw getopt_root_filename(
                  "filename \""
                + filename
                + "\" last slash (/) is at the start, which is not allowed.");
    }
    if(pos != std::string::npos
    && pos > 0)
    {
        pattern = filename.substr(0, pos + 1)
                + name
                + ".d/[0-9][0-9]-"
                + filename.substr(pos + 1);
    }
    else
    {
        pattern = name
                + ".d/[0-9][0-9]-"
                + filename;
    }
 
    // we use an std::set so the resulting list is sorted
    //
    snapdev::glob_to_list<std::set<std::string>> glob;
 
    // the glob() function is not thread safe
    {
        cppthread::guard lock(get_global_mutex());
        snapdev::NOT_USED(glob.read_path<snapdev::glob_to_list_flag_t::GLOB_FLAG_IGNORE_ERRORS>(pattern));
    }
 
    // we add the default name if none other exists
    //
    if(add_default_on_empty
    && glob.empty())
    {
        glob.insert(default_group_name(
                  filename
                , group_name
                , project_name));
    }
 
    return string_list_t(glob.begin(), glob.end());
}
 
 
std::string default_group_name(
          std::string const & filename
        , char const * group_name
        , char const * project_name
        , int priority)
{
    if(priority < 0 || priority >= 100)
    {
        throw getopt_invalid_parameter(
              "priority must be a number between 0 and 99 inclusive; "
            + std::to_string(priority)
            + " is invalid.");
    }
 
    if(filename.empty())
    {
        return std::string();
    }
 
    char const * name(nullptr);
    if(group_name == nullptr
    || *group_name == '\0')
    {
        if(project_name == nullptr
        || *project_name == '\0')
        {
            return std::string();
        }
        name = project_name;
    }
    else
    {
        name = group_name;
    }
 
    std::string::size_type const pos(filename.find_last_of('/'));
    if(pos == 0)
    {
        throw getopt_root_filename("filename \"" + filename + "\" starts with a slash (/), which is not allowed.");
    }
 
    std::string result;
    result.reserve(filename.length() + strlen(name) + 6);
    if(pos != std::string::npos)
    {
        result = filename.substr(0, pos + 1);
    }
    result += name;
    result += ".d/";
    if(priority < 10)
    {
        result += '0';
    }
    result += std::to_string(priority);
    result += '-';
    if(pos == std::string::npos)
    {
        result += filename;
    }
    else
    {
        result += filename.substr(pos + 1);
    }
 
    return result;
}
 
 
std::string handle_user_directory(std::string const & filename)
{
    if(!filename.empty()
    && filename[0] == '~'
    && (filename.length() == 1 || filename[1] == '/'))
    {
        char const * const home(getenv("HOME"));
        if(home != nullptr
        && *home != '\0')
        {
            return home + filename.substr(1);
        }
    }
 
    return filename;
}
 
 
bool is_true(std::string s)
{
    return s == "true" || s == "on" || s == "yes" | s == "1";
}
 
 
bool is_false(std::string s)
{
    return s == "false" || s == "off" || s == "no" || s == "0";
}
 
 
size_t get_screen_width()
{
    std::int64_t cols(80);
 
    if(isatty(STDOUT_FILENO))
    {
// LCOV_EXCL_START
        // when running coverage, the output is redirected for logging purposes
        // which means that isatty() returns false -- so at this time I just
        // exclude those since they are unreachable from my standard Unit Tests
        //
        winsize w;
        if(ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) != -1)
        {
            cols = std::max(static_cast<unsigned short>(40), w.ws_col);
        }
// LCOV_EXCL_STOP
    }
 
    return cols;
}
 
 
std::string breakup_line(
      std::string line
    , size_t const option_width
    , size_t const line_width)
{
    std::stringstream ss;
 
    size_t const width(line_width - option_width);
 
    // TODO: once we have C++17, avoid substr() using std::string_view instead
    //
    for(;;)
    {
        std::string l;
        std::string::size_type const nl(line.find('\n'));
        if(nl != std::string::npos
        && nl < width)
        {
            l = line.substr(0, nl);
            line = line.substr(nl + 1);
        }
        else if(line.size() <= width)
        {
            break;
        }
        else if(std::isspace(line[width]))
        {
            // special case when the space is right at the edge
            //
            l = line.substr(0, width);
            size_t pos(width);
            do
            {
                ++pos;
            }
            while(std::isspace(line[pos]));
            line = line.substr(pos);
        }
        else
        {
            // search for the last space before the edge of the screen
            //
            std::string::size_type pos(line.find_last_of(' ', width));
            if(pos == std::string::npos)
            {
                // no space found, cut right at the edge...
                // (this should be really rare)
                //
                l = line.substr(0, width);
                line = line.substr(width);
            }
            else
            {
                // we found a space, write everything up to that space
                //
                l = line.substr(0, pos);
 
                // remove additional spaces from the start of the next line
                do  // LCOV_EXCL_LINE
                {
                    ++pos;
                }
                while(std::isspace(line[pos]));
                line = line.substr(pos);
            }
        }
 
        ss << l
           << std::endl;
 
        // more to print? if so we need the indentation
        //
        if(!line.empty()
        && option_width > 0)
        {
            ss << std::setw(option_width) << " ";
        }
    }
 
    // some leftover?
    //
    if(!line.empty())
    {
        ss << line << std::endl;
    }
 
    return ss.str();
}
 
 
std::string format_usage_string(
                      std::string const & argument
                    , std::string const & help
                    , size_t const option_width
                    , size_t const line_width)
{
    std::stringstream ss;
 
    ss << "   ";
 
    if(argument.size() < option_width - 3)
    {
        // enough space on a single line
        //
        ss << argument
           << std::setw(option_width - 3 - argument.size())
           << " ";
    }
    else if(argument.size() >= line_width - 4)
    {
        // argument too long for even one line on the screen!?
        // call the function to break it up with indentation of 3
        //
        ss << breakup_line(argument, 3, line_width);
 
        if(!help.empty()
        && option_width > 0)
        {
            ss << std::setw(option_width) << " ";
        }
    }
    else
    {
        // argument too long for the help to follow immediately
        //
        ss << argument
           << std::endl
           << std::setw(option_width)
           << " ";
    }
 
    ss << breakup_line(help, option_width, line_width);
 
    return ss.str();
}
 
 
std::string escape_shell_argument(std::string const & arg)
{
    if(arg.empty())
    {
        return std::string(g_empty_string);
    }
 
    std::string::size_type const pos(arg.find_first_not_of(g_simple_characters));
    if(pos == std::string::npos)
    {
        return arg;
    }
 
    std::string result;
 
    result += g_single_quote;
    std::string::size_type p1(0);
    while(p1 < arg.length())
    {
        std::string::size_type const p2(arg.find('\'', p1));
        if(p2 == std::string::npos)
        {
            result += arg.substr(p1);
            break;
        }
        result += arg.substr(p1, p2 - p1);
        result += g_escaped_single_quotes;
        p1 = p2 + 1;                            // skip the '
    }
    result += g_single_quote;
 
    return result;
}
 
 
std::string sanitizer_details()
{
    std::string result;
#if defined(__SANITIZE_ADDRESS__) || defined(__SANITIZE_THREAD__)
#if defined(__SANITIZE_ADDRESS__)
    result += "The address sanitizer is compiled in.\n";
#endif
#if defined(__SANITIZE_THREAD__)
    result += "The thread sanitizer is compiled in.\n";
#endif
#else
    result += "The address and thread sanitizers are not compiled in.\n";
#endif
    return result;
}
 
 
// LCOV_EXCL_START
size_t get_screen_height()
{
    std::int64_t rows(25);
 
    if(isatty(STDOUT_FILENO))
    {
        // when running coverage, the output is redirected for logging purposes
        // which means that isatty() returns false -- so at this time I just
        // exclude those since they are unreachable from my standard Unit Tests
        //
        winsize w;
        if(ioctl(STDOUT_FILENO, TIOCGWINSZ, &w) != -1)
        {
            rows = std::max(static_cast<unsigned short>(2), w.ws_row);
        }
    }
 
    return rows;
}
// LCOV_EXCL_STOP
 
 
void less(std::basic_ostream<char> & out, std::string const & data)
{
    if(snapdev::isatty(out))
    {
// LCOV_EXCL_START
        auto const lines(std::count(data.begin(), data.end(), '\n'));
        size_t const height(get_screen_height());
        if(lines > static_cast<std::remove_const_t<decltype(lines)>>(height))
        {
            struct stat s;
            if(stat("/bin/less", &s) == 0)
            {
                FILE * f(popen("/bin/less", "w"));
                if(f != nullptr)
                {
                    fwrite(data.c_str(), sizeof(char), data.length(), f);
                    pclose(f);
                    return;
                }
            }
            else if(stat("/bin/more", &s) == 0)
            {
                FILE * f(popen("/bin/more", "w"));
                if(f != nullptr)
                {
                    fwrite(data.c_str(), sizeof(char), data.length(), f);
                    pclose(f);
                    return;
                }
            }
        }
// LCOV_EXCL_STOP
    }
 
    // fallback, just print everything to the console as is
    //
    out << data << std::endl;
}
 
 
 
}   // namespace advgetopt
// vim: ts=4 sw=4 et