skrueger/versionnumber/ReleaseUtil.java

package skrueger.versionnumber;

import java.io.InputStream;
import java.net.URL;
import java.util.Properties;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.log4j.Logger;

/**
 * This class provides static utility classes that help releasing and versioning
 * applications. Especially usefull in combination with maven2's
 * buildnumber-maven plugin.<br/>
 * 
 * @author Stefan A. Tzeggai
 * 
 *         Wer sein Maven Projekt wie folgt konfiguriert kann die Maven +
 *         SVN-Revisionnummer als Programmversion verwenden, z.B.
 *         "v1.5-SNAPSHOT r123"
 * 
 * <br/>
 *         1. pom.xml anpassen: <code>
                                        <plugin>
                                <groupId>org.codehaus.mojo</groupId>
                                <artifactId>buildnumber-maven-plugin</artifactId>
                                <version>1.0-beta-4</version>
                                <executions>
                                        <execution>
                                                <id>buildnumber in phase initialize</id>
                                                <phase>initialize</phase>
                                                <goals>
                                                        <goal>create</goal>
                                                </goals>
                                        </execution>
                                </executions>
                                <configuration>
                                        <!-- <doCheck>false</doCheck> <doUpdate>false</doUpdate> <providerImplementations> 
                                                <svn>javasvn</svn> </providerImplementations> -->
                                        <format>{0,date,yyyyMMddHHmm}</format>
                                        <items>
                                                <item>timestamp</item>
                                        </items>
                                </configuration>
                        </plugin>
                </code><br/>
 *         2. Datei src/main/resources.properties mit foglenden Inhalt anlegen:
 *         <code>
                                #Properties describing this release/build
                                version=${project.version}
                                build=${buildNumber}
                </code><br/>
 *         3. Filtering für die src/main/resources.properties - Datei
 *         einschalten:<code>
 *         
                        <resources>
                                <resource>
                                        <filtering>true</filtering>
                                        <directory>src/main/resources</directory>
                                        <includes><include>release.properties</include></includes>
                                </resource>
                        </resources>
            </code> <br/>
 * <br/>
 *         Eine maven Fehlermeldung "The scm url cannot be null." ist
 *         irreführend. In wirklichkeit wird ein Eintrag
 *         <scm>...<developerConnection>..</scm> verlangt.
 */
public class ReleaseUtil {
        private static Logger log = Logger.getLogger(ReleaseUtil.class);

        /**
         * Returns all (the most) information in one sting. This is a public method
         * which never throws an Exception.
         * 
         * @param clazz
         *            Pass a class that resides in the same "project" or jar, where
         *            the /release.properties resides as well.
         * 
         * @return A {@link String} like "v1.4 r243" where the first number is the
         *         maven project version and the second number is the SCM revision.
         *         Returns "unknown version" if it can't be determined.
         */
        public static String getVersionInfo(Class<?> clazz) {
                try {
                        return "v" + getVersion(clazz) + "-r" + getVersionBuild(clazz);
                } catch (final Exception e) {
                        return "unknown version";
                }
        }

        /**
         * @param clazz
         *            Pass a class that resides in the same "project" or jar, where
         *            the /release.properties resides as well.
         * 
         * @Return the major part of the software version or 0 if a problem occurs.
         */
        public static String getVersionBuild(Class<?> clazz) {
                try {
                        final URL releasePropsURL = clazz
                                        .getResource("/release.properties");

                        final Properties releaseProps = new Properties();
                        final InputStream openStream = releasePropsURL.openStream();
                        try {
                                releaseProps.load(openStream);
                        } finally {
                                openStream.close();
                        }
                        final String str = releaseProps.getProperty("build", "0");

                        if (str.equals("${buildNumber}")) {
                                // We are in development or Maven didn't filter the properties
                                // while building.
                                return "0";
                        }

                        return str;
                } catch (final Exception e) {
                        log.error(
                                        "/release.properties could not be read from "
                                                        + clazz.getSimpleName(), e);
                        return "0";
                }

        }

