  ---
  Features
  ---
  John Casey
  ---
  12-May-2006
  ---

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

Features

  The current version of this plugin can be found {{{./project-summary.html}here}}.

  <NOTE: Features with no version information have been present since the first final release of the plugin.>

  * Inclusion of dependencies, modules <[2.1]>, file-sets, and individual files

  * Inclusion of project website documentation <[2.1]>

  * Flexible directory structures for assembly elements

  * All assembly inclusions controlled by include/exclude pattern sets

  * Option to unpack artifact files into the assembly <[deprecated in 2.2]>

  * Project modules can be included as source files or in binary form <[2.1]>

  * Reusable assembly-descriptor components <[2.1]>

  * Supported archive formats include: zip, tar, tar.gz (or tgz), tar.bz2 (or tbz2), jar, dir, war
   (and any other format that the ArchiveManager has been configured for).


  * Directory-only assemblies

  * Filtering and line-ending conversion for file-sets and individual files

  * Directory and file attributes (<modes>) <[2.1]>

  * Artifact filename mapping with expression support <[2.1]>

  * Descriptor interpolation using current project and other assembly descriptor information <[2.1]>

  * Embedded Maven repository creation with artifact version alignment <[2.1]>

  * Security / signature information stripped from embedded artifacts prior to inclusion <[2.1]>

  []

