Renderer Class Reference

Public Member Functions
bool	loadTemplates (const QString &dirPath)
QStringList	templatesNames () const
void	push (const QVariantHash &context)
void	pop ()
bool	render (const QString &templateName, const QString &outputPathName, const QVariantHash &additionalContext=QVariantHash{})

Static Public Member Functions
static QString	sanitise (const QString &key)
static QVariant	sanitise (const QVariant &variant)
static QVariantHash	sanitise (const QVariantHash &hash)
static QVariantMap	sanitise (const QVariantMap &map)

Static Protected Member Functions
static	Q_LOGGING_CATEGORY (lc, "smithy.Renderer", QtInfoMsg)
	Logging category for Renderer.

Protected Attributes
Textlee::Context	context
Textlee::Engine	engine
QStringList	templates

Private Member Functions
	Q_DECLARE_TR_FUNCTIONS (Renderer)

Detailed Description

Definition at line 22 of file renderer.h.

Constructor & Destructor Documentation

Renderer()

Renderer::Renderer

(

)

Definition at line 24 of file renderer.cpp.

{
    engine.setSmartTrimEnabled(true);
}

Member Function Documentation

loadTemplates()

bool Renderer::loadTemplates

(

const QString &

dirPath

)

Definition at line 29 of file renderer.cpp.

{
    qCInfo(lc).noquote() << tr("Loading Textlee templates from %1").arg(dir);
 
    // Setup the template loader.
    #if defined USE_CUTELEE
    auto loader = std::make_shared<Textlee::FileSystemTemplateLoader>();
    auto cachedLoader = std::make_shared<Textlee::CachingLoaderDecorator>(loader);
    #elif defined USE_GRANTLEE or defined USE_KTEXTTEMPLATE
    auto loader = QSharedPointer<Textlee::FileSystemTemplateLoader>::create();
    auto cachedLoader = QSharedPointer<Textlee::CachingLoaderDecorator>::create(loader);
    #endif
    // Note, {% include "<filename>" %} will look for files relative to templateDirs.
    loader->setTemplateDirs(QStringList{dir});
    engine.addTemplateLoader(cachedLoader);
 
    // Load the templates.
    QDirIterator iter{QDir::cleanPath(dir), QDir::Files, QDirIterator::Subdirectories};
    while (iter.hasNext()) {
        const QString name = iter.next().mid(iter.path().size()+1);
        qCDebug(lc).noquote() << tr("Loading template: %1").arg(name);
        const Textlee::Template tmplate = engine.loadByName(name);
        if (tmplate->error()) {
            qCritical().noquote() << tr("Error loading template %1: %2")
                .arg(name, tmplate->errorString());
            return false;
        }
        templates.append(name);
    }
    qDebug(lc).noquote() << tr("Loaded %n template/s from %1", nullptr, templates.size()).arg(dir);
    return true;
}

pop()

void Renderer::pop

(

)

Definition at line 95 of file renderer.cpp.

{
    context.pop();
}

push()

void Renderer::push

(

const QVariantHash &

context

)

Definition at line 87 of file renderer.cpp.

{
    this->context.push();
    for (auto iter = context.constBegin(); iter != context.constEnd(); ++iter) {
        this->context.insert(sanitise(iter.key()), sanitise(iter.value()));
    }
}

render()

bool Renderer::render	(	const QString &	templateName,
		const QString &	outputPathName,
		const QVariantHash &	additionalContext = QVariantHash{} )

Definition at line 100 of file renderer.cpp.