        /**
         * @param clazz
         *            Pass a class that resides in the same "project" or jar, where
         *            the /release.properties resides as well.
         * 
         * @return A Version String like "1.3" or "1.6". Returns "0.0" if a problem
         *         occurred.
         */
        public static String getVersion(Class<?> clazz) {
                final String defaultVer = "0.0";

                try {

                        final URL releasePropsURL = clazz
                                        .getResource("/release.properties");

                        final Properties releaseProps = new Properties();
                        final InputStream openStream = releasePropsURL.openStream();
                        try {
                                releaseProps.load(openStream);
                        } finally {
                                openStream.close();
                        }

                        final String versionProperty = releaseProps.getProperty("version",
                                        defaultVer);
                        if (versionProperty.equals("${project.version}"))
                                return defaultVer;
                        return versionProperty;
                } catch (final Exception e) {
                        log.error(
                                        "/release.properties could not be read from "
                                                        + clazz.getSimpleName(), e);
                        return defaultVer;
                }

        }

        /**
         * @param clazz
         *            Pass a class that resides in the same "project" or jar, where
         *            the /release.properties resides as well.
         * 
         * @return Mayor version number part, e.g. "1" for version "1.3". Returns 0
         *         if a problem occurred.
         */
        public static int getVersionMaj(Class<?> clazz) {
                try {
                        return Integer.parseInt(getVersion(clazz).split("\\.")[0]);
                } catch (final Exception e) {
                        log.error("Major version number '" + getVersion(clazz)
                                        + "' part could not be parsed from could not parsed (from "
                                        + clazz.getSimpleName() + "). Must be numeric!", e);
                        return 0;
                }
        }

        /**
         * @param clazz
         *            Pass a class that resides in the same "project" or jar, where
         *            the /release.properties resides as well.
         * 
         * @return Minor version number part, e.g. "3" for version "1.3". Returns 0
         *         if a problem occurred.
         */
        public static int getVersionMin(Class<?> clazz) {
                try {
                        return extractMinVersionFromString(getVersion(clazz));
                } catch (final Exception e) {
                        log.error("Minor version number '" + getVersion(clazz)
                                        + "' part could not be parsed from could not parsed (from "
                                        + clazz.getSimpleName() + "). Must be numeric!", e);
                        return 0;
                }

        }

        public static int extractMinVersionFromString(String versionString) {
                Pattern minVersionPattern = Pattern.compile("\\d*\\.(\\d*).*");
                Matcher matcher = minVersionPattern.matcher(versionString);
                matcher.find();
                return Integer.parseInt(matcher.group(1));
        }

        /**
         * Different types of licenses supported.
         */
        public enum License {
                LGPL3, GPL3
        };

