comparison import/Import.cpp @ 5:d23a4c935a22 classical-rdf

* Update CMN and mbz mappings for new classical archives import

     nr.replace("(II)", "II");
     nr.replace("(III)", "III");
     c->addAlias(nr);
 }
 
+QString makeNameKey(QString name)
+{
+    QString key = name.toLower()
+        .replace("'", "")
+        .replace("x", "ks")
+        .replace("y", "i")
+        .replace("k", "c")
+        .replace("ch", "c")
+        .replace("cc", "c")
+        .replace("v", "f")
+        .replace("ff", "f")
+        .replace("th", "t")
+        .replace("tch", "ch")
+        .replace("er", "r");
+//    DEBUG << "makeNameKey(" << name << "): " << key << endl;
+    return key;
+}
+
 bool namesFuzzyMatch(QString an, Composer *b)
 {
     // ew!
 
     QString bn = b->name();

         bn.replace(",", "");
     } else {
         bSurnameIndex = -1;
     }
     QStringList nl = an.split(QRegExp("[ -]"));
-    QStringList bnl = bn.split(QRegExp("[ -]"));
+    QStringList bnl = makeNameKey(bn).split(QRegExp("[ -]"));
     int matchCount = 0;
     QString surnameMatch = "";
     if (aSurnameIndex == -1) aSurnameIndex = nl.size()-1;
     if (bSurnameIndex == -1) bSurnameIndex = bnl.size()-1;
     if (nl[aSurnameIndex][0].isUpper() &&
         nl[aSurnameIndex] != "Della" &&
-        nl[aSurnameIndex] == bnl[bSurnameIndex]) {
+        makeNameKey(nl[aSurnameIndex]) == bnl[bSurnameIndex]) {
         surnameMatch = nl[aSurnameIndex];
     }
+    int tested = 0;
     foreach (QString elt, nl) {
         if (!elt[0].isUpper() || elt == "Della") continue;
-        if (bnl.contains(elt)) {
+        QString k = makeNameKey(elt);
+        if (bnl.contains(k)) {
             ++matchCount;
-            continue;
-        }
-    }
-    if (matchCount > 1 && surnameMatch != "") {
+        }
+        if (++tested == 2 && matchCount == 0) {
+            return false;
+        }
+    }
+    if (surnameMatch != "") {
         DEBUG << "namesFuzzyMatch: note: surnameMatch = " << surnameMatch << endl;
-        return true;
+        if (matchCount > 1) {
+            return true;
+        } else {
+            DEBUG << "(but not enough else matched)" << endl;
+            return false;
+        }
     }
     return false;
 }
 
 bool

     }
 
     QSet<Composer *> matches;
 
     foreach (QString candidateName, allNames) {
-        QString key = candidateName.toLower();
+        QString key = makeNameKey(candidateName);
         if (composers.contains(key)) {
             foreach (Composer *candidate, composers[key]) {
                 if (candidateName == dates) {
-                    if (!namesFuzzyMatch(c->name(), candidate) &&
-                        !namesFuzzyMatch(candidate->name(), c)) {
+                    if (c->name() == candidate->name()) {
+                        DEBUG << "mergeComposer: Exact name match for " << c->name() << " with date(s) " << dates << endl;
+                    } else if (!namesFuzzyMatch(c->name(), candidate) &&
+                               !namesFuzzyMatch(candidate->name(), c)) {
                         DEBUG << "mergeComposer: Names differ for " << c->name() << " and " << candidate->name() << " (having matched date(s) " << dates << ")" << endl;
                         continue;
                     } else {
                         DEBUG << "mergeComposer: Note: Fuzzy name match for " << c->name() << " and " << candidate->name() << " with date(s) " << dates << endl;
                     }

 
     if (matches.empty()) {
         DEBUG << "mergeComposer: No existing composer with alias matching any alias of " << c->name() << ", adding" << endl;
 
         if (!c->birth() && !c->death()) {
+            DEBUG << "Composer has no dates, laboriously searching for all names" << endl;
             // laboriously look for fuzzy match across _all_ composers
             for (ComposerMap::iterator i = composers.begin();
                  i != composers.end(); ++i) {
                 foreach (Composer *candidate, *i) {
                     if (namesFuzzyMatch(c->name(), candidate)) {

             }
         }
 
         if (matches.empty()) {
             foreach (QString candidateName, allNames) {
-                composers[candidateName.toLower()].insert(c);
+                QString key = makeNameKey(candidateName);
+                composers[key].insert(c);
                 DEBUG << "added for alias or date " << candidateName << endl;
             }
             return;
         }
     }

         other->addAlias(other->name());
         other->setName(c->name());
     } else {
         other->addAlias(c->name());
     }
-    composers[c->name().toLower()].insert(other);
+    composers[makeNameKey(c->name())].insert(other);
     DEBUG << "linking from alias " << c->name() << endl;
 
     foreach (QString alias, c->aliases()) {
         if (alias != other->name() && 
             !other->aliases().contains(alias)) {
             other->addAlias(alias);
-            composers[alias.toLower()].insert(other);
+            composers[makeNameKey(alias)].insert(other);
             DEBUG << "linking from alias " << alias << endl;
         }
     }
     
     foreach (Document *d, c->pages()) {

     foreach (Work *w, works) {
         Composition *cn = w->composition();
         if (!cn) continue;
         if (!cn->composer()) {
             QString cname = cn->composerName();
+            QString key = makeNameKey(cname);
             if (cname != "") {
-                if (!composers.contains(cname.toLower())) {
+                if (!composers.contains(key)) {
                     DEBUG << "Failed to assign Composition to composer: no composer matches name " << cname << endl;
                 } else {
-                    QSet<Composer *> cs = composers[cname.toLower()];
+                    QSet<Composer *> cs = composers[key];
                     if (cs.empty()) {
                         DEBUG << "Failed to assign Composition to composer: no composer matches name " << cname << endl;
                     } else if (cs.size() > 1) {
                         DEBUG << "Failed to assign Composition to composer: "
                               << cs.size() << " composers match name " << cname << endl;