Added additional help screen for patterns.

Author: SecretDeveloper

README.md

@@ -1,4 +1,4 @@
-<#{"seed":1}#>
+
 
 # ![TestDataGenerator](https://raw.githubusercontent.com/SecretDeveloper/TestDataGenerator/master/icon.png) TestDataGenerator
 A library and command line tool that can be used to generate data for testing, templating and other uses.  You provide it with a pattern containing symbols defining the output you want to produce and it will create random data to match that pattern.
@@ -45,50 +45,50 @@ The following symbols are shorthand tokens which you can use in your generation
 ### Groups
 Groups can contain multiple Symbols or characters and allows us to treat them as a single unit.  Their usage becomes apparent when using them with *repetitions* or *alternations*.  Groups are surrounded in () brackets.
 #### Simple Groups
-- `(\d)` - A number between 0 and 9 e.g. '8'
-- `(ABC\d)` - 'ABC' followed by a number between 0 and 9 e.g. ABC7
-- `\L(\d)\L` - A upper-case letter, three digits between 0 and 9 and another upper-case letter e.g. H2O
+- `(\d)` - A number between 0 and 9 e.g. '2'
+- `(ABC\d)` - 'ABC' followed by a number between 0 and 9 e.g. ABC1
+- `\L(\d)\L` - A upper-case letter, three digits between 0 and 9 and another upper-case letter e.g. M7R
 
 #### Alternations
 When a group contains alternations the patterns are divided by the | character, during processing one of the alternated patterns is selected at random. 
 Groups can contain several individual symbols or groups of symbols and randomly alternate between them when generating the output value.
 
 **Alternatives must be contained within a Group**
-- `(\L\L|\d\d)` - Either two upper-case letters OR two numbers e.g. 'RX'
-- `(\L\L|\d\d|[AEIOU]|[100-120])` - Either two upper-case letters OR two digits OR an upper-case vowel OR a number between 100 and 120 e.g. 'U'
+- `(\L\L|\d\d)` - Either two upper-case letters OR two numbers e.g. 'JY'
+- `(\L\L|\d\d|[AEIOU]|[100-120])` - Either two upper-case letters OR two digits OR an upper-case vowel OR a number between 100 and 120 e.g. 'QA'
 - `(\C|)` - Either a upper-case Consonant or nothing.
 
 ### Ranges
 Ranges can contain multiple characters or ranges of characters but no symbols (the items defined within the range will be what is used, no special symbols are allowed).  The item to be produced is selected at random.
 #### Character ranges
-- `[abc]` - Either 'a','b' or 'c' e.g. 'b'
-- `[a-z]` - A single lower-case letter between a and z e.g. 'v'
-- `[A-Z]` - A single upper-case letter between A and Z e.g. 'D'
-- `[A-D]` - A single upper-case letter between A and D e.g. 'D'
-- `[A-Da-z]` - A single character between A and D or between a and z e.g. 'n'
+- `[abc]` - Either 'a','b' or 'c' e.g. 'a'
+- `[a-z]` - A single lower-case letter between a and z e.g. 'z'
+- `[A-Z]` - A single upper-case letter between A and Z e.g. 'R'
+- `[A-D]` - A single upper-case letter between A and D e.g. 'C'
+- `[A-Da-z]` - A single character between A and D or between a and z e.g. 's'
 
 #### Numeric ranges
-- `[1-5]` - A number between 1 and 5 e.g. '3'
-- `[100-500]` - A number between 100 and 500 e.g. '161'
-- `[1.25-5]` - A decimal number between 1.25 and 5. The scope or number of decimal places is taken from the first number defined (1.25 in this case) and the produced value will have the same number of decimal places. e.g. '3.39'
+- `[1-5]` - A number between 1 and 5 e.g. '1'
+- `[100-500]` - A number between 100 and 500 e.g. '253'
+- `[1.25-5]` - A decimal number between 1.25 and 5. The scope or number of decimal places is taken from the first number defined (1.25 in this case) and the produced value will have the same number of decimal places. e.g. '1.89'
 
 ### Named Parameters
 A named pattern is surrounded with @ characters and links to a predefined pattern loaded from a file. The `default.tdg-patterns` file located in the same directory as the tdg executable file contains a list of named patterns which can be used in other patterns you write.  For example to generate you could write something like `([1-9]\d\d-\d\d-\d\d\d\d)` or you can use the named parameter in the file `(@misc_ssn@)` to a similar value.  You can add more patterns to the file as you wish.  Named patterns can also include other named patterns if you so wish.  
 
