Index: lutincommandline/src/java/org/codelutin/option/def/DefinitionParserUtil.java
diff -u lutincommandline/src/java/org/codelutin/option/def/DefinitionParserUtil.java:1.1.1.1 lutincommandline/src/java/org/codelutin/option/def/DefinitionParserUtil.java:1.2
--- lutincommandline/src/java/org/codelutin/option/def/DefinitionParserUtil.java:1.1.1.1	Sat Feb  9 15:05:36 2008
+++ lutincommandline/src/java/org/codelutin/option/def/DefinitionParserUtil.java	Sun Mar 16 03:49:49 2008
@@ -42,6 +42,10 @@
 
     public static final Character[] OPENING_CHARS = {'(', '{', '[', '<'};
     public static final Character[] CLOSING_CHARS = {')', '}', ']', '>'};
+    
+    final static String ODEFINITION_KEY_SUFFIX = ".option.definition";
+    final static String CDEFINITION_KEY_FACTOR = ".config.definition.";
+    final static String CMODIFIERS_KEY_FACTOR = ".config.modifiers.";
 
     /**
      * permet de définir le type de source pour lire les définitions à analyser.
@@ -131,6 +135,15 @@
         }
     }
 
+    static class OptionDefEntry extends AbstractMap.SimpleEntry<String, String> {
+        private static final long serialVersionUID = -5430904379928407190L;
+        String def;
+        String mods;        
+        public OptionDefEntry(String key, String value) {
+            super(key, value);
+        }
+    }
+
     /**
      * This class defines an abstract Walker on
      * {@link org.codelutin.option.def.DefinitionParser} contexts.

Index: lutincommandline/src/java/org/codelutin/option/def/DefinitionParserFromProperties.java
diff -u lutincommandline/src/java/org/codelutin/option/def/DefinitionParserFromProperties.java:1.2 lutincommandline/src/java/org/codelutin/option/def/DefinitionParserFromProperties.java:1.3
--- lutincommandline/src/java/org/codelutin/option/def/DefinitionParserFromProperties.java:1.2	Sat Mar 15 22:05:49 2008
+++ lutincommandline/src/java/org/codelutin/option/def/DefinitionParserFromProperties.java	Sun Mar 16 03:49:50 2008
@@ -43,11 +43,8 @@
  */
 public class DefinitionParserFromProperties extends DefinitionParser {
 
-    final static String ODEFINITION_KEY_SUFFIX = ".option.definition";
-    final static String CDEFINITION_KEY_FACTOR = ".config.definition.";
-    final static String CMODIFIERS_KEY_FACTOR = ".config.modifiers.";
-    final static int CDEFINITION_KEY_FACTOR_LENGTH = CDEFINITION_KEY_FACTOR.length();
-    final static int ODEFINITION_KEY_PREFIX_LENGTH = ODEFINITION_KEY_SUFFIX.length();
+    final static int CDEFINITION_KEY_FACTOR_LENGTH = DefinitionParserUtil.CDEFINITION_KEY_FACTOR.length();
+    final static int ODEFINITION_KEY_PREFIX_LENGTH = DefinitionParserUtil.ODEFINITION_KEY_SUFFIX.length();
 
     /**
      * Initialise un contexte de parseur à partir d'un fichier de propriétés.
@@ -75,19 +72,114 @@
         }
 
         // récupération des clefs d'options
-        List<String> okeys = new ArrayList<String>();
-        List<String> categories = new ArrayList<String>();
-        Map<String, List<ConfigDefEntry>> cdefinitions = new HashMap<String, List<ConfigDefEntry>>();
-        Map<String, List<ConfigDefEntry>> cmodifiers = new HashMap<String, List<ConfigDefEntry>>();
+        List<String> categories;
+        Map<String, List<ConfigDefEntry>> cdefinitions;
+        Map<String, List<ConfigDefEntry>> cmodifiers;
+
+        detectConfigs(properties,
+                categories = new ArrayList<String>(),
+                cdefinitions = new HashMap<String, List<ConfigDefEntry>>(),
+                cmodifiers = new HashMap<String, List<ConfigDefEntry>>()
+        );
+
+        List<String> okeys;
+        List<String> odefinitions;
+
+        detectOptions(properties, categories,
+                odefinitions = new ArrayList<String>(),
+                okeys = new ArrayList<String>()
+        );
+
+        ParserContext context = new ParserContext();
+
+        // construction du context de parsing des options
+        OptionsContext options = new OptionsContext(
+                context,
+                okeys.toArray(new String[okeys.size()]),
+                odefinitions.toArray(new String[okeys.size()])
+        );
+
+        // construction du context de parsing des configs
+        ConfigsContext configs = new ConfigsContext(
+                context,
+                categories.toArray(new String[categories.size()]),
+                cdefinitions,
+                cmodifiers);
+
+        context.setOptions(options);
+        context.setConfigs(configs);
+
+        okeys.clear();
+        categories.clear();
+        odefinitions.clear();
+        properties.clear();
+        return context;
+    }
+
+    private void detectOptions(Properties properties, List<String> categories, List<String> odefinitions, List<String> okeys) {
+        Map<String, String> optionDefs = new HashMap<String, String>();
+
+        String categoriesStr = "";
+        if (!categories.isEmpty()) {
+            StringBuilder sb = new StringBuilder();
+            for (String category : categories) {
+                sb.append('|').append(category);
+            }
+            categoriesStr = sb.substring(1);
+
+        }
+        List<String> defaultOptions = DefaultOption.getConfigKeys();
         for (Object o : properties.keySet()) {
-            String key = o.toString();
-            if (key.endsWith(ODEFINITION_KEY_SUFFIX)) {
-                String s = key.substring(0, key.length() - ODEFINITION_KEY_PREFIX_LENGTH);
-                okeys.add(s);
+            String fullKey = o.toString();
+            if (!fullKey.endsWith(DefinitionParserUtil.ODEFINITION_KEY_SUFFIX)) {
                 continue;
             }
-            if (key.contains(CDEFINITION_KEY_FACTOR)) {
-                int pos = key.indexOf(CDEFINITION_KEY_FACTOR);
+            String key = fullKey.substring(0, fullKey.length() - ODEFINITION_KEY_PREFIX_LENGTH);
+            String realDef = properties.getProperty(fullKey);
+            if (defaultOptions.contains(fullKey)) {
+                // do not add this, this is a generated option
+                log.warn("generic option " + key + " used instead of customize one, you should delete this option from your configuration...");
+                // use default definition
+                realDef = DefaultOption.valueOf(key).def();
+                defaultOptions.remove(fullKey);
+            }
+            optionDefs.put(fullKey, realDef);
+        }
+
+        // add default options not already found
+        for (String optionKey : defaultOptions) {
+            // get defaultOption
+            for (DefaultOption option : DefaultOption.values()) {
+                if (option.configKey().equals(optionKey)) {
+                    optionDefs.put(optionKey, option.def());
+                }
+            }
+        }
+
+        List<String> keys = new ArrayList<String>(optionDefs.keySet());
+
+        // on trie les clefs d'options une seule fois
+        // ensuite on travaille sur cet ordre établi.
+        Collections.sort(keys);
+
+        // récupérations des définitions d'options
+        for (String optionKey : keys) {
+            String realDef = optionDefs.get(optionKey);
+            realDef = realDef.replace("@categories@", categoriesStr);
+            String key = optionKey.substring(0,optionKey.length()-ODEFINITION_KEY_PREFIX_LENGTH);
+            if (log.isDebugEnabled()) {
+                log.debug("new option " + key + " : " + realDef);
+            }
+            okeys.add(key);
+            odefinitions.add(realDef);
+        }
+    }
+
+    protected void detectConfigs(Properties properties, List<String> categories, Map<String, List<ConfigDefEntry>> cdefinitions, Map<String, List<ConfigDefEntry>> cmodifiers) {
+        for (Object o : properties.keySet()) {
+            String key = o.toString();
+            if (key.contains(DefinitionParserUtil.CDEFINITION_KEY_FACTOR)) {
+                int pos = key.indexOf(DefinitionParserUtil.CDEFINITION_KEY_FACTOR);
                 String cat = key.substring(0, pos);
                 String ckey = key.substring(pos + CDEFINITION_KEY_FACTOR_LENGTH);
                 List<ConfigDefEntry> defs, mods;
@@ -103,7 +195,7 @@
                 String def = properties.getProperty(key);
                 ConfigDefEntry cdef = new ConfigDefEntry(ckey, def);
                 defs.add(cdef);
-                String mod = properties.getProperty(cat + CMODIFIERS_KEY_FACTOR + ckey);
+                String mod = properties.getProperty(cat + DefinitionParserUtil.CMODIFIERS_KEY_FACTOR + ckey);
                 if (mod != null && !"".equals(mod)) {
                     // only save modifiers if we found one
                     ConfigDefEntry cmod = new ConfigDefEntry(ckey, mod);
@@ -112,43 +204,10 @@
             }
         }
 
-        // on trie les clefs d'options une seule fois
-        // ensuite on travaille sur cet ordre établi.
-        Collections.sort(okeys);
-
         // on trie les catégories une seule fois
         // ensuite on travaille sur cet ordre établi.
         Collections.sort(categories);
+    }
 
-        List<String> odefinitions = new ArrayList<String>();
-        // récupérations des définitions d'options
-        for (String optionKey : okeys) {
-            odefinitions.add(properties.getProperty(optionKey + ODEFINITION_KEY_SUFFIX));
-        }
-
-        ParserContext context = new ParserContext();
-
-        // construction du context de parsing des options
-        OptionsContext options = new OptionsContext(
-                context,
-                okeys.toArray(new String[okeys.size()]),
-                odefinitions.toArray(new String[okeys.size()])
-        );
-
-        // construction du context de parsing des configs
-        ConfigsContext configs = new ConfigsContext(
-                context,
-                categories.toArray(new String[categories.size()]),
-                cdefinitions,
-                cmodifiers);
-
-        context.setOptions(options);
-        context.setConfigs(configs);
 
-        okeys.clear();
-        categories.clear();
-        odefinitions.clear();
-        properties.clear();
-        return context;
-    }
 }

Index: lutincommandline/src/java/org/codelutin/option/def/DefinitionParser.java
diff -u lutincommandline/src/java/org/codelutin/option/def/DefinitionParser.java:1.1.1.1 lutincommandline/src/java/org/codelutin/option/def/DefinitionParser.java:1.2
--- lutincommandline/src/java/org/codelutin/option/def/DefinitionParser.java:1.1.1.1	Sat Feb  9 15:05:37 2008
+++ lutincommandline/src/java/org/codelutin/option/def/DefinitionParser.java	Sun Mar 16 03:49:50 2008
@@ -24,10 +24,15 @@
 import static org.codelutin.option.def.DefinitionParserContexts.OptionContext;
 import static org.codelutin.option.def.DefinitionParserContexts.ParserContext;
 import static org.codelutin.option.def.DefinitionParserUtil.TypeSource;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 
 import java.io.IOException;
 import java.io.Writer;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
+import java.util.Collections;
 
 /**
  * Parseur de définitions. TODO Revoir javadoc non correcte
@@ -46,6 +51,83 @@
 
 public abstract class DefinitionParser {
 
+    protected static final Log log = LogFactory.getLog(DefinitionParser.class);
+    
+    /**
+     * les options gérées par commandline (config, help, usage...).
+     * <p/>
+     * Ces options seront générés par le plugin commandline car sont génériques.
+     *
+     * @author chemit
+     */
+    public enum DefaultOption {
+
+        showConfig("--show-config * [@categories@] [normal|all|tec]"),
+        editConfig("--edit-config"),
+        changeFileConfig("--config-file <configFile:File>"),
+        changeConfig("--config * [@categories@] <key:String> <value:String>"),
+        help("--help|-h"),
+        resetConfig("--reset-config"),
+        ui("--ui <flag:Boolean>");
+
+        private final String def;
+
+        protected static boolean skipDefault=false;
+
+        private DefaultOption(String def) {
+            this.def = def;
+        }
+
+        public String def() {
+            return def;
+        }
+
+        public String configKey() {
+            return name() + DefinitionParserUtil.ODEFINITION_KEY_SUFFIX;
+        }
+
+        public static List<String> getConfigKeys() {
+            List<String> defaultOptions = new ArrayList<String>();
+            if (!skipDefault) {
+                for (DefaultOption option : DefaultOption.values()) {
+                    defaultOptions.add(option.configKey());
+                }
+                Collections.sort(defaultOptions);
+            }
+            return defaultOptions;
+        }
+    }
+
+    /**
+     * les propriétés de configuration obligatoires.
+     *
+     * @author chemit
+     */
+    public enum MandatoryConfigProperty {
+        configFileName("main", "java.io.File"),
+        version("main", "org.codelutin.util.VersionNumber");
+
+        private final String category;
+        private final String type;
+
+        MandatoryConfigProperty(String type, String category) {
+            this.type = type;
+            this.category = category;
+        }
+
+        public String category() {
+            return category;
+        }
+
+        public String type() {
+            return type;
+        }
+
+        public String getEntryKey() {
+            return category() + '.' + DefinitionParserUtil.CDEFINITION_KEY_FACTOR + name();
+        }
+    }
+
     /**
      * Initialise le parser avec son context remplit avec les données de la source.
      *