        /**
         * Print the GPL disclaimer to the given {@link Logger} on INFO level.
         * 
         * @param progname
         *            Name of the program as printed in the license. Will
         *            automatically be starting with an upper-case letter.
         *            <code>null</code> will fall-back to <code>This program</code>
         */
        public static String getLicense(License l, String progname) {
                if (progname == null || progname.isEmpty())
                        progname = "This program";
                switch (l) {
                case GPL3:
                        return ("\n"
                                        + progname
                                        + " is free software: you can redistribute it and/or modify\n"
                                        + "it under the terms of the GNU General Public License as published by\n"
                                        + "the Free Software Foundation, either version 3 of the License, or\n"
                                        + "(at your option) any later version.\n"
                                        + "\n"
                                        + progname
                                        + " is distributed in the hope that it will be useful,\n"
                                        + "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
                                        + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n" + "GNU General Public License for more details.\n");
                case LGPL3:
                        return ("\n"
                                        + progname
                                        + " is free software: you can redistribute it and/or modify\n"
                                        + "it under the terms of the GNU Lesser General Public License as published by\n"
                                        + "the Free Software Foundation, either version 3 of the License, or\n"
                                        + "(at your option) any later version.\n"
                                        + "\n"
                                        + progname
                                        + " is distributed in the hope that it will be useful,\n"
                                        + "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
                                        + "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n" + "GNU Lesser General Public License for more details.\n");
                }
                throw new IllegalArgumentException();
        }

        public static boolean isSnapshot(Class<?> clazz) {
                return getVersionInfo(clazz).contains("SNAPSHOT");
        }
}
1	package skrueger.versionnumber;
2
3	import java.io.InputStream;
4	import java.net.URL;
5	import java.util.Properties;
6	import java.util.regex.Matcher;
7	import java.util.regex.Pattern;
8
9	import org.apache.log4j.Logger;
10
11	/**
12	* This class provides static utility classes that help releasing and versioning
13	* applications. Especially usefull in combination with maven2's
14	* buildnumber-maven plugin.<br/>
15	*
16	* @author Stefan A. Tzeggai
17	*
18	* Wer sein Maven Projekt wie folgt konfiguriert kann die Maven +
19	* SVN-Revisionnummer als Programmversion verwenden, z.B.
20	* "v1.5-SNAPSHOT r123"
21	*
22	* <br/>
23	* 1. pom.xml anpassen: <code>
24	<plugin>
25	<groupId>org.codehaus.mojo</groupId>
26	<artifactId>buildnumber-maven-plugin</artifactId>
27	<version>1.0-beta-4</version>
28	<executions>
29	<execution>
30	<id>buildnumber in phase initialize</id>
31	<phase>initialize</phase>
32	<goals>
33	<goal>create</goal>
34	</goals>
35	</execution>
36	</executions>
37	<configuration>
38	<!-- <doCheck>false</doCheck> <doUpdate>false</doUpdate> <providerImplementations>
39	<svn>javasvn</svn> </providerImplementations> -->
40	<format>{0,date,yyyyMMddHHmm}</format>
41	<items>
42	<item>timestamp</item>
43	</items>
44	</configuration>
45	</plugin>
46	</code><br/>
47	* 2. Datei src/main/resources.properties mit foglenden Inhalt anlegen:
48	* <code>
49	#Properties describing this release/build
50	version=${project.version}
51	build=${buildNumber}
52	</code><br/>
53	* 3. Filtering für die src/main/resources.properties - Datei
54	* einschalten:<code>
55	*
56	<resources>
57	<resource>
58	<filtering>true</filtering>
59	<directory>src/main/resources</directory>
60	<includes><include>release.properties</include></includes>
61	</resource>
62	</resources>
63	</code> <br/>
64	* <br/>
65	* Eine maven Fehlermeldung "The scm url cannot be null." ist
66	* irreführend. In wirklichkeit wird ein Eintrag
67	* <scm>...<developerConnection>..</scm> verlangt.
68	*/
69	public class ReleaseUtil {
70	private static Logger log = Logger.getLogger(ReleaseUtil.class);
71
72	/**
73	* Returns all (the most) information in one sting. This is a public method
74	* which never throws an Exception.
75	*
76	* @param clazz
77	* Pass a class that resides in the same "project" or jar, where
78	* the /release.properties resides as well.
79	*
80	* @return A {@link String} like "v1.4 r243" where the first number is the
81	* maven project version and the second number is the SCM revision.
82	* Returns "unknown version" if it can't be determined.
83	*/
84	public static String getVersionInfo(Class<?> clazz) {
85	try {
86	return "v" + getVersion(clazz) + "-r" + getVersionBuild(clazz);
87	} catch (final Exception e) {
88	return "unknown version";
89	}
90	}
91
92	/**
93	* @param clazz
94	* Pass a class that resides in the same "project" or jar, where
95	* the /release.properties resides as well.
96	*
97	* @Return the major part of the software version or 0 if a problem occurs.
98	*/
99	public static String getVersionBuild(Class<?> clazz) {
100	try {
101	final URL releasePropsURL = clazz
102	.getResource("/release.properties");
103
104	final Properties releaseProps = new Properties();
105	final InputStream openStream = releasePropsURL.openStream();
106	try {
107	releaseProps.load(openStream);
108	} finally {
109	openStream.close();
110	}
111	final String str = releaseProps.getProperty("build", "0");
112
113	if (str.equals("${buildNumber}")) {
114	// We are in development or Maven didn't filter the properties
115	// while building.
116	return "0";
117	}
118
119	return str;
120	} catch (final Exception e) {
121	log.error(
122	"/release.properties could not be read from "
123	+ clazz.getSimpleName(), e);
124	return "0";
125	}
126
127	}
128
129	/**
130	* @param clazz
131	* Pass a class that resides in the same "project" or jar, where
132	* the /release.properties resides as well.
133	*
134	* @return A Version String like "1.3" or "1.6". Returns "0.0" if a problem
135	* occurred.
136	*/
137	public static String getVersion(Class<?> clazz) {
138	final String defaultVer = "0.0";
139
140	try {
141
142	final URL releasePropsURL = clazz
143	.getResource("/release.properties");
144
145	final Properties releaseProps = new Properties();
146	final InputStream openStream = releasePropsURL.openStream();
147	try {
148	releaseProps.load(openStream);
149	} finally {
150	openStream.close();
151	}
152
153	final String versionProperty = releaseProps.getProperty("version",
154	defaultVer);
155	if (versionProperty.equals("${project.version}"))
156	return defaultVer;
157	return versionProperty;
158	} catch (final Exception e) {
159	log.error(
160	"/release.properties could not be read from "
161	+ clazz.getSimpleName(), e);
162	return defaultVer;
163	}
164
165	}
166
167	/**
168	* @param clazz
169	* Pass a class that resides in the same "project" or jar, where
170	* the /release.properties resides as well.
171	*
172	* @return Mayor version number part, e.g. "1" for version "1.3". Returns 0
173	* if a problem occurred.
174	*/
175	public static int getVersionMaj(Class<?> clazz) {
176	try {
177	return Integer.parseInt(getVersion(clazz).split("\\.")[0]);
178	} catch (final Exception e) {
179	log.error("Major version number '" + getVersion(clazz)
180	+ "' part could not be parsed from could not parsed (from "
181	+ clazz.getSimpleName() + "). Must be numeric!", e);
182	return 0;
183	}
184	}
185
186	/**
187	* @param clazz
188	* Pass a class that resides in the same "project" or jar, where
189	* the /release.properties resides as well.
190	*
191	* @return Minor version number part, e.g. "3" for version "1.3". Returns 0
192	* if a problem occurred.
193	*/
194	public static int getVersionMin(Class<?> clazz) {
195	try {
196	return extractMinVersionFromString(getVersion(clazz));
197	} catch (final Exception e) {
198	log.error("Minor version number '" + getVersion(clazz)
199	+ "' part could not be parsed from could not parsed (from "
200	+ clazz.getSimpleName() + "). Must be numeric!", e);
201	return 0;
202	}
203
204	}
205
206	public static int extractMinVersionFromString(String versionString) {
207	Pattern minVersionPattern = Pattern.compile("\\d\\.(\\d).*");
208	Matcher matcher = minVersionPattern.matcher(versionString);
209	matcher.find();
210	return Integer.parseInt(matcher.group(1));
211	}
212
213	/**
214	* Different types of licenses supported.
215	*/
216	public enum License {
217	LGPL3, GPL3
218	};
219
220	/**
221	* Print the GPL disclaimer to the given {@link Logger} on INFO level.
222	*
223	* @param progname
224	* Name of the program as printed in the license. Will
225	* automatically be starting with an upper-case letter.
226	* <code>null</code> will fall-back to <code>This program</code>
227	*/
228	public static String getLicense(License l, String progname) {
229	if (progname == null \|\| progname.isEmpty())
230	progname = "This program";
231	switch (l) {
232	case GPL3:
233	return ("\n"
234	+ progname
235	+ " is free software: you can redistribute it and/or modify\n"
236	+ "it under the terms of the GNU General Public License as published by\n"
237	+ "the Free Software Foundation, either version 3 of the License, or\n"
238	+ "(at your option) any later version.\n"
239	+ "\n"
240	+ progname
241	+ " is distributed in the hope that it will be useful,\n"
242	+ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
243	+ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "GNU General Public License for more details.\n");
244	case LGPL3:
245	return ("\n"
246	+ progname
247	+ " is free software: you can redistribute it and/or modify\n"
248	+ "it under the terms of the GNU Lesser General Public License as published by\n"
249	+ "the Free Software Foundation, either version 3 of the License, or\n"
250	+ "(at your option) any later version.\n"
251	+ "\n"
252	+ progname
253	+ " is distributed in the hope that it will be useful,\n"
254	+ "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
255	+ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n" + "GNU Lesser General Public License for more details.\n");
256	}
257	throw new IllegalArgumentException();
258	}
259
260	public static boolean isSnapshot(Class<?> clazz) {
261	return getVersionInfo(clazz).contains("SNAPSHOT");
262	}
263	}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain