If you are looking for Maven like features, but still need more, you've come to the right place.
Like Maven, OpenMake Meister establishes standard guidelines for build best practices and build project management, therefore clarifying and simplifying the build process. Meister is a build management tool that actually manages binaries. As users of Maven know, putting workflow on top of chaos does not solve the build management problems. OpenMake Software offers free workflow management with Mojo, but addresses the complete build management challenge with Meister.
Like Maven, Meister manages the creation of binaries. Meister provides the framework for allowing build projects to use a standard template, called a Build Method. When you use a Build Method to construct a binary, Meister guarantees that every binary of that type will be built consistently to your specifications. That means that every war, ear and jar file - just to name a few - is created with the same well-documented and automated process. The Meister community developed knowledge base gathers the build best practice information that clarifies how a binary was created, from standardizing on the compile options as well as defining what versions of packages should be used.
Flexible and Customizable
Meister is flexible and can support any type of directory structure that your Java Project uses. Meister can also adjust to changes you make in your directory structure. You do not need to conform to a standard that has been pre-defined, you can define your own. To put it another way, Meister does not care how you named your files or directories. It can accommodate any file structure.
Meister Leverages Ant as the Compiler
Like Maven, Meister leverages Ant as the compiler for building java objects. You can customize the way in which you want to call Ant, develop standardize Ant tasks and share these methods with other developers.
Automatically Synchronize IDE Compiles with Your Continuous Integration Build
If you are implementing Continuous Integration, or at least automating your builds, Meister can accelerate the process by synchronizing your individual IDE build changes automatically with your CI builds. Meister manages at the IDE Project file level, and automatically updates the build scripts executing on the Continuous Integration Build Server with the changes made inside of the IDE. Get the White Paper.
Transitive Dependency Management
We know how important dependency management is - we have been providing source scanning and dependency discovery technology to our customers for the last 13 years. Meister provides deep dependency discovery exposing all artifacts referenced by your .jars, .wars and .ears. With Meister, you do not need to sort out dependencies manually - it does the work for you. Meister integrates with artifact repositories such as the Maven Repository, Sonatype Nexus, Archiva or it allows you to define your own central repository.
Fast, Efficient Builds
Faster more efficient builds are needed to support today's agile and iterative development practices. For this reason, Meister leverages it's dependency scanning features to determine which objects are impacted by source code changes and builds only those objects. Build Avoidance can reduce your build times from hours to minutes. With Meister, the 10 minute builds is not only possible, its the norm.
Real-Time Build Monitoring
Meister gives you a real-time build monitoring command center. When you execute a build from inside your IDE, or on your CI build server, Meister displays each step of your build, including the detailed steps of the build such as calls to javac.exe and jar.exe. With Meister you can track the creation of the binaries as well as the pre and post steps such as calls to check-out source, execute testing tools and the calling of deployment scripts.
Repeatable and Transparent Builds
With Meister, you control every aspect of how a build is configured and executed. The process is completely transparent and repeatable to anyone on the team. There is never guess work involved causing you to spend time attempting to sort out where a dependency may have come from during the build. You will know that before the build.