-Take a look at the `@address_us_type1@` pattern in the file as an example of a compound pattern than uses other patterns to produce an output e.g. '5376 Pleasant Lane, Stafford County, Oregon, 68443'
+Take a look at the `@address_us_type1@` pattern in the file as an example of a compound pattern than uses other patterns to produce an output e.g. '8579 Shady Lane, Howard County, Montana, 52963'
 
 ### Repetition
 Repetition is a powerful feature allowing for complicated data production. A Symbol, Group or Range can be repeated a set or random number of times by using the following syntax.
 
 #### Quantity Repetition
-- `\d{5}` - Will generate 5 number characters e.g. '74910'
-- `(\L\d\L){5}` - Will generate 5 upper-case letter, number, upper-case letter items e.g. 'Z8XA2AU8QU6QI2M'
-- `[ABC]{5}` - Will generate 5 items where each item will be either 'A','B' or 'C' e.g. 'ACCBA'
+- `\d{5}` - Will generate 5 number characters e.g. '46642'
+- `(\L\d\L){5}` - Will generate 5 upper-case letter, number, upper-case letter items e.g. 'J5EJ6KE9CZ4QB1F'
+- `[ABC]{5}` - Will generate 5 items where each item will be either 'A','B' or 'C' e.g. 'AABAC'
 
 #### Random Quantity
-- `\d{5,10}` - Will generate between 5 and 10 number characters e.g. '39296896'
-- `(\L\d\L){5,10}` - Will generate  between 5 and 10 upper-case letter, number, upper-case letter items e.g. 'A5UQ4QI1NB8YE4AZ5GA0B'
-- `[ABC]{5,10}` - Will generate  between 5 and 10 items where each item will be either 'A','B' or 'C' e.g. 'BCBCCCAB'
+- `\d{5,10}` - Will generate between 5 and 10 number characters e.g. '7211494791'
+- `(\L\d\L){5,10}` - Will generate  between 5 and 10 upper-case letter, number, upper-case letter items e.g. 'I0MJ3JA6VW7CA8FW4HD1J'
+- `[ABC]{5,10}` - Will generate  between 5 and 10 items where each item will be either 'A','B' or 'C' e.g. 'BBAAAAB'
 
 
 ## Template Syntax
@@ -98,7 +98,7 @@ You can create template documents that contain multiple pattern syntax placehold
 
 ### Placeholders
 You can place your symbols and patterns within placeholders which will be replaced with the generated values.  These placeholders contain 1 or more symbols representing the desired output characters.  
-Within a template all text not within a placeholder is treated as normal text with no special handling taking place.  Patterns that need to be randomly generated should be placed inside '<< >>' tokens e.g. 'This is a template <<\L\L>>'  produces 'This is a template DW'. You can also escape placeholders by placing a '\' before them which will prevent them from being processed.  To place a '\' before a placeholder in the generated content you need to place 2 backslashes before the placeholder. 
+Within a template all text not within a placeholder is treated as normal text with no special handling taking place.  Patterns that need to be randomly generated should be placed inside '<< >>' tokens e.g. 'This is a template <<\L\L>>'  produces 'This is a template TE'. You can also escape placeholders by placing a '\' before them which will prevent them from being processed.  To place a '\' before a placeholder in the generated content you need to place 2 backslashes before the placeholder. 
 
 ### Configuration
 You can supply configuration values to the generator either as an additional parameter within the api or you can include it within the template string itself by wrapping it within '<# #>' tokens.  Configuration directives must appear as the first item with a template or else they will be ignored and removed.
@@ -134,23 +134,23 @@ Pattern files contain Named Patterns which can be used within Templates. TDG com
 ### Commandline examples
 - Single repeating symbols using the following syntax
   - `tdg -t 'Letters <<\L{20}>> and Numbers <<\d{12}>>'`
-  - Produces items like *'Letters EGTCWRTVAOIIGRDMEACQ and Numbers 963398177619'*.
+  - Produces items like *'Letters DWZIZQWSYOREAADBHFCY and Numbers 489186903271'*.
 - Repeating patterns containing multiple letters or numbers of random length.
