Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorGoal.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorGoal.java:1.11 maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorGoal.java:1.12
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorGoal.java:1.11	Wed Mar 19 20:21:42 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorGoal.java	Thu Mar 20 01:30:55 2008
@@ -20,11 +20,12 @@
 
 import org.codelutin.i18n.I18n;
 import static org.codelutin.i18n.I18n._;
-import org.codelutin.option.AbstractContext;
+import org.codelutin.i18n.LanguageManager;
+import org.codelutin.i18n.LocaleEnum;
+import org.codelutin.i18n.bundle.I18nBundleManager;
 import org.codelutin.option.ConfigKey;
 import org.codelutin.option.ConfigPropertyKey;
 import org.codelutin.option.OptionKey;
-import org.codelutin.option.OptionParser;
 import static org.codelutin.option.ParserUtil.addTitle;
 import org.codelutin.option.def.OptionDefinition;
 import org.codelutin.option.generate.util.AbstractGeneratorGoal;
@@ -36,6 +37,9 @@
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
+import java.lang.reflect.Field;
+import java.net.URL;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -43,72 +47,82 @@
  *
  * @author chemit
  * @goal genRst
- * @phase pre-site
+ * @phase process-classes
  */
 public class RstGeneratorGoal extends AbstractGeneratorGoal<RstGeneratorContext> {
 
-
-    protected Class<? extends OptionParser> parserClass;
-
-    protected Class<? extends AbstractContext> contextClass;
+    /**
+     * @description le chemin où trouver les fichiers de traductions pour l'initialisation I18N, sinon le fichier du
+     *              plugin est utilisé, alors qu'il faut que ce soit celui de l'application
+     * @parameter expression="${commandline.i18nCP}" default-value="${basedir}/src/resources"
+     */
+    protected File i18nCP;
+
+    /**
+     * @description Répertoire de sortie.
+     * @parameter expression="${commandline.out}" default-value="${basedir}/target/classes"
+     * @required
+     */
+    protected File out;
+
+    /**
+     * @description Target rst file.
+     * @parameter expression="${commandline.rstFilePath}"
+     * @required
+     */
+    protected File rstFilePath;
+
+    /**
+     * @description Target rst file.
+     * @parameter expression="${commandline.bundles}"
+     */
+    protected String[] bundles;
 
     public RstGeneratorGoal() {
         super(RstGeneratorContext.class);
     }
 
-    @SuppressWarnings({"unchecked"})
-    protected void init() throws Exception {
-
-        getLog().info("projectCP:" + getContext().getOut());
-        // add i18n location as classpath
-        Resource.addDefaultClassLoader(new File(getContext().getI18nCP()).toURI().toURL());
-        Resource.addDefaultClassLoader(getContext().getOut().toURI().toURL());
-        // init i18n
-        I18n.initISO88591(System.getProperty("user.language"), System.getProperty("user.country"));
-
-        checkInstanceOf(getContext().getParserFQN(), OptionParser.class);
-
-        checkInstanceOf(getContext().getContextFQN(), AbstractContext.class);
+    public void generate() throws Exception {
 
+        List<OptionKey> optionKeys = ReflectUtil.getConstants(getContext().getParserClass(), OptionKey.class);
+        List<ConfigKey> configKeys = ReflectUtil.getConstants(getContext().getContextClass(), ConfigKey.class);
 
-        parserClass = (Class<? extends OptionParser>) Class.forName(getContext().getParserFQN());
+        // find bundle for the project
+        URL[] urls = Resource.getURLs(I18nBundleManager.SEARCH_BUNDLE_PATTERN, getI18nCP().toURI().toURL()).toArray(new URL[2]);
 
-        contextClass = (Class<? extends AbstractContext>) Class.forName(getContext().getParserFQN());
+        // reset i18n manager
+        LanguageManager.reset();
 
-        if (!getContext().getRstFilePath().getParentFile().exists()) {
-            getContext().getRstFilePath().getParentFile().mkdirs();
+        for (String bundle : getBundles()) {
+            File rstFilePath = new File(getContext().getRstFilePath(), getPrefix() + "Usage-" + bundle + ".rst");
+            LocaleEnum langue = LocaleEnum.valueOf(bundle);
+            Writer w = null;
+            try {
+                w = new BufferedWriter(new FileWriter(rstFilePath));
+
+                generateForBundle(w, rstFilePath, getPrefix(), optionKeys, configKeys, langue, urls);
+            } finally {
+                if (w != null) {
+                    w.flush();
+                    w.close();
+                }
+            }
         }
-
     }
 
-    public void generate() throws Exception {
-
-        Writer w = null;
-
-        try {
-            File rstFilePath = getContext().getRstFilePath();
+    private void generateForBundle(Writer w, File rstFilePath, String prefix, List<OptionKey> optionKeys, List<ConfigKey> configKeys, LocaleEnum langue, URL[] urls) throws IOException {
 
-            w = new BufferedWriter(new FileWriter(rstFilePath));
+        // init i18n with this
+        I18n.initISO88591(langue, urls);
 
-            String prefix = getContext().getPrefix();
-
-            List<OptionKey> optionKeys = ReflectUtil.getConstants(parserClass, OptionKey.class);
-            List<ConfigKey> configKeys = ReflectUtil.getConstants(contextClass, ConfigKey.class);
-
-            toString(w,
-                    _("commandline.generateRstFile.head", prefix),
-                    _("commandline.generateRstFile.prefix") + ' ',
-                    _("commandline.generateRstFile.options.head", prefix),
-                    _("commandline.generateRstFile.configs.head", prefix),
-                    optionKeys, configKeys
-            );
-            getLog().info(_("commandline.generateRstFile.info", rstFilePath));
-        } finally {
-            if (w != null) {
-                w.flush();
-                w.close();
-            }
-        }
+        toString(w,
+                _("commandline.generateRstFile.head", prefix),
+                _("commandline.generateRstFile.prefix") + ' ',
+                _("commandline.generateRstFile.options.head", prefix),
+                _("commandline.generateRstFile.configs.head", prefix),
+                optionKeys, configKeys
+        );
+        getLog().info(_("commandline.generateRstFile.info", rstFilePath.getAbsolutePath()));
     }
 
     public void toString(Writer w, String head, String prefix, String prefixOption, String prefixConfig, List<OptionKey> optionKeys, List<ConfigKey> configKeys) throws IOException {
@@ -119,7 +133,7 @@
         for (OptionKey key : optionKeys) {
             OptionDefinition definition = key.getDefinition();
             w.append(prefix).append(definition.toString());
-            w.append("\n    ").append(key.getDescription()).append("\n\n");
+            w.append("\n    ").append(_(key.getDescription())).append("\n\n");
         }
         if (configKeys.isEmpty()) {
             return;
@@ -138,4 +152,58 @@
         }
     }
 
+    public File getI18nCP() {
+        return i18nCP;
+    }
+
+    public File getRstFilePath() {
+        return rstFilePath;
+    }
+
+    public File getOut() {
+        return out;
+    }
+
+    public String[] getBundles() {
+        return bundles;
+    }
+
+    public void setOut(File out) {
+        this.out = out;
+    }
+
+    public void setBundles(String[] bundles) {
+        this.bundles = bundles;
+    }
+
+    @SuppressWarnings({"unchecked"})
+    public <T> List<T> getConstants(Class<?> klass, Class<T> searchingClass) {
+        List<T> result = new ArrayList<T>();
+        for (Field field : klass.getDeclaredFields()) {
+            if (!field.isAccessible()) {
+                field.setAccessible(true);
+            }
+            if (acceptClass(field.getType(), searchingClass) && ReflectUtil.isConstantField(field)) {
+                try {
+                    result.add((T) field.get(null));
+                } catch (IllegalAccessException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+        Class<?> superClass = klass.getSuperclass();
+        if (superClass != null) {
+            result.addAll(getConstants(superClass, searchingClass));
+        }
+        return result;
+    }
+
+    public boolean acceptClass(Class<?> klass, Class<?> searchingClass) {
+
+        boolean result = klass.getName().equals(searchingClass.getName());
+        if (!result && klass.getSuperclass() != null) {
+            result = acceptClass(klass.getSuperclass(), searchingClass);
+        }
+        return result;
+    }
 }
\ No newline at end of file

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorContext.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorContext.java:1.1 maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorContext.java:1.2
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorContext.java:1.1	Wed Mar 19 20:21:42 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorContext.java	Thu Mar 20 01:30:55 2008
@@ -14,9 +14,261 @@
  */
 package org.codelutin.option.generate;
 
+import org.codelutin.i18n.I18n;
+import static org.codelutin.i18n.I18n._;
+import org.codelutin.option.Option;
+import org.codelutin.option.OptionParser;
+import org.codelutin.option.def.DefinitionParser;
+import org.codelutin.option.def.DefinitionParserUtil.TypeSource;
 import org.codelutin.option.generate.util.AbstractGeneratorContext;
 
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+
 /** @author chemit */
-public class JavaGeneratorContext extends AbstractGeneratorContext {
+public class JavaGeneratorContext extends AbstractGeneratorContext<JavaGeneratorGoal> {
+
+    protected String parserPackageName;
+    protected String optionPackageName;
+    protected String configPackageName;
+    protected String actionPackageName;
+    protected String contextPackageName;
+
+    protected String parserSimpleName;
+    protected String optionSimpleName;
+    protected String configSimpleName;
+    protected String actionSimpleName;
+    protected String contextSimpleName;
+
+    protected DefinitionParser parser;
+
+    public String getActionPackageName() {
+        return actionPackageName;
+    }
+
+    public void setActionPackageName(String actionPackageName) {
+        this.actionPackageName = actionPackageName;
+    }
+
+    public String getActionSimpleName() {
+        return actionSimpleName;
+    }
+
+    public void setActionSimpleName(String actionSimpleName) {
+        this.actionSimpleName = actionSimpleName;
+    }
+
+    public String getActionSuperClass() {
+        return getGoal().getActionSuperClass();
+    }
+
+
+    public boolean isConcreteConfig() {
+        return getGoal().isConcreteConfig();
+    }
+
+    public String getConfigPackageName() {
+        return configPackageName;
+    }
+
+    public void setConfigPackageName(String configPackageName) {
+        this.configPackageName = configPackageName;
+    }
+
+    public String getConfigSimpleName() {
+        return configSimpleName;
+    }
+
+    public void setConfigSimpleName(String configSimpleName) {
+        this.configSimpleName = configSimpleName;
+    }
+
+    public String getConfigSuperClass() {
+        return getGoal().getConfigSuperClass();
+    }
+
+
+    public String getContextPackageName() {
+        return contextPackageName;
+    }
+
+    public void setContextPackageName(String contextPackageName) {
+        this.contextPackageName = contextPackageName;
+    }
+
+    public String getContextSimpleName() {
+        return contextSimpleName;
+    }
+
+    public void setContextSimpleName(String contextSimpleName) {
+        this.contextSimpleName = contextSimpleName;
+    }
+
+    public String getContextSuperClass() {
+        return goal.getContextSuperClass();
+    }
+
+
+    public String getOptionPackageName() {
+        return optionPackageName;
+    }
+
+    public void setOptionPackageName(String optionPackageName) {
+        this.optionPackageName = optionPackageName;
+    }
+
+    public String getOptionSimpleName() {
+        return optionSimpleName;
+    }
+
+    public void setOptionSimpleName(String optionSimpleName) {
+        this.optionSimpleName = optionSimpleName;
+    }
+
+    public String getOptionSuperClass() {
+        return goal.getOptionSuperClass();
+    }
+
+    public String getParserPackageName() {
+        return parserPackageName;
+    }
+
+    public void setParserPackageName(String parserPackageName) {
+        this.parserPackageName = parserPackageName;
+    }
+
+    public String getParserSimpleName() {
+        return parserSimpleName;
+    }
+
+    public void setParserSimpleName(String parserSimpleName) {
+        this.parserSimpleName = parserSimpleName;
+    }
+
+    public String getParserSuperClass() {
+        return goal.getParserSuperClass();
+    }
+
+    public boolean isShowErrors() {
+        return goal.isShowErrors();
+    }
+
+
+    public File getSource() {
+        return goal.getSource();
+    }
+
+    public String getTypeSource() {
+        return goal.getTypeSource();
+    }
+
+
+    public DefinitionParser getParser() {
+        return parser;
+    }
+
+    public void init(JavaGeneratorGoal goal) throws IOException, ClassNotFoundException {
+
+        super.init(goal);
+
+
+        checkInstanceOf(getParserSuperClass(), OptionParser.class);
+        checkInstanceOf(getOptionSuperClass(), Option.class);
+
+        //checkInstanceOf(actionSuperClass, OptionAction.class);
+        //checkInstanceOf(configSuperClass, Config.class);
+        
+        String packageName = getPackageName();
+
+        parserPackageName = packageName;
+
+        if (optionPackageName == null) {
+            optionPackageName = packageName + ".options";
+        }
+        if (actionPackageName == null) {
+            actionPackageName = packageName + ".actions";
+        }
+        if (configPackageName == null) {
+            configPackageName = packageName + ".configs";
+        }
+        if (contextPackageName == null) {
+            contextPackageName = packageName;
+        }
+        if (parserSimpleName == null) {
+            parserSimpleName = getPrefix() + "OptionParser";
+        }
+        if (optionSimpleName == null) {
+            optionSimpleName = getPrefix() + "Option";
+        }
+        if (actionSimpleName == null) {
+            actionSimpleName = getPrefix() + "AbstractOptionAction";
+        }
+        if (configSimpleName == null) {
+            configSimpleName = getPrefix() + "Config";
+        }
+        if (contextSimpleName == null) {
+            contextSimpleName = getPrefix() + "AbstractContext";
+        }
+
+        // get source (make sure to be on a absolute path)
+        File source = new File(getSource().getAbsolutePath());
+
+        // get type of source for parser
+        TypeSource typeP = null;
+        try {
+            typeP = TypeSource.valueOf(getTypeSource());
+        } catch (Exception e) {
+            // ignore here (will be treate by parser)
+        }
+
+        // get source (make sure to be on a absolute path)
+        source = new File(source.getAbsolutePath());
+
+        // init i18n for error explicit messages
+        I18n.initISO88591();
+
+        // do parse definitions and return parser
+        parser = DefinitionParser.doParse(typeP, source);
+
+        getLog().info(_("commandline.parser.result.info", parser.getClass().getSimpleName(), parser.getOptions().length, parser.getConfigs().length));
+
+        // show errors
+        if (isShowErrors()) {
+            if (parser.hasFailed()) {
+                Writer writer = new StringWriter();
+                parser.printErrors(writer);
+                String lines = writer.toString();
+                for (String s : lines.split("\n")) {
+                    getLog().info(_("commandline.showErrors.info") + ' ' + s);
+                }
+                writer.flush();
+                writer.close();
+
+            } else {
+                getLog().info(_("commandline.showErrors.no.error.info"));
+            }
+        }
+
+        // quit if any error detected
+        if (parser.hasFailed()) {
+            String message = _("commandline.parser.parsing.error", parser, parser.getErrors().length);
+            throw new IllegalStateException(message);
+        }
+
+    }
+
+    protected void checkInstanceOf(String givenClass, Class<?> expectedClass) {
+        try {
+            Class clazz = Class.forName(givenClass);
+            //Class clazz = Class.forName(givenClass, true, loader);
+            if (!expectedClass.isAssignableFrom(clazz)) {
+                throw new IllegalArgumentException("required a " + expectedClass + " class but found a " + clazz);
+            }
+        } catch (ClassNotFoundException e) {
+            throw new IllegalArgumentException(e);
+        }
+    }
 
 }

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorContext.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorContext.java:1.1 maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorContext.java:1.2
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorContext.java:1.1	Wed Mar 19 20:21:42 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/RstGeneratorContext.java	Thu Mar 20 01:30:55 2008
@@ -14,57 +14,120 @@
  */
 package org.codelutin.option.generate;
 
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.plugin.logging.Log;
+import org.apache.maven.project.MavenProject;
+import org.codelutin.i18n.I18n;
+import static org.codelutin.i18n.I18n._;
+import org.codelutin.option.AbstractContext;
+import org.codelutin.option.OptionParser;
 import org.codelutin.option.generate.util.AbstractGeneratorContext;
 
 import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Set;
 
 /** @author chemit */
-public class RstGeneratorContext extends AbstractGeneratorContext {
+public class RstGeneratorContext extends AbstractGeneratorContext<RstGeneratorGoal> {
 
-    /**
-     * @description le chemin où trouver les fichiers de traductions pour l'initialisation I18N, sinon le fichier du plugin est utilisé, alors qu'il faut que ce soit celui de l'application
-     * @parameter expression="${commandline.i18nCP}" default-value="${basedir}/target/gen/i18n"
-     */
-    protected String i18nCP;
-    /**
-     * @description Target rst file.
-     * @parameter expression="${commandline.rstFilePath}"
-     * @required
-     */
-    protected File rstFilePath;
+    private Class<? extends OptionParser> parserClass;
+    private Class<? extends AbstractContext> contextClass;
 
-    protected String parserFQN;
-    protected String contextFQN;
+    private URLClassLoader loader;
 
-    public String getI18nCP() {
-        return i18nCP;
-    }
-
-    public void setI18nCP(String i18nCP) {
-        this.i18nCP = i18nCP;
-    }
-
-    public String getParserFQN() {
-        return parserFQN;
-    }
-
-    public String getContextFQN() {
-        return contextFQN;
+    public File getI18nCP() {
+        return goal.getI18nCP();
     }
 
     public File getRstFilePath() {
-        return rstFilePath;
+        return goal.getRstFilePath();
     }
 
-    public void setRstFilePath(File rstFilePath) {
-        this.rstFilePath = rstFilePath;
+    public String[] getBundles() {
+        return goal.getBundles();
     }
 
-    public void init() {
-        super.init();
-        parserFQN = getPackageName()+'.'+getPrefix()+"OptionParser";
-
-        contextFQN = getPackageName()+'.'+getPrefix()+"AbstractContext";
-
+    public Class<? extends AbstractContext> getContextClass() {
+        return contextClass;
+    }
+
+    public Class<? extends OptionParser> getParserClass() {
+        return parserClass;
+    }
+
+    public URLClassLoader getLoader() {
+        return loader;
+    }
+
+    @SuppressWarnings({"unchecked"})
+    public void init(RstGeneratorGoal goal) throws IOException, ClassNotFoundException {
+
+        super.init(goal);
+
+        String parserFQN = getPackageName() + '.' + getPrefix() + "OptionParser";
+
+        String contextFQN = getPackageName() + '.' + getPrefix() + "AbstractContext";
+
+        loader = initClassLoader(goal.getProject(), getLog());
+
+        // init i18n
+        I18n.initISO88591(System.getProperty("user.language"), System.getProperty("user.country"));
+
+        parserClass = (Class<? extends OptionParser>) Class.forName(parserFQN, true, loader);
+
+        contextClass = (Class<? extends AbstractContext>) Class.forName(contextFQN, true, loader);
+
+        if (!getRstFilePath().getParentFile().exists()) {
+            getRstFilePath().getParentFile().mkdirs();
+        }
+
+        if (goal.getBundles() == null) {
+            goal.setBundles(new String[]{"fr", "en"});
+        }
+    }
+
+    @SuppressWarnings({"unchecked"})
+    protected URLClassLoader initClassLoader(MavenProject project, Log log) {
+        URLClassLoader loader = null;
+        if (project != null) {
+            URLClassLoader result;
+            try {
+                Set<Artifact> compileClasspathElements = project.getArtifacts();
+                URL[] url = new URL[compileClasspathElements.size() + 2];
+                url[0] = getOut().toURI().toURL();
+                url[1] = getI18nCP().toURI().toURL();
+                int i = 2;
+                for (Artifact artifact : compileClasspathElements) {
+                    File file = new File(artifact.getFile().getAbsolutePath());
+                    if (file.getName().endsWith(".jar")) {
+                        url[i] = new URL("jar", "", file.toURI().toURL().toString() + "!/");
+                    } else {
+                        url[i] = file.toURI().toURL();
+                    }
+                    i++;
+                }
+                //ClassLoader parent = Thread.currentThread().getContextClassLoader();
+                if (compileClasspathElements.size() == 0) {
+                    result = new URLClassLoader(url, getClass().getClassLoader());
+                } else {
+                    result = new URLClassLoader(url, getClass().getClassLoader());
+                }
+            } catch (MalformedURLException eee) {
+                throw new RuntimeException(_("Can't create ClassLoader for script, bad directory: {0} for reason {1}", getOut(), eee.getMessage()), eee);
+            } catch (IOException e) {
+                throw new RuntimeException(_("Can't create ClassLoader for script, bad directory: {0} for reason {1}", getOut(), e.getMessage()), e);
+            }
+            loader = result;
+        }
+        if (log.isDebugEnabled() && loader != null) {
+            for (URL entry : loader.getURLs()) {
+                log.info("cp url " + entry);
+            }
+        }
+        return loader;
     }
+
 }
\ No newline at end of file

Index: maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorGoal.java
diff -u maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorGoal.java:1.20 maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorGoal.java:1.21
--- maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorGoal.java:1.20	Wed Mar 19 20:21:42 2008
+++ maven-commandline-plugin/src/java/org/codelutin/option/generate/JavaGeneratorGoal.java	Thu Mar 20 01:30:55 2008
@@ -19,16 +19,10 @@
 package org.codelutin.option.generate;
 
 import org.apache.commons.lang.StringUtils;
-import org.apache.maven.plugin.MojoFailureException;
-import static org.codelutin.i18n.I18n._;
 import org.codelutin.option.Config;
-import org.codelutin.option.Option;
 import org.codelutin.option.OptionAction;
-import org.codelutin.option.OptionParser;
-import org.codelutin.option.def.DefinitionParser;
 import org.codelutin.option.def.DefinitionParserContexts.ConfigContext;
 import org.codelutin.option.def.DefinitionParserContexts.OptionContext;
-import org.codelutin.option.def.DefinitionParserUtil.TypeSource;
 import org.codelutin.option.generate.java.AbstractConfigJavaGenerator;
 import org.codelutin.option.generate.java.AbstractContextJavaGenerator;
 import org.codelutin.option.generate.java.AbstractOptionActionJavaGenerator;
@@ -40,8 +34,6 @@
 import org.codelutin.option.generate.util.AbstractGeneratorGoal;
 
 import java.io.File;
-import java.io.StringWriter;
-import java.io.Writer;
 import java.util.Map;
 import java.util.TreeMap;
 
@@ -63,11 +55,11 @@
     protected File source;
 
     /**
-     * @description nom du paquetage utilisé pour la génération du parseur
-     * @parameter expression="${commandline.parserPackageName}"
+     * @description Répertoire de sortie.
+     * @parameter expression="${commandline.out}" default-value="${maven.src.dir}/java"
      * @required
      */
-    protected String parserPackageName;
+    protected File out;
 
     /**
      * @description type de source à  utiliser par le parser
@@ -82,60 +74,6 @@
     protected boolean showErrors;
 
     /**
-     * @description nom du paquetage utilisé pour la génération des options
-     * @parameter expression="${commandline.optionPackageName}"
-     */
-    protected String optionPackageName;
-
-    /**
-     * @description nom du paquetage utilisé pour la génération des config
-     * @parameter expression="${commandline.configPackageName}"
-     */
-    protected String configPackageName;
-
-    /**
-     * @description nom du paquetage utilisé pour la génération des actions
-     * @parameter expression="${commandline.actionPackageName}"
-     */
-    protected String actionPackageName;
-
-    /**
-     * @description nom du paquetage utilisé pour la génération des actions
-     * @parameter expression="${commandline.contextPackageName}"
-     */
-    protected String contextPackageName;
-
-    /**
-     * @description nom du parseur a generer
-     * @parameter expression="${commandline.parserSimpleName}"
-     */
-    protected String parserSimpleName;
-
-    /**
-     * @description prefix du nom des options a generer
-     * @parameter expression="${commandline.optionSimpleName}"
-     */
-    protected String optionSimpleName;
-
-    /**
-     * @description prefix du nom des config a generer
-     * @parameter expression="${commandline.configSimpleName}"
-     */
-    protected String configSimpleName;
-
-    /**
-     * @description prefix du nom des actions a generer
-     * @parameter expression="${commandline.actionSimpleName}"
-     */
-    protected String actionSimpleName;
-
-    /**
-     * @description prefix du nom du context a generer
-     * @parameter expression="${commandline.contextSimpleName}"
-     */
-    protected String contextSimpleName;
-
-    /**
      * @description fqn de la super classe du parseur a generer
      * @parameter expression="${commandline.parserSuperClass}" default-value="org.codelutin.option.OptionParser"
      */
@@ -171,99 +109,17 @@
      */
     protected boolean concreteConfig;
 
+
     public JavaGeneratorGoal() {
         super(JavaGeneratorContext.class);
     }
 
-    protected DefinitionParser parser;
-
-    //protected boolean needActionConstructor;
-
-    protected void init() throws Exception {
-
-        super.init();
-        //I18n.initISO88591(System.getProperty("user.language"), System.getProperty("user.country"));
-
-        checkInstanceOf(parserSuperClass, OptionParser.class);
-        checkInstanceOf(optionSuperClass, Option.class);
-        //checkInstanceOf(actionSuperClass, OptionAction.class);
-        //checkInstanceOf(configSuperClass, Config.class);
-        //initClassLoader();
-
-        if (optionPackageName == null) {
-            optionPackageName = parserPackageName + ".options";
-        }
-        if (actionPackageName == null) {
-            actionPackageName = parserPackageName + ".actions";
-        }
-        if (configPackageName == null) {
-            configPackageName = parserPackageName + ".configs";
-        }
-        if (contextPackageName == null) {
-            contextPackageName = parserPackageName;
-        }
-        if (parserSimpleName == null) {
-            parserSimpleName = getContext().getPrefix() + "OptionParser";
-        }
-        if (optionSimpleName == null) {
-            optionSimpleName = getContext().getPrefix() + "Option";
-        }
-        if (actionSimpleName == null) {
-            actionSimpleName = getContext().getPrefix() + "AbstractOptionAction";
-        }
-        if (configSimpleName == null) {
-            configSimpleName = getContext().getPrefix() + "Config";
-        }
-        if (contextSimpleName == null) {
-            contextSimpleName = getContext().getPrefix() + "AbstractContext";
-        }
-
-        // get type of source for parser
-        TypeSource typeP = null;
-        try {
-            typeP = TypeSource.valueOf(typeSource);
-        } catch (Exception e) {
-            // ignore here (will be treate by parser)
-        }
-
-        // get source (make sure to be on a absolute path)
-        source = new File(source.getAbsolutePath());
-
-        // do parse definitions and return parser
-        parser = DefinitionParser.doParse(typeP, source);
-
-        log.info(_("commandline.parser.result.info", parser.getClass().getSimpleName(), parser.getOptions().length, parser.getConfigs().length));
-
-        //TODO Do same exception handling than the OptionPArser
-
-        // show errors
-        if (showErrors) {
-            if (parser.hasFailed()) {
-                Writer writer = new StringWriter();
-                parser.printErrors(writer);
-                String lines = writer.toString();
-                for (String s : lines.split("\n")) {
-                    getLog().info(_("commandline.showErrors.info") + ' ' + s);
-                }
-                writer.flush();
-                writer.close();
-
-            } else {
-                log.info(_("commandline.showErrors.no.error.info"));
-            }
-        }
-
-        // quit if any error detected
-        if (parser.hasFailed()) {
-            throw new MojoFailureException(_("commandline.parser.parsing.error", parser, parser.getErrors().length));
-        }
-    }
-
     public void generate() throws Exception {
 
-        String optionKeySimpleName = parserSimpleName;
-        OptionContext[] optionContexts = parser.getOptions();
-        ConfigContext[] configContexts = parser.getConfigs();
+        String optionKeySimpleName = getContext().getParserSimpleName();
+
+        OptionContext[] optionContexts = getContext().getParser().getOptions();
+        ConfigContext[] configContexts = getContext().getParser().getConfigs();
 
         int pos = optionKeySimpleName.indexOf("OptionParser");
         if (pos > -1) {
@@ -275,77 +131,77 @@
         // build a dictonary of options implementations name
         for (OptionContext context : optionContexts) {
             String suffix = StringUtils.capitalize(context.getKey());
-            String optionClassName = optionSimpleName + suffix;
+            String optionClassName = getContext().getOptionSimpleName() + suffix;
             map.put(context.getKey(), optionClassName);
         }
 
         // generate specialized abstract OptionAction for this parser
         if (needSpecializedAction()) {
             AbstractOptionActionJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(),
-                    parserPackageName,
-                    contextPackageName,
-                    parserSimpleName,
-                    contextSimpleName,
-                    actionSimpleName,
-                    actionSuperClass
+                    getContext().getParserPackageName(),
+                    getContext().getContextPackageName(),
+                    getContext().getParserSimpleName(),
+                    getContext().getContextSimpleName(),
+                    getContext().getActionSimpleName(),
+                    getActionSuperClass()
             );
-            actionSuperClass = actionSimpleName;
+            setActionSuperClass(getContext().getActionSimpleName());
         }
 
-        configSimpleName = getContext().getPrefix() + (concreteConfig ? "" : "Abstract") + "Config";
+        getContext().setConfigSimpleName(getContext().getPrefix() + (getContext().isConcreteConfig() ? "" : "Abstract") + "Config");
 
         // generate specialized abstract SimpleConfigImpl for this parser
         if (needSpecializedAbstractConfig()) {
             AbstractConfigJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(),
                     configContexts,
-                    parserPackageName,
-                    contextPackageName,
-                    optionPackageName,
-                    configPackageName,
-                    parserSimpleName,
-                    contextSimpleName,
+                    getContext().getParserPackageName(),
+                    getContext().getContextPackageName(),
+                    getContext().getOptionPackageName(),
+                    getContext().getConfigPackageName(),
+                    getContext().getParserSimpleName(),
+                    getContext().getContextSimpleName(),
                     optionKeySimpleName + "<?, ?>",
-                    getContext().getPrefix() + "AbstractConfig",
-                    configSimpleName,
-                    configSuperClass
+                    getPrefix() + "AbstractConfig",
+                    getContext().getConfigSimpleName(),
+                    getConfigSuperClass()
             );
             // the super classes of generatred configs is the one generated here
-            configSuperClass = getContext().getPrefix() + "AbstractConfig";
+            setConfigSuperClass(getContext().getPrefix() + "AbstractConfig");
         }
 
         // generate specialized OptionKey for this parser
         OptionKeyJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(),
-                parserPackageName,
-                contextPackageName,
-                optionPackageName,
-                parserSimpleName,
-                contextSimpleName,
+                getContext().getParserPackageName(),
+                getContext().getContextPackageName(),
+                getContext().getOptionPackageName(),
+                getContext().getParserSimpleName(),
+                getContext().getContextSimpleName(),
                 optionKeySimpleName,
-                actionSuperClass
+                getContext().getActionSuperClass()
         );
 
         // generate OptionParser implementation
         OptionParserJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(),
                 optionContexts,
-                parserPackageName,
-                parserSimpleName,
+                getContext().getParserPackageName(),
+                getContext().getParserSimpleName(),
                 optionKeySimpleName,
-                optionPackageName,
-                optionSimpleName,
-                actionPackageName,
-                actionSimpleName,
-                parserSuperClass
+                getContext().getOptionPackageName(),
+                getContext().getOptionSimpleName(),
+                getContext().getActionPackageName(),
+                getContext().getActionSimpleName(),
+                getContext().getParserSuperClass()
         );
 
 
         AbstractContextJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(),
                 configContexts,
-                parserPackageName,
-                configPackageName,
-                parserSimpleName,
-                configSimpleName,
-                contextSimpleName,
-                contextSuperClass
+                getContext().getParserPackageName(),
+                getContext().getConfigPackageName(),
+                getContext().getParserSimpleName(),
+                getContext().getConfigSimpleName(),
+                getContext().getContextSimpleName(),
+                getContext().getContextSuperClass()
         );
 
         // generate Config implementations
@@ -353,21 +209,21 @@
             String suffix = StringUtils.capitalize(context.getCategory());
             ConfigJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(),
                     context,
-                    parserPackageName,
-                    configPackageName,
-                    configSimpleName + suffix,
-                    parserSimpleName,
-                    configSuperClass,
-                    concreteConfig
+                    getContext().getParserPackageName(),
+                    getContext().getConfigPackageName(),
+                    getContext().getConfigSimpleName() + suffix,
+                    getContext().getParserSimpleName(),
+                    getContext().getConfigSuperClass(),
+                    getContext().isConcreteConfig()
             );
         }
 
         // generate Option implementations
         for (OptionContext context : optionContexts) {
             OptionJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(), context,
-                    optionPackageName,
+                    getContext().getOptionPackageName(),
                     map.get(context.getKey()),
-                    optionSuperClass
+                    getContext().getOptionSuperClass()
             );
         }
 
@@ -376,24 +232,104 @@
             String suffix = StringUtils.capitalize(context.getKey());
             String optionClassName = map.get(context.getKey());
             OptionActionJavaGenerator.doGenerate(getContext().getOut(), timestamp, getContext().getI18nPrefix(), context,
-                    actionPackageName,
-                    actionSimpleName + suffix,
-                    actionSuperClass + "<" + optionClassName + ">",
-                    optionPackageName,
+                    getContext().getActionPackageName(),
+                    getContext().getActionSimpleName() + suffix,
+                    getContext().getActionSuperClass() + "<" + optionClassName + ">",
+                    getContext().getOptionPackageName(),
                     optionClassName,
-                    parserPackageName,
-                    parserSimpleName,
-                    contextSimpleName
+                    getContext().getParserPackageName(),
+                    getContext().getParserSimpleName(),
+                    getContext().getContextSimpleName()
             );
         }
         map.clear();
     }
 
+    public File getOut() {
+        return out;
+    }
+
     private boolean needSpecializedAction() {
-        return actionSuperClass.equals(OptionAction.class.getName());
+        return getContext().getActionSuperClass().equals(OptionAction.class.getName());
     }
 
     private boolean needSpecializedAbstractConfig() {
-        return configSuperClass.equals(Config.class.getName());
+        return getContext().getConfigSuperClass().equals(Config.class.getName());
+    }
+
+    public String getActionSuperClass() {
+        return actionSuperClass;
+    }
+
+    public boolean isConcreteConfig() {
+        return concreteConfig;
+    }
+
+    public String getConfigSuperClass() {
+        return configSuperClass;
+    }
+
+    public String getContextSuperClass() {
+        return contextSuperClass;
+    }
+
+    public String getOptionSuperClass() {
+        return optionSuperClass;
+    }
+
+    public String getParserSuperClass() {
+        return parserSuperClass;
+    }
+
+    public boolean isShowErrors() {
+        return showErrors;
+    }
+
+    public File getSource() {
+        return source;
+    }
+
+    public String getTypeSource() {
+        return typeSource;
+    }
+
+    public void setConfigSuperClass(String configSuperClass) {
+        this.configSuperClass = configSuperClass;
+    }
+
+    public void setActionSuperClass(String actionSuperClass) {
+        this.actionSuperClass = actionSuperClass;
+    }
+
+    public void setShowErrors(boolean showErrors) {
+        this.showErrors = showErrors;
+    }
+
+    public void setConcreteConfig(boolean concreteConfig) {
+        this.concreteConfig = concreteConfig;
+    }
+
+    public void setContextSuperClass(String contextSuperClass) {
+        this.contextSuperClass = contextSuperClass;
+    }
+
+    public void setOptionSuperClass(String optionSuperClass) {
+        this.optionSuperClass = optionSuperClass;
+    }
+
+    public void setParserSuperClass(String parserSuperClass) {
+        this.parserSuperClass = parserSuperClass;
+    }
+
+    public void setSource(File source) {
+        this.source = source;
+    }
+
+    public void setTypeSource(String typeSource) {
+        this.typeSource = typeSource;
+    }
+
+    public void setOut(File out) {
+        this.out=out;
     }
 }
\ No newline at end of file