naming.hpp

Go to the documentation of this file.

#pragma once
#include <meta>
#include <stdexcept> // name_of_or: missing-override diagnostic
#include <string>
#include <string_view>
#include <vector>
 
#include <welder/concepts.hpp> // the name_style concept (welder::naming::name_style)

 
namespace welder::inline v0::naming {
 
// --- identifier word-splitting ----------------------------------------------

consteval std::vector<std::string> split_words(std::string_view id) {
    auto is_upper = [](char c) { return c >= 'A' && c <= 'Z'; };
    auto is_lower = [](char c) { return c >= 'a' && c <= 'z'; };
    auto is_digit = [](char c) { return c >= '0' && c <= '9'; };
    auto to_lower = [&](char c) { return is_upper(c) ? char(c - 'A' + 'a') : c; };
 
    std::vector<std::string> words{};
    std::string cur{};
    auto flush = [&] {
        if (!cur.empty()) {
            words.push_back(cur);
            cur.clear();
        }
    };
    for (std::string::size_type i{0}; i < id.size(); ++i) {
        const char c{id[i]};
        if (c == '_' || c == '-' || c == ' ') {
            flush();
            continue;
        }
        if (!cur.empty()) {
            const char prev{id[i - 1]};
            const bool hump{is_upper(c) && (is_lower(prev) || is_digit(prev))};
            const bool acronym_end{is_upper(c) && is_upper(prev) &&
                                   i + 1 < id.size() && is_lower(id[i + 1])};
            if (hump || acronym_end)
                flush();
        }
        cur.push_back(to_lower(c));
    }
    flush();
    return words;
}
 
// --- word joiners (the common conventions) ----------------------------------

enum class case_kind {
    snake,           
    screaming_snake, 
    kebab,           
    camel,           
    pascal,          
};

consteval std::string join_words(const std::vector<std::string>& words,
                                 case_kind kind) {
    auto upper = [](char c) { return (c >= 'a' && c <= 'z') ? char(c - 'a' + 'A') : c; };
    auto cap = [&](std::string w) {
        if (!w.empty())
            w[0] = upper(w[0]);
        return w;
    };
    std::string out{};
    for (std::string::size_type i{0}; i < words.size(); ++i) {
        switch (kind) {
        case case_kind::snake:
            if (i)
                out += '_';
            out += words[i];
            break;
        case case_kind::screaming_snake:
            if (i)
                out += '_';
            for (char c : words[i])
                out += upper(c);
            break;
        case case_kind::kebab:
            if (i)
                out += '-';
            out += words[i];
            break;
        case case_kind::camel:
            out += i ? cap(words[i]) : words[i];
            break;
        case case_kind::pascal:
            out += cap(words[i]);
            break;
        }
    }
    return out;
}

consteval std::string restyle(std::string_view id, case_kind kind) {
    std::string::size_type lead{0};
    while (lead < id.size() && id[lead] == '_')
        ++lead;
    if (lead == id.size()) // empty or all underscores: nothing to restyle
        return std::string{id};
    std::string::size_type trail{0};
    while (id[id.size() - 1 - trail] == '_')
        ++trail;
    return std::string(lead, '_') + join_words(split_words(id), kind) +
           std::string(trail, '_');
}

consteval case_kind detect_case(std::string_view id) {
    bool has_underscore{false}, has_hyphen{false}, has_lower{false},
        has_upper{false};
    bool first_alpha_upper{false}, seen_alpha{false};
    for (char c : id) {
        if (c == '_')
            has_underscore = true;
        else if (c == '-')
            has_hyphen = true;
        else if (c >= 'a' && c <= 'z')
            has_lower = true;
        else if (c >= 'A' && c <= 'Z')
            has_upper = true;
        if (!seen_alpha && ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) {
            seen_alpha = true;
            first_alpha_upper = (c >= 'A' && c <= 'Z');
        }
    }
    if (has_hyphen)
        return case_kind::kebab;
    if (has_underscore || !has_upper)
        return has_lower || !has_upper ? case_kind::snake
                                       : case_kind::screaming_snake;
    return first_alpha_upper ? case_kind::pascal : case_kind::camel;
}

consteval std::vector<std::string> accessor_property_words(std::string_view id) {
    std::vector<std::string> words{split_words(id)};
    if (words.size() >= 2 && (words[0] == "get" || words[0] == "set"))
        words.erase(words.begin());
    return words;
}

consteval std::string strip_accessor_word(std::string_view styled) {
    std::string::size_type lead{0};
    while (lead < styled.size() && styled[lead] == '_')
        ++lead;
    if (lead == styled.size())
        return std::string{styled};
    std::string::size_type trail{0};
    while (styled[styled.size() - 1 - trail] == '_')
        ++trail;
    return std::string(lead, '_') +
           join_words(accessor_property_words(styled), detect_case(styled)) +
           std::string(trail, '_');
}
 
// --- the style customization point ------------------------------------------
//
// The `name_style` concept — the per-kind hook contract a style below implements —
// lives in <welder/concepts.hpp> (with welder's other interface concepts).

struct none {
    static consteval std::string transform_class(std::meta::info e) { return id(e); }
    static consteval std::string transform_enum(std::meta::info e) { return id(e); }
    static consteval std::string transform_enumerator(std::meta::info e) { return id(e); }
    static consteval std::string transform_method(std::meta::info e) { return id(e); }
    static consteval std::string transform_static_method(std::meta::info e) { return id(e); }
    static consteval std::string transform_function(std::meta::info e) { return id(e); }
    static consteval std::string transform_field(std::meta::info e) { return id(e); }
    static consteval std::string transform_variable(std::meta::info e) { return id(e); }
    static consteval std::string transform_submodule(std::meta::info e) { return id(e); }
 