-  - `tdg -t '<<(\L){5}>>'` - Will generate 5 random upper-case characters. e.g. *'YBTXR'*
-  - `tdg -t '<<(\L\L\d){24}>>'`  - Will generate 24 repeating letter-letter-number values e.g. *'YC8NE0MI2RV5LN9LN9OY3CA4YC3KJ4FX2UG9FC7OV0TD3HH1EN4CF9IV0KO0QC9VM9HR2BF4'*
+  - `tdg -t '<<(\L){5}>>'` - Will generate 5 random upper-case characters. e.g. *'CRQGA'*
+  - `tdg -t '<<(\L\L\d){24}>>'`  - Will generate 24 repeating letter-letter-number values e.g. *'OG2QP1PR3JN1ZW0JV7IW8MH7UJ7UN0IK8BS9WH8QK4NI3WI3RV2ZI3EC9MV2LU1GA1HY1CM5'*
 - Variable length data can be generated also
-  - `tdg -t '<<(\L){10,20}>>'` - Will generate a string containing between 10 and 20 characters of random value e.g. *'ZDHJWERVHFWZ'*
-  - `tdg -t 'Letters <<\L{2,20}>> and Numbers <<\d{2,12}>>'` produces items like *'Letters SHLL and Numbers 85697196496'*
+  - `tdg -t '<<(\L){10,20}>>'` - Will generate a string containing between 10 and 20 characters of random value e.g. *'RLLYYJXBKCRVJBNXQAJ'*
+  - `tdg -t 'Letters <<\L{2,20}>> and Numbers <<\d{2,12}>>'` produces items like *'Letters QFQGHIFPJEP and Numbers 71697'*
 - Input can contain several placeholders.
   - `tdg -t 'Hi there <<\L\v{0,2}\l{0,2}\v \L\v{0,2}\l{0,2}\v{0,2}\l{0,2}\l>> how are you doing?  Your SSN is <<[1-9]\d\d-\d\d-\d\d\d\d>>.' -c 100` 
-  - Produces 100 items like *'Hi there Va Xamw how are you doing?  Your SSN is 480-83-2018.'*
+  - Produces 100 items like *'Hi there Eu Emkabnc how are you doing?  Your SSN is 114-81-6613.'*
 - Generate 100 SSN like values and output to console window.
   - `tdg -t '<<[1-9]\d\d-\d\d-\d\d\d\d>>' -c 100`
-  - Produces 100 items like *'485-03-1427'*.
+  - Produces 100 items like *'353-02-4514'*.
 - Generate 100 strings with random name like values and output to file.
   - `tdg -t 'Hi there <<\L\v\l\v \L\v\l\l\v\v\l\l\v>> how are you doing?' -c 100 -o C:\test1.txt`
-  - Produces 100 items like *'Sala Nufniizqi'*.
-- `tdg -t '<<Letters \w{2,20} and Numbers \d{2,12}\n>>'` produces the following output: *'Letters xI3bgtn9Bb37lui and Numbers 800410
+  - Produces 100 items like *'Aepi Euuwoavio'*.
+- `tdg -t '<<Letters \w{2,20} and Numbers \d{2,12}\n>>'` produces the following output: *'Letters nR9mhIGy_KE and Numbers 1134618008
 '*
 
 ## This README was generated using the generator.  See the unit tests for other examples.

releases/TestDataGenerator_V3.4.2.0.zip

@@ -1,5 +1,7 @@
 using System;
 using System.Reflection;
+using System.Security.Policy;
+using System.Text;
 using CommandLine;
 using CommandLine.Text;
 
@@ -13,6 +15,9 @@ internal class CommandLineArgs
         [Option('p', "pattern", DefaultValue = "", HelpText = "The pattern to use when producing data.", MutuallyExclusiveSet = "fromCL")]
         public string Pattern { get; set; }
 
+        [Option('d', "detailed", DefaultValue = false, HelpText = "Show help text for pattern symbols")]
+        public bool ShowPatternHelp { get; set; }
+
         [Option('i', "inputfile", DefaultValue = "", HelpText = "The path of the input file.", Required = false, MutuallyExclusiveSet = "fromFile")]
         public string InputFilePath { get; set; }
 
@@ -57,6 +62,7 @@ public string GetUsage()
             };
             help.AddPreOptionsLine("This is free software. You may redistribute copies of it under the terms of the MIT License.");
             help.AddPreOptionsLine(" <http://www.opensource.org/licenses/mit-license.php>");
