GWT compilation is skipped in maven when module packaging is pom

Question

I am trying to reuse a assembled gwt compilation in another war. For this i am try to change the current maven module's packaging from war to pom. I then plan to use maven-assembly-plugin to zip up gwt's module js output and use that later on in another war module.

I tried changing the packaging tag from <packaging>war</packaging> to <packaging>pom</packaging> in pom.xml from Validation sample . gwt-maven-plugin never enters into compilation. Instead, it skips compilation!!!!!

1. What is happening?
2. Is this expected?
3. Is there any workaround?

Answer 1

To join multiple gwt compiled modules into a single .war file, it is very easy with the maven-dependency-plugin

1. Package all your gwt examples as habitual (.war), and install them mvn install or mvn deploy if you have a private maven repo.
2. Create an empty maven module of type war, with no code but with the maven folder structure, you can put any additional stuff you need here like a global src/main/webapp/index.html.

3. Configure the new module to use the maven-dependency-plugin like shown below, and run mvn package:

   <dependency>
       <groupId>my.group</groupId>
       <artifactId>example1</artifactId>
       <version>...</version>
       <type>war</type>
   </dependency>
   ...
   <plugin>
     <groupId>org.apache.maven.plugins</groupId>
     <artifactId>maven-dependency-plugin</artifactId>
     <executions>
       <execution>
         <id>unpack-gwt-examples</id>
         <phase>prepare-package</phase>
         <goals>
           <goal>unpack-dependencies</goal>
         </goals>
         <configuration>
           <includeGroupIds>my.group</includeGroupIds>
           <includes>**/example1/**</includes>
           <outputDirectory>${project.build.directory}/${project.artifactId}-${project.version}</outputDirectory>
         </configuration>
       </execution>
     </executions>
   </plugin>
   

Finally and related with the gwt-maven-plugin, like with any other maven pluging, it would be enough to select an appropriate phase of the pom-packaging life cycle (package, install or deploy):

  ...
  <packaging>pom</packaging>
  ...
     <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>gwt-maven-plugin</artifactId>
        ...
        <configuration>
        ...
        </configuration>
        <executions>
            <execution>
                <phase>package</phase>
                <goals>
                    <goal>compile</goal>
                </goals>
            </execution>
        </executions>
      </plugin>

Unfortunately, gwt-maven-plugin specifically disallows compilation when packaging is pom, take a look to line #269 of CompileMojo.java

Answer 2

You can create the reusable modules (that you mention as samples in the comments) as separate GWT projects with no EntryPoint. Package them as jar and add the following as resources:

1. the client side source code
2. other resource items that will be necessary for the final compilation (images, xml files, etc.)

Something like this:

<build>
    <plugins>
        <plugin>
            <artifactId>maven-compiler-plugin</artifactId>
            ...
        </plugin>
    </plugins>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/services/**</include>
                <include>**/client/**</include>
                <include>**/public/**</include>
                <include>**/*.gwt.xml</include>
            </includes>
        </resource>
    </resources>
</build>

That's it, you can reuse it in any other GWT project. When you will do so, you just have to add the dependency (to the reusable module) in the pom.xml and import in the *.gwt.xml.

As for Maven's behaviour, it seems correct. pom packaging is going through package, install and deploy phases and

By default, the compile goal is configured to be executed during the ''prepare-package'' phase to run as late as possible.

You could change the phase in the plugin's execution, but I think it's risky because you can't know when exactly during the package phase will your code get compiled.