path: root/src/plugins/texteditor/generichighlighter/manager.cpp

/**************************************************************************
**
** This file is part of Qt Creator
**
** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
**
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** Commercial Usage
**
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
**
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at http://qt.nokia.com/contact.
**
**************************************************************************/

#include "manager.h"
#include "highlightdefinition.h"
#include "highlightdefinitionhandler.h"
#include "highlighterexception.h"
#include "definitiondownloader.h"
#include "highlightersettings.h"
#include "plaintexteditorfactory.h"
#include "texteditorconstants.h"
#include "texteditorplugin.h"
#include "texteditorsettings.h"

#include <coreplugin/icore.h>
#include <utils/qtcassert.h>
#include <coreplugin/progressmanager/progressmanager.h>
#include <qtconcurrent/QtConcurrentTools>

#include <QtCore/QtAlgorithms>
#include <QtCore/QtPlugin>
#include <QtCore/QString>
#include <QtCore/QLatin1Char>
#include <QtCore/QLatin1String>
#include <QtCore/QStringList>
#include <QtCore/QFile>
#include <QtCore/QFileInfo>
#include <QtCore/QDir>
#include <QtCore/QRegExp>
#include <QtCore/QFuture>
#include <QtCore/QtConcurrentRun>
#include <QtCore/QtConcurrentMap>
#include <QtCore/QUrl>
#include <QtGui/QDesktopServices>
#include <QtXml/QXmlSimpleReader>
#include <QtXml/QXmlInputSource>
#include <QtXml/QXmlStreamReader>
#include <QtXml/QXmlStreamAttributes>
#include <QtNetwork/QNetworkRequest>
#include <QtNetwork/QNetworkReply>

using namespace TextEditor;
using namespace Internal;

Manager::Manager() : m_downloadingDefinitions(false)
{
    connect(&m_mimeTypeWatcher, SIGNAL(resultReadyAt(int)), this, SLOT(registerMimeType(int)));
    connect(&m_downloadWatcher, SIGNAL(finished()), this, SLOT(downloadDefinitionsFinished()));
}

Manager::~Manager()
{}

Manager *Manager::instance()
{
    static Manager manager;
    return &manager;
}

QString Manager::definitionIdByName(const QString &name) const
{ return m_idByName.value(name); }

QString Manager::definitionIdByMimeType(const QString &mimeType) const
{ return m_idByMimeType.value(mimeType); }

QString Manager::definitionIdByAnyMimeType(const QStringList &mimeTypes) const
{
    QString definitionId;
    foreach (const QString &mimeType, mimeTypes) {
        definitionId = definitionIdByMimeType(mimeType);
        if (!definitionId.isEmpty())
            break;
    }
    return definitionId;
}

QSharedPointer<HighlightDefinition> Manager::definition(const QString &id)
{
    if (!id.isEmpty() && !m_definitions.contains(id)) {
        QFile definitionFile(id);
        if (!definitionFile.open(QIODevice::ReadOnly | QIODevice::Text))
            return QSharedPointer<HighlightDefinition>();

        QSharedPointer<HighlightDefinition> definition(new HighlightDefinition);
        HighlightDefinitionHandler handler(definition);

        QXmlInputSource source(&definitionFile);
        QXmlSimpleReader reader;
        reader.setContentHandler(&handler);
        m_isBuilding.insert(id);
        try {
            reader.parse(source);
        } catch (HighlighterException &) {
            definition.clear();
        }
        m_isBuilding.remove(id);
        definitionFile.close();

        m_definitions.insert(id, definition);
    }

    return m_definitions.value(id);
}

QSharedPointer<HighlightDefinitionMetaData> Manager::definitionMetaData(const QString &id) const
{ return m_definitionsMetaData.value(id); }

bool Manager::isBuildingDefinition(const QString &id) const
{ return m_isBuilding.contains(id); }

void Manager::registerMimeTypes()
{
    clear();
    QFuture<Core::MimeType> future =
            QtConcurrent::run(&Manager::gatherDefinitionsMimeTypes, this);
    m_mimeTypeWatcher.setFuture(future);
}

void Manager::gatherDefinitionsMimeTypes(QFutureInterface<Core::MimeType> &future)
{
    const HighlighterSettings &settings = TextEditorSettings::instance()->highlighterSettings();
    QDir definitionsDir(settings.definitionFilesPath());

    QStringList filter(QLatin1String("*.xml"));
    definitionsDir.setNameFilters(filter);

    const QFileInfoList &filesInfo = definitionsDir.entryInfoList();
    foreach (const QFileInfo &fileInfo, filesInfo) {
        const QSharedPointer<HighlightDefinitionMetaData> &metaData = parseMetadata(fileInfo);
        if (metaData.isNull())
            continue;

        const QString &id = fileInfo.absoluteFilePath();
        m_idByName.insert(metaData->name(), id);
        m_definitionsMetaData.insert(id, metaData);

        // A definition can specify multiple MIME types and file extensions/patterns. However, each
        // thing is done with a single string. Then, there is no direct way to tell which patterns
        // belong to which MIME types nor whether a MIME type is just an alias for the other.
        // Currently, I associate all expressions/patterns with all MIME types from a definition.

        static const QStringList textPlain(QLatin1String("text/plain"));

        QList<QRegExp> patterns;
        foreach (const QString &type, metaData->mimeTypes()) {
            m_idByMimeType.insert(type, id);
            Core::MimeType mimeType = Core::ICore::instance()->mimeDatabase()->findByType(type);
            if (mimeType.isNull()) {
                if (patterns.isEmpty()) {
                    foreach (const QString &pattern, metaData->patterns())
                        patterns.append(QRegExp(pattern, Qt::CaseSensitive, QRegExp::Wildcard));
                }

                mimeType.setType(type);
                mimeType.setSubClassesOf(textPlain);
                mimeType.setComment(metaData->name());
                mimeType.setGlobPatterns(patterns);

                future.reportResult(mimeType);
            }
        }
    }
}

