RequireJS compilazione in progetto Maven con dipendenze JS esterni

Question

Ho un progetto web che è costruito con Maven e sto cercando di capire il modo migliore per compilare i file JavaScript con il compilatore RequireJS (questa domanda potrebbe applicarsi a qualsiasi compilatore / minifier pure).

Ho un sistema che funziona, ma ha bisogno di miglioramento:

Sono confezionati, le librerie JavaScript 3rd party e vengono scaricati come dipendenze e poi aggiunse con il plugin GUERRA Overlay.

Ho un compito plugin di Exec che esegue il compilatore RequireJS all'interno del bersaglio directory. Attualmente io faccio girare manualmente exec:exec dopo l'esecuzione di destinazione del pacchetto (e quindi il contenuto di WAR vengono inseriti nella directory di destinazione).

Quello che vorrei invece è quello di far parte compilation JS della compilazione principale (Java). Il compilatore JS stessa (Richiede JS) viene scaricato come una dipendenza durante la fase di sovrapposizione WAR che avviene dopo la compilazione. Così, ho bisogno del richiedono che i file JS per essere scaricato e scompattato e ho bisogno di eseguire la compilazione JS utilizzando tali file, prima / durante / dopo la compilazione Java.

Sono sicuro che ci potrebbe essere diversi modi per raggiungere questo obiettivo. Sto cercando la soluzione più elegante.

---

Aggiornamento: esistenti frammenti POM

Ho dipendenze JavaScript che ho zippato e aggiunto al nostro repository manager:

    <dependency>
        <groupId>org.requirejs</groupId>
        <artifactId>requirejs</artifactId>
        <version>0.22.0</version>
        <classifier>repackaged</classifier>
        <type>zip</type>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>com.jqueryui</groupId>
        <artifactId>jquery-ui</artifactId>
        <version>1.8.7</version>
        <classifier>repackaged</classifier>
        <type>zip</type>
        <scope>runtime</scope>
    </dependency>

Prendete nota che RequireJS stesso (che è richiesto per la compilazione del resto librerie) è caricato anche come dipendenza esterna. Quindi la prima cosa è, ho bisogno di questa dipendenza per essere scaricato e scompattato prima di poter iniziare con la compilazione RequireJS.

Queste dipendenze vengono aggiunti alla guerra utilizzando il plugin GUERRA Overlay:

        <plugin>
            <artifactId>maven-war-plugin</artifactId>
            <configuration>
                <overlays>
                    <overlay>
                        <groupId>org.requirejs</groupId>
                        <artifactId>requirejs</artifactId>
                        <classifier>repackaged</classifier>
                        <type>zip</type>
                        <targetPath>lib</targetPath>
                        <includes>
                            <include>requirejs/require.js</include>
                            <include>requirejs/require/*</include>
                            <include>requirejs/build/**</include>
                        </includes>
                    </overlay>
                    <overlay>
                        <groupId>com.jqueryui</groupId>
                        <artifactId>jquery-ui</artifactId>
                        <classifier>repackaged</classifier>
                        <type>zip</type>
                        <targetPath>lib</targetPath>
                    </overlay>
                </overlays>
            </configuration>
        </plugin>

Anche se non ho bisogno requirejs/build/** di finire in guerra, ho compreso come parte della sovrapposizione per ottenere i RequireJS decompressi costruire script, semplicemente perché non ho trovato un modo migliore.

Poi ho un plugin compito Exec che esegue la compilazione. Ma si noti che questo compito non è stato aggiunto al normale flusso di lavoro di compilazione: devo manualmente invoke con mvn exec:exec dopo la confezione WAR è fatto:

        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>exec-maven-plugin</artifactId>
            <version>1.1</version>
            <executions>
                <execution>
                    <goals>
                        <goal>exec</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <executable>lib/requirejs/build/build.bat</executable>
                <workingDirectory>${project.build.directory}/${project.artifactId}</workingDirectory>
                <arguments>
                    <argument>name=bootstrap</argument>
                    <argument>out=combined.js</argument>
                    <argument>baseUrl=scripts</argument>
                    <argument>optimize=closure</argument>
                    <argument>excludeShallow=plugins/manifest</argument>
                </arguments>
            </configuration>
        </plugin>

Quindi, alcune domande sono:

1. Come posso estrarre diverse porzioni di una dipendenza da un unico zip per la compilazione e fasi di imballaggio guerra? O devo creare due zip file, uno con solo la roba runtime e l'altro per gli script compilation?
2. vorrei grilletto exec:exec idealmente durante la compilazione, o se no, basta prima del confezionamento WAR. Come faccio a farlo?

Ho effettivamente provato un mucchio fuori roba senza successo, quindi spero che non appaiono come pigramente la pubblicazione di un enorme pezzo di codice e in attesa di risposte :) E 'solo che non ho abbastanza avvolto la mia mente intorno a come Maven obiettivi / fasi ecc lavoro ancora.

Answer 1

Sono venuto con la seguente soluzione che funziona per me:

Invece di a seconda della sovrapposizione guerra per il disimballaggio dei file RequireJS, disimballo esplicitamente utilizzando il plugin Dipendenza:

  <plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-dependency-plugin</artifactId>
    <executions>
      <execution>
        <phase>compile</phase>
        <goals>
          <goal>unpack</goal>
        </goals>
        <configuration>
          <artifactItems>
            <artifactItem>
              <groupId>org.requirejs</groupId>
              <artifactId>requirejs</artifactId>
              <version>0.22.0</version>
              <type>zip</type>
              <classifier>repackaged</classifier>
              <overWrite>true</overWrite>
            </artifactItem>
          </artifactItems>
        </configuration>
      </execution>
    </executions>
  </plugin>

La fase è impostato su "compilazione". Questo mi permette di avere l'intero contenuto del pacchetto RequireJS sotto la cartella "dipendenze", durante la compilazione. Quindi, la prossima cosa che ho è:

      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>1.1</version>
        <executions>
          <execution>
            <phase>compile</phase>
            <goals>
              <goal>exec</goal>
            </goals>
            <configuration>
              <executable>
              ${project.build.directory}/dependency/requirejs/build/build.bat</executable>
              <workingDirectory>
              ${basedir}/src/main/webapp</workingDirectory>
              <arguments>
                <argument>name=bootstrap</argument>
                <argument>out=scripts/compiled.js</argument>
                <argument>baseUrl=scripts</argument>
                <argument>optimize=closure</argument>
                <argument>
                excludeShallow=plugins/manifest</argument>
              </arguments>
            </configuration>
          </execution>
        </executions>
      </plugin>

Questo innesca RequireJS compilazione all'interno della cartella "dipendenze", senza né mia directory sorgente toccare o la directory WAR. Ho poi continuare a utilizzare il WAR sovrapposizione plugin per ciliegia scegliere i file RequireJS che vogliono andare in guerra.

Aggiorna

Dopo aver scritto questa soluzione, sono passato ad usare l'obiettivo "Java" invece di "exec" perché ho avuto problemi con l'utilizzo file di script di shell + lotto del compilatore RequireJS attraverso Hudson. Sono fondamentalmente eseguendo il comando Java finale (generato dagli script) che funzionano il compilatore attraverso Rhino. La soluzione Node sarebbe leggermente diverso. Per RequireJS 0.23.0, è più o meno così:

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>exec-maven-plugin</artifactId>
    <version>1.1</version>
    <executions>
        <execution>
            <id>compile-js</id>
            <phase>compile</phase>
            <goals>
                <goal>exec</goal>
            </goals>
            <configuration>
                <executable>java</executable>
                <workingDirectory>${basedir}/src/main/webapp</workingDirectory>
                <arguments>
                    <argument>-classpath</argument>
                    <!--argument>${project.build.directory}/dependency/requirejs/build/lib/rhino/js.jar${path.separator}${project.build.directory}/dependency/requirejs/build/lib/closure/compiler.jar</argument -->
                    <argument>${project.build.directory}/dependency/requirejs/build/lib/rhino/js.jar</argument>
                    <argument>org.mozilla.javascript.tools.shell.Main</argument>
                    <argument>${project.build.directory}/dependency/requirejs/bin/x.js</argument>
                    <argument>${project.build.directory}/dependency/requirejs/bin/</argument>
                    <argument>${project.build.directory}/dependency/requirejs/build/build.js</argument>
                    <argument>name=bootstrap</argument>
                    <argument>out=scripts/compiled.js</argument>
                    <argument>baseUrl=scripts</argument>
                    <argument>optimize=none</argument>
                </arguments>
            </configuration>
        </execution>
    </executions>
</plugin>

Answer 2

https://github.com/jakewins/requirejs-maven

Answer 3

C'è un esperto di plug-in appositamente mirati per l'ottimizzazione RequireJS all'indirizzo:

https://github.com/mcheely/requirejs-maven-plugin

Si deve sempre disponibile con una versione recente di RequireJS, ed è abbastanza facile da ignorare che con l'aggiunta di una versione diversa al progetto, e specificando il suo percorso nel plugin config.

Full disclosure:. Ho scritto il plugin