BNM v0.1.0

BNM is not Maven.
BNM is rather a prof of possible enhancements to Maven.

Get Started

Get the BNM launcher launcher-0.2.7.jar and unzip it int a new folder. You'l get a few files:

bnm                 the Unix shell file
bnm.bat             the Windows batch file
BnmLauncher.class   the bootstrap class which starts BNM
LICENSE             the GPL
src                 the source code for BnmLauncher.class

Then start bnm or bnm.bat (depending on your operation system).
It downloads the remaining required artifacts into your repository and relaunches BNM using the specified version.
Once the launcher got all required files, it never attempts to download the files again, until you switch to a newer version. Why? Because it doesn't use SNAPSHOT versions and thus the content won't change.
If there is a new version, you can manually edit the version in the launcher batch/script file, or download the most recent launcher package.

Source

The bnm project tree is now available via github at https://github.com/bebbo/de.bb.tools.bnm

How good is BNM

BNM is able to build its own project tree and is more than 3 times faster than Maven 2. And it is still faster than Maven 3.
Not everything is implemented yet, but BNM can build itself :-)

build tool	command line	build time (best of 3 repeated runs)
Maven 2	mvn.bat clean install	-- failes to resolve org.eclipse versions
Maven 3	mvn.bat clean install	25.8s
Maven 3	mvn.bat -T2 clean install	17.7s
BNM 0.1.0	bnm clean install	11.7s

Report bugs in bugzilla or use the forum.

There is also an eclipse integration using the BNM eclipse plugin. Please use the eclipse update site http://www.bebbosoft.de/plugins to install the feature.

Once installed learn how to use it [here].

Can I use existing pom.xml files?

Yes you can! Right now not all plugins are present. Since BNM does not use Maven plugins a replacement plugin must exist. Each replacement plugin maps itself to the maven id (ignoring the maven version). BNM runs its own plugins on your existing pom.xml files.
Since BNM is more a proof that Maven could be much faster, there is still hope that Maven will improve. Nevertheless it is futile to wait. The best way today is to use BNM and Maven in parallel: - use BNM to compile/build during your development cycle - use Maven for everything else This also reduces the need for many plugins (deployment etc. pp).

Can I code own plugins?

Yes you can. And you don't need any special processing to create a plugin since BNM uses Java annotations to attach the pom.xml values to plugin instances.
Still be aware that BNM plugins must be thread safe! If your plugins hooks some third party stuff which isn't thread safe, synchronize the invokation in the plugins code.

Feedback

Also checkout http://www.bebbosoft.de/bugs/ to enter bugs, requests and so on.

License

BNM is published under GPLv3. The sources are bundled into the JAR files.
If you need a commercial license feel free to contact us.

Features

BNM has a small launcher
BNM is compact
BNM works much faster than Maven
- parallelizes downloads
- parallelizes the build process
BNM is different / better?
- BNM performs no updates on final artifacts (non SNAPSHOT version)
- BNM performs no updates on SNAPSHOT version which are part of the current project tree.
BNM is more strict (maybe more precise!?)
- no support for version ranges since this breaks the build (You always get exactly the specified version)
- disallows variable usage in id, artifactId, groupId, version, scope and packaging fields.
Eclipse plugin for a new way of using Maven/BNM projects
- action to create the next SNAPSHOT version of an artifact and update all dependencies inside the project tree
- action to finalize an artifact and update all dependencies inside the project tree
- action to get a subproject as Eclipse project
- (unfinished) integrated builder to run 'bnm install' on changes for all dependent projects
- (planned)
  - wizard to create project roots
  - wizards to create projects inside the project tree
  - final artifacts are made read only, thus requires a SNAPSHOT creation to modify

Internals

If you plan to use a tool like BNM it is important to know how everything works together.

Ingredients

First the ingredients:

settings.xml
pom.xml - own, parent and included

merge order

Those are merged in this order to create a resolved pom (see below how merge works).

settings.xml
included from root pom.xml
root pom.xml
included from first child pom.xml
first child pom.xml
...
included from artifact pom.xml
artifact pom.xml So how does this merge work? Once the resolved pom is created
the active profiles of the resolved pom
the active profiles of the settings.xml are applied. And finally the properties are resolved which results into the effective pom.
merge mechanics
The merge mechanism takes a parent pom.xml and a child pom.xml and performs the following steps:
The elements
- parent
- modules
- groupId
- artifactId
- version of the parent pom.xml are replaced with the values of the child pom.xml, even when null.
The elements
- build
- dependencyManagement
- pluginManagement
- reporting are merged by applying this algorithm to the elements recursively.
simple elements (String, URL, boolean, types) are replaced with the child value, if it is set. If the value is unset in the child, the parent value persists.
list elements are merged by this algorithm:
- parent list members having a field named inherited set to false are removed.
- if a list member contains the groupId, artifactId fields
  - if the member has the type plugin, children of same groupId, artifactId, version are merged by applying this algorithm recursively. Plugins with different version coexists!
  - otherwise child member with the same groupId, artifactId are replacing parent members (thus overriding the version!).
  - if a list member contains an id field, child members with the same id are replacing parent members. Elements with different id are appended.
  - otherwise all child members are appended to the parent list
map elements (like properties or configuration) are merged by these rules:
- if the map key refers to a CTYPE (like properties), if a child value exists it replaces the parent value.
- if the key refers to elements all named identical, it is treated as a list. By default if a child list exists it replaces the parent list.
  - planned: modify the behaviour with attributes in the child list:
    - mode="append" will result into appending the child list.
    - mode="prepend" will result into prepending the child list.
    - mode="merge" uses the list merge algorithm described above.
  if the key refers to different named elements this map merge algorithm is applied recursively

rev: 1.31