Clementine-audio-player-Mac.../src/songinfo/ultimatelyricsprovider.cpp

271 lines
8.1 KiB
C++

/* This file is part of Clementine.
Copyright 2010, David Sansome <me@davidsansome.com>
Clementine is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Clementine is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Clementine. If not, see <http://www.gnu.org/licenses/>.
*/
#include "songinfotextview.h"
#include "ultimatelyricsprovider.h"
#include "core/logging.h"
#include "core/network.h"
#include <QNetworkReply>
#include <QTextCodec>
#include <boost/scoped_ptr.hpp>
const int UltimateLyricsProvider::kRedirectLimit = 5;
UltimateLyricsProvider::UltimateLyricsProvider()
: network_(new NetworkAccessManager(this)),
relevance_(0),
redirect_count_(0)
{
}
void UltimateLyricsProvider::FetchInfo(int id, const Song& metadata) {
// Get the text codec
const QTextCodec* codec = QTextCodec::codecForName(charset_.toAscii().constData());
if (!codec) {
qLog(Warning) << "Invalid codec" << charset_;
emit Finished(id);
return;
}
// Fill in fields in the URL
QString url_text(url_);
ReplaceFields(metadata, &url_text);
QUrl url(url_text);
qLog(Debug) << "Fetching lyrics from" << url;
// Fetch the URL, follow redirects
metadata_ = metadata;
redirect_count_ = 0;
QNetworkReply* reply = network_->get(QNetworkRequest(url));
requests_[reply] = id;
connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
}
void UltimateLyricsProvider::LyricsFetched() {
QNetworkReply* reply = qobject_cast<QNetworkReply*>(sender());
if (!reply)
return;
int id = requests_.take(reply);
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
emit Finished(id);
return;
}
// Handle redirects
QVariant redirect_target = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);
if (redirect_target.isValid()) {
if (redirect_count_ >= kRedirectLimit) {
emit Finished(id);
return;
}
QUrl target = redirect_target.toUrl();
if (target.scheme().isEmpty() || target.host().isEmpty()) {
QString path = target.path();
target = reply->url();
target.setPath(path);
}
redirect_count_ ++;
QNetworkReply* reply = network_->get(QNetworkRequest(target));
requests_[reply] = id;
connect(reply, SIGNAL(finished()), SLOT(LyricsFetched()));
return;
}
const QTextCodec* codec = QTextCodec::codecForName(charset_.toAscii().constData());
const QString original_content = codec->toUnicode(reply->readAll());
QString lyrics;
// Check for invalid indicators
foreach (const QString& indicator, invalid_indicators_) {
if (original_content.contains(indicator)) {
qLog(Debug) << "Found invalid indicator" << indicator;
emit Finished(id);
return;
}
}
// Apply extract rules
foreach (const Rule& rule, extract_rules_) {
// Modify the rule for this request's metadata
Rule rule_copy(rule);
for (Rule::iterator it = rule_copy.begin() ; it != rule_copy.end() ; ++it) {
ReplaceFields(metadata_, &it->first);
}
QString content = original_content;
ApplyExtractRule(rule_copy, &content);
qLog(Debug) << "Extract rule" << rule_copy << "matched" << content.length();
if (!content.isEmpty()) {
lyrics = content;
break;
}
}
// Apply exclude rules
foreach (const Rule& rule, exclude_rules_) {
ApplyExcludeRule(rule, &lyrics);
}
if (!lyrics.isEmpty()) {
CollapsibleInfoPane::Data data;
data.id_ = "ultimatelyrics/" + name_;
data.title_ = tr("Lyrics from %1").arg(name_);
data.type_ = CollapsibleInfoPane::Data::Type_Lyrics;
data.relevance_ = relevance();
SongInfoTextView* editor = new SongInfoTextView;
editor->SetHtml(lyrics);
data.contents_ = editor;
emit InfoReady(id, data);
}
emit Finished(id);
}
void UltimateLyricsProvider::ApplyExtractRule(const Rule& rule, QString* content) const {
foreach (const RuleItem& item, rule) {
if (item.second.isNull()) {
*content = ExtractXmlTag(*content, item.first);
} else {
*content = Extract(*content, item.first, item.second);
}
}
}
QString UltimateLyricsProvider::ExtractXmlTag(const QString& source, const QString& tag) {
QRegExp re("<(\\w+).*>"); // ಠ_ಠ
if (re.indexIn(tag) == -1)
return QString();
return Extract(source, tag, "</" + re.cap(1) + ">");
}
QString UltimateLyricsProvider::Extract(const QString& source, const QString& begin, const QString& end) {
int begin_idx = source.indexOf(begin);
if (begin_idx == -1)
return QString();
begin_idx += begin.length();
int end_idx = source.indexOf(end, begin_idx);
if (end_idx == -1)
return QString();
return source.mid(begin_idx, end_idx - begin_idx - 1);
}
void UltimateLyricsProvider::ApplyExcludeRule(const Rule& rule, QString* content) const {
foreach (const RuleItem& item, rule) {
if (item.second.isNull()) {
*content = ExcludeXmlTag(*content, item.first);
} else {
*content = Exclude(*content, item.first, item.second);
}
}
}
QString UltimateLyricsProvider::ExcludeXmlTag(const QString& source, const QString& tag) {
QRegExp re("<(\\w+).*>"); // ಠ_ಠ
if (re.indexIn(tag) == -1)
return source;
return Exclude(source, tag, "</" + re.cap(1) + ">");
}
QString UltimateLyricsProvider::Exclude(const QString& source, const QString& begin, const QString& end) {
int begin_idx = source.indexOf(begin);
if (begin_idx == -1)
return source;
int end_idx = source.indexOf(end, begin_idx + begin.length());
if (end_idx == -1)
return source;
return source.left(begin_idx) + source.right(source.length() - end_idx - end.length());
}
QString UltimateLyricsProvider::FirstChar(const QString& text) {
if (text.isEmpty())
return QString();
return text[0].toLower();
}
QString UltimateLyricsProvider::TitleCase(const QString& text) {
if (text.length() == 0)
return QString();
QString ret = text;
bool last_was_space = true;
for (QString::iterator it = ret.begin() ; it != ret.end() ; ++it) {
if (last_was_space) {
*it = it->toUpper();
last_was_space = false;
} else if (it->isSpace()) {
last_was_space = true;
}
}
return ret;
}
void UltimateLyricsProvider::ReplaceField(const QString& tag, const QString& value,
QString* text) const {
if (!text->contains(tag))
return;
// Apply URL character replacement
QString value_copy(value);
foreach (const UrlFormat& format, url_formats_) {
QRegExp re("[" + QRegExp::escape(format.first) + "]");
value_copy.replace(re, format.second);
}
text->replace(tag, value_copy, Qt::CaseInsensitive);
}
void UltimateLyricsProvider::ReplaceFields(const Song& metadata, QString* text) const {
ReplaceField("{artist}", metadata.artist().toLower(), text);
ReplaceField("{artist2}",NoSpace(metadata.artist().toLower()), text);
ReplaceField("{album}", metadata.album().toLower(), text);
ReplaceField("{album2}", NoSpace(metadata.album().toLower()), text);
ReplaceField("{title}", metadata.title().toLower(), text);
ReplaceField("{Artist}", metadata.artist(), text);
ReplaceField("{Album}", metadata.album(), text);
ReplaceField("{ARTIST}", metadata.artist().toUpper(), text);
ReplaceField("{year}", metadata.PrettyYear(), text);
ReplaceField("{Title}", metadata.title(), text);
ReplaceField("{Title2}", TitleCase(metadata.title()), text);
ReplaceField("{a}", FirstChar(metadata.artist()), text);
ReplaceField("{track}", QString::number(metadata.track()), text);
}
QString UltimateLyricsProvider::NoSpace(const QString& text) {
QString ret(text);
ret.remove(' ');
return ret;
}