Clean up the compatibility helper js a bit

Author: timfel

docs/site/assets/js/check_compatibility_helpers.js

@@ -1,21 +1,7 @@
-class RequestedModule {
-    constructor(name, version) {
-        this.name = name;
-        this.version = Utilities.normalize_version(version);
-    }
-}
-
-class ModuleListing {
-    constructor(name, contents) {
-        this.name = name;
-        this.contents = contents;
-    }
-}
-
 class DBEntry {
     constructor(library_name, library_version, test_status, notes) {
         this.name = library_name;
-        this.version = Utilities.normalize_version(library_version);
+        this.version = library_version.replace(/^v(\d.*)/, '$1').replace(/ and /g, ", ");
         this.test_status = parseInt(test_status);
         this._notes = notes;
     }
@@ -60,259 +46,46 @@ class DB {
         this.language = language;
 
         const lines = db_contents.split('\n');
+        let any_versions = {}
 
-        for (let l in lines) {
-            if (!lines[l]) {
+        for (const line of lines) {
+            if (!line) {
                 continue;
             }
-            let [name, version, test_status, ...notes] = lines[l].split(',');
+            let [name, version, test_status, ...notes] = line.split(',');
             const entry = new DBEntry(name, version, test_status, notes.join(','));
 
-            if (!(entry.name in this.db)) {
-                this.db[entry.name] = {};
+            this.db[entry.name] ||= {};
+            this.db[entry.name][entry.version] = merge_entries(entry, this.db[entry.name][entry.version]);
+
+            if (entry.version == "any") {
+                any_versions[entry.name] = this.db[entry.name][entry.version];
             }
+        }
+
+        for (const name in any_versions) {
+            for (const version in this.db[name]) {
+                this.db[name][version] = merge_entries(any_versions[name], this.db[name][version]);
+            }
+        }
 
-            for (const v of [entry.version, Utilities.approximate_recommendation(entry.version)]) {
-                let previous_entry = this.db[entry.name][v];
-                if (previous_entry && !previous_entry.notes.includes(entry.notes)) {
+        function merge_entries(entry, previous_entry) {
+            if (previous_entry) {
+                if (!notes_overlap(previous_entry.notes, entry.notes)) {
                     if (previous_entry.is_test_percentage() && previous_entry.has_no_test_results()) {
                         previous_entry.notes = entry.notes;
                     } else {
                         previous_entry.notes = entry.notes + " " + previous_entry.notes;
                     }
-                } else {
-                    this.db[entry.name][v] = entry;
-                }
-            }
-        }
-    }
-
-    lookup(requested_name, requested_version, print_missing) {
-        const ret = [];
-
-        if (requested_name in this.db) {
-            if (requested_version === undefined) {
-                const versions = this.db[requested_name];
-                for (let version in versions) {
-                    if (!version.startsWith('~')) {
-                        const entry = versions[version];
-                        ret.push([entry.name, version, entry.test_status, entry.notes]);
-                    }
                 }
+                return previous_entry;
             } else {
-                if (requested_version in this.db[requested_name]) {
-                    const entry = this.db[requested_name][requested_version];
-                    ret.push([entry.name, entry.version, entry.test_status, entry.notes]);
-                } else {
-                    const semver_match = Utilities.approximate_recommendation(requested_version);
-                    if (semver_match in this.db[requested_name]) {
-                        const entry = this.db[requested_name][semver_match];
-                        ret.push([entry.name, entry.version, entry.test_status, entry.notes]);
-                    } else {
-                        ret.push([requested_name, requested_version, 'unknown', undefined]);
-                    }
-                }
-            }
-        } else {
-            if (print_missing) {
-                ret.push([requested_name, '*', 'library not yet tested', undefined]);
+                return entry;
             }
         }
 
-        // In the event of multiple versions for a module, sort the results from highest version to lowest.
-        ret.sort(function(a, b) {
-            return b[1].localeCompare(a[1]);
-        });
-
-        return ret;
-    }
-
-    lookup_module(module, print_missing) {
-        return this.lookup(module.name, module.version, print_missing);
-    }
-
-}
-
-class Utilities {
-    static normalize_version(version) {
-        if (version === undefined) {
-            return undefined;
-        } else {
-            return version.replace(/^v(\d.*)/, '$1').replace(/ and /g, ", ");
-        }
-    }
-
-    static version_segments(version) {
-        if (version === undefined) {
-            return undefined;
-        }
-
-        const string_parts = version.match(/[0-9]+|[a-z]+/ig);
-
-        // The result of the regexp match will be an array of strings. We would like to be
-        // able to perform numeric comparisons on the parts corresponding to integer values,
-        // so convert them here.
-        return string_parts.map(function(e) {
-            let x = parseInt(e);
-
-            if (isNaN(x)) {
-                return e;
-            } else {
-                return x;
-            }
-        });
-    }
-
-    static approximate_recommendation(version) {
-        if (version === undefined) {
-            return undefined;
-        }
-
-        const segments = this.version_segments(version);
-
-        while (segments.some(function(e) { typeof(e) === 'string' })) {
-            segments.pop();
-        }
-
-        while (segments.length > 2) {
-            segments.pop();
+        function notes_overlap(notes1, notes2) {
+            return notes1.replace(/<[^>]+>/, "").includes(notes2.replace(/<[^>]+>/, ""));
         }
-
-        while (segments.length < 2) {
-            segments.push(0);
-        }
-
-        return `~> ${segments.join('.')}`
     }
 }
-
-class DependencyFileProcessor {
-    static handle_gemfile(db, contents) {
-        if (db.language !== 'ruby') {
-            return [];
-        }
-
-        const r = /\n    (\S+?) \((.+?)\)/g;
-        let match;
-        const queries = [];
-
-        while (match = r.exec(contents)) {
-            queries.push(match.slice(1, 3));
-        }
-
-        queries.sort(function(a, b) {
-            return a[0].localeCompare(b[0]);
-        });
-
-        let results = [];
-        for (let [name, version] of queries) {
-            results = results.concat(db.lookup(name, version, true));
-        }
-
-        return results;
-    }
-
-    static handle_package_json(db, contents) {
-        if (db.language !== 'js') {
-            return [];
-        }
-
-        const json = JSON.parse(contents);
-        let queries = [];
-
-        for (let name in json['dependencies']) {
-            queries.push([name, undefined]);
-        }
-
-        let results = [];
-        for (let [name, version] of queries) {
-            results = results.concat(db.lookup(name, version, true));
-        }
-
-        return results;
-    }
-
-    static handle_package_lock(db, contents) {
-        if (db.language !== 'js') {
-            return [];
-        }
-
-        const json = JSON.parse(contents);
-        let queries = [[json['name'], json['version']]];
-
-        for (let name in json['dependencies']) {
-            let metadata = json['dependencies'][name];
-
-            if (metadata['dev'] || metadata['optional']) {
-                continue;
-            }
-
-            queries.push([name, metadata['version']]);
-        }
-
-        let results = [];
-        for (let [name, version] of queries) {
-            results = results.concat(db.lookup(name, version, true));
-        }
-
-        return results;
-    }
-
-    static handle_yarn_lock(db, contents) {
-        if (db.language != 'js') {
-            return [];
-        }
-
-        const r = /\n(\w.*?)@.+?:\s+?version "(.+?)"/g;
-        let match;
-        const queries = [];
-
-        while (match = r.exec(contents)) {
-            queries.push(match.slice(1, 3));
-        }
-
-        queries.sort(function(a, b) {
-            return a[0].localeCompare(b[0]);
-        });
-
-        let results = [];
-        for (let [name, version] of queries) {
-            results = results.concat(db.lookup(name, version, true));
-        }
-
-        return results;
-    }
-
-    static handle_packrat_lock(db, contents) {
-        if (db.language != 'r') {
-            return [];
-        }
-
-        const r = /\nPackage: (\w+)\nSource: (\w+)\nVersion: (.+?)\n/g;
-        let match;
-        const queries = [];
-
-        while (match = r.exec(contents)) {
-            queries.push(match.slice(1, 4));
-        }
-
-        queries.sort(function(a, b) {
-            return a[0].localeCompare(b[0]);
-        });
-
-        let results = [];
-        for (let [name, repository, version] of queries) {
-            results = results.concat(db.lookup(name, version, true));
-        }
-
-        return results;
-    }
-}
-
-if (typeof module !== 'undefined') {
-    module.exports.DB = DB;
-    module.exports.DependencyFileProcessor = DependencyFileProcessor;
-    module.exports.ModuleListing = ModuleListing;
-    module.exports.RequestedModule = RequestedModule;
-    module.exports.Utilities = Utilities;
-}