Actually implement the automatic main class finding for Java solutions

[EmilGedda]

Perhaps some crude regex-solution?
Should be fairly easy, does not need to be 100% correct all the time.

[EmilGedda]

This is how kattis.com does it:

extractMainFromPascal: function(a, b) {
        return /^\s*[Pp]rogram\b/.test(b) ? a : null
    },
    extractMainFromJava: function(a, b) {
        if (!/ main\s*\(/.test(b))
            return null;
        if (-1 === b.indexOf("class " + a)) {
            var c = b.match(/\bclass\s*(\w+)/);
            a = c ? c[1] : a
        }
        c = b.match(/(?:\n|^)package +([\w.]+) *;/);
        return (c ? c[1] + "." : "") + a
    },
    extractMainFromScala: function(a, b) {
        if (!/ main\s*\(/.test(b))
            return null;
        if (-1 === b.indexOf("class " + a) && -1 === b.indexOf("object " + a)) {
            var c = b.match(/\b(?:class|object)\s*(\w+)/);
            a = c ? c[1] : a
        }
        c = b.match(/(?:\n|^)package +([\w.]+)/);
        return (c ? c[1] + "." : "") + a
    },
    extractMainFromKotlin: function(a, b) {
        if (!/\bfun\s+main\s*\(/.test(b))
            return null;
        var c = b.match(/(?:\n|^)package +([\w.]+)/);
        return (c ? c[1] + "." : "") + a
    },
    guessMain: function(a, b, c, d, e, f) {
        for (var g = 0; g < a.length; g++)
            if (/^[Mm]ain\.\w+$/.test(a[g].name) && this.languageFromExtension(b[g], b) == c) {
                f(e(a[g].name));
                return
            }
        var h = 0
          , m = function() {
            if (h >= a.length)
                f("");
            else {
                var g = a[h]
                  , k = g.name.split(".").reverse()[0] || "";
                h++;
                this.languageFromExtension(k, b) !== c ? m() : this.readFile(g, {
                    success: function(a) {
                        (a = d(e(g.name), a)) ? f(a) : m()
                    },
                    failure: m,
                    scope: this
                })
            }
        }
        .bind(this);
        m()
    },

[simonlindholm]

Here's the unminified version of that, if that helps (I wrote most of it):

    extractMainFromPascal: function (name, data) {
        return /^\s*[Pp]rogram\b/.test(data) ? name : null;
    },

    extractMainFromRust: function (name, data) {
        return /\bfn main\(\)/.test(data) ? name : null;
    },

    extractMainFromJava: function (name, data) {
        if (!/ main\s*\(/.test(data)) {
            return null;
        }

        if (data.indexOf("class " + name) === -1) {
            var m = data.match(/\bclass\s*(\w+)/);
            name = m ? m[1] : name;
        }

        var m = data.match(/(?:\n|^)package +([\w.]+) *;/);
        return (m ? m[1] + "." : "") + name;
    },

    extractMainFromScala: function (name, data) {
        if (!/ main\s*\(/.test(data)) {
            return null;
        }

        if (data.indexOf("class " + name) === -1 &&
                data.indexOf("object " + name) === -1) {
            var m = data.match(/\b(?:class|object)\s*(\w+)/);
            name = m ? m[1] : name;
        }

        // FIXME -- Scala packaging is more complicated than Java
        // packaging. Packages in Scala can be nested, e.g.
        //      package foo { package bar { package baz { class Foo {} } } }
        // This code only identifies a limited type of Scala packaging.
        var m = data.match(/(?:\n|^)package +([\w.]+)/);
        return (m ? m[1] + "." : "") + name;
    },

    extractMainFromKotlin: function (name, data) {
        if (!/\bfun\s+main\s*\(/.test(data)) {
            return null;
        }

        var m = data.match(/(?:\n|^)package +([\w.]+)/);
        return (m ? m[1] + "." : "") + name;
    },

    guessMain: function (files, exts, lang, extractMain, fileNameToClass, done) {
        // For problemtools compliance, first check for Main.<ext>.
        for (var i = 0; i < files.length; i++) {
            if (/^[Mm]ain\.\w+$/.test(files[i].name) &&
                    this.languageFromExtension(exts[i], exts) == lang) {
                done(fileNameToClass(files[i].name));
                return;
            }
        }

        var index = 0;
        var next = function () {
            if (index >= files.length) {
                done("");
            } else {
                var file = files[index],
                    ext = file.name.split(".").reverse()[0] || '';
                index++;

                if (this.languageFromExtension(ext, exts) !== lang) {
                    next();
                    return;
                }

                this.readFile(file, {
                    success: function (data) {
                        var main = extractMain(fileNameToClass(file.name), data);
                        if (main) {
                            done(main);
                        } else {
                            next();
                        }
                    },
                    failure: next,
                    scope: this
                });
            }
        }.bind(this);
        next();
    },

    guessLanguage: function (files, done) {
        var len = (files ? files.length : 0),
            exts = [];

        for (var i = 0; i < len; i++) {
            exts.push(files[i].name.split(".").reverse()[0] || '');
        }

        function basename (filename) {
            return filename.split(".").slice(0, -1).join(".");
        }

        function kotlinBasename (filename) {
            var name = basename(filename);
            return name.charAt(0).toUpperCase() + name.slice(1) + 'Kt';
        }

        function id (x) {
            return x;
        }

        for (var i = 0; i < len; i++) {
            var file = files[i],
                ext = exts[i],
                lang = this.languageFromExtension(ext, exts),
                doneMain = done.bind(null, lang);

            if (lang === "Java") {
                this.guessMain(files, exts, lang,
                    this.extractMainFromJava, basename, doneMain);
                return;
            } else if (lang === "Scala") {
                this.guessMain(files, exts, lang,
                    this.extractMainFromScala, basename, doneMain);
                return;
            } else if (lang === "Kotlin") {
                this.guessMain(files, exts, lang,
                    this.extractMainFromKotlin, kotlinBasename, doneMain);
                return;
            } else if (lang === "Rust") {
                this.guessMain(files, exts, lang,
                    this.extractMainFromRust, id, doneMain);
                return;
            } else if (lang === "Pascal") {
                this.guessMain(files, exts, lang,
                    this.extractMainFromPascal, id, doneMain);
                return;
            } else if (lang !== null) {
                done(lang);
                return;
            } else if (ext === "py") {
                this.guessPython(file, done);
                return;
            }
        }

        done();
    },

https://github.com/Kattis/kattis-cli/blob/master/submit.py also includes some logic for this (much simpler than the above).