{
    qCDebug(lc).noquote() << tr("Rendering %1 to %2").arg(templateName, outputPathName);
    if (!templates.contains(templateName)) {
        qCCritical(lc).noquote() << tr("Template %1 has not been loaded").arg(templateName);
        return false;
    }
 
    const QDir dir = QFileInfo(outputPathName).dir();
    if (!dir.mkpath(QSL("./"))) {
        qCCritical(lc).noquote() << tr("Failed to create directory path %1").arg(dir.path());
        return false;
    }
 
    QFile file(outputPathName);
    if (!file.open(QFile::WriteOnly)) {
        qCCritical(lc).noquote() << tr("Failed to open %1 for writing: %2")
            .arg(outputPathName, file.errorString());
        return false;
    }
 
    push(additionalContext);
    QTextStream textStream(&file);
    NoEscapeStream noEscapeStream(&textStream);
    Textlee::Template tmplate = engine.loadByName(templateName);
    if (!tmplate) {
        qCCritical(lc).noquote() << tr("Failed to fetch template %1").arg(outputPathName);
        pop();
        return false;
    }
    tmplate->render(&noEscapeStream, &context);
    if (tmplate->error()) {
        qCCritical(lc).noquote() << tr("Failed to render %1: %2").arg(outputPathName, tmplate->errorString());
        pop();
        return false;
    }
    pop();
    return true;
}

sanitise() [1/4]

QString Renderer::sanitise ( const QString & key )

static

Definition at line 141 of file renderer.cpp.

{
    QString newKey = key;
    int pos;
    while ((pos = newKey.indexOf(QLatin1Char('.'))) >= 0) {
        newKey = newKey.mid(0, pos) + newKey.mid(pos+1,1).toUpper() + newKey.mid(pos+2);
    }
    newKey.replace(QRegularExpression{QSL("[^a-zA-Z0-9_]")}, QSL("_"));
    newKey.replace(QRegularExpression{QSL("^[0-9_]")}, QLatin1String());
    return newKey;
}

sanitise() [2/4]

QVariant Renderer::sanitise ( const QVariant & variant )

static

Definition at line 153 of file renderer.cpp.

{
    #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
    const int typeId = variant.typeId();
    #else
    const int typeId = variant.type();
    #endif
    if (typeId == QMetaType::QVariantHash) {
        return sanitise(variant.toHash());
    } else if (typeId == QMetaType::QVariantMap) {
        return sanitise(variant.toMap());
    }
    return variant;
}

sanitise() [3/4]

QVariantHash Renderer::sanitise ( const QVariantHash & hash )

static

Definition at line 168 of file renderer.cpp.

{
    QVariantHash newHash;
    for (auto iter = hash.begin(); iter != hash.end(); ++iter) {
        const QString saneKey = sanitise(iter.key());
        QVariant saneValue = iter.value();
        #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
        const int typeId = iter->typeId();
        #else
        const int typeId = iter->type();
        #endif
        if (typeId == QMetaType::QVariantHash) {
            saneValue = sanitise(iter->toHash());
        } else if (typeId == QMetaType::QVariantMap) {
            saneValue = sanitise(iter->toMap());
        }
        newHash.insert(saneKey, saneValue);
    }
    Q_ASSERT(hash.size() == newHash.size());
    return newHash;
}

sanitise() [4/4]

QVariantMap Renderer::sanitise ( const QVariantMap & map )

static

Definition at line 190 of file renderer.cpp.

{
    QVariantMap newMap;
    for (auto iter = map.begin(); iter != map.end(); ++iter) {
        const QString saneKey = sanitise(iter.key());
        QVariant saneValue = iter.value();
        #if (QT_VERSION >= QT_VERSION_CHECK(6, 0, 0))
        const int typeId = iter->typeId();
        #else
        const int typeId = iter->type();
        #endif
        if (typeId == QMetaType::QVariantHash) {
            saneValue = sanitise(iter->toHash());
        } else if (typeId == QMetaType::QVariantMap) {
            saneValue = sanitise(iter->toMap());
        }
        newMap.insert(saneKey, saneValue);
    }
    Q_ASSERT(map.size() == newMap.size());
    return newMap;
}

templatesNames()

QStringList Renderer::templatesNames

(

)

const

Definition at line 62 of file renderer.cpp.

{
    return templates;
}

Member Data Documentation

context

Textlee::Context Renderer::context

protected

Definition at line 45 of file renderer.h.

engine

Textlee::Engine Renderer::engine

protected

Definition at line 46 of file renderer.h.

templates

QStringList Renderer::templates

protected

Definition at line 47 of file renderer.h.

---

The documentation for this class was generated from the following files:

• renderer.h
• renderer.cpp