2027

Committed 08 Feb 2026 06:52PM UTC coverage: 89.941% (-0.02%) from 89.961%

Build # 2027

Build Type

push

github

Committed by

web-flow

Commit Message

Remove the Eclipse based Java file merger in favor of the merger in the core library (#1443)

* Remove unnecessary extra line in JavaDoc for most cases

* Support unmergeable Java files

* Generic files are never mergeable

* Remove Java merger from the Eclipse plugin

The new merger in the core project is better tested and more capable.

* Package our dependencies in a new plugin

* Remove the old core plugin

There is no need for this to be separated now. It only held the callback implementations after we removed the merger.

* Use Eclipse BND tools to keep binaries out of our source repo

* Revert a little change no longer needed

* Remove the old target platform definitions - no need to keep them around

* Remove deprecated source feature generation

Replace it with an explicit source feature

* Remove deprecated source feature generation

Replace it with an explicit source feature

* Remove unnecessary dependencies

* Restore the function where we add the Java project to the runtime classpath

This seems to have changed in more recent Eclipse versions. The project was getting added to the bootstrap classpath and not the user classpath.

* Documentation Updates

* Setup artifact signing in the release profile

* Refactor the main entry point and shell callback so that Java merging is configurable and optional

* Refactor the main entry point and shell callback so that Java merging is configurable and optional

Coverage Stats

2295 of 3073 branches covered (74.68%)

66 of 96 new or added lines in 8 files covered. (68.75%)

4 existing lines in 3 files now uncovered.

11641 of 12943 relevant lines covered (89.94%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/core/mybatis-generator-core/src/main/java/org/mybatis/generator/ant/GeneratorAntTask.java

/*
 *    Copyright 2006-2026 the original author or 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.
 */
package org.mybatis.generator.ant;

import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
import static org.mybatis.generator.internal.util.messages.Messages.getString;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.types.PropertySet;
import org.jspecify.annotations.Nullable;
import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;

/**
 * This is an Ant task that will run the generator. The following is a sample
 * Ant script that shows how to run the generator from Ant:
 *
 * <pre>
 *  &lt;project default="genfiles" basedir="."&gt;
 *    &lt;property name="generated.source.dir" value="${basedir}" /&gt;
 *    &lt;target name="genfiles" description="Generate the files"&gt;
 *      &lt;taskdef name="mbgenerator"
 *               classname="org.mybatis.generator.ant.GeneratorAntTask"
 *               classpath="mybatis-generator-core-x.x.x.jar" /&gt;
 *      &lt;mbgenerator overwrite="true" configfile="generatorConfig.xml" verbose="false" &gt;
 *        &lt;propertyset&gt;
 *          &lt;propertyref name="generated.source.dir"/&gt;
 *        &lt;/propertyset&gt;
 *      &lt;/mbgenerator&gt;
 *    &lt;/target&gt;
 *  &lt;/project&gt;
 * </pre>
 *
 * <p>The task requires that the attribute "configFile" be set to an existing XML
 * configuration file.
 *
 * <p>The task supports these optional attributes:
 * <ul>
 *     <li>"overwrite" - if true, then existing Java files will be overwritten. if
 *         false (default), then existing Java files will be untouched and the generator
 *         will write new Java files with a unique name</li>
 *     <li>"verbose" - if true, then the generator will log progress messages to the
 *         Ant log. Default is false</li>
 *     <li>"contextIds" - a comma delimited list of contaxtIds to use for this run</li>
 *     <li>"fullyQualifiedTableNames" - a comma-delimited list of fully qualified
 *         table names to use for this run</li>
 *     <li>
 *         "javaMergeEnabled" - if true, then existing Java files will be merged. if
 *         false (default), then existing Java files will be untouched and the generator
 *         will write new Java files with a unique name
 *     </li>
 * </ul>
 *
 *
 * @author Jeff Butler
 */
public class GeneratorAntTask extends Task {

    private @Nullable String configfile;
    private boolean overwrite;
    private @Nullable PropertySet propertyset;
    private boolean verbose;
    private @Nullable String contextIds;
    private @Nullable String fullyQualifiedTableNames;
    private boolean javaMergeEnabled;

    @Override
    public void execute() {
        File configurationFile = calculateConfigurationFile();
        Set<String> fullyQualifiedTables = calculateTables();
        Set<String> contexts = calculateContexts();

        List<String> warnings = new ArrayList<>();
        try {
            Properties p = propertyset == null ? null : propertyset.getProperties();

            ConfigurationParser cp = new ConfigurationParser(p);
            Configuration config = cp.parseConfiguration(configurationFile);
            warnings.addAll(cp.getWarnings());

            MyBatisGenerator myBatisGenerator = new MyBatisGenerator.Builder()
                    .withConfiguration(config)
                    .withShellCallback(new DefaultShellCallback())
                    .withProgressCallback(new AntProgressCallback(this, verbose))
                    .withContextIds(contexts)
                    .withFullyQualifiedTableNames(fullyQualifiedTables)
                    .withJavaFileMergeEnabled(javaMergeEnabled)
                    .withOverwriteEnabled(overwrite)
                    .build();

            warnings.addAll(myBatisGenerator.generateAndWrite());
        } catch (XMLParserException | InvalidConfigurationException e) {
            for (String error : e.getErrors()) {
                log(error, Project.MSG_ERR);
            }

            throw new BuildException(e.getMessage());
        } catch (SQLException | IOException e) {
            throw new BuildException(e.getMessage());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            log(e, Project.MSG_ERR);
            throw new BuildException(e.getMessage());
        }

        for (String error : warnings) {
            log(error, Project.MSG_WARN);
        }
    }

    private Set<String> calculateContexts() {
        Set<String> contexts = new HashSet<>();
        if (stringHasValue(contextIds)) {
            StringTokenizer st = new StringTokenizer(contextIds, ","); //$NON-NLS-1$
            while (st.hasMoreTokens()) {
                String s = st.nextToken().trim();
                if (!s.isEmpty()) {
                    contexts.add(s);
                }
            }
        }
        return contexts;
    }

    private Set<String> calculateTables() {
        Set<String> fullyqualifiedTables = new HashSet<>();
        if (stringHasValue(fullyQualifiedTableNames)) {
            StringTokenizer st = new StringTokenizer(fullyQualifiedTableNames, ","); //$NON-NLS-1$
            while (st.hasMoreTokens()) {
                String s = st.nextToken().trim();
                if (!s.isEmpty()) {
                    fullyqualifiedTables.add(s);
                }
            }
        }
        return fullyqualifiedTables;
    }

    private File calculateConfigurationFile() {
        if (!stringHasValue(configfile)) {
            throw new BuildException(getString("RuntimeError.0")); //$NON-NLS-1$
        }


        Path configurationFile = Path.of(configfile);
        if (Files.notExists(configurationFile)) {
            throw new BuildException(getString("RuntimeError.1", configfile)); //$NON-NLS-1$
        }
        return configurationFile.toFile();
    }

    public @Nullable String getConfigfile() {
        return configfile;
    }

    public void setConfigfile(String configfile) {
        this.configfile = configfile;
    }

    public boolean isOverwrite() {
        return overwrite;
    }

    public void setOverwrite(boolean overwrite) {
        this.overwrite = overwrite;
    }

    public PropertySet createPropertyset() {
        if (propertyset == null) {
            propertyset = new PropertySet();
        }

        return propertyset;
    }

    public boolean isVerbose() {
        return verbose;
    }

    public void setVerbose(boolean verbose) {
        this.verbose = verbose;
    }

    public @Nullable String getContextIds() {
        return contextIds;
    }

    public void setContextIds(String contextIds) {
        this.contextIds = contextIds;
    }

    public @Nullable String getFullyQualifiedTableNames() {
        return fullyQualifiedTableNames;
    }

    public void setFullyQualifiedTableNames(String fullyQualifiedTableNames) {
        this.fullyQualifiedTableNames = fullyQualifiedTableNames;
    }

    public boolean isJavaMergeEnabled() {
        return javaMergeEnabled;
    }

    public void setJavaMergeEnabled(boolean javaMergeEnabled) {
        this.javaMergeEnabled = javaMergeEnabled;
    }
}

1	/*
2	* Copyright 2006-2026 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package org.mybatis.generator.ant;
17
18	import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
19	import static org.mybatis.generator.internal.util.messages.Messages.getString;
20
21	import java.io.File;
22	import java.io.IOException;
23	import java.nio.file.Files;
24	import java.nio.file.Path;
25	import java.sql.SQLException;
26	import java.util.ArrayList;
27	import java.util.HashSet;
28	import java.util.List;
29	import java.util.Properties;
30	import java.util.Set;
31	import java.util.StringTokenizer;
32
33	import org.apache.tools.ant.BuildException;
34	import org.apache.tools.ant.Project;
35	import org.apache.tools.ant.Task;
36	import org.apache.tools.ant.types.PropertySet;
37	import org.jspecify.annotations.Nullable;
38	import org.mybatis.generator.api.MyBatisGenerator;
39	import org.mybatis.generator.config.Configuration;
40	import org.mybatis.generator.config.xml.ConfigurationParser;
41	import org.mybatis.generator.exception.InvalidConfigurationException;
42	import org.mybatis.generator.exception.XMLParserException;
43	import org.mybatis.generator.internal.DefaultShellCallback;
44
45	/**
46	* This is an Ant task that will run the generator. The following is a sample
47	* Ant script that shows how to run the generator from Ant:
48	*
49	* <pre>
50	* <project default="genfiles" basedir=".">
51	* <property name="generated.source.dir" value="${basedir}" />
52	* <target name="genfiles" description="Generate the files">
53	* <taskdef name="mbgenerator"
54	* classname="org.mybatis.generator.ant.GeneratorAntTask"
55	* classpath="mybatis-generator-core-x.x.x.jar" />
56	* <mbgenerator overwrite="true" configfile="generatorConfig.xml" verbose="false" >
57	* <propertyset>
58	* <propertyref name="generated.source.dir"/>
59	* </propertyset>
60	* </mbgenerator>
61	* </target>
62	* </project>
63	* </pre>
64	*
65	* <p>The task requires that the attribute "configFile" be set to an existing XML
66	* configuration file.
67	*
68	* <p>The task supports these optional attributes:
69	* <ul>
70	* <li>"overwrite" - if true, then existing Java files will be overwritten. if
71	* false (default), then existing Java files will be untouched and the generator
72	* will write new Java files with a unique name</li>
73	* <li>"verbose" - if true, then the generator will log progress messages to the
74	* Ant log. Default is false</li>
75	* <li>"contextIds" - a comma delimited list of contaxtIds to use for this run</li>
76	* <li>"fullyQualifiedTableNames" - a comma-delimited list of fully qualified
77	* table names to use for this run</li>
78	* <li>
79	* "javaMergeEnabled" - if true, then existing Java files will be merged. if
80	* false (default), then existing Java files will be untouched and the generator
81	* will write new Java files with a unique name
82	* </li>
83	* </ul>
84	*
85	*
86	* @author Jeff Butler
87	*/
88	public class GeneratorAntTask extends Task {	×
89
90	private @Nullable String configfile;
91	private boolean overwrite;
92	private @Nullable PropertySet propertyset;
93	private boolean verbose;
94	private @Nullable String contextIds;
95	private @Nullable String fullyQualifiedTableNames;
96	private boolean javaMergeEnabled;
97
98	@Override
99	public void execute() {
100	File configurationFile = calculateConfigurationFile();	×
101	Set<String> fullyQualifiedTables = calculateTables();	×
102	Set<String> contexts = calculateContexts();	×
103
104	List<String> warnings = new ArrayList<>();	×
105	try {
106	Properties p = propertyset == null ? null : propertyset.getProperties();	×
107
108	ConfigurationParser cp = new ConfigurationParser(p);	×
109	Configuration config = cp.parseConfiguration(configurationFile);	×
110	warnings.addAll(cp.getWarnings());	×
111
UNCOV 112	MyBatisGenerator myBatisGenerator = new MyBatisGenerator.Builder()	×
113	.withConfiguration(config)	×
NEW 114	.withShellCallback(new DefaultShellCallback())	×
115	.withProgressCallback(new AntProgressCallback(this, verbose))	×
116	.withContextIds(contexts)	×
117	.withFullyQualifiedTableNames(fullyQualifiedTables)	×
NEW 118	.withJavaFileMergeEnabled(javaMergeEnabled)	×
NEW 119	.withOverwriteEnabled(overwrite)	×
UNCOV 120	.build();	×
121
122	warnings.addAll(myBatisGenerator.generateAndWrite());	×
123	} catch (XMLParserException \| InvalidConfigurationException e) {	×
124	for (String error : e.getErrors()) {	×
125	log(error, Project.MSG_ERR);	×
126	}	×
127
128	throw new BuildException(e.getMessage());	×
129	} catch (SQLException \| IOException e) {	×
130	throw new BuildException(e.getMessage());	×
131	} catch (InterruptedException e) {	×
132	Thread.currentThread().interrupt();	×
133	} catch (Exception e) {	×
134	log(e, Project.MSG_ERR);	×
135	throw new BuildException(e.getMessage());	×
136	}	×
137
138	for (String error : warnings) {	×
139	log(error, Project.MSG_WARN);	×
140	}	×
141	}	×
142
143	private Set<String> calculateContexts() {
144	Set<String> contexts = new HashSet<>();	×
145	if (stringHasValue(contextIds)) {	×
146	StringTokenizer st = new StringTokenizer(contextIds, ","); //$NON-NLS-1$	×
147	while (st.hasMoreTokens()) {	×
148	String s = st.nextToken().trim();	×
149	if (!s.isEmpty()) {	×
150	contexts.add(s);	×
151	}
152	}	×
153	}
154	return contexts;	×
155	}
156
157	private Set<String> calculateTables() {
158	Set<String> fullyqualifiedTables = new HashSet<>();	×
159	if (stringHasValue(fullyQualifiedTableNames)) {	×
160	StringTokenizer st = new StringTokenizer(fullyQualifiedTableNames, ","); //$NON-NLS-1$	×
161	while (st.hasMoreTokens()) {	×
162	String s = st.nextToken().trim();	×
163	if (!s.isEmpty()) {	×
164	fullyqualifiedTables.add(s);	×
165	}
166	}	×
167	}
168	return fullyqualifiedTables;	×
169	}
170
171	private File calculateConfigurationFile() {
172	if (!stringHasValue(configfile)) {	×
173	throw new BuildException(getString("RuntimeError.0")); //$NON-NLS-1$	×
174	}
175
176
177	Path configurationFile = Path.of(configfile);	×
178	if (Files.notExists(configurationFile)) {	×
179	throw new BuildException(getString("RuntimeError.1", configfile)); //$NON-NLS-1$	×
180	}
181	return configurationFile.toFile();	×
182	}
183
184	public @Nullable String getConfigfile() {
185	return configfile;	×
186	}
187
188	public void setConfigfile(String configfile) {
189	this.configfile = configfile;	×
190	}	×
191
192	public boolean isOverwrite() {
193	return overwrite;	×
194	}
195
196	public void setOverwrite(boolean overwrite) {
197	this.overwrite = overwrite;	×
198	}	×
199
200	public PropertySet createPropertyset() {
201	if (propertyset == null) {	×
202	propertyset = new PropertySet();	×
203	}
204
205	return propertyset;	×
206	}
207
208	public boolean isVerbose() {
209	return verbose;	×
210	}
211
212	public void setVerbose(boolean verbose) {
213	this.verbose = verbose;	×
214	}	×
215
216	public @Nullable String getContextIds() {
217	return contextIds;	×
218	}
219
220	public void setContextIds(String contextIds) {
221	this.contextIds = contextIds;	×
222	}	×
223
224	public @Nullable String getFullyQualifiedTableNames() {
225	return fullyQualifiedTableNames;	×
226	}
227
228	public void setFullyQualifiedTableNames(String fullyQualifiedTableNames) {
229	this.fullyQualifiedTableNames = fullyQualifiedTableNames;	×
230	}	×
231
232	public boolean isJavaMergeEnabled() {
233	return javaMergeEnabled;	×
234	}
235
236	public void setJavaMergeEnabled(boolean javaMergeEnabled) {
237	this.javaMergeEnabled = javaMergeEnabled;	×
238	}	×
239	}

mybatis / generator / 2027

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous