web-dev-qa-db-fra.com

Est-il possible de compiler le projet Grunt de Maven?

J'essaie d'exécuter des tâches grognantes à partir de maven sans avoir à installer Node.js ou quoi que ce soit. C'est parce que je ne souhaite pas que l'artefact soit emballé par Jenkins et je ne peux pas installer Node.js sur cette machine.

Je sais que c'est facile avec npm et quelques commandes pour le faire fonctionner, mais je pense aussi que l'intégration avec maven devrait être facile, le problème est que je ne sais pas par où commencer puisque je suis nouveau dans npm.

javanode.jsmavengruntjs
40
gfournier

Oui, en utilisant frontend-maven-plugin , vous pouvez compiler des projets Grunt via Maven (disponibles via la liste de diffusion NodeJS ). 

Comme le souligne la documentation, le plugin présente les caractéristiques suivantes: 

  • Laissez-vous garder vos constructions frontend et backend aussi séparées que possible, en réduisant au minimum la quantité d'interaction entre elles. en utilisant seulement 1 plugin.
  • Vous permet d'utiliser Node.js et ses bibliothèques dans votre processus de construction sans installer Node/NPM globalement pour votre système de construction
  • Assurez-vous que la version de Node et de NPM en cours d'exécution est la même dans chaque environnement de construction

J'ai parcouru le code et c'est assez simple. Dieu merci, quelqu'un a finalement mis cela en place; c'est une solution élégante. Le référentiel inclut un exemple qui utilise un Gruntfile.js standard pour appeler l'analyse jshint.

28
blong

UPDATE 2014-09-19: Ce n'est plus la réponse la plus précise. Veuillez consulter certaines des réponses ci-dessous. C'était exact au moment où j'ai répondu à la question, mais il semble y avoir eu beaucoup de progrès dans ce domaine depuis lors.

J'ai bien peur que vous n'ayez pas de chance. Grunt est construit en utilisant node et doit être installé en utilisant npm. Vous pourrez peut-être copier une installation existante de Grunt à partir d'une autre machine si vous ne voulez pas utiliser npm, mais utiliserez toujours l'exécutable grunt et toutes ses dépendances sur votre serveur de construction.

De plus, de nombreuses tâches Grunt sont implémentées en tant que modules Node.js et vous devrez également les installer. Encore une fois, vous pourrez peut-être les copier depuis un autre serveur, où vous avez effectué l'installation de Node.js/Grunt, mais vous devez le faire à un moment donné.

Pour exécuter Grunt à partir de Maven, le mieux est d’utiliser le plugin Maven exec puis d’exécuter l’exécutable grunt à partir de là.

En guise d'alternative, il existe plusieurs plug-ins Maven qui vous permettent de faire des choses similaires à Grunt d'une manière basée sur Java. Ils nécessitent une configuration supplémentaire non compatible avec Grunt, donc YMMV. Celui que j'ai utilisé dans le passé est http://code.google.com/p/wro4j/ , qui est également fourni avec un plugin Maven: http://code.google.com/ p/wro4j/wiki/MavenPlugin

Une raison particulière pour laquelle vous ne pouvez pas installer Node.js sur votre serveur de build?

15
nwinkler

Vous pouvez utiliser grunt-maven-plugin . Cela vous permet d'intégrer facilement les tâches Grunt au processus de construction Maven. Pas de hacks sales.

C’est ce que j’utilise dans mon projet actuel et cela fonctionne parfaitement.

11
pbetkier

Finalement, j'ai fini avec ceci (ce qui est assez proche mais ne résout pas le problème):

<plugin>
<groupId>org.mule.tools.javascript</groupId>
<artifactId>npm-maven-plugin</artifactId>
<version>1.0</version>
<executions>
    <execution>
        <phase>generate-resources</phase>
            <goals>
                <goal>fetch-modules</goal>
            </goals>
            <configuration>
                <packages>
                    <package>grunt-cli:0.1.6</package>
                </packages>
            </configuration>
        </execution>
    </executions>
</plugin>

cela installe localement le grunt-cli, mais si je n'ai pas installé node.js, cela ne vaut rien. Bien que j'essaye d'installer node.js localement, il faut installer python, g ++ et make. Je vais donc aller avec la solution KISS: installer grunt dans le serveur de compilation.

Références: 
https://github.com/mulesoft/npm-maven-plugin
https://github.com/joyent/node/wiki/Installing-Node.js-via-package-manager
https://github.com/mcheely/requirejs-maven-plugin

10
gfournier

Vous voudrez peut-être utiliser http://jhipster.github.io/ : il s’agit d’un générateur Yeoman, qui génère une application dans laquelle Maven, Grunt et Bower travaillent ensemble.

C'est un peu comme votre troisième option, mais tout est configuré pour vous, ce qui n'est pas si facile. Il génère également les services de base AngularJS et Java REST pour vous.

6
Er KK Chopra

Il s'agit d'une solution complète de copier/coller qui fonctionnera en 2017 avec frontend-maven-plugin pour Front Build, et maven-war-plugin pour construire la guerre.

Ce qu'il fait ? Installez npm, Bower Grunt et tout ce dont vous avez besoin, puis lancez npm install, Bower Install et enfin Grunt Build.

Vous pouvez supprimer/ajouter, remplacer les étapes souhaitées. Pour moi, il s’agit d’une bibliothèque et d’un projet complets d’installation/construction de 30 secondes.

<dependencies>
  ...
</dependencies>

<dependencyManagement>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.github.eirslett/frontend-maven-plugin -->
        <dependency>
            <groupId>com.github.eirslett</groupId>
            <artifactId>frontend-maven-plugin</artifactId>
        </dependency>
    </dependencies>
</dependencyManagement>

<build>
    <pluginManagement>
        <plugins>
            <plugin>
                <groupId>org.Apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <warSourceDirectory>src/main/webapp/YourFrontJsFolder/dist</warSourceDirectory>
                    <warName>YouWarName</warName>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                    <warSourceExcludes>node_modules/**</warSourceExcludes>
                    <includeScope>system</includeScope>
                    <webResources>
                        <resource>
                            <directory>WebContent/WEB-INF</directory>
                            <targetPath>WEB-INF</targetPath>
                            <includes>
                                <include>**/*.jar</include>
                                <include>**/*.jsp</include>
                            </includes>
                        </resource>
                    </webResources>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.Apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.7</source>
                    <target>1.7</target>
                    <encoding>Cp1252</encoding>
                </configuration>
            </plugin>
        </plugins>
    </pluginManagement>

    <finalName>YourAppName</finalName>
</build>

<profiles>
    <profile>
        <id>release</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>com.github.eirslett</groupId>
                    <artifactId>frontend-maven-plugin</artifactId>
                    <executions>
                        <execution>
                            <!-- optional: you don't really need execution ids, but it looks 
                                Nice in your build log. -->
                            <id>install node and npm</id>
                            <goals>
                                <goal>install-node-and-npm</goal>
                            </goals>
                            <!-- optional: default phase is "generate-resources" -->
                            <phase>generate-resources</phase>

                            <configuration>
                                <nodeVersion>v7.6.0</nodeVersion>
                            </configuration>
                        </execution>

                        <execution>
                            <id>npm install</id>
                            <goals>
                                <goal>npm</goal>
                            </goals>

                            <!-- optional: default phase is "generate-resources" -->
                            <phase>generate-resources</phase>

                            <configuration>
                                <arguments>install</arguments>
                            </configuration>
                        </execution>

                        <execution>
                            <id>bower install</id>
                            <goals>
                                <goal>bower</goal>
                            </goals>

                            <configuration>
                                <!-- optional: The default argument is actually "install", so unless 
                                    you need to run some other bower command, you can remove this whole <configuration> 
                                    section. -->
                                <arguments>install</arguments>
                            </configuration>
                        </execution>

                        <execution>
                            <id>grunt build</id>
                            <goals>
                                <goal>grunt</goal>
                            </goals>

                            <!-- optional: the default phase is "generate-resources" -->
                            <phase>generate-resources</phase>

                            <configuration>
                                <!-- optional: if not specified, it will run Grunt's default task 
                                    (and you can remove this whole <configuration> section.) -->
                                <arguments>build</arguments>
                            </configuration>
                        </execution>
                    </executions>

                    <configuration>
                        <installDirectory>target</installDirectory>
                        <workingDirectory>src/main/webapp/YourFrontJsFolder</workingDirectory>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    </profile>
    <profile>
        <id>debug</id>
        <activation>
            <activeByDefault>true</activeByDefault>
        </activation>
    </profile>
    <profile>
        <id>IDE</id>
        <activation>
            <property>
                <name>m2e.version</name>
            </property>
        </activation>
        <build>
            <!-- Put the IDE's build output in a folder other than target, so that 
                IDE builds don't interact with Maven builds -->
            <directory>target-ide</directory>
        </build>
    </profile>
</profiles>

Ensuite, vous pouvez Run as -> Maven build ..., avec l'objectif clean install et le profil release

3
amdev

Le premier problème est que Maven est Java, mais Grunt.js s'exécute sur le moteur d'exécution Node.js. L'intégration la plus facile que j'ai jamais réalisée entre les deux impliquait le plugin maven-exec-plugin. Le plug-in maven-exec est capable d'exécuter les scripts .sh/.bat/.cmd, quels que soient les paramètres natifs du système d'exploitation utilisé. Ainsi, lors de la construction de Maven, je ferais exécuter par maven-exec-plugin un script nommé optim-js.sh, par exemple, qui ferait simplement quelque chose comme «grunt release –force», ou peu importe. Les scripts peuvent être faits pour faire n'importe quoi. L'important est de configurer le plug-in maven-exec pour les exécuter dans le bon répertoire de travail. Bien sûr, “grunt” et “node” doivent être exécutables à partir de la ligne de commande.

1
jdobry

Si le problème est d'installer NodeJS sur la machine Jenkins, vous pouvez utiliser le plugin NodeJS Jenkins.

https://wiki.jenkins-ci.org/display/JENKINS/NodeJS+Plugin

Nous ne l'utilisons pas (encore) avec Maven, mais le fonctionnement est difficile.

1
jamie

Peut être fait avec exec-maven-plugin .

Définissez un script et une dépendance vers grunt-cli dans votre package.json :

...
  "scripts": {
    "build": "./node_modules/.bin/grunt install"
  },
  "devDependencies": {
  "grunt-cli": "^1.2.0",
...

Dans votre pom, ajoutez les commandes à exécuter:

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>X.Y.Z</version>
            <executions>
                <execution>
                    <id>exec-npm-install</id>
                    <phase>generate-sources</phase>
                    <configuration>
                        <workingDirectory>${project.basedir}</workingDirectory>
                        <executable>npm</executable>
                        <arguments>
                            <argument>install</argument>
                        </arguments>
                    </configuration>
                    <goals>
                        <goal>exec</goal>
                    </goals>
                </execution>
                <execution>
                    <id>exec-grunt-install</id>
                    <phase>generate-sources</phase>
                    <configuration>
                        <workingDirectory>${project.basedir}</workingDirectory>
                        <executable>npm</executable>
                        <arguments>
                            <argument>run</argument>
                            <argument>build</argument>
                        </arguments>
                    </configuration>
                    <goals>
                        <goal>exec</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>

Il va maintenant fonctionner sur paquet mvn

0
Tomas Bjerre