├── .github
    ├── FUNDING.yml
    └── workflows
    │   └── dotnet.yml
├── images
    ├── icon.png
    └── icon.cs
├── doc
    ├── linqpad-samples
    │   ├── FileOrder.txt
    │   ├── Diagnostic tools.linq
    │   ├── Quick start.linq
    │   ├── Nested types.linq
    │   └── Using record types.linq
    └── spec.md
├── RegExtract.Test
    ├── Usage.a008.verified.txt
    ├── Usage.a007.verified.txt
    ├── Usage.a002.verified.txt
    ├── Usage.a006.verified.txt
    ├── Usage.a013.verified.txt
    ├── Usage.a001.verified.txt
    ├── Usage.a004.verified.txt
    ├── Usage.a012.verified.txt
    ├── Usage.a009.verified.txt
    ├── Usage.a010.verified.txt
    ├── Usage.a005.verified.txt
    ├── Usage.a011.verified.txt
    ├── Usage.a003.verified.txt
    ├── VerifyShim.cs
    ├── RegExtract.Test.csproj
    └── Usage.cs
├── LICENSE
├── RegExtract.sln
├── tools
    └── ExtractionPlanInspector.linq
├── RegExtract
    ├── RegExtractExtensions.cs
    ├── RegExtract.csproj
    ├── ExtractionPlanTypeWrapper.cs
    ├── ExtractionPlan.cs
    ├── ExtractionPlanNodeTypes.cs
    ├── ExtractionPlanNode.cs
    └── RegexCaptureGroupTree.cs
├── .gitignore
└── README.md


/.github/FUNDING.yml:
--------------------------------------------------------------------------------
1 | ko_fi: sblom
2 | 


--------------------------------------------------------------------------------
/images/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/sblom/RegExtract/HEAD/images/icon.png


--------------------------------------------------------------------------------
/doc/linqpad-samples/FileOrder.txt:
--------------------------------------------------------------------------------
1 | Quick start.linq
2 | Nested types.linq
3 | Using record types.linq
4 | Diagnostic tools.linq


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a008.verified.txt:
--------------------------------------------------------------------------------
1 | CollectionInitializer<List<int>>[1] (
2 | 	StaticParseMethod<int>[1] ()
3 | )
4 | 
5 | ↓-------↓₀
6 | (\d+ ?)+₁ 
7 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a007.verified.txt:
--------------------------------------------------------------------------------
1 | CollectionInitializer<List<int>>[1] (
2 | 	StaticParseMethod<int>[1] ()
3 | )
4 | 
5 | (?:↓----↓ ?)+₀
6 |    (\d+)₁     
7 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a002.verified.txt:
--------------------------------------------------------------------------------
1 | CollectionInitializer<List<int>>[1] (
2 | 	StaticParseMethod<int>[2] ()
3 | )
4 | 
5 | ↓----------↓₀
6 | (↓----↓ ?)+₁ 
7 |  (\d+)₂      
8 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a006.verified.txt:
--------------------------------------------------------------------------------
1 | CollectionInitializer<List<int>>[1] (
2 | 	StaticParseMethod<int>[2] ()
3 | )
4 | 
5 | ↓----------↓₀
6 | (↓----↓ ?)+₁ 
7 |  (\d+)₂      
8 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a013.verified.txt:
--------------------------------------------------------------------------------
1 | Constructor<triple>[0] (
2 | 	StaticParseMethod<int>[1] (),
3 | 	StaticParseMethod<int>[2] (),
4 | 	StaticParseMethod<int>[3] ()
5 | )
6 | 
7 | ↓----↓ ↓----↓ ↓----↓₀
8 | (\d+)₁ (\d+)₂ (\d+)₃ 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a001.verified.txt:
--------------------------------------------------------------------------------
 1 | CollectionInitializer<List<(char,char)>>[1] (
 2 | 	ConstructTuple<(char,char)>[1] (
 3 | 		StaticParseMethod<char>[2] (),
 4 | 		StaticParseMethod<char>[3] ()
 5 | 	)
 6 | )
 7 | 
 8 | ↓------------↓₀
 9 | (↓---↓↓---↓)+₁ 
10 |  (\w)₂(\w)₃    
11 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a004.verified.txt:
--------------------------------------------------------------------------------
 1 | CollectionInitializer<List<(char,int)>>[1] (
 2 | 	ConstructTuple<(char,int)>[1] (
 3 | 		StaticParseMethod<char>[2] (),
 4 | 		StaticParseMethod<int>[3] ()
 5 | 	)
 6 | )
 7 | 
 8 | ↓-------------------↓₀
 9 | (↓-----↓↓----↓,? ?)+₁ 
10 |  ([RL])₂(\d+)₃        
11 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a012.verified.txt:
--------------------------------------------------------------------------------
 1 | ConstructTuple<(string,List<Rule>)>[0] (
 2 | 	StringCast<string>[1] (),
 3 | 	CollectionInitializer<List<Rule>>[2] (
 4 | 		StaticParseMethod<Rule>[3] ()
 5 | 	)
 6 | )
 7 | 
 8 | ↓----↓{↓------------↓}₀
 9 | (\w+)₁ (↓------↓,?)+₂  
10 |         ([^,]+)₃       
11 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a009.verified.txt:
--------------------------------------------------------------------------------
 1 | CollectionInitializer<List<(string,string)>>[1] (
 2 | 	ConstructTuple<(string,string)>[1] (
 3 | 		StringCast<string>[2] (),
 4 | 		StringCast<string>[3] ()
 5 | 	)
 6 | )
 7 | 
 8 | ↓--------------------------↓₀
 9 | (↓-------↓↓-----------↓,?)+₁ 
10 |  ([a-z]+)₂([=-][0-9]?)₃      
11 | 


--------------------------------------------------------------------------------
/images/icon.cs:
--------------------------------------------------------------------------------
 1 | using System.Text.RegularExpressions;
 2 | 
 3 | 
 4 |                   (int,string)           value;
 5 | //                  ⬆      ⬆
 6 | new Regex(@"      (\d+)\s+(.*)            ");
 7 | 
 8 | 
 9 | 
10 | // Enable bold on: Comment, Keyword, Punctuation, Regex Quantifier, Regex Grouping, Regex Character Class 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a010.verified.txt:
--------------------------------------------------------------------------------
 1 | CollectionInitializer<List<List<List<char>>>>[1] (
 2 | 	CollectionInitializer<List<List<char>>>[2] (
 3 | 		CollectionInitializer<List<char>>[3] (
 4 | 			StaticParseMethod<char>[3] ()
 5 | 		)
 6 | 	)
 7 | )
 8 | 
 9 | ↓------------------↓₀
10 | (↓----------↓,? ?)+₁ 
11 |  (↓----↓ ?)+₂        
12 |   (\w)+₃             
13 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a005.verified.txt:
--------------------------------------------------------------------------------
 1 | CollectionInitializer<Dictionary<string,(string,string)>>[1] (
 2 | 	StringCast<string>[2] (),
 3 | 	ConstructTuple<(string,string)>[3] (
 4 | 		StringCast<string>[4] (),
 5 | 		StringCast<string>[5] ()
 6 | 	)
 7 | )
 8 | 
 9 | ↓------------------------------------↓₀
10 | (↓----↓ = \(↓---------------↓\);? ?)+₁ 
11 |  (...)₂     (↓----↓, ↓----↓)₃          
12 |              (...)₄  (...)₅            
13 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a011.verified.txt:
--------------------------------------------------------------------------------
 1 | ConstructTuple<((char?,string),List<string>)>[0] (
 2 | 	ConstructTuple<(char?,string)>[1] (
 3 | 		StaticParseMethod<char?>[2] (),
 4 | 		StringCast<string>[3] ()
 5 | 	),
 6 | 	CollectionInitializer<List<string>>[4] (
 7 | 		StringCast<string>[5] ()
 8 | 	)
 9 | )
10 | 
11 | ^↓------------------↓ -> ↓---------------↓$₀
12 |  (↓------↓↓-------↓)₁    (↓-------↓,? ?)+₄  
13 |   ([%&])?₂([a-z]+)₃       ([a-z]+)₅         
14 | 


--------------------------------------------------------------------------------
/doc/linqpad-samples/Diagnostic tools.linq:
--------------------------------------------------------------------------------
1 | <Query Kind="Statements">
2 |   <Reference Relative="..\..\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll">C:\src\public\RegExtract\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll</Reference>
3 |   <Namespace>RegExtract</Namespace>
4 | </Query>
5 | 
6 | var plan = ExtractionPlan<((int x, int y), char ch, string pwd)>.CreatePlan(new Regex(@"((\d+)-(\d+)) (.): (.*)"));
7 | var diagnostics = plan.ToString("x");
8 | 
9 | Util.WithStyle(diagnostics, "font-family:consolas").DumpFixed();


--------------------------------------------------------------------------------
/doc/linqpad-samples/Quick start.linq:
--------------------------------------------------------------------------------
 1 | <Query Kind="Statements">
 2 |   <Reference Relative="..\..\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll">C:\src\public\RegExtract\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll</Reference>
 3 |   <Namespace>RegExtract</Namespace>
 4 | </Query>
 5 | 
 6 | "Hello, world!"
 7 |     .Extract<string>(@"Hello, (\w+)!")
 8 |     .Dump("Simple extraction");
 9 | 
10 | "Party like it's 1999!"
11 |     .Extract<(string verb, int year)>(@"(\w+) like it's (\d+)!")
12 |     .Dump("Extract multiple captures");
13 | 


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.a003.verified.txt:
--------------------------------------------------------------------------------
 1 | Constructor<game>[0] (
 2 | 	StaticParseMethod<int>[1] (),
 3 | 	CollectionInitializer<List<draw>>[2] (
 4 | 		Constructor<draw>[2] (
 5 | 			CollectionInitializer<List<(int,string)>>[3] (
 6 | 				ConstructTuple<(int,string)>[3] (
 7 | 					StaticParseMethod<int>[4] (),
 8 | 					StringCast<string>[5] ()
 9 | 				)
10 | 			)
11 | 		)
12 | 	)
13 | )
14 | 
15 | Game ↓----↓: ↓---------------------------↓₀
16 |      (\d+)₁  (↓-------------------↓;? ?)+₂ 
17 |               (↓----↓ ↓----↓,? ?)+₃        
18 |                (\d+)₄ (\w+)₅               
19 | 


--------------------------------------------------------------------------------
/doc/linqpad-samples/Nested types.linq:
--------------------------------------------------------------------------------
 1 | <Query Kind="Statements">
 2 |   <Reference Relative="..\..\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll">C:\src\public\RegExtract\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll</Reference>
 3 |   <Namespace>RegExtract</Namespace>
 4 | </Query>
 5 | 
 6 | // You can nest parentheses in the Regex. The order of the types in your typle
 7 | // should correspond to the open parenthesis of each capture group.
 8 | (Uri uri, string protocol, string host, int port, string path) nested =
 9 |     "https://nuget.org:443/packages/RegExtract"
10 |         .Extract<(Uri, string, string, int, string)>(@"((\S+)://(\S+):(\d+)(\S*))");
11 | 
12 | nested.Dump("Nested parens in Regex");
13 | 


--------------------------------------------------------------------------------
/RegExtract.Test/VerifyShim.cs:
--------------------------------------------------------------------------------
 1 | // Compatibility shim for older target frameworks that don't have Verify packages available.
 2 | #if NETCOREAPP3_1 || NET462
 3 | using System;
 4 | using System.Threading.Tasks;
 5 | 
 6 | namespace VerifyXunit
 7 | {
 8 |     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
 9 |     internal sealed class UsesVerifyAttribute : Attribute { }
10 | }
11 | 
12 | namespace VerifyTests
13 | {
14 |     // Minimal Verifier stub to allow the test code to compile and run on older TFMs.
15 |     internal static class Verifier
16 |     {
17 |         public static Task Verify(object? input) => Task.CompletedTask;
18 |         public static Task Verify(string input) => Task.CompletedTask;
19 |     }
20 | }
21 | #endif
22 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT
 2 | 
 3 | Copyright (c) Scott Blomquist
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/RegExtract.Test/RegExtract.Test.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFrameworks>netcoreapp8.0;netcoreapp3.1;net462;net10.0</TargetFrameworks>
 5 |     <Nullable>enable</Nullable>
 6 |     <IsPackable>false</IsPackable>
 7 |     <LangVersion>latest</LangVersion>
 8 |   </PropertyGroup>
 9 | 
10 |   <ItemGroup>
11 |     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
12 |     <PackageReference Include="Verify.Xunit" Version="22.10.2" />
13 |     <PackageReference Include="xunit" Version="2.6.4" />
14 |     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.6">
15 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
16 |       <PrivateAssets>all</PrivateAssets>
17 |     </PackageReference>
18 |     <PackageReference Include="coverlet.collector" Version="6.0.0">
19 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
20 |       <PrivateAssets>all</PrivateAssets>
21 |     </PackageReference>
22 |     <PackageReference Include="Microsoft.TestPlatform.ObjectModel" Version="17.8.0" Condition="$(TargetFramework.StartsWith('net4')) AND '$(OS)' == 'Unix'" />
23 |   </ItemGroup>
24 | 
25 |   <ItemGroup>
26 |     <ProjectReference Include="..\RegExtract\RegExtract.csproj" />
27 |   </ItemGroup>
28 | 
29 | </Project>
30 | 


--------------------------------------------------------------------------------
/doc/linqpad-samples/Using record types.linq:
--------------------------------------------------------------------------------
 1 | <Query Kind="Statements">
 2 |   <Reference Relative="..\..\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll">C:\src\public\RegExtract\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll</Reference>
 3 |   <Namespace>RegExtract</Namespace>
 4 | </Query>
 5 | 
 6 | // Instead of a tuple, you can use any type with a single non-default public constructor.
 7 | // The most useful examples of this will probably be C# 9's record types.
 8 | UrlPositionalRecord urlPositional = "https://nuget.org:443/packages/RegExtract"
 9 |     .Extract<UrlPositionalRecord>
10 |       (@"((\S+)://(\S+):(\d+)(\S*))");
11 | 
12 | urlPositional.Dump("Record type (positional)");
13 | 
14 | // Instead of a tuple, you can use any type with a single non-default public constructor.
15 | // The most useful examples of this will probably be C# 9's record types.
16 | UrlRecord urlProperties = "https://nuget.org:443/packages/RegExtract"
17 |       .Extract<UrlRecord>(@"(?<protocol>\S+)://(?<host>\S+):(?<port>\d+)(?<path>\S*)");
18 | 
19 | urlProperties.Dump("Record type (properties)");
20 | 
21 | record UrlPositionalRecord(Uri uri, string protocol, string host, int port, string path);
22 | 
23 | record UrlRecord
24 | {
25 |     public string protocol { get; init; }
26 |     public string host { get; init; }
27 |     public int port { get; init; }
28 |     public string path { get; init; }
29 | }
30 | 


--------------------------------------------------------------------------------
/RegExtract.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.0.32014.148
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RegExtract", "RegExtract\RegExtract.csproj", "{7F764AB9-4BEA-4128-B1DA-17B51166715D}"
 7 | EndProject
 8 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "RegExtract.Test", "RegExtract.Test\RegExtract.Test.csproj", "{836F68E6-27F6-417F-B216-3B48BBE34862}"
 9 | EndProject
