apache/ant-easyant-core

Mirror of Apache EasyAnt core
Switch branches/tags
Nothing to show
Fetching latest commit…
Cannot retrieve the latest commit at this time.
 Failed to load latest commit information. .settings bin example experiment src .classpath .gitignore .gitmodules .project LICENSE NOTICE README RETIRED_PROJECT build.xml easyant-conf.xml easyant.eclipse.formatter.xml ivysettings-bootstrap.xml ivysettings.xml module.ant module.ivy sample-easyant-ivysettings.xml

**********************
* Welcome to easyant *
**********************

Easyant is a toolbox focusing on easing project build processes.
It's based on Apache Ant and Apache Ivy, and allows for maximum flexibily, improved integration in existing build systems and provides conventions and guidelines.

Our goals are :

* to simplify build process by providing a set of ready to use build scripts (or modules) to ease the implementation of build system.
* to provide conventions and guidelines
* to leverage your ant knowledge (no need to learn another language)
o what about conventions ? : Even if Easyant comes with a lot of conventions, we never lock you in.
o what about modules ? : You can easily adapt it to your projects. The architecture of Easyant allows you to easily extends existing modules and to provide your own one.
o what if you already have an existing project ? Since Easyant is fully based on top of ant, you can keep your existing project along with the "old school" ant scripts. This should ease the migration to Easyant.

************************
* Status               *
************************

This is a retired project.
No further development will be done.

************************
* How to run examples  *
************************

The Easyant source has a few sample projects that demonstrate how Easyant may be used in a project. Check the 'example' directory for all such examples.

* standard-java-app use build-std-java build type.
* webapp-java use build-webapp-java build type and jetty-deploy plugin.
* standard-scala-app uses build-std-scala build type
* example-multimodule shows a multi-module project.
* std-java-with-documentation shows another project using build-std-java build type with documentation samples.

To run the build of an example, you should first set up in your environment the EASYANT_HOME variable :

* for windows users : set EASYANT_HOME=path\to\easyant
* for unix users : export EASYANT_HOME=path/to/easyant

Then go to the example directory, and run:

* for windows users : %EASYANT_HOME%\bin\easyant -p
* for unix users : $EASYANT_HOME/bin/easyant -p You may also add EASYANT_HOME to your path : * for windows users : set PATH=%EASYANT_HOME%\bin;%PATH% * for unix users : export PATH=$EASYANT_HOME/bin:\$PATH

Then you should see all the available targets, which include all build phases inspired by maven 2, and some additional targets contributed by some plugins.
Main phases:

clean                                           delete any artifacts from previous builds
compile                                         compile the source code of the project
documentation                                   generate documentation
generate-local-version                          generate a local version number
generate-release-version                        generate a version number for a release
generate-resources                              generate resources for inclusion in the package
generate-shared-version                         generate a version number for shared publication
generate-sources                                generate any source code for inclusion in compilation
integration-test                                process and deploy the package if necessary into an environment where integration tests can be run
org.apache.easyant.plugins#phases-std.validate  validate the project is correct and all necessary information is available
package                                         take the compiled code and package it in its distributable format, such as a JAR.
post-integration-test                           perform actions required after integration tests have been executed. This may including cleaning up the environment
pre-integration-test                            perform actions required before integration tests are executed. This may involve things such as setting up the required environment
prepare-package                                 perform any operations necessary to prepare a package before the actual packaging. This often results in an unpacked, processed version of the package
prepare-publish-local                           prepare a publish for a local repository
prepare-publish-shared                          prepare a publish for a shared repository (snapshot)
prepare-release                                 prepare a release
process-classes                                 post-process the generated files from compilation, for example to do bytecode enhancement on Java classes
process-documentation-resources                 copy and process the documentation resources into the destination directory
process-resources                               copy and process the resources into the destination directory, ready for packaging
process-sources                                 process the source code, for example to filter any values
provision                                       supply provision required by this project
publish-local                                   publish the package into the local repository, for use as a dependency in other projects locally
publish-shared                                  done in an integration environment, copies the final package to the remote repository for sharing with other developers and projects
release                                         done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects
report                                          generate report
test                                            run tests using a suitable unit testing framework. These tests should not require the code be packaged or deployed
test-compile                                    compile the test source code into the test destination directory
test-generate-resources                         create resources for testing
test-generate-sources                           generate any test source code for inclusion in compilation
test-process-resources                          copy and process the resources into the test destination directory
test-process-sources                            process the test source code, for example to filter any values
test-provision                                  supply provision required to test this project
validate                                        validate the project is correct and all necessary information is available
verify                                          run any checks to verify the package is valid and meets quality criteri

Default target: doit

Then run: %EASYANT_HOME%\bin\easyant

The example should be compiled, as well as unit tests, which should then be executed, and a jar should be produced in target/artifacts.

***************
* Source code *
***************
Easyant is released under Apache License 2.0.

Sources can be found here
Git URL : https://git-wip-us.apache.org/repos/asf/easyant-core.git

************
* Web site *
************

Check the website to get further information http://ant.apache.org/easyant/

**************************************
* IRC Channel (#easyant on freenode) *
**************************************
We've registered an IRC channel on the freenode network for informal easyant discussions, asking questions or just hanging out and "socializing".

The channel is #easyant on irc.freenode.net.

Drop by if you are interested in the development of easyant, have a quick question or just want to get to know the people developing and using it. If you're new to IRC, be sure to learn how to get answers. A free web irc client is available here http://www.mibbit.com/