<html>
<head>
<!-- 
	Include the title here. We will parse it out of here and include it on the
	rendered webpage. Do not duplicate the title within the text of your page.
 -->

<title>Maven Integration for Web Tools Platform</title>
</head>

<!-- 
	We make use of the 'classic' HTML Definition List (dl) tag to specify
	committers. I know... you haven't seen this tag in a long while...
 -->
 
<style>
dt {
display: list-item;
list-style-position:outside;
list-style-image:url(/eclipse.org-common/themes/Phoenix/images/arrow.gif);
margin-left:16px;
}
dd {
margin-left:25px;
margin-bottom:5px;
}
</style>
<body>

<p>Maven Integration for Web Tools Platform is a proposed open
source project under the <a href="http://www.eclipse.org/m2e/">Maven Integration</a> project.</p>

<p>This proposal is in the Project Proposal Phase (as defined in the
Eclipse Development Process) and is written to declare its intent and
scope. We solicit additional participation and input from the Eclipse
community. Please send all feedback to the <a href="http://www.eclipse.org/forums/eclipse.proposals">Proposals Forum</a>.</p>

<h2 id="background">Background</h2>

<p>Maven is the defacto standard build tool in Java. It is supported at
Eclipse by the M2E project which provides tooling to configure Eclipse
JDT to understand Maven’s pom.xml file(s) and thereby allow users to
easily import, use and modify Maven projects in Eclipse.</p>

<p>For this to work smoothly, M2E provides a set of extension points to
allow other Eclipse plugins to provide the mapping between the &quot;Maven World&quot;
to the &quot;Eclipse World&quot;.</p>

<p>For example M2E provides a set of extension implementations to make
Eclipse JDT understand the metadata in Maven pom.xml concerning
classpaths and delegates the work of compiling to Eclipse&#8217;s built-in
java compiler instead of what Maven would use by default.</p>

<p>Similarly, the pom.xml contains information about how Java EE projects 
(war, ejb, application-client, rar or ear) are structured and how these 
projects are packaged. These parts are not covered by the M2E project.</p>

<p>The Maven Integration for Web Tools Platform project will cover
these and enable Maven projects to be easily used in context of Eclipse
WTP.</p>

<h2 id="scope">Scope</h2>

<p>Deliver integration between the Maven Integration (M2E) and
Eclipse WTP projects.</p>

<h2 id="description">Description</h2>

<p>The integration is done primarily by implementing extension points in
M2E to listen to its Maven Configuration model changes and from that configure
Eclipse WTP projects. There are also provided extensions for Eclipse WTP
module component system to provide advanced functionality such as
support for Maven Web resource filtering and War Overlay features.</p>

<p>The primary goal is to make the bridge as transparent as possible when
you import Maven projects - secondary would be to make it easy when you
create Eclipse projects to make them Maven projects.</p>

<h2 id="whyeclipse">Why Eclipse?</h2>

<p>This proposal is at Eclipse because of a multitude of reasons:</p>

<ul>
<li>Encourage and enable co-operation between M2E and WTP communities </li>
<li>Participate in release train</li>
<li>Be available in common repository (ease of access for users)</li>
<li>Be available in common issue tracker system (M2E and WTP use eclipse bugzilla) </li>
<li>Be included in future EPP packages</li>
<li>Ease of adoption due to the safety provided by the Eclipse IP due-diligence process</li>
</ul>

<p>Not all of these will be possible at first (such as participate in release train), 
but over time all of these reasons will help improve the Maven support in Eclipse, 
especially for WTP backed projects.</p>

<h2 id="codecontribution">Code Contribution</h2>

<p>The work on these features is currently taking place inside the
m2eclipse-wtp project. This project have, since it was introduced on <a href="http://marketplace.eclipse.org/content/maven-integration-eclipse-wtp">Eclipse Marketplace</a> 
in August 2011, always been in Top 6 of the most installed Eclipse plugins.</p>

<p><a href="https://github.com/sonatype/m2eclipse-wtp/wiki">m2eclipse-wtp Wiki (with additional info links)</a></p>

<p><a href="https://github.com/sonatype/m2eclipse-wtp/">m2eclipse-wtp Source Repository</a></p>

<h3 id="originsofcode">Origins of code</h3>

