This should be a space

[svn-all-fast-export.git] / src / ruleparser.cpp

diff --git a/src/ruleparser.cpp b/src/ruleparser.cpp
index c4c36afe694a265823093ddbcb8bd1aea3265127..0f675ddaa20e697721fec4d34b8366cd2aca8b28 100644 (file)
--- a/src/ruleparser.cpp
+++ b/src/ruleparser.cpp
@@ -26,6 +26,10 @@ Rules::Rules(const QString &fn)
 {
 }
 
+Rules::~Rules()
+{
+}
+
 QList<Rules::Repository> Rules::repositories()
 {
     return m_repositories;
@@ -43,69 +47,104 @@ void Rules::load()
         return;
 
     // initialize the regexps we will use
-    QRegExp repoLine("create repository\\s+(\\w+)", Qt::CaseInsensitive);
-    QRegExp repoBranchLine("branch\\s+(\\S+)\\s+from\\s+(\\S+)", Qt::CaseInsensitive);
+    QRegExp repoLine("create repository\\s+(\\S+)", Qt::CaseInsensitive);
+    QRegExp repoBranchLine("branch\\s+(\\S+)", Qt::CaseInsensitive);
+
     QRegExp matchLine("match\\s+(.*)", Qt::CaseInsensitive);
-    QRegExp matchRepoLine("repository\\s+(\\w+)", Qt::CaseInsensitive);
+    QRegExp matchActionLine("action\\s+(\\w+)", Qt::CaseInsensitive);
+    QRegExp matchRepoLine("repository\\s+(\\S+)", Qt::CaseInsensitive);
     QRegExp matchBranchLine("branch\\s+(\\S+)", Qt::CaseInsensitive);
-    QRegExp matchPathLine("path\\s+(.*)", Qt::CaseInsensitive);
+    QRegExp matchRevLine("(min|max) revision (\\d+)", Qt::CaseInsensitive);
 
     QTextStream s(&file);
     enum { ReadingNone, ReadingRepository, ReadingMatch } state = ReadingNone;
     Repository repo;
     Match match;
+    int lineNumber = 0;
     while (!s.atEnd()) {
+        ++lineNumber;
         QString origLine = s.readLine();
-        QString line = origLine.trimmed();
+        QString line = origLine;
 
         int hash = line.indexOf('#');
-        if (hash != -1) {
+        if (hash != -1)
             line.truncate(hash);
-            line = line.trimmed();
-        }
+        line = line.trimmed();
         if (line.isEmpty())
             continue;
 
         if (state == ReadingRepository) {
             if (repoBranchLine.exactMatch(line)) {
                 Repository::Branch branch;
-                branch.name = repoBranchLine.cap(0);
-                branch.branchFrom = repoBranchLine.cap(1);
+                branch.name = repoBranchLine.cap(1);
 
                 repo.branches += branch;
+                continue;
+            } else if (line == "end repository") {
+                m_repositories += repo;
+                state = ReadingNone;
+                continue;
             }
         } else if (state == ReadingMatch) {
-            if (matchRepoLine.exactMatch(line))
-                match.repository = matchRepoLine.cap(0);
-            else if (matchBranchLine.exactMatch(line))
-                match.branch = matchBranchLine.cap(0);
-            else if (matchPathLine.exactMatch(line))
-                match.path = matchPathLine.cap(0);
+            if (matchRepoLine.exactMatch(line)) {
+                match.repository = matchRepoLine.cap(1);
+                continue;
+            } else if (matchBranchLine.exactMatch(line)) {
+                match.branch = matchBranchLine.cap(1);
+                continue;
+            } else if (matchRevLine.exactMatch(line)) {
+                if (matchRevLine.cap(1) == "min")
+                    match.minRevision = matchRevLine.cap(2).toInt();
+                else            // must be max
+                    match.maxRevision = matchRevLine.cap(2).toInt();
+                continue;
+            } else if (matchActionLine.exactMatch(line)) {
+                QString action = matchActionLine.cap(1);
+                if (action == "export")
+                    match.action = Match::Export;
+                else if (action == "ignore")
+                    match.action = Match::Ignore;
+                else if (action == "recurse")
+                    match.action = Match::Recurse;
+                else
+                    qFatal("Invalid action \"%s\" on line %d", qPrintable(action), lineNumber);
+                continue;
+            } else if (line == "end match") {
+                if (!match.repository.isEmpty())
+                    match.action = Match::Export;
+                m_matchRules += match;
+                state = ReadingNone;
+                continue;
+            }
         }
 
         bool isRepositoryRule = repoLine.exactMatch(line);
         bool isMatchRule = matchLine.exactMatch(line);
-        if (isRepositoryRule || isMatchRule) {
-            // save the current rule
-            if (state == ReadingRepository)
-                m_repositories += repo;
-            else if (state == ReadingMatch)
-                m_matchRules += match;
-        }
 
         if (isRepositoryRule) {
             // repository rule
             state = ReadingRepository;
             repo = Repository(); // clear
-            repo.name = repoLine.cap(0);
+            repo.name = repoLine.cap(1);
+            repo.lineNumber = lineNumber;
         } else if (isMatchRule) {
             // match rule
             state = ReadingMatch;
             match = Match();
-            match.rx = QRegExp(matchLine.cap(0), Qt::CaseSensitive, QRegExp::RegExp2);
+            match.rx = QRegExp(matchLine.cap(1), Qt::CaseSensitive, QRegExp::RegExp2);
+            match.lineNumber = lineNumber;
         } else {
-            qWarning() << "Malformed line in configure file:" << origLine;
-            state = ReadingNone;
+            qFatal("Malformed line in rules file: line %d: %s",
+                   lineNumber, qPrintable(origLine));
         }
     }
 }
+
+#ifndef QT_NO_DEBUG_STREAM
+QDebug operator<<(QDebug s, const Rules::Match &rule)
+{
+    s.nospace() << rule.rx.pattern() << " (line " << rule.lineNumber << ")";
+    return s.space();
+}
+
+#endif