generator.inl

Go to the documentation of this file.

#pragma once
 
#include "core/internal.hpp"
#include "generatorcore.inl"
#include "generatorformats.inl"
 
#ifndef LIPSUM_MIN_BUILD
static std::string ClearApostrAndCh(char letter, const std::string& str)
{
    std::string ret;
    ret.reserve(str.size());
    for (const char& let : str)
    {
        if (let != '\'' && let != letter)
        {
            ret.push_back(let);
        }
    }
    return ret;
}
 
static std::string
ClearApostrAndCh(char let1, char let2, const std::string& str)
{
    std::string ret;
    ret.reserve(str.size());
    for (const char& let : str)
    {
        if (let != '\'' && let != let1 && let != let2)
        {
            ret.push_back(let);
        }
    }
    return ret;
}
 
static std::string CapitalizeStr(const std::string& str)
{
    std::string ret = str;
    for (auto& letter : ret)
    {
        letter = LPSM_SAFE_CCTYPE(char, std::toupper, letter);
    }
    return ret;
}
#endif
 
namespace lipsum
{
 
    /*
     * CORE
     */
 
    std::string Generator::word(int num)
    {
 
        std::string ret;
 
        if (num < 0)
        {
            internal::LogWarn(internal::LogType::Warn,
                              "lpsm::Generator::word(): expected num >= 0, "
                              "got ",
                              num);
        }
 
        for (int i = 0; i < num; ++i)
        {
            ret += m_Source.random_word(m_Gen, m_Settings.lazy) += " ";
        }
 
        if (!ret.empty())
        {
            ret.pop_back();
        }
        return ret;
    }
 
    std::string Generator::fragment()
    {
        int numWords = m_Settings.word.roll(m_Gen, m_Settings.lazy);
        return word(numWords);
    }
 
    std::string Generator::sentence(int num, bool useLipsum)
    {
        std::string result;
 
        if (num < 0)
        {
            internal::LogWarn(internal::LogType::Warn,
                              "lpsm::Generator::sentence(): expected num "
                              ">= 0, got ",
                              num);
        }
 
        for (int i = 0; i < num; ++i)
        {
            if (i == 0 && useLipsum)
            {
                result += GenerateDefaultLipsumSentence() + " ";
            }
            else
            {
                result += single_sentence(m_Settings.word, m_Settings.frag) +=
                        " ";
            }
        }
        return result;
    }
 
    std::string Generator::paragraph(int num, bool useLipsum)
    {
        std::string result;
 
        if (num < 0)
        {
            internal::LogWarn(internal::LogType::Warn,
                              "lpsm::Generator::paragraph(): expected num "
                              ">= 0, got ",
                              num);
        }
 
        for (int i = 0; i < num; ++i)
        {
            if (i == 0 && useLipsum)
            {
                result += single_paragraph(USELIPSUM);
            }
            else
            {
                result += single_paragraph(NO_USELIPSUM);
            }
        }
        return result;
    }
 
    std::string Generator::text(bool useLipsum)
    {
        int num = m_Settings.para.roll(m_Gen, m_Settings.lazy);
        return paragraph(num, useLipsum);
    }
 
#ifndef LIPSUM_MIN_BUILD
    /*
     * MISC
     */
 
    std::string Generator::scramble(int length, char minChar, char maxChar)
    {
        std::string ret;
        if (length < 0)
        {
            internal::LogWarn(internal::LogType::Warn,
                              "lpsm::Generator::scramble(): expected length >= "
                              "0, "
                              "got ",
                              length);
        }
        else
        {
            ret.reserve(length);
        }
        for (int i = 0; i < length; ++i)
        {
            ret.push_back(random_number(minChar, maxChar));
        }
        return ret;
    }
 
    std::string Generator::url()
    {
        return std::string("https://") + plain_url() + std::string("/#") +
               slug('-');
    }
 
    std::string Generator::plain_url()
    {
        return std::string("lpsmcpp-") +
               m_Source.random_word(m_Gen, m_Settings.lazy) + tld();
    }
 
    std::string Generator::email()
    {
        return m_Source.random_word(m_Gen, m_Settings.lazy) + std::string(".") +
               m_Source.random_word(m_Gen, m_Settings.lazy) + std::string("@") +
               plain_url();
    }
 
