[Bugfix:Plagiarism] Fix all versions bug (#72)

* Fix multiple versions bug

* add config.json

* fix course

* Add placeholder file

* FIx tests(?)

Author: williamjallen

bin/process_all.sh

@@ -85,9 +85,11 @@ mkdir -p "${BASEPATH}/users"
 
     ############################################################################
     # Run Lichen
-    ./tokenize_all.py    "$tmp_location" || { rm -rf "$tmp_location"; exit 1; }
-    ./hash_all.py        "$tmp_location" || { rm -rf "$tmp_location"; exit 1; }
-    ./compare_hashes.out "$tmp_location" || { rm -rf "$tmp_location"; echo "${KILL_ERROR_MESSAGE}"; exit 1; }
+    {  # We still want to unzip files if an error occurs when running Lichen here
+      ./tokenize_all.py    "$tmp_location" &&
+      ./hash_all.py        "$tmp_location" &&
+      ./compare_hashes.out "$tmp_location" || echo "${KILL_ERROR_MESSAGE}";
+    }
 
     ############################################################################
     # Zip the results back up and send them back to the course's lichen directory

compare_hashes/compare_hashes.cpp

@@ -157,8 +157,8 @@ int main(int argc, char* argv[]) {
   std::unordered_set<hash> provided_code;
   // stores all hashes from other gradeables
   std::unordered_map<hash, std::unordered_map<user_id, std::vector<HashLocation>>> other_gradeables;
-  // stores the highest match for every student, used later for generating overall_rankings.txt
-  std::unordered_map<user_id, std::pair<int, Score>> highest_matches;
+  // stores the matches for every student, used later for generating overall_rankings.txt
+  std::unordered_map<user_id, std::vector<std::pair<version_number, Score>>> highest_matches;
   // keeps track of max matching hashes across all submissions, used for calculation of ranking score
   unsigned int max_hashes_matched = 0;
 
@@ -283,7 +283,7 @@ int main(int argc, char* argv[]) {
         }
       }
 
-      // if the hash doesn't match any of the provided code's hashes, try to find matched between other students
+      // if the hash doesn't match any of the provided code's hashes, try to find matches between other students
       if (!provided_match_found) {
         // look up that hash in the all_hashes table, loop over all other students that have the same hash
         std::unordered_map<std::string, std::vector<HashLocation>> occurences = all_hashes[hash_itr->first];
@@ -333,23 +333,6 @@ int main(int argc, char* argv[]) {
       continue;
     }
 
-    // Save this submissions highest percent match for later when we generate overall_rankings.txt
-    float percentMatch = (*submission_itr)->getPercentage();
-    unsigned int totalMatchingHashes = (*submission_itr)->getMatchCount();
-    Score submission_score(totalMatchingHashes, percentMatch);
-    if (max_hashes_matched < totalMatchingHashes) {
-      max_hashes_matched = totalMatchingHashes;
-    }
-
-    std::unordered_map<user_id, std::pair<int, Score> >::iterator highest_matches_itr = highest_matches.find((*submission_itr)->student());
-    std::pair<int, Score> new_pair = {(*submission_itr)->version(), submission_score};
-    if (highest_matches_itr == highest_matches.end()) {
-      highest_matches.insert({(*submission_itr)->student(), new_pair});
-    }
-    else if (submission_score > highest_matches_itr->second.second) {
-      highest_matches_itr->second = new_pair;
-    }
-
     // =========================================================================
     // Write matches.json file
 
@@ -563,6 +546,19 @@ int main(int argc, char* argv[]) {
       }
     }
 
+    // =========================================================================
+    // Save this submission's highest percent match for later when we generate overall_rankings.txt
+    float percentMatch = (*submission_itr)->getPercentage();
+    unsigned int totalMatchingHashes = (*submission_itr)->getMatchCount();
+    Score submission_score(totalMatchingHashes, percentMatch);
+    if (max_hashes_matched < totalMatchingHashes) {
+      max_hashes_matched = totalMatchingHashes;
+    }
+    
+    std::pair<version_number, Score> new_pair = {(*submission_itr)->version(), submission_score};
+    highest_matches[(*submission_itr)->student()].push_back(new_pair);
+    // =========================================================================
+
     std::sort(student_ranking.begin(), student_ranking.end(), ranking_sorter);
 
     // create the directory and a file to write into
@@ -609,10 +605,18 @@ int main(int argc, char* argv[]) {
   // take the map of highest matches and convert it to a vector so we can sort it
   // by percent match and then save it to a file
   std::vector<StudentRanking> ranking;
-  for (std::unordered_map<user_id, std::pair<int, Score> >::iterator itr
+  for (std::unordered_map<user_id, std::vector<std::pair<version_number, Score>>>::iterator itr
         = highest_matches.begin(); itr != highest_matches.end(); ++itr) {
-    ranking.push_back(StudentRanking(itr->first, itr->second.first, "", itr->second.second));
-    ranking[ranking.size()-1].score.calculateScore(max_hashes_matched);
+
+    std::pair<version_number, Score> best_score = itr->second.front();
+    best_score.second.calculateScore(max_hashes_matched);
+    for (unsigned int i=0; i < itr->second.size(); i++) {
+      itr->second[i].second.calculateScore(max_hashes_matched);
+      if (itr->second[i].second > best_score.second) {
+        best_score = itr->second[i];
+      }
+    }
+    ranking.push_back(StudentRanking(itr->first, best_score.first, "", best_score.second));
   }
 
   std::sort(ranking.begin(), ranking.end(), ranking_sorter);

compare_hashes/score.h

@@ -2,6 +2,7 @@
 #define SCORE_H
 
 #include <cassert>
+#include <string>
 
 typedef int location_in_submission;
 typedef unsigned int hash;

tests/data/test_lichen/multiple_versions/expected_output/config.json

@@ -0,0 +1,18 @@
+{
+    "semester": "f21",
+    "course": "plagiarism",
+    "gradeable": "multiple_versions",
+    "config_id": 1,
+    "version": "all_versions",
+    "regex": [
+        ""
+    ],
+    "regex_dirs": [
+        "submissions"
+    ],
+    "language": "plaintext",
+    "threshold": 10,
+    "hash_size": 4,
+    "other_gradeables": [],
+    "ignore_submissions": []
+}

tests/data/test_lichen/multiple_versions/expected_output/logs/lichen_job_output.txt

@@ -0,0 +1,10 @@
+Beginning Lichen run: 2021-12-21 17:20:31
+CONCATENATE ALL...done in 0 seconds, 949 Bytes concatenated
+TOKENIZE ALL...done in 0 seconds
+HASH ALL...done in 0 seconds
+COMPARE HASHES...finished loading in 0 seconds
+hash walk: 33% complete
+hash walk: 66% complete
+hash walk: 100% complete
+finished walking in 0 seconds
+COMPARE HASHES done in 0 seconds

tests/data/test_lichen/multiple_versions/expected_output/other_gradeables/git_placeholder.txt

@@ -0,0 +1,2 @@
+aphacker              2    81.4%      35
+bitdiddle             1    81.4%      35