Nrthugu

Tom's solution with the Exec Maven Plugin is much better, but still more complicated than it needs to be. For me it's as simple as:

MVN_VERSION=$(mvn -q 

    -Dexec.executable=echo 

    -Dexec.args='${project.version}' 

    --non-recursive 

    exec:exec)

mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | grep -v '['

The top answer is pretty garbage in my opinion, you have to use a bunch of grep to hack out the maven console output. Why not use the right tool for the job? Using xpath syntax is the best approach to retrieving the version number, since it is the intended method of accessing a XML data structure. The expression below is traversing the pom using the "local name" of the elements, in other words ignoring namespace declarations which may or may not be present in the xml.

xmllint --xpath "//*[local-name()='project']/*[local-name()='version']/text()" pom.xml

This will avoid the need for grepping off log entries from the output:

mvn -Dexec.executable='echo' -Dexec.args='${project.version}' --non-recursive exec:exec -q

I have been doing some research and found the following:

1. Maven has been blamed for not being easily integrable within system operation scripts since it does not follow some good practices regarding CLI tools. (ref: https://youtu.be/1ILEw6Qca3U?t=372)



2. 
   

   Inspired on the previous assertion, I decided to give a look on maven's source code as well as on maven-help-plugin. It seems that they have fixed a little bit the maven's -q switch (I am using version 3.5.3), so now if you pass it, you won't get all the annoying non-sense logging stuff that prevents maven from being used within automated scripts. So you should be able to use something like this:

   
   
   

   mvn help:evaluate -Dexpression=project.version -q
   
   

   
   
   

   The problem is that this command prints nothing because by default the help plugin outputs through the logger which has been silenced by the -q switch. (latest available version of the plugin is 3.1.0 released on June, 3rd 2018)

   
   


3. 
   

   Karl Heinz Marbaise (https://github.com/khmarbaise) fixed it by adding an optional parameter that allows you to call it in the following way:

   
   
   

   mvn help:evaluate -Dexpression=project.version -q -DforceStdout
   
   

   
   
   

   The commit description is available at: (https://github.com/apache/maven-help-plugin/commit/316656983d780c04031bbadd97d4ab245c84d014)

   
   

python -c "import xml.etree.ElementTree as ET; 

  print(ET.parse(open('pom.xml')).getroot().find( 

  '{http://maven.apache.org/POM/4.0.0}version').text)"

As long as you have python 2.5 or greater, this should work. If you have a lower version than that, install python-lxml and change the import to lxml.etree. This method is quick and doesn't require downloading any extra plugins. It also works on malformed pom.xml files that don't validate with xmllint, like the ones I need to parse. Tested on Mac and Linux.

I kept running into side cases when using some of the other answers here, so here's yet another alternative.

version=$(printf 'VERt${project.version}' | mvn help:evaluate | grep '^VER' | cut -f2)

If you don't mind to write the version into a temporary file, there is another solution (without grep/sed) that works well for me. (EDIT: see rjrjr's answer for a much simpler solution without any temporary file hassle)

I use the Exec Maven Plugin along with the echo binary. In contrast to the Maven Help Plugin, the Exec Plugin allows output redirection into a file, which can be used to bypass grep/sed, and makes it even possible to parse strange things like multiline version strings (with CDATA block in version tag), at least to a certain extent.

#!/usr/bin/env sh



MVN_VERSION=""

VERSION_FILE=$( mktemp mvn_project_version_XXXXX )

trap "rm -f -- "$VERSION_FILE"" INT EXIT



mvn -Dexec.executable="echo" 

    -Dexec.args='${project.version}' 

    -Dexec.outputFile="$VERSION_FILE" 

    --non-recursive 

    --batch-mode 

    org.codehaus.mojo:exec-maven-plugin:1.3.1:exec > /dev/null 2>&1 ||

    { echo "Maven invocation failed!" 1>&2; exit 1; }



# if you just care about the first line of the version, which will be

# sufficent for pretty much every use case I can imagine, you can use

# the read builtin

[ -s "$VERSION_FILE" ] && read -r MVN_VERSION < "$VERSION_FILE"



# Otherwise, you could use cat.

# Note that this still has issues when there are leading whitespaces

# in the multiline version string

#MVN_VERSION=$( cat "$VERSION_FILE" )



printf "Maven project version: %sn" "$MVN_VERSION"

I noticed some spurious Downloaded: lines coming in the output that were breaking my original assignment. Here's the filter I've settled on; hope it helps!

version=$(mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | egrep -v '^[|Downloading:' | tr -d ' n')

EDIT

Not 100% sure why, but when running this through a post-build script in Jenkins, the output was coming out as [INFO]version, e.g. [INFO]0.3.2.

I dumped the output to a file and ran it through my first filter directly from BASH, it works fine.., so again, unsure what's going on in Jenkins land.

To get it 100% in Jenkins, I've added a follow-up sed filter; here's my latest

version=$(mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | egrep -v '^[|Downloading:' | tr -d ' n' | sed -E 's/[.*]//g')

EDIT

One last note here.. I found out tr was still resulting in things like /r/n0.3.2 (again only when running via Jenkins). Switched to awk and the problem has gone away! My final working result

mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version 

| egrep -v '^[|Downloading:' | sed 's/[^0-9.]//g' | awk 1 ORS=''

Just for the record, it's possible to configure Maven's Simple SLF4J logging directly in the command line to output only what we need by configuring:

• 
  org.slf4j.simpleLogger.defaultLogLevel=WARN and


• org.slf4j.simpleLogger.log.org.apache.maven.plugins.help=INFO

as documented at http://www.slf4j.org/api/org/slf4j/impl/SimpleLogger.html

MAVEN_OPTS="

-Dorg.slf4j.simpleLogger.defaultLogLevel=WARN 

-Dorg.slf4j.simpleLogger.log.org.apache.maven.plugins.help=INFO" 

mvn help:evaluate -o -Dexpression=project.version

As a result, one can run simply tail -1 and get:

$ MAVEN_OPTS="

-Dorg.slf4j.simpleLogger.defaultLogLevel=WARN 

-Dorg.slf4j.simpleLogger.log.org.apache.maven.plugins.help=INFO" 

mvn help:evaluate -o -Dexpression=project.version | tail -1



1.0.0-SNAPSHOT

Note that this is a one-liner. MAVEN_OPTS are being rewritten only for this particular mvn execution.

A simple maven only solution

mvn -q -N org.codehaus.mojo:exec-maven-plugin:1.3.1:exec 

    -Dexec.executable='echo' 

    -Dexec.args='${project.version}'

And for bonus points parsed part of a version

mvn -q -N org.codehaus.mojo:build-helper-maven-plugin:3.0.0:parse-version 

    org.codehaus.mojo:exec-maven-plugin:1.3.1:exec 

    -Dexec.executable='echo' 

    -Dexec.args='${parsedVersion.majorVersion}.${parsedVersion.minorVersion}.${parsedVersion.incrementalVersion}'

I've recently developed the Release Candidate Maven plugin that solves this exact problem so that you don't have to resort to any hacky shell scripts and parsing the output of the maven-help-plugin.

For example, to print the version of your Maven project to a terminal, run:

mvn com.smartcodeltd:release-candidate-maven-plugin:LATEST:version

which gives output similar to maven-help-plugin:

[INFO] Detected version: '1.0.0-SNAPSHOT'

1.0.0-SNAPSHOT

[INFO] ------------------------------------------------------------------------

[INFO] BUILD SUCCESS

[INFO] ------------------------------------------------------------------------

However, you can also specify an arbitrary output format (so that the version could be picked up from the log by a CI server such as TeamCity):

mvn com.smartcodeltd:release-candidate-maven-plugin:LATEST:version 

   -DoutputTemplate="##teamcity[setParameter name='env.PROJECT_VERSION' value='{{ version }}']"

Which results in:

[INFO] Detected version: '1.0.0-SNAPSHOT'

##teamcity[setParameter name='env.PROJECT_VERSION' value='1.0.0-SNAPSHOT']

[INFO] ------------------------------------------------------------------------

[INFO] BUILD SUCCESS

[INFO] ------------------------------------------------------------------------

To save the output to a file (so that a CI server such as Jenkins could use it):

mvn com.smartcodeltd:release-candidate-maven-plugin:LATEST:version 

   -DoutputTemplate="PROJECT_VERSION={{ version }}" 

   -DoutputUri="file://${project.basedir}/version.properties"

The resulting version.properties file will look as follows:

PROJECT_VERSION=1.0.0-SNAPSHOT

On top of all the above, Release Candidate also allows you to set the version of your project (which is something you'd probably do on your CI server) based on the API version you've defined in your POM.

If you'd like to see an example of Release Candidate being used as part of the Maven lifecycle, have a look at the pom.xml of my other open-source project - Build Monitor for Jenkins.

The easy to understand all-in-one solution that outputs the maven project version, and suppresses extraneous output from [INFO] and Download messages:

mvn -o org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | grep -v '['

Same thing, but split onto two lines:

mvn -o org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate 

      -Dexpression=project.version | grep -v '['

Outputs: 4.3-SNAPSHOT

So, using your project.version in a simple bash script:

projectVersion=`mvn -o org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate -Dexpression=project.version | grep -v '['`

cd "target/"$projectVersion"-build"

Other solutions on this page didn't seem to combine all the tricks into one.

Should be easier since this bug is fixed in maven-help-plugin 3.0.0: MPH-99 Evaluate has no output in quiet mode.

Exec plugin works without any output parsing because output can be redirected into file and injected back into the job environment via EnvInject plugin:

I found right balance for me. After mvn package maven-archiver plugin creates target/maven-archiver/pom.properties with contents like this

version=0.0.1-SNAPSHOT

groupId=somegroup

artifactId=someArtifact

and I am using bash just to execute it

. ./target/maven-archiver/pom.properties

then

echo $version

0.0.1-SNAPSHOT

Of course this is not safe at all to execute this file, but execution can easily be converted into perl or bash script to read and set environment variable from that file.

This worked for me, offline and without depending on mvn:

VERSION=$(grep --max-count=1 '<version>' <your_path>/pom.xml | awk -F '>' '{ print $2 }' | awk -F '<' '{ print $1 }')

echo $VERSION

Either you have mvn give you the answer (as most answers suggest), or you extract the answer from the pom.xml. The only drawback of the second approach is that you can very easily extract the value of the <version/> tag, but it will be meaningful only if it's literal, that is, not a Maven property. I chose this approach anyway because:

• 
  mvn is way to verbose and I simply don't like filtering its output.


• Starting mvn is very slow compared to reading the pom.xml.


• I always use literal values in <version/>.

mvn-version is a zsh shell script that uses xmlstarlet to read the pom.xml and print the version of the project (if it exists) or the version of the parent project (if it exists):

$ mvn-version .

1.0.0-SNAPSHOT

The advantage is that it's way quicker than running mvn:

$ time mvn-version .

1.1.0-SNAPSHOT

mvn-version .  0.01s user 0.01s system 75% cpu 0.019 total



$ time mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate 

> -Dexpression=project.version

mvn org.apache.maven.plugins:maven-help-plugin:2.1.1:evaluate   4.17s user 0.21s system 240% cpu 1.823 total

The difference on my machine is greater than two orders of magnitude.

mvn help:evaluate -Dexpression=project.version | sed -e 1h -e '2,3{H;g}' -e '/[INFO] BUILD SUCCESS/ q' -e '1,2d' -e '{N;D}' | sed -e '1q'

I'm just adding small sed filter improvement I have recently implemented to extract project.version from maven output.

VERSION=$(head -50 pom.xml | awk -F'>' '/SNAPSHOT/ {print $2}' | awk -F'<' '{print $1}')

This is what I used to get the version number, thought there would have been a better maven way to do so