    std::string Generator::slug(char separator)
    {
        std::string result;
        int         numWords = m_Settings.wordURL.roll(m_Gen, m_Settings.lazy);
        result               = word(numWords);
        std::replace(result.begin(), result.end(), ' ', separator);
        return result;
    }
 
    std::string Generator::case_slug(CaseSlugCase case_)
    {
        std::string ret;
        std::string innerWord;
        int         numWords = -2;
        switch (case_)
        {
            case CaseSlugCase::CamelCase:
            {
                numWords = m_Settings.wordURL.roll(m_Gen, m_Settings.lazy);
                ret += m_Source.random_word(m_Gen, m_Settings.lazy);
                --numWords;
                [[fallthrough]];
            }
            case CaseSlugCase::PascalCase:
            {
                if (numWords == -2)
                {
                    numWords = m_Settings.wordURL.roll(m_Gen, m_Settings.lazy);
                }
                for (int i = 0; i < numWords; ++i)
                {
                    innerWord = ClearApostrAndCh(
                            '-',
                            '_',
                            m_Source.random_word(m_Gen, m_Settings.lazy));
                    innerWord.at(0) = LPSM_SAFE_CCTYPE(char,
                                                       std::toupper,
                                                       innerWord.at(0));
                    ret += innerWord;
                }
                break;
            }
            case CaseSlugCase::SnakeCase:
            {
                ret = ClearApostrAndCh('-', slug('_'));
                break;
            }
            case CaseSlugCase::ShoutyCase:
            {
                ret = CapitalizeStr(ClearApostrAndCh('-', slug('_')));
                break;
            }
            case CaseSlugCase::KebabCase:
            {
                ret = ClearApostrAndCh('_', slug('-'));
                break;
            }
            case CaseSlugCase::TrainCase:
            {
                ret = CapitalizeStr(ClearApostrAndCh('_', slug('-')));
                break;
            }
        }
        return ret;
    }
 
    std::string Generator::code(CodeLanguage lang)
    {
        std::string              ret;
        std::vector<std::string> varNames;
        std::string              mainNamespace =
                scramble(m_Settings.wordURL.roll(m_Gen, m_Settings.lazy),
                         'a',
                         'z');
        int numStatements = m_Settings.point.roll(m_Gen, m_Settings.lazy);
        if (numStatements <= 0)
        {
            internal::LogWarn(internal::LogType::Warn,
                              "lpsm::Generator::code(): expected numStatements "
                              "> 0, got ",
                              numStatements);
        }
 
        auto varBlock = [&](CaseSlugCase       varCase,
                            CaseSlugCase       funcCase,
                            const std::string& varDeclarer,
                            const std::string& namespSep)
        {
            for (int i = 0; i < numStatements; ++i)
            {
                varNames.push_back(case_slug(varCase));
                ret += varDeclarer + varNames.back() + std::string(" = ") +
                       mainNamespace + namespSep + case_slug(funcCase) +
                       "();\n";
            }
        };
 
        auto cppBlock = [&]()
        {
            ret += std::string("#include <") + mainNamespace +
                   std::string("/") + mainNamespace + ".hpp>\n";
            ret += "#include <iostream>\nint main()\n{\n";
            ret += std::string("    // ") +
                   single_sentence(m_Settings.wordFmt, m_Settings.fragFmt) +
                   "\n";
            varBlock(CaseSlugCase::CamelCase,
                     CaseSlugCase::PascalCase,
                     "    auto ",
                     "::");
            ret += "    std::cout";
            for (int i = 0; i < numStatements; ++i)
            {
                ret += std::string(" << ") + varNames.at(i) + " << ' '";
            }
            ret += " << '\\n';\n    return 0;\n}";
        };
 
        auto pyBlock = [&]()
        {
            ret += std::string("import ") + mainNamespace + "\n";
            ret += "if __name__ == \"__main__\":\n";
            ret += std::string("    # ") +
                   single_sentence(m_Settings.wordFmt, m_Settings.fragFmt) +
                   "\n";
            // pyVars();
            varBlock(CaseSlugCase::SnakeCase,
                     CaseSlugCase::SnakeCase,
                     "    ",
                     ".");
            ret += "    print(f\"";
            for (int i = 0; i < numStatements; ++i)
            {
                ret += std::string("{") + varNames.at(i) + std::string("} ");
            }
            ret += "\")\n";
        };
 
        auto rsBlock = [&]()
        {
            ret += std::string("use ") + mainNamespace + ";\n";
            ret += "fn main()\n{\n";
            ret += std::string("    // ") +
                   single_sentence(m_Settings.wordFmt, m_Settings.fragFmt) +
                   "\n";
            // rsVars();
            varBlock(CaseSlugCase::SnakeCase,
                     CaseSlugCase::SnakeCase,
                     "    let ",
                     "::");
            ret += "    println!(\"";
            for (int i = 0; i < numStatements; ++i)
            {
                ret += std::string("{} ");
            }
            ret += "\"";
            for (int i = 0; i < numStatements; ++i)
            {
                ret += std::string(", ") + varNames.at(i);
            }
            ret += ");\n}";
        };
 
        auto cBlock = [&]()
        {
            ret += std::string("#include <") + mainNamespace +
                   std::string("/") + mainNamespace + ".h>\n";
            ret += "#include <stdio.h>\n";
            ret += "int main(void)\n{\n";
            ret += std::string("    // ") +
                   single_sentence(m_Settings.wordFmt, m_Settings.fragFmt) +
                   "\n";
            varBlock(CaseSlugCase::CamelCase,
                     CaseSlugCase::PascalCase,
                     "    int ",
                     "_");
            ret += "    printf(\"";
            for (int i = 0; i < numStatements; ++i)
            {
                ret += std::string("%d ");
            }
            ret += "\"";
            for (int i = 0; i < numStatements; ++i)
            {
                ret += std::string(", ") + varNames.at(i);
            }
            ret += ");\n}";
        };
 
        auto jsBlock = [&]()
        {
            ret += std::string("import * as ") + mainNamespace +
                   std::string(" from \"./") + mainNamespace + ".js\";\n";
            ret += std::string("// ") +
                   single_sentence(m_Settings.wordFmt, m_Settings.fragFmt) +
                   "\n";
            varBlock(CaseSlugCase::CamelCase,
                     CaseSlugCase::CamelCase,
                     "const ",
                     ".");
            ret += "console.log(";
            ret += varNames.front();
            for (int i = 1; i < numStatements; ++i)
            {
                ret += std::string(", \" \", ") + varNames.at(i);
            }
            ret += ");\n";
        };
 
        switch (lang)
        {
            case CodeLanguage::Cpp:
            {
                cppBlock();
                break;
            }
            case CodeLanguage::Python:
            {
                pyBlock();
                break;
            }
            case CodeLanguage::Rust:
            {
                rsBlock();
                break;
            }
            case CodeLanguage::C:
            {
                cBlock();
                break;
            }
            case CodeLanguage::JavaScript:
            {
                jsBlock();
                break;
            }
        }
        return ret;
    }
 
