spell.hpp

Go to the documentation of this file.

#pragma once

 
// Internal headers (users don't need to know about these)
#include "spell_base.hpp"
#include "spell_extensible.hpp"
#include "rune_sequence.hpp"
#include "caster.hpp"
 
// Implementation headers
#include "spell_core.hpp"
#include "spell_filter.hpp"
#include "spell_language.hpp"
#include "spell_token.hpp"
 
namespace rune_caster {
namespace spell {
 
// === Simple factory functions for common spells ===

inline auto lowercase() {
    return core::CaseConverter{core::CaseConverter::CaseType::Lower};
}

inline auto uppercase() {
    return core::CaseConverter{core::CaseConverter::CaseType::Upper};
}

inline auto titlecase() {
    return core::CaseConverter{core::CaseConverter::CaseType::Title};
}

inline auto trim() {
    return core::TrimEdges{};
}

inline auto normalize_whitespace(bool collapse_multiple = true, bool trim_edges = true) {
    return core::WhitespaceNormalizer{collapse_multiple, trim_edges};
}

inline auto unicode_nfc() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFC};
}

inline auto unicode_nfd() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFD};
}

inline auto unicode_nfkc() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFKC};
}

inline auto unicode_nfkd() {
    return core::UnicodeNormalizer{unicode::NormalizationForm::NFKD};
}

inline auto tokenize() {
    return core::WhitespaceTokenizer{};
}

inline auto remove_punctuation() {
    return filter::PunctuationFilter{};
}

inline auto detect_language() {
    return language::LanguageDetector{};
}
 
// === Common spell combinations ===

class TextCleanup : public spell_extensible<> {
public:
    TextCleanup() : spell_extensible{"TextCleanup", "Standard text cleanup"} {}
 
private:
    RuneSequence process(const RuneSequence& input) const override {
        return make_caster(input)
            .cast(spell::normalize_whitespace())
            .cast(spell::trim())
            .cast(spell::lowercase())
            .result();
    }
};

inline auto cleanup() {
    return TextCleanup{};
}

class SearchPreprocess : public spell_extensible<> {
public:
    SearchPreprocess() : spell_extensible{"SearchPreprocess", "Search preprocessing"} {}
 
private:
    RuneSequence process(const RuneSequence& input) const override {
        return make_caster(input)
            .cast(spell::unicode_nfc())
            .cast(spell::normalize_whitespace())
            .cast(spell::trim())
            .cast(spell::lowercase())
            .cast(spell::remove_punctuation())
            .result();
    }
};

inline auto search_preprocess() {
    return SearchPreprocess{};
}
 
// === Advanced: Custom spell creation ===

template<typename Func>
class CustomSpell : public spell_extensible<> {
private:
    Func func_;
 
public:
    CustomSpell(std::string name, std::string desc, Func func)
        : spell_extensible{std::move(name), std::move(desc)}, func_{std::move(func)} {}
 
private:
    RuneSequence process(const RuneSequence& input) const override {
        return func_(input);
    }
};

template<typename Func>
auto custom(std::string name, std::string description, Func&& func) {
    return CustomSpell<std::decay_t<Func>>{
        std::move(name),
        std::move(description),
        std::forward<Func>(func)
    };
}
 
} // namespace spell
} // namespace rune_caster