This commit groups the testImplementation and testRuntimeOnly
dependencies. It also depends on junit-jupiter-engine specifically at
test runtime, rather than all of junit-jupiter. This is the
configuration shown in the JUnit documentation.
Signed-off-by: Graham <gpe@openrs2.org>
Gradle seems to re-run this every time, so Drone ended up building the
KDoc twice (once in the build stage and again in the publish stage).
Removing it from the build stage ensures Drone only builds KDoc once.
Signed-off-by: Graham <gpe@openrs2.dev>
The output is significantly nicer.
External documentation links don't seem to work correctly at the moment,
so I have commented those out for now.
Signed-off-by: Graham <gpe@openrs2.dev>
This already caught some cases of public members that should have been
private and one case where the inferred type was too specific.
Signed-off-by: Graham <gpe@openrs2.dev>
Unfortunately we can't use the compiler to guarantee k isn't changed,
though making it internal will help. When the JVM (and Kotlin) get value
types, we might be able to improve on this (e.g. by making it an inline
class of four integers).
Signed-off-by: Graham <gpe@openrs2.dev>
This allows users to compile and run the deobfuscator's output without
access to the nonfree repository. It will be particularly useful when
the deobfuscator can make use of the deob-map files.
Signed-off-by: Graham <gpe@openrs2.dev>
I'm very keen on being able to use the jdk.jartool module (which is only
available in JDK11 onwards) as it allows us to avoid shelling out to
jarsigner entirely.
11 is the current LTS release and is already widespread in Linux
distributions, so I think it's reasonable to require it.
This commit removes the jsobject module. We might need to re-add it in
the future (if jdk.jsobject is removed from the JDK). However, it was
only necessary in 8 because modern versions of 8 tended to be
distributed without plugin.jar. JDK11 is distributed with the
jdk.jsobject module.
Signed-off-by: Graham <gpe@openrs2.dev>
I've been considering this for a long time, and have decided to switch to it at
the last minute before opening the repository up publicly. My reasons include:
* It's a much simpler license. GPL's complexity adds some risk - for example, it
might be incompatible with future open-source licenses (like the well-known
GPLv2/Apache v2 incompatibility problem). The "or any later version" clause
requires placing some trust in the Free Software Foundation.
* The simplicity makes it easier for people to understand and comply with the
license.
* Dishonest users who disobey the GPL would have an advantage over honest users
who refuse to do so. The ISC license provides a much more even playing field.
* OpenRS2 will primarily be server software accessible over a network. As such,
the GPL can do little to prevent use of the code in a proprietary system, as
the code is never distributed. (While the AGPL would fix this, I have already
discounted it. Enforcement would be too difficult and dishonest users would
have an unfair advantage.)
* It's much easier to switch to a stricter license in future versions, if it
turns out that is desirable (as the ISC license allows users to sublicense
the code). However, switching from the GPL to the ISC license requires all
copyright holders to grant permission.
* Other open-source projects in the community, such as Apollo, use the ISC
license and will be able to make use of OpenRS2 code if they so desire.
I've removed the FAQ entry about the reasons for using the GPL license, as I
think the ISC license is less controversial and therefore does not require an
entry.
I've discussed this with Desetude, and he's okay with his commit being
relicensed.
These might be added to the user's ~/gradle.properties file, at which
point having a per-project prefix is useful.
Ideally I'd have preferred to use openrs2.repo.{username,password}.
However, Gradle properties with dots in them can't be configured with
the ORG_GRADLE_PROJECT_* environment variables, which we use in the
Jenkinsfile.