    std::string Generator::ip_addr(bool useIpv6, bool usePort)
    {
        std::ostringstream ret;
        std::string port = internal::ToString(random_number(1023, 65535));
        if (useIpv6)
        {
            ret << (usePort ? "[" : "");
            ret << std::hex;
            for (int i = 0; i < 7; ++i)
            {
                ret << random_number(0, 65535) << ":";
            }
            ret << random_number(0, 65535);
            ret << (usePort ? "]" : "");
            if (usePort)
            {
                ret << ":" << port;
            }
            return ret.str();
        }
        ret << random_number(0, 255) << ".";
        ret << random_number(0, 255) << ".";
        ret << random_number(0, 255) << ".";
        ret << random_number(0, 255);
        if (usePort)
        {
            ret << ":";
            ret << port;
        }
        return ret.str();
    }
 
    std::string Generator::phone_number()
    {
        std::string ret = "(+1) ";
        ret += internal::ToString(random_number(0, 999));
        ret += "-";
        ret += internal::ToString(random_number(0, 999));
        ret += "-";
        ret += internal::ToString(random_number(0, 9999));
        return ret;
    }
#else
    std::string Generator::phone_number()
    {
        return "";
    }
    std::string Generator::scramble(int, char, char)
    {
        return "";
    }
    std::string Generator::url()
    {
        return "";
    }
    std::string Generator::plain_url()
    {
        return "";
    }
    std::string Generator::email()
    {
        return "";
    }
    std::string Generator::slug(char)
    {
        return "";
    }
    std::string Generator::case_slug(CaseSlugCase)
    {
        return "";
    }
    std::string Generator::code(CodeLanguage)
    {
        return "";
    }
    std::string Generator::ip_addr(bool, bool)
    {
        return "";
    }
#endif
 
} // namespace lipsum