<p>The original code for this project comes from the m2eclipse project which was 
contributed and maintained by Sonatype and eventually released under EPL at 
http://m2eclipse.sonatype.org/. </p>

<p>Fred Bricon&#8217;s first patch for <a href="http://jira.codehaus.org/browse/MNGECLIPSE-688">initial support for EJB and EAR projects</a> was applied 
in september 2008. He was soon after granted commit rights on the m2eclipse project 
and since september 2009 has been the primary contributor and maintainer of the 
WTP integration part of m2eclipse, mostly as an individual contributor, but also partly 
as a contractor for Sonatype (january/february 2009). </p>

<p>In May 2010, <a href="https://issues.sonatype.org/browse/MNGECLIPSE-1811?focusedCommentId=114262&amp;page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-114262">m2eclipse-wtp split</a> from the m2eclipse core source base and started living 
a separate lifecycle from m2eclipse. Since November 2010, Fred is the designated project 
lead of m2eclipse-wtp.</p>

<p>When Sonatype brought m2eclipse to Eclipse, as M2E, in october 2010, they decided 
not to bring over m2eclipse-wtp mainly due to resource constraints and because it was 
considered not to be fully mature at the time. We believe that it is no longer the case.</p>

<p>Since April 1st, 2011, Fred has been working for Red Hat and continues to maintain and
develop on m2eclipse-wtp under its EPL license via Sonatype&#8217;s contributor license agreement.</p>

<h2 id="committers">Committers</h2>

<p>The following individuals are proposed as initial committers to the
project:</p>
<dl>
<dt>Fred Bricon, Red Hat</dt>
<dd>Fred is the projet lead for the m2eclipse-wtp project and committer on m2e.</dd>

<dt>Snjezana Peco, Red Hat</dt>
<dd>
  Snjezana contributes to Maven functionality at JBoss Tools and Developer Studio 
    and have contributed to both m2e and m2eclipse-wtp over the years. </dd>

<dt>Max Rydahl Andersen, Red Hat</dt>
<dd>Max is the project lead for JBoss Tools and Developer Studio which
    uses and extends M2E and m2eclipse-wtp. He has also been a long-time contributor to M2E's mailing lists.</dd>
</dl>
<h2 id="mentors">Mentors</h2>

<p>The following Architecture Council members will mentor this project:</p>

<ul>
<li>Nick Boldt</li>
<li>Chuck Bridgham</li>
</ul>

<h2 id="interestedparties">Interested Parties</h2>

<p>The following individuals, organizations, companies and projects have
expressed interest in this project:</p>

<ul>
<li>Chuck Bridgham (IBM)</li>
<li>Konstantin Komissarchik (Oracle)</li>
<li>Martin Lippert - VMWare, as part of Spring Source ToolSuite</li>
<li>Kaloyan Raev (SAP)</li>
<li>Neil Hauge - Oracle, Dali Project</li>
<li>Carl Anderson - WTP j2ee project committer, IBM</li>
<li>Chuck Bridgham -WTP j2ee project committer, IBM</li>
<li>Roberto Sanchez Herrera - WTP j2ee project comitter, IBM</li>
<li>Ian Trimble - Oracle</li>
<li>Werner Keil - UOMo Lead, Java EE 6/7 EG Member </li>
</ul>

<h2 id="namespace">Namespace</h2>

<p>org.eclipse.m2e.wtp.*</p>

<h2 id="projectscheduling">Project Scheduling</h2>

<p>The plan is to deliver support for Eclipse Maven and Web Tools Platform 
project as part of an Eclipse train as soon as possible. Juno is too soon, 
thus goal would be Juno + 1.</p>

<h2>Changes to this Document</h2>
<table>
	<tr>
		<th>Date</th>
		<th>Change</th>
	</tr>
<tr><td>2012-04-19</td> <td>Mentors added.</td></tr>

<tr><td>2012-04-02</td> <td>Added Werner Keil as interested party.</td></tr>
<--<tr><td>2012-01-25</td> <td>Added VMWare, SAP and Oracle interested parties. More details about origins of code.</td></tr>
<tr><td>2012-03-22</td> <td>Package name update and project placement.</td></tr>
-->
</table>
</body>
</html>