  private:
    static consteval std::string id(std::meta::info e) {
        return std::string{std::meta::identifier_of(e)};
    }
};
static_assert(name_style<none>, "welder: naming::none is not a name_style");

template <case_kind Kind>
struct uniform {
    static consteval std::string transform_class(std::meta::info e) { return in(e); }
    static consteval std::string transform_enum(std::meta::info e) { return in(e); }
    static consteval std::string transform_enumerator(std::meta::info e) { return in(e); }
    static consteval std::string transform_method(std::meta::info e) { return in(e); }
    static consteval std::string transform_static_method(std::meta::info e) { return in(e); }
    static consteval std::string transform_function(std::meta::info e) { return in(e); }
    static consteval std::string transform_field(std::meta::info e) { return in(e); }
    static consteval std::string transform_variable(std::meta::info e) { return in(e); }
    static consteval std::string transform_submodule(std::meta::info e) { return in(e); }
 
  private:
    static consteval std::string in(std::meta::info e) {
        return restyle(std::meta::identifier_of(e), Kind);
    }
};
 
// Each predefined style is checked against the `name_style` concept right at its
// definition, so a hook that drifts out of contract (a missing or wrongly-typed
// transform_*) fails loudly here rather than at some rod's call site.
using snake_case = uniform<case_kind::snake>; 
static_assert(name_style<snake_case>, "welder: naming::snake_case is not a name_style");
using screaming_snake_case = uniform<case_kind::screaming_snake>; 
static_assert(name_style<screaming_snake_case>,
              "welder: naming::screaming_snake_case is not a name_style");
using kebab_case = uniform<case_kind::kebab>; 
static_assert(name_style<kebab_case>, "welder: naming::kebab_case is not a name_style");
using camel_case = uniform<case_kind::camel>; 
static_assert(name_style<camel_case>, "welder: naming::camel_case is not a name_style");
using pascal_case = uniform<case_kind::pascal>; 
static_assert(name_style<pascal_case>, "welder: naming::pascal_case is not a name_style");
 
} // namespace welder::naming
 
namespace welder::inline v0 {

enum class ent_kind {
    class_,        
    enum_,         
    enumerator,    
    method,        
    static_method, 
    function,      
    field,         
    variable,      
    submodule,     
};

template <std::meta::info Ent, lang L>
consteval const char* weld_as_of() {
    template for (constexpr auto a :
                  std::define_static_array(std::meta::annotations_of(Ent))) {
        constexpr std::meta::info t{std::meta::type_of(a)};
        if constexpr (std::meta::has_template_arguments(t) &&
                      std::meta::template_of(t) == ^^detail::weld_as_spec) {
            using spec_type = [:t:];
            constexpr auto spec{std::meta::extract<spec_type>(a)};
            if constexpr (spec.mask == 0 || (spec.mask & lang_bit(L)) != 0)
                return std::define_static_string(spec.name.data);
        }
    }
    return nullptr;
}

template <std::meta::info Ent, lang L, class Style, ent_kind K>
consteval const char* name_of() {
    if (const char* forced{weld_as_of<Ent, L>()})
        return forced;
    if constexpr (K == ent_kind::class_)
        return std::define_static_string(Style::transform_class(Ent));
    else if constexpr (K == ent_kind::enum_)
        return std::define_static_string(Style::transform_enum(Ent));
    else if constexpr (K == ent_kind::enumerator)
        return std::define_static_string(Style::transform_enumerator(Ent));
    else if constexpr (K == ent_kind::method)
        return std::define_static_string(Style::transform_method(Ent));
    else if constexpr (K == ent_kind::static_method)
        return std::define_static_string(Style::transform_static_method(Ent));
    else if constexpr (K == ent_kind::function)
        return std::define_static_string(Style::transform_function(Ent));
    else if constexpr (K == ent_kind::field)
        return std::define_static_string(Style::transform_field(Ent));
    else if constexpr (K == ent_kind::variable)
        return std::define_static_string(Style::transform_variable(Ent));
    else // ent_kind::submodule
        return std::define_static_string(Style::transform_submodule(Ent));
}

template <std::meta::info Ent, lang L, class Style, ent_kind K>
constexpr const char* name_of_or(const char* override_) {
    if (override_)
        return override_;
    if constexpr (weld_as_of<Ent, L>() != nullptr || std::meta::has_identifier(Ent)) {
        return name_of<Ent, L, Style, K>();
    } else {
        throw std::invalid_argument{
            "welder: this entity has no identifier (a template instantiation?) and "
            "no [[=welder::weld_as]] — pass an explicit name at the weld_* call"};
    }
}
 
} // namespace welder