10 | Global
11 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
12 | 		Debug|Any CPU = Debug|Any CPU
13 | 		Release|Any CPU = Release|Any CPU
14 | 	EndGlobalSection
15 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
16 | 		{7F764AB9-4BEA-4128-B1DA-17B51166715D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
17 | 		{7F764AB9-4BEA-4128-B1DA-17B51166715D}.Debug|Any CPU.Build.0 = Debug|Any CPU
18 | 		{7F764AB9-4BEA-4128-B1DA-17B51166715D}.Release|Any CPU.ActiveCfg = Release|Any CPU
19 | 		{7F764AB9-4BEA-4128-B1DA-17B51166715D}.Release|Any CPU.Build.0 = Release|Any CPU
20 | 		{836F68E6-27F6-417F-B216-3B48BBE34862}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
21 | 		{836F68E6-27F6-417F-B216-3B48BBE34862}.Debug|Any CPU.Build.0 = Debug|Any CPU
22 | 		{836F68E6-27F6-417F-B216-3B48BBE34862}.Release|Any CPU.ActiveCfg = Release|Any CPU
23 | 		{836F68E6-27F6-417F-B216-3B48BBE34862}.Release|Any CPU.Build.0 = Release|Any CPU
24 | 	EndGlobalSection
25 | 	GlobalSection(SolutionProperties) = preSolution
26 | 		HideSolutionNode = FALSE
27 | 	EndGlobalSection
28 | 	GlobalSection(ExtensibilityGlobals) = postSolution
29 | 		SolutionGuid = {EC1F0F9D-41E7-458E-AF8A-74B6C9FFB231}
30 | 	EndGlobalSection
31 | EndGlobal
32 | 


--------------------------------------------------------------------------------
/tools/ExtractionPlanInspector.linq:
--------------------------------------------------------------------------------
 1 | <Query Kind="Statements">
 2 |   <Reference Relative="..\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll">C:\src\public\RegExtract\RegExtract\bin\Debug\netstandard2.1\RegExtract.dll</Reference>
 3 |   <Namespace>RegExtract</Namespace>
 4 | </Query>
 5 | 
 6 | //"2-12 c: abcdefghi".ShowExtractionPlan<((int,int), char, string)>(@"((\d+)-(\d+)) (.): (.*)")
 7 | //"The quick brown fox jumps over the lazy dog".ShowExtractionPlan<List<List<char>>>(@"(?:((\w)+) ?)+")
 8 | //"2-12 18-3 10-5".ShowExtractionPlan<List<(int,int)>>(@"((\d+)-(\d+) ?)+")
 9 | //"faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.".ShowExtractionPlan<(string,string,string,List<int>,List<string>)>(@"^(.+) bags contain(?: (no other bags)\.| ((\d+) (.*?)) bags?[,.])+$").Dump();
10 | //"faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.".ShowExtractionPlan<(string,string,List<(int,string)>)>(@"^(.+) bags contain(?: (no other bags)\.| ((\d+) (.*?)) bags?[,.])+$").Dump();
11 | 
12 | //"2-12 c: abcdefghi".ShowExtractionPlan<((int, int), char?, string)>(@"((\d+)-(\d+)) (.): (.*)").Dump();
13 | 
14 | //"faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.".Extr<(string,string,string,List<int>,List<string>)>(@"^(.+) bags contain(?: (no other bags)\.| ((\d+) (.*?)) bags?[,.])+$")
15 | 
16 | //RegexExtractionPlan.CreatePlan<(string, string, List<(int?, string)?>)>(@"^(.+) bags contain(?: (no other bags)\.| ((\d+) (.*?)) bags?[,.])+$").Dump();
17 | //var plan = RegexExtractionPlan.CreatePlan<List<List<char>>>(@"((\w)+ ?)+").Dump();
18 | //plan.Execute(Regex.Match("The quick brown fox jumps over the lazy dog",@"(?:((\w)+) ?)+").Dump()).Dump();
19 | 
20 | RegexExtractionPlan.CreatePlan<(long, string, int, char, string, int, char, string, int, char, string)>(@"(((.)(.)(.)(.)(.)(.)(.)(.)(.)))").Dump();
21 | 
22 | record bound(int lo, int hi);
23 | record rule(string range, int lo, int hi, char ch, string pwd);


--------------------------------------------------------------------------------
/doc/spec.md:
--------------------------------------------------------------------------------
  1 | # List of tuple
  2 | 
  3 | <table>
  4 | <tr>
  5 | <td>
  6 | 
  7 | ```mermaid
  8 | graph TD
  9 |   Start["List<(char,char)>"] --> tuple["(char,char)"]
 10 |   tuple --> char1["char"]
 11 |   tuple --> char2["char"]
 12 | ```
 13 | </td>
 14 | <td>
 15 | 
 16 | ```mermaid
 17 | graph TD
 18 |     A1["((.)(.))+"]
 19 |     A1 --> tuple["(.)(.)"]
 20 |     tuple --> char1["."]
 21 |     tuple --> char2["."]
 22 | ```
 23 | </td>
 24 | </tr>
 25 | </table>
 26 | 
 27 | # List of primitive type
 28 | 
 29 | <table>
 30 | <tr>
 31 | <td>
 32 | 
 33 | ```mermaid
 34 | graph TD
 35 |   Start["List#lt;int>"] --> int
 36 | ```
 37 | </td>
 38 | <td>
 39 | 
 40 | ```mermaid
 41 | graph TD
 42 |     A1["((\d+),? ?)+"]
 43 |     A1 --> int["(\d+),? ?"]
 44 | ```
 45 | </td>
 46 | <td></td>
 47 | <td>
 48 | 
 49 | ```mermaid
 50 | graph TD
 51 |   Start["List#lt;int>"] --> int
 52 | ```
 53 | </td>
 54 | <td>
 55 | 
 56 | ```mermaid
 57 | graph TD
 58 |     A1["(\d+ ?)+"]
 59 |     A1 --> int["\d+ ?"]
 60 | ```
 61 | </td>
 62 | </tr>
 63 | </table>
 64 | 
 65 | # Dictionary of tuple including list
 66 | 
 67 | <table>
 68 | <tr>
 69 | <td>
 70 | 
 71 | ```mermaid
 72 | graph TD
 73 |   Start["Dictionary#lt;int,List#lt;string>>"] --> tuple["(int,List#lt;string>)"]
 74 |   tuple --> int
 75 |   tuple --> list["List#lt;string>"]
 76 |   list --> string
 77 | ```
 78 | </td>
 79 | <td>
 80 | 
 81 | ```mermaid
 82 | graph TD
 83 |     A1["((\d+) = ((\w+),? ?)+)+"]
 84 |     A1 --> tuple["(\d+) = ((\w+),? ?)+"]
 85 |     tuple --> int["\d+"]
 86 |     tuple --> list["(\w+),? ?"]
 87 |     list --> string["\w+"]
 88 | ```
 89 | </td>
 90 | </tr>
 91 | </table>
 92 | 
 93 | # Record with two values
 94 | 
 95 | <table>
 96 | <tr>
 97 | <td>
 98 | 
 99 | ```mermaid
100 | graph TD
101 |   Start["record(long,long)"] --> long1[long]
102 |   Start --> long2[long]
103 | ```
104 | </td>
105 | <td>
106 | 
107 | ```mermaid
108 | graph TD
109 |     A1["mem\[(\d+)\] = (\d+)"]
110 |     A1 --> long1["\d+"]
111 |     A1 --> long2["\d+"]
112 | ```
113 | </td>
114 | </tr>
115 | </table>
116 | 
117 | # List of List of List of char
118 | 
119 | <table>
120 | <tr>
121 | <td>
122 | 
123 | ```mermaid
124 | graph TD
125 |   Start["List#lt;List#lt;List#lt;char>>>"] --> listlist["List#lt;List#lt;char>>"]
126 |   listlist --> list["List#lt;char>"]
127 |   list --> char  
128 | ```
129 | </td>
130 | <td>
131 | 
132 | ```mermaid
133 | graph TD
134 |     A1["(((\w)+\s+)+,? ?)+"] --> listlist["((\w)+\s+)+,? ?"]
135 |     listlist --> list["(\w)+\s+"]
136 |     list --> char["\w"]
137 | ```
138 | </td>
139 | </tr>
140 | </table>
141 | 


--------------------------------------------------------------------------------
/.github/workflows/dotnet.yml:
--------------------------------------------------------------------------------
  1 | name: dotnet
  2 | 
  3 | permissions:
  4 |   contents: read
  5 |   packages: write
  6 |   id-token: write
  7 | 
  8 | on:
  9 |   push:
 10 |     branches: [ main ]
 11 |     tags: ["*"]
 12 |   pull_request:
 13 |     branches: [ main ]
 14 | 
 15 | jobs:
 16 |   build:
 17 |     runs-on: ubuntu-latest
 18 |     steps:
 19 |       - uses: actions/checkout@v4
 20 |         with:
 21 |           fetch-depth: 0
 22 |       - uses: actions/setup-dotnet@v4
 23 |         with:
 24 |           dotnet-version: '8.0.x'
 25 |       - uses: actions/setup-dotnet@v4
 26 |         with:
 27 |           dotnet-version: '3.1.x'
 28 |       - uses: gittools/actions/gitversion/setup@v0.9.7
 29 |         with:
 30 |           versionSpec: "5.x"
 31 |       - id: gitversion
 32 |         uses: gittools/actions/gitversion/execute@v0.9.7
 33 |       - name: Restore dependencies
 34 |         run: dotnet restore
 35 |       - name: Build
 36 |         run: dotnet build --configuration Release --no-restore
 37 |       - name: Test
 38 |         run: |
 39 |           if [ "$RUNNER_OS" = "Linux" ]; then
 40 |             # Skip net462 on Linux (Mono/OpenSSL compatibility issues)
 41 |             dotnet test --configuration Release --no-build --verbosity normal --framework '!net462'
 42 |           else
 43 |             dotnet test --configuration Release --no-build --verbosity normal
 44 |           fi
 45 |         shell: bash
 46 |       - run: |
 47 |           dotnet pack \
 48 |             --include-source \
 49 |             --include-symbols \
 50 |             --configuration Release \
 51 |             --no-build \
 52 |             --no-restore \
 53 |             -p:PackageVersion="${{ env.GitVersion_FullSemVer }}" \
 54 |             RegExtract/RegExtract.csproj \
 55 |             --output ${{ github.workspace }}/nugets/
 56 |       - uses: actions/upload-artifact@v4
 57 |         with:
 58 |           name: nugets
 59 |           path: nugets
 60 | 
 61 |   nuget-push-dev:
 62 |     runs-on: ubuntu-latest
 63 |     if: github.ref == 'refs/heads/main'
 64 |     needs: build
 65 | 
 66 |     steps:
 67 |       - name: download artifact
 68 |         uses: actions/download-artifact@v4
 69 |         with:
 70 |           name: nugets
 71 | 
 72 |       - name: setup dotnet
 73 |         uses: actions/setup-dotnet@v4
 74 |         with:
 75 |           dotnet-version: '8.0.x'
 76 |           source-url: https://nuget.pkg.github.com/sblom/index.json
 77 |         env:
 78 |           NUGET_AUTH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 79 | 
 80 |       - name: nuget push
 81 |         run: dotnet nuget push *.nupkg *.snupkg --skip-duplicate --api-key ${{ secrets.GITHUB_TOKEN }}
 82 | 
 83 |   nuget-push-prod:
 84 |     runs-on: ubuntu-latest
 85 |     if: startsWith(github.ref, 'refs/tags/')
 86 |     needs: build
 87 | 
 88 |     steps:
 89 |       - uses: actions/download-artifact@v4
 90 |         with:
 91 |           name: nugets
 92 | 
 93 |       # Get a short-lived NuGet API key
 94 |       - name: NuGet login (OIDC → temp API key)
 95 |         uses: NuGet/login@v1
 96 |         id: login
 97 |         with:
 98 |           user: ${{secrets.NUGET_USER}}
 99 |     
100 |       # Push the package
101 |       - name: NuGet push
102 |         run: dotnet nuget push *.nupkg *.snupkg --skip-duplicate --api-key ${{steps.login.outputs.NUGET_API_KEY}} --source https://api.nuget.org/v3/index.json


--------------------------------------------------------------------------------
/RegExtract/RegExtractExtensions.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Reflection;
 5 | using System.Text.RegularExpressions;
 6 | 
 7 | namespace RegExtract
 8 | {
 9 |     public enum RegExtractOptions
10 |     {
11 |         None = 0x0,
12 |         Strict = 1<<0
13 |     }
14 | 
15 |     public static class RegExtractExtensions
16 |     {
17 |         public static T? Extract<T>(this string str, string rx, RegExtractOptions options = RegExtractOptions.None)
18 |         {
19 |             return Extract<T>(str, rx, RegexOptions.None, options);
20 |         }
21 | 
22 |         public static T? Extract<T>(this string str, string rx, RegexOptions rxOptions, RegExtractOptions options = RegExtractOptions.None)
23 |         {
24 |             var match = Regex.Match(str, rx, rxOptions);
25 | 
26 |             var plan = ExtractionPlan<T>.CreatePlan(new Regex(rx));
27 |             return (T)plan.Extract(match);
28 |         }
29 | 
30 |         public static T? Extract<T>(this string str, Regex rx, RegExtractOptions options = RegExtractOptions.None)
31 |         {
32 |             var match = rx.Match(str);
33 | 
34 |             var plan = ExtractionPlan<T>.CreatePlan(rx);
35 |             return (T)plan.Extract(match);
36 |         }
37 | 
38 |         public static T? Extract<T>(this string str, ExtractionPlan<T> plan)
39 |         {
40 |             return plan.Extract(str);
41 |         }
42 | 
43 |         public static T? Extract<T>(this string str, RegExtractOptions options = RegExtractOptions.None)
44 |         {
45 |             var rx = GetRegexFromType(typeof(T));   
46 | 
47 |             return Extract<T>(str, rx, options);
48 |         }
49 | 
50 |         static Regex GetRegexFromType(Type type)
51 |         {
52 |             var field = type.GetField("REGEXTRACT_REGEX_PATTERN", BindingFlags.Public | BindingFlags.Static);
53 |             if (field is not { IsLiteral: true, IsInitOnly: false })
54 |                 throw new ArgumentException("No string, Regex, or Match provided, and extraction type doesn't have public const string REGEXTRACT_REGEX_PATTERN.");
55 |             string rxPattern = (string)field.GetValue(null);
56 | 
57 |             RegexOptions rxOptions = RegexOptions.None;
58 |             field = type.GetField("REGEXTRACT_REGEX_OPTIONS", BindingFlags.Public | BindingFlags.Static);
59 |             if (field is { IsLiteral: true, IsInitOnly: false }) rxOptions = (RegexOptions)field.GetValue(null);
60 | 
61 |             return new Regex(rxPattern, rxOptions);
62 |         }
63 |         
64 |         public static IEnumerable<T> Extract<T>(this IEnumerable<string> str, string rx, RegExtractOptions options = RegExtractOptions.None)
65 |         {
66 |             return Extract<T>(str, rx, RegexOptions.None, options);
67 |         }
68 | 
69 |         public static IEnumerable<T> Extract<T>(this IEnumerable<string> str, string rx, RegexOptions rxOptions, RegExtractOptions options = RegExtractOptions.None)
70 |         {
71 |             return Extract<T>(str, new Regex(rx, rxOptions), options);
72 |         }
73 | 
74 |         public static IEnumerable<T> Extract<T>(this IEnumerable<string> str, ExtractionPlan<T> plan)
75 |         {
76 |             return str.Select(plan.Extract);
77 |         }
78 | 
79 |         public static IEnumerable<T> Extract<T>(this IEnumerable<string> str, RegExtractOptions options = RegExtractOptions.None)
80 |         {
81 |             var rx = GetRegexFromType(typeof(T));
82 |             return Extract<T>(str, rx, options);
83 |         }
84 |         
85 |         public static IEnumerable<T> Extract<T>(this IEnumerable<string> str, Regex rx, RegExtractOptions options = RegExtractOptions.None)
86 |         {
87 |             var plan = ExtractionPlan<T>.CreatePlan(rx, options);
88 |             return str.Select(s => plan.Extract(rx.Match(s)));
89 |         }
90 |     }
91 | }
92 | 


--------------------------------------------------------------------------------
/RegExtract/RegExtract.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFrameworks>netstandard2.0;netstandard2.1;net40;net10.0</TargetFrameworks>
 5 |     <Nullable>enable</Nullable>
 6 |     <LangVersion>Latest</LangVersion>
 7 |   </PropertyGroup>
 8 | 
 9 |   <!-- NuGet package config -->
10 |   <PropertyGroup>
11 |     <Description>Clean &amp; simple, idiomatic C# RegEx-based line parser.
12 | 
13 | RegExtract takes a string and a regular expression template and deserializes to a provided type. Works especially well with records and tuples, but can extract to any type that provides either a `static T Parse(string)` method or a single-string constructor (`T(string)`).
14 | 
15 | See more docs at project page: https://github.com/sblom/RegExtract
16 | </Description>
17 |     <Authors>Scott Blomquist</Authors>
18 |     <Copyright>Copyright © Scott Blomquist. All rights reserved.</Copyright>
19 |     <Company />
20 |     <Product />
21 |     <PackageProjectUrl>https://github.com/sblom/RegExtract</PackageProjectUrl>
22 |     <PackageLicenseExpression>MIT</PackageLicenseExpression>
23 |     <PackageTags>regex parse parser reader deserialize deserializer valuetuple record deserialization parsing regular-expression regular-expressions regular expression expressions type string tuple linqpad-samples</PackageTags>
24 |     <PackageIcon>icon.png</PackageIcon>
25 |   </PropertyGroup>
26 |   
27 |   <!-- SourceLink configuration -->
28 |   <PropertyGroup>
29 |     <PublishRepositoryUrl>true</PublishRepositoryUrl>
30 |     <EmbedUntrackedSources>true</EmbedUntrackedSources>
31 |     <IncludeSymbols>true</IncludeSymbols>
32 |     <SymbolPackageFormat>snupkg</SymbolPackageFormat>
33 |   </PropertyGroup>
34 | 
35 |   <!-- SourceLink configuration -->
36 |   <ItemGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">
37 |     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
38 |   </ItemGroup>
39 | 
40 |   <!-- SourceLink configuration -->
41 |   <PropertyGroup Condition="'$(GITHUB_ACTIONS)' == 'true'">
42 |     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
43 |     <DeterministicSourcePaths>true</DeterministicSourcePaths>
44 |   </PropertyGroup>
45 | 
46 |   <PropertyGroup>
47 |     <AssemblyVersion>$(GITVERSION_ASSEMBLYSEMVER)</AssemblyVersion>
48 |     <AssemblyFileVersion>$(GITVERSION_ASSEMBLYFILESEMVER)</AssemblyFileVersion>
49 |     <AssemblyVersion Condition="'$(AssemblyVersion)' == ''">0.0.0.0</AssemblyVersion>
50 |     <AssemblyFileVersion Condition="'$(AssemblyFileVersion)' == ''">0.0.0.0</AssemblyFileVersion>
51 |   </PropertyGroup>
52 | 
53 |   <ItemGroup>
54 |     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute">
55 |       <_Parameter1>RegExtract.Test</_Parameter1>
56 |     </AssemblyAttribute>
57 |     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleToAttribute" Condition="'$(Configuration)' == 'Debug'">
58 |       <_Parameter1>LINQPadQuery</_Parameter1>
59 |     </AssemblyAttribute>
60 |   </ItemGroup>
61 | 
62 |   <ItemGroup>
63 |     <None Include="..\doc\linqpad-samples\**" Pack="True" PackagePath="linqpad-samples">
64 |       <Visible>false</Visible>
65 |     </None>
66 |     <None Include="..\images\icon.png" Pack="True" PackagePath="\">
67 |       <Visible>false</Visible>
68 |     </None>
69 |   </ItemGroup>
70 | 
71 |   <ItemGroup>
72 |     <None Include="..\doc\**" />
73 |   </ItemGroup>
74 | 
75 |   <ItemGroup Condition="'$(TargetFramework)' == 'NET40'">
76 |     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
77 |   </ItemGroup>
78 | 
79 |   <ItemGroup>
80 |     <PackageReference Include="PolySharp" Version="1.14.1">
81 |       <PrivateAssets>all</PrivateAssets>
82 |       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
83 |     </PackageReference>
84 |   </ItemGroup>
85 | 
86 | </Project>
87 | 


--------------------------------------------------------------------------------
/RegExtract/ExtractionPlanTypeWrapper.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | using System.Globalization;
  5 | using System.Linq;
  6 | using System.Reflection;
  7 | using System.Text;
  8 | 
  9 | namespace RegExtract
 10 | {
 11 |     internal class ExtractionPlanTypeWrapper
 12 |     {
 13 |         private static Dictionary<Type, ExtractionPlanTypeWrapper> _typeWrappers = new();
 14 | 
 15 |         public static ExtractionPlanTypeWrapper Wrap(Type? type)
 16 |         {
 17 |             type ??= typeof(void);
 18 |             if (_typeWrappers.TryGetValue(type, out var wrap))
 19 |                 return wrap;
 20 |             else
 21 |                 return (_typeWrappers[type] = new ExtractionPlanTypeWrapper(type));
 22 |         }
 23 | 
 24 |         private ExtractionPlanTypeWrapper(Type type)
 25 |         {
 26 |             Type = type;
 27 |             _genericArguments = new Lazy<Type[]?>(() => NonNullableType.Type.GetGenericArguments());
 28 |             _addMethod = new Lazy<MethodInfo?>(() => Type.GetMethod("Add", BindingFlags.Public | BindingFlags.Instance, null, GenericArguments, null));
 29 |             _nonNullableType = new Lazy<ExtractionPlanTypeWrapper>(() => { var type = Nullable.GetUnderlyingType(Type); return type != null ? ExtractionPlanTypeWrapper.Wrap(type) : this; });
 30 |         }
 31 | 
 32 |         public Type Type { get; }
 33 | 
 34 |         private Lazy<ExtractionPlanTypeWrapper> _nonNullableType;
 35 |         public ExtractionPlanTypeWrapper NonNullableType => _nonNullableType.Value;
 36 | 
 37 |         private Lazy<Type[]?> _genericArguments;
 38 |         public Type[]? GenericArguments => _genericArguments.Value;
 39 | 
 40 |         private bool? _isNullable = null;
 41 |         public bool IsNullable => _isNullable.HasValue ? _isNullable.Value : ((bool)(_isNullable = Nullable.GetUnderlyingType(Type) != null));
 42 | 
 43 |         private bool? _isTuple = null;
 44 |         public bool IsTuple => _isTuple.HasValue ? _isTuple.Value : ((bool)(_isTuple = NonNullableType.Type.FullName.StartsWith(VALUETUPLE_TYPENAME)));
 45 | 
 46 |         // We use C#'s definition of an initializable collection, which is any type that implements IEnumerable and has a public Add() method.
 47 |         // In our case, we also require that the Add() method has parameters of the same type as the collection's generic parameters.
 48 |         private bool? _isInitializableCollection = null;
 49 |         public bool IsInitializableCollection => _isInitializableCollection.HasValue ? _isInitializableCollection.Value : ((bool)(_isInitializableCollection = IsInitializableCollectionImpl()));
 50 | 
 51 |         private Lazy<MethodInfo?> _addMethod;
 52 |         public MethodInfo? AddMethod => _addMethod.Value;
 53 | 
 54 |         private bool IsInitializableCollectionImpl()
 55 |         {
 56 |             var genericParameters = GenericArguments;
 57 |             var addMethod = Type.GetMethod("Add", BindingFlags.Public | BindingFlags.Instance, null, genericParameters, null);
 58 | 
 59 |             return Type.GetInterfaces().Any(i => i == typeof(IEnumerable)) && addMethod != null;
 60 |         }
 61 | 
 62 |         private ConstructorInfo[]? _constructors = null;
 63 |         public ConstructorInfo[] Constructors => _constructors ?? (_constructors = NonNullableType.Type.GetConstructors());
 64 | 
 65 |         public bool IsContainerOfSize(int numParams)
 66 |         {
 67 |             var constructors = Constructors.Where(cons => cons.GetParameters().Length == numParams);
 68 |             return constructors.Count() == 1;
 69 |         }
 70 | 
 71 |         public bool IsDirectlyConstructable {
 72 |             get
 73 |             {
 74 |                 if (Type == typeof(string))
 75 |                 {
 76 |                     return true;
 77 |                 }
 78 | 
 79 |                 if (IsTuple)
 80 |                 {
 81 |                     return false;
 82 |                 }
 83 | 
 84 |                 var parse = NonNullableType.Type.GetMethod("Parse",
 85 |                                 BindingFlags.Static | BindingFlags.Public,
 86 |                                 null,
 87 |                                 new Type[] { typeof(string) },
 88 |                                 null);
 89 | 
 90 |                 if (parse is not null)
 91 |                 {
 92 |                     return true;
 93 |                 }
 94 | 
 95 |                 if (NonNullableType.Type.BaseType == typeof(Enum))
 96 |                 {
 97 |                     return true;
 98 |                 }
 99 | 
100 |                 return false;
101 |             }
102 |         }
103 | 
104 |         protected Type[] GetTupleArgumentsList(Type type)
105 |         {
106 |             var typeArgs = type.GetGenericArguments();
107 | 
108 |             if (IsTuple && typeArgs.Length == 8)
109 |             {
110 |                 return typeArgs.Take(7).Concat(GetTupleArgumentsList(typeArgs[7])).ToArray();
111 |             }
112 |             else
113 |             {
114 |                 return typeArgs;
115 |             }
116 |         }
117 | 
118 |         private const string VALUETUPLE_TYPENAME = "System.ValueTuple`";
119 |         private const string NULLABLE_TYPENAME = "System.Nullable`";
120 |     }
121 | }
122 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | ## Ignore Visual Studio temporary files, build results, and
  2 | ## files generated by popular Visual Studio add-ons.
  3 | ##
  4 | ## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
  5 | 
  6 | # User-specific files
  7 | *.rsuser
  8 | *.suo
  9 | *.user
 10 | *.userosscache
 11 | *.sln.docstates
 12 | 
 13 | # User-specific files (MonoDevelop/Xamarin Studio)
 14 | *.userprefs
 15 | 
 16 | # Mono auto generated files
 17 | mono_crash.*
 18 | 
 19 | # Build results
 20 | [Dd]ebug/
 21 | [Dd]ebugPublic/
 22 | [Rr]elease/
 23 | [Rr]eleases/
 24 | x64/
 25 | x86/
 26 | [Aa][Rr][Mm]/
 27 | [Aa][Rr][Mm]64/
 28 | bld/
 29 | [Bb]in/
 30 | [Oo]bj/
 31 | [Ll]og/
 32 | [Ll]ogs/
 33 | 
 34 | # Visual Studio 2015/2017 cache/options directory
 35 | .vs/
 36 | # Uncomment if you have tasks that create the project's static files in wwwroot
 37 | #wwwroot/
 38 | 
 39 | # Visual Studio 2017 auto generated files
 40 | Generated\ Files/
 41 | 
 42 | # MSTest test Results
 43 | [Tt]est[Rr]esult*/
 44 | [Bb]uild[Ll]og.*
 45 | 
 46 | # NUnit
 47 | *.VisualState.xml
 48 | TestResult.xml
 49 | nunit-*.xml
 50 | 
 51 | # Build Results of an ATL Project
 52 | [Dd]ebugPS/
 53 | [Rr]eleasePS/
 54 | dlldata.c
 55 | 
 56 | # Benchmark Results
 57 | BenchmarkDotNet.Artifacts/
 58 | 
 59 | # .NET Core
 60 | project.lock.json
 61 | project.fragment.lock.json
 62 | artifacts/
 63 | 
 64 | # StyleCop
 65 | StyleCopReport.xml
 66 | 
 67 | # Files built by Visual Studio
 68 | *_i.c
 69 | *_p.c
 70 | *_h.h
 71 | *.ilk
 72 | *.meta
 73 | *.obj
 74 | *.iobj
 75 | *.pch
 76 | *.pdb
 77 | *.ipdb
 78 | *.pgc
 79 | *.pgd
 80 | *.rsp
 81 | *.sbr
 82 | *.tlb
 83 | *.tli
 84 | *.tlh
 85 | *.tmp
 86 | *.tmp_proj
 87 | *_wpftmp.csproj
 88 | *.log
 89 | *.vspscc
 90 | *.vssscc
 91 | .builds
 92 | *.pidb
 93 | *.svclog
 94 | *.scc
 95 | 
 96 | # Chutzpah Test files
 97 | _Chutzpah*
 98 | 
 99 | # Visual C++ cache files
100 | ipch/
101 | *.aps
102 | *.ncb
103 | *.opendb
104 | *.opensdf
105 | *.sdf
106 | *.cachefile
107 | *.VC.db
108 | *.VC.VC.opendb
109 | 
110 | # Visual Studio profiler
111 | *.psess
112 | *.vsp
113 | *.vspx
114 | *.sap
115 | 
116 | # Visual Studio Trace Files
117 | *.e2e
118 | 
119 | # TFS 2012 Local Workspace
120 | $tf/
121 | 
122 | # Guidance Automation Toolkit
123 | *.gpState
124 | 
125 | # ReSharper is a .NET coding add-in
126 | _ReSharper*/
127 | *.[Rr]e[Ss]harper
128 | *.DotSettings.user
129 | 
130 | # TeamCity is a build add-in
131 | _TeamCity*
132 | 
133 | # DotCover is a Code Coverage Tool
134 | *.dotCover
135 | 
136 | # AxoCover is a Code Coverage Tool
137 | .axoCover/*
138 | !.axoCover/settings.json
139 | 
140 | # Visual Studio code coverage results
141 | *.coverage
142 | *.coveragexml
143 | 
144 | # NCrunch
145 | _NCrunch_*
146 | .*crunch*.local.xml
147 | nCrunchTemp_*
148 | 
149 | # MightyMoose
150 | *.mm.*
151 | AutoTest.Net/
152 | 
153 | # Web workbench (sass)
154 | .sass-cache/
155 | 
156 | # Installshield output folder
157 | [Ee]xpress/
158 | 
159 | # DocProject is a documentation generator add-in
160 | DocProject/buildhelp/
161 | DocProject/Help/*.HxT
162 | DocProject/Help/*.HxC
163 | DocProject/Help/*.hhc
164 | DocProject/Help/*.hhk
165 | DocProject/Help/*.hhp
166 | DocProject/Help/Html2
167 | DocProject/Help/html
168 | 
169 | # Click-Once directory
170 | publish/
171 | 
172 | # Publish Web Output
173 | *.[Pp]ublish.xml
174 | *.azurePubxml
175 | # Note: Comment the next line if you want to checkin your web deploy settings,
176 | # but database connection strings (with potential passwords) will be unencrypted
177 | *.pubxml
178 | *.publishproj
179 | 
180 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
181 | # checkin your Azure Web App publish settings, but sensitive information contained
182 | # in these scripts will be unencrypted
183 | PublishScripts/
184 | 
185 | # NuGet Packages
186 | *.nupkg
187 | # NuGet Symbol Packages
188 | *.snupkg
189 | # The packages folder can be ignored because of Package Restore
190 | **/[Pp]ackages/*
191 | # except build/, which is used as an MSBuild target.
192 | !**/[Pp]ackages/build/
193 | # Uncomment if necessary however generally it will be regenerated when needed
194 | #!**/[Pp]ackages/repositories.config
195 | # NuGet v3's project.json files produces more ignorable files
196 | *.nuget.props
197 | *.nuget.targets
198 | 
199 | # Microsoft Azure Build Output
200 | csx/
201 | *.build.csdef
202 | 
203 | # Microsoft Azure Emulator
204 | ecf/
205 | rcf/
206 | 
207 | # Windows Store app package directories and files
208 | AppPackages/
209 | BundleArtifacts/
210 | Package.StoreAssociation.xml
211 | _pkginfo.txt
212 | *.appx
213 | *.appxbundle
214 | *.appxupload
215 | 
216 | # Visual Studio cache files
217 | # files ending in .cache can be ignored
218 | *.[Cc]ache
219 | # but keep track of directories ending in .cache
220 | !?*.[Cc]ache/
221 | 
222 | # Others
223 | ClientBin/
224 | ~$*
225 | *~
226 | *.dbmdl
227 | *.dbproj.schemaview
228 | *.jfm
229 | *.pfx
230 | *.publishsettings
231 | orleans.codegen.cs
232 | 
233 | # Including strong name files can present a security risk
234 | # (https://github.com/github/gitignore/pull/2483#issue-259490424)
235 | #*.snk
236 | 
237 | # Since there are multiple workflows, uncomment next line to ignore bower_components
238 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
239 | #bower_components/
240 | 
241 | # RIA/Silverlight projects
242 | Generated_Code/
243 | 
244 | # Backup & report files from converting an old project file
245 | # to a newer Visual Studio version. Backup files are not needed,
246 | # because we have git ;-)
247 | _UpgradeReport_Files/
248 | Backup*/
249 | UpgradeLog*.XML
250 | UpgradeLog*.htm
251 | ServiceFabricBackup/
252 | *.rptproj.bak
253 | 
254 | # SQL Server files
255 | *.mdf
256 | *.ldf
257 | *.ndf
258 | 
259 | # Business Intelligence projects
260 | *.rdl.data
261 | *.bim.layout
262 | *.bim_*.settings
263 | *.rptproj.rsuser
264 | *- [Bb]ackup.rdl
265 | *- [Bb]ackup ([0-9]).rdl
266 | *- [Bb]ackup ([0-9][0-9]).rdl
267 | 
268 | # Microsoft Fakes
269 | FakesAssemblies/
270 | 
271 | # GhostDoc plugin setting file
272 | *.GhostDoc.xml
273 | 
274 | # Node.js Tools for Visual Studio
275 | .ntvs_analysis.dat
276 | node_modules/
277 | 
278 | # Visual Studio 6 build log
279 | *.plg
280 | 
281 | # Visual Studio 6 workspace options file
282 | *.opt
283 | 
284 | # Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
285 | *.vbw
286 | 
287 | # Visual Studio LightSwitch build output
288 | **/*.HTMLClient/GeneratedArtifacts
289 | **/*.DesktopClient/GeneratedArtifacts
290 | **/*.DesktopClient/ModelManifest.xml
291 | **/*.Server/GeneratedArtifacts
292 | **/*.Server/ModelManifest.xml
293 | _Pvt_Extensions
294 | 
295 | # Paket dependency manager
296 | .paket/paket.exe
297 | paket-files/
298 | 
299 | # FAKE - F# Make
300 | .fake/
301 | 
302 | # CodeRush personal settings
303 | .cr/personal
304 | 
305 | # Python Tools for Visual Studio (PTVS)
306 | __pycache__/
307 | *.pyc
308 | 
309 | # Cake - Uncomment if you are using it
310 | # tools/**
311 | # !tools/packages.config
312 | 
313 | # Tabs Studio
314 | *.tss
315 | 
316 | # Telerik's JustMock configuration file
317 | *.jmconfig
318 | 
319 | # BizTalk build output
320 | *.btp.cs
321 | *.btm.cs
322 | *.odx.cs
323 | *.xsd.cs
324 | 
325 | # OpenCover UI analysis results
326 | OpenCover/
327 | 
328 | # Azure Stream Analytics local run output
329 | ASALocalRun/
330 | 
331 | # MSBuild Binary and Structured Log
332 | *.binlog
333 | 
334 | # NVidia Nsight GPU debugger configuration file
335 | *.nvuser
336 | 
337 | # MFractors (Xamarin productivity tool) working folder
338 | .mfractor/
339 | 
340 | # Local History for Visual Studio
341 | .localhistory/
342 | 
343 | # BeatPulse healthcheck temp database
344 | healthchecksdb
345 | 
346 | # Backup folder for Package Reference Convert tool in Visual Studio 2017
347 | MigrationBackup/
348 | 
349 | # Ionide (cross platform F# VS Code tools) working folder
350 | .ionide/
351 | 
352 | # Verify snapshot test received files (not part of source control)
353 | *.received.txt
354 | 


--------------------------------------------------------------------------------
/RegExtract/ExtractionPlan.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Reflection;
  6 | using System.Text.RegularExpressions;
  7 | 
  8 | using RegExtract.ExtractionPlanNodeTypes;
  9 | using RegExtract.RegexTools;
 10 | 
 11 | namespace RegExtract
 12 | {
 13 |     public class ExtractionPlan<T>: IFormattable
 14 |     {
 15 |         ExtractionPlanNode Plan { get; set; }
 16 |         RegexCaptureGroupTree? _tree;
 17 | 
 18 |         protected ExtractionPlan()
 19 |         {
 20 |             Plan = new UninitializedNode();
 21 |         }
 22 | 
 23 |         public T Extract(string str)
 24 |         {
 25 |             return (T)Plan.Execute(_tree?.Regex.Match(str) ?? Regex.Match("",""))!;
 26 |         }
 27 | 
 28 |         public T Extract(Match match)
 29 |         {
 30 |             return (T)Plan.Execute(match)!;
 31 |         }
 32 | 
 33 |         static public ExtractionPlan<T> CreatePlan(Regex regex, RegExtractOptions reOptions= RegExtractOptions.None)
 34 |         {
 35 |             ExtractionPlan<T> plan = new ExtractionPlan<T>();
 36 |             plan.InitializePlan(regex);
 37 | 
 38 |             return plan;
 39 |         }
 40 | 
 41 |         internal void InitializePlan(Regex regex)
 42 |         {
 43 |             _tree = new RegexCaptureGroupTree(regex);
 44 |             var type = ExtractionPlanTypeWrapper.Wrap(typeof(T));
 45 | 
 46 |             Plan = AssignTypesToTree(_tree.Tree, type);
 47 |         }
 48 | 
 49 | 
 50 |         ExtractionPlanNode BindPropertyPlan(RegexCaptureGroupNode tree, ExtractionPlanTypeWrapper type, string name)
 51 |         {
 52 |             type = type.NonNullableType;
 53 | 
 54 |             // TODO: Figure out how to move this into ExtractionPlanTypeWrapper, and do some caching
 55 |             var property = type.Type.GetProperty(name);
 56 | 
 57 |             if (property is null)
 58 |                 throw new ArgumentException($"Could not find property for named capture group '{name}'.");
 59 | 
 60 |             type = ExtractionPlanTypeWrapper.Wrap(property.PropertyType);
 61 | 
 62 |             return AssignTypesToTree(tree, type);
 63 |         }
 64 | 
 65 |         ExtractionPlanNode BindConstructorPlan(RegexCaptureGroupNode tree, ExtractionPlanTypeWrapper type, int paramNum, int paramCount)
 66 |         {
 67 |             var constructors = type.Constructors
 68 |                        .Where(cons => cons.GetParameters().Length == paramCount);
 69 | 
 70 |             if (type.IsInitializableCollection)
 71 |             {
 72 |                 try
 73 |                 {
 74 |                     type = ExtractionPlanTypeWrapper.Wrap(type.GenericArguments?[paramNum]);
 75 |                 }
 76 |                 catch (IndexOutOfRangeException)
 77 |                 {
 78 |                     throw new ArgumentException($"Capture group '{tree.name}' represents too many parameters for collection {type.Type.FullName}");
 79 |                 }
 80 |             }
 81 |             else if (type.IsTuple)
 82 |             {
 83 |                 try
 84 |                 {
 85 |                     type = ExtractionPlanTypeWrapper.Wrap(type.GenericArguments?[paramNum]);
 86 |                 }
 87 |                 catch (IndexOutOfRangeException)
 88 |                 {
 89 |                     throw new ArgumentException($"Capture group '{tree.name}' represents too many parameters for tuple {type.Type.FullName}");
 90 |                 }
 91 |             }
 92 |             else if (constructors?.Count() == 1)
 93 |             {
 94 |                 var constructor = constructors.Single();
 95 | 
 96 |                 try
 97 |                 {
 98 |                     type = ExtractionPlanTypeWrapper.Wrap(constructor.GetParameters()[paramNum].ParameterType);
 99 |                 }
100 |                 catch (IndexOutOfRangeException)
101 |                 {
102 |                     throw new ArgumentException($"Capture group '{tree.name}' represents too many parameters for constructor {type.Type.FullName}");
103 |                 }
104 |             }
105 | 
106 |             return AssignTypesToTree(tree, type);
107 |         }
108 | 
109 |         ExtractionPlanNode BindTupleConstructorPlan(string name, IEnumerable<RegexCaptureGroupNode> nodes, ExtractionPlanTypeWrapper tupleType)
110 |         {
111 |             var typeArgs = tupleType.GenericArguments;
112 | 
113 |             List<ExtractionPlanNode> groups = new();
114 | 
115 |             foreach (var (node, type, idx) in nodes.Zip(typeArgs, (n, t) => (n,t)).Select(((x,i) => (x.n, x.t, i))))
116 |             {
117 |                 if (idx < 7)
118 |                 {
119 |                     groups.Add(BindConstructorPlan(node, tupleType, idx, typeArgs?.Length ?? 0));
120 |                 }
121 |                 else
122 |                 {
123 |                     groups.Add(BindTupleConstructorPlan(name, nodes.Skip(7), ExtractionPlanTypeWrapper.Wrap(type)));
124 |                 }
125 |             }
126 | 
127 |             return ExtractionPlanNode.Bind(name, tupleType, groups.ToArray(), new ExtractionPlanNode[0]);
128 |         }
129 | 
130 |         private ExtractionPlanNode AssignTypesToTree(RegexCaptureGroupNode tree, ExtractionPlanTypeWrapper type)
131 |         {
132 |             List<ExtractionPlanNode> groups = new();
133 |             List<ExtractionPlanNode> namedgroups = new();
134 | 
135 |             if (tree.children is [] or [{children: []}] && type.IsDirectlyConstructable)
136 |             {
137 |                 // We're at a leaf in the type hierarchy, and all we need is a string.
138 |                 // If there's an inner capture group, use it to narrow the match.
139 |                 if (tree.children.Length == 1)
140 |                 {
141 |                     tree = tree.children.Single();
142 |                 }
143 | 
144 |                 return ExtractionPlanNode.BindLeaf(tree.name, type, groups.ToArray(), namedgroups.ToArray());
145 |             }
146 |             else if (type.IsTuple)
147 |             {
148 |                 return BindTupleConstructorPlan(tree.name, tree.children, type);
149 |             }
150 |             else if (type.IsInitializableCollection)
151 |             {
152 |                 var typeParams = type.GenericArguments;
153 | 
154 |                 if (tree.name == "0")
155 |                 {
156 |                     return AssignTypesToTree(tree.children.Single(), type);
157 |                 }
158 | 
159 |                 if ((typeParams?.Length ?? 0) < 2 && !((typeParams?.Length ?? 0) > 0 && ExtractionPlanTypeWrapper.Wrap(typeParams.First()).IsInitializableCollection))
160 |                 {
161 |                     return ExtractionPlanNode.Bind(tree.name, type, new[] { BindConstructorPlan(tree, type, 0, 1) }, new ExtractionPlanNode[0]);
162 |                 }
163 | 
164 |                 foreach (var node in tree.children)
165 |                 {
166 |                     var plan = BindConstructorPlan(node, type, groups.Count, tree.NumberedGroups.Count());
167 |                     groups.Add(plan);
168 |                 }
169 |                 // TODO: assert that there are no named groups
170 |             }
171 |             else
172 |             {
173 |                 foreach (var node in tree.children)
174 |                 {
175 |                     if (int.TryParse(node.name, out var num))
176 |                     {
177 |                         var plan = BindConstructorPlan(node, type, groups.Count, tree.NumberedGroups.Count());
178 |                         groups.Add(plan);
179 |                     }
180 |                     else
181 |                     {
182 |                         namedgroups.Add(BindPropertyPlan(node, type, node.name));
183 |                     }
184 |                 }
185 |             }
186 | 
187 |             return ExtractionPlanNode.Bind(tree.name, type, groups.ToArray(), namedgroups.ToArray());
188 |         }
189 | 
190 |         public object ToDump() => this;
191 | 
192 |         public override string ToString() =>
193 |             Plan.ShowPlanTree().Replace("\t", "").Replace("\n", "");
194 | 
195 |         public string ToString(string? format) => ToString(format, null);
196 | 
197 |         public string ToString(string? format, IFormatProvider? formatProvider)
198 |         {
199 |             if (format == "x")
200 |                 return Plan.ShowPlanTree() + "\n\n" + _tree?.TreeViz() ?? "";
201 |             else return Plan.ShowPlanTree().Replace("\t", "").Replace("\n", "");
202 |         }
203 |     }
204 | }
205 | 


--------------------------------------------------------------------------------
/RegExtract/ExtractionPlanNodeTypes.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.Linq;
  5 | using System.Reflection;
  6 | using System.Text.RegularExpressions;
  7 | 
  8 | namespace RegExtract.ExtractionPlanNodeTypes
  9 | {
 10 |     internal record UninitializedNode() :
 11 |         ExtractionPlanNode("", ExtractionPlanTypeWrapper.Wrap(typeof(void)), new ExtractionPlanNode[0], new ExtractionPlanNode[0])
 12 |     {
 13 |         internal override object? Execute(Match match, int captureStart, int captureLength, Dictionary<string, (string Value, int Index, int Length)[]> cache)
 14 |         {
 15 |             throw new InvalidOperationException("Extraction plan was not initialized before execution.");
 16 |         }
 17 |     }
 18 | 
 19 |     internal record CollectionInitializerNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters) :
 20 |         ExtractionPlanNode(groupName, type, constructorParams, propertySetters)
 21 |     {
 22 |         internal override object? Execute(Match match, int captureStart, int captureLength, Dictionary<string, (string Value, int Index, int Length)[]> cache)
 23 |         {
 24 |             var genericArgs = type.GenericArguments;
 25 | 
 26 |             // TODO: Create a pre-sized collection
 27 |             var vals = Activator.CreateInstance(type.Type);
 28 |             var addMethod = type.Type.GetMethod("Add");
 29 | 
 30 |             object?[] itemVals = new object[genericArgs?.Length ?? 0];
 31 | 
 32 |             var rangeArray = constructorParams.Select(c => Ranges(match, groupName, captureStart, captureLength, cache).GetEnumerator()).ToArray();
 33 | 
 34 |             do
 35 |             {
 36 |                 for (int i = 0; i < genericArgs?.Length; i++)
 37 |                 {
 38 |                     if (rangeArray[i].MoveNext())
 39 |                     {
 40 |                         itemVals[i] = constructorParams[i].Execute(match, rangeArray[i].Current.Index, rangeArray[i].Current.Length, cache);
 41 |                     }
 42 |                     else
 43 |                     {
 44 |                         goto no_more;
 45 |                     }
 46 |                 }
 47 |                 addMethod.Invoke(vals, itemVals);
 48 |             } while (true);
 49 |             
 50 |         no_more:;
 51 | 
 52 |             foreach (var range in rangeArray)
 53 |             {
 54 |                 range.Dispose();
 55 |             }
 56 | 
 57 |             return vals;
 58 |         }
 59 |     }
 60 | 
 61 |     internal record ConstructTupleNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters) :
 62 |         ExtractionPlanNode(groupName, type, constructorParams, propertySetters)
 63 |     {
 64 |         ConstructorInfo? _constructor = null;
 65 | 
 66 |         ConstructorInfo constructor
 67 |         {
 68 |             get
 69 |             {
 70 |                 if (_constructor != null) return _constructor;
 71 |                 else
 72 |                 {
 73 |                     var wrappedType = type.NonNullableType;
 74 |                     return (_constructor = wrappedType.Type.GetConstructor(wrappedType.Type.GetGenericArguments()));
 75 |                 }
 76 |             }
 77 |         }
 78 | 
 79 |         internal override object? Construct(Match match, ExtractionPlanTypeWrapper type, (string Value, int Index, int Length) range, Dictionary<string, (string Value, int Index, int Length)[]> cache)
 80 |         {
 81 |             type = type.NonNullableType;
 82 |             var constructor = type.Type.GetConstructor(type.Type.GetGenericArguments());
 83 | 
 84 |             return constructor.Invoke(constructorParams.Select(i => i.Execute(match, range.Index, range.Length, cache)).ToArray());
 85 |         }
 86 | 
 87 |         internal override void Validate()
 88 |         {
 89 |             base.Validate();
 90 |         }
 91 |     }
 92 | 
 93 |     internal record ConstructorNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters) :
 94 |         ExtractionPlanNode(groupName, type, constructorParams, propertySetters)
 95 |     {
 96 |         ConstructorInfo? _constructor = null;
 97 | 
 98 |         ConstructorInfo constructor
 99 |         {
100 |             get
101 |             {
102 |                 return _constructor ?? type.Constructors.Where(cons => cons.GetParameters().Length == constructorParams.Length).Single();
103 |             }
104 |         }
105 | 
106 |         internal override object? Construct(Match match, ExtractionPlanTypeWrapper type, (string Value, int Index, int Length) range, Dictionary<string, (string Value, int Index, int Length)[]> cache)
107 |         {
108 |             return constructor.Invoke(constructorParams.Select(i => i.Execute(match, range.Index, range.Length, cache)).ToArray());
109 |         }
110 | 
111 |         internal override void Validate()
112 |         {
113 |             var constructors = type.Constructors
114 |                 .Where(cons => cons.GetParameters().Length == constructorParams.Length);
115 | 
116 |             if (constructors.Count() != 1)
117 |                 throw new InvalidOperationException($"{nameof(ConstructorNode)} has wrong number of constructor params.");
118 | 
119 |             base.Validate();
120 |         }
121 |     }
122 | 
123 |     internal record EnumParseNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters) :
124 |         ExtractionPlanNode(groupName, type, constructorParams, propertySetters)
125 |     {
126 |         internal override object? Construct(Match match, ExtractionPlanTypeWrapper type, (string Value, int Index, int Length) range, Dictionary<string, (string Value, int Index, int Length)[]> cache)
127 |         {
128 |             return Enum.Parse(type.Type, range.Value);
129 |         }
130 |     }
131 | 
132 |     internal record StringConstructorNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters) :
133 |         ExtractionPlanNode(groupName, type, constructorParams, propertySetters)
134 |     {
135 |         ConstructorInfo? _constructor = null;
136 | 
137 |         ConstructorInfo constructor
138 |         {
139 |             get
140 |             {
141 |                 return _constructor ?? (type.NonNullableType.Type.GetConstructor(new[] { typeof(string) }));
142 |             }
143 |         }
144 | 
145 | 
146 |         internal override object? Construct(Match match, ExtractionPlanTypeWrapper type, (string Value, int Index, int Length) range, Dictionary<string, (string Value, int Index, int Length)[]> cache)
147 |         {
148 |             Debug.Assert(type == this.type);
149 |             return constructor.Invoke(new[] { range.Value });
150 |         }
151 | 
152 |         internal override void Validate()
153 |         {
154 |             var constructor = type.NonNullableType.Type.GetConstructor(new[] { typeof(string) });
155 | 
156 |             if (constructor is null || constructorParams.Length != 0)
157 |                 throw new InvalidOperationException($"{nameof(StringConstructorNode)} has wrong type or constructor params.");
158 | 
159 |             base.Validate();
160 |         }
161 |     }
162 | 
163 |     internal record StaticParseMethodNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters) :
164 |         ExtractionPlanNode(groupName, type, constructorParams, propertySetters)
165 |     {
166 |         MethodInfo? _parse = null;
167 | 
168 |         MethodInfo parse
169 |         {
170 |             get
171 |             {
172 |                 return _parse ?? (_parse = type.NonNullableType.Type
173 |                     .GetMethod("Parse",
174 |                             BindingFlags.Static | BindingFlags.Public,
175 |                             null,
176 |                             new Type[] { typeof(string) },
177 |                             null));
178 |             }
179 |         }
180 | 
181 |         internal override object? Construct(Match match, ExtractionPlanTypeWrapper type, (string Value, int Index, int Length) range, Dictionary<string, (string Value, int Index, int Length)[]> cache)
182 |         {
183 |             return parse.Invoke(null, new object[] { range.Value });
184 |         }
185 | 
186 |         internal override void Validate()
187 |         {
188 |             var parse = type.NonNullableType.Type.GetMethod("Parse",
189 |                             BindingFlags.Static | BindingFlags.Public,
190 |                             null,
191 |                             new Type[] { typeof(string) },
192 |                             null);
193 | 
194 |             if (parse is null)
195 |                 throw new InvalidOperationException($"{nameof(StaticParseMethodNode)} has wrong type or constructor params.");
196 | 
197 |             base.Validate();
198 |         }
199 |     }
200 | 
201 |     internal record StringCastNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters) :
202 |         ExtractionPlanNode(groupName, type, constructorParams, propertySetters)
203 |     {
204 |         internal override object? Construct(Match match, ExtractionPlanTypeWrapper type, (string Value, int Index, int Length) range, Dictionary<string, (string Value, int Index, int Length)[]> cache)
205 |         {
206 |             return range.Value;
207 |         }
208 |     }
209 | }
210 | 


--------------------------------------------------------------------------------
/RegExtract/ExtractionPlanNode.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using System.Reflection;
  6 | using System.Text;
  7 | using System.Text.RegularExpressions;
  8 | using RegExtract.ExtractionPlanNodeTypes;
  9 | 
 10 | namespace RegExtract
 11 | {
 12 |     internal record ExtractionPlanNode(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertyNodes)
 13 |     {
 14 |         public string ShowPlanTree()
 15 |         {
 16 |             StringBuilder builder = new();
 17 | 
 18 |             builder.Append(this.GetType().Name.Replace("Node","")).Append("<").Append(string.Join(",",FriendlyTypeName(type.Type))).Append(">[").Append(int.TryParse(groupName, out var _) ? groupName : '"' + groupName + '"').Append("] (");
 19 |             if (constructorParams.Any())
 20 |             {
 21 |                 builder.Append("\n");
 22 |                 builder.Append(string.Join(",\n", constructorParams.Select(param => "\t" + param.ShowPlanTree().Replace("\n", "\n\t"))));
 23 |                 builder.Append("\n)");
 24 |             }
 25 |             else
 26 |             {
 27 |                 builder.Append(")");
 28 |             }
 29 |             if (propertyNodes.Any())
 30 |             {
 31 |                 builder.Append(" {\n");
 32 |                 builder.Append(string.Join(",\n", propertyNodes.Select(param => "\t" + param.groupName + " = " + param.ShowPlanTree().Replace("\n", "\n\t"))));
 33 |                 builder.Append("\n}");
 34 |             }
 35 | 
 36 |             return builder.ToString();
 37 |         }
 38 | 
 39 |         string FriendlyTypeName(Type type)
 40 |         {
 41 |             var keyword = type.Name switch
 42 |             {
 43 |                 "Byte" => "byte",
 44 |                 "SByte" => "sbyte",
 45 |                 "Float" => "float",
 46 |                 "Double" => "double",
 47 |                 "Decimal" => "decimal",
 48 |                 "Int16" => "short",
 49 |                 "UInt16" => "ushort",
 50 |                 "Int32" => "int",
 51 |                 "UInt32" => "uint",
 52 |                 "Int64" => "long",
 53 |                 "UInt64" => "ulong",
 54 |                 "Char" => "char",
 55 |                 "String" => "string",
 56 |                 _ => null
 57 |             };
 58 | 
 59 |             if (keyword is not null) return keyword;
 60 | 
 61 |             if (Nullable.GetUnderlyingType(type) is Type nonNullableType) return FriendlyTypeName(nonNullableType) + "?";
 62 | 
 63 |             var args = type.GetGenericArguments();
 64 | 
 65 |             if (type.FullName.StartsWith(VALUETUPLE_TYPENAME)) return "(" + String.Join(",", args.Select(arg => FriendlyTypeName(arg))) + ")";
 66 | 
 67 |             if (args.Any())
 68 |             {
 69 |                 return type.Name.Split('`')[0] + "<" + String.Join(",", args.Select(arg => FriendlyTypeName(arg))) + ">";
 70 |             }
 71 | 
 72 |             else return type.Name;
 73 |         }
 74 | 
 75 |         internal static ExtractionPlanNode Bind(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters)
 76 |         {
 77 |             var innerType = type.NonNullableType;
 78 | 
 79 |             var multiConstructor = innerType.Constructors
 80 |                 .Where(cons => cons.GetParameters().Length == constructorParams.Length);
 81 | 
 82 |             var staticParseMethod = innerType.Type.GetMethod("Parse",
 83 |                                         BindingFlags.Static | BindingFlags.Public,
 84 |                                         null,
 85 |                                         new Type[] { typeof(string) },
 86 |                                         null);
 87 | 
 88 |             var stringConstructor = innerType.Type.GetConstructor(new[] { typeof(string) });
 89 | 
 90 | 
 91 | 
 92 |             ExtractionPlanNode node;
 93 | 
 94 |             if (type.IsInitializableCollection)
 95 |                 node = new CollectionInitializerNode(groupName, type, constructorParams, propertySetters);
 96 |             else if (innerType.IsTuple)
 97 |                 node = new ConstructTupleNode(groupName, type, constructorParams, propertySetters);
 98 |             else if (multiConstructor.Count() == 1 && (constructorParams.Any() || propertySetters.Any()))
 99 |                 node = new ConstructorNode(groupName, type, constructorParams, propertySetters);
100 |             else if (!constructorParams.Any() && !propertySetters.Any() && stringConstructor != null)
101 |                 node = new StringConstructorNode(groupName, type, new ExtractionPlanNode[0], new ExtractionPlanNode[0]);
102 |             else
103 |                 throw new ArgumentException("Couldn't find appropriate constructor for type.");
104 | 
105 |             node.Validate();
106 | 
107 |             return node;
108 |         }
109 | 
110 |         internal static ExtractionPlanNode BindLeaf(string groupName, ExtractionPlanTypeWrapper type, ExtractionPlanNode[] constructorParams, ExtractionPlanNode[] propertySetters)
111 |         {
112 |             var innerType = type.NonNullableType;
113 | 
114 |             var staticParseMethod = innerType.Type.GetMethod("Parse",
115 |                                         BindingFlags.Static | BindingFlags.Public,
116 |                                         null,
117 |                                         new Type[] { typeof(string) },
118 |                                         null);
119 | 
120 |             var stringConstructor = innerType.Type.GetConstructor(new[] { typeof(string) });
121 | 
122 | 
123 | 
124 |             ExtractionPlanNode node;
125 | 
126 |             if (innerType.IsTuple)
127 |                 throw new ArgumentException("Tuple in type cannot be bound to leaf of regex capture group tree.");
128 |             else if (staticParseMethod is not null)
129 |                 node = new StaticParseMethodNode(groupName, type, constructorParams, propertySetters);
130 |             else if (stringConstructor is not null)
131 |                 node = new StringConstructorNode(groupName, type, constructorParams, propertySetters);
132 |             else if (innerType.Type.BaseType == typeof(Enum))
133 |                 node = new EnumParseNode(groupName, type, constructorParams, propertySetters);
134 |             else
135 |                 node = new StringCastNode(groupName, type, constructorParams, propertySetters);
136 | 
137 |             node.Validate();
138 | 
139 |             return node;
140 |         }
141 | 
142 | 
143 |         internal virtual void Validate()
144 |         {
145 |             return;
146 |         }
147 | 
148 |         internal virtual object? Construct(Match match, ExtractionPlanTypeWrapper type, (string Value, int Index, int Length) range, Dictionary<string, (string Value, int Index, int Length)[]> cache)
149 |         {
150 |             throw new InvalidOperationException("Can't construct a node based on base ExtractionPlanNode type.");
151 |         }
152 | 
153 |         protected IEnumerable<(string Value, int Index, int Length)> Ranges(Match match, string groupName, int captureStart, int captureLength, Dictionary<string, (string Value, int Index, int Length)[]> cache)
154 |         {
155 |             if (!cache.ContainsKey(groupName))
156 |             {
157 |                 cache[groupName] = AsEnumerable(match.Groups[groupName].Captures)
158 |                     .Select(cap => (cap.Value, cap.Index, cap.Length))
159 |                     .ToArray();
160 |             }
161 |             return cache[groupName].Where(cap => cap.Index >= captureStart && cap.Index + cap.Length <= captureStart + captureLength);
162 |         }
163 | 
164 |         internal virtual object? Execute(Match match, int captureStart, int captureLength, Dictionary<string, (string Value, int Index, int Length)[]> cache)
165 |         {
166 |             object? result = null;
167 | 
168 |             var ranges = Ranges(match, groupName, captureStart, captureLength, cache).ToArray();
169 | 
170 |             if (!ranges.Any())
171 |             {
172 |                 if (type.Type.IsClass || Nullable.GetUnderlyingType(type.Type) != null) return null;
173 |                 else return Convert.ChangeType(null, type.Type);
174 |             }
175 |             else
176 |             {
177 |                 var lastRange = ranges.Last();
178 | 
179 |                 result = Construct(match, type.NonNullableType, lastRange, cache);
180 | 
181 |                 if (result is not null)
182 |                 {
183 |                     foreach (var prop in propertyNodes)
184 |                     {
185 |                         result.GetType().GetProperty(prop.groupName).GetSetMethod().Invoke(result, new[] { prop.Execute(match, lastRange.Index, lastRange.Length, cache) });
186 |                     }
187 |                 }
188 |             }
189 | 
190 |             return result;
191 |         }
192 | 
193 |         internal object? Execute(Match match)
194 |         {
195 |             if (!match.Success)
196 |             {
197 |                 throw new ArgumentException("Regex didn't match.");
198 |             }
199 | 
200 |             Dictionary<string, (string Value, int Index, int Length)[]> cache = new();
201 | 
202 |             return Execute(match, match.Groups[0].Index, match.Groups[0].Length, cache);
203 |         }
204 | 
205 |         protected const string VALUETUPLE_TYPENAME = "System.ValueTuple`";
206 |         protected const string NULLABLE_TYPENAME = "System.Nullable`";
207 | 
208 |         protected static IEnumerable<Capture> AsEnumerable(CaptureCollection cc)
209 |         {
210 |             foreach (Capture c in cc)
211 |             {
212 |                 yield return c;
213 |             }
214 |         }
215 |     }
216 | }
217 | 


--------------------------------------------------------------------------------
/RegExtract/RegexCaptureGroupTree.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Diagnostics;
  4 | using System.Linq;
  5 | using System.Text;
  6 | using System.Text.RegularExpressions;
  7 | 
  8 | namespace RegExtract.RegexTools
  9 | {
 10 |     internal record RegexCaptureGroupNode(string name, RegexCaptureGroupNode[] children, ((int start, int length) range, string text) substring)
 11 |     {
 12 |         public IEnumerable<RegexCaptureGroupNode> NamedGroups => children.Where(node => !int.TryParse(node.name, out var _));
 13 |         public IEnumerable<RegexCaptureGroupNode> NumberedGroups => children.Where(node => int.TryParse(node.name, out var _));
 14 |     }
 15 | 
 16 |     internal class RegexCaptureGroupTree
 17 |     {
 18 |         public List<string> Groups { get; private set; } = new() { "0" };
 19 | 
 20 |         public Regex Regex { get; private set; }
 21 |         private string _regexString;
 22 | 
 23 |         public RegexCaptureGroupNode Tree { 
 24 |             get
 25 |             {
 26 |                 if (_tree is null)
 27 |                 {
 28 |                     InitializeTree();
 29 |                 }
 30 |                 return _tree!;
 31 |             }
 32 |             private set
 33 |             {
 34 |                 _tree = value;
 35 |             }
 36 |         }
 37 |         private RegexCaptureGroupNode? _tree;
 38 | 
 39 |         public RegexCaptureGroupTree(Regex rx)
 40 |         {
 41 |             Regex = rx;
 42 |             _regexString = rx.ToString();
 43 |             InitializeTree();
 44 |         }
 45 | 
 46 |         public RegexCaptureGroupTree(string rx) : this(new Regex(rx))
 47 |         {
 48 |             _regexString = rx;
 49 |         }
 50 | 
 51 |         private void InitializeTree()
 52 |         {
 53 |             int loc = 0, num = 0;
 54 |             Tree = BuildCaptureGroupTree(ref loc, ref num, 0);
 55 |         }
 56 | 
 57 |         private RegexCaptureGroupNode BuildCaptureGroupTree(ref int loc, ref int num, int start, string? name = null)
 58 |         {
 59 |             string myname = name ?? num.ToString();
 60 |             List<RegexCaptureGroupNode> children = new();
 61 | 
 62 |             int charGroupLevels = 0;
 63 |             bool escape = false;
 64 |             int nameStart = -1;
 65 |             int ignoreGroups = 0;
 66 |             char openchar = ' ';
 67 |             int groupStart = 0;
 68 | 
 69 |             for (; loc < _regexString.Length; loc++)
 70 |             {
 71 |                 if (escape)
 72 |                 {
 73 |                     escape = false;
 74 |                     continue;
 75 |                 }
 76 |                 if (nameStart != -1)
 77 |                 {
 78 |                     if ((openchar == '<' && _regexString[loc] == '>') || (openchar == '\'' && _regexString[loc] == '\''))
 79 |                     {
 80 |                         loc++;
 81 |                         var parsedName = _regexString.Substring(nameStart, loc - nameStart - 1);
 82 |                         Groups.Add(parsedName);
 83 |                         children.Add(BuildCaptureGroupTree(ref loc, ref num, groupStart, _regexString.Substring(nameStart, loc - nameStart - 1)));
 84 |                         nameStart = -1;
 85 |                         continue;
 86 |                     }
 87 |                     else if (!char.IsLetterOrDigit(_regexString[nameStart]) && _regexString[loc] != '_') throw new Exception("Group Name must be a valid C identifier.");
 88 |                 }
 89 |                 if (charGroupLevels > 0)
 90 |                 {
 91 |                     if (_regexString[loc] == '\\')
 92 |                     {
 93 |                         escape = true;
 94 |                         continue;
 95 |                     }
 96 |                     if (_regexString[loc] == '-' && _regexString[loc + 1] == '[')
 97 |                     {
 98 |                         loc += 2;
 99 |                         if (_regexString[loc] == '^') loc++;
100 |                         if (_regexString[loc] == '\\') escape = true;
101 |                         charGroupLevels++;
102 |                         continue;
103 |                     }
104 |                     else if (_regexString[loc] == ']') charGroupLevels--;
105 |                     continue;
106 |                 }
107 | 
108 |                 switch (_regexString[loc])
109 |                 {
110 |                     case '\\':
111 |                         escape = true;
112 |                         break;
113 |                     case '(':
114 |                         groupStart = loc;
115 |                         if (_regexString[loc + 1] == '?')
116 |                         {
117 |                             // ? may be followed by lookbehind (which starts out looking like a <> named group) or something that's clearly not a named group
118 |                             if ((_regexString[loc + 2] == '<' && (_regexString[loc + 3] == '=' || _regexString[loc + 3] == '!')) || (_regexString[loc + 2] != '<' && _regexString[loc + 2] != '\''))
119 |                             {
120 |                                 ignoreGroups++;
121 |                                 continue;
122 |                             }
123 |                             // otherwise, it's a named group
124 |                             else
125 |                             {
126 |                                 openchar = _regexString[loc + 2];
127 |                                 loc += 3;
128 |                                 nameStart = loc;
129 |                                 if (!char.IsLetter(_regexString[nameStart]) && _regexString[nameStart] != '_') throw new Exception("Group Name must be a valid C identifier.");
130 |                             }
131 |                         }
132 |                         else
133 |                         {
134 |                             num++;
135 |                             loc++;
136 |                             Groups.Add(num.ToString());
137 |                             children.Add(BuildCaptureGroupTree(ref loc, ref num, groupStart));
138 |                         }
139 |                         break;
140 |                     case ')':
141 |                         if (ignoreGroups > 0)
142 |                         {
143 |                             ignoreGroups--;
144 |                             continue;
145 |                         }
146 |                         else
147 |                         {
148 |                             if (myname == "0") throw new Exception("Too many close parens.");
149 |                             if (loc + 1 < _regexString.Length)
150 |                             {
151 |                                 if (_regexString[loc + 1] is '?' or '+' or '*')
152 |                                 {
153 |                                     loc++;
154 |                                     if (loc + 1 < _regexString.Length && _regexString[loc + 1] is '?')
155 |                                         loc++;
156 |                                 }
157 |                                 else if (_regexString[loc + 1] is '{')
158 |                                 {
159 |                                     var startloc = loc;
160 |                                     var quantifierState = 0;
161 |                                     loc ++;
162 |                                     while (loc < _regexString.Length - 1 && quantifierState >= 0)
163 |                                     {
164 |                                         loc++;
165 |                                         switch (quantifierState, _regexString[loc])
166 |                                         {
167 |                                             case (0, >= '0' and <= '9'):
168 |                                                 quantifierState = 1;
169 |                                                 break;
170 |                                             case (1 or 2, >= '0' and <= '9'):
171 |                                                 break;
172 |                                             case (1, ','):
173 |                                                 quantifierState = 2;
174 |                                                 break;
175 |                                             case (1 or 2, '}'):
176 |                                                 quantifierState = 3;
177 |                                                 break;
178 |                                             default:
179 |                                                 quantifierState = -1;
180 |                                                 break;
181 |                                         }
182 | 
183 |                                         if (quantifierState == 3)
184 |                                         {
185 |                                             if (loc < _regexString.Length - 1 && _regexString[loc + 1] is '?')
186 |                                                 loc++;
187 | 
188 |                                             break;
189 |                                         }
190 |                                         else if (loc >= _regexString.Length - 1 || quantifierState == -1)
191 |                                         {
192 |                                             loc = startloc;
193 |                                             break;
194 |                                         }
195 |                                     }
196 |                                 }
197 |                             }
198 |                             return new RegexCaptureGroupNode(myname, children.ToArray(), ((start, loc - start + 1),_regexString.Substring(start, loc - start + 1)));
199 |                         }
200 |                     case '[':
201 |                         loc++;
202 |                         if (_regexString[loc] == '^') loc++;
203 |                         if (_regexString[loc] == '\\') escape = true;
204 |                         charGroupLevels++;
205 |                         break;
206 |                     default:
207 |                         break;
208 |                 }
209 |             }
210 | 
211 |             // TODO: These should probably be asserts, because Regex has validated everything after constructor is complete.
212 |             if (loc > _regexString.Length) throw new Exception("Parser over-ran end of regex string.");
213 |             if (myname != "0") throw new Exception("Not enough close parens.");
214 |             if (charGroupLevels > 0) throw new Exception("Unterminated char group.");
215 | 
216 |             Groups = Groups.OrderBy(name => int.TryParse(name, out var _) ? 0 : 1).ToList();
217 |             Debug.Assert(Groups.Zip(Regex.GetGroupNames(), (a,b) => a == b).All(b => b), "Group List doesn't match Regex.GetGroupNames()");
218 | 
219 |             return new RegexCaptureGroupNode(myname, children.ToArray(), ((start, loc - start), _regexString.Substring(start, loc - start)));
220 |         }
221 | 
222 |         string IntToSubscripts(int i)
223 |         {
224 |             List<char> digits = new();
225 | 
226 |             do
227 |             {
228 |                 digits.Add((i % 10) switch
229 |                 {
230 |                     0 => '₀',
231 |                     1 => '₁',
232 |                     2 => '₂',
233 |                     3 => '₃',
234 |                     4 => '₄',
235 |                     5 => '₅',
236 |                     6 => '₆',
237 |                     7 => '₇',
238 |                     8 => '₈',
239 |                     9 => '₉',
240 |                     _ => throw new InvalidOperationException("That's impossible!")
241 |                 });
242 |                 i /= 10;
243 |             } while (i > 0);
244 | 
245 |             digits.Reverse();
246 |             return string.Join("", digits);
247 |         }
248 | 
249 |         public string TreeViz() => String.Join("\n",TreeViz(Tree));
250 | 
251 |         string[] TreeViz(RegexCaptureGroupNode tree)
252 |         {
253 |             var line = tree.substring.text;
254 | 
255 |             var tag = int.TryParse(tree.name, out var num) ? IntToSubscripts(num) : "";
256 | 
257 |             char[] pad;
258 |             string[] results;
259 | 
260 |             if (!tree.children.Any())
261 |             {
262 |                 var solo = $"{line}{tag}";
263 |                 results = new[] { solo };
264 | 
265 |                 return results;
266 |             }
267 |             else
268 |             {
269 |                 var left = tree.substring.range.start;
270 |                 var right = tree.substring.range.start + tree.substring.range.length;
271 | 
272 |                 var blocks = tree.children.Select(child => TreeViz(child)).ToArray();
273 |                 var longestblock = blocks.Max(block => block.Length);
274 | 
275 |                 for (int i = 0; i < blocks.Length; i++)
276 |                 {
277 |                     if (blocks[i].Length != longestblock)
278 |                     {
279 |                         var blockline = new char[blocks[i][0].Length];
280 |                         for (int j = 0; j < blockline.Length; j++) blockline[j] = ' ';
281 | 
282 |                         var newblock = new string[longestblock];
283 |                         for (int j = 0; j < newblock.Length; j++)
284 |                         {
285 |                             if (j < blocks[i].Length) newblock[j] = blocks[i][j];
286 |                             else newblock[j] = string.Join("", blockline);
287 |                         }
288 | 
289 |                         blocks[i] = newblock;
290 |                     }
291 |                 }
292 | 
293 |                 var widths = blocks.Select(block => block[0].Length);
294 | 
295 |                 results = new string[blocks[0].Length];
296 | 
297 |                 pad = new char[tree.children[0].substring.range.start - left];
298 |                 for (int j = 0; j < pad.Length; j++) pad[j] = ' ';
299 | 
300 |                 for (int i = 0; i < results.Length; i++)
301 |                 {
302 |                     results[i] = string.Join("", pad);
303 |                 }
304 | 
305 |                 for (int i = 0; i < blocks.Length; i++)
306 |                 {
307 |                     var nextstart = i == blocks.Length - 1 ? right : tree.children[i + 1].substring.range.start;
308 |                     pad = new char[nextstart - (tree.children[i].substring.range.start + tree.children[i].substring.range.length)];
309 |                     for (int j = 0; j < pad.Length; j++) pad[j] = ' ';
310 | 
311 |                     for (int j = 0; j < blocks[0].Length; j++)
312 |                     {
313 |                         results[j] += blocks[i][j];
314 |                         results[j] += string.Join("", pad);
315 |                     }
316 |                 }
317 | 
318 |                 var topline = tree.substring.text.Substring(0, tree.children[0].substring.range.start - left);
319 |                 for (int i = 0; i < blocks.Length; i++)
320 |                 {
321 |                     pad = new char[blocks[i][0].Length];
322 |                     for (int j = 0; j < pad.Length; j++) pad[j] = '-';
323 |                     pad[0] = pad[pad.Length - 1] = '↓';
324 |                     topline += string.Join("", pad);
325 |                     var subleft = tree.children[i].substring.range.start + tree.children[i].substring.range.length;
326 |                     topline += tree.substring.text.Substring(subleft - left, i == blocks.Length - 1 ? right - subleft : tree.children[i + 1].substring.range.start - subleft);
327 |                 }
328 | 
329 |                 pad = new char[tag.Length];
330 |                 for (int j = 0; j < pad.Length; j++) pad[j] = ' ';
331 | 
332 |                 results = new[] { $"{topline}{tag}" }.Concat(results.Select(result => result + string.Join("", pad))).ToArray();
333 | 
334 |                 return results;
335 |             }
336 |         }
337 |     }
338 | }
339 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # RegExtract
  2 | Quick and dirty idiomatic C# line parser that extracts text into practical data types.
  3 | 
  4 | [![dotnet](https://github.com/sblom/RegExtract/workflows/dotnet/badge.svg)](https://github.com/sblom/RegExtract/actions)
  5 | [![NuGet](https://img.shields.io/nuget/v/RegExtract.svg)](https://www.nuget.org/packages/RegExtract/)
  6 | [![Downloads](https://img.shields.io/nuget/dt/RegExtract.svg)](https://www.nuget.org/packages/RegExtract/)
  7 | [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  8 | 
  9 | ## Table of Contents
 10 | - [RegExtract](#regextract)
 11 |   - [Table of Contents](#table-of-contents)
 12 |   - [Release History (newest first)](#release-history-newest-first)
 13 | - [Using RegExtract](#using-regextract)
 14 |   - [Basic extraction to `ValueTuple`](#basic-extraction-to-valuetuple)
 15 |   - [Extracting from multiple input strings (`IEnumerable<string>`)](#extracting-from-multiple-input-strings-ienumerablestring)
 16 |   - [Extracting to collections (such as `List<T>`)](#extracting-to-collections-such-as-listt)
 17 |   - [Nullable types](#nullable-types)
 18 |   - [Nesting compound types (such as tuples) and collections](#nesting-compound-types-such-as-tuples-and-collections)
 19 |     - [Tuple that contains Collections](#tuple-that-contains-collections)
 20 |     - [Collection that contains a tuple](#collection-that-contains-a-tuple)
 21 |     - [Collection that contains a collection](#collection-that-contains-a-collection)
 22 |   - [Collections with more than one argument (including `Dictionary<,>`)](#collections-with-more-than-one-argument-including-dictionary)
 23 |   - [`record`s and other compound types](#records-and-other-compound-types)
 24 |   - [Extracting named capture groups to properties](#extracting-named-capture-groups-to-properties)
 25 |   - [Other supported types](#other-supported-types)
 26 |   - [Including REGEXTRACT\_REGEX\_PATTERN templates on types](#including-regextract_regex_pattern-templates-on-types)
 27 | - [Performance and troubleshooting](#performance-and-troubleshooting)
 28 |   - [Creating a re-usable `ExtractionPlan`](#creating-a-re-usable-extractionplan)
 29 |   - [Inspecting an extraction plan](#inspecting-an-extraction-plan)
 30 | - [Regular Expression reference](#regular-expression-reference)
 31 | - [History](#history)
 32 | 
 33 | ## Release History (newest first)
 34 | 
 35 | |Release Number |Release Date | Main Features |
 36 | |--|--|--|
 37 | | 3.0 | FUTURE ROADMAP | Source Generator support to eliminate run-time reflection
 38 | | 2.1 | December 15, 2023 | Added caching for up to 6x speedup<br>Made tuples less magic |
 39 | | 2.0 | December 14, 2023 | Rewrote planning engine with better Collections support |
 40 | | 1.0 | December 20, 2020 | First modern release with tree-based extraction planner |
 41 | | 0.9 | early December 2020 | Pre-release prototypes |
 42 | <details>
 43 | <summary>History of pre-release versions</summary>
 44 | 
 45 | |Release Number |Release Date | Main Features |
 46 | |--|--|--|
 47 | | 0.9.24 | December 2020 | Extraction planner fully operational |
 48 | | 0.9.19 | December 2020 | Prototype extraction planner to support nested types |
 49 | | 0.9.16 | December 2020 | Add support for REGEXTRACT_REGEX_PATTERN templates |
 50 | | 0.9.11 | December 2020 | Add support for Enums |
 51 | | 0.9.10 | December 2020 | More support for Lists |
 52 | | 0.9.6 | December 2020 | Add support for Lists and Nullables |
 53 | | 0.9.4 | December 2020 | Add support for named capture groups initializing properties |
 54 | | 0.9.2 | December 2020 | Add positional records |
 55 | | 0.9 | December 2020 | Extract capture groups to tuples, and that's all |
 56 | 
 57 | </details>
 58 | 
 59 | # Using RegExtract
 60 | 
 61 | ## Basic extraction to `ValueTuple`
 62 | 
 63 | Let's say you have a string `2-10 c: abcdefghi`, consisting of a two `int`s separated by a dash (-), a `char` followed by a colon (:), and a `string`.
 64 | 
 65 | You could use the regular expression `@"(\d+)-(\d+) (.): (.*)"` to extract that into a tuple `(int min, int max, char ch, string str)`.
 66 | Or you could use `@"((\d+)-(\d+)) (.): (.*)"` to extract into a nested tuple `((int min, int max) range, char ch, string str)`. 
 67 | 
 68 | > [!TIP]
 69 | > If you need a primer on helpful regular expression syntax, see the [Regular Expression Examples](#regular-expression-examples) section below.
 70 | 
 71 | In C# code, those two examples would look like:
 72 | 
 73 | ```cs
 74 | using RegExtract;
 75 | 
 76 | var input = "2-10 c: abcdefghi";
 77 | 
 78 | var flat_tuple   = input.Extract<( int min, int max,        char ch, string str)>(@"(\d+)-(\d+) (.): (.*)");
 79 | var nested_tuple = input.Extract<((int min, int max) range, char ch, string str)>(@"((\d+)-(\d+)) (.): (.*)");
 80 | ```
 81 | 
 82 | > [!NOTE]
 83 | > The nesting of your capture groups (parts wrapped in `()`) in your regular expression must match the nesting of your type hierarchy.
 84 | 
 85 | ## Extracting from multiple input strings (`IEnumerable<string>`)
 86 | 
 87 | There are many variations on RegExtract extension methods, but there are two that you will use most often.
 88 | The first one is the `.Extract<T>()` method demonstrated above.
 89 | It's an extension method on `string`, and returns a single fully constructed instance of your type hierarchy `T`.
 90 | The other one is very similar, but it accepts any `IEnumerable<string>`.
 91 | 
 92 | Here's an example of using the `IEnumerable<string>` extension method:
 93 | 
 94 | ```cs
 95 | using RegExtract;
 96 | 
 97 | var inputs = new[] {
 98 |   "2-10 c: abcdefghi",
 99 |   "3-7 e: qwertyuiop"
100 | };
101 | 
102 | IEnumerable<(int,int,char,string)> results = 
103 |     inputs.Extract<( int min, int max, char ch, string str)>(@"(\d+)-(\d+) (.): (.*)");
104 | ```
105 | 
106 | Notice that the actual `.Extract<>()` call looks nearly identical to the version that takes a single `string`.
107 | This makes it trivial to switch between extracting a single instance and extracting from each string in an `IEnumerable<string>`.
108 | 
109 | > [!TIP]
110 | > These are the two most common RegExtract methods to use, but if you're going to be using the same extraction plan multiple times, you should first [create a reusable `ExtractionPlan`](#creating-a-re-usable-extractionplan), so that RegExtract only has to parse your regular expression and type hierarchy once.
111 | 
112 | ## Extracting to collections (such as `List<T>`)
113 | 
114 | In addition to arbitrarily long `ValueTuple`s as demonstrated above, RegExtract supports any collection type that works with [C#'s Collection Initializer syntax](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/object-and-collection-initializers#collection-initializers) (commonly `List<>`, `HashSet<>`, and `Dictionary<,>`).
115 | 
116 | > [!TIP]
117 | > C# collection initializers work with *any collection type that implements `IEnumerable` [the non-generic one, in particular] and has Add with the appropriate signature*.
118 | 
119 | To extract a list, you should include a capture group in your regular expression that repeats.
120 | For example, to break a sentence up into individual words, you can do something like:
121 | 
122 | ```cs
123 | using RegExtract;
124 | 
125 | var input = "The quick brown fox jumps over the lazy dog.";
126 | 
127 | var words_with_trailing_spaces = input.Extract<List<string>>(@"(\w+ ?)+");
128 | var words_without_spaces       = input.Extract<List<string>>(@"((\w+) ?)+");
129 | ```
130 | 
131 | Notice in the first example (`words_with_trailing_spaces`), there is only one capture group, and everything inside it is treated as part of the match.
132 | As a result, the strings in the List include trailing spaces (except for "dog", which stopped matching before the trailing period (.)).
133 | 
134 | In the second example (`words_without_spaces`), an optional final set of parens was included immediately around `\w+`.
135 | As a result, the strings in the second list will only include the words themselves without trailing spaces.
136 | 
137 | > [!NOTE]
138 | > As illustrated by the `words_without_spaces` example, you can always optionally include an extra capture group to capture only a relevant subpart inside the repeating capture group of any **Collection** type.
139 | >
140 | > This is useful if the repeated capture group includes optional separators such as spaces, commas, semicolons, etc., and it allows you to include only the interesting part without the separator.
141 | 
142 | ## Nullable types
143 | 
144 | Any time a type hierarchy expects a value but there's no corresponding Capture (because of an optional capture group, for example), RegExtract considers the extracted value to be `null`.
145 | For reference types, this works exactly how you'd expect.
146 | For value types, you'll get an `InvalidCastException ("Null object cannot be converted to a value type.")` unless you have marked the value type as nullable in your type hierarchy.
147 | 
148 | > [!NOTE]
149 | > Collection types will always be constructed and will never be extracted as a `null`.
150 | > Unlike missing Captures for non-collection values, that there are no matches, it will simply be empty.
151 | 
152 | An example of extracting to a nullable type (or not):
153 | 
154 | ```csharp
155 | using RegExtract;
156 | 
157 | // This will succeed because int? can be null.
158 | var nullable     = "".Extract<int?>(@"(\d+)");
159 | //                               ^Nullable
160 | 
161 | // This will throw an exception because \d+ doesn't match anything
162 | // and the int value is required by the type system.
163 | var not_nullable = "".Extract<int >(@"(\d+)");
164 | //                               ^Not nullable
165 | ```
166 | 
167 | > [!TIP]
168 | > You can use nullable types in combination with the regular expression alternation operator (`|`) to extract to a different type depending on the details of the match.
169 | 
170 | An example of using nullable types to support regular expression alternation (`|`):
171 | ```csharp
172 | var (n,s) = "str".Extract<(int?,string)>(@"(\d+)|(.*)");
173 | ```
174 | 
175 | ## Nesting compound types (such as tuples) and collections
176 | 
177 | You'll frequently find that you need to nest a **compound type** (such as a tuple) inside a **collection** or that you need to nest a **collection** inside a **compound type**.
178 | RegExtract can handle arbitrarily deeply nested mixes of any supported data types.
179 | 
180 | ### Tuple that contains Collections
181 | ```csharp
182 | using RegExtract;
183 | 
184 | var input = "Item #1: 27 61 49 58 44 2 69 78";
185 | 
186 | var result = input.Extract<(int itemno, HashSet<int> set)>(@"Item #(\d+): (\d+ ?)+");
187 | ```
188 | 
189 | > [!TIP]
190 | > As you can see in this examples, a `HashSet<>` works just like a `List<>`. 
191 | 
192 | ### Collection that contains a tuple
193 | ```csharp
194 | using RegExtract;
195 | 
196 | var input = "red 10, blue 25, green 12, yellow 19";
197 | 
198 | var result = input.Extract<List<(string color, int count)>>(@"((\w+) (\d+),? ?)+");
199 | ```
200 | 
201 | ### Collection that contains a collection
202 | ```csharp
203 | using RegExtract;
204 | 
205 | var input = "The quick brown fox jumps over the lazy dog";
206 | 
207 | var result = input.Extract<List<List<char>>>(@"((\w)+ ?)+");
208 | ```
209 | 
210 | ## Collections with more than one argument (including `Dictionary<,>`)
211 | 
212 | C# collection initializers will work with `.Add()` methods that take more than one parameter, such as the `.Add(TKey key, TValue value)` that `Dictionary<,>` implements.
213 | RegExtract doesn't have the benefit of inferring generic type arguments from examples of parameters, however, since everything is a `string` before extraction.
214 | So, instead, RegExtract will only consider an `.Add()` method whose parameter types match the generic arguments `TKey` and `TValue`.
215 | 
216 | Example using a `Dictionary<string,int>`:
217 | ```csharp
218 | using RegExtract;
219 | 
220 | var input = "red 10, blue 25, green 12, yellow 19";
221 | 
222 | var result = input.Extract<Dictionary<string, int>>(@"((\w+) (\d+),? ?)+");
223 | ```
224 | 
225 | > [!TIP]
226 | > RegExtract doesn't yet support having, for example, a capture group with the `value` before the `key`.
227 | > (They have to be in the order that the collection's `.Add()` method expects them.)
228 | > 
229 | > You can work around this by capturing to a `List<(TValue value, TKey key)>` and then using `list.ToDictionary(vk => vk.key, vk => vk.Value)` to convert to a `Dictionary<,>` that's organized the way you want.
230 | 
231 | 
232 | ## `record`s and other compound types
233 | 
234 | You can build almost anything you need using `ValueTuple`s and `List<>`s, and for simple, ad hoc scenarios that's often where I begin and end.
235 | 
236 | However, when it comes time to extract inputs to more richly modeled types, you'll use RegExtract's support for types such as `record`s that have a single obvious constructor (some might say a [primary constructor!](https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/instance-constructors#primary-constructors)) with the number of parameters corresponding to the number of capture groups in your regular expression.
237 | (Strictly speaking, it doesn't have to be a record, and you don't have to use primary constructor syntax&mdash;absolutely any type with a constructor of the right shape is fine.)
238 | 
239 | > [!INFO]
240 | > For custom compound types such as `record`s or `struct`s or `class`es, RegExtract looks for a single public constructor that takes the same number of arguments as the number of capture groups nested inside the compound type's capture group.
241 | >
242 | > It then uses the types of the constructor arguments to determine what types to construct for the nested capture groups.
243 | 
244 | Here's an example using a couple of nested `record` types and `List`s:
245 | ```csharp
246 | using RegExtract;
247 | 
248 | var input = "Game 14: 9 green, 4 red; 6 blue, 1 red, 7 green; 3 blue, 5 green";
249 | 
250 | var game = input.Extract<Game>(@"Game (\d+): (((\d+) (\w+),? ?)+;? ?)+");
251 | 
252 | record Game(int id, List<Draw> draws);
253 | record Draw(List<(int count, string color)> colors);
254 | ```
255 | 
256 | ## Extracting named capture groups to properties
257 | 
258 | All of the examples of compound types so far make use of constructors with positional semantics.
259 | RegExtract uses typical (non-named) capture groups as parameters destined for a tuple slot or a constructor parameter.
260 | 
261 | Regular expressions also support named capture groups.
262 | They look like `(?<name>pattern_goes_here)`.
263 | When RegExtract encounters a named capture group, the captures from it are used to call a property setter on the type being extracted after the type is fully constructed from (non-named) positional capture groups.
264 | 
265 | A simple example:
266 | ```csharp
267 | using RegExtract;
268 | 
269 | var input = 
270 | 
271 | var result = input.Extract<template>(@"(?<lo>\d+)-(?<hi>\d+) (?<ch>.): (?<pwd>.*)");
272 | 
273 | class template {
274 |     public int lo { get; set; }
275 |     public int hi { get; set; }
276 |     public char ch { get; set; }
277 |     public string pwd { get; set; }
278 | }
279 | ```
280 | 
281 | A more complex example that mixes positional (constructor) parameters with properties set by named captures:
282 | ```csharp
283 | var input = "faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.";
284 | 
285 | var result = input.Extract<BagDescription>(@"^(.+) bags contain(?<contents> (?<num>\d+) (?<type>.*?) bags?[,.])+$");
286 | 
287 | result.Dump();
288 | 
289 | // Notice that name is a constructor parameter, and
290 | // is set by a capture group without a name, specifically `(.+)`.
291 | record BagDescription(string name)
292 | {
293 |     // On the other hand, contents is set by the named capture group `(?<contents>...)`.
294 |     public List<IncludedBags> contents {get;set;}
295 | };
296 | 
297 | // More properties set by named capture groups.
298 | record IncludedBags
299 | {
300 |     public int? num { get; set; }
301 |     public string type { get; set; }
302 | }
303 | ```
304 | 
305 | ## Other supported types
306 | 
307 | In addition to tuples, custom compound types, and collections as discussed above, *all of .NET's primitive types* are supported, as well as any `Enum`, any type that implements a static `.Parse(string)` method, and, as a last resort, any type with a public constructor that takes a single string as its only parameter.
308 | 
309 | > [!TIP]
310 | > In fact, .NET's primitive types aren't really special to RegExtract&mdash;they're simply examples of types that implement a static `.Parse(string)` method.
311 | 
312 | A couple of Enum examples:
313 | ```csharp
314 | var mode = "OpenOrCreate".Extract<FileMode>(@".*");
315 | var flags = "Public,Static".Extract<BindingFlags>(".*");
316 | ```
317 | 
318 | ## Including REGEXTRACT_REGEX_PATTERN templates on types
319 | You can set a default RegExtract regular expression pattern on a compound type to enable RegExtract to know how to extract the type without passing the regular expression pattern as an argument to `.Extract<>()`.
320 | 
321 | You do this by placing a `public const string REGEXTRACT_REGEX_PATTERN` on the type.
322 | You can also set default regular expression options by setting `public const string REGEXTRACT_REGEX_OPTIONS`.
323 | 
324 | For example:
325 | ```csharp
326 | using RegExtract;
327 | 
328 | var result = "add -12".Extract<WithTemplate>();
329 | 
330 | record WithTemplate(string op, int arg)
331 | {
332 |     public const string REGEXTRACT_REGEX_PATTERN = @"(\S+) ([+-]?\d+)";
333 |     public const RegexOptions REGEXTRACT_REGEX_OPTIONS = RegexOptions.None;
334 | }
335 | ```
336 | 
337 | # Performance and troubleshooting
338 | 
339 | ## Creating a re-usable `ExtractionPlan`
340 | RegExtract spends some upfront time parsing regular expressions and inspecting your type hierarchy using reflection.
341 | Reflection in particular is notorious for being slow.
342 | 
343 | If you're going to be doing the same extraction repeatedly, you can have RegExtract do all of this work upfront.
344 | 
345 | Your approach should be to first create an `ExtractionPlan` that knows the regular expression and type hierarchy that it will be using to do its extraction.
346 | You can then use this `ExtractionPlan` instead of a regex pattern or Regex.
347 | 
348 | Example:
349 | ```csharp
350 | var plan = ExtractionPlan<((int, int), char, string)>.CreatePlan(new Regex(@"((\d+)-(\d+)) (.): (.*)"));
351 | "2-12 c: abcdefg".Extract(plan);
352 | ```
353 | 
354 | > [!INFO]
355 | > Note that `CreatePlan` takes a `Regex` instead of the string that we've been using throughout the examples in this documentation.
356 | >
357 | > Every call to `.Extract()` that you have seen happens to have a `Regex` overload.
358 | > This is important when you have Source Generated regular expressions, but can also be used in other places where you've already created a `Regex` instance that you may want to use for extraction.
359 | 
360 | ## Inspecting an extraction plan
361 | If you have an `ExtractionPlan`, you can have it pretty-print its understanding of the types and the regular expression that you have asked it to use for its extraction.
362 | 
363 | ```csharp
364 | var plan = ExtractionPlan<((int, int), char, string)>.CreatePlan(new Regex(@"((\d+)-(\d+)) (.): (.*)"));
365 | Console.WriteLine(plan.ToString("x"));
366 | ```
367 | 
368 | This prints the following extraction plan (you can see what capture groups it found):
369 | ```
370 | ConstructTuple<((int,int),char,string)>[0] (
371 |   ConstructTuple<(int,int)>[1] (
372 |     StaticParseMethod<int>[2] (),
373 |     StaticParseMethod<int>[3] ()
374 |   ),
375 |   StaticParseMethod<char>[4] (),
376 |   StringCast<string>[5] ()
377 | )
378 | 
379 | ↓--------------↓ ↓--↓: ↓---↓₀
380 | (↓----↓-↓----↓)₁ (.)₄  (.*)₅ 
381 |   (\d+)₂ (\d+)₃
382 | ```
383 | 
384 | # Regular Expression reference
385 | 
386 | | Regex block | Effect |
387 | | --- | --- |
388 | | ([+-]?\d+) | a positive or negative integer with an optional sign character |
389 | | (\w+) | a string of word characters |
390 | | (.) | a single character |
391 | | ()+ | a list of whatever you put inside the parens |
392 | | (?&lt;name>pattern_goes_here) | a named capture group named 'name' |
393 | | (?: ) | a non-capturing group |
394 | 
395 | # History
396 | This project came about during [day 2 of Advent of Code 2020][1].
397 | The task involved parsing a strings that looked something like:
398 | 
399 |     1-3 a: abcde
400 |     1-3 b: cdefg
401 |     2-9 c: ccccccccc
402 | 
403 | [1]: https://adventofcode.com/2020/day/2
404 | 
405 | From each one, I needed two numbers, a character, and a string.
406 | 25 years ago I would have written the following absolutely trivial C code that would take care of parsing it:
407 | 
408 | ```c
409 | int lo, hi; char ch; char pwd[50];
410 | 
411 | sscanf(line, "%d-%d %c: %s", &lo, &hi, &ch, pwd);
412 | ```
413 | 
414 | It bothered me that the C to parse this was so much simpler than what I would wirte in C#.
415 | For contests, like Advent of Code or Google Code Jam, I usually make extensive use of `.Split()` a la:
416 | 
417 | ```csharp
418 | (int lo, int hi, char ch, string pwd) ParseLine(string line)
419 | {
420 |     var splits = line.Split(" ");
421 |     var nums = splits[0].Split("-").Select(int.Parse).ToArray();
422 |     return (nums[0], nums[1], splits[1][0], splits[2]);
423 | }
424 | ```
425 | 
426 | But that's fiddly to write, and even fiddlier to read.
427 | It's good enough for contest conditions, but leaves lots to be desired for sharing solutions and discussing approaches with other competitors.
428 | 
429 | Undoubtedly, a regular expression has most of the simplicity of that `sscanf` template from above--you can see what the extra characters are in the template, and you can see what's being extracted:
430 | 
431 | ```csharp
432 | @"(\d+)-(\d+) (.): (.*)"
433 | ```
434 | 
435 | Unfortunately .NET `Regex` `Match`es leave a lot of fiddling after matching to get to the simple types that you want to use for computation:
436 | 
437 | ```csharp
438 | (int lo, int hi, char ch, string pwd) ParseLine(string line)
439 | {
440 |     var match = Regex.Match(line, @"(\d+)-(\d+) (.): (.*)");
441 | 
442 |     return (int.Parse(match.Groups[1].Value),
443 |             int.Parse(match.Groups[2].Value),
444 |             match.Groups[3].Value[0],
445 |             match.Groups[4].Value);
446 | }
447 | ```
448 | 
449 | So I set out to design the best possible C# syntax that got me somewhere near the expressiveness and simplicity of the `sscanf` example from the 1960s.
450 | 
451 | Here's where I settled:
452 | 
453 | ```csharp
454 | var (lo, hi, ch, pwd) = line.Extract<(int, int, char, string)>(@"(\d+)-(\d+) (.): (.*)");
455 | ```
456 | 
457 | From there I added support for types with friendly constructors:
458 | 
459 | ```csharp
460 | var (lo, hi, ch, pwd) = line.Extract<template>(@"(\d+)-(\d+) (.): (.*)");
461 | 
462 | record template(int lo, int hi, char ch, string pwd);
463 | ```
464 | 
465 | And support for extracting named groups to properties:
466 | 
467 | ```csharp
468 | var result = line.Extract<template>(@"(?<lo>\d+)-(?<hi>\d+) (?<ch>.): (?<pwd>.*)");
469 | 
470 | class template {
471 |     public int lo { get; set; }
472 |     public int hi { get; set; }
473 |     public char ch { get; set; }
474 |     public string pwd { get; set; }
475 | }
476 | ```


--------------------------------------------------------------------------------
/RegExtract.Test/Usage.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Threading.Tasks;
  3 | 
  4 | using Xunit;
  5 | 
  6 | using System.Text.RegularExpressions;
  7 | using System.Collections.Generic;
  8 | using Xunit.Abstractions;
  9 | using RegExtract.RegexTools;
 10 | using VerifyXunit;
 11 | using VerifyTests;
 12 | 
 13 | namespace RegExtract.Test
 14 | {
 15 |     [UsesVerify]
 16 |     public class Usage
 17 |     {
 18 |         // Tests prefixed with 'a' are intended to be a broad variety of extraction plan creation and execution samples.
 19 |         // It's reasonable to expect 'a' tests to be reasonably performant.
 20 |         //
 21 |         // Tests prefixed with 'f' are functional tests that aren't intended to be performant.
 22 |         //
 23 |         // Other test names are designed to cover a broad variety of scenarios, and don't necessarily follow a pattern.
 24 | 
 25 |         private readonly ITestOutputHelper output;
 26 | 
 27 |         public Usage(ITestOutputHelper output)
 28 |         {
 29 |             this.output = output;
 30 |         }
 31 | 
 32 |         const string data = "123456789";
 33 |         const string pattern = "(.)(.)(.)(.)(.)(.)(.)(.)(.)";
 34 |         const string pattern_nested = "(((.)(.)(.)(.)(.)(.)(.)(.)(.)))";
 35 | 
 36 |         Regex rxa001 = new(@"((\w)(\w))+");
 37 | 
 38 |         [Fact]
 39 |         public Task a001()
 40 |         {
 41 |             var (plan,str) = CreateAndLogPlan<List<(char, char)>>(rxa001);
 42 | 
 43 |             var result = plan.Extract( @"abcdef");
 44 | 
 45 |             Assert.Equal(result, [('a', 'b'), ('c', 'd'), ('e', 'f')]);
 46 | 
 47 |             return Verifier.Verify(str);
 48 |         }
 49 | 
 50 |         Regex rxa002 = new(@"((\d+) ?)+");
 51 | 
 52 |         [Fact]
 53 |         public Task a002()
 54 |         {
 55 |             var (plan,str) = CreateAndLogPlan<List<int>>(rxa002);
 56 |             
 57 |             var result = plan.Extract(@"123 456 789");
 58 | 
 59 |             Assert.Equal(result, [123, 456, 789]);
 60 | 
 61 |             return Verifier.Verify(str);
 62 |         }
 63 | 
 64 |         record game(int id, List<draw> draws);
 65 |         record draw(List<(int count, string color)> colors);
 66 | 
 67 |         Regex rxa003 = new(@"Game (\d+): (((\d+) (\w+),? ?)+;? ?)+");
 68 | 
 69 |         [Fact]
 70 |         public Task a003()
 71 |         {
 72 |             var (plan, str) = CreateAndLogPlan<game>(/* language=regex */rxa003);
 73 |             
 74 |             var result = plan.Extract("Game 31: 9 blue, 6 red, 7 green; 20 red, 1 green, 15 blue");
 75 | 
 76 |             Assert.Equivalent(result, new game(31, [new draw([(9, "blue"), (6, "red"), (7, "green")]), new draw([(20, "red"), (1, "green"), (15, "blue")])]));
 77 | 
 78 |             return Verifier.Verify(str);
 79 |         }
 80 | 
 81 |         Regex rxa004 = new(@"(([RL])(\d+),? ?)+");
 82 | 
 83 |         [Fact]
 84 |         public Task a004()
 85 |         {
 86 |             var (plan, str) = CreateAndLogPlan<List<(char, int)>>(rxa004);
 87 | 
 88 |             var result = plan.Extract("R8, R4, L4, R8");
 89 | 
 90 |             Assert.Equal(result, [('R', 8), ('R', 4), ('L', 4), ('R', 8)]);
 91 | 
 92 |             return Verifier.Verify(str);
 93 |         }
 94 | 
 95 |         Regex rxa005 = new(@"((...) = \(((...), (...))\);? ?)+");
 96 | 
 97 |         [Fact]
 98 |         public Task a005()
 99 |         {
100 |             var (plan, str) = CreateAndLogPlan<Dictionary<string, (string left, string right)>>(rxa005);
101 | 
102 |             var result = plan.Extract(@"AAA = (BBB, CCC); BBB = (DDD, EEE)");
103 | 
104 |             var expected = new Dictionary<string, (string left, string right)>
105 |             {
106 |                 ["AAA"] = ("BBB", "CCC"),
107 |                 ["BBB"] = ("DDD", "EEE")
108 |             };
109 | 
110 |             Assert.Equal(expected, result);
111 | 
112 |             return Verifier.Verify(str);
113 |         }
114 | 
115 |         Regex rxa006 = new(@"((\d+) ?)+");
116 | 
117 |         [Fact]
118 |         public Task a006()
119 |         {
120 |             var (plan, str) = CreateAndLogPlan<List<int>>(rxa006);
121 | 
122 |             var result = plan.Extract("123 456 789");
123 | 
124 |             Assert.Equal([123, 456, 789], result);
125 | 
126 |             return Verifier.Verify(str);
127 |         }
128 | 
129 |         Regex rxa007 = new(@"(?:(\d+) ?)+");
130 | 
131 |         [Fact]
132 |         public Task a007()
133 |         {
134 |             var (plan, str) = CreateAndLogPlan<List<int>>(rxa007);
135 | 
136 |             var result = plan.Extract("123 456 789");
137 | 
138 |             Assert.Equal([123, 456, 789], result);
139 | 
140 |             return Verifier.Verify(str);
141 |         }
142 | 
143 |         Regex rxa008 = new(@"(\d+ ?)+");
144 | 
145 |         [Fact]
146 |         public Task a008()
147 |         {
148 |             var (plan, str) = CreateAndLogPlan<List<int>>(rxa008);
149 | 
150 |             var result = plan.Extract("123 456 789");
151 | 
152 |             Assert.Equal([123, 456, 789], result);
153 | 
154 |             return Verifier.Verify(str);
155 |         }
156 | 
157 |         Regex rxa009 = new(@"(([a-z]+)([=-][0-9]?),?)+");
158 | 
159 |         [Fact]
160 |         public Task a009()
161 |         {
162 |             var (plan, str) = CreateAndLogPlan<List<(string, string)>>(rxa009);
163 | 
164 |             var result = plan.Extract(@"rn=1,cm-,qp=3,cm=2,qp-,pc=4,ot=9,ab=5,pc-,pc=6,ot=7");
165 | 
166 |             Assert.Equal([("rn", "=1"), ("cm", "-"), ("qp", "=3"), ("cm", "=2"), ("qp", "-"), ("pc", "=4"), ("ot", "=9"), ("ab", "=5"), ("pc", "-"), ("pc", "=6"), ("ot", "=7")], result);
167 | 
168 |             return Verifier.Verify(str);
169 |         }
170 | 
171 |         Regex rxa010 = new(@"(((\w)+ ?)+,? ?)+");
172 | 
173 |         [Fact]
174 |         public Task a010()
175 |         {
176 |             var (plan, str) = CreateAndLogPlan<List<List<List<char>>>>(rxa010);
177 | 
178 |             var result = plan.Extract(@"asdf lkj, wero oiu");
179 | 
180 |             Assert.Equal([[['a', 's', 'd', 'f'], ['l', 'k', 'j']], [['w', 'e', 'r', 'o'], ['o', 'i', 'u']]], result);
181 | 
182 |             return Verifier.Verify(str);
183 |         }
184 | 
185 |         Regex rxa011 = new(@"^(([%&])?([a-z]+)) -> (([a-z]+),? ?)+$");
186 | 
187 |         [Fact]
188 |         public Task a011()
189 |         {
190 |             var (plan, str) = CreateAndLogPlan<((char? type, string name) module, List<string> outputs)>(rxa011);
191 | 
192 |             var result = plan.Extract("&kx -> zs, br, jd, bj, vg");
193 | 
194 |             Assert.Equivalent((('&', "kx"), new List<string>() { "zs", "br", "jd", "bj", "vg"}), result);
195 | 
196 |             return Verifier.Verify(str);
197 |         }
198 | 
199 |         record Rule()
200 |         {
201 |             public static Rule? Parse(string str)
202 |             {
203 |                 if (str.Contains(":"))
204 |                     return str.Extract<Conditional>();
205 |                 else
206 |                     return str.Extract<Absolute>();
207 |             }
208 |         }
209 | 
210 |         record Absolute(Action step) : Rule
211 |         {
212 |             public const string REGEXTRACT_REGEX_PATTERN = @"(.*)";
213 |         }
214 |         record Conditional(Condition cond, Action step) : Rule
215 |         {
216 |             public const string REGEXTRACT_REGEX_PATTERN = @"((.)([<>])(\d+)):(\w+)";
217 |         }
218 |         record Condition(char prop, char test, int val);
219 | 
220 |         record Action
221 |         {
222 |             public static Action Parse(string str)
223 |             {
224 |                 return str switch
225 |                 {
226 |                     "A" => new Accept(),
227 |                     "R" => new Reject(),
228 |                     _ => new Workflow(str)
229 |                 };
230 |             }
231 |         }
232 |         record Accept: Action;
233 |         record Reject: Action;
234 |         record Workflow(string workflow) : Action;
235 | 
236 |         Regex rxa012 = new(@"(\w+){(([^,]+),?)+}");
237 | 
238 |         [Fact]
239 |         public Task a012()
240 |         {
241 |             var (plan, str) = CreateAndLogPlan<(string workflow, List<Rule> rules) >(rxa012);
242 | 
243 |             var result = plan.Extract("sxc{x>2414:jtp,s>954:R,m>2406:A,xfz}");
244 | 
245 |             Assert.Equivalent(("sxc", new List<Rule> { new Conditional(new Condition('x', '>', 2414), new Workflow("jtp")), new Conditional(new Condition('s', '>', 954), new Reject()), new Conditional(new Condition('m', '>', 2406), new Accept()), new Absolute(new Workflow("xfz")) }), result);
246 | 
247 |             return Verifier.Verify(str);
248 |         }
249 | 
250 |         record triple(int a, int b, int c) {
251 |             public static triple Parse(string str)
252 |             {
253 |                 return new triple(0,0,0);
254 |             }
255 |         }
256 | 
257 |         private Regex rxa013 = new(@"(\d+) (\d+) (\d+)");
258 | 
259 |         [Fact]
260 |         public Task a013()
261 |         {
262 |             var (plan, str) = CreateAndLogPlan<triple>(rxa013);
263 | 
264 |             var result = plan.Extract("123 456 789");
265 | 
266 |             Assert.Equal(new triple(123,456,789), result);
267 | 
268 |             return Verifier.Verify(str);
269 |         }
270 | 
271 |         [Fact]
272 |         public void f001()
273 |         {
274 |             var 
275 |             tree = new RegexCaptureGroupTree(new Regex("(asdf){}"));
276 |             output.WriteLine(tree.TreeViz());
277 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){01"));
278 |             output.WriteLine(tree.TreeViz());
279 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){01}"));
280 |             output.WriteLine(tree.TreeViz());
281 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){01,}"));
282 |             output.WriteLine(tree.TreeViz());
283 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){1,2}"));
284 |             output.WriteLine(tree.TreeViz());
285 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){1,2}?"));
286 |             output.WriteLine(tree.TreeViz());
287 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){,12}"));
288 |             output.WriteLine(tree.TreeViz());
289 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){1\,2}"));
290 |             output.WriteLine(tree.TreeViz());
291 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){\1,2}"));
292 |             output.WriteLine(tree.TreeViz());
293 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf)\{1}"));
294 |             output.WriteLine(tree.TreeViz());
295 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){1\}"));
296 |             output.WriteLine(tree.TreeViz());
297 |             tree = new RegexCaptureGroupTree(new Regex(@"(asdf){,}"));
298 |             output.WriteLine(tree.TreeViz());
299 |         }
300 | 
301 |         [Fact]
302 |         public void slow()
303 |         {
304 |             var plan = ExtractionPlan<List<(string, string)>>.CreatePlan(new Regex(/* language=regex */@"(([a-z]+)([=-].?),?)+"));
305 | 
306 |             var result = plan.Extract(@"tp-,pnm-,vrg-,nfk=6,qqc=2,zs=2,hm-,xnl=4,fszj=6,cx=7,zpfsz-,hdg=9,nqqm-,nfk-,pb-,cbn=5,ng=8,pdk=4,rd=7,sl=2,qtk=7,fkdp-,dxkx-,qc=9,dxtz-,bgzmkc-,jzv-,ljd-,nbh=7,dtr-,sbd=5,zt=2,zgj-,rbpq=7,vm=6,gq=3,qnjfm-,hxd=8,rsnbql=4,bdx=7,mvgfg=8,hv=4,ql=5,tnkt-,qdh-,dv-,dqclp-,tnc=2,vgk=7,rb=6,flzg=6,rv=5,qn-,fgdr-,gj=5,gg-,vtm-,btjv=5,xs-,rfbn-,hxd=6,bhxnh-,zr-,llq=7,ds-,xs-,hdvdp=1,ll=9,kgm=1,tj-,lmx=3,mn-,zbb-,xj-,pcv=1,xrl=7,mc=2,zf=3,rrl=7,mztj=2,pcp-,fvjj=6,tn=9,jc-,xsr=2,kkgj-,bnzq=7,vtld-,hx-,zs=5,fl-,pmjz-,hh=4,hrzhq-,xs=2,dsqgh-,qqz=9,glmz=1,xs-,dvc=1,ng-,qcf-,tnsmf-,nqqm-,ksr-,kq=8,lbng=4,fntl-,zr=8,ll=1,ml=8,ctz-,hq=4,cb=1,kjq=8,ckr=4,td=8,cp=6,gpmx-,ppd=5,nc=6,mz-,dtjxv-,hmt-,vrrqpg=2,tnc-,pm=3,qqz=3,llphh=9,pm=2,kmmvl-,jl-,hmt-,tlhm=3,bh=7,kxb=2,rt-,hsm-,crqn-,mq-,mljpt=8,pcv=5,ksr-,sb=5,hprc=4,dsg-,klpm=9,qqc=8,rb=2,ntbjb-,xlc=9,rkd=3,tpfrc-,dsg=4,nbd-,sb=8,sp-,jqhkf=3,dhb=8,llq=4,jxp=7,mtr-,zlc=7,rs=9,xlg=7,qk=8,bs=2,pldx-,lrqrhk=1,lkbj=4,kmmvl-,jcj=9,qxg-,nng-,smf-,ss-,sk=2,td-,rfcgxr=1,sjfx-,kcv=9,llq=2,rxkp=4,njh-,pg=1,nf=9,ksl-,kmmvl=8,tgsdsb=6,tnc-,qkx-,hrrmd-,hrzhq=7,qnjfm=3,pc-,pg-,czh-,lsl-,mp-,sk=6,qkl-,bnzq=6,fps-,ckr=4,pcp=8,qkx-,lj-,qxg=4,bd-,mqr=5,htm-,hl-,mtkbz=4,kmmvl-,hb-,rqc-,qtk=6,mfr=9,hmt=7,nckm-,jf-,dl=7,hxd=7,mzn=5,zpfsz=1,hd-,nsl-,dx=8,ts-,gq=6,fp=3,qtk=9,fntc=9,tkxd-,bf-,dc=8,rr=2,ktqgm-,mqg=5,tnc-,sp=4,kqkl-,xvx-,zpfsz-,fsb=3,hprc=7,llh=8,xf-,bknq=5,kbvd=8,nklnq=8,flzg-,jl=3,stldk=5,ns=7,lj-,svg=3,ftdll=9,qdjff=7,pdk=9,cgb=4,cfj-,hff=7,sh=1,lj=9,mdzc=3,cdh-,spv=9,glmz=2,mzn-,zv=9,hff-,jfjgt-,qtk=3,hb-,lmdg=8,cntd-,xdfb=3,ssv-,xj-,hs-,tdvm-,fj-,rt-,gtf-,fndhj-,nknrvm-,qbp=8,nhgz-,rbzlx=7,jf-,rb=2,hhhx=1,jf-,zpn-,tk=5,mks-,sk=5,hdvdp=2,fvjj-,bhxnh-,pzz-,jfjgt-,zlc-,tnsmf-,xh-,kjq-,bpf-,rs=9,jb=7,qbms=8,rcb-,tgg-,gltc=2,pzz=3,xvx=7,hrrmd-,kqm-,xdpj-,fps=8,qqz-,tp=1,jhs=8,bpf-,dvc-,ljd-,xgmft-,dv-,ntbjb=1,ld-,bgzmkc=1,qcf=3,tnr=3,xrl-,zkknr=9,pbnr=7,hprc-,pbnr-,xfb=6,nc=5,hjq=3,bdz-,mfbj-,xl=3,vrrqpg-,ht-,mr-,bp=1,zgt=8,pb=8,dvc=1,xs=3,lmx-,kqm-,fk=5,fptk-,kd-,glmz-,nng-,jjfl-,nckm=3,sb=9,nknrvm-,hqngsj=4,fx-,xj=2,zpfsz=5,qm=3,xmd-,pnm-,sgmp=1,phl-,cmsf=4,hmt-,fp=7,kfhn-,jc-,qqc=8,pl=1,zpn-,kjq-,cmsf-,lsl-,kx=3,bnzq=7,kvjm-,rxkp=9,xnfpt=1,sn=1,qx=3,fntl-,czj=4,dpq-,mqh-,gmt=5,lcv=8,kd=9,gg=9,dkp-,nbk=8,xpt-,cncd=3,fszj-,mc=1,hc-,dkzsqb=3,dv=4,nc-,sb-,gl=1,njkr-,df-,dv=4,ltp=9,jx=2,dx=1,gl-,fgdr-,dqclp=1,dsqgh-,vtm-,vkk-,hgxd-,pqgmnl=3,nfk=5,lj-,cfj-,kt=4,mqh-,vb-,xhblcq=1,cbvr-,nf-,pk=1,lbp-,cbbt=4,lkbj=4,sdv-,jcj-,qggxgx-,dhb=3,vrrqpg-,dhb-,mbj-,mztj-,sbd=9,jbf=6,jrqk=5,nch=6,njkr=7,kqkl-,ctz-,cbn=8,klpm-,qzts=3,sgmp-,gql-,fgdk=4,lrnz-,qkx=5,pdk-,hsm-,lmx=4,fx=7,tmfn=4,jp-,fbn=9,qvxv=8,spv=2,knf=7,nxxhk=6,hprc-,km=1,jh=3,rx=7,qzgb=3,ns-,cbv=3,kqkl=3,pf-,xrlqx-,hq=4,hb=4,hc=7,qk-,nc-,dsg=6,tvd-,sp=5,ln=2,tj-,llphh=4,ztgx-,jtc-,pf-,ktqgm-,cbvr-,pm=2,xdgcfh-,gq-,rs-,xpj-,vvt=4,tkm=9,fgz=1,xvx-,tk=6,jbf=2,mvgfg=9,rsnbql-,xh-,zxdj-,kcv-,rfcgxr=9,jf=8,rv=2,sjfx=9,gb-,ptn=5,czh-,cntd=6,tvd-,gdlq=1,rb=4,nbk-,vxzxc-,lc-,xdgcfh=1,jh-,pbnr-,rt-,hdvdp=9,jhf=4,vmh=9,dhb-,xdgcfh=3,hnb=5,xpj-,fjg-,gltc-,ll-,qh-,nf=1,bnzq=4,hm-,tp=1,gl-,gq-,nbh-,dxdxl-,tvd-,cfj-,kmcgcr-,mql=4,rf=8,kcv=9,dh=1,nhgz-,xpj=3,ql-,bpf=9,jqh=7,mnmshn=5,lj-,vvl=3,jrqk=2,gdlq=1,jf=9,rcb=3,tsv=8,gnpz-,nbk=8,pc-,pf=8,lkt-,hs-,hj-,mc=1,sc=4,qcrvs-,qh-,hdvdp-,kd=8,fj=4,gql-,mvgfg-,jz=2,rt=9,qqc-,jhs-,kk=1,smf-,lbng=8,tkl-,lkmt-,tmfn=2,ljd=7,pqgmnl=9,mks-,krsqtb=1,njfx-,hh=8,sl=3,kdn=8,pldx=4,sp-,kvjm=9,mfnkh=8,qjh=8,pmjz-,tj=1,qbp-,gg-,kxb=4,tk-,htm=6,bqv-,bs=5,qvd-,qh-,kt-,zlc-,pldx-,hc-,mdjn-,hsm-,nscnp-,cbvr-,sk=2,rf=1,vpk-,dxkx=1,rrl=8,fdf=1,cfj=5,dc-,pg-,bdz=9,vb=1,jjfl=2,gg=4,dzrg-,cfj-,xb-,dl-,mc=9,xrl=8,cdh=3,rsnbql=1,jhf=1,qnjfm=3,ft=3,qdjff-,fvjj-,vd=8,qdjff=9,lkt-,htm=6,gl=6,gpmx=7,fgdr=4,mf-,sc=1,bb-,bd=6,xz-,jx-,kdn=4,ng=8,cbbt=3,xlf-,kf=7,kr=6,qqc=5,jrqk-,gnpz-,sqz-,mvgfg-,xdpj=4,xdgcfh=6,xd=5,rfbn-,qxg=1,jjhd=5,ht=4,px-,kf-,vrrqpg-,rv-,glmz-,dzrg=5,kr-,nckm-,qggxgx-,hdg-,pc=7,nc-,cm-,vmh-,tnkt=3,zlc=8,mrq-,ddf=1,xlg=1,xmd=1,dc-,hm=5,qxg-,vmcq=9,sb=5,mz-,jj=9,bpf-,ng=8,llphh-,hsm-,rrl=6,gtf-,ptn=9,dtjxv=2,jfjgt=2,gltc-,hsblgj-,hrzhq-,xdfb-,hmbhhr=5,cr=6,lxzg-,kdn=1,kvtcc-,hd=7,kxmpd=4,zfh=5,rcb-,bf=1,nqqm=4,jh-,vb-,mztj=3,zh-,cx-,qjh-,kcv-,hmt=5,hmbhhr-,lkbj-,xj=5,xfb-,cbn-,bf-,jxxhbv-,tkl-,bf-,llq-,kqkl-,tnc=3,mztj-,hsm=4,sctzlm=4,llq=2,fvjj-,zbrq-,mtkbz=4,rrv-,mfbj-,dvc=3,xd=4,zgj=5,nvc=4,hqngsj-,hl=3,cdr-,dpp-,rf-,gl-,dtr-,jqh=4,gpz-,pcp=8,kt=7,ltp-,tn=7,ng-,nbq=8,tnr-,kd-,kgm-,fsb-,xfb-,hmbhhr=5,nscnp=6,rqc=6,bb-,vgk=4,lsr-,mnmshn-,fl=6,qcf-,tvd=9,zxm-,tpfrc=3,xmd=8,kjzsmv=8,tn-,ll=8,ht=2,xg-,kvjm=8,fszj=8,sh=4,fgdr-,jqhkf-,kxmpd-,mdjn-,hg=2,qtk=7,rd=3,rqbz-,ktz-,stldk=2,xsr=2,ds=3,cbv=1,vpk-,dsqgh=2,mdzc-,dc-,ml=7,rsnbql=2,xb=4,tg-,tkl=1,rbzlx=2,jcj=6,sh=8,xm=1,nbh=2,jp-,qjv-,hv=4,ss-,cncd=1,ssv=4,glmz-,jfjgt=4,lc=7,mbj=1,xhgt-,pm-,sc-,cr-,pb=6,ss-,gmt-,qvxv=8,sgmp-,hxr-,pzz=5,qvxv=4,fl=6,zbb-,nlmj=6,kjq=4,bb=3,sb=2,srn=8,bdx=8,rsnbql-,kk-,cr=7,lj=6,ssv=4,tsv=1,bdz=5,zfh-,sctzlm-,mbj=8,hc=2,llq=1,kp=2,hhhx=2,xfb-,hm=2,sp-,rbzlx=3,dzrg=8,bqv-,mks-,xpj-,rf=2,zv-,nsl-,fgdk-,cr-,lkt=7,zqsd-,kthg-,hhhx-,clt-,bdx=6,rf=7,hs-,svg-,cf=6,ml-,sbd=6,hq=9,mp=2,lmx-,xsr-,rbzlx=8,jfjgt=3,nxxhk=2,cdr=4,ktz=4,hbp-,sp-,bm-,jqh-,sc-,btjv-,xhblcq=8,sh=5,kthg=4,ns=4,mbd=9,hbp-,pdk-,zpfsz-,zbrq-,nscnp-,hg-,ss-,pl-,kt-,kjq=5,nxxhk-,xhblcq-,vrrqpg-,gdlq-,gltc-,lv=8,dsqgh-,jl-,jjhd-,sndpd=7,mfg-,klq=4,flzg=1,nbd=2,dc=9,ktqgm-,vs=5,xs-,hrrmd-,ld-,hhhx=1,zgt-,rfcgxr=8,jxp-,hnb=4,lsr=1,mnmshn-,svg=5,pc-,kgq-,lnh-,hgxd-,kfhn=7,vvt-,zfh-,nscnp-,vgk=3,cqggjb=6,td-,mfnkh=1,mljpt-,rd-,dkzsqb-,mz=9,xlg=8,gpz-,flzg=2,zz-,fps-,llh-,fhp=7,jcj-,nch-,fps-,clt=1,nng=5,jz=3,zfxmb-,df-,rqc-,hj=8,zxdj=2,dv-,spv=1,fszj-,kcv-,hff=2,vck-,tvd-,gb=8,hv-,hsm=1,tkl-,hrzhq-,xpj-,kvtcc=3,jzd=3,cx-,xm=4,lnh=3,dltvb-,xvx-,llh-,zpn-,hc=2,cnq=2,dtjxv=5,zs=5,gdlq=7,mc-,zgj-,jc=9,kxmpd-,bf=7,sctzlm=1,hs=9,zv=2,vst-,rs-,cbvr=4,pm=4,ns=5,hm-,vb=3,nscnp-,ztgx-,jrqk=9,ddf=3,hx=3,hdg-,qcrvs=3,bfq-,fk-,qn=9,lrz-,hs-,rp=2,dj=9,cf-,pt=2,cbbt-,rt-,zkknr=9,qm=4,fndhj-,vm-,bs-,dh=7,srn=1,vmh=7,hsm-,fl-,ds-,rmdlr=6,hmbhhr=7,mvgfg-,mdzc-,hprc-,nvp=2,vmh=4,jgp=2,jqh-,nch=7,gpz=1,fhp-,bp=2,btjv-,hqngsj-,zct-,ckr=4,ltp=1,fszj=4,zpn-,xlg=8,lbng-,zfh-,jhf-,kgm=4,vrg=4,vpk-,zgj-,zxdj-,xgmft=7,hs-,gdm=2,tt-,lkt-,qdjff-,vs-,mbd=3,nng=7,clt-,dr=8,kcv-,mrq=4,ftdll-,kvtcc-,fk=7,fnqkh-,gg-,mzn=6,fszj=6,ns-,mrq-,bgzmkc-,srn=6,cp=5,hkbf-,lmdg-,fhp-,pbnr-,sndpd-,tkpp=2,kt-,ll=2,xpt=4,fqj=9,flzg-,mzn=7,lrt-,nsl=6,cmsf-,vtm-,xdqd=8,bb=1,njfx-,sgmp=9,nbd=3,hb-,jgts=6,mn=4,jcj-,pmlhn-,bpf=2,sctzlm-,gdm=6,czj=4,bnzq-,dv-,jhf-,njh=2,vfk-,hs=5,rk=8,pdk-,fntl-,cm=2,lkbj=2,ljd-,jqhkf=6,dsz-,rfbn=2,sdnmh-,kmcgcr=3,srn=8,ssv=9,mrq-,mbj-,fbhzcd-,rb=4,mqr=5,fgz-,qdjff-,jpk-,svg-,gq=8,xdfb-,hx=9,rt=8,bgzmkc=9,glnl=7,jgts-,xpj=4,xlf-,bq-,tkxd=4,lsl-,ngfn-,ts=9,jbf-,kh=8,tlhm-,klq=9,rfbn=2,xfb-,pm=9,ngfn=1,nn=5,tj-,cm=3,rg-,xlc=4,mljpt-,vtm-,tnr-,vxzxc-,ltp=7,cb-,rcb-,srn=6,mz=6,qggxgx-,tn=3,bdz-,hxr=2,fkdp-,qqz=6,xsk-,bh=5,jbf=8,bxmz=3,lsr-,cf-,qkx=2,zbb-,pnm-,fgz-,dkp=7,gb-,kxb-,rf=2,zpn=5,mfr-,rf=2,bknq-,dv-,tkxd-,pcv=8,vb-,mc-,klq=2,fk=6,stldk=1,ln=2,qc-,tt=5,vck=9,xvx-,rk=5,fp=5,ssv=9,pc-,nvp=8,xgnr=1,xhgt=2,mtr-,pmlhn-,fdf-,fjg=4,cbbt=6,vtld-,cbvr-,hm=2,ts=7,sh-,cb=8,kthg=7,tkl=7,bknq-,vst-,cmsf-,jgts=7,vgk-,vgk=9,qkx-,kp-,ktqgm=6,nfk=9,xlg=6,tj-,bpf-,fntc=2,ktz-,zbb-,bm=6,ql=4,pkdf=7,ppd=4,jz=2,pcv=2,qtk-,lrnz=2,qk-,jj=4,jfjgt=1,bfq=3,xb-,mf-,hgxd=7,lrt-,rk-,zqsd=2,gxkv=4,qn-,lmx-,sn=3,ptn=2,vpk-,qjh-,ddf-,cr-,xj-,qqc=5,zc-,hqngsj-,xrlqx=4,hnb=1,gm-,klpm-,qdjff=3,zpn=1,gql-,rqbz=4,knf-,ql-,xhgt-,cr=3,kq-,gql-,fp-,gpmx=5,ll-,xm-,tgsdsb-,zc-,zb-,mqg-,knf=9,tgg-,dj-,kkgj-,rkd-,crqn-,kqm=1,jzbv=7,qqc=9,gjtf=9,htm=9,jhs-,pg-,cf-,kvjm-,dx-,xdgcfh=3,qk-,ql=4,fgdr=4,rfcgxr=5,jgp=6,jp=2,xd=1,tn=4,qjv=4,fkdp-,pmlhn-,bknq=2,jclf=2,cdh-,dl=1,nxxhk-,zpfsz-,nbd=7,jxp-,hdg=2,km-,nsf-,xmd=8,nxxhk=3,mf-,mrq-,sgmp=3,xhgt-,pkdf-,mdzc=7,qqc=4,njh=6,ds=6,ng=1,qc=3,tgsdsb=5,dxtz=6,qvd-,qdjff-,jgts-,kq=8,phl=4,mvs-,vmcq-,qbms=8,jzd-,tkm=8,zxdj=7,qn=6,mn=5,bd=6,mvgfg=2,cgb=6,xpj-,rb=2,kfhn=4,mkvj-,gpz-,zkknr=6,qjh-,jxp=8,gm-,hprc=8,vmcq-,vmcq=1,hxr-,gdm=8,jzbv=7,njkr=2,krsqtb-,rrl-,cfj=5,dpp-,lcv=2,qjv=2,qtk-,qc=9,fx-,jqhkf=3,tn=3,jhf-,df-,ht=6,hd-,hsblgj=3,hsm=5,sjn=6,qx=3,mljpt-,bb=8,pm=1,ktz-,hd=9,gxkv-,ktqgm-,pcp=9,sndpd-,nng=3,mqh=9,pcv=1,cm-,xs-,hsm-,xpj-,nbq=1,qvd=7,vkk=2,bpf-,rmdlr-,ln-,xrl-,rfcgxr=1,qcf=4,fj-,mks-,rfbn=3,xdgcfh=7,pxhkd=1,lc-,ksl-,jz-,rrv-,vpk=2,ktz=2,gtj-,glmz=7,rs-,tsv-,dxdxl-,xdfb-,gpz-,dkzsqb-,bnzq=2,tvd-,bknq-,zbb-,cmsf-,tpfrc=5,kqm=6,nscnp-,xlc=9,qxg=3,mz=9,zxm-,xlf=4,hkbf-,zxm=9,ksr=6,xm=6,kjzsmv=9,sk-,sxzhh-,cnq=5,hff-,mrq-,ps-,mdzc=5,tkxd-,jc-,pqgmnl=4,dsz=5,rqc=6,gnpz=3,vkk-,nsl-,sjn-,ljd-,tkxd=4,fbh-,htm-,dtjxv=8,lj-,xl-,dkp=5,vtm-,gltc=7,fps-,btjv-,kqm-,dsqgh=1,fgdk=5,svg=6,hq-,rf=6,vvl=6,jh=8,jrqk=5,pldx=4,llq-,tn=1,kkgj=9,bb=6,hpph-,xg=1,lkt=1,njfx=1,cdh=6,ps=2,sbd=7,qk=1,jf=3,vd=2,xgnr=7,knf=9,xj-,pb=2,pnm-,clt-,klpm=1,kgm=3,xpj=8,xb-,lrnz-,hrzhq-,crqn-,dc=1,rb-,jf=9,cf=3,pcv-,sctzlm=3,gb=5,mqg-,nckm-,xtp=2,cnq=5,vgk-,xb=8,kvjm=2,gb-,mdzc-,mtr=8,cntd-,fbn=7,sp-,kbvd-,qk-,fjg=2,xm=6,kgq-,krsqtb=2,ns-,nfk=8,qjh=2,qh=2,vl=9,jzrhx-,bfq-,gnpz=3,vrrqpg-,xmd-,frb=5,gj=3,jgts-,ssv=7,mdjn=2,xfb=5,gql=8,mql=8,tkl=3,rx=7,mdjn=1,sp-,ddf-,tnc-,kxb=6,gdlq-,gq-,xmd-,xs=8,xnfpt-,nsf-,fl-,rsnbql-,jhf-,nbd-,hdt-,rrl=5,krsqtb=5,lxzg-,vpk-,nbh=8,gq-,cr=9,msb=2,lsr-,ppd-,njfx=9,czj-,jgts-,mq-,rf=9,hdt-,mnmshn-,hqngsj=7,qnjfm-,fntc-,rqc-,mq-,fszj-,dh=2,sl=9,llphh=5,zt=6,mvgfg-,zct-,bgzmkc=7,cx-,mc-,dtjxv=3,cntd-,fntc=7,lrt-,ddf=7,mc-,lsl=7,nqqm-,hh-,vb=9,xlc=1,jtc=1,gtf-,tt=1,lrt=1,ljd=9,sp=2,rk-,lxzg=3,nscnp=9,tg=9,tnr=5,hkbf-,cgb-,mfr=5,rv=5,zr=4,sjn=3,gd-,fj-,kqm=8,xnfpt=9,xgnr-,mfg=1,qqz=9,fvjj=3,ckprt-,hl=2,gnpz-,mtkbz=3,hxd-,pmjz=7,lv-,kh-,stldk-,qbp-,hrrmd=6,vvd=6,mqh-,ckprt-,mdjn-,dhg-,qh=8,vtm=2,hsblgj=5,xdfb-,ptn=1,rk-,rv-,sh=2,kf=9,bqv-,bnzq=7,mks-,kt=1,fk-,cmsf-,dqclp=4,hq=2,hmbhhr=2,km=5,lbp=9,lmdg-,fsb-,jxp-,hmbhhr-,xm-,vd-,hpph=8,cbvr-,bf=1,ktz=2,vvd=8,jbf-,xl-,cqggjb-,dpp-,dpq-,tn-,vs=4,kdn=3,hrrmd-,klpm=3,hdvdp=6,hj-,df=2,vrrqpg-,fjg=9,ngfn=4,fgz=4,gpmx=9,hdvdp-,dhg=1,mdjn-,nbh=4,zfh-,qggxgx=4,fqj=1,sxv=9,nklnq-,hhhx=1,tnr-,czh-,hc=4,sqz=5,fp-,lrqrhk-,jhs-,rb=1,cbv=9,pldx=4,rrv-,srn=5,vm=1,gdm-,tgg=7,dzrg-,cr-,qm-,ll-,vkk-,vck-,pxhkd-,sxv-,ntbjb=9,cncd-,hd=8,sbd=7,nng=5,xdqd=2,tt=7,jm=8,htm=3,qvxv=6,cntd-,mdjn=4,mq=1,xrl-,rd=3,lrt=4,njfx=9,ql-,lrqrhk-,rbpq-,mzn=4,vs=8,vs=2,mtr-,pch-,mdzc=9,ctl-,lcv=1,srn-,tnkt-,px=5,jz-,qbp=3,jh=5,pc-,jh-,sjn=1,vtm=7,mf=6,xd=9,pnm=2,jpk-,llq=7,hv=6,dxtz=6,fjg=8,nfk-,fk=8,xh-,tnsmf-,cf=8,rx=9,jcj=5,dxtz-,fj=5,hff-,vfk=8,rvnklp-,kq=8,hrzhq-,gtf=5,llh-,qcrvs=3,phl=6,jfjgt=6,jzd=5,rv=6,kvtcc=5,ql-,dx=2,dpp=8,td=2,cncd=6,xhgt-,px-,jj=1,vvt-,jqhkf=1,hjq=2,mtkbz-,pzz=2,km=9,tkxd=6,xrl-,jhs-,pqgmnl=1,kvtcc-,vb-,jf-,xtp-,fhp=7,qtk-,nbh=5,sxzhh=9,vd=9,hq-,fjg=9,kjzsmv=8,bqv-,mrq-,pkdf-,nvc=3,fbn-,bdm=6,czh-,fvjj-,bq=1,jpk=7,lrt-,dj-,llq-,mljpt=8,dhg=9,pnfmgj-,rfbn=2,sbd-,fbhzcd=3,pdk-,rp=8,xgmft=9,sndpd=4,kjq=5,sxv=9,xlf-,xdpj=6,ptn=2,vtld=9,htm-,xdgcfh-,hg=9,dqclp-,xvx-,gltc-,sc=7,xfb-,spv=1,nsl=3,xsr-,jzbv=2,ckprt=7,fj-,bp-,mbd=3,knf=6,jzd=8,jjhd-,qkx-,qm=9,hjq-,xdgcfh=8,kbvd-,jp=4,qcrvs=1,ktz=4,cr-,kxmpd-,lcv=5,vfk=1,gd-,mf-,rrv-,tvd-,lbng-,zr=5,hmt-,hd-,crqn-,htm-,xz-,cntd=7,pbnr-,kjzsmv-,xd-,vm-,mqr-,qnjfm=2,qggxgx=7,gxkv=7,dxkx-,hx=2,sxzhh-,bnzq=2,jzbv-,hv-,zqsd=8,ssv=9,gg-,rk-,ss-,rxkp=9,mqg=8,mp=6,qvxv-,hrrmd=3,tdvm=8,njh-,ftdll-,qggxgx-,tp-,gdlq=8,cqggjb-,hc-,lsl-,mdjn=3,vs=3,lbp-,jh-,cf-,pg-,mzn-,zfl=2,xg-,tmfn-,zbrq=5,czj=2,dsg=2,zqsd=5,jm=1,kthg-,hdvdp=5,bxmz-,bm=8,czj-,hsm=6,rqc-,ktqgm=9,bhxnh-,zlqd-,hq=6,ksr=7,mbj=8,sl=6,lbng=4,xnl-,nklnq=5,mz=6,zxm-,lgx=6,qqc-,hb-,fnqkh-,hrrmd-,gn-,gxkv-,ljd=5,nf-,rvnklp=4,sxv=5,dx-,vs=5,xm-,mkvj=7,rr-,ts=8,sjn-,hsm=9,rhq-,xb-,mfnkh=3,hxd=5,pcp-,hprc=1,pl=1,cqggjb=2,qbms-,rhq=7,qbp=9,hnb=8,tn=6,hl-,pt-,ksr=4,cgb-,cbvr=1,dc-,fdf-,cnq=6,cx=9,tn=5,mbd=3,rfbn=4,ckprt-,kmcgcr=7,ps=7,hj-,fvjj-,ll-,mljpt=5,fnqkh=1,jzd-,pbnr=5,rr=6,qvd=2,mz-,rhq-,ml-,qk-,hgxd=7,bnzq-,qkl=4,ckr-,dr=4,klpm-,qzts=2,mnmshn=2,sndpd=1,mljpt=3,kmmvl=8,vkk=2,kgq-,crqn=6,jm-,njfx-,xb=2,bxmz=8,lmx-,cqggjb-,jz-,gpz-,vck=3,hj=1,xnfpt=8,zpfsz-,tkl=2,hm=4,ctl=6,pg=7,qvxv=6,kvjm-,cdh-,dhb-,cm=5,pnfmgj-,kvjm-,hxd-,nqqm-,cqggjb-,gnpz-,lbng-,kk-,vs-,dt-,kthg-,dzrg=1,jfjgt=5,ljd=4,qkkm=2,zb-,mq=6,bfq=8,bb=6,kxmpd-,pqgmnl-,cfj-,stldk-,dsg-,clt=2,sk=7,kq-,pt-,nbq-,vst=7,cf-,zbrq=2,nxxhk=4,xlf=2,tkpp=4,qkx=9,hj=1,sc=6,kgm=2,qggxgx=1,rcb-,kmcgcr=1,sh=7,xj=5,kbvd-,cp-,hqngsj-,rvnklp-,jz=8,mc-,xgmft-,mqh=9,nsl=9,jjhd=9,dsqgh-,kdn=4,vrrqpg-,mdzc=2,dj=9,ljd-,sc-,pb-,jqh=1,mbj-,rv=2,mtkbz=6,zfl=1,qk=9,mzn-,kdn=1,gg=7,jjfl-,zh=2,nscnp-,fvjj=4,qvd-,btjv-,gl=7,tnc-,xf=1,fp-,xlf=1,hqngsj=2,pqgmnl=8,jzbv-,zgj=1,xl=6,mqh-,qqz-,mdzc-,lkt=5,jp=5,kxb=8,dpp=5,qcrvs=1,fhp-,bq=8,vxzxc-,kf=3,nfk-,qqz-,bhxnh=1,sxv-,kbvd-,llq=2,pnfmgj=3,mfnkh=7,vd-,zgj=5,rxkp-,gtj-,ft=2,dhb=1,dm=5,ps-,ml-,rx=7,cntd-,lrz=7,xm-,knf=4,nbq=6,rsnbql-,kq-,zr=9,xsk-,mks=4,pmlhn-,xg-,nbh=1,dzrg-,njfx-,zf=4,jl=8,tkpp=2,jb-,km-,bd-,nn-,hprc=8,mfr-,xhblcq-,kt-,qvxv-,hgxd=2,ps-,kbvd=3,ftdll=1,lrt=7,mvgfg-,fx=2,xlf=6,bs-,xrlqx-,hpph=4,dpp-,lrt-,pm=2,jrqk-,qqc-,mtr=9,kgq-,sk-,kk-,tvd-,dqclp-,fjg=3,pg=1,hmt=5,sctzlm-,sp=4,rrv=9,jpk-,nc=7,dqclp=1,llq-,gmt-,dr=4,mks=3,tgsdsb-,mz-,cqggjb=6,vck-,dhb-,fgdk=1,mfnkh=1,hgxd=9,pch=6,lkt-,vmh=2,jclf-,ld=7,clt-,jh=5,jxp-,kjzsmv-,dtjxv-,jgp=2,fps=5,rt-,lkt=4,dh-,qcrvs-,pc-,mdjn=6,fptk=4,hv=7,sp=9,kdn-,cbn=1,sb-,fqj-,xsk-,nfk-,rr=1,qn=4,nch-,zfh-,xhblcq-,sndpd-,lc-,gn=1,pzz-,rrv-,xtp=4,ns=6,fntl-,gn-,mc=7,qk=9,mp=6,dxdxl=8,sndpd-,pl-,qggxgx=2,pcp-,srn-,zb-,hmbhhr=1,rb-,hprc-,kx=6,vm=9,pkdf=3,mc-,gn=7,bgzmkc=5,kxb=1,pxhkd-,kgm=3,fbn=2,xdpj=4,sb=1,td-,td-,tvd=9,lrz=2,pnm-,qkkm=6,ctz=6,dhb=5,cmsf=4,xtp=7,gn=9,bdm-,nklnq=5,kthg=3,sk-,tn=2,crqn-,zc-,kqm-,tn-,nsf-,qbp-,nsl=7,glnl-,kk-,dtjxv=9,mdjn=7,njh=4,ckr=4,hv-,hsm-,spv-,sctzlm-,rhq=8,mtr-,km=6,lj=6,zpfsz-,tlhm=4,dkp-,dl-,crqn-,pf-,dtr-,lv=4,pg=7,fgz=4,rr-,mz-,kcv=6,bknq-,hx-,rxkp-,rhq-,kk=4,rqc=8,cqggjb-,tt=4,mc=7,zs-,czh=6,xnl=7,dltvb-,lbng=8,kv=6,kxb=6,bh=7,ckr=7,bpf=9,pmjz-,kq-,czh-,vb=4,ds=6,bqv-,bfq-,zct=7,lkmt-,qx=4,hb-,zf=6,fsb=3,nc-,lmx=9,pcv-,ntbjb-,kf-,vm-,cnq=3,lbp-,hb-,dsqgh-,llh=4,ftdll=7,ns-,sn-,qzts=8,xf-,ts-,lbp-,nn=5,ksr-,xnfpt=6,glmz=5,vfk=9,jgts-,rkd=6,jqhkf=6,xsr=6,nbk=5,kp=7,mkvj=9,lnh-,zfxmb=9,xrlqx=9,gd=6,jf-,hqngsj-,vxzxc=7,kq=1,bp=4,gl=9,zbb=9,bd-,kt=4,jtc=9,hdt=2,ngfn-,xd-,zxm=1,lkmt=1,fj=1,kthg-,jzd=7,lnh-,jrqk-,mztj=3,kh=8,fntl-,fp-,dsz-,tkm-,fps=9,jb=8,vs-,vvd=3,bhxnh=9,rrl-,zr=4,mqr-,bq-,kgm=1,clt-,kthg-,srn=1,qjh-,kgq-,lkt-,vxzxc-,tdvm-,gdlq-,qbms=7,kdn-,gd=2,gdm-,hkbf=9,ltp=4,mfnkh=7,qh=4,vvd=6,ht-,hjq-,dsqgh-,pch=5,pcv=9,xz=2,sh=3,mql=4,xgnr=1,zct=7,qbms-,jj-,xfb-,qk=8,bh=9,hkbf=4,mztj-,sc-,nknrvm=6,zc=4,rr-,fps=7,dtr-,vgk-,rkd=4,cbv-,cv-,sgmp-,kxb=1,mks=4,tkl=1,pcp-,ntbjb-,cv=5,vkk=9,clt=9,ftdll=1,hpph=4,htm=9,nng-,fkdp-,xnfpt-,vs-,bqv=6,qqz-,vgk-,kxmpd=8,fl=7,bm-,hhhx=4,qzts=3,srn-,kv=3,cm-,tk-,dm=2,kfhn=6,mql=2,mdzc=5,pm=7,nbd-,brfm-,gj-,tvd=4,tmfn=5,dltvb-,gm=9,ln=1,nvp=2,mdjn=5,mfg=8,tnsmf=6,qkl=5,dc=8,bdm=9,kdn=9,nscnp=5,hb=8,zgj-,lmdg-,dhb=1,mkvj-,bfq=3,ljd=9,xhgt=6,jp-,zpn-,krsqtb=1,ztgx=1,htm=8,bfq=8,dqclp-,qkl=4,cdh-,pk=3,zxdj=3,gxkv-,kkgj-,xlc-,xhblcq-,hx=6,xhgt-,fntc-,fps=3,pcp=2,xj-,xhblcq-,hb-,fgz-,hdvdp-,gtj=7,qnjfm-,mfg=1,bp-,tn-,bqv=5,rd=4,pnfmgj-,dkzsqb=2,ds=2,jgts=7,pch=8,bb-,sdv-,tk=2,xtp-,jx=7,mf-,kx=8,dqclp=3,fntc-,dtr=1,nvp=5,vrg-,ngfn=1,pcv-,pl-,kqm=1,vl=2,btjv-,dl=9,dm=8,hv-,glmz-,ssv=2,njh=1,rfcgxr=8,gnpz-,lv=9,bpf=8,vl-,lbng=2,lkt-,tt=7,pqgmnl=1,rsnbql-,rd-,hxd-,dxtz-,ts-,hd=4,jbf-,cp=9,cm=1,bdx=7,cbn=9,dxdxl-,sjfx-,nsl-,rcb-,hprc-,rkd-,xfb=2,ltp-,nn=5,czh=1,kx=6,vst-,fk=3,sn=1,llh-,hprc=7,bqv=4,dtjxv-,tn-,nckm-,fps-,lsr-,hl=3,rcb-,hrzhq-,cfj=4,nbk-,gmt-,qh-,nknrvm=4,qn-,tt-,xvx=6,gxkv=4,dtr=5,fjg=1,mdjn-,vs=1,dsqgh-,rr=5,ml-,spv=4,ll=7,cntd=3,gd-,qxg=6,nxxhk=8,qvxv-,hprc-,xdpj-,xs=7,pqgmnl-,rbpq=9,mn=3,mql=4,fgdk=4,cdr=5,sn-,mljpt=5,pt-,zf-,lxzg-,gnpz=6,pc=6,zbb-,nscnp-,ptn-,mnmshn=1,xmd-,tczns=2,gpmx=5,nf-,pch=2,lj=1,frb-,crqn-,nbd=3,gtf-,lsl-,fgdk=8,xs-,hpph-,kthg-,dkzsqb-,qn-,cgb-,fnqkh-,vl-,kgq-,kbvd-,jrqk-,jclf-,cntd=9,ksl-,ctl-,klpm=8,rbpq-,jcj-,nlmj-,qxg-,jl=4,cbv-,nqqm=8,pmlhn=9,vl=8,bp=5,tczns-,spv=3,ksr=7,zb-,ztgx=5,bm=2,lrz-,lrz=3,vkk=4,nch=3,ngfn=9,nklnq=5,jtc=8,ht=9,nfk-,fnqkh-,xsk-,pkdf-,jxp-,jm-,sxzhh-,zr-,svg=8,kv=4,sxv-,kxmpd-,jgp=8,qdjff=3,fgdk=4,xnfpt-,lkbj=4,xd=2,jclf-,ht-,bq=3,gl=8,jtc-,pc=4,tnc-,sdnmh=4,kf=1,lgx-,dvc-,rg-,hff-,sqz-,zc-,hjq-,xdpj-,pt=9,xh-,llh-,mp=7,lbng-,mqg-,qdjff-,zfl=1,kkgj-,dhb=5,sdnmh-,jc=9,hsm-,rt=4,xf=1,xdpj=6,qcrvs-,hsm=7,mqg=7,hsblgj=9,sk-,ckr=9,xl-,kq-,cbvr-,cdh-,sndpd=2,sk-,qnjfm=5,jjfl-,tmfn=6,nknrvm=4,dsz-,zt=6,nc=2,btjv=5,bhxnh=9,ld=4,rr=1,kv=2,jxp-,tkl-,dr-,pldx=1,jh=2,gg-,jclf=5,kgm-,fgz-,rkd-,xlf-,vpk-,zt-,nckm-,sc-,vm-,jfjgt-,jp-,tpfrc=8,bknq-,dr-,jzv-,hjq-,kdn=6,fps-,tkm=8,glmz-,xlc=5,xz=2,bdz-,gpz=6,vck-,lv-,lxzg-,zpfsz=2,kcv=1,xdfb-,jcj-,bdx=1,pdk=8,qqz-,fk-,tgg-,hrzhq-,lrt=9,zh-,jhf-,kq-,llq=2,fgdk-,hbp=9,hrzhq-,ckprt=2,cncd-,fx-,pmjz-,pc-,hprc-,rbpq=6,jzrhx-,bknq-,nf-,jrqk=3,czj-,tt=8,hdt=9,rsnbql-,nng-,hpph-,cbbt-,tk=7,zpn=1,cb=5,zgt-,btjv-,ddf-,mfnkh=4,bp-,bd=9,zlqd=9,cx-,fgdk-,jb-,ld-,dvc-,kcv-,lkbj=8,mf-,hj=8,px=5,zpn-,qzts-,glmz-,rxkp-,rs=8,hsblgj-,bq-,ztgx=2,qvxv-,qbms-,nlmj-,sndpd-,sxzhh-,nbd=2,cnq=6,qm=5,dqclp=3,vrg=6,sjfx=8,rt-,hsblgj=5,tj=8,xg-,bknq=1,bdm-,zpn-,hd-,kjzsmv=1,fhp=9,hrrmd=1,ftdll-,xdpj-,dtr-,rbzlx-,nc-,fj-,rr=4,tg-,pmjz=1,kmmvl-,pnm-,glnl=9,rfbn-,hdt=6,sndpd=3,dkp=3,hbp-,sctzlm-,qn-,xdpj-,kq-,zpfsz-,vrrqpg=3,pt=3,qcf-,mfbj=3,hv-,jgp-,mfr=5,cmsf-,mql-,dsz-,dvc-,xdqd=9,lbng=9,fntl=1,kmmvl=3,hjq=4,rvnklp-,fptk=5,qqz=5,tkpp-,qm-,pmd=6,mfnkh=7,kp-,kvjm=9,xrl-,bd-,nch-,fp-,sn=8,zh-,vtm=2,bfq=4,zfh=7,sqz=9,km=9,qkx=1,xb=3,fgdk=2,cbn-,bq-,frb=2,fvjj-,vl-,zfxmb=7,dh=1,fntl-,ckprt-,gmt=9,px=3,mn=4,gl=6,rg=8,sc=4,ltp-,mvs-,kq-,tkxd-,tnr=9,nvp-,pch-,jhf=1,fkdp=7,rmdlr=4,qjh-,hdvdp=3,zf=1,pzz-,mvs=5,rcb-,vl=7,fptk=8,ckr=3,hb-,mc-,qbp=2,nvp-,pk=6,tlhm=4,rf-,ljd-,jzd=4,sxv-,pzz=6,pt=9,lsr-,tvd=2,dr=2,zs=4,sqz=1,dh=9,zb-,hdvdp=5,kvtcc=8,mfr=4,tnr-,nf=4,qc-,lkbj-,cb=2,qx=9,cgb=7,rk=9,zxdj-,mbd=9,bgzmkc=7,mr-,ksr=2,mvs=7,xgmft=6,dkp=1,nknrvm=3,hc=8,rf=8,fntl-,cp-,xhblcq=2,sndpd=1,xpj=2,xlf=4,pmjz=6,nxxhk=9,hdvdp-,gnpz=1,mvs=2,kthg=2,nbd=5,qvxv=7,pdk-,cmsf=7,jzbv=6,vkk=1,sp-,fdf-,dsqgh-,jhf=3,dhg=6,knf-,mfbj-,ctz-,jqh=1,nbq-,jzbv=8,mn=5,xfb=3,nklnq=8,cntd-,mfnkh-,pkdf-,mfbj-,ts=4,gdlq-,cfj=2,nfk=4,nhgz-,zb-,cdh-,nklnq-,fdf=6,kjzsmv-,cp-,fbhzcd-,rxkp-,rb-,lkmt-,czh=8,xlf=9,llq-,jxp=3,rcb-,fsb=9,cv=5,bs=6,hsm=1,cbbt=4,mtkbz=8,cmsf-,vl=1,kqkl-,xsr-,zlc-,qkx-,dsg=9,hsm-,hff-,dx=3,pkdf=4,zbb-,zbb-,pl-,flzg=3,rxkp=1,dsg-,hq-,bm=5,sndpd-,rfbn=4,jfjgt=8,tnc=1,qk-,gdlq=5,fx-,cbbt-,mp-,zfxmb=9,kkgj-,lc-,rb=5,cbv=1,dzrg-,nbq=6,qdh=5,bnzq=6,zs=5,czh=3,rk-,mn=7,hjq=3,pkdf=6,zr-,mz-,dkzsqb-,pmjz-,dxtz=9,hd-,lkmt=9,nbq-,zgj=9,fndhj-,ctl-,fx=3,xl=1,kbvd-,rxkp=1,ckr-,cbvr=1,bb=2,xfb-,rfbn=5,ksl=9,kq=6,kjq-,qqz-,xrlqx=3,dkzsqb-,rrv=6,vkk=2,cbv=7,mnmshn-,kkgj=4,mtr-,czh=5,tt-,vtld=1,mtr-,bknq=2,fjg=2,pmd=7,rd-,mfbj=8,jp=7,pnfmgj=8,fszj=5,tp-,fx=3,ppd-,zct=4,gj-,glnl-,kd=5,dpq-,xtp=7,ngfn=7,ljd=8,xs=6,jz-,lkbj-,bf=6,dtr=4,tn-,jclf=1,ld=4,sgmp=8,hnb=2,sjfx-,dvc=7,pbnr=6,xb-,pg-,rx-,rx-,pzz=8,zz-,vmcq=7,cx-,dpp=1,fp=7,dpp=1,srn-,zpfsz=3,nf=4,tkxd-,lnh=4,zz=4,vl=5,sdv-,bm-,qtk=1,ft-,pbnr-,qtk-,xvx=7,nckm-,bdx=2,bgzmkc-,mz-,zbb-,gdlq=6,vb-,zkknr=2,zfxmb-,bb=4,cntd-,pk-,hmt-,kxb-,pxhkd=5,ftdll-,qggxgx-,cntd=4,nvc=5,tmfn-,vb-,xf-,td=9,cncd=6,rp=4,xdpj-,cp-,tg=9,jp-,ksl-,jj-,bqv=7,nscnp=7,hc-,nsl=2,dpp-,xs-,ppd-,zfl-,qtk-,hxd=4,czh=1,mqh-,cbv=6,ctz-,llq-,hv=1,ld-,njkr-,jzv=5,tkm=7,xs-,dhg=9,mqg=3,rp=3,rvnklp-,ltp=5,jcj=9,qvd=7,dxtz=7,dh=8,kq-,vkk=4,tnr=9,ts-,mzn-,fj=6,jzrhx=9,pk=5,ptn-,nsf-,ssv=1,bdz-,rcb-,cr-,cgb-,jm-,fk-,btjv=4,kqm=3,ktz-,pb=5,fntl-,rxkp=7,phl=3,flzg-,zct-,vpk-,cm-,nhgz-,xrl=5,kx-,msb-,fntc-,mfg=2,fl-,nvp=3,jhf=3,nqqm=6,nf=7,cgb=6,qh=7,jzbv-,fsb=9,fnqkh-,fkdp-,tj=4,hbp-,fbhzcd-,bxmz-,lkmt=2,rs-,nbq-,xtp-,xrlqx=9,ksr=2,mqr-,tsv=4,qqz=7,sxzhh=4,zz=5,tvd=1,mnmshn-,xrl=5,gm=7,jtc-,pl-,nc-,rfcgxr=4,msb-,tg-,hb-,zpfsz-,rmdlr=4,pzz-,pb=5,qm=7,ns-,xdgcfh-,cf=2,pf-,ps=3,mtr=7,hj=3,hv=9,qjh=9,jb=4,hj-,mvgfg=5,xmd=5,lsl-,xhgt-,zpn-,qzgb=3,lrqrhk=3,zpfsz=3,vfk=4,xpt-,gn-,sl-,xm=4,ctz=7,hb-,gpz-,kvjm=2,rb-,jhs=4,ds=3,rk-,sbd-,rp=1,kr=4,ftdll=1,bh=7,zxm-,nsl=7,xgnr=8,sh=6,vtm-,cnq-,ddf=6,nfk=2,qkx-,hq=3,tnr-,nqqm-,xd=8,cntd=1,zgt-,nsl-,mz-,ql-,svg=8,cncd=9,ntbjb=6,lj=3,hdg-,mc=3,vm=4,fntc=9,tt-,km=1,fj=8,fbhzcd=7,tt=4,fk-,pt-,kf=1,kh=8,kdn-,mfnkh-,jjhd-,btjv-,kgm-,tnr-,zb-,zf=4,hv-,ts-,cdr-,rv-,vs-,frb-,zct-,gpz-,htm=3,mn-,nbh-,dxtz=2,zpfsz-,ksl=4,cm-,dsqgh=1,pzz-,lrqrhk-,bd-,jh-,cmsf-,smf-,jl=2,bh=4,mfbj=1,mzn-,dsqgh=2,hx=5,lrnz-,vtm-,ckr-,lkt-,ssv-,klpm=4,kt-,bnzq=2,dtr=8,hsm=7,kf-,tdvm-,hjq-,dvc-,pcv-,vvt-,bp-,jcj=3,sndpd-,xfb=9,vd=7,gb-,sb=6,nsf=4,cbvr=7,phl=5,fl=7,fsb-,mtkbz=5,sbd=4,vs-,tkm=7,rx-,zlc=9,xnl-,jb=3,rp-,qcrvs=8,zb=7,xnl=5,lrt=4,rv=9,mqg-,rmdlr-,ckprt-,mqh-,nhgz=3,spv-,xm=8,nlmj=7,fvjj-,lsl-,xb-,vtld-,gn-,gd-,cv-,pg-,fgdr=9,sgmp=5,xj=4,zt-,fgz=3,krsqtb=8,jhs-,kd=9,fvjj=4,ptn=3,sgmp=7,ckprt-,hnb=1,mfg-,qqc-,mfg=1,gpmx=8,kmmvl=7,nc-,sxzhh-,mq=9,hpph=5,xgnr=6,tpfrc=9,zf-,qk=6,hj=3,czh=5,cnq=4,frb=3,ptn=8,sjn=3,tj=4,rkd-,sjn=7,hv=5,gd-,lkmt=1,ppd-,tkm=4,sxv-,ln=7,hprc-,cr=8,xdqd-,sbd=9,sxzhh-,pc-,zqsd=3,cdr=3,nknrvm=4,sc=8,fgdk=7,mz=6,hhhx-,hq-,qbms=3,cbvr-,mks-,hprc=1,nch-,fntc-,vgk-,ld-,rfcgxr-,nf=1,hdt-,rbpq=6,jhs=9,kvjm=3,pdk=8,mqr-,dtr=9,jjhd=1,gpz=9,qk-,nch=6,njh=4,ft=8,mnmshn=7,tgsdsb-,xrl=1,sctzlm-,tj-,llphh-,cdr-,tkl=2,vl-,ht=1,bpf=2,bpf-,gnpz-,tsv-,ps-,mp-,kthg-,tgsdsb=4,bqv-,rp=7,dpp=9,rkd-,gmt-,qc-,zlc=7,gl-,ts=1,vrrqpg=1,jm-,mks-,jfjgt=3,kcv-,msb=6,nbq-,qvd=7,gxkv-,dsg-,zlqd-,qzts-,dpp-,xhblcq=3,hsblgj=8,vmcq=3,cv-,mfbj=5,fndhj=1,dv-,ctz=5,bknq-,sp=2,rhq-,fx-,lcv-,cnq-,hv=9,jzrhx-,hh=9,bm-,jclf-,dm-,sndpd=6,bh=2,fbh=6,dm=3,frb-,zpn-,cdr=5,jzbv=8,dh-,qdh=6,lcv-,ngfn-,dzrg=3,xgnr=7,kjq=4,sqz-,fp=7,tn-,bdm=1,hgxd=7,srn-,fjg-,rsnbql-,sgmp-,xfb-,jxp-,bf=9,fkdp=6,tkm-,jj-,kk-,tmfn=3,mzn=4,xdqd-,rvnklp=4,nsl=4,jfjgt=9,qk=6,bdm=7,ddf=5,bhxnh-,rfbn=9,ln-,xj-,xb-,lbng-,xs-,ftdll-,lbng=5,gltc-,lnh-,kthg=5,fps=3,km=4,jpk=6,ft=8,bpf=6,nn-,ds=1,mn=5,jqh-,xlf=6,mfnkh=6,dc=9,tp=3,bnzq=1,xsk=7,lrqrhk-,gn-,mqh=5,bf=1,fl=5,crqn=9,dm=6,cfj-,kcv=6,zlqd=5,fkdp=8,sgmp-,rqc=8,bdz=5,qjv-,vd=2,gxkv=3,bdm=1,msb=1,fnqkh=7,df=9,rd=3,xhgt-,ts-,stldk=9,gn=3,dv=5,dvc=6,lkbj=2,mfbj-,hl-,rvnklp-,sbd=8,klq-,qdjff=5,lc=6,pch=7,hm=2,gdlq-,kjzsmv-,dsz=3,gd=4,vfk-,jbf=5,srn=9,stldk=5,kqkl-,bf=1,dhb-,ngfn-,ftdll=1,xd-,hprc=2,nng-,rcb=3,dsg=9,cbbt=3,fkdp-,bq=7,tkpp-,dtjxv-,hxd=1,rg-,rs=7,gg-,jbf=8,nvc-,jxxhbv-,dxtz-,fkdp-,gjtf-,ll-,xz-,bfq=6,rt=7,mfnkh=1,hdt-,cv-,hbp=7,hxd=1,gl=6,nsl-,ftdll=7,zbb-,vb-,zqsd=1,qjv=6,ng-,nvc-,zs-,zfh-,lnh=3,hxd-,lbng-,ctz-,knf-,jzd-,mqg-,gxkv-,pc=1,hc-,qxg-,dtr-,dkp-,hl=5,xdqd-,rk-,mtr-,qjv=9,lv-,vpk=7,hjq-,mvgfg=4,sqz=8,ng-,jxxhbv=7,zxm=1,kjzsmv-");
307 |         }
308 | 
309 | 
310 |         [Fact]
311 |         public void can_parse_lookbehind()
312 |         {
313 |             data.Extract<string>(@"(?<=(12))");
314 |         }
315 | 
316 |         [Fact]
317 |         public void can_extract_to_tuple()
318 |         {
319 |             var (a, b, c, d, e, f, g, h, i) = data.Extract<(int, char, string, int, char, string, int, char, string)>(pattern);
320 | 
321 |             Assert.IsType<int>(a);
322 |             Assert.IsType<char>(b);
323 |             Assert.IsType<string>(c);
324 |             Assert.IsType<int>(d);
325 |             Assert.IsType<char>(e);
326 |             Assert.IsType<string>(f);
327 |             Assert.IsType<int>(g);
328 |             Assert.IsType<char>(h);
329 |             Assert.IsType<string>(i);
330 | 
331 |             Assert.Equal(1, a);
332 |             Assert.Equal('2', b);
333 |             Assert.Equal("3", c);
334 |             Assert.Equal(4, d);
335 |             Assert.Equal('5', e);
336 |             Assert.Equal("6", f);
337 |             Assert.Equal(7, g);
338 |             Assert.Equal('8', h);
339 |             Assert.Equal("9", i);
340 |         }
341 | 
342 |         record PositionalRecord(int a, char b, string c, int d, char e, string f, int g, char h, string i);
343 | 
344 |         [Fact]
345 |         public void can_extract_to_positional_record()
346 |         {
347 |             PositionalRecord? record = data.Extract<PositionalRecord>(pattern);
348 | 
349 |             Assert.NotNull(record);
350 | 
351 |             var (a, b, c, d, e, f, g, h, i) = record!;
352 | 
353 |             Assert.IsType<int>(a);
354 |             Assert.IsType<char>(b);
355 |             Assert.IsType<string>(c);
356 |             Assert.IsType<int>(d);
357 |             Assert.IsType<char>(e);
358 |             Assert.IsType<string>(f);
359 |             Assert.IsType<int>(g);
360 |             Assert.IsType<char>(h);
361 |             Assert.IsType<string>(i);
362 | 
363 |             Assert.Equal(1, a);
364 |             Assert.Equal('2', b);
365 |             Assert.Equal("3", c);
366 |             Assert.Equal(4, d);
367 |             Assert.Equal('5', e);
368 |             Assert.Equal("6", f);
369 |             Assert.Equal(7, g);
370 |             Assert.Equal('8', h);
371 |             Assert.Equal("9", i);
372 |         }
373 | 
374 |         [Fact]
375 |         public void fails_when_positional_record_is_wrong_arity()
376 |         {
377 |             Assert.Throws<ArgumentException>(() => data.Extract<PositionalRecord>(pattern_nested));
378 |         }
379 | 
380 |         record PropertiesRecord
381 |         {
382 |             public string? s { get; init; }
383 |             public long? n { get; init; }
384 |             public int? a { get; init; }
385 |             public char? b { get; init; }
386 |             public string? c { get; init; }
387 |             public int? d { get; init; }
388 |             public char? e { get; init; }
389 |             public string? f { get; init; }
390 |             public int? g { get; init; }
391 |             public char? h { get; init; }
392 |             public string? i { get; init; }
393 |         }
394 | 
395 |         record Passport
396 |         {
397 |             public int? byr { get; set; }
398 |             public int? iyr { get; set; }
399 |             public int? eyr { get; set; }
400 |             public string? hgt { get; set; }
401 |             public string? hcl { get; set; }
402 |             public string? ecl { get; set; }
403 |             public string? pid { get; set; }
404 |         }
405 | 
406 |         [Fact]
407 |         public void can_extract_mondo_conditional_regex()
408 |         {
409 |             var mondoString = @"
410 | ^(?:\b
411 | (?: (?:byr: (?:(?<byr>19[2-9][0-9]|200[0-2])                           |.*?) )
412 | |    (?:iyr: (?:(?<iyr>20(?:1[0-9]|20))                                   |.*?) )
413 | |    (?:eyr: (?:(?<eyr>20(?:2[0-9]|30))                                   |.*?) )
414 | |    (?:hgt: (?:(?<hgt>(?:(?:59|6[0-9]|7[0-6])in)|(?:1(?:[5-8][0-9]|9[0-3])cm)) |.*?) )
415 | |    (?:hcl: (?:(?<hcl>\#[0-9a-f]{6})                                   |.*?) )
416 | |    (?:ecl: (?:(?<ecl>amb|blu|brn|gry|grn|hzl|oth)                     |.*?) )
417 | |    (?:pid: (?:(?<pid>[0-9]{9})                                        |.*?) )
418 | |    (?:cid: (?:.*?)                                                          )
419 | )
420 | \b\s*)+
421 | $
422 | ";
423 |             var mondo = new Regex(mondoString, RegexOptions.IgnorePatternWhitespace);
424 | 
425 |             var result = "hgt:61in iyr:2014 pid:916315544 hcl:#733820 ecl:oth".Extract<Passport>(mondoString,RegexOptions.IgnorePatternWhitespace);
426 | 
427 |             Assert.Equal(new Passport { hgt = "61in", iyr = 2014, pid = "916315544", hcl = "#733820", ecl = "oth" }, result);
428 | 
429 |             //TODO: this was the only test using the `this Match` extension for Extract. Should re-add one.
430 |         }
431 | 
432 |         record Container
433 |         {
434 |             public string? container { get; init; }
435 |             public List<int?>? count { get; init; }
436 |             public List<string?>? bag { get; init; }
437 |             public string? none { get; init; }
438 |         }
439 | 
440 |         [Fact]
441 |         public void can_extract_capture_collections_to_lists()
442 |         {
443 |             var line = "faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.";
444 |             var regex = @"^(?<container>.+) bags contain(?: (?<none>no more bags\.)| (?<count>\d+) (?<bag>[^,.]*) bag[s]?[,.])+$";
445 | 
446 |             var output = line.Extract<Container>(regex);
447 | 
448 |             Assert.Equivalent(new Container
449 |             {
450 |                 container = "faded yellow",
451 |                 count = new List<int?> { 4, 4, 3, 5 },
452 |                 bag = new List<string?> { "mirrored fuchsia", "dotted indigo", "faded orange", "plaid crimson" },
453 |                 none = null
454 |             }, output);
455 |         }
456 | 
457 |         [Fact]
458 |         public void can_extract_single_item()
459 |         {
460 |             var output = "asdf".Extract<string>("(.*)");
461 |             Assert.Equal("asdf", output);
462 | 
463 |             var n = "2023".Extract<int>(@"(\d+)");
464 |             Assert.Equal(2023, n);
465 |         }
466 | 
467 |         [Fact]
468 |         public void can_extract_multimatch_to_list()
469 |         {
470 |             var result = "123 456 789".Extract<List<int>> (@"(?:(\d+) ?)+");
471 | 
472 |             Assert.Equal([123, 456, 789], result);
473 |         }
474 | 
475 |         [Fact]
476 |         public void can_extract_multimatch_to_hashset()
477 |         {
478 |             var result = "123 456 789".Extract<HashSet<int>>(@"(?:(\d+) ?)+");
479 | 
480 |             Assert.Equal(new HashSet<int> { 123, 456, 789 }, result);
481 |         }
482 | 
483 |         [Fact]
484 |         public void can_extract_alternation_to_tuple()
485 |         {
486 |             var result = "asdf".Extract<(int?, string)>(@"(\d+)|(.*)");
487 | 
488 |             Assert.Equal((null, "asdf"), result);
489 |             
490 |             result = "123".Extract<(int?, string)>(@"(\d+)|(.*)");
491 | 
492 |             Assert.Equal((123, null), result);
493 |         }
494 | 
495 |         record Alternation(int? n, string s);
496 | 
497 |         record NamedAlternation
498 |         {
499 |             public int? n { get; init; }
500 |             public string? s { get; init; }
501 |         }
502 | 
503 |         [Fact]
504 |         public void can_extract_alternation_to_record()
505 |         {
506 |             var result = "asdf".Extract<Alternation>(@"(\d+)|(.*)");
507 | 
508 |             Assert.Equal(new Alternation(null, "asdf"), result);
509 | 
510 |             var result_named = "asdf".Extract<NamedAlternation>(@"(?<n>\d+)|(?<s>.*)");
511 | 
512 |             Assert.Equal(new NamedAlternation { n = null, s = "asdf" }, result_named);
513 |         }
514 | 
515 |         [Fact]
516 |         public void can_extract_enum()
517 |         {
518 |             var result = "Asynchronous,Encrypted".Extract<System.IO.FileOptions>(@".*");
519 | 
520 |             Assert.Equal(System.IO.FileOptions.Asynchronous | System.IO.FileOptions.Encrypted, result);
521 |         }
522 | 
523 |         record WithTemplate(string op, int arg)
524 |         {
525 |             public const string REGEXTRACT_REGEX_PATTERN = @"(\S+) ([+-]?\d+)";
526 |             public const RegexOptions REGEXTRACT_REGEX_OPTIONS = RegexOptions.None;
527 |         }
528 | 
529 |         [Fact]
530 |         public void can_extract_with_template()
531 |         {
532 |             var result = "acc +7".Extract<WithTemplate>();
533 | 
534 |             Assert.Equal(new WithTemplate("acc", 7), result);
535 |         }
536 | 
537 |         const RegexOptions opts = RegexOptions.IgnoreCase|RegexOptions.Multiline;
538 | 
539 |         [Fact]
540 |         public void can_extract_to_string_constructor()
541 |         {
542 |             var result = "https://www.google.com/ 12345".Extract<(Uri,int)>(@"(.*) (\d+)");
543 |             Assert.Equal((new Uri("https://www.google.com/"), 12345), result);
544 |         }
545 | 
546 |         [Fact]
547 |         public void regex_does_not_match()
548 |         {
549 |             Assert.Throws<ArgumentException>(()=>"https://www.google.com/".Extract<Uri>(@"\d+"));
550 |         }
551 | 
552 |         record bounds(int lo, int hi);
553 | 
554 |         Regex rx_nested_extraction = new(@"((\d+)-(\d+)) (.): (.*)");
555 | 
556 |         [Fact]
557 |         public void nested_extraction()
558 |         {
559 |             // TODO: Why is this so much slower than nested_extraction_control?
560 |             var result = "2-12 c: abcdefg".Extract<(bounds, char, string)>(rx_nested_extraction);
561 | 
562 |             //Assert.Equal((new bounds(2, 12), 'c', "abcdefg"), result);
563 |         }
564 | 
565 |         [Fact]
566 |         public void nested_extraction_control()
567 |         {
568 |             var result = "2-12 c: abcdefg".Extract<((int lo, int hi), char ch, string str)>(rx_nested_extraction);
569 | 
570 |             //Assert.Equal(((2, 12), 'c', "abcdefg"), result);
571 |         }
572 | 
573 | 
574 |         [Fact]
575 |         public void nested_extraction_of_list()
576 |         {
577 |             // TODO: Why does this need the outer parens here: "((\w)+)"?
578 |             var plan = ExtractionPlan<List<List<char>>>.CreatePlan(new Regex(@"((\w)+ ?)+"));
579 |             var str = plan.ToString("x");
580 |             output.WriteLine(str);
581 |             
582 |             var result = plan.Extract("The quick brown fox jumps over the lazy dog.");
583 | 
584 |             Assert.Equal([['T', 'h', 'e'], ['q', 'u', 'i', 'c', 'k'], ['b', 'r', 'o', 'w', 'n'], ['f', 'o', 'x'], ['j', 'u', 'm', 'p', 's'], ['o', 'v', 'e', 'r'], ['t', 'h', 'e'], ['l', 'a', 'z', 'y'], ['d', 'o', 'g']], result);
585 |         }
586 | 
587 |         [Fact]
588 |         public void harder_nested_extraction_of_list()
589 |         {
590 |             // TODO: This currently doesn't quite work without extra parens outsize the top level.
591 |             var plan = ExtractionPlan<List<List<List<char>>>>.CreatePlan(new Regex(@"(((\w)+ ?)+,? ?)+"));
592 |             var str = plan.ToString("x");
593 |             output.WriteLine(str);
594 | 
595 |             var result = plan.Extract("asdf lkj, wero oiu");
596 | 
597 |             Assert.Equal([[['a', 's', 'd', 'f'], ['l', 'k', 'j']], [['w', 'e', 'r', 'o'], ['o', 'i', 'u']]], result);
598 |         }
599 | 
600 |         [Fact]
601 |         public void nested_extraction_of_bags()
602 |         {
603 |             var line = "faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.";
604 |             var regex = @"^(.+) bags contain(?: (no more bags\.)| ((\d+) ([^,.]*)) bag[s]?[,.])+$";
605 | 
606 |             var output = line.Extract<(string,string,List<(int,string)>)>(regex);
607 | 
608 |             Assert.Equivalent(("faded yellow", default(string), new List<(int, string)> { (4, "mirrored fuchsia"), (4, "dotted indigo"), (3, "faded orange"), (5, "plaid crimson") }), output);
609 |         }
610 | 
611 |         [Fact]
612 |         public void extraction_plan()
613 |         {
614 |             var regex = new Regex(@"((\d+)-(\d+)) (.): (.*)");
615 |             var match = regex.Match("2-12 c: abcdefg");
616 |             var plan = ExtractionPlan<((int, int), char, string)>.CreatePlan(regex);
617 |             var result = plan.Extract(match);
618 | 
619 |             output.WriteLine(plan.ToString("x"));
620 | 
621 |             Assert.Equal(((2, 12), 'c', "abcdefg"), result);
622 |         }
623 | 
624 |         [Fact]
625 |         public void extraction_plan_to_long_tuple()
626 |         {
627 |             var regex = new Regex(pattern);
628 |             var match = Regex.Match(data, pattern);
629 |             var plan = ExtractionPlan<(int?, char, string, int, char, string, int, char, string)>.CreatePlan(regex);
630 | 
631 |             var (a, b, c, d, e, f, g, h, i) = plan.Extract(match);
632 | 
633 |             Assert.IsType<int>(a);
634 |             Assert.IsType<char>(b);
635 |             Assert.IsType<string>(c);
636 |             Assert.IsType<int>(d);
637 |             Assert.IsType<char>(e);
638 |             Assert.IsType<string>(f);
639 |             Assert.IsType<int>(g);
640 |             Assert.IsType<char>(h);
641 |             Assert.IsType<string>(i);
642 | 
643 |                  var (verb, year) =
644 |               "Party like it's 1999"
645 |                .Extract<(string, int)>
646 |             (@"(\w+) like it's (\d)+");
647 | 
648 |             Assert.Equal(1, a);
649 |             Assert.Equal('2', b);
650 |             Assert.Equal("3", c);
651 |             Assert.Equal(4, d);
652 |             Assert.Equal('5', e);
653 |             Assert.Equal("6", f);
654 |             Assert.Equal(7, g);
655 |             Assert.Equal('8', h);
656 |             Assert.Equal("9", i);
657 |         }
658 |         
659 |         [Fact]
660 |         public void debug()
661 |         {
662 |             //var data = "faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.";
663 |             //var plan = RegexExtractionPlan.CreatePlan<(string, string, List<(int?, string)?>)>(@"^(.+) bags contain(?: (no other bags)\.| ((\d+) (.*?)) bags?[,.])+$");
664 |             //var result = plan.Execute(Regex.Match(data, @"^(.+) bags contain(?: (no other bags)\.| ((\d+) (.*?)) bags?[,.])+$"));
665 | 
666 |             var (plan, str) = CreateAndLogPlan<bagdescription>(new Regex(@"^(?<name>.+) bags contain(?: (?<none>no other bags)\.| (?<contents>(\d+) (.*?)) bags?[,.])+$"));
667 |             var result = plan.Extract("faded yellow bags contain 4 mirrored fuchsia bags, 4 dotted indigo bags, 3 faded orange bags, 5 plaid crimson bags.");
668 | 
669 |             Assert.Equivalent(new bagdescription { name = "faded yellow", contents = new List<includedbags> { new includedbags(4, "mirrored fuchsia"), new includedbags(4, "dotted indigo"), new includedbags(3, "faded orange"), new includedbags(5, "plaid crimson") } }, result);
670 |         }
671 | 
672 |         record bagdescription
673 |         {
674 |             public string? name { get; init; }
675 |             public string? none { get; init; }
676 |             public List<includedbags>? contents { get; init; }
677 |         }
678 |         record includedbags(int? num, string name);
679 | 
680 |         [Fact]
681 |         public void CreateTreePlan()
682 |         {
683 |             var regex = new Regex(@"((\d+)-(\d+)) (.): (.*)");
684 |             var plan = ExtractionPlan<((int?, int?)?, char, string)?>.CreatePlan(regex);
685 |             object? result = plan.Extract(regex.Match("2-12 c: abcdefgji"));
686 | 
687 |             regex = new Regex(@"((\w)+ ?)+");
688 |             var plan2 = ExtractionPlan<List<List<char>>>.CreatePlan(regex);
689 | 
690 |             result = plan2.Extract(regex.Match("The quick brown fox jumps over the lazy dog"));
691 |         }
692 | 
693 |         [Fact]
694 |         public void deep_tuple_type_tree()
695 |         {
696 |             var (plan, str) = CreateAndLogPlan<(int, (int, int), int, int, int, int, (int, (List<int>, int)), int, int, int, int, int, int, int, int)>(new Regex(@"(\d+) \(((\d+) (\d+))\) (\d+) (\d+) (\d+) (\d+) ((\d+) \(((\d+ ?)+ (\d+))\)) (\d+) (\d+) (\d+) (\d+) (\d+) (\d+) (\d+) (\d+)"));
697 | 
698 |             var result = plan.Extract("1 (2 3) 4 5 6 7 8 (9 10 11 12 13) 14 15 16 17 18 19 20 21");
699 | 
700 |             Assert.Equivalent((1, (2, 3), 4, 5, 6, 7, (8, (new List<int> { 9, 10, 11, 12 }, 13)), 14, 15, 16, 17, 18, 19, 20, 21), result);
701 |         }
702 | 
703 |         [Fact]
704 |         public void can_create_polymorphic_parse_plan()
705 |         {
706 |             var (plan, str) = CreateAndLogPlan<instr>(new Regex(@"(.*)"));
707 |             var results = plan.Extract("mask = lkjasdf");
708 |             Assert.Equal(new maskinstr("lkjasdf"), results);
709 |         }
710 | 
711 |         record instr()
712 |         {
713 |             public static instr Parse(string str)
714 |             {
715 |                 if (str.StartsWith("mask"))
716 |                 {
717 |                     return str.Extract<maskinstr>(@"mask = (.+)")!;
718 |                 }
719 |                 else
720 |                 {
721 |                     return str.Extract<meminstr>(@"mem\[(\d+)] = (\d+)")!;
722 |                 }
723 |             }
724 |         }
725 |         record maskinstr(string mask) : instr;
726 |         record meminstr(long loc, long val) : instr;
727 | 
728 |         private (ExtractionPlan<T>,string) CreateAndLogPlan<T>(Regex rx)
729 |         {
730 |             var plan = ExtractionPlan<T>.CreatePlan(rx);
731 |             var str = plan.ToString("x");
732 |             output.WriteLine(str);
733 | 
734 |             return (plan, str);
735 |         }
736 |     }
737 | }
738 | 
739 | // This is here to enable use of record types in .NET 3.1.
740 | namespace System.Runtime.CompilerServices
741 | {
742 |     internal static class IsExternalInit { }
743 | }
744 | 


--------------------------------------------------------------------------------