← Back to branch summary

~ubuntu-branches/ubuntu/natty/clementine/natty

« back to all changes in this revision

Viewing changes to tools/ultimate_lyrics_parser/main.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Artur Rona
  • Date: 2010-12-12 11:32:03 UTC
  • Revision ID: james.westby@ubuntu.com-20101212113203-oi0lbt5d9alzfjq7
Tags: upstream-0.6
Import upstream version 0.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/ultimate_lyrics_parser/main.cpp
 
1
/* This file is part of Clementine.
 
2
   Copyright 2010, David Sansome <me@davidsansome.com>
 
3
 
 
4
   Clementine is free software: you can redistribute it and/or modify
 
5
   it under the terms of the GNU General Public License as published by
 
6
   the Free Software Foundation, either version 3 of the License, or
 
7
   (at your option) any later version.
 
8
 
 
9
   Clementine is distributed in the hope that it will be useful,
 
10
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
   GNU General Public License for more details.
 
13
 
 
14
   You should have received a copy of the GNU General Public License
 
15
   along with Clementine.  If not, see <http://www.gnu.org/licenses/>.
 
16
*/
 
17
 
 
18
#include <QApplication>
 
19
#include <QFile>
 
20
#include <QWebFrame>
 
21
#include <QWebPage>
 
22
#include <QXmlStreamWriter>
 
23
#include <QtDebug>
 
24
 
 
25
int ShowUsage() {
 
26
  qWarning() << "Usage:" << qApp->arguments()[0].toUtf8().constData() << "sites.js\n";
 
27
  qWarning() << "This tool parses a sites.js file from the Ultimate Lyrics Amarok script";
 
28
  qWarning() << "and outputs an XML file that can be used by Clementine.";
 
29
  return 2;
 
30
}
 
31
 
 
32
void WriteRuleItem(QXmlStreamWriter& writer, const QVariant& value) {
 
33
  if (value.type() == QVariant::String) {
 
34
    writer.writeStartElement("item");
 
35
    writer.writeAttribute("tag", value.toString());
 
36
    writer.writeEndElement();
 
37
  } else if (value.type() == QVariant::List) {
 
38
    QVariantList list = value.toList();
 
39
    writer.writeStartElement("item");
 
40
    writer.writeAttribute("begin", list[0].toString());
 
41
    writer.writeAttribute("end", list[1].toString());
 
42
    writer.writeEndElement();
 
43
  }
 
44
}
 
45
 
 
46
void WriteRules(QXmlStreamWriter& writer, const QString& name, const QVariantMap& map) {
 
47
  for (int i=1 ; i<=4 ; ++i) {
 
48
    const QString map_name = name + (i == 1 ? "" : QString::number(i));
 
49
 
 
50
    if (!map.contains(map_name))
 
51
      continue;
 
52
 
 
53
    writer.writeStartElement(name);
 
54
 
 
55
    QVariant value = map[map_name];
 
56
    if (value.type() == QVariant::String) {
 
57
      WriteRuleItem(writer, value);
 
58
    } else if (value.type() == QVariant::List) {
 
59
      foreach (const QVariant& child, value.toList()) {
 
60
        WriteRuleItem(writer, child);
 
61
      }
 
62
    }
 
63
 
 
64
    writer.writeEndElement();
 
65
  }
 
66
}
 
67
 
 
68
void WriteList(QXmlStreamWriter& writer, const QString& name, const QVariantMap& map) {
 
69
  if (!map.contains(name))
 
70
    return;
 
71
 
 
72
  QVariant value = map[name];
 
73
  if (value.type() == QVariant::String) {
 
74
    writer.writeStartElement(name);
 
75
    writer.writeAttribute("value", value.toString());
 
76
    writer.writeEndElement();
 
77
  } else if (value.type() == QVariant::List) {
 
78
    foreach (const QVariant& child, value.toList()) {
 
79
      writer.writeStartElement(name);
 
80
      writer.writeAttribute("value", child.toString());
 
81
      writer.writeEndElement();
 
82
    }
 
83
  }
 
84
}
 
85
 
 
86
void WriteUrlFormat(QXmlStreamWriter& writer, const QVariantList& list) {
 
87
  foreach (const QVariant& child, list) {
 
88
    if (child.type() != QVariant::Map)
 
89
      continue;
 
90
    QVariantMap map = child.toMap();
 
91
    if (!map.contains("rep") || !map.contains("punct"))
 
92
      continue;
 
93
 
 
94
    writer.writeStartElement("urlFormat");
 
95
    writer.writeAttribute("replace", map["punct"].toString());
 
96
    writer.writeAttribute("with", map["rep"].toString());
 
97
    writer.writeEndElement();
 
98
  }
 
99
}
 
100
 
 
101
void WriteProvider(QXmlStreamWriter& writer, const QString& name, const QVariant& data) {
 
102
  QVariantMap map = data.toMap();
 
103
  if (!map.contains("url") || map.contains("getReply"))
 
104
    return;
 
105
 
 
106
  writer.writeStartElement("provider");
 
107
  writer.writeAttribute("name", name);
 
108
  writer.writeAttribute("title", map["title"].toString());
 
109
  writer.writeAttribute("charset", map["charset"].toString());
 
110
  writer.writeAttribute("url", map["url"].toString());
 
111
 
 
112
  WriteUrlFormat(writer, map["urlFormat"].toList());
 
113
 
 
114
  WriteRules(writer, "extract", map);
 
115
  WriteRules(writer, "exclude", map);
 
116
  WriteList(writer, "invalidIndicator", map);
 
117
 
 
118
  writer.writeEndElement();
 
119
}
 
120
 
 
121
int main(int argc, char** argv) {
 
122
  QApplication a(argc, argv);
 
123
 
 
124
  // Parse commandline arguments
 
125
  if (a.arguments().count() != 2)
 
126
    return ShowUsage();
 
127
 
 
128
  QString sites_filename = a.arguments()[1];
 
129
  if (!QFile::exists(sites_filename)) {
 
130
    qWarning() << "Error:" << sites_filename << "does not exist";
 
131
    return 1;
 
132
  }
 
133
 
 
134
  // Load the javascript file
 
135
  QFile sites_file(sites_filename);
 
136
  if (!sites_file.open(QIODevice::ReadOnly)) {
 
137
    qWarning() << "Error: could not open" << sites_filename;
 
138
    return 1;
 
139
  }
 
140
  QString javascript = QString::fromUtf8(sites_file.readAll());
 
141
  javascript = javascript.section("\n}", 0, 0, QString::SectionIncludeTrailingSep);
 
142
  javascript.append(";\n(siteDescriptors)");
 
143
 
 
144
  // Parse the javascript
 
145
  QWebPage page;
 
146
  QVariant data = page.mainFrame()->evaluateJavaScript(javascript);
 
147
 
 
148
  // Open the document
 
149
  QFile stdout(NULL);
 
150
  stdout.open(1, QIODevice::WriteOnly);
 
151
  QXmlStreamWriter writer(&stdout);
 
152
  writer.setAutoFormatting(true);
 
153
  writer.setAutoFormattingIndent(2);
 
154
 
 
155
  // Begin writing
 
156
  writer.writeStartDocument();
 
157
  writer.writeStartElement("lyricproviders");
 
158
 
 
159
  foreach (const QString& provider_name, data.toMap().keys()) {
 
160
    WriteProvider(writer, provider_name, data.toMap()[provider_name]);
 
161
  }
 
162
 
 
163
  writer.writeEndElement();
 
164
  writer.writeEndDocument();
 
165
 
 
166
  return 0;
 
167
}