void Manager::registerMimeType(int index) const
{
    const Core::MimeType &mimeType = m_mimeTypeWatcher.resultAt(index);
    TextEditorPlugin::instance()->editorFactory()->addMimeType(mimeType.type());
    Core::ICore::instance()->mimeDatabase()->addMimeType(mimeType);
}

QSharedPointer<HighlightDefinitionMetaData> Manager::parseMetadata(const QFileInfo &fileInfo)
{
    static const QLatin1Char kSemiColon(';');
    static const QLatin1Char kSlash('/');
    static const QLatin1String kLanguage("language");
    static const QLatin1String kArtificial("artificial");

    QFile definitionFile(fileInfo.absoluteFilePath());
    if (!definitionFile.open(QIODevice::ReadOnly | QIODevice::Text))
        return QSharedPointer<HighlightDefinitionMetaData>();

    QSharedPointer<HighlightDefinitionMetaData> metaData(new HighlightDefinitionMetaData);

    QXmlStreamReader reader(&definitionFile);
    while (!reader.atEnd() && !reader.hasError()) {
        if (reader.readNext() == QXmlStreamReader::StartElement &&
            reader.name() == kLanguage) {
            const QXmlStreamAttributes &atts = reader.attributes();

            metaData->setName(atts.value(HighlightDefinitionMetaData::kName).toString());
            metaData->setVersion(atts.value(HighlightDefinitionMetaData::kVersion).toString());
            metaData->setPatterns(atts.value(HighlightDefinitionMetaData::kExtensions).
                                  toString().split(kSemiColon, QString::SkipEmptyParts));

            QStringList mimeTypes = atts.value(HighlightDefinitionMetaData::kMimeType).
                                    toString().split(kSemiColon, QString::SkipEmptyParts);
            if (mimeTypes.isEmpty()) {
                // There are definitions which do not specify a MIME type, but specify file
                // patterns. Creating an artificial MIME type is a workaround.
                QString artificialType(kArtificial);
                artificialType.append(kSlash).append(metaData->name());
                mimeTypes.append(artificialType);
            }
            metaData->setMimeTypes(mimeTypes);

            break;
        }
    }
    reader.clear();
    definitionFile.close();

    return metaData;
}

QList<HighlightDefinitionMetaData> Manager::parseAvailableDefinitionsList(QIODevice *device) const
{
    static const QLatin1String kDefinition("Definition");

    QList<HighlightDefinitionMetaData> metaDataList;
    QXmlStreamReader reader(device);
    while (!reader.atEnd() && !reader.hasError()) {
        if (reader.readNext() == QXmlStreamReader::StartElement &&
            reader.name() == kDefinition) {
            const QXmlStreamAttributes &atts = reader.attributes();

            HighlightDefinitionMetaData metaData;
            metaData.setName(atts.value(HighlightDefinitionMetaData::kName).toString());
            metaData.setUrl(QUrl(atts.value(HighlightDefinitionMetaData::kUrl).toString()));
            metaData.setVersion(atts.value(HighlightDefinitionMetaData::kVersion).toString());

            metaDataList.append(metaData);
        }
    }
    reader.clear();

    return metaDataList;
}

void Manager::downloadAvailableDefinitionsMetaData()
{
    QUrl url(QLatin1String("http://www.kate-editor.org/syntax/update-3.2.xml"));
    QNetworkRequest request(url);
    // Currently this takes a couple of seconds on Windows 7: QTBUG-10106.
    QNetworkReply *reply = m_networkManager.get(request);
    connect(reply, SIGNAL(finished()), this, SLOT(downloadAvailableDefinitionsListFinished()));
}

void Manager::downloadAvailableDefinitionsListFinished()
{
    if (QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender())) {
        if (reply->error() == QNetworkReply::NoError)
            emit definitionsMetaDataReady(parseAvailableDefinitionsList(reply));
        else
            emit errorDownloadingDefinitionsMetaData();
        reply->deleteLater();
    }
}

void Manager::downloadDefinitions(const QList<QUrl> &urls)
{
    const QString &savePath =
        TextEditorSettings::instance()->highlighterSettings().definitionFilesPath() +
        QLatin1Char('/');

    m_downloaders.clear();
    foreach (const QUrl &url, urls)
        m_downloaders.append(new DefinitionDownloader(url, savePath));

    m_downloadingDefinitions = true;
    QFuture<void> future = QtConcurrent::map(m_downloaders, DownloaderStarter());
    m_downloadWatcher.setFuture(future);
    Core::ICore::instance()->progressManager()->addTask(future,
                                                        tr("Downloading definitions"),
                                                        Constants::TASK_DOWNLOAD);
}

void Manager::downloadDefinitionsFinished()
{
    foreach (DefinitionDownloader *downloader, m_downloaders)
        delete downloader;

    registerMimeTypes();
    m_downloadingDefinitions = false;
}

bool Manager::isDownloadingDefinitions() const
{
    return m_downloadingDefinitions;
}

void Manager::showGenericHighlighterOptions() const
{
    Core::ICore::instance()->showOptionsDialog(Constants::TEXT_EDITOR_SETTINGS_CATEGORY,
                                               Constants::TEXT_EDITOR_HIGHLIGHTER_SETTINGS);
}

void Manager::clear()
{
    m_idByName.clear();
    m_idByMimeType.clear();
    m_definitions.clear();
    m_definitionsMetaData.clear();
}