+            help.AddPreOptionsLine("Commandline Arguments:");
 
             help.AddPostOptionsLine("Examples:");
             help.AddPostOptionsLine("\t tdg -t '<<LL>>'");
@@ -69,6 +75,45 @@ public string GetUsage()
             return help;
         }
 
+        public string GetPatternUsage()
+        {
+            var sb = new StringBuilder();
+
+            sb.AppendLine("Detailed Pattern Usage");
+            sb.AppendLine();
+
+            sb.AppendLine("The following symbols can be used within a pattern to produce the desired output.");
+            sb.AppendLine("\t\\. - A single random character of any type.");
+            sb.AppendLine("\t\\W - A single random character from the following list ' .,;:'\"!&?£€$%^<>{}*+-=\\@#|~/'.");
+            sb.AppendLine("\t\\w - A single random upper-case or lower-case letter.");
+            sb.AppendLine("\t\\L - A single random upper-case Letter.");
+            sb.AppendLine("\t\\l - A single random lower-case letter.");
+            sb.AppendLine("\t\\V - A single random upper-case Vowel.");
+            sb.AppendLine("\t\\v - A single random lower-case vowel.");
+            sb.AppendLine("\t\\C - A single random upper-case Consonant.");
+            sb.AppendLine("\t\\c - A single random lower-case consonant.");
+            sb.AppendLine("\t\\D - A single random non number character.");
+            sb.AppendLine("\t\\d - A single random number, 1-9.");
+            sb.AppendLine("\t\\S - A single random non-whitespace character.");
+            sb.AppendLine("\t\\s - A whitespace character (Tab, New Line, Space, Carriage Return or Form Feed)");
+            sb.AppendLine("\t\\n - A newline character.");
+            sb.AppendLine("\t\\t - A tab character.");
+            
+            sb.AppendLine("Patterns usage");
+            sb.AppendLine("\ttdg -p '(\\L)' - Will generate a random upper-case character.");
+            sb.AppendLine("\ttdg -p '(\\L){5}' - Will generate 5 random upper-case characters.");
+            sb.AppendLine("\ttdg -p '(\\L){10,20}' - Will generate between 10 and 20 random upper-case characters.");
+            
+            sb.AppendLine("Patterns and normal text can be combined in templates");
+            sb.AppendLine("Template usage");
+            sb.AppendLine("\ttdg -t '<<Text containing a (\\L) pattern>>'");
+            sb.AppendLine("\ttdg -t '<<Text containing a (\\L){5} pattern>>'");
+            sb.AppendLine("\ttdg -t '<<Text containing a (\\L){10,20} pattern>>'");
+            sb.AppendLine("View the Readme document for further examples");
+
+            return sb.ToString();
+        }
+
     }
 }
 

releases/tdg.3.4.2.0.nupkg

@@ -27,6 +27,12 @@ private static void Main(string[] args)
                     Console.WriteLine("Parse failed!  Use --help flag for instructions on usage.");
                     return;
                 }
+
+                if (cla.ShowPatternHelp)
+                {
+                    Console.Write(cla.GetPatternUsage());
+                    return;
+                }
 
                 if (cla.Verbose)
                 {
@@ -142,10 +148,19 @@ private static void OutputToFile(CommandLineArgs cla, string template)
                 generateFrom = AlphaNumericGenerator.GenerateFromPattern;
             }
 
-            GenerationConfig config = new GenerationConfig();
+            GenerationConfig config = null;
             if(cla.Seed.HasValue || !cla.NamedPatterns.IsNullOrEmpty()){
-                if (cla.Seed.HasValue) config.Seed = cla.Seed;
-                if (!cla.NamedPatterns.IsNullOrEmpty()) cla.NamedPatterns.Split(';').ToList().ForEach(config.PatternFiles.Add);
+                
+                if (cla.Seed.HasValue)
+                {
+                    if (config == null) config = new GenerationConfig();
+                    config.Seed = cla.Seed;
+                }
+                if (!cla.NamedPatterns.IsNullOrEmpty())
+                {
+                    if (config == null) config = new GenerationConfig();
+                    cla.NamedPatterns.Split(';').ToList().ForEach(config.PatternFiles.Add);
+                }
             }
 
             using (var fs = new StreamWriter(cla.OutputFilePath))