First working commit
This commit is contained in:
44
.gitignore
vendored
Normal file
44
.gitignore
vendored
Normal file
@@ -0,0 +1,44 @@
|
||||
.gradle
|
||||
build/
|
||||
!gradle/wrapper/gradle-wrapper.jar
|
||||
!**/src/main/**/build/
|
||||
!**/src/test/**/build/
|
||||
|
||||
### IntelliJ IDEA ###
|
||||
.idea/modules.xml
|
||||
.idea/jarRepositories.xml
|
||||
.idea/compiler.xml
|
||||
.idea/libraries/
|
||||
*.iws
|
||||
*.iml
|
||||
*.ipr
|
||||
out/
|
||||
!**/src/main/**/out/
|
||||
!**/src/test/**/out/
|
||||
|
||||
### Eclipse ###
|
||||
.apt_generated
|
||||
.classpath
|
||||
.factorypath
|
||||
.project
|
||||
.settings
|
||||
.springBeans
|
||||
.sts4-cache
|
||||
bin/
|
||||
!**/src/main/**/bin/
|
||||
!**/src/test/**/bin/
|
||||
|
||||
### NetBeans ###
|
||||
/nbproject/private/
|
||||
/nbbuild/
|
||||
/dist/
|
||||
/nbdist/
|
||||
/.nb-gradle/
|
||||
|
||||
### VS Code ###
|
||||
.vscode/
|
||||
|
||||
### Mac OS ###
|
||||
.DS_Store
|
||||
|
||||
.idea
|
||||
9
HEADER
Normal file
9
HEADER
Normal file
@@ -0,0 +1,9 @@
|
||||
/*
|
||||
* This file is part of ModFusioner, licensed under the GNU Lesser General Public License v2.1.
|
||||
*
|
||||
* This project is based on, and contains code from https://github.com/PacifistMC/Forgix, licensed under the same license.
|
||||
* See their license here: https://github.com/PacifistMC/Forgix/blob/main/LICENSE
|
||||
*
|
||||
* Copyright HypherionSA and Contributors
|
||||
* Forgix Code Copyright by their contributors and Ran-Mewo
|
||||
*/
|
||||
458
LICENSE
Normal file
458
LICENSE
Normal file
@@ -0,0 +1,458 @@
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 2.1, February 1999
|
||||
|
||||
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
|
||||
[This is the first released version of the Lesser GPL. It also counts
|
||||
as the successor of the GNU Library Public License, version 2, hence
|
||||
the version number 2.1.]
|
||||
|
||||
Preamble
|
||||
|
||||
The licenses for most software are designed to take away your
|
||||
freedom to share and change it. By contrast, the GNU General Public
|
||||
Licenses are intended to guarantee your freedom to share and change
|
||||
free software--to make sure the software is free for all its users.
|
||||
|
||||
This license, the Lesser General Public License, applies to some
|
||||
specially designated software packages--typically libraries--of the
|
||||
Free Software Foundation and other authors who decide to use it. You
|
||||
can use it too, but we suggest you first think carefully about whether
|
||||
this license or the ordinary General Public License is the better
|
||||
strategy to use in any particular case, based on the explanations below.
|
||||
|
||||
When we speak of free software, we are referring to freedom of use,
|
||||
not price. Our General Public Licenses are designed to make sure that
|
||||
you have the freedom to distribute copies of free software (and charge
|
||||
for this service if you wish); that you receive source code or can get
|
||||
it if you want it; that you can change the software and use pieces of
|
||||
it in new free programs; and that you are informed that you can do
|
||||
these things.
|
||||
|
||||
To protect your rights, we need to make restrictions that forbid
|
||||
distributors to deny you these rights or to ask you to surrender these
|
||||
rights. These restrictions translate to certain responsibilities for
|
||||
you if you distribute copies of the library or if you modify it.
|
||||
|
||||
For example, if you distribute copies of the library, whether gratis
|
||||
or for a fee, you must give the recipients all the rights that we gave
|
||||
you. You must make sure that they, too, receive or can get the source
|
||||
code. If you link other code with the library, you must provide
|
||||
complete object files to the recipients, so that they can relink them
|
||||
with the library after making changes to the library and recompiling
|
||||
it. And you must show them these terms so they know their rights.
|
||||
|
||||
We protect your rights with a two-step method: (1) we copyright the
|
||||
library, and (2) we offer you this license, which gives you legal
|
||||
permission to copy, distribute and/or modify the library.
|
||||
|
||||
To protect each distributor, we want to make it very clear that
|
||||
there is no warranty for the free library. Also, if the library is
|
||||
modified by someone else and passed on, the recipients should know
|
||||
that what they have is not the original version, so that the original
|
||||
author's reputation will not be affected by problems that might be
|
||||
introduced by others.
|
||||
|
||||
Finally, software patents pose a constant threat to the existence of
|
||||
any free program. We wish to make sure that a company cannot
|
||||
effectively restrict the users of a free program by obtaining a
|
||||
restrictive license from a patent holder. Therefore, we insist that
|
||||
any patent license obtained for a version of the library must be
|
||||
consistent with the full freedom of use specified in this license.
|
||||
|
||||
Most GNU software, including some libraries, is covered by the
|
||||
ordinary GNU General Public License. This license, the GNU Lesser
|
||||
General Public License, applies to certain designated libraries, and
|
||||
is quite different from the ordinary General Public License. We use
|
||||
this license for certain libraries in order to permit linking those
|
||||
libraries into non-free programs.
|
||||
|
||||
When a program is linked with a library, whether statically or using
|
||||
a shared library, the combination of the two is legally speaking a
|
||||
combined work, a derivative of the original library. The ordinary
|
||||
General Public License therefore permits such linking only if the
|
||||
entire combination fits its criteria of freedom. The Lesser General
|
||||
Public License permits more lax criteria for linking other code with
|
||||
the library.
|
||||
|
||||
We call this license the "Lesser" General Public License because it
|
||||
does Less to protect the user's freedom than the ordinary General
|
||||
Public License. It also provides other free software developers Less
|
||||
of an advantage over competing non-free programs. These disadvantages
|
||||
are the reason we use the ordinary General Public License for many
|
||||
libraries. However, the Lesser license provides advantages in certain
|
||||
special circumstances.
|
||||
|
||||
For example, on rare occasions, there may be a special need to
|
||||
encourage the widest possible use of a certain library, so that it becomes
|
||||
a de-facto standard. To achieve this, non-free programs must be
|
||||
allowed to use the library. A more frequent case is that a free
|
||||
library does the same job as widely used non-free libraries. In this
|
||||
case, there is little to gain by limiting the free library to free
|
||||
software only, so we use the Lesser General Public License.
|
||||
|
||||
In other cases, permission to use a particular library in non-free
|
||||
programs enables a greater number of people to use a large body of
|
||||
free software. For example, permission to use the GNU C Library in
|
||||
non-free programs enables many more people to use the whole GNU
|
||||
operating system, as well as its variant, the GNU/Linux operating
|
||||
system.
|
||||
|
||||
Although the Lesser General Public License is Less protective of the
|
||||
users' freedom, it does ensure that the user of a program that is
|
||||
linked with the Library has the freedom and the wherewithal to run
|
||||
that program using a modified version of the Library.
|
||||
|
||||
The precise terms and conditions for copying, distribution and
|
||||
modification follow. Pay close attention to the difference between a
|
||||
"work based on the library" and a "work that uses the library". The
|
||||
former contains code derived from the library, whereas the latter must
|
||||
be combined with the library in order to run.
|
||||
|
||||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
|
||||
|
||||
0. This License Agreement applies to any software library or other
|
||||
program which contains a notice placed by the copyright holder or
|
||||
other authorized party saying it may be distributed under the terms of
|
||||
this Lesser General Public License (also called "this License").
|
||||
Each licensee is addressed as "you".
|
||||
|
||||
A "library" means a collection of software functions and/or data
|
||||
prepared so as to be conveniently linked with application programs
|
||||
(which use some of those functions and data) to form executables.
|
||||
|
||||
The "Library", below, refers to any such software library or work
|
||||
which has been distributed under these terms. A "work based on the
|
||||
Library" means either the Library or any derivative work under
|
||||
copyright law: that is to say, a work containing the Library or a
|
||||
portion of it, either verbatim or with modifications and/or translated
|
||||
straightforwardly into another language. (Hereinafter, translation is
|
||||
included without limitation in the term "modification".)
|
||||
|
||||
"Source code" for a work means the preferred form of the work for
|
||||
making modifications to it. For a library, complete source code means
|
||||
all the source code for all modules it contains, plus any associated
|
||||
interface definition files, plus the scripts used to control compilation
|
||||
and installation of the library.
|
||||
|
||||
Activities other than copying, distribution and modification are not
|
||||
covered by this License; they are outside its scope. The act of
|
||||
running a program using the Library is not restricted, and output from
|
||||
such a program is covered only if its contents constitute a work based
|
||||
on the Library (independent of the use of the Library in a tool for
|
||||
writing it). Whether that is true depends on what the Library does
|
||||
and what the program that uses the Library does.
|
||||
|
||||
1. You may copy and distribute verbatim copies of the Library's
|
||||
complete source code as you receive it, in any medium, provided that
|
||||
you conspicuously and appropriately publish on each copy an
|
||||
appropriate copyright notice and disclaimer of warranty; keep intact
|
||||
all the notices that refer to this License and to the absence of any
|
||||
warranty; and distribute a copy of this License along with the
|
||||
Library.
|
||||
|
||||
You may charge a fee for the physical act of transferring a copy,
|
||||
and you may at your option offer warranty protection in exchange for a
|
||||
fee.
|
||||
|
||||
2. You may modify your copy or copies of the Library or any portion
|
||||
of it, thus forming a work based on the Library, and copy and
|
||||
distribute such modifications or work under the terms of Section 1
|
||||
above, provided that you also meet all of these conditions:
|
||||
|
||||
a) The modified work must itself be a software library.
|
||||
|
||||
b) You must cause the files modified to carry prominent notices
|
||||
stating that you changed the files and the date of any change.
|
||||
|
||||
c) You must cause the whole of the work to be licensed at no
|
||||
charge to all third parties under the terms of this License.
|
||||
|
||||
d) If a facility in the modified Library refers to a function or a
|
||||
table of data to be supplied by an application program that uses
|
||||
the facility, other than as an argument passed when the facility
|
||||
is invoked, then you must make a good faith effort to ensure that,
|
||||
in the event an application does not supply such function or
|
||||
table, the facility still operates, and performs whatever part of
|
||||
its purpose remains meaningful.
|
||||
|
||||
(For example, a function in a library to compute square roots has
|
||||
a purpose that is entirely well-defined independent of the
|
||||
application. Therefore, Subsection 2d requires that any
|
||||
application-supplied function or table used by this function must
|
||||
be optional: if the application does not supply it, the square
|
||||
root function must still compute square roots.)
|
||||
|
||||
These requirements apply to the modified work as a whole. If
|
||||
identifiable sections of that work are not derived from the Library,
|
||||
and can be reasonably considered independent and separate works in
|
||||
themselves, then this License, and its terms, do not apply to those
|
||||
sections when you distribute them as separate works. But when you
|
||||
distribute the same sections as part of a whole which is a work based
|
||||
on the Library, the distribution of the whole must be on the terms of
|
||||
this License, whose permissions for other licensees extend to the
|
||||
entire whole, and thus to each and every part regardless of who wrote
|
||||
it.
|
||||
|
||||
Thus, it is not the intent of this section to claim rights or contest
|
||||
your rights to work written entirely by you; rather, the intent is to
|
||||
exercise the right to control the distribution of derivative or
|
||||
collective works based on the Library.
|
||||
|
||||
In addition, mere aggregation of another work not based on the Library
|
||||
with the Library (or with a work based on the Library) on a volume of
|
||||
a storage or distribution medium does not bring the other work under
|
||||
the scope of this License.
|
||||
|
||||
3. You may opt to apply the terms of the ordinary GNU General Public
|
||||
License instead of this License to a given copy of the Library. To do
|
||||
this, you must alter all the notices that refer to this License, so
|
||||
that they refer to the ordinary GNU General Public License, version 2,
|
||||
instead of to this License. (If a newer version than version 2 of the
|
||||
ordinary GNU General Public License has appeared, then you can specify
|
||||
that version instead if you wish.) Do not make any other change in
|
||||
these notices.
|
||||
|
||||
Once this change is made in a given copy, it is irreversible for
|
||||
that copy, so the ordinary GNU General Public License applies to all
|
||||
subsequent copies and derivative works made from that copy.
|
||||
|
||||
This option is useful when you wish to copy part of the code of
|
||||
the Library into a program that is not a library.
|
||||
|
||||
4. You may copy and distribute the Library (or a portion or
|
||||
derivative of it, under Section 2) in object code or executable form
|
||||
under the terms of Sections 1 and 2 above provided that you accompany
|
||||
it with the complete corresponding machine-readable source code, which
|
||||
must be distributed under the terms of Sections 1 and 2 above on a
|
||||
medium customarily used for software interchange.
|
||||
|
||||
If distribution of object code is made by offering access to copy
|
||||
from a designated place, then offering equivalent access to copy the
|
||||
source code from the same place satisfies the requirement to
|
||||
distribute the source code, even though third parties are not
|
||||
compelled to copy the source along with the object code.
|
||||
|
||||
5. A program that contains no derivative of any portion of the
|
||||
Library, but is designed to work with the Library by being compiled or
|
||||
linked with it, is called a "work that uses the Library". Such a
|
||||
work, in isolation, is not a derivative work of the Library, and
|
||||
therefore falls outside the scope of this License.
|
||||
|
||||
However, linking a "work that uses the Library" with the Library
|
||||
creates an executable that is a derivative of the Library (because it
|
||||
contains portions of the Library), rather than a "work that uses the
|
||||
library". The executable is therefore covered by this License.
|
||||
Section 6 states terms for distribution of such executables.
|
||||
|
||||
When a "work that uses the Library" uses material from a header file
|
||||
that is part of the Library, the object code for the work may be a
|
||||
derivative work of the Library even though the source code is not.
|
||||
Whether this is true is especially significant if the work can be
|
||||
linked without the Library, or if the work is itself a library. The
|
||||
threshold for this to be true is not precisely defined by law.
|
||||
|
||||
If such an object file uses only numerical parameters, data
|
||||
structure layouts and accessors, and small macros and small inline
|
||||
functions (ten lines or less in length), then the use of the object
|
||||
file is unrestricted, regardless of whether it is legally a derivative
|
||||
work. (Executables containing this object code plus portions of the
|
||||
Library will still fall under Section 6.)
|
||||
|
||||
Otherwise, if the work is a derivative of the Library, you may
|
||||
distribute the object code for the work under the terms of Section 6.
|
||||
Any executables containing that work also fall under Section 6,
|
||||
whether or not they are linked directly with the Library itself.
|
||||
|
||||
6. As an exception to the Sections above, you may also combine or
|
||||
link a "work that uses the Library" with the Library to produce a
|
||||
work containing portions of the Library, and distribute that work
|
||||
under terms of your choice, provided that the terms permit
|
||||
modification of the work for the customer's own use and reverse
|
||||
engineering for debugging such modifications.
|
||||
|
||||
You must give prominent notice with each copy of the work that the
|
||||
Library is used in it and that the Library and its use are covered by
|
||||
this License. You must supply a copy of this License. If the work
|
||||
during execution displays copyright notices, you must include the
|
||||
copyright notice for the Library among them, as well as a reference
|
||||
directing the user to the copy of this License. Also, you must do one
|
||||
of these things:
|
||||
|
||||
a) Accompany the work with the complete corresponding
|
||||
machine-readable source code for the Library including whatever
|
||||
changes were used in the work (which must be distributed under
|
||||
Sections 1 and 2 above); and, if the work is an executable linked
|
||||
with the Library, with the complete machine-readable "work that
|
||||
uses the Library", as object code and/or source code, so that the
|
||||
user can modify the Library and then relink to produce a modified
|
||||
executable containing the modified Library. (It is understood
|
||||
that the user who changes the contents of definitions files in the
|
||||
Library will not necessarily be able to recompile the application
|
||||
to use the modified definitions.)
|
||||
|
||||
b) Use a suitable shared library mechanism for linking with the
|
||||
Library. A suitable mechanism is one that (1) uses at run time a
|
||||
copy of the library already present on the user's computer system,
|
||||
rather than copying library functions into the executable, and (2)
|
||||
will operate properly with a modified version of the library, if
|
||||
the user installs one, as long as the modified version is
|
||||
interface-compatible with the version that the work was made with.
|
||||
|
||||
c) Accompany the work with a written offer, valid for at
|
||||
least three years, to give the same user the materials
|
||||
specified in Subsection 6a, above, for a charge no more
|
||||
than the cost of performing this distribution.
|
||||
|
||||
d) If distribution of the work is made by offering access to copy
|
||||
from a designated place, offer equivalent access to copy the above
|
||||
specified materials from the same place.
|
||||
|
||||
e) Verify that the user has already received a copy of these
|
||||
materials or that you have already sent this user a copy.
|
||||
|
||||
For an executable, the required form of the "work that uses the
|
||||
Library" must include any data and utility programs needed for
|
||||
reproducing the executable from it. However, as a special exception,
|
||||
the materials to be distributed need not include anything that is
|
||||
normally distributed (in either source or binary form) with the major
|
||||
components (compiler, kernel, and so on) of the operating system on
|
||||
which the executable runs, unless that component itself accompanies
|
||||
the executable.
|
||||
|
||||
It may happen that this requirement contradicts the license
|
||||
restrictions of other proprietary libraries that do not normally
|
||||
accompany the operating system. Such a contradiction means you cannot
|
||||
use both them and the Library together in an executable that you
|
||||
distribute.
|
||||
|
||||
7. You may place library facilities that are a work based on the
|
||||
Library side-by-side in a single library together with other library
|
||||
facilities not covered by this License, and distribute such a combined
|
||||
library, provided that the separate distribution of the work based on
|
||||
the Library and of the other library facilities is otherwise
|
||||
permitted, and provided that you do these two things:
|
||||
|
||||
a) Accompany the combined library with a copy of the same work
|
||||
based on the Library, uncombined with any other library
|
||||
facilities. This must be distributed under the terms of the
|
||||
Sections above.
|
||||
|
||||
b) Give prominent notice with the combined library of the fact
|
||||
that part of it is a work based on the Library, and explaining
|
||||
where to find the accompanying uncombined form of the same work.
|
||||
|
||||
8. You may not copy, modify, sublicense, link with, or distribute
|
||||
the Library except as expressly provided under this License. Any
|
||||
attempt otherwise to copy, modify, sublicense, link with, or
|
||||
distribute the Library is void, and will automatically terminate your
|
||||
rights under this License. However, parties who have received copies,
|
||||
or rights, from you under this License will not have their licenses
|
||||
terminated so long as such parties remain in full compliance.
|
||||
|
||||
9. You are not required to accept this License, since you have not
|
||||
signed it. However, nothing else grants you permission to modify or
|
||||
distribute the Library or its derivative works. These actions are
|
||||
prohibited by law if you do not accept this License. Therefore, by
|
||||
modifying or distributing the Library (or any work based on the
|
||||
Library), you indicate your acceptance of this License to do so, and
|
||||
all its terms and conditions for copying, distributing or modifying
|
||||
the Library or works based on it.
|
||||
|
||||
10. Each time you redistribute the Library (or any work based on the
|
||||
Library), the recipient automatically receives a license from the
|
||||
original licensor to copy, distribute, link with or modify the Library
|
||||
subject to these terms and conditions. You may not impose any further
|
||||
restrictions on the recipients' exercise of the rights granted herein.
|
||||
You are not responsible for enforcing compliance by third parties with
|
||||
this License.
|
||||
|
||||
11. If, as a consequence of a court judgment or allegation of patent
|
||||
infringement or for any other reason (not limited to patent issues),
|
||||
conditions are imposed on you (whether by court order, agreement or
|
||||
otherwise) that contradict the conditions of this License, they do not
|
||||
excuse you from the conditions of this License. If you cannot
|
||||
distribute so as to satisfy simultaneously your obligations under this
|
||||
License and any other pertinent obligations, then as a consequence you
|
||||
may not distribute the Library at all. For example, if a patent
|
||||
license would not permit royalty-free redistribution of the Library by
|
||||
all those who receive copies directly or indirectly through you, then
|
||||
the only way you could satisfy both it and this License would be to
|
||||
refrain entirely from distribution of the Library.
|
||||
|
||||
If any portion of this section is held invalid or unenforceable under any
|
||||
particular circumstance, the balance of the section is intended to apply,
|
||||
and the section as a whole is intended to apply in other circumstances.
|
||||
|
||||
It is not the purpose of this section to induce you to infringe any
|
||||
patents or other property right claims or to contest validity of any
|
||||
such claims; this section has the sole purpose of protecting the
|
||||
integrity of the free software distribution system which is
|
||||
implemented by public license practices. Many people have made
|
||||
generous contributions to the wide range of software distributed
|
||||
through that system in reliance on consistent application of that
|
||||
system; it is up to the author/donor to decide if he or she is willing
|
||||
to distribute software through any other system and a licensee cannot
|
||||
impose that choice.
|
||||
|
||||
This section is intended to make thoroughly clear what is believed to
|
||||
be a consequence of the rest of this License.
|
||||
|
||||
12. If the distribution and/or use of the Library is restricted in
|
||||
certain countries either by patents or by copyrighted interfaces, the
|
||||
original copyright holder who places the Library under this License may add
|
||||
an explicit geographical distribution limitation excluding those countries,
|
||||
so that distribution is permitted only in or among countries not thus
|
||||
excluded. In such case, this License incorporates the limitation as if
|
||||
written in the body of this License.
|
||||
|
||||
13. The Free Software Foundation may publish revised and/or new
|
||||
versions of the Lesser General Public License from time to time.
|
||||
Such new versions will be similar in spirit to the present version,
|
||||
but may differ in detail to address new problems or concerns.
|
||||
|
||||
Each version is given a distinguishing version number. If the Library
|
||||
specifies a version number of this License which applies to it and
|
||||
"any later version", you have the option of following the terms and
|
||||
conditions either of that version or of any later version published by
|
||||
the Free Software Foundation. If the Library does not specify a
|
||||
license version number, you may choose any version ever published by
|
||||
the Free Software Foundation.
|
||||
|
||||
14. If you wish to incorporate parts of the Library into other free
|
||||
programs whose distribution conditions are incompatible with these,
|
||||
write to the author to ask for permission. For software which is
|
||||
copyrighted by the Free Software Foundation, write to the Free
|
||||
Software Foundation; we sometimes make exceptions for this. Our
|
||||
decision will be guided by the two goals of preserving the free status
|
||||
of all derivatives of our free software and of promoting the sharing
|
||||
and reuse of software generally.
|
||||
|
||||
NO WARRANTY
|
||||
|
||||
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
|
||||
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
|
||||
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
|
||||
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
|
||||
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
||||
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
|
||||
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
|
||||
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
|
||||
|
||||
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
|
||||
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
|
||||
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
|
||||
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
|
||||
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
|
||||
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
|
||||
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
|
||||
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
|
||||
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
||||
DAMAGES.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
109
build.gradle
Normal file
109
build.gradle
Normal file
@@ -0,0 +1,109 @@
|
||||
plugins {
|
||||
id 'java'
|
||||
id 'idea'
|
||||
id 'java-gradle-plugin'
|
||||
id 'com.github.johnrengelman.shadow' version '7.0.0'
|
||||
id 'com.gradle.plugin-publish' version '1.2.1'
|
||||
id "com.diffplug.spotless" version "6.13.0"
|
||||
}
|
||||
apply plugin: 'maven-publish'
|
||||
|
||||
group = 'com.hypherionmc.modutils'
|
||||
version = "${version_base}.${version_patch}"
|
||||
description = "Gradle plugin to merge multiloader/architectury multiplatform mods into a single jar file"
|
||||
archivesBaseName = 'ModFusioner'
|
||||
java.toolchain.languageVersion = JavaLanguageVersion.of(8)
|
||||
|
||||
if (System.getenv('BUILD_NUMBER') != null) {
|
||||
version = "${version_base}." + System.getenv('BUILD_NUMBER')
|
||||
}
|
||||
|
||||
configurations {
|
||||
shadeMe
|
||||
implementation.extendsFrom shadeMe
|
||||
}
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
maven {
|
||||
url "https://maven.firstdarkdev.xyz/releases"
|
||||
}
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation gradleApi()
|
||||
|
||||
// Shaded Deps
|
||||
shadeMe 'org.jetbrains:annotations:24.0.1'
|
||||
shadeMe 'commons-io:commons-io:2.11.0'
|
||||
|
||||
shadeMe('me.lucko:jar-relocator:1.5') {
|
||||
exclude group: 'org.ow2.asm'
|
||||
}
|
||||
shadeMe 'org.ow2.asm:asm:9.3'
|
||||
shadeMe 'org.ow2.asm:asm-commons:9.3'
|
||||
shadeMe "fr.stevecohen.jarmanager:JarManager:0.5.0"
|
||||
shadeMe 'org.apache.commons:commons-compress:1.24.0'
|
||||
shadeMe 'org.apache.tika:tika-core:1.28'
|
||||
|
||||
compileOnly 'org.projectlombok:lombok:1.18.30'
|
||||
annotationProcessor 'org.projectlombok:lombok:1.18.30'
|
||||
}
|
||||
|
||||
shadowJar {
|
||||
duplicatesStrategy = DuplicatesStrategy.EXCLUDE
|
||||
configurations = [project.configurations.getByName("shadeMe")]
|
||||
archiveClassifier.set(null)
|
||||
}
|
||||
|
||||
gradlePlugin {
|
||||
plugins {
|
||||
modPublisherPlugin {
|
||||
id = 'com.hypherionmc.modutils.modfusioner'
|
||||
description = project.description
|
||||
displayName = 'ModFusioner'
|
||||
version = project.version
|
||||
implementationClass = "com.hypherionmc.modfusioner.plugin.ModFusionerPlugin"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pluginBundle {
|
||||
website = 'https://github.com/firstdarkdev/modfusioner'
|
||||
vcsUrl = 'https://github.com/firstdarkdev/modfusioner'
|
||||
description = 'Gradle plugin to merge multiloader/architectury multiplatform mods into a single jar file'
|
||||
tags = ['minecraft', 'forge', 'fabric', 'quilt', 'merge', 'mod']
|
||||
}
|
||||
|
||||
jar {
|
||||
manifest {
|
||||
attributes([
|
||||
'Timestamp' : System.currentTimeMillis(),
|
||||
'Specification-Title' : project.archivesBaseName,
|
||||
'Specification-Version' : project.version,
|
||||
'Implementation-Title' : project.archivesBaseName,
|
||||
'Implementation-Version' : project.version,
|
||||
'Implementation-Timestamp': new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
|
||||
'Built-On-Java' : "${System.getProperty('java.vm.version')} (${System.getProperty('java.vm.vendor')})"
|
||||
])
|
||||
}
|
||||
}
|
||||
|
||||
spotless {
|
||||
java {
|
||||
targetExclude("src/test/**")
|
||||
licenseHeaderFile(rootProject.file("HEADER")).yearSeparator("-")
|
||||
}
|
||||
}
|
||||
|
||||
publishing {
|
||||
repositories {
|
||||
maven {
|
||||
url System.getenv('MAVEN_URL')
|
||||
credentials {
|
||||
username System.getenv('MAVEN_USER')
|
||||
password System.getenv('MAVEN_PASS')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
2
gradle.properties
Normal file
2
gradle.properties
Normal file
@@ -0,0 +1,2 @@
|
||||
version_base=1.0
|
||||
version_patch=0
|
||||
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Normal file
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Normal file
Binary file not shown.
6
gradle/wrapper/gradle-wrapper.properties
vendored
Normal file
6
gradle/wrapper/gradle-wrapper.properties
vendored
Normal file
@@ -0,0 +1,6 @@
|
||||
#Sun Oct 29 20:46:13 SAST 2023
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-7.4-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
234
gradlew
vendored
Normal file
234
gradlew
vendored
Normal file
@@ -0,0 +1,234 @@
|
||||
#!/bin/sh
|
||||
|
||||
#
|
||||
# Copyright © 2015-2021 the original authors.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# https://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
#
|
||||
|
||||
##############################################################################
|
||||
#
|
||||
# Gradle start up script for POSIX generated by Gradle.
|
||||
#
|
||||
# Important for running:
|
||||
#
|
||||
# (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
|
||||
# noncompliant, but you have some other compliant shell such as ksh or
|
||||
# bash, then to run this script, type that shell name before the whole
|
||||
# command line, like:
|
||||
#
|
||||
# ksh Gradle
|
||||
#
|
||||
# Busybox and similar reduced shells will NOT work, because this script
|
||||
# requires all of these POSIX shell features:
|
||||
# * functions;
|
||||
# * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
|
||||
# «${var#prefix}», «${var%suffix}», and «$( cmd )»;
|
||||
# * compound commands having a testable exit status, especially «case»;
|
||||
# * various built-in commands including «command», «set», and «ulimit».
|
||||
#
|
||||
# Important for patching:
|
||||
#
|
||||
# (2) This script targets any POSIX shell, so it avoids extensions provided
|
||||
# by Bash, Ksh, etc; in particular arrays are avoided.
|
||||
#
|
||||
# The "traditional" practice of packing multiple parameters into a
|
||||
# space-separated string is a well documented source of bugs and security
|
||||
# problems, so this is (mostly) avoided, by progressively accumulating
|
||||
# options in "$@", and eventually passing that to Java.
|
||||
#
|
||||
# Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
|
||||
# and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
|
||||
# see the in-line comments for details.
|
||||
#
|
||||
# There are tweaks for specific operating systems such as AIX, CygWin,
|
||||
# Darwin, MinGW, and NonStop.
|
||||
#
|
||||
# (3) This script is generated from the Groovy template
|
||||
# https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
|
||||
# within the Gradle project.
|
||||
#
|
||||
# You can find Gradle at https://github.com/gradle/gradle/.
|
||||
#
|
||||
##############################################################################
|
||||
|
||||
# Attempt to set APP_HOME
|
||||
|
||||
# Resolve links: $0 may be a link
|
||||
app_path=$0
|
||||
|
||||
# Need this for daisy-chained symlinks.
|
||||
while
|
||||
APP_HOME=${app_path%"${app_path##*/}"} # leaves a trailing /; empty if no leading path
|
||||
[ -h "$app_path" ]
|
||||
do
|
||||
ls=$( ls -ld "$app_path" )
|
||||
link=${ls#*' -> '}
|
||||
case $link in #(
|
||||
/*) app_path=$link ;; #(
|
||||
*) app_path=$APP_HOME$link ;;
|
||||
esac
|
||||
done
|
||||
|
||||
APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
|
||||
|
||||
APP_NAME="Gradle"
|
||||
APP_BASE_NAME=${0##*/}
|
||||
|
||||
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
|
||||
|
||||
# Use the maximum available, or set MAX_FD != -1 to use that value.
|
||||
MAX_FD=maximum
|
||||
|
||||
warn () {
|
||||
echo "$*"
|
||||
} >&2
|
||||
|
||||
die () {
|
||||
echo
|
||||
echo "$*"
|
||||
echo
|
||||
exit 1
|
||||
} >&2
|
||||
|
||||
# OS specific support (must be 'true' or 'false').
|
||||
cygwin=false
|
||||
msys=false
|
||||
darwin=false
|
||||
nonstop=false
|
||||
case "$( uname )" in #(
|
||||
CYGWIN* ) cygwin=true ;; #(
|
||||
Darwin* ) darwin=true ;; #(
|
||||
MSYS* | MINGW* ) msys=true ;; #(
|
||||
NONSTOP* ) nonstop=true ;;
|
||||
esac
|
||||
|
||||
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
|
||||
|
||||
|
||||
# Determine the Java command to use to start the JVM.
|
||||
if [ -n "$JAVA_HOME" ] ; then
|
||||
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
|
||||
# IBM's JDK on AIX uses strange locations for the executables
|
||||
JAVACMD=$JAVA_HOME/jre/sh/java
|
||||
else
|
||||
JAVACMD=$JAVA_HOME/bin/java
|
||||
fi
|
||||
if [ ! -x "$JAVACMD" ] ; then
|
||||
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
|
||||
|
||||
Please set the JAVA_HOME variable in your environment to match the
|
||||
location of your Java installation."
|
||||
fi
|
||||
else
|
||||
JAVACMD=java
|
||||
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
|
||||
Please set the JAVA_HOME variable in your environment to match the
|
||||
location of your Java installation."
|
||||
fi
|
||||
|
||||
# Increase the maximum file descriptors if we can.
|
||||
if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
|
||||
case $MAX_FD in #(
|
||||
max*)
|
||||
MAX_FD=$( ulimit -H -n ) ||
|
||||
warn "Could not query maximum file descriptor limit"
|
||||
esac
|
||||
case $MAX_FD in #(
|
||||
'' | soft) :;; #(
|
||||
*)
|
||||
ulimit -n "$MAX_FD" ||
|
||||
warn "Could not set maximum file descriptor limit to $MAX_FD"
|
||||
esac
|
||||
fi
|
||||
|
||||
# Collect all arguments for the java command, stacking in reverse order:
|
||||
# * args from the command line
|
||||
# * the main class name
|
||||
# * -classpath
|
||||
# * -D...appname settings
|
||||
# * --module-path (only if needed)
|
||||
# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
|
||||
|
||||
# For Cygwin or MSYS, switch paths to Windows format before running java
|
||||
if "$cygwin" || "$msys" ; then
|
||||
APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
|
||||
CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
|
||||
|
||||
JAVACMD=$( cygpath --unix "$JAVACMD" )
|
||||
|
||||
# Now convert the arguments - kludge to limit ourselves to /bin/sh
|
||||
for arg do
|
||||
if
|
||||
case $arg in #(
|
||||
-*) false ;; # don't mess with options #(
|
||||
/?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath
|
||||
[ -e "$t" ] ;; #(
|
||||
*) false ;;
|
||||
esac
|
||||
then
|
||||
arg=$( cygpath --path --ignore --mixed "$arg" )
|
||||
fi
|
||||
# Roll the args list around exactly as many times as the number of
|
||||
# args, so each arg winds up back in the position where it started, but
|
||||
# possibly modified.
|
||||
#
|
||||
# NB: a `for` loop captures its iteration list before it begins, so
|
||||
# changing the positional parameters here affects neither the number of
|
||||
# iterations, nor the values presented in `arg`.
|
||||
shift # remove old arg
|
||||
set -- "$@" "$arg" # push replacement arg
|
||||
done
|
||||
fi
|
||||
|
||||
# Collect all arguments for the java command;
|
||||
# * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
|
||||
# shell script including quotes and variable substitutions, so put them in
|
||||
# double quotes to make sure that they get re-expanded; and
|
||||
# * put everything else in single quotes, so that it's not re-expanded.
|
||||
|
||||
set -- \
|
||||
"-Dorg.gradle.appname=$APP_BASE_NAME" \
|
||||
-classpath "$CLASSPATH" \
|
||||
org.gradle.wrapper.GradleWrapperMain \
|
||||
"$@"
|
||||
|
||||
# Use "xargs" to parse quoted args.
|
||||
#
|
||||
# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
|
||||
#
|
||||
# In Bash we could simply go:
|
||||
#
|
||||
# readarray ARGS < <( xargs -n1 <<<"$var" ) &&
|
||||
# set -- "${ARGS[@]}" "$@"
|
||||
#
|
||||
# but POSIX shell has neither arrays nor command substitution, so instead we
|
||||
# post-process each arg (as a line of input to sed) to backslash-escape any
|
||||
# character that might be a shell metacharacter, then use eval to reverse
|
||||
# that process (while maintaining the separation between arguments), and wrap
|
||||
# the whole thing up as a single "set" statement.
|
||||
#
|
||||
# This will of course break if any of these variables contains a newline or
|
||||
# an unmatched quote.
|
||||
#
|
||||
|
||||
eval "set -- $(
|
||||
printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
|
||||
xargs -n1 |
|
||||
sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
|
||||
tr '\n' ' '
|
||||
)" '"$@"'
|
||||
|
||||
exec "$JAVACMD" "$@"
|
||||
89
gradlew.bat
vendored
Normal file
89
gradlew.bat
vendored
Normal file
@@ -0,0 +1,89 @@
|
||||
@rem
|
||||
@rem Copyright 2015 the original author or authors.
|
||||
@rem
|
||||
@rem Licensed under the Apache License, Version 2.0 (the "License");
|
||||
@rem you may not use this file except in compliance with the License.
|
||||
@rem You may obtain a copy of the License at
|
||||
@rem
|
||||
@rem https://www.apache.org/licenses/LICENSE-2.0
|
||||
@rem
|
||||
@rem Unless required by applicable law or agreed to in writing, software
|
||||
@rem distributed under the License is distributed on an "AS IS" BASIS,
|
||||
@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
@rem See the License for the specific language governing permissions and
|
||||
@rem limitations under the License.
|
||||
@rem
|
||||
|
||||
@if "%DEBUG%" == "" @echo off
|
||||
@rem ##########################################################################
|
||||
@rem
|
||||
@rem Gradle startup script for Windows
|
||||
@rem
|
||||
@rem ##########################################################################
|
||||
|
||||
@rem Set local scope for the variables with windows NT shell
|
||||
if "%OS%"=="Windows_NT" setlocal
|
||||
|
||||
set DIRNAME=%~dp0
|
||||
if "%DIRNAME%" == "" set DIRNAME=.
|
||||
set APP_BASE_NAME=%~n0
|
||||
set APP_HOME=%DIRNAME%
|
||||
|
||||
@rem Resolve any "." and ".." in APP_HOME to make it shorter.
|
||||
for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
|
||||
|
||||
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
|
||||
set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
|
||||
|
||||
@rem Find java.exe
|
||||
if defined JAVA_HOME goto findJavaFromJavaHome
|
||||
|
||||
set JAVA_EXE=java.exe
|
||||
%JAVA_EXE% -version >NUL 2>&1
|
||||
if "%ERRORLEVEL%" == "0" goto execute
|
||||
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
|
||||
echo.
|
||||
echo Please set the JAVA_HOME variable in your environment to match the
|
||||
echo location of your Java installation.
|
||||
|
||||
goto fail
|
||||
|
||||
:findJavaFromJavaHome
|
||||
set JAVA_HOME=%JAVA_HOME:"=%
|
||||
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
|
||||
|
||||
if exist "%JAVA_EXE%" goto execute
|
||||
|
||||
echo.
|
||||
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
|
||||
echo.
|
||||
echo Please set the JAVA_HOME variable in your environment to match the
|
||||
echo location of your Java installation.
|
||||
|
||||
goto fail
|
||||
|
||||
:execute
|
||||
@rem Setup the command line
|
||||
|
||||
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
|
||||
|
||||
|
||||
@rem Execute Gradle
|
||||
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
|
||||
|
||||
:end
|
||||
@rem End local scope for the variables with windows NT shell
|
||||
if "%ERRORLEVEL%"=="0" goto mainEnd
|
||||
|
||||
:fail
|
||||
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
|
||||
rem the _cmd.exe /c_ return code!
|
||||
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
|
||||
exit /b 1
|
||||
|
||||
:mainEnd
|
||||
if "%OS%"=="Windows_NT" endlocal
|
||||
|
||||
:omega
|
||||
2
settings.gradle
Normal file
2
settings.gradle
Normal file
@@ -0,0 +1,2 @@
|
||||
rootProject.name = 'ModMeld'
|
||||
|
||||
32
src/main/java/com/hypherionmc/modfusioner/Constants.java
Normal file
32
src/main/java/com/hypherionmc/modfusioner/Constants.java
Normal file
@@ -0,0 +1,32 @@
|
||||
package com.hypherionmc.modfusioner;
|
||||
|
||||
import java.nio.file.attribute.PosixFilePermission;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* @author HypherionSA
|
||||
* Class that contain constant values used througout the plugin
|
||||
*/
|
||||
public class Constants {
|
||||
|
||||
public static final String TASK_GROUP = "modfusioner";
|
||||
public static final String TASK_NAME = "fusejars";
|
||||
public static final String EXTENSION_NAME = "fusioner";
|
||||
public static final String MANIFEST_KEY = "ModFusioner-Version";
|
||||
|
||||
public static Set<PosixFilePermission> filePerms = new HashSet<>();
|
||||
|
||||
static {
|
||||
filePerms.add(PosixFilePermission.OTHERS_EXECUTE);
|
||||
filePerms.add(PosixFilePermission.OTHERS_WRITE);
|
||||
filePerms.add(PosixFilePermission.OTHERS_READ);
|
||||
filePerms.add(PosixFilePermission.OWNER_EXECUTE);
|
||||
filePerms.add(PosixFilePermission.OWNER_WRITE);
|
||||
filePerms.add(PosixFilePermission.OWNER_READ);
|
||||
filePerms.add(PosixFilePermission.GROUP_EXECUTE);
|
||||
filePerms.add(PosixFilePermission.GROUP_WRITE);
|
||||
filePerms.add(PosixFilePermission.GROUP_READ);
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,622 @@
|
||||
package com.hypherionmc.modfusioner.actions;
|
||||
|
||||
import com.hypherionmc.modfusioner.Constants;
|
||||
import com.hypherionmc.modfusioner.plugin.ModFusionerExtension;
|
||||
import com.hypherionmc.modfusioner.utils.FileTools;
|
||||
import fr.stevecohen.jarmanager.JarPacker;
|
||||
import fr.stevecohen.jarmanager.JarUnpacker;
|
||||
import lombok.RequiredArgsConstructor;
|
||||
import lombok.Setter;
|
||||
import me.lucko.jarrelocator.JarRelocator;
|
||||
import me.lucko.jarrelocator.Relocation;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.StandardCopyOption;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.atomic.AtomicReference;
|
||||
import java.util.jar.JarFile;
|
||||
import java.util.jar.Manifest;
|
||||
|
||||
import static com.hypherionmc.modfusioner.plugin.ModFusionerPlugin.logger;
|
||||
import static com.hypherionmc.modfusioner.utils.FileTools.*;
|
||||
|
||||
/**
|
||||
* @author HypherionSA
|
||||
* The main logic class of the plugin. This class is responsible for
|
||||
* extracting, remapping, de-duplicating and finally merging the input jars
|
||||
*/
|
||||
@RequiredArgsConstructor(staticName = "of")
|
||||
public class JarMergeAction {
|
||||
|
||||
// File Inputs
|
||||
@Setter private File forgeInput;
|
||||
@Setter private File fabricInput;
|
||||
@Setter private File quiltInput;
|
||||
private final Map<ModFusionerExtension.CustomConfiguration, File> customInputs;
|
||||
|
||||
// Relocations
|
||||
@Setter private Map<String, String> forgeRelocations;
|
||||
@Setter private Map<String, String> fabricRelocations;
|
||||
@Setter private Map<String, String> quiltRelocations;
|
||||
|
||||
// Mixins
|
||||
@Setter private List<String> forgeMixins;
|
||||
|
||||
// Custom
|
||||
private Map<ModFusionerExtension.CustomConfiguration, Map<File, File>> customTemps;
|
||||
|
||||
// Relocations
|
||||
private final List<String> ignoredPackages;
|
||||
private final Map<String, String> ignoredDuplicateRelocations = new HashMap<>();
|
||||
private final Map<String, String> removeDuplicateRelocationResources = new HashMap<>();
|
||||
private final List<Relocation> relocations = new ArrayList<>();
|
||||
|
||||
// Settings
|
||||
private final String group;
|
||||
private final File tempDir;
|
||||
private final String outJarName;
|
||||
|
||||
/**
|
||||
* Start the merge process
|
||||
* @param skipIfExists - Should the task be cancelled if an existing merged jar is found
|
||||
* @return - The fully merged jar file
|
||||
* @throws IOException - Thrown when an IO Exception occurs
|
||||
*/
|
||||
public File mergeJars(boolean skipIfExists) throws IOException {
|
||||
File outJar = new File(tempDir, outJarName);
|
||||
if (outJar.exists()) {
|
||||
if (skipIfExists) return outJar;
|
||||
outJar.delete();
|
||||
}
|
||||
|
||||
logger.lifecycle("Cleaning output Directory");
|
||||
FileTools.createOrReCreate(tempDir);
|
||||
|
||||
// Check if the required input files exists
|
||||
if (forgeInput == null && fabricInput == null && quiltInput == null && customInputs.isEmpty()) {
|
||||
throw new IllegalArgumentException("No input jars were provided.");
|
||||
}
|
||||
|
||||
if (!FileTools.exists(forgeInput)) {
|
||||
logger.warn("Forge jar does not exist! You can ignore this warning if you are not using forge");
|
||||
}
|
||||
|
||||
if (!FileTools.exists(fabricInput)) {
|
||||
logger.warn("Fabric jar does not exist! You can ignore this warning if you are not using fabric");
|
||||
}
|
||||
|
||||
if (!FileTools.exists(quiltInput)) {
|
||||
logger.warn("Quilt jar does not exist! You can ignore this warning if you are not using quilt");
|
||||
}
|
||||
|
||||
customInputs.forEach((key, value) -> {
|
||||
if (!FileTools.exists(value)) {
|
||||
logger.warn(key.getProjectName() + " jar does not exist! You can ignore this if you are not using custom configurations");
|
||||
}
|
||||
});
|
||||
|
||||
// Remap the jar files to match their platform name
|
||||
remapJars();
|
||||
|
||||
// Create the temporary processing directories
|
||||
File fabricTemp = FileTools.getOrCreate(new File(tempDir, "fabric-temp"));
|
||||
File forgeTemp = FileTools.getOrCreate(new File(tempDir, "forge-temp"));
|
||||
File quiltTemp = FileTools.getOrCreate(new File(tempDir, "quilt-temp"));
|
||||
|
||||
customTemps = new HashMap<>();
|
||||
customInputs.forEach((key, value) -> {
|
||||
Map<File, File> temp = new HashMap<>();
|
||||
|
||||
temp.put(value, new File(tempDir, key.getProjectName() + "-temp"));
|
||||
FileTools.getOrCreate(new File(tempDir, key.getProjectName() + "-temp"));
|
||||
customTemps.put(key, temp);
|
||||
});
|
||||
|
||||
// Extract the input jars to their processing directories
|
||||
logger.lifecycle("Unpacking input jars");
|
||||
JarUnpacker jarUnpacker = new JarUnpacker();
|
||||
if (FileTools.exists(forgeInput)) {
|
||||
jarUnpacker.unpack(forgeInput.getAbsolutePath(), forgeTemp.getAbsolutePath());
|
||||
}
|
||||
if (FileTools.exists(fabricInput)) {
|
||||
jarUnpacker.unpack(fabricInput.getAbsolutePath(), fabricTemp.getAbsolutePath());
|
||||
}
|
||||
if (FileTools.exists(quiltInput)) {
|
||||
jarUnpacker.unpack(quiltInput.getAbsolutePath(), quiltTemp.getAbsolutePath());
|
||||
}
|
||||
|
||||
customTemps.forEach((key, value) -> value.forEach((k, v) -> {
|
||||
if (FileTools.exists(k)) {
|
||||
jarUnpacker.unpack(k.getAbsolutePath(), v.getAbsolutePath());
|
||||
}
|
||||
}));
|
||||
|
||||
File mergedTemp = FileTools.getOrCreate(new File(tempDir, "merged-temp"));
|
||||
processManifests(mergedTemp, forgeTemp, fabricTemp, quiltTemp);
|
||||
|
||||
FileTools.moveDirectory(forgeTemp, mergedTemp);
|
||||
FileTools.moveDirectory(fabricTemp, mergedTemp);
|
||||
FileTools.moveDirectory(quiltTemp, mergedTemp);
|
||||
|
||||
for (Map.Entry<ModFusionerExtension.CustomConfiguration, Map<File, File>> entry : customTemps.entrySet()) {
|
||||
for (Map.Entry<File, File> entry2 : entry.getValue().entrySet()) {
|
||||
FileTools.moveDirectory(entry2.getValue(), mergedTemp);
|
||||
}
|
||||
}
|
||||
|
||||
// Process duplicate packages and resources
|
||||
logger.lifecycle("Processing duplicate packages and resources");
|
||||
processDuplicatePackages();
|
||||
removeDuplicatePackages(mergedTemp);
|
||||
removeDuplicateResources(mergedTemp);
|
||||
|
||||
// Clean the output jar if it exists
|
||||
FileUtils.deleteQuietly(outJar);
|
||||
|
||||
// Repack the fully processed jars into a single jar
|
||||
logger.lifecycle("Fusing jars into single jar");
|
||||
JarPacker jarPacker = new JarPacker();
|
||||
jarPacker.pack(mergedTemp.getAbsolutePath(), outJar.getAbsolutePath());
|
||||
|
||||
// Relocate duplicate packages that have been de-duplicated
|
||||
logger.lifecycle("Finishing up");
|
||||
relocateJar(outJar, new File(tempDir, "relocate.jar"));
|
||||
|
||||
try {
|
||||
Files.setPosixFilePermissions(outJar.toPath(), Constants.filePerms);
|
||||
} catch (Exception ignored) {}
|
||||
|
||||
return outJar;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clean the output directory before the task exists
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
public void clean() throws IOException {
|
||||
FileUtils.deleteQuietly(tempDir);
|
||||
}
|
||||
|
||||
/**
|
||||
* ================================================================================================================
|
||||
* = Jar Remapping =
|
||||
* ================================================================================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
* Relocate, or rename packages that have been deduplicated and moved around
|
||||
* @param mergedJar - Input jar
|
||||
* @param mergedOutputJar - Temporary output jar
|
||||
* @throws IOException - Thrown if an IO exception occurs
|
||||
*/
|
||||
private void relocateJar(File mergedJar, File mergedOutputJar) throws IOException {
|
||||
JarRelocator jarRelocator = new JarRelocator(mergedJar, mergedOutputJar, relocations);
|
||||
jarRelocator.run();
|
||||
|
||||
Files.move(mergedOutputJar.toPath(), mergedJar.toPath(), StandardCopyOption.REPLACE_EXISTING);
|
||||
if (mergedOutputJar.exists()) mergedOutputJar.delete();
|
||||
}
|
||||
|
||||
/**
|
||||
* Process input jars to relocate them internally to their final package names
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
public void remapJars() throws IOException {
|
||||
logger.lifecycle("Start processing input jars");
|
||||
|
||||
remapJar(forgeInput, "forge", forgeRelocations);
|
||||
remapJar(fabricInput, "fabric", fabricRelocations);
|
||||
remapJar(quiltInput, "quilt", quiltRelocations);
|
||||
|
||||
for (Map.Entry<ModFusionerExtension.CustomConfiguration, File> entry : customInputs.entrySet()) {
|
||||
if (FileTools.exists(entry.getValue())) {
|
||||
remapCustomJar(entry.getKey(), entry.getValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remap a Forge/Fabric/Quilt Jar
|
||||
* @param jarFile - The input jar
|
||||
* @param target - The identifier of the package names
|
||||
* @param relocations - List of packages to be moved around
|
||||
* @throws IOException - Thrown if an io exception occurs
|
||||
*/
|
||||
private void remapJar(File jarFile, String target, Map<String, String> relocations) throws IOException {
|
||||
if (FileTools.exists(jarFile)) {
|
||||
File remappedJar = FileTools.createOrReCreateF(new File(tempDir, "temp" + target + "InMerging.jar"));
|
||||
|
||||
List<Relocation> jarRelocations = new ArrayList<>();
|
||||
jarRelocations.add(new Relocation(group, target + "." + group));
|
||||
if (relocations != null)
|
||||
jarRelocations.addAll(relocations.entrySet().stream().map(entry -> new Relocation(entry.getKey(), entry.getValue())).collect(ArrayList::new, ArrayList::add, ArrayList::addAll));
|
||||
|
||||
AtomicReference<String> architectury = new AtomicReference<>();
|
||||
architectury.set(null);
|
||||
|
||||
JarFile jar = new JarFile(jarFile);
|
||||
jar.stream().forEach(jarEntry -> {
|
||||
if (jarEntry.isDirectory()) {
|
||||
if (jarEntry.getName().startsWith("architectury_inject")) {
|
||||
architectury.set(jarEntry.getName());
|
||||
}
|
||||
} else {
|
||||
String firstDirectory = getFirstDirectory(jarEntry.getName());
|
||||
if (firstDirectory.startsWith("architectury_inject")) {
|
||||
architectury.set(firstDirectory);
|
||||
}
|
||||
}
|
||||
});
|
||||
jar.close();
|
||||
|
||||
if (architectury.get() != null) {
|
||||
jarRelocations.add(new Relocation(architectury.get(), target + "." + architectury.get()));
|
||||
}
|
||||
|
||||
JarRelocator jarRelocator = new JarRelocator(jarFile, remappedJar, jarRelocations);
|
||||
jarRelocator.run();
|
||||
|
||||
switch (target) {
|
||||
case "forge":
|
||||
forgeInput = remappedJar;
|
||||
break;
|
||||
case "fabric":
|
||||
fabricInput = remappedJar;
|
||||
break;
|
||||
case "quilt":
|
||||
quiltInput = remappedJar;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remap a Custom Jar
|
||||
* @param configuration - The configuration of the custom package
|
||||
* @param jarFile - The input jar of the custom project to be processed
|
||||
* @throws IOException - Thrown if an io exception occurs
|
||||
*/
|
||||
private void remapCustomJar(ModFusionerExtension.CustomConfiguration configuration, File jarFile) throws IOException {
|
||||
String name = configuration.getProjectName();
|
||||
File remappedJar = FileTools.createOrReCreateF(new File(tempDir, "tempCustomInMerging_" + name + ".jar"));
|
||||
|
||||
List<Relocation> customRelocations = new ArrayList<>();
|
||||
customRelocations.add(new Relocation(group, name + "." + group));
|
||||
if (configuration.getRelocations() != null)
|
||||
customRelocations.addAll(configuration.getRelocations().entrySet().stream().map(entry -> new Relocation(entry.getKey(), entry.getValue())).collect(ArrayList::new, ArrayList::add, ArrayList::addAll));
|
||||
|
||||
AtomicReference<String> architectury = new AtomicReference<>();
|
||||
architectury.set(null);
|
||||
|
||||
JarFile jar = new JarFile(jarFile);
|
||||
jar.stream().forEach(jarEntry -> {
|
||||
if (jarEntry.isDirectory()) {
|
||||
if (jarEntry.getName().startsWith("architectury_inject")) {
|
||||
architectury.set(jarEntry.getName());
|
||||
}
|
||||
} else {
|
||||
String firstDirectory = getFirstDirectory(jarEntry.getName());
|
||||
if (firstDirectory.startsWith("architectury_inject")) {
|
||||
architectury.set(firstDirectory);
|
||||
}
|
||||
}
|
||||
});
|
||||
jar.close();
|
||||
|
||||
if (architectury.get() != null) {
|
||||
customRelocations.add(new Relocation(architectury.get(), name + "." + architectury.get()));
|
||||
}
|
||||
|
||||
JarRelocator customRelocator = new JarRelocator(jarFile, remappedJar, customRelocations);
|
||||
customRelocator.run();
|
||||
|
||||
customInputs.replace(configuration, jarFile, remappedJar);
|
||||
}
|
||||
|
||||
/**
|
||||
* Process resource files from unpacked jars to remap them to their new package names
|
||||
* @param forgeTemps - The forge processing directory
|
||||
* @param fabricTemps - The fabric processing directory
|
||||
* @param quiltTemps - The quilt processing directory
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
private void remapResources(File forgeTemps, File fabricTemps, File quiltTemps) throws IOException {
|
||||
logger.lifecycle("Start Remapping Resources");
|
||||
remapJarResources(forgeInput, "forge", forgeTemps, forgeRelocations);
|
||||
remapJarResources(fabricInput, "fabric", fabricTemps, fabricRelocations);
|
||||
remapJarResources(quiltInput, "quilt", quiltTemps, quiltRelocations);
|
||||
|
||||
for (Map.Entry<ModFusionerExtension.CustomConfiguration, Map<File, File>> entry : customTemps.entrySet()) {
|
||||
for (Map.Entry<File, File> entry2 : entry.getValue().entrySet()) {
|
||||
if (entry2.getKey() != null && entry2.getKey().exists()) {
|
||||
File customTemps = entry2.getValue();
|
||||
String name = entry.getKey().getProjectName();
|
||||
remapJarResources(null, name, customTemps, entry.getKey().getRelocations());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
logger.lifecycle("Remapping Finished");
|
||||
}
|
||||
|
||||
/**
|
||||
* Remap resource files from jar. Used to remove duplicate code from {@link JarMergeAction#remapResources(File, File, File)}
|
||||
* @param jar - The jar file being processed
|
||||
* @param identifier - The group identifier of the packages
|
||||
* @param workingDir - The processing directory
|
||||
* @param relocations - List of packages that have been relocated
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
private void remapJarResources(File jar, String identifier, File workingDir, Map<String, String> relocations) throws IOException {
|
||||
if (jar != null && !jar.exists())
|
||||
return;
|
||||
|
||||
if (relocations == null) relocations = new HashMap<>();
|
||||
for (File file : embeddedJars(workingDir)) {
|
||||
File remappedFile = new File(file.getParentFile(), identifier + "-" + file.getName());
|
||||
relocations.put(file.getName(), remappedFile.getName());
|
||||
file.renameTo(remappedFile);
|
||||
}
|
||||
|
||||
for (File file : getPlatformServices(workingDir, group)) {
|
||||
File remappedFile = new File(file.getParentFile(), identifier + "." + file.getName());
|
||||
relocations.put(file.getName(), remappedFile.getName());
|
||||
file.renameTo(remappedFile);
|
||||
}
|
||||
|
||||
if (identifier.equalsIgnoreCase("forge"))
|
||||
forgeMixins = new ArrayList<>();
|
||||
|
||||
for (File file : getMixins(workingDir, !identifier.equalsIgnoreCase("forge"))) {
|
||||
File remappedFile = new File(file.getParentFile(), identifier + "-" + file.getName());
|
||||
relocations.put(file.getName(), remappedFile.getName());
|
||||
file.renameTo(remappedFile);
|
||||
|
||||
if (identifier.equalsIgnoreCase("forge"))
|
||||
forgeMixins.add(remappedFile.getName());
|
||||
}
|
||||
|
||||
if (!identifier.equalsIgnoreCase("forge")) {
|
||||
for (File file : getAccessWideners(workingDir)) {
|
||||
File remappedFile = new File(file.getParentFile(), identifier + "-" + file.getName());
|
||||
relocations.put(file.getName(), remappedFile.getName());
|
||||
file.renameTo(remappedFile);
|
||||
}
|
||||
}
|
||||
|
||||
for (File file : getRefmaps(workingDir)) {
|
||||
File remappedFile = new File(file.getParentFile(), identifier + "-" + file.getName());
|
||||
relocations.put(file.getName(), remappedFile.getName());
|
||||
file.renameTo(remappedFile);
|
||||
}
|
||||
|
||||
relocations.put(group, identifier + "." + group);
|
||||
relocations.put(group.replace(".", "/"), identifier + "/" + group.replace(".", "/"));
|
||||
|
||||
for (File file : getTextFiles(workingDir)) {
|
||||
FileInputStream fis = new FileInputStream(file);
|
||||
Scanner scanner = new Scanner(fis);
|
||||
StringBuilder sb = new StringBuilder();
|
||||
|
||||
while (scanner.hasNext()) {
|
||||
String line = scanner.nextLine();
|
||||
for (Map.Entry<String, String> entry : relocations.entrySet()) {
|
||||
line = line.replace(entry.getKey(), entry.getValue());
|
||||
}
|
||||
sb.append(line).append("\n");
|
||||
}
|
||||
|
||||
scanner.close();
|
||||
fis.close();
|
||||
FileOutputStream fos = new FileOutputStream(file);
|
||||
fos.write(sb.toString().getBytes());
|
||||
fos.flush();
|
||||
fos.close();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ================================================================================================================
|
||||
* = Manifest Merging =
|
||||
* ================================================================================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
* Process the manifest files from all the input jars and combine them into one
|
||||
* @param mergedTemp - The processing directory
|
||||
* @param forgeTemp - The forge processing directory
|
||||
* @param fabricTemp - The fabric processing directory
|
||||
* @param quiltTemp - The quilt processing directory
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
public void processManifests(File mergedTemp, File forgeTemp, File fabricTemp, File quiltTemp) throws IOException {
|
||||
Manifest mergedManifest = new Manifest();
|
||||
Manifest forgeManifest = new Manifest();
|
||||
Manifest fabricManifest = new Manifest();
|
||||
Manifest quiltManifest = new Manifest();
|
||||
List<Manifest> customManifests = new ArrayList<>();
|
||||
|
||||
FileInputStream fileInputStream = null;
|
||||
if (FileTools.exists(forgeInput)) forgeManifest.read(fileInputStream = new FileInputStream(new File(forgeTemp, "META-INF/MANIFEST.MF")));
|
||||
if (fileInputStream != null) fileInputStream.close();
|
||||
if (FileTools.exists(fabricInput)) fabricManifest.read(fileInputStream = new FileInputStream(new File(fabricTemp, "META-INF/MANIFEST.MF")));
|
||||
if (fileInputStream != null) fileInputStream.close();
|
||||
if (FileTools.exists(quiltInput)) quiltManifest.read(fileInputStream = new FileInputStream(new File(quiltTemp, "META-INF/MANIFEST.MF")));
|
||||
if (fileInputStream != null) fileInputStream.close();
|
||||
|
||||
for (Map.Entry<ModFusionerExtension.CustomConfiguration, Map<File, File>> entry : customTemps.entrySet()) {
|
||||
for (Map.Entry<File, File> entry2 : entry.getValue().entrySet()) {
|
||||
Manifest manifest = new Manifest();
|
||||
if (FileTools.exists(entry2.getKey())) {
|
||||
manifest.read(fileInputStream = new FileInputStream(new File(entry2.getValue(), "META-INF/MANIFEST.MF")));
|
||||
customManifests.add(manifest);
|
||||
}
|
||||
if (fileInputStream != null) fileInputStream.close();
|
||||
}
|
||||
}
|
||||
|
||||
forgeManifest.getMainAttributes().forEach((key, value) -> mergedManifest.getMainAttributes().putValue(key.toString(), value.toString()));
|
||||
fabricManifest.getMainAttributes().forEach((key, value) -> mergedManifest.getMainAttributes().putValue(key.toString(), value.toString()));
|
||||
quiltManifest.getMainAttributes().forEach((key, value) -> mergedManifest.getMainAttributes().putValue(key.toString(), value.toString()));
|
||||
|
||||
for (Manifest manifest : customManifests) {
|
||||
manifest.getMainAttributes().forEach((key, value) -> mergedManifest.getMainAttributes().putValue(key.toString(), value.toString()));
|
||||
}
|
||||
|
||||
if (mergedManifest.getMainAttributes().getValue("MixinConfigs") != null) {
|
||||
String value = mergedManifest.getMainAttributes().getValue("MixinConfigs");
|
||||
String[] mixins;
|
||||
List<String> remappedMixin = new ArrayList<>();
|
||||
|
||||
if (value.contains(",")) {
|
||||
mixins = value.split(",");
|
||||
} else {
|
||||
mixins = new String[]{value};
|
||||
}
|
||||
|
||||
for (String mixin : mixins) {
|
||||
remappedMixin.add("forge-" + mixin);
|
||||
}
|
||||
|
||||
mergedManifest.getMainAttributes().putValue("MixinConfigs", String.join(",", remappedMixin));
|
||||
}
|
||||
|
||||
if (this.forgeMixins != null) {
|
||||
List<String> newForgeMixins = new ArrayList<>();
|
||||
for (String mixin : this.forgeMixins) {
|
||||
newForgeMixins.add("forge-" + mixin);
|
||||
}
|
||||
this.forgeMixins = newForgeMixins;
|
||||
if (!forgeMixins.isEmpty()) mergedManifest.getMainAttributes().putValue("MixinConfigs", String.join(",", this.forgeMixins));
|
||||
}
|
||||
|
||||
remapResources(forgeTemp, fabricTemp, quiltTemp);
|
||||
|
||||
if (this.forgeMixins != null && mergedManifest.getMainAttributes().getValue("MixinConfigs") == null) {
|
||||
logger.debug("Couldn't detect forge mixins. You can ignore this if you are not using mixins with forge.\n" +
|
||||
"If this is an issue then you can configure mixins manually\n" +
|
||||
"Though we'll try to detect them automatically.\n");
|
||||
if (!forgeMixins.isEmpty()) {
|
||||
logger.debug("Detected forge mixins: " + String.join(",", this.forgeMixins) + "\n");
|
||||
mergedManifest.getMainAttributes().putValue("MixinConfigs", String.join(",", this.forgeMixins));
|
||||
}
|
||||
}
|
||||
|
||||
// TODO Manifest Version
|
||||
//mergedManifest.getMainAttributes().putValue(manifestVersionKey, version);
|
||||
|
||||
if (FileTools.exists(forgeInput)) new File(forgeTemp, "META-INF/MANIFEST.MF").delete();
|
||||
if (FileTools.exists(fabricInput)) new File(fabricTemp, "META-INF/MANIFEST.MF").delete();
|
||||
if (FileTools.exists(quiltInput)) new File(quiltTemp, "META-INF/MANIFEST.MF").delete();
|
||||
|
||||
for (Map.Entry<ModFusionerExtension.CustomConfiguration, Map<File, File>> entry : customTemps.entrySet()) {
|
||||
for (Map.Entry<File, File> entry2 : entry.getValue().entrySet()) {
|
||||
if (FileTools.exists(entry2.getKey())) new File(entry2.getValue(), "META-INF/MANIFEST.MF").delete();
|
||||
}
|
||||
}
|
||||
|
||||
new File(FileTools.getOrCreate(new File(mergedTemp, "META-INF")), "MANIFEST.MF").createNewFile();
|
||||
FileOutputStream outputStream = new FileOutputStream(new File(mergedTemp, "META-INF/MANIFEST.MF"));
|
||||
mergedManifest.write(outputStream);
|
||||
outputStream.close();
|
||||
}
|
||||
|
||||
/**
|
||||
* ================================================================================================================
|
||||
* = Duplicate Package Processing =
|
||||
* ================================================================================================================
|
||||
*/
|
||||
|
||||
/**
|
||||
* Build a list of duplicate packages that need to be removed from the final jar
|
||||
*/
|
||||
private void processDuplicatePackages() {
|
||||
if (ignoredPackages != null) {
|
||||
for (String duplicate : ignoredPackages) {
|
||||
String duplicatePath = duplicate.replace(".", "/");
|
||||
|
||||
if (FileTools.exists(forgeInput)) {
|
||||
ignoredDuplicateRelocations.put("forge." + duplicate, duplicate);
|
||||
removeDuplicateRelocationResources.put("forge/" + duplicatePath, duplicatePath);
|
||||
}
|
||||
|
||||
if (FileTools.exists(fabricInput)) {
|
||||
ignoredDuplicateRelocations.put("fabric." + duplicate, duplicate);
|
||||
removeDuplicateRelocationResources.put("fabric/" + duplicatePath, duplicatePath);
|
||||
}
|
||||
|
||||
if (FileTools.exists(quiltInput)) {
|
||||
ignoredDuplicateRelocations.put("quilt." + duplicate, duplicate);
|
||||
removeDuplicateRelocationResources.put("quilt/" + duplicatePath, duplicatePath);
|
||||
}
|
||||
|
||||
for (Map.Entry<ModFusionerExtension.CustomConfiguration, Map<File, File>> entry : customTemps.entrySet()) {
|
||||
for (Map.Entry<File, File> entry2 : entry.getValue().entrySet()) {
|
||||
if (FileTools.exists(entry2.getKey())) {
|
||||
String name = entry.getKey().getProjectName();
|
||||
ignoredDuplicateRelocations.put(name + "." + duplicate, duplicate);
|
||||
removeDuplicateRelocationResources.put(name + "/" + duplicatePath, duplicatePath);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
removeDuplicateRelocationResources.putAll(ignoredDuplicateRelocations);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Relocate duplicate packages from their original location, to a single location
|
||||
* @param mergedTemps - The processing directory
|
||||
* @throws IOException - Thrown if an IO exception occurs
|
||||
*/
|
||||
private void removeDuplicatePackages(File mergedTemps) throws IOException {
|
||||
for (Map.Entry<String, String> entry : ignoredDuplicateRelocations.entrySet()) {
|
||||
File baseFile = new File(mergedTemps, entry.getKey().replace(".", "/") + "/");
|
||||
String name = entry.getValue().replace(".", "/") + "/";
|
||||
File outFile = new File(mergedTemps, name);
|
||||
|
||||
if (outFile.isDirectory())
|
||||
outFile.mkdirs();
|
||||
|
||||
FileTools.moveDirectory(baseFile, outFile);
|
||||
relocations.add(new Relocation(entry.getKey(), entry.getValue()));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove duplicate resources files from extracted jars
|
||||
* @param mergedTemps - The processing directory
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
public void removeDuplicateResources(File mergedTemps) throws IOException {
|
||||
|
||||
if (ignoredPackages != null) {
|
||||
for (File file : getTextFiles(mergedTemps)) {
|
||||
FileInputStream fis = new FileInputStream(file);
|
||||
Scanner scanner = new Scanner(fis);
|
||||
StringBuilder sb = new StringBuilder();
|
||||
|
||||
while (scanner.hasNext()) {
|
||||
String line = scanner.nextLine();
|
||||
for (Map.Entry<String, String> entry : removeDuplicateRelocationResources.entrySet()) {
|
||||
line = line.replace(entry.getKey(), entry.getValue());
|
||||
}
|
||||
sb.append(line).append("\n");
|
||||
}
|
||||
|
||||
scanner.close();
|
||||
fis.close();
|
||||
FileOutputStream fos = new FileOutputStream(file);
|
||||
fos.write(sb.toString().getBytes());
|
||||
fos.flush();
|
||||
fos.close();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
package com.hypherionmc.modfusioner.plugin;
|
||||
|
||||
import groovy.lang.Closure;
|
||||
import lombok.Getter;
|
||||
import lombok.Setter;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* @author HypherionSA
|
||||
* Main Plugin Extension allowing users to configure the plugin
|
||||
*/
|
||||
public class ModFusionerExtension {
|
||||
|
||||
// Group, or package names that will be used for the final jar
|
||||
@Getter @Setter
|
||||
String group;
|
||||
|
||||
// The name of the final jar
|
||||
@Getter @Setter
|
||||
String outJarName;
|
||||
|
||||
// Duplicate packages that fill be de-duplicated upon merge
|
||||
@Getter
|
||||
List<String> duplicateRelocations;
|
||||
|
||||
// The output directory for the merged jar
|
||||
@Getter @Setter
|
||||
String outputDir = "fused";
|
||||
|
||||
// Forge Project Configuration
|
||||
@Getter @Setter
|
||||
ForgeConfiguration forgeConfiguration;
|
||||
|
||||
// Fabric Project Configuration
|
||||
@Getter @Setter
|
||||
FabricConfiguration fabricConfiguration;
|
||||
|
||||
// Quilt Project Configuration
|
||||
@Getter @Setter
|
||||
QuiltConfiguration quiltConfiguration;
|
||||
|
||||
// Custom Project Configurations
|
||||
@Getter
|
||||
List<CustomConfiguration> customConfigurations = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Main extension entry point
|
||||
*/
|
||||
public ModFusionerExtension() {
|
||||
if (group == null || group.isEmpty()) {
|
||||
if (ModFusionerPlugin.rootProject.hasProperty("group") && ModFusionerPlugin.rootProject.property("group") != null) {
|
||||
group = ModFusionerPlugin.rootProject.property("group").toString();
|
||||
} else {
|
||||
ModFusionerPlugin.logger.error("\"group\" is not defined and cannot be set automatically");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a duplicate package to be de-duplicated
|
||||
* @param duplicate - The package name. For example: com.mymod.mylibrary
|
||||
*/
|
||||
public void relocateDuplicate(String duplicate) {
|
||||
if (duplicateRelocations == null) duplicateRelocations = new ArrayList<>();
|
||||
duplicateRelocations.add(duplicate);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add duplicate packages to be de-duplicated
|
||||
* @param duplicates - List of package names. For example: ["com.mymod.mylibrary", "com.google.gson"]
|
||||
*/
|
||||
public void relocateDuplicates(List<String> duplicates) {
|
||||
if (duplicateRelocations == null) duplicateRelocations = new ArrayList<>();
|
||||
duplicateRelocations.addAll(duplicates);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up the forge project configurations
|
||||
*/
|
||||
public ForgeConfiguration forge(Closure<ForgeConfiguration> closure) {
|
||||
forgeConfiguration = new ForgeConfiguration();
|
||||
ModFusionerPlugin.rootProject.configure(forgeConfiguration, closure);
|
||||
return forgeConfiguration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up the fabric project configurations
|
||||
*/
|
||||
public FabricConfiguration fabric(Closure<FabricConfiguration> closure) {
|
||||
fabricConfiguration = new FabricConfiguration();
|
||||
ModFusionerPlugin.rootProject.configure(fabricConfiguration, closure);
|
||||
return fabricConfiguration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up the quilt project configurations
|
||||
*/
|
||||
public QuiltConfiguration quilt(Closure<QuiltConfiguration> closure) {
|
||||
quiltConfiguration = new QuiltConfiguration();
|
||||
ModFusionerPlugin.rootProject.configure(quiltConfiguration, closure);
|
||||
return quiltConfiguration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set up custom project configurations
|
||||
*/
|
||||
public CustomConfiguration custom(Closure<CustomConfiguration> closure) {
|
||||
CustomConfiguration customConfiguration = new CustomConfiguration();
|
||||
ModFusionerPlugin.rootProject.configure(customConfiguration, closure);
|
||||
|
||||
if (customConfiguration.getProjectName() == null || customConfiguration.getProjectName().isEmpty()) {
|
||||
throw new IllegalStateException("Custom project configurations need to specify a \"projectName\"");
|
||||
}
|
||||
customConfigurations.add(customConfiguration);
|
||||
return customConfiguration;
|
||||
}
|
||||
|
||||
/**
|
||||
* Forge Configuration Structure
|
||||
*/
|
||||
public static class ForgeConfiguration {
|
||||
|
||||
// The name of the gradle module that contains the forge code
|
||||
@Getter @Setter
|
||||
public String projectName = "forge";
|
||||
|
||||
// The file that will be used as the input
|
||||
@Getter @Setter
|
||||
String jarLocation;
|
||||
|
||||
// Packages that should be relocated, instead of duplicated
|
||||
@Getter
|
||||
Map<String, String> relocations = new LinkedHashMap<>();
|
||||
|
||||
// Forge Mixin Configs
|
||||
@Getter
|
||||
List<String> mixins = new ArrayList<>();
|
||||
|
||||
/**
|
||||
* Add a package to relocate, instead of duplicating
|
||||
* @param from - The original name of the package. For example: com.google.gson
|
||||
* @param to - The new name of the package. For example: forge.com.google.gson
|
||||
*/
|
||||
public void addRelocate(String from, String to) {
|
||||
this.relocations.put(from, to);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a mixin config file
|
||||
* @param mixin - The name of the mixin config file
|
||||
*/
|
||||
public void mixin(String mixin) {
|
||||
this.mixins.add(mixin);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fabric project configuration
|
||||
*/
|
||||
public static class FabricConfiguration {
|
||||
|
||||
// The name of the gradle module that contains the fabric code
|
||||
@Getter @Setter
|
||||
String projectName = "fabric";
|
||||
|
||||
// The file that will be used as the input
|
||||
@Getter @Setter
|
||||
String jarLocation;
|
||||
|
||||
// Packages that should be relocated, instead of duplicated
|
||||
@Getter
|
||||
Map<String, String> relocations = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Add a package to relocate, instead of duplicating
|
||||
* @param from - The original name of the package. For example: com.google.gson
|
||||
* @param to - The new name of the package. For example: forge.com.google.gson
|
||||
*/
|
||||
public void addRelocate(String from, String to) {
|
||||
this.relocations.put(from, to);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Quilt project configuration
|
||||
*/
|
||||
public static class QuiltConfiguration {
|
||||
|
||||
// The name of the gradle module that contains the quilt code
|
||||
@Getter @Setter
|
||||
String projectName = "quilt";
|
||||
|
||||
// The file that will be used as the input
|
||||
@Getter @Setter
|
||||
String jarLocation;
|
||||
|
||||
// Packages that should be relocated, instead of duplicated
|
||||
@Getter
|
||||
Map<String, String> relocations = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Add a package to relocate, instead of duplicating
|
||||
* @param from - The original name of the package. For example: com.google.gson
|
||||
* @param to - The new name of the package. For example: forge.com.google.gson
|
||||
*/
|
||||
public void addRelocate(String from, String to) {
|
||||
this.relocations.put(from, to);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Custom project configuration
|
||||
*/
|
||||
public static class CustomConfiguration {
|
||||
|
||||
// The name of the gradle module that contains the custom code
|
||||
@Getter @Setter
|
||||
String projectName;
|
||||
|
||||
// The file that will be used as the input
|
||||
@Getter @Setter
|
||||
String jarLocation;
|
||||
|
||||
// Packages that should be relocated, instead of duplicated
|
||||
@Getter
|
||||
Map<String, String> relocations = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Add a package to relocate, instead of duplicating
|
||||
* @param from - The original name of the package. For example: com.google.gson
|
||||
* @param to - The new name of the package. For example: forge.com.google.gson
|
||||
*/
|
||||
public void addRelocation(String from, String to) {
|
||||
this.relocations.put(from, to);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
package com.hypherionmc.modfusioner.plugin;
|
||||
|
||||
import com.hypherionmc.modfusioner.Constants;
|
||||
import com.hypherionmc.modfusioner.task.FuseJarsTask;
|
||||
import org.gradle.api.Plugin;
|
||||
import org.gradle.api.Project;
|
||||
import org.gradle.api.logging.Logger;
|
||||
|
||||
/**
|
||||
* @author HypherionSA
|
||||
* Main Gradle Plugin Class
|
||||
*/
|
||||
public class ModFusionerPlugin implements Plugin<Project> {
|
||||
|
||||
public static Project rootProject;
|
||||
public static Logger logger;
|
||||
public static ModFusionerExtension modFusionerExtension;
|
||||
|
||||
@Override
|
||||
public void apply(Project project) {
|
||||
rootProject = project;
|
||||
logger = project.getLogger();
|
||||
|
||||
modFusionerExtension = rootProject.getExtensions().create(Constants.EXTENSION_NAME, ModFusionerExtension.class);
|
||||
|
||||
rootProject.getTasks().register(Constants.TASK_NAME, FuseJarsTask.class).configure(fusioner -> {
|
||||
fusioner.setGroup(Constants.TASK_GROUP);
|
||||
fusioner.setDescription("Merge multiple jars into a single jar, for multi mod loader projects");
|
||||
});
|
||||
}
|
||||
}
|
||||
185
src/main/java/com/hypherionmc/modfusioner/task/FuseJarsTask.java
Normal file
185
src/main/java/com/hypherionmc/modfusioner/task/FuseJarsTask.java
Normal file
@@ -0,0 +1,185 @@
|
||||
package com.hypherionmc.modfusioner.task;
|
||||
|
||||
import com.hypherionmc.modfusioner.Constants;
|
||||
import com.hypherionmc.modfusioner.actions.JarMergeAction;
|
||||
import com.hypherionmc.modfusioner.plugin.ModFusionerExtension;
|
||||
import com.hypherionmc.modfusioner.plugin.ModFusionerPlugin;
|
||||
import com.hypherionmc.modfusioner.utils.FileChecks;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.gradle.api.DefaultTask;
|
||||
import org.gradle.api.Project;
|
||||
import org.gradle.api.tasks.TaskAction;
|
||||
import org.jetbrains.annotations.Nullable;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardCopyOption;
|
||||
import java.util.*;
|
||||
|
||||
import static com.hypherionmc.modfusioner.plugin.ModFusionerPlugin.modFusionerExtension;
|
||||
import static com.hypherionmc.modfusioner.plugin.ModFusionerPlugin.rootProject;
|
||||
|
||||
/**
|
||||
* @author HypherionSA
|
||||
* The main task of the plugin
|
||||
*/
|
||||
public class FuseJarsTask extends DefaultTask {
|
||||
|
||||
@TaskAction
|
||||
void meldJars() throws IOException {
|
||||
long time = System.currentTimeMillis();
|
||||
|
||||
// Check that all required values are set
|
||||
if (modFusionerExtension.getOutJarName() == null || modFusionerExtension.getGroup() == null) {
|
||||
ModFusionerPlugin.logger.error("Please configure \"group\" and \"outJarName\" manually!");
|
||||
return;
|
||||
}
|
||||
|
||||
ModFusionerPlugin.logger.lifecycle("Start Fusing Jars");
|
||||
|
||||
// Get settings from extension
|
||||
ModFusionerExtension.ForgeConfiguration forgeConfiguration = modFusionerExtension.getForgeConfiguration();
|
||||
ModFusionerExtension.FabricConfiguration fabricConfiguration = modFusionerExtension.getFabricConfiguration();
|
||||
ModFusionerExtension.QuiltConfiguration quiltConfiguration = modFusionerExtension.getQuiltConfiguration();
|
||||
|
||||
List<ModFusionerExtension.CustomConfiguration> customConfigurations = modFusionerExtension.getCustomConfigurations();
|
||||
|
||||
// Try to resolve the projects specific in the extension config
|
||||
Project forgeProject = null;
|
||||
Project fabricProject = null;
|
||||
Project quiltProject = null;
|
||||
Map<Project, ModFusionerExtension.CustomConfiguration> customProjects = new HashMap<>();
|
||||
List<Boolean> validation = new ArrayList<>();
|
||||
|
||||
if (forgeConfiguration != null) {
|
||||
try {
|
||||
forgeProject = rootProject.getAllprojects().stream().filter(p -> !p.getName().equals(rootProject.getName())).filter(p -> p.getName().equalsIgnoreCase(forgeConfiguration.getProjectName())).findFirst().get();
|
||||
validation.add(true);
|
||||
} catch (NoSuchElementException ignored) { }
|
||||
}
|
||||
|
||||
if (fabricConfiguration != null) {
|
||||
try {
|
||||
fabricProject = rootProject.getAllprojects().stream().filter(p -> !p.getName().equals(rootProject.getName())).filter(p -> p.getName().equalsIgnoreCase(fabricConfiguration.getProjectName())).findFirst().get();
|
||||
validation.add(true);
|
||||
} catch (NoSuchElementException ignored) { }
|
||||
}
|
||||
|
||||
if (quiltConfiguration != null) {
|
||||
try {
|
||||
quiltProject = rootProject.getAllprojects().stream().filter(p -> !p.getName().equals(rootProject.getName())).filter(p -> p.getName().equalsIgnoreCase(quiltConfiguration.getProjectName())).findFirst().get();
|
||||
validation.add(true);
|
||||
} catch (NoSuchElementException ignored) { }
|
||||
}
|
||||
|
||||
if (customConfigurations != null) {
|
||||
for (ModFusionerExtension.CustomConfiguration customSettings : customConfigurations) {
|
||||
try {
|
||||
customProjects.put(rootProject.getAllprojects().stream().filter(p -> !p.getName().equals(rootProject.getName())).filter(p -> p.getName().equals(customSettings.getProjectName())).findFirst().get(), customSettings);
|
||||
validation.add(true);
|
||||
} catch (NoSuchElementException ignored) { }
|
||||
}
|
||||
}
|
||||
|
||||
// Check that at least 2 projects are defined
|
||||
if (validation.size() < 2) {
|
||||
if (validation.size() == 1) ModFusionerPlugin.logger.error("Only one project was found. Skipping meldJars task.");
|
||||
if (validation.size() == 0) ModFusionerPlugin.logger.error("No projects were found. Skipping meldJars task.");
|
||||
return;
|
||||
}
|
||||
validation.clear();
|
||||
|
||||
// Try to automatically determine the input jar from the projects
|
||||
File forgeJar = null;
|
||||
File fabricJar = null;
|
||||
File quiltJar = null;
|
||||
Map<ModFusionerExtension.CustomConfiguration, File> customJars = new HashMap<>();
|
||||
|
||||
if (forgeProject != null && forgeConfiguration != null) {
|
||||
forgeJar = getInputFile(forgeConfiguration.getJarLocation(), forgeProject);
|
||||
}
|
||||
|
||||
if (fabricProject != null && fabricConfiguration != null) {
|
||||
fabricJar = getInputFile(fabricConfiguration.getJarLocation(), fabricProject);
|
||||
}
|
||||
|
||||
if (quiltProject != null && quiltConfiguration != null) {
|
||||
quiltJar = getInputFile(quiltConfiguration.getJarLocation(), quiltProject);
|
||||
}
|
||||
|
||||
for (Map.Entry<Project, ModFusionerExtension.CustomConfiguration> entry : customProjects.entrySet()) {
|
||||
File f = getInputFile(entry.getValue().getJarLocation(), entry.getKey());
|
||||
if (f != null)
|
||||
customJars.put(entry.getValue(), f);
|
||||
}
|
||||
|
||||
// Set up the final output jar
|
||||
File mergedJar = new File(rootProject.getRootDir(), modFusionerExtension.getOutputDir() + File.separator + modFusionerExtension.getOutJarName());
|
||||
if (mergedJar.exists()) FileUtils.forceDelete(mergedJar);
|
||||
if (!mergedJar.getParentFile().exists()) mergedJar.getParentFile().mkdirs();
|
||||
|
||||
// Set up the jar merge action
|
||||
JarMergeAction mergeAction = JarMergeAction.of(
|
||||
customJars,
|
||||
modFusionerExtension.getDuplicateRelocations(),
|
||||
modFusionerExtension.getGroup(),
|
||||
new File(rootProject.getRootDir(), ".gradle" + File.separator + "fusioner"),
|
||||
modFusionerExtension.getOutJarName()
|
||||
);
|
||||
|
||||
// Forge
|
||||
mergeAction.setForgeInput(forgeJar);
|
||||
mergeAction.setForgeRelocations(forgeConfiguration == null ? new HashMap<>() : forgeConfiguration.getRelocations());
|
||||
mergeAction.setForgeMixins(forgeConfiguration == null ? new ArrayList<>() : forgeConfiguration.getMixins());
|
||||
|
||||
// Fabric
|
||||
mergeAction.setFabricInput(fabricJar);
|
||||
mergeAction.setFabricRelocations(fabricConfiguration == null ? new HashMap<>() : fabricConfiguration.getRelocations());
|
||||
|
||||
// Quilt
|
||||
mergeAction.setQuiltInput(quiltJar);
|
||||
mergeAction.setQuiltRelocations(quiltConfiguration == null ? new HashMap<>() : quiltConfiguration.getRelocations());
|
||||
|
||||
// Merge them jars
|
||||
Path tempMergedJarPath = mergeAction.mergeJars(false).toPath();
|
||||
|
||||
// Move the merged jar to the specified output directory
|
||||
Files.move(tempMergedJarPath, mergedJar.toPath(), StandardCopyOption.REPLACE_EXISTING);
|
||||
try {
|
||||
Files.setPosixFilePermissions(mergedJar.toPath(), Constants.filePerms);
|
||||
} catch (UnsupportedOperationException | IOException | SecurityException ignored) { }
|
||||
|
||||
// Cleanup
|
||||
mergeAction.clean();
|
||||
|
||||
ModFusionerPlugin.logger.lifecycle("Fused jar created in " + (System.currentTimeMillis() - time) / 1000.0 + " seconds.");
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to determine the input jar of a project
|
||||
* @param jarLocation - The user defined jar location
|
||||
* @param inProject - The project the file should be for or from
|
||||
* @return - The jar file or null
|
||||
*/
|
||||
@Nullable
|
||||
private File getInputFile(@Nullable String jarLocation, Project inProject) {
|
||||
if (jarLocation != null && !jarLocation.isEmpty()) {
|
||||
return new File(inProject.getProjectDir(), jarLocation);
|
||||
} else {
|
||||
int i = 0;
|
||||
for (File file : new File(inProject.getBuildDir(), "libs").listFiles()) {
|
||||
if (file.isDirectory()) continue;
|
||||
if (FileChecks.isZipFile(file)) {
|
||||
if (file.getName().length() < i || i == 0) {
|
||||
i = file.getName().length();
|
||||
return file;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
package com.hypherionmc.modfusioner.utils;
|
||||
|
||||
import org.apache.tika.Tika;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.io.BufferedInputStream;
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.IOException;
|
||||
|
||||
/**
|
||||
* @author HypherionSA
|
||||
* Utility class to perform some checks on files
|
||||
*/
|
||||
public class FileChecks {
|
||||
|
||||
/**
|
||||
* Try to determine if a file is a binary or text file
|
||||
* @param file - The file to test
|
||||
* @return - True if binary
|
||||
*/
|
||||
public static boolean isBinary(@NotNull File file) throws IOException {
|
||||
Tika tika = new Tika();
|
||||
String detectedType = tika.detect(file);
|
||||
return detectedType.equals("application/octet-stream");
|
||||
}
|
||||
|
||||
/**
|
||||
* Test to see if input file is a ZIP file
|
||||
* @param file - The file to test
|
||||
* @return - True if zip
|
||||
*/
|
||||
public static boolean isZipFile(@NotNull File file) {
|
||||
try {
|
||||
if (file.isDirectory()) return false;
|
||||
byte[] bytes = new byte[4];
|
||||
FileInputStream fis = new FileInputStream(file);
|
||||
if (fis.read(bytes) != 4) {
|
||||
return false;
|
||||
}
|
||||
fis.close();
|
||||
final int header = bytes[0] + (bytes[1] << 8) + (bytes[2] << 16) + (bytes[3] << 24);
|
||||
return 0x04034b50 == header;
|
||||
} catch (IOException e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
402
src/main/java/com/hypherionmc/modfusioner/utils/FileTools.java
Normal file
402
src/main/java/com/hypherionmc/modfusioner/utils/FileTools.java
Normal file
@@ -0,0 +1,402 @@
|
||||
package com.hypherionmc.modfusioner.utils;
|
||||
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.apache.commons.io.FilenameUtils;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.Charset;
|
||||
import java.nio.file.CopyOption;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardCopyOption;
|
||||
import java.util.*;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static org.apache.commons.io.FileUtils.*;
|
||||
|
||||
/**
|
||||
* @author HypherionSA
|
||||
* Utility class to make working with files easier
|
||||
*/
|
||||
public class FileTools {
|
||||
|
||||
// Name of the META-INF directory inside the mods
|
||||
private static final String META_DIR = "META-INF";
|
||||
|
||||
// Fabric folder name of "shaded" jars
|
||||
private static final String JARS_DIR = "jars";
|
||||
|
||||
// Forge folder name of Jar in Jar jars
|
||||
private static final String JARJAR_DIR = "jarjar";
|
||||
|
||||
// Services folder name
|
||||
private static final String SERVICES_DIR = "services";
|
||||
|
||||
/**
|
||||
* Test to see if input file is not null, and exists on the drive
|
||||
* @param file - The file to test
|
||||
* @return - True if not null and exists on drive
|
||||
*/
|
||||
public static boolean exists(File file) {
|
||||
return file != null && file.exists();
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a directory if it doesn't exist
|
||||
* @param file - The directory to create
|
||||
* @return - The "now existent" directory
|
||||
*/
|
||||
public static File getOrCreate(File file) {
|
||||
if (!file.exists())
|
||||
file.mkdirs();
|
||||
|
||||
return file;
|
||||
}
|
||||
|
||||
/**
|
||||
* Move a directory from one location to another
|
||||
* @param sourceDir - The directory to copy from
|
||||
* @param outDir - The directory to copy to
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
public static void moveDirectory(File sourceDir, File outDir) throws IOException {
|
||||
if (!exists(sourceDir))
|
||||
return;
|
||||
|
||||
File[] files = sourceDir.listFiles();
|
||||
if (files == null)
|
||||
return;
|
||||
|
||||
for (File f : files) {
|
||||
File outPath = new File(outDir, f.getName());
|
||||
|
||||
if (f.isDirectory()) {
|
||||
moveDirectoryInternal(f, outPath);
|
||||
}
|
||||
|
||||
if (f.isFile()) {
|
||||
moveFileInternal(f, outPath, StandardCopyOption.REPLACE_EXISTING);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copied from Apache Commons, with the "Directory Must Not Exist" check removed
|
||||
* @param srcDir - The source directory
|
||||
* @param destDir - The destination directory
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
private static void moveDirectoryInternal(final File srcDir, final File destDir) throws IOException {
|
||||
validateMoveParameters(srcDir, destDir);
|
||||
requireDirectory(srcDir, "srcDir");
|
||||
|
||||
if (!srcDir.renameTo(destDir)) {
|
||||
if (destDir.getCanonicalPath().startsWith(srcDir.getCanonicalPath() + File.separator)) {
|
||||
throw new IOException("Cannot move directory: " + srcDir + " to a subdirectory of itself: " + destDir);
|
||||
}
|
||||
copyDirectory(srcDir, destDir);
|
||||
deleteDirectory(srcDir);
|
||||
if (srcDir.exists()) {
|
||||
throw new IOException("Failed to delete original directory '" + srcDir +
|
||||
"' after copy to '" + destDir + "'");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Copied from Apache Commons, with the "File Must Not Exist" check removed
|
||||
* @param srcFile - The source file
|
||||
* @param destFile - The destination file
|
||||
* @param copyOptions - {@link StandardCopyOption} to be used with the move process
|
||||
* @throws IOException - Thrown if an IO error occurs
|
||||
*/
|
||||
public static void moveFileInternal(final File srcFile, final File destFile, final CopyOption... copyOptions)
|
||||
throws IOException {
|
||||
validateMoveParameters(srcFile, destFile);
|
||||
requireFile(srcFile, "srcFile");
|
||||
final boolean rename = srcFile.renameTo(destFile);
|
||||
if (!rename) {
|
||||
copyFile(srcFile, destFile, copyOptions);
|
||||
if (!srcFile.delete()) {
|
||||
FileUtils.deleteQuietly(destFile);
|
||||
throw new IOException("Failed to delete original file '" + srcFile +
|
||||
"' after copy to '" + destFile + "'");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check that input values are not null and that the source file/directory exists
|
||||
* @param source - The source file/directory
|
||||
* @param destination - The destination file/directory
|
||||
* @throws FileNotFoundException - Thrown if the source file/directory does not exist
|
||||
*/
|
||||
private static void validateMoveParameters(final File source, final File destination) throws FileNotFoundException {
|
||||
Objects.requireNonNull(source, "source");
|
||||
Objects.requireNonNull(destination, "destination");
|
||||
if (!source.exists()) {
|
||||
throw new FileNotFoundException("Source '" + source + "' does not exist");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the source input is a directory
|
||||
* @param directory - The source directory
|
||||
* @param name - Identifier for the error message
|
||||
* @return - Return the directory if it's valid
|
||||
*/
|
||||
private static File requireDirectory(final File directory, final String name) {
|
||||
Objects.requireNonNull(directory, name);
|
||||
if (!directory.isDirectory()) {
|
||||
throw new IllegalArgumentException("Parameter '" + name + "' is not a directory: '" + directory + "'");
|
||||
}
|
||||
return directory;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the source input is not a directory
|
||||
* @param file - The source file
|
||||
* @param name - Identifier for the error message
|
||||
* @return - Return the file if it's valid
|
||||
*/
|
||||
private static File requireFile(final File file, final String name) {
|
||||
Objects.requireNonNull(file, name);
|
||||
if (!file.isFile()) {
|
||||
throw new IllegalArgumentException("Parameter '" + name + "' is not a file: " + file);
|
||||
}
|
||||
return file;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of embedded jar files from the input jar
|
||||
* @param dir - The directory the jar was extracted to
|
||||
* @return - List of embedded jars
|
||||
*/
|
||||
@NotNull
|
||||
public static List<File> embeddedJars(File dir) {
|
||||
List<File> returnJars = new ArrayList<>();
|
||||
|
||||
// Directories
|
||||
File metaInf = new File(dir, META_DIR);
|
||||
File jarsDir = new File(metaInf, JARS_DIR);
|
||||
File jarJarDir = new File(metaInf, JARJAR_DIR);
|
||||
|
||||
if (jarsDir.exists()) {
|
||||
File[] list = jarsDir.listFiles();
|
||||
|
||||
if (list != null) {
|
||||
for (File jar : list) {
|
||||
if (FilenameUtils.getExtension(jar.getName()).equalsIgnoreCase("jar"))
|
||||
returnJars.add(jar);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (jarJarDir.exists()) {
|
||||
File[] list = jarJarDir.listFiles();
|
||||
|
||||
if (list != null) {
|
||||
for (File jar : list) {
|
||||
if (FilenameUtils.getExtension(jar.getName()).equalsIgnoreCase("jar"))
|
||||
returnJars.add(jar);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return returnJars;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all text files from the input jar
|
||||
* @param dir - The directory the jar was extracted to
|
||||
* @return - List of text files
|
||||
*/
|
||||
@NotNull
|
||||
public static List<File> getTextFiles(@NotNull File dir) throws IOException {
|
||||
List<File> returnFiles = new ArrayList<>();
|
||||
File[] list = dir.listFiles();
|
||||
if (list == null)
|
||||
return returnFiles;
|
||||
|
||||
for (File file : list) {
|
||||
if (file.isDirectory()) {
|
||||
returnFiles.addAll(getTextFiles(file));
|
||||
} else {
|
||||
if (!FilenameUtils.getExtension(file.getName()).equalsIgnoreCase("class")) {
|
||||
if (!FileChecks.isBinary(file))
|
||||
returnFiles.add(file);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return returnFiles;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of mixin configurations from the input jar
|
||||
* @param dir - The directory the jar was extracted to
|
||||
* @param includeRefmaps - Should reference maps be included in the search
|
||||
* @return - List of mixin configs and optionally refmaps
|
||||
* @throws IOException - Thrown when an IO error occurs
|
||||
*/
|
||||
@NotNull
|
||||
public static List<File> getMixins(@NotNull File dir, boolean includeRefmaps) throws IOException {
|
||||
List<File> files = getTextFiles(dir);
|
||||
List<File> returnMixins = new ArrayList<>();
|
||||
|
||||
for (File file : files) {
|
||||
if (FilenameUtils.getExtension(file.getName()).equalsIgnoreCase("json")) {
|
||||
String text = FileUtils.readFileToString(file, Charset.defaultCharset());
|
||||
|
||||
if (includeRefmaps) {
|
||||
if (text.contains("\"mappings\":") || text.contains("\"data\":")) {
|
||||
returnMixins.add(file);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
|
||||
if (text.contains("\"package\":")) {
|
||||
returnMixins.add(file);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return returnMixins;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of refmaps from input jar
|
||||
* @param dir - The directory the jar was extracted to
|
||||
* @return - A list of mixin refmaps
|
||||
* @throws IOException - Thrown when an IO error occurs
|
||||
*/
|
||||
@NotNull
|
||||
public static List<File> getRefmaps(@NotNull File dir) throws IOException {
|
||||
List<File> files = getTextFiles(dir);
|
||||
List<File> refmaps = new ArrayList<>();
|
||||
|
||||
for (File file : files) {
|
||||
if (FilenameUtils.getExtension(file.getName()).equals("json")) {
|
||||
String text = FileUtils.readFileToString(file, Charset.defaultCharset());
|
||||
if (text.contains("\"mappings\":") || text.contains("\"data\":"))
|
||||
refmaps.add(file);
|
||||
}
|
||||
}
|
||||
|
||||
return refmaps;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of accesswideners from the input jar
|
||||
* @param dir - The directory the jar was extracted to
|
||||
* @return - A list of access wideners
|
||||
* @throws IOException - Thrown when an IO error occurs
|
||||
*/
|
||||
@NotNull
|
||||
public static List<File> getAccessWideners(@NotNull File dir) throws IOException {
|
||||
List<File> files = getTextFiles(dir);
|
||||
List<File> wideners = new ArrayList<>();
|
||||
|
||||
for (File file : files) {
|
||||
if (FilenameUtils.getExtension(file.getName()).equals("accesswidener")) {
|
||||
wideners.add(file);
|
||||
continue;
|
||||
}
|
||||
|
||||
FileInputStream fis = new FileInputStream(file);
|
||||
Scanner scanner = new Scanner(fis);
|
||||
if (scanner.hasNext()) {
|
||||
if (scanner.nextLine().startsWith("accessWidener"))
|
||||
wideners.add(file);
|
||||
}
|
||||
scanner.close();
|
||||
fis.close();
|
||||
}
|
||||
|
||||
return wideners;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of platform services from the input jar
|
||||
* @param dir - The directory the jar was extracted to
|
||||
* @param group - The group to search for
|
||||
* @return - A list of service files
|
||||
*/
|
||||
@NotNull
|
||||
public static List<File> getPlatformServices(@NotNull File dir, @NotNull String group) {
|
||||
List<File> services = new ArrayList<>();
|
||||
|
||||
File metaInf = new File(dir, META_DIR);
|
||||
File servicesLocation = new File(metaInf, SERVICES_DIR);
|
||||
|
||||
if (servicesLocation.exists()) {
|
||||
File[] list = servicesLocation.listFiles();
|
||||
if (list != null) {
|
||||
for (File service : list) {
|
||||
if (FilenameUtils.getBaseName(service.getName()).contains(group))
|
||||
services.add(service);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return services;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the first directory from a file name
|
||||
* @param fileName - The input file name
|
||||
* @return - The name of the first directory specified in the file name
|
||||
*/
|
||||
@NotNull
|
||||
public static String getFirstDirectory(@NotNull String fileName) {
|
||||
int end = fileName.indexOf(File.separator);
|
||||
if (end != -1) {
|
||||
return fileName.substring(0, end);
|
||||
}
|
||||
end = fileName.indexOf("/");
|
||||
if (end != -1) {
|
||||
return fileName.substring(0, end);
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a directory if it doesn't exist, or delete and recreate it if it does
|
||||
* @param dir - The input directory
|
||||
* @return - The new directory
|
||||
* @throws IOException - Thrown when an IO exception occurs
|
||||
*/
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
@NotNull
|
||||
public static File createOrReCreate(@NotNull File dir) throws IOException {
|
||||
if (dir.exists())
|
||||
FileUtils.deleteQuietly(dir);
|
||||
|
||||
if (!dir.exists())
|
||||
dir.mkdirs();
|
||||
|
||||
return dir;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a file if it doesn't exist, or delete and recreate it if it does
|
||||
* @param dir - The input directory
|
||||
* @return - The new file
|
||||
* @throws IOException - Thrown when an IO error occurs
|
||||
*/
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
@NotNull
|
||||
public static File createOrReCreateF(@NotNull File dir) throws IOException {
|
||||
if (dir.exists())
|
||||
FileUtils.deleteQuietly(dir);
|
||||
|
||||
if (!dir.exists())
|
||||
dir.createNewFile();
|
||||
|
||||
return dir;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user