├── .gitignore
├── Parser
    ├── App.config
    ├── Parser.cs
    ├── Parser.csproj
    ├── Parser.csproj.DotSettings
    ├── Parser.ruleset
    ├── Program.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── Yaml
    │   ├── CharacterSpan.cs
    │   ├── Container.cs
    │   ├── ContainerOrTerminalNode.cs
    │   ├── File.cs
    │   ├── IntendedString.cs
    │   ├── LineInfo.cs
    │   ├── LocationSpan.cs
    │   ├── ParsingError.cs
    │   └── TerminalNode.cs
    └── packages.config
├── README.md
├── ResXSemanticParser.sln
├── ResXSemanticParser.sln.DotSettings
├── ResXSemanticParser.v3.ncrunchsolution
├── Screenshots
    ├── ResX_SemanticDiff.png
    ├── ResX_TextDiff.png
    └── ResX_VisualDiff.png
├── Tests
    ├── ParserAdditionalTests.cs
    ├── ParserTests.cs
    ├── Properties
    │   └── AssemblyInfo.cs
    ├── Tests.csproj
    ├── Tests.ruleset
    ├── packages.config
    ├── test.resx
    ├── test2.Designer.cs
    └── test2.resx
├── appveyor.yml
└── codecov.yml


/.gitignore:
--------------------------------------------------------------------------------
1 | /.vs/
2 | *.ncrunchsolution.user
3 | /*/obj/
4 | /*/bin/
5 | /packages/
6 | /_NCrunch*/
7 | *.user
8 | 


--------------------------------------------------------------------------------
/Parser/App.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8" ?>
2 | <configuration>
3 |     <startup> 
4 |         <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
5 |     </startup>
6 | </configuration>


--------------------------------------------------------------------------------
/Parser/Parser.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Xml;
  5 | using System.Xml.Linq;
  6 | 
  7 | using MiKoSolutions.SemanticParsers.ResX.Yaml;
  8 | 
  9 | using File = System.IO.File;
 10 | 
 11 | namespace MiKoSolutions.SemanticParsers.ResX
 12 | {
 13 |     public static class Parser
 14 |     {
 15 |         private static readonly char LineEndingCR = '\r';
 16 |         private static readonly char LineEndingLF = '\n';
 17 |         private static readonly char[] LineEndings = { LineEndingCR, LineEndingLF };
 18 | 
 19 |         public static bool TryParse(string path, out string yamlContent)
 20 |         {
 21 |             var parsingFine = TryParseFile(path, out Yaml.File file);
 22 |             yamlContent = file.ToYamlString();
 23 | 
 24 |             return parsingFine;
 25 |         }
 26 | 
 27 |         public static bool TryParseFile(string path, out Yaml.File yamlContent)
 28 |         {
 29 |             var allText = File.ReadAllText(path);
 30 | 
 31 |             if (string.IsNullOrWhiteSpace(allText))
 32 |             {
 33 |                 yamlContent = new Yaml.File
 34 |                                   {
 35 |                                       Name = path,
 36 |                                       LocationSpan = new LocationSpan(new LineInfo(0, 0), new LineInfo(0, 0)),
 37 |                                       FooterSpan = new CharacterSpan(0, -1),
 38 |                                   };
 39 | 
 40 |                 return true;
 41 |             }
 42 | 
 43 |             return CreateYaml(path, allText, out yamlContent);
 44 |         }
 45 | 
 46 |         private static bool CreateYaml(string path, string allText, out Yaml.File yamlContent)
 47 |         {
 48 |             var lines = LineSplitter.SplitLines(allText);
 49 | 
 50 |             var file = YamlFile(lines, path);
 51 | 
 52 |             XDocument document = null;
 53 |             try
 54 |             {
 55 |                 document = XDocument.Parse(allText, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo);
 56 |             }
 57 |             catch (Exception ex)
 58 |             {
 59 |                 file.ParsingErrors.Add(new ParsingError { ErrorMessage = ex.Message });
 60 |             }
 61 | 
 62 |             var parsingFine = file.ParsingErrors.Count == 0;
 63 |             if (parsingFine)
 64 |             {
 65 |                 var root = YamlRoot(lines, allText);
 66 | 
 67 |                 // adjust footer
 68 |                 var footerStart = root.FooterSpan.End + 1;
 69 |                 var footerEnd = allText.Length - 1;
 70 |                 if (footerStart < footerEnd)
 71 |                 {
 72 |                     file.FooterSpan = new CharacterSpan(footerStart, footerEnd);
 73 |                 }
 74 | 
 75 |                 YamlInfrastructureCommentAndSchema(root, lines, allText);
 76 | 
 77 |                 file.Children.Add(root);
 78 |                 root.Children.AddRange(Yaml("resheader", document, lines));
 79 |                 root.Children.AddRange(Yaml("data", document, lines));
 80 |                 root.Children.AddRange(Yaml("metadata", document, lines));
 81 |                 root.Children.AddRange(Yaml("assembly", document, lines));
 82 | 
 83 |                 // sort based on span
 84 |                 root.Children.Sort(new AscendingSpanComparer());
 85 |             }
 86 | 
 87 |             yamlContent = file;
 88 | 
 89 |             return parsingFine;
 90 |         }
 91 | 
 92 |         private static Yaml.File YamlFile(string[] lines, string fileName)
 93 |         {
 94 |             return new Yaml.File
 95 |                        {
 96 |                            Name = fileName,
 97 |                            LocationSpan = new LocationSpan(new LineInfo(1, 0), new LineInfo(lines.Length, lines.Last().Length)),
 98 |                            FooterSpan = new CharacterSpan(0, -1),
 99 |                        };
100 |         }
101 | 
102 |         private static Container YamlRoot(string[] lines, string allText)
103 |         {
104 |             const string TAG = "root";
105 |             const string STARTTAG = "<" + TAG + ">";
106 |             const string ENDTAG = "</" + TAG + ">";
107 | 
108 |             var endLine = GetLastLineInfo(ENDTAG, lines);
109 | 
110 |             var headerSpan = GetFirstCharacterSpan(STARTTAG, allText);
111 | 
112 |             // adjust root header to include XML header
113 |             headerSpan = new CharacterSpan(0, headerSpan.End);
114 | 
115 |             var footerSpan = GetLastCharacterSpan(ENDTAG, allText);
116 | 
117 |             return new Container
118 |                        {
119 |                            Type = TAG,
120 |                            Name = TAG,
121 |                            LocationSpan = new LocationSpan(YamlLine(1, 1), endLine),
122 |                            HeaderSpan = headerSpan,
123 |                            FooterSpan = footerSpan,
124 |                        };
125 |         }
126 | 
127 |         private static void YamlInfrastructureCommentAndSchema(Container parent, string[] lines, string allText)
128 |         {
129 |             const string ENDTAG = "</xsd:schema>";
130 | 
131 |             if (allText.LastIndexOf(ENDTAG, StringComparison.OrdinalIgnoreCase) >= 0)
132 |             {
133 |                 var startLineComment = GetFirstLineInfo("<!-- ", lines).LineNumber;
134 |                 var startLineSchema = GetFirstLineInfo("<xsd:schema", lines).LineNumber;
135 |                 var startLineLineNumber = Math.Min(startLineComment, startLineSchema);
136 |                 var startLine = new LineInfo(startLineLineNumber, 1); // we want to start at first
137 | 
138 |                 var endLine = GetLastLineInfo(ENDTAG, lines);
139 |                 endLine = new LineInfo(endLine.LineNumber, lines[endLine.LineNumber - 1].Length); // we want to include line breaks
140 | 
141 |                 var endTagSpan = GetLastCharacterSpan(ENDTAG, allText);
142 | 
143 |                 parent.Children.Add(new TerminalNode
144 |                                         {
145 |                                             Type = "schema",
146 |                                             Name = "schema",
147 |                                             LocationSpan = new LocationSpan(startLine, endLine),
148 |                                             Span = new CharacterSpan(parent.HeaderSpan.End + 1, endTagSpan.End),
149 |                                         });
150 |             }
151 |         }
152 | 
153 |         private static IEnumerable<TerminalNode> Yaml(string name, XDocument document, string[] lines) => document.Descendants(name).Select(_ => YamlTerminalNode(_, lines));
154 | 
155 |         private static TerminalNode YamlTerminalNode(XElement element, string[] lines)
156 |         {
157 |             var textAfterClosingTag = element.NodesAfterSelf().First();
158 | 
159 |             var startPosition = GetCharacterPositionAtLineStart(element, lines);
160 |             var endPosition = GetCharacterPositionAtLineEnd(textAfterClosingTag, lines);
161 | 
162 |             var localName = element.Name.LocalName;
163 | 
164 |             return new TerminalNode
165 |                        {
166 |                            Type = localName,
167 |                            Name = element.Attribute("name")?.Value ?? localName,
168 |                            LocationSpan = new LocationSpan(YamlLineStart(element), YamlLineEnd(textAfterClosingTag)),
169 |                            Span = new CharacterSpan(startPosition, endPosition),
170 |                        };
171 |         }
172 | 
173 |         private static LineInfo YamlLineStart(IXmlLineInfo node) => YamlLine(node.LineNumber, 1);
174 | 
175 |         private static LineInfo YamlLineEnd(IXmlLineInfo node)
176 |         {
177 |             var content = node.ToString();
178 | 
179 |             if (node is XText)
180 |             {
181 |                 var lines = LineSplitter.SplitLines(content);
182 |                 content = lines[0];
183 |             }
184 | 
185 |             return YamlLine(node.LineNumber, node.LinePosition - 1 + content.Length);
186 |         }
187 | 
188 |         private static LineInfo YamlLine(int lineNumber, int linePosition) => new LineInfo(lineNumber, linePosition);
189 | 
190 |         private static LineInfo GetFirstLineInfo(string tag, string[] lines)
191 |         {
192 |             var lineNumber = 0;
193 |             var linePosition = -1;
194 | 
195 |             foreach (var line in lines)
196 |             {
197 |                 lineNumber++;
198 | 
199 |                 linePosition = line.IndexOf(tag, StringComparison.OrdinalIgnoreCase);
200 |                 if (linePosition != -1)
201 |                 {
202 |                     linePosition += tag.Length;
203 |                     break;
204 |                 }
205 |             }
206 | 
207 |             return new LineInfo(lineNumber, linePosition);
208 |         }
209 | 
210 |         private static LineInfo GetLastLineInfo(string tag, string[] lines)
211 |         {
212 |             var lineNumber = 0;
213 |             var linePosition = -1;
214 | 
215 |             foreach (var line in lines)
216 |             {
217 |                 lineNumber++;
218 | 
219 |                 linePosition = line.LastIndexOf(tag, StringComparison.OrdinalIgnoreCase);
220 |                 if (linePosition != -1)
221 |                 {
222 |                     linePosition += tag.Length;
223 |                     break;
224 |                 }
225 |             }
226 | 
227 |             return new LineInfo(lineNumber, linePosition);
228 |         }
229 | 
230 |         private static CharacterSpan GetFirstCharacterSpan(string tag, string allText)
231 |         {
232 |             var index = allText.IndexOf(tag, StringComparison.OrdinalIgnoreCase);
233 |             if (index < 0)
234 |             {
235 |                 return null;
236 |             }
237 | 
238 |             return GetCharacterSpanIncludingLineBreak(tag, allText, index);
239 |         }
240 | 
241 |         private static CharacterSpan GetLastCharacterSpan(string tag, string allText)
242 |         {
243 |             var index = allText.LastIndexOf(tag, StringComparison.OrdinalIgnoreCase);
244 |             if (index < 0)
245 |             {
246 |                 return null;
247 |             }
248 | 
249 |             return GetCharacterSpanIncludingLineBreak(tag, allText, index);
250 |         }
251 | 
252 |         private static CharacterSpan GetCharacterSpanIncludingLineBreak(string value, string allText, int index)
253 |         {
254 |             var end = index + value.Length;
255 |             if (end >= allText.Length)
256 |             {
257 |                 // last line does not have a line break
258 |                 return new CharacterSpan(index, end - 1);
259 |             }
260 | 
261 |             // we have to include the line breaks
262 |             if (allText[end] == LineEndingCR)
263 |             {
264 |                 // find out whether we have a CRLF
265 |                 var next = end + 1;
266 | 
267 |                 if (next < allText.Length && allText[next] == LineEndingLF)
268 |                 {
269 |                     end = next;
270 |                 }
271 |             }
272 | 
273 |             return new CharacterSpan(index, end);
274 |         }
275 | 
276 |         private static int GetCharacterPositionAtLineStart(IXmlLineInfo info, string[] lines) => CharactersUntilLine(lines, info.LineNumber - 1);
277 | 
278 |         private static int GetCharacterPositionAtLineEnd(IXmlLineInfo info, string[] lines) => CharactersUntilLine(lines, info.LineNumber) - 1;
279 | 
280 |         private static int CharactersUntilLine(string[] lines, int linesToTake) => lines.Take(linesToTake).Sum(_ => _.Length);
281 | 
282 |         private sealed class LineSplitter
283 |         {
284 |             public static string[] SplitLines(string allText)
285 |             {
286 |                 var lines = new List<string>();
287 | 
288 |                 var startIndex = 0;
289 | 
290 |                 var endIndex = allText.Length - 1;
291 | 
292 |                 // go through all characters and evaluate if it is a CR, CRLF or LF
293 |                 // if it starts with a CR then inspect next char to see if it is a LF
294 |                 // remember all indices and add a 1 or 2, dependent by CR/LF or CRLF
295 |                 while (true)
296 |                 {
297 |                     var nextIndex = allText.IndexOfAny(LineEndings, startIndex);
298 |                     if (nextIndex == -1)
299 |                     {
300 |                         // last line does not contain a line ending
301 |                         var lastLine = allText.Substring(startIndex);
302 |                         lines.Add(lastLine);
303 |                         break;
304 |                     }
305 | 
306 |                     if (nextIndex < endIndex)
307 |                     {
308 |                         if (allText[nextIndex] == LineEndingCR && allText[nextIndex + 1] == LineEndingLF)
309 |                         {
310 |                             nextIndex++;
311 |                         }
312 | 
313 |                         // ensure that we are 1 index step behind
314 |                         nextIndex++;
315 | 
316 |                         var count = nextIndex - startIndex;
317 | 
318 |                         var line = allText.Substring(startIndex, count);
319 |                         lines.Add(line);
320 | 
321 |                         startIndex = nextIndex;
322 |                     }
323 |                 }
324 | 
325 |                 return lines.ToArray();
326 |             }
327 |         }
328 | 
329 |         private sealed class AscendingSpanComparer : IComparer<ContainerOrTerminalNode>
330 |         {
331 |             public int Compare(ContainerOrTerminalNode x, ContainerOrTerminalNode y)
332 |             {
333 |                 if (x is TerminalNode tX)
334 |                 {
335 |                     if (y is TerminalNode tY)
336 |                     {
337 |                         return tX.Span.Start - tY.Span.Start;
338 |                     }
339 | 
340 |                     if (y is Container cY)
341 |                     {
342 |                         return tX.Span.Start - cY.HeaderSpan.Start;
343 |                     }
344 |                 }
345 | 
346 |                 if (x is Container cX)
347 |                 {
348 |                     if (y is TerminalNode tY)
349 |                     {
350 |                         return cX.HeaderSpan.Start - tY.Span.Start;
351 |                     }
352 | 
353 |                     if (y is Container cY)
354 |                     {
355 |                         return cX.HeaderSpan.Start - cY.HeaderSpan.Start;
356 |                     }
357 |                 }
358 | 
359 |                 return 0;
360 |             }
361 |         }
362 | }
363 | }


--------------------------------------------------------------------------------
/Parser/Parser.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
 4 |   <PropertyGroup>
 5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 7 |     <ProjectGuid>{4E9E944D-118E-4D86-9B56-2B0B878A62B8}</ProjectGuid>
 8 |     <OutputType>Exe</OutputType>
 9 |     <RootNamespace>MiKoSolutions.SemanticParsers.ResX</RootNamespace>
10 |     <AssemblyName>ResXSemanticParser</AssemblyName>
11 |     <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
12 |     <FileAlignment>512</FileAlignment>
13 |     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
14 |   </PropertyGroup>
15 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
16 |     <PlatformTarget>AnyCPU</PlatformTarget>
17 |     <DebugSymbols>true</DebugSymbols>
18 |     <DebugType>full</DebugType>
19 |     <Optimize>false</Optimize>
20 |     <OutputPath>bin\Debug\</OutputPath>
21 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
22 |     <ErrorReport>prompt</ErrorReport>
23 |     <WarningLevel>4</WarningLevel>
24 |     <LangVersion>latest</LangVersion>
25 |     <CodeAnalysisRuleSet>Parser.ruleset</CodeAnalysisRuleSet>
26 |   </PropertyGroup>
27 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
28 |     <PlatformTarget>AnyCPU</PlatformTarget>
29 |     <DebugType>pdbonly</DebugType>
30 |     <Optimize>true</Optimize>
31 |     <OutputPath>bin\Release\</OutputPath>
32 |     <DefineConstants>TRACE</DefineConstants>
33 |     <ErrorReport>prompt</ErrorReport>
34 |     <WarningLevel>4</WarningLevel>
35 |     <LangVersion>latest</LangVersion>
36 |     <CodeAnalysisRuleSet>Parser.ruleset</CodeAnalysisRuleSet>
37 |   </PropertyGroup>
38 |   <PropertyGroup>
39 |     <StartupObject>MiKoSolutions.SemanticParsers.ResX.Program</StartupObject>
40 |   </PropertyGroup>
41 |   <ItemGroup>
42 |     <Reference Include="Microsoft.CSharp" />
43 |     <Reference Include="System" />
44 |     <Reference Include="System.Data" />
45 |     <Reference Include="System.Data.DataSetExtensions" />
46 |     <Reference Include="System.Net.Http" />
47 |     <Reference Include="System.Xml" />
48 |     <Reference Include="System.Xml.Linq" />
49 |   </ItemGroup>
50 |   <ItemGroup>
51 |     <Compile Include="Parser.cs" />
52 |     <Compile Include="Program.cs" />
53 |     <Compile Include="Properties\AssemblyInfo.cs" />
54 |     <Compile Include="Yaml\CharacterSpan.cs" />
55 |     <Compile Include="Yaml\Container.cs" />
56 |     <Compile Include="Yaml\ContainerOrTerminalNode.cs" />
57 |     <Compile Include="Yaml\File.cs" />
58 |     <Compile Include="Yaml\IntendedString.cs" />
59 |     <Compile Include="Yaml\LineInfo.cs" />
60 |     <Compile Include="Yaml\LocationSpan.cs" />
61 |     <Compile Include="Yaml\ParsingError.cs" />
62 |     <Compile Include="Yaml\TerminalNode.cs" />
63 |   </ItemGroup>
64 |   <ItemGroup>
65 |     <None Include="App.config" />
66 |     <None Include="packages.config" />
67 |     <None Include="Parser.ruleset" />
68 |   </ItemGroup>
69 |   <ItemGroup>
70 |     <Analyzer Include="..\packages\StyleCop.Analyzers.1.1.0-beta009\analyzers\dotnet\cs\StyleCop.Analyzers.CodeFixes.dll" />
71 |     <Analyzer Include="..\packages\StyleCop.Analyzers.1.1.0-beta009\analyzers\dotnet\cs\StyleCop.Analyzers.dll" />
72 |   </ItemGroup>
73 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
74 | </Project>


--------------------------------------------------------------------------------
/Parser/Parser.csproj.DotSettings:
--------------------------------------------------------------------------------
1 | <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
2 | 	<s:String x:Key="/Default/CodeInspection/CSharpLanguageProject/LanguageLevel/@EntryValue">CSharp71</s:String></wpf:ResourceDictionary>


--------------------------------------------------------------------------------
/Parser/Parser.ruleset:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RuleSet Name="ResX Semantic Parser Rules" Description="Customized rule sets for the semantic parser for resx files." ToolsVersion="10.0">
 3 |   <Localization ResourceAssembly="Microsoft.VisualStudio.CodeAnalysis.RuleSets.Strings.dll" ResourceBaseName="Microsoft.VisualStudio.CodeAnalysis.RuleSets.Strings.Localized">
 4 |     <Name Resource="MinimumRecommendedRules_Name" />
 5 |     <Description Resource="MinimumRecommendedRules_Description" />
 6 |   </Localization>
 7 |   <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
 8 |     <Rule Id="CA1001" Action="Warning" />
 9 |     <Rule Id="CA1009" Action="Warning" />
10 |     <Rule Id="CA1016" Action="Warning" />
11 |     <Rule Id="CA1033" Action="Warning" />
12 |     <Rule Id="CA1049" Action="Warning" />
13 |     <Rule Id="CA1060" Action="Warning" />
14 |     <Rule Id="CA1061" Action="Warning" />
15 |     <Rule Id="CA1063" Action="Warning" />
16 |     <Rule Id="CA1065" Action="Warning" />
17 |     <Rule Id="CA1301" Action="Warning" />
18 |     <Rule Id="CA1400" Action="Warning" />
19 |     <Rule Id="CA1401" Action="Warning" />
20 |     <Rule Id="CA1403" Action="Warning" />
21 |     <Rule Id="CA1404" Action="Warning" />
22 |     <Rule Id="CA1405" Action="Warning" />
23 |     <Rule Id="CA1410" Action="Warning" />
24 |     <Rule Id="CA1415" Action="Warning" />
25 |     <Rule Id="CA1821" Action="Warning" />
26 |     <Rule Id="CA1900" Action="Warning" />
27 |     <Rule Id="CA1901" Action="Warning" />
28 |     <Rule Id="CA2002" Action="Warning" />
29 |     <Rule Id="CA2100" Action="Warning" />
30 |     <Rule Id="CA2101" Action="Warning" />
31 |     <Rule Id="CA2108" Action="Warning" />
32 |     <Rule Id="CA2111" Action="Warning" />
33 |     <Rule Id="CA2112" Action="Warning" />
34 |     <Rule Id="CA2114" Action="Warning" />
35 |     <Rule Id="CA2116" Action="Warning" />
36 |     <Rule Id="CA2117" Action="Warning" />
37 |     <Rule Id="CA2122" Action="Warning" />
38 |     <Rule Id="CA2123" Action="Warning" />
39 |     <Rule Id="CA2124" Action="Warning" />
40 |     <Rule Id="CA2126" Action="Warning" />
41 |     <Rule Id="CA2131" Action="Warning" />
42 |     <Rule Id="CA2132" Action="Warning" />
43 |     <Rule Id="CA2133" Action="Warning" />
44 |     <Rule Id="CA2134" Action="Warning" />
45 |     <Rule Id="CA2137" Action="Warning" />
46 |     <Rule Id="CA2138" Action="Warning" />
47 |     <Rule Id="CA2140" Action="Warning" />
48 |     <Rule Id="CA2141" Action="Warning" />
49 |     <Rule Id="CA2146" Action="Warning" />
50 |     <Rule Id="CA2147" Action="Warning" />
51 |     <Rule Id="CA2149" Action="Warning" />
52 |     <Rule Id="CA2200" Action="Warning" />
53 |     <Rule Id="CA2202" Action="Warning" />
54 |     <Rule Id="CA2207" Action="Warning" />
55 |     <Rule Id="CA2212" Action="Warning" />
56 |     <Rule Id="CA2213" Action="Warning" />
57 |     <Rule Id="CA2214" Action="Warning" />
58 |     <Rule Id="CA2216" Action="Warning" />
59 |     <Rule Id="CA2220" Action="Warning" />
60 |     <Rule Id="CA2229" Action="Warning" />
61 |     <Rule Id="CA2231" Action="Warning" />
62 |     <Rule Id="CA2232" Action="Warning" />
63 |     <Rule Id="CA2235" Action="Warning" />
64 |     <Rule Id="CA2236" Action="Warning" />
65 |     <Rule Id="CA2237" Action="Warning" />
66 |     <Rule Id="CA2238" Action="Warning" />
67 |     <Rule Id="CA2240" Action="Warning" />
68 |     <Rule Id="CA2241" Action="Warning" />
69 |     <Rule Id="CA2242" Action="Warning" />
70 |   </Rules>
71 |   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
72 |     <Rule Id="SA1101" Action="Hidden" />
73 |     <Rule Id="SA1200" Action="Hidden" />
74 |     <Rule Id="SA1633" Action="Hidden" />
75 |     <Rule Id="SA1133" Action="Hidden" />
76 |     <Rule Id="SA1309" Action="Hidden" />
77 |     <Rule Id="SA0001" Action="Hidden" />
78 |     <Rule Id="SA1600" Action="Hidden" />
79 |   </Rules>
80 | </RuleSet>


--------------------------------------------------------------------------------
/Parser/Program.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Diagnostics;
 3 | using System.IO;
 4 | using System.Threading.Tasks;
 5 | 
 6 | namespace MiKoSolutions.SemanticParsers.ResX
 7 | {
 8 |     public static class Program
 9 |     {
10 |         private const string Category = "RKN Semantic";
11 | 
12 |         public static async Task<int> Main(string[] args)
13 |         {
14 |             if (args.Length != 2)
15 |             {
16 |                 return -1;
17 |             }
18 | 
19 |             var shell = args[0]; // reserved for future usage
20 |             var flagFile = args[1];
21 | 
22 |             File.WriteAllBytes(flagFile, new byte[] { 0x42 });
23 | 
24 |             while (true)
25 |             {
26 |                 var fileToParse = await Console.In.ReadLineAsync();
27 | 
28 |                 if ("end".Equals(fileToParse, StringComparison.OrdinalIgnoreCase) || fileToParse == null)
29 |                 {
30 |                     // session is done
31 |                     return 0;
32 |                 }
33 | 
34 |                 var encodingToUse = Console.In.ReadLine();
35 |                 var outputFileToWrite = Console.In.ReadLine();
36 | 
37 |                 Debug.WriteLine($"File to parse: '{fileToParse}'", Category);
38 |                 Debug.WriteLine($"Encoding: '{encodingToUse}'", Category);
39 |                 Debug.WriteLine($"File to write: {outputFileToWrite}", Category);
40 | 
41 |                 try
42 |                 {
43 |                     var success = Parser.TryParse(fileToParse, out var yamlContent) ? "OK" : "KO";
44 | 
45 |                     Debug.WriteLine($"Parsed result: {success}", Category);
46 | 
47 |                     File.WriteAllText(outputFileToWrite, yamlContent);
48 | 
49 |                     Console.WriteLine(success);
50 |                 }
51 |                 catch (Exception ex)
52 |                 {
53 |                     Debug.WriteLine($"Exception: {ex}", Category);
54 |                     throw;
55 |                 }
56 |             }
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/Parser/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.InteropServices;
 3 | 
 4 | // General Information about an assembly is controlled through the following
 5 | // set of attributes. Change these attribute values to modify the information
 6 | // associated with an assembly.
 7 | [assembly: AssemblyTitle("ResXSemanticParser")]
 8 | [assembly: AssemblyDescription("")]
 9 | [assembly: AssemblyConfiguration("")]
10 | [assembly: AssemblyCompany("MiKo Solutions")]
11 | [assembly: AssemblyProduct("ResXSemanticParser")]
12 | [assembly: AssemblyCopyright("Copyright © MiKo Solutions 2018")]
13 | [assembly: AssemblyTrademark("")]
14 | [assembly: AssemblyCulture("")]
15 | 
16 | // Setting ComVisible to false makes the types in this assembly not visible
17 | // to COM components.  If you need to access a type in this assembly from
18 | // COM, set the ComVisible attribute to true on that type.
19 | [assembly: ComVisible(false)]
20 | 
21 | // The following GUID is for the ID of the typelib if this project is exposed to COM
22 | [assembly: Guid("4e9e944d-118e-4d86-9b56-2b0b878a62b8")]
23 | 
24 | // Version information for an assembly consists of the following four values:
25 | //
26 | //      Major Version
27 | //      Minor Version
28 | //      Build Number
29 | //      Revision
30 | //
31 | // You can specify all the values or you can default the Build and Revision Numbers
32 | // by using the '*' as shown below:
33 | // [assembly: AssemblyVersion("1.0.*")]
34 | [assembly: AssemblyVersion("0.0.1.0")]
35 | [assembly: AssemblyFileVersion("0.0.1.0")]
36 | 


--------------------------------------------------------------------------------
/Parser/Yaml/CharacterSpan.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 4 | {
 5 |     public sealed class CharacterSpan : IEquatable<CharacterSpan>
 6 |     {
 7 |         public CharacterSpan(int start, int end)
 8 |         {
 9 |             Start = start;
10 |             End = end;
11 |         }
12 | 
13 |         public int Start { get; }
14 | 
15 |         public int End { get; }
16 | 
17 |         public override string ToString() => $"Start={Start}, End={End}";
18 | 
19 |         public string ToYamlString() => $"[{Start}, {End}]";
20 | 
21 |         public bool Equals(CharacterSpan other)
22 |         {
23 |             if (ReferenceEquals(null, other))
24 |             {
25 |                 return false;
26 |             }
27 | 
28 |             if (ReferenceEquals(this, other))
29 |             {
30 |                 return true;
31 |             }
32 | 
33 |             return Start == other.Start && End == other.End;
34 |         }
35 | 
36 |         public override bool Equals(object obj) => Equals(obj as CharacterSpan);
37 | 
38 |         public override int GetHashCode()
39 |         {
40 |             unchecked
41 |             {
42 |                 return (Start * 397) ^ End;
43 |             }
44 |         }
45 |     }
46 | }


--------------------------------------------------------------------------------
/Parser/Yaml/Container.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | using System.Text;
 4 | 
 5 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 6 | {
 7 |     public sealed class Container : ContainerOrTerminalNode
 8 |     {
 9 |         public CharacterSpan HeaderSpan { get; set; }
10 | 
11 |         public CharacterSpan FooterSpan { get; set; }
12 | 
13 |         public List<ContainerOrTerminalNode> Children { get; } = new List<ContainerOrTerminalNode>();
14 | 
15 |         public override void FillYamlString(StringBuilder builder, int intendation)
16 |         {
17 |             base.FillYamlString(builder, intendation);
18 | 
19 |             var intended = IntendedString.From(intendation);
20 | 
21 |             builder.Append(intended).Append("headerSpan: ").AppendLine(HeaderSpan.ToYamlString());
22 |             builder.Append(intended).Append("footerSpan: ").AppendLine(FooterSpan.ToYamlString());
23 | 
24 |             if (Children.Any())
25 |             {
26 |                 builder.Append(intended).AppendLine("children: ");
27 | 
28 |                 foreach (var child in Children)
29 |                 {
30 |                     builder.Append(intended).AppendLine("- ");
31 |                     child.FillYamlString(builder, intendation + 3);
32 |                     builder.AppendLine();
33 |                 }
34 |             }
35 |         }
36 |     }
37 | }


--------------------------------------------------------------------------------
/Parser/Yaml/ContainerOrTerminalNode.cs:
--------------------------------------------------------------------------------
 1 | using System.Diagnostics;
 2 | using System.Text;
 3 | 
 4 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 5 | {
 6 |     [DebuggerDisplay("Type={Type}, Name={Name}")]
 7 |     public abstract class ContainerOrTerminalNode
 8 |     {
 9 |         public string Type { get; set; }
10 | 
11 |         public string Name { get; set; }
12 | 
13 |         public LocationSpan LocationSpan { get; set; }
14 | 
15 |         public virtual void FillYamlString(StringBuilder builder, int intendation)
16 |         {
17 |             var intended = IntendedString.From(intendation);
18 | 
19 |             builder.Append(intended).Append("type: ").AppendLine(Type);
20 |             builder.Append(intended).Append("name: \"").Append(Name).AppendLine("\"");
21 |             builder.Append(intended).Append("locationSpan: ").AppendLine(LocationSpan.ToYamlString());
22 |         }
23 |     }
24 | }


--------------------------------------------------------------------------------
/Parser/Yaml/File.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | using System.Text;
 4 | 
 5 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 6 | {
 7 |     public sealed class File
 8 |     {
 9 |         public string Name { get; set; }
10 | 
11 |         public LocationSpan LocationSpan { get; set; }
12 | 
13 |         public CharacterSpan FooterSpan { get; set; }
14 | 
15 |         public List<ParsingError> ParsingErrors { get; } = new List<ParsingError>();
16 | 
17 |         public List<Container> Children { get; } = new List<Container>();
18 | 
19 |         public string ToYamlString()
20 |         {
21 |             var parsingErrorsDetected = ParsingErrors.Any();
22 | 
23 |             var builder = new StringBuilder()
24 |                 .Append("type: ").AppendLine("file")
25 |                 .Append("name: ").AppendLine(Name)
26 |                 .Append("locationSpan: ").AppendLine(LocationSpan.ToYamlString())
27 |                 .Append("footerSpan: ").AppendLine(FooterSpan.ToYamlString())
28 |                 .Append("parsingErrorsDetected: ").AppendLine(parsingErrorsDetected.ToString());
29 | 
30 |             if (Children.Any())
31 |             {
32 |                 builder.AppendLine("children: ");
33 | 
34 |                 foreach (var child in Children)
35 |                 {
36 |                     builder.AppendLine("- ");
37 |                     child.FillYamlString(builder, 3);
38 |                     builder.AppendLine();
39 |                 }
40 |             }
41 | 
42 |             if (parsingErrorsDetected)
43 |             {
44 |                 builder.AppendLine("parsingError: ");
45 | 
46 |                 foreach (var parsingError in ParsingErrors)
47 |                 {
48 |                     builder.AppendLine("- ");
49 |                     parsingError.FillYamlString(builder, 3);
50 |                     builder.AppendLine();
51 |                 }
52 |             }
53 | 
54 |             return builder.ToString();
55 |         }
56 |     }
57 | }


--------------------------------------------------------------------------------
/Parser/Yaml/IntendedString.cs:
--------------------------------------------------------------------------------
 1 | using System.Collections.Generic;
 2 | using System.Linq;
 3 | 
 4 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 5 | {
 6 |     internal static class IntendedString
 7 |     {
 8 |         private static readonly Dictionary<int, string> Map = new Dictionary<int, string>();
 9 | 
10 |         public static string From(int intendation)
11 |         {
12 |             if (!Map.TryGetValue(intendation, out var result))
13 |             {
14 |                 result = new string(Enumerable.Repeat(' ', intendation).ToArray());
15 |                 Map[intendation] = result;
16 |             }
17 | 
18 |             return result;
19 |         }
20 |     }
21 | }


--------------------------------------------------------------------------------
/Parser/Yaml/LineInfo.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 4 | {
 5 |     public sealed class LineInfo : IEquatable<LineInfo>
 6 |     {
 7 |         public LineInfo(int lineNumber, int linePosition)
 8 |         {
 9 |             LineNumber = lineNumber;
10 |             LinePosition = linePosition;
11 |         }
12 | 
13 |         public int LineNumber { get; }
14 | 
15 |         public int LinePosition { get; }
16 | 
17 |         public override string ToString() => $"LineNumber={LineNumber}, LinePosition={LinePosition}";
18 | 
19 |         public string ToYamlString() => $"[{LineNumber}, {LinePosition}]";
20 | 
21 |         public bool Equals(LineInfo other)
22 |         {
23 |             if (ReferenceEquals(null, other))
24 |             {
25 |                 return false;
26 |             }
27 | 
28 |             if (ReferenceEquals(this, other))
29 |             {
30 |                 return true;
31 |             }
32 | 
33 |             return LineNumber == other.LineNumber && LinePosition == other.LinePosition;
34 |         }
35 | 
36 |         public override bool Equals(object obj) => Equals(obj as LineInfo);
37 | 
38 |         public override int GetHashCode()
39 |         {
40 |             unchecked
41 |             {
42 |                 return (LineNumber * 397) ^ LinePosition;
43 |             }
44 |         }
45 |     }
46 | }


--------------------------------------------------------------------------------
/Parser/Yaml/LocationSpan.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | 
 3 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 4 | {
 5 |     public sealed class LocationSpan : IEquatable<LocationSpan>
 6 |     {
 7 |         public LocationSpan(LineInfo start, LineInfo end)
 8 |         {
 9 |             Start = start;
10 |             End = end;
11 |         }
12 | 
13 |         public LineInfo Start { get; }
14 | 
15 |         public LineInfo End { get; }
16 | 
17 |         public string ToYamlString() => $"{{start: {Start.ToYamlString()}, end: {End.ToYamlString()}}}";
18 | 
19 |         public bool Equals(LocationSpan other)
20 |         {
21 |             if (ReferenceEquals(null, other))
22 |             {
23 |                 return false;
24 |             }
25 | 
26 |             if (ReferenceEquals(this, other))
27 |             {
28 |                 return true;
29 |             }
30 | 
31 |             return Equals(Start, other.Start) && Equals(End, other.End);
32 |         }
33 | 
34 |         public override bool Equals(object obj) => Equals(obj as LocationSpan);
35 | 
36 |         public override int GetHashCode()
37 |         {
38 |             unchecked
39 |             {
40 |                 return ((Start != null ? Start.GetHashCode() : 0) * 397) ^ (End != null ? End.GetHashCode() : 0);
41 |             }
42 |         }
43 |     }
44 | }


--------------------------------------------------------------------------------
/Parser/Yaml/ParsingError.cs:
--------------------------------------------------------------------------------
 1 | using System.Text;
 2 | 
 3 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 4 | {
 5 |     public sealed class ParsingError
 6 |     {
 7 |         public LineInfo Location { get; set; }
 8 | 
 9 |         public string ErrorMessage { get; set; }
10 | 
11 |         public void FillYamlString(StringBuilder builder, int intendation)
12 |         {
13 |             var intended = IntendedString.From(intendation);
14 | 
15 |             builder.Append(intended).Append("location: ").AppendLine(Location?.ToYamlString() ?? "<unknown>");
16 |             builder.Append(intended).Append("message: ").AppendLine(ErrorMessage);
17 |         }
18 |     }
19 | }


--------------------------------------------------------------------------------
/Parser/Yaml/TerminalNode.cs:
--------------------------------------------------------------------------------
 1 | using System.Text;
 2 | 
 3 | namespace MiKoSolutions.SemanticParsers.ResX.Yaml
 4 | {
 5 |     public sealed class TerminalNode : ContainerOrTerminalNode
 6 |     {
 7 |         public CharacterSpan Span { get; set; }
 8 | 
 9 |         public override void FillYamlString(StringBuilder builder, int intendation)
10 |         {
11 |             base.FillYamlString(builder, intendation);
12 | 
13 |             var intended = IntendedString.From(intendation);
14 | 
15 |             builder.Append(intended).Append("span: ").AppendLine(Span.ToYamlString());
16 |         }
17 |     }
18 | }


--------------------------------------------------------------------------------
/Parser/packages.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <packages>
3 |   <package id="Codecov" version="1.1.0" targetFramework="net472" />
4 |   <package id="StyleCop.Analyzers" version="1.1.0-beta009" targetFramework="net472" developmentDependency="true" />
5 | </packages>


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # resx-semantic-external-parser
 2 | A semantic external parser for .resx files that can be used together with [GMaster](https://gmaster.io), [PlasticSCM](https://www.plasticscm.com) or [SemanticMerge](https://semanticmerge.com/).
 3 | 
 4 | How to use it with GMaster is documented [here](http://blog.gmaster.io/2018/03/using-external-parsers-with-gmaster.html).
 5 | 
 6 | How to use it with _**SemanticMerge**_ or _**Plastic SCM**_ is described [here](https://docs.plasticscm.com/semanticmerge/external-parsers/external-parsers-guide) in chapter _"How to invoke Semantic with an external parser"_.
 7 | 
 8 | ## Build status
 9 | [![Build status](https://ci.appveyor.com/api/projects/status/536b0rx4mp3d838b/branch/master?svg=true)](https://ci.appveyor.com/project/RalfKoban/resx-semantic-external-parser/branch/master)
10 | [![codecov](https://codecov.io/gh/RalfKoban/resx-semantic-external-parser/branch/master/graph/badge.svg)](https://codecov.io/gh/RalfKoban/resx-semantic-external-parser)
11 | 
12 | [![Build history](https://buildstats.info/appveyor/chart/RalfKoban/resx-semantic-external-parser)](https://ci.appveyor.com/project/RalfKoban/resx-semantic-external-parser/history)
13 | 
14 | ## Issues
15 | Please raise issues on [GitHub](https://github.com/RalfKoban/resx-semantic-external-parser/issues).
16 | If you can repeat the issue then please provide a sample to make it easier for me to also repeat it and then implement a fix.
17 | 
18 | Please do not hijack unrelated issues, I would rather you create a new issue than add noise to an unrelated issue.
19 | 
20 | ## Example
21 | Following images give an impression about the different diff results.
22 | 
23 | #### Text diff
24 | ![TextDiff](Screenshots/ResX_TextDiff.png)
25 | 
26 | #### Semantic diff
27 | ![SemanticDiff](Screenshots/ResX_SemanticDiff.png)
28 | 
29 | #### Visual diff
30 | ![SemanticDiff](Screenshots/ResX_VisualDiff.png)
31 | 


--------------------------------------------------------------------------------
/ResXSemanticParser.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.27703.2026
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Parser", "Parser\Parser.csproj", "{4E9E944D-118E-4D86-9B56-2B0B878A62B8}"
 7 | EndProject
 8 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests", "Tests\Tests.csproj", "{458E024E-56AD-4971-9E12-5ACB007E05D9}"
 9 | EndProject
10 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Github", "Github", "{500E6EA7-A2D8-461B-B23B-B5F9DE606A9F}"
11 | 	ProjectSection(SolutionItems) = preProject
12 | 		.gitignore = .gitignore
13 | 		appveyor.yml = appveyor.yml
14 | 		codecov.yml = codecov.yml
15 | 		README.md = README.md
16 | 	EndProjectSection
17 | EndProject
18 | Global
19 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
20 | 		Debug|Any CPU = Debug|Any CPU
21 | 		Release|Any CPU = Release|Any CPU
22 | 	EndGlobalSection
23 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
24 | 		{4E9E944D-118E-4D86-9B56-2B0B878A62B8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
25 | 		{4E9E944D-118E-4D86-9B56-2B0B878A62B8}.Debug|Any CPU.Build.0 = Debug|Any CPU
26 | 		{4E9E944D-118E-4D86-9B56-2B0B878A62B8}.Release|Any CPU.ActiveCfg = Release|Any CPU
27 | 		{4E9E944D-118E-4D86-9B56-2B0B878A62B8}.Release|Any CPU.Build.0 = Release|Any CPU
28 | 		{458E024E-56AD-4971-9E12-5ACB007E05D9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
29 | 		{458E024E-56AD-4971-9E12-5ACB007E05D9}.Debug|Any CPU.Build.0 = Debug|Any CPU
30 | 		{458E024E-56AD-4971-9E12-5ACB007E05D9}.Release|Any CPU.ActiveCfg = Release|Any CPU
31 | 		{458E024E-56AD-4971-9E12-5ACB007E05D9}.Release|Any CPU.Build.0 = Release|Any CPU
32 | 	EndGlobalSection
33 | 	GlobalSection(SolutionProperties) = preSolution
34 | 		HideSolutionNode = FALSE
35 | 	EndGlobalSection
36 | 	GlobalSection(ExtensibilityGlobals) = postSolution
37 | 		SolutionGuid = {B25477F4-FE35-41A2-B23A-9945A7CB9DA4}
38 | 	EndGlobalSection
39 | EndGlobal
40 | 


--------------------------------------------------------------------------------
/ResXSemanticParser.sln.DotSettings:
--------------------------------------------------------------------------------
 1 | <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
 2 | 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INDENT_PARS/@EntryValue">OUTSIDE_AND_INSIDE</s:String>
 3 | 	<s:Boolean x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/ALIGN_MULTILINE_ARRAY_AND_OBJECT_INITIALIZER/@EntryValue">True</s:Boolean>
 4 | 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/INITIALIZER_BRACES/@EntryValue">NEXT_LINE_SHIFTED_2</s:String>
 5 | 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/CSharpFormat/PLACE_ACCESSORHOLDER_ATTRIBUTE_ON_SAME_LINE_EX/@EntryValue">NEVER</s:String>
 6 | 	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FTAG_005FNAME/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 7 | 	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FTAG_005FPREFIX/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 8 | 	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
 9 | 	<s:String x:Key="/Default/CodeStyle/Naming/WebNaming/UserRules/=ASP_005FHTML_005FCONTROL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
10 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
11 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FCONSTANT/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
12 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLOCAL_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
13 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FBLOCK_005FSCOPE_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
14 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
15 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FCLASS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
16 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FPARAMETER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
17 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLABEL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
18 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FGLOBAL_005FVARIABLE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
19 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FOBJECT_005FPROPERTY_005FOF_005FFUNCTION/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
20 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FCONSTRUCTOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
21 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=JS_005FLOCAL_005FCONSTRUCTOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
22 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
23 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE_005FLOCAL/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
24 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMODULE_005FEXPORTED/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
25 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FCLASS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
26 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FINTERFACE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="I" Suffix="" Style="AaBb" /&gt;</s:String>
27 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
28 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
29 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FTYPE_005FMETHOD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
30 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
31 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
32 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
33 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
34 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
35 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FSTATIC_005FTYPE_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
36 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPUBLIC_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
37 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPRIVATE_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
38 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FPROTECTED_005FMEMBER_005FACCESSOR/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
39 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FENUM/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
40 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FMIXED_005FENUM/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
41 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FENUM_005FMEMBER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
42 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FTYPE_005FPARAMETER/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="T" Suffix="" Style="AaBb" /&gt;</s:String>
43 | 	<s:String x:Key="/Default/CodeStyle/Naming/JavaScriptNaming/UserRules/=TS_005FTYPE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
44 | 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=NAMESPACE_005FALIAS/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="aaBb" /&gt;</s:String>
45 | 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FFIELD/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
46 | 	<s:String x:Key="/Default/CodeStyle/Naming/XamlNaming/UserRules/=XAML_005FRESOURCE/@EntryIndexedValue">&lt;Policy Inspect="True" Prefix="" Suffix="" Style="AaBb" /&gt;</s:String>
47 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=SolExp_002DTrack/@EntryIndexedValue">LIVE_MONITOR</s:String>
48 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=Roslyn_002Dswea/@EntryIndexedValue">DO_NOTHING</s:String>
49 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=VCS/@EntryIndexedValue">LIVE_MONITOR</s:String>
50 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=StartPage_002DOnEnvironmentStatup/@EntryIndexedValue">LIVE_MONITOR</s:String>
51 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=StartPage_002DIsDownloadRefreshEnabled/@EntryIndexedValue">LIVE_MONITOR</s:String>
52 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=AutoRecoverer/@EntryIndexedValue">LIVE_MONITOR</s:String>
53 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=TextEditor_002DTrackChanges_002D2/@EntryIndexedValue">LIVE_MONITOR</s:String>
54 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=XAML_0020Designer/@EntryIndexedValue">LIVE_MONITOR</s:String>
55 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=Format/@EntryIndexedValue">LIVE_MONITOR</s:String>
56 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=SyncSettings/@EntryIndexedValue">LIVE_MONITOR</s:String>
57 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=ShowAnnotations/@EntryIndexedValue">LIVE_MONITOR</s:String>
58 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=TextEditor_002DCodeLens/@EntryIndexedValue">LIVE_MONITOR</s:String>
59 | 	<s:String x:Key="/Default/Environment/PerformanceGuide/SwitchBehaviour/=VsBulb/@EntryIndexedValue">DO_NOTHING</s:String>
60 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
61 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
62 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
63 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpRenamePlacementToArrangementMigration/@EntryIndexedValue">True</s:Boolean>
64 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@EntryIndexedValue">True</s:Boolean>
65 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
66 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
67 | 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>


--------------------------------------------------------------------------------
/ResXSemanticParser.v3.ncrunchsolution:
--------------------------------------------------------------------------------
1 | <SolutionConfiguration>
2 |   <Settings>
3 |     <AllowParallelTestExecution>True</AllowParallelTestExecution>
4 |     <SolutionConfigured>True</SolutionConfigured>
5 |   </Settings>
6 | </SolutionConfiguration>


--------------------------------------------------------------------------------
/Screenshots/ResX_SemanticDiff.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RalfKoban/resx-semantic-external-parser/347856481d5714f3d8ce343d281c55f9345de026/Screenshots/ResX_SemanticDiff.png


--------------------------------------------------------------------------------
/Screenshots/ResX_TextDiff.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RalfKoban/resx-semantic-external-parser/347856481d5714f3d8ce343d281c55f9345de026/Screenshots/ResX_TextDiff.png


--------------------------------------------------------------------------------
/Screenshots/ResX_VisualDiff.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/RalfKoban/resx-semantic-external-parser/347856481d5714f3d8ce343d281c55f9345de026/Screenshots/ResX_VisualDiff.png


--------------------------------------------------------------------------------
/Tests/ParserAdditionalTests.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.IO;
 3 | using System.Linq;
 4 | 
 5 | using MiKoSolutions.SemanticParsers.ResX.Yaml;
 6 | 
 7 | using NUnit.Framework;
 8 | 
 9 | namespace MiKoSolutions.SemanticParsers.ResX
10 | {
11 |     [TestFixture]
12 |     public class ParserAdditionalTests
13 |     {
14 |         private Yaml.File ObjectUnderTest { get; set; }
15 | 
16 |         [SetUp]
17 |         public void PrepareTest()
18 |         {
19 |             var codeBasePath = Directory.GetParent(new Uri(typeof(ParserTests).Assembly.CodeBase).LocalPath);
20 |             var filePath = Path.Combine(codeBasePath.Parent.FullName, "test2.resx");
21 | 
22 |             Parser.TryParseFile(filePath, out var file);
23 |             ObjectUnderTest = file;
24 |         }
25 | 
26 |         [Test]
27 |         public void File_matches()
28 |         {
29 |             Assert.That(ObjectUnderTest.LocationSpan.Start, Is.EqualTo(new LineInfo(1, 0)), "wrong location start");
30 |             Assert.That(ObjectUnderTest.LocationSpan.End, Is.EqualTo(new LineInfo(69, 7)), "wrong location end");
31 | 
32 |             Assert.That(ObjectUnderTest.FooterSpan, Is.EqualTo(new CharacterSpan(0, -1)), "wrong footer span");
33 |         }
34 | 
35 |         [Test]
36 |         public void Root_matches()
37 |         {
38 |             var node = ObjectUnderTest.Children.First(_ => _.Name == "root");
39 | 
40 |             Assert.Multiple(() =>
41 |             {
42 |                 Assert.That(node.LocationSpan.Start, Is.EqualTo(new LineInfo(1, 1)), "wrong location start");
43 |                 Assert.That(node.LocationSpan.End, Is.EqualTo(new LineInfo(69, 7)), "wrong location end");
44 | 
45 |                 Assert.That(node.HeaderSpan, Is.EqualTo(new CharacterSpan(0, 47)), "wrong header span");
46 |                 Assert.That(node.FooterSpan, Is.EqualTo(new CharacterSpan(3073, 3079)), "wrong footer span");
47 |             });
48 |         }
49 | 
50 |         [TestCase("schema",       3, 1, 48, 17,   48, 2305)]
51 |         [TestCase("resmimetype", 49, 1, 51, 16, 2306, 2395)]
52 |         [TestCase("version",     52, 1, 54, 16, 2396, 2465)]
53 |         [TestCase("reader",      55, 1, 57, 16, 2466, 2655)]
54 |         [TestCase("writer",      58, 1, 60, 16, 2656, 2845)]
55 |         [TestCase("String1",     61, 1, 63, 11, 2846, 2932)]
56 |         [TestCase("String2",     64, 1, 68, 11, 2933, 3072)] // special LF instead of CRLF
57 |         public void Child_matches(string name, int startLineNr, int startLinePos, int endLineNr, int endLinePos, int startSpan, int stopSpan)
58 |         {
59 |             Assert.Multiple(() =>
60 |             {
61 |                 var node = ObjectUnderTest.Children.SelectMany(_ => _.Children.OfType<TerminalNode>()).First(_ => _.Name == name);
62 | 
63 |                 Assert.That(node.LocationSpan.Start, Is.EqualTo(new LineInfo(startLineNr, startLinePos)), "wrong location start for " + name);
64 |                 Assert.That(node.LocationSpan.End, Is.EqualTo(new LineInfo(endLineNr, endLinePos)), "wrong location end for " + name);
65 | 
66 |                 Assert.That(node.Span, Is.EqualTo(new CharacterSpan(startSpan, stopSpan)), "wrong span for " + name);
67 |             });
68 |         }
69 |     }
70 | }


--------------------------------------------------------------------------------
/Tests/ParserTests.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.IO;
  3 | using System.Linq;
  4 | 
  5 | using MiKoSolutions.SemanticParsers.ResX.Yaml;
  6 | 
  7 | using NUnit.Framework;
  8 | 
  9 | using YamlDotNet.Core;
 10 | using YamlDotNet.RepresentationModel;
 11 | 
 12 | namespace MiKoSolutions.SemanticParsers.ResX
 13 | {
 14 |     [TestFixture]
 15 |     public class ParserTests
 16 |     {
 17 |         private Yaml.File ObjectUnderTest { get; set; }
 18 | 
 19 |         [SetUp]
 20 |         public void PrepareTest()
 21 |         {
 22 |             var codeBasePath = Directory.GetParent(new Uri(typeof(ParserTests).Assembly.CodeBase).LocalPath);
 23 |             var filePath = Path.Combine(codeBasePath.Parent.FullName, "test.resx");
 24 | 
 25 |             Parser.TryParseFile(filePath, out var file);
 26 |             ObjectUnderTest = file;
 27 |         }
 28 | 
 29 |         [Test]
 30 |         public void File_matches()
 31 |         {
 32 |             Assert.Multiple(() =>
 33 |             {
 34 |                 Assert.That(ObjectUnderTest.LocationSpan.Start, Is.EqualTo(new LineInfo(1, 0)), "wrong location start");
 35 |                 Assert.That(ObjectUnderTest.LocationSpan.End, Is.EqualTo(new LineInfo(144, 0)), "wrong location end");
 36 | 
 37 |                 Assert.That(ObjectUnderTest.FooterSpan, Is.EqualTo(new CharacterSpan(6695, 6696)), "wrong footer span");
 38 |             });
 39 |         }
 40 | 
 41 |         [Test]
 42 |         public void Root_matches()
 43 |         {
 44 |             Assert.Multiple(() =>
 45 |             {
 46 |                 var node = ObjectUnderTest.Children.First(_ => _.Name == "root");
 47 | 
 48 |                 Assert.That(node.LocationSpan.Start, Is.EqualTo(new LineInfo(1, 1)), "wrong location start");
 49 |                 Assert.That(node.LocationSpan.End, Is.EqualTo(new LineInfo(142, 7)), "wrong location end");
 50 | 
 51 |                 Assert.That(node.HeaderSpan, Is.EqualTo(new CharacterSpan(0, 47)), "wrong header span");
 52 |                 Assert.That(node.FooterSpan, Is.EqualTo(new CharacterSpan(6686, 6694)), "wrong footer span");
 53 |             });
 54 |         }
 55 | 
 56 |         [TestCase("schema",        3, 1, 107,  17,   48, 5266)]
 57 |         [TestCase("resmimetype", 108, 1, 110,  16, 5267, 5356)]
 58 |         [TestCase("version",     111, 1, 113,  16, 5357, 5426)]
 59 |         [TestCase("reader",      114, 1, 116,  16, 5427, 5616)]
 60 |         [TestCase("writer",      117, 1, 119,  16, 5617, 5806)]
 61 |         [TestCase("Image1",      121, 1, 123,  11, 5947, 6175)]
 62 |         [TestCase("String1",     124, 1, 126,  11, 6176, 6264)]
 63 |         [TestCase("String2",     127, 1, 132,  11, 6265, 6418)]
 64 |         [TestCase("String3",     133, 1, 135,  11, 6419, 6507)]
 65 |         [TestCase("String4",     136, 1, 138,  11, 6508, 6596)]
 66 |         [TestCase("String5: a",  139, 1, 141,  11, 6597, 6685)]
 67 |         public void Child_matches(string name, int startLineNr, int startLinePos, int endLineNr, int endLinePos, int startSpan, int stopSpan)
 68 |         {
 69 |             Assert.Multiple(() =>
 70 |             {
 71 |                 var node = ObjectUnderTest.Children.SelectMany(_ => _.Children.OfType<TerminalNode>()).First(_ => _.Name == name);
 72 | 
 73 |                 Assert.That(node.LocationSpan.Start, Is.EqualTo(new LineInfo(startLineNr, startLinePos)), "wrong location start for " + name);
 74 |                 Assert.That(node.LocationSpan.End, Is.EqualTo(new LineInfo(endLineNr, endLinePos)), "wrong location end for " + name);
 75 | 
 76 |                 Assert.That(node.Span, Is.EqualTo(new CharacterSpan(startSpan, stopSpan)), "wrong span for " + name);
 77 |             });
 78 |         }
 79 | 
 80 |         [Test]
 81 |         public void Assembly_matches()
 82 |         {
 83 |             Assert.Multiple(() =>
 84 |             {
 85 |                 var node = ObjectUnderTest.Children.SelectMany(_ => _.Children.OfType<TerminalNode>()).First(_ => _.Type == "assembly");
 86 | 
 87 |                 Assert.That(node.LocationSpan.Start, Is.EqualTo(new LineInfo(120, 1)));
 88 |                 Assert.That(node.LocationSpan.End, Is.EqualTo(new LineInfo(120, 140)));
 89 | 
 90 |                 Assert.That(node.Span, Is.EqualTo(new CharacterSpan(5807, 5946)));
 91 |             });
 92 |         }
 93 | 
 94 |         [Test]
 95 |         public void RoundTrip_Yaml_can_be_read()
 96 |         {
 97 |             var yaml = ObjectUnderTest.ToYamlString();
 98 | 
 99 |             VerifyRead(yaml);
100 |         }
101 | 
102 |         private static void VerifyRead(string yaml)
103 |         {
104 |             try
105 |             {
106 |                 var stream = new YamlStream();
107 |                 stream.Load(new StringReader(yaml));
108 |             }
109 |             catch (YamlException ex)
110 |             {
111 |                 Assert.Fail(ex.Message + Environment.NewLine + yaml);
112 |             }
113 |         }
114 |     }
115 | }
116 | 


--------------------------------------------------------------------------------
/Tests/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.InteropServices;
 3 | 
 4 | // General Information about an assembly is controlled through the following
 5 | // set of attributes. Change these attribute values to modify the information
 6 | // associated with an assembly.
 7 | [assembly: AssemblyTitle("Tests")]
 8 | [assembly: AssemblyDescription("")]
 9 | [assembly: AssemblyConfiguration("")]
10 | [assembly: AssemblyCompany("MiKo Solutions")]
11 | [assembly: AssemblyProduct("ResXSemanticParser")]
12 | [assembly: AssemblyCopyright("Copyright © MiKo Solutions 2018")]
13 | [assembly: AssemblyTrademark("")]
14 | [assembly: AssemblyCulture("")]
15 | 
16 | // Setting ComVisible to false makes the types in this assembly not visible
17 | // to COM components.  If you need to access a type in this assembly from
18 | // COM, set the ComVisible attribute to true on that type.
19 | [assembly: ComVisible(false)]
20 | 
21 | // The following GUID is for the ID of the typelib if this project is exposed to COM
22 | [assembly: Guid("458e024e-56ad-4971-9e12-5acb007e05d9")]
23 | 
24 | // Version information for an assembly consists of the following four values:
25 | //
26 | //      Major Version
27 | //      Minor Version
28 | //      Build Number
29 | //      Revision
30 | //
31 | // You can specify all the values or you can default the Build and Revision Numbers
32 | // by using the '*' as shown below:
33 | // [assembly: AssemblyVersion("1.0.*")]
34 | [assembly: AssemblyVersion("0.0.1.0")]
35 | [assembly: AssemblyFileVersion("0.0.1.0")]


--------------------------------------------------------------------------------
/Tests/Tests.csproj:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
 3 |   <Import Project="..\packages\NUnit.3.10.1\build\NUnit.props" Condition="Exists('..\packages\NUnit.3.10.1\build\NUnit.props')" />
 4 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
 5 |   <PropertyGroup>
 6 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
 7 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
 8 |     <ProjectGuid>{458E024E-56AD-4971-9E12-5ACB007E05D9}</ProjectGuid>
 9 |     <OutputType>Library</OutputType>
10 |     <AppDesignerFolder>Properties</AppDesignerFolder>
11 |     <RootNamespace>MiKoSolutions.SemanticParsers.ResX</RootNamespace>
12 |     <AssemblyName>Tests</AssemblyName>
13 |     <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
14 |     <FileAlignment>512</FileAlignment>
15 |     <NuGetPackageImportStamp>
16 |     </NuGetPackageImportStamp>
17 |   </PropertyGroup>
18 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
19 |     <DebugSymbols>true</DebugSymbols>
20 |     <DebugType>full</DebugType>
21 |     <Optimize>false</Optimize>
22 |     <OutputPath>bin\</OutputPath>
23 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
24 |     <ErrorReport>prompt</ErrorReport>
25 |     <WarningLevel>4</WarningLevel>
26 |     <CodeAnalysisRuleSet>Tests.ruleset</CodeAnalysisRuleSet>
27 |   </PropertyGroup>
28 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
29 |     <DebugType>pdbonly</DebugType>
30 |     <Optimize>true</Optimize>
31 |     <OutputPath>bin\</OutputPath>
32 |     <DefineConstants>TRACE</DefineConstants>
33 |     <ErrorReport>prompt</ErrorReport>
34 |     <WarningLevel>4</WarningLevel>
35 |     <CodeAnalysisRuleSet>Tests.ruleset</CodeAnalysisRuleSet>
36 |   </PropertyGroup>
37 |   <ItemGroup>
38 |     <Reference Include="Microsoft.CSharp" />
39 |     <Reference Include="nunit.framework, Version=3.10.1.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
40 |       <HintPath>..\packages\NUnit.3.10.1\lib\net45\nunit.framework.dll</HintPath>
41 |     </Reference>
42 |     <Reference Include="System" />
43 |     <Reference Include="System.Core" />
44 |     <Reference Include="System.Data" />
45 |     <Reference Include="System.Data.DataSetExtensions" />
46 |     <Reference Include="System.Net.Http" />
47 |     <Reference Include="System.Xml" />
48 |     <Reference Include="System.Xml.Linq" />
49 |     <Reference Include="YamlDotNet, Version=5.0.0.0, Culture=neutral, processorArchitecture=MSIL">
50 |       <HintPath>..\packages\YamlDotNet.5.1.0\lib\net45\YamlDotNet.dll</HintPath>
51 |     </Reference>
52 |   </ItemGroup>
53 |   <ItemGroup>
54 |     <Compile Include="ParserAdditionalTests.cs" />
55 |     <Compile Include="ParserTests.cs" />
56 |     <Compile Include="Properties\AssemblyInfo.cs" />
57 |     <Compile Include="test2.Designer.cs">
58 |       <AutoGen>True</AutoGen>
59 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
60 |       <DependentUpon>test2.resx</DependentUpon>
61 |       <DesignTime>True</DesignTime>
62 |     </Compile>
63 |   </ItemGroup>
64 |   <ItemGroup>
65 |     <ProjectReference Include="..\Parser\Parser.csproj">
66 |       <Project>{4e9e944d-118e-4d86-9b56-2b0b878a62b8}</Project>
67 |       <Name>Parser</Name>
68 |     </ProjectReference>
69 |   </ItemGroup>
70 |   <ItemGroup>
71 |     <None Include="packages.config" />
72 |     <None Include="Tests.ruleset" />
73 |   </ItemGroup>
74 |   <ItemGroup>
75 |     <AdditionalFiles Include="test.resx">
76 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
77 |       <SubType>Designer</SubType>
78 |     </AdditionalFiles>
79 |   </ItemGroup>
80 |   <ItemGroup>
81 |     <EmbeddedResource Include="test2.resx">
82 |       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
83 |       <Generator>ResXFileCodeGenerator</Generator>
84 |       <LastGenOutput>test2.Designer.cs</LastGenOutput>
85 |       <SubType>Designer</SubType>
86 |     </EmbeddedResource>
87 |   </ItemGroup>
88 |   <ItemGroup>
89 |     <Analyzer Include="..\packages\StyleCop.Analyzers.1.1.0-beta009\analyzers\dotnet\cs\StyleCop.Analyzers.CodeFixes.dll" />
90 |     <Analyzer Include="..\packages\StyleCop.Analyzers.1.1.0-beta009\analyzers\dotnet\cs\StyleCop.Analyzers.dll" />
91 |   </ItemGroup>
92 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
93 |   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
94 |     <PropertyGroup>
95 |       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
96 |     </PropertyGroup>
97 |     <Error Condition="!Exists('..\packages\NUnit.3.10.1\build\NUnit.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\NUnit.3.10.1\build\NUnit.props'))" />
98 |   </Target>
99 | </Project>


--------------------------------------------------------------------------------
/Tests/Tests.ruleset:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RuleSet Name="ResX Semantic Parser Test Rules" Description="Customized rule sets for the tests of the semantic parser for resx files." ToolsVersion="10.0">
 3 |   <Localization ResourceAssembly="Microsoft.VisualStudio.CodeAnalysis.RuleSets.Strings.dll" ResourceBaseName="Microsoft.VisualStudio.CodeAnalysis.RuleSets.Strings.Localized">
 4 |     <Name Resource="MinimumRecommendedRules_Name" />
 5 |     <Description Resource="MinimumRecommendedRules_Description" />
 6 |   </Localization>
 7 |   <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
 8 |     <Rule Id="CA1001" Action="Warning" />
 9 |     <Rule Id="CA1009" Action="Warning" />
10 |     <Rule Id="CA1016" Action="Warning" />
11 |     <Rule Id="CA1033" Action="Warning" />
12 |     <Rule Id="CA1049" Action="Warning" />
13 |     <Rule Id="CA1060" Action="Warning" />
14 |     <Rule Id="CA1061" Action="Warning" />
15 |     <Rule Id="CA1063" Action="Warning" />
16 |     <Rule Id="CA1065" Action="Warning" />
17 |     <Rule Id="CA1301" Action="Warning" />
18 |     <Rule Id="CA1400" Action="Warning" />
19 |     <Rule Id="CA1401" Action="Warning" />
20 |     <Rule Id="CA1403" Action="Warning" />
21 |     <Rule Id="CA1404" Action="Warning" />
22 |     <Rule Id="CA1405" Action="Warning" />
23 |     <Rule Id="CA1410" Action="Warning" />
24 |     <Rule Id="CA1415" Action="Warning" />
25 |     <Rule Id="CA1821" Action="Warning" />
26 |     <Rule Id="CA1900" Action="Warning" />
27 |     <Rule Id="CA1901" Action="Warning" />
28 |     <Rule Id="CA2002" Action="Warning" />
29 |     <Rule Id="CA2100" Action="Warning" />
30 |     <Rule Id="CA2101" Action="Warning" />
31 |     <Rule Id="CA2108" Action="Warning" />
32 |     <Rule Id="CA2111" Action="Warning" />
33 |     <Rule Id="CA2112" Action="Warning" />
34 |     <Rule Id="CA2114" Action="Warning" />
35 |     <Rule Id="CA2116" Action="Warning" />
36 |     <Rule Id="CA2117" Action="Warning" />
37 |     <Rule Id="CA2122" Action="Warning" />
38 |     <Rule Id="CA2123" Action="Warning" />
39 |     <Rule Id="CA2124" Action="Warning" />
40 |     <Rule Id="CA2126" Action="Warning" />
41 |     <Rule Id="CA2131" Action="Warning" />
42 |     <Rule Id="CA2132" Action="Warning" />
43 |     <Rule Id="CA2133" Action="Warning" />
44 |     <Rule Id="CA2134" Action="Warning" />
45 |     <Rule Id="CA2137" Action="Warning" />
46 |     <Rule Id="CA2138" Action="Warning" />
47 |     <Rule Id="CA2140" Action="Warning" />
48 |     <Rule Id="CA2141" Action="Warning" />
49 |     <Rule Id="CA2146" Action="Warning" />
50 |     <Rule Id="CA2147" Action="Warning" />
51 |     <Rule Id="CA2149" Action="Warning" />
52 |     <Rule Id="CA2200" Action="Warning" />
53 |     <Rule Id="CA2202" Action="Warning" />
54 |     <Rule Id="CA2207" Action="Warning" />
55 |     <Rule Id="CA2212" Action="Warning" />
56 |     <Rule Id="CA2213" Action="Warning" />
57 |     <Rule Id="CA2214" Action="Warning" />
58 |     <Rule Id="CA2216" Action="Warning" />
59 |     <Rule Id="CA2220" Action="Warning" />
60 |     <Rule Id="CA2229" Action="Warning" />
61 |     <Rule Id="CA2231" Action="Warning" />
62 |     <Rule Id="CA2232" Action="Warning" />
63 |     <Rule Id="CA2235" Action="Warning" />
64 |     <Rule Id="CA2236" Action="Warning" />
65 |     <Rule Id="CA2237" Action="Warning" />
66 |     <Rule Id="CA2238" Action="Warning" />
67 |     <Rule Id="CA2240" Action="Warning" />
68 |     <Rule Id="CA2241" Action="Warning" />
69 |     <Rule Id="CA2242" Action="Warning" />
70 |   </Rules>
71 |   <Rules AnalyzerId="StyleCop.Analyzers" RuleNamespace="StyleCop.Analyzers">
72 |     <Rule Id="SA1120" Action="Hidden" />
73 |     <Rule Id="SA1101" Action="Hidden" />
74 |     <Rule Id="SA1633" Action="Hidden" />
75 |     <Rule Id="SA1200" Action="Hidden" />
76 |     <Rule Id="SA1133" Action="Hidden" />
77 |     <Rule Id="SA1309" Action="Hidden" />
78 |     <Rule Id="SA0001" Action="Hidden" />
79 |   </Rules>
80 | </RuleSet>


--------------------------------------------------------------------------------
/Tests/packages.config:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <packages>
3 |   <package id="Codecov" version="1.1.0" targetFramework="net472" />
4 |   <package id="NUnit" version="3.10.1" targetFramework="net472" />
5 |   <package id="OpenCover" version="4.6.519" targetFramework="net472" />
6 |   <package id="StyleCop.Analyzers" version="1.1.0-beta009" targetFramework="net472" developmentDependency="true" />
7 |   <package id="YamlDotNet" version="5.1.0" targetFramework="net472" />
8 | </packages>


--------------------------------------------------------------------------------
/Tests/test.resx:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <root>
  3 |   <!-- 
  4 |     Microsoft ResX Schema 
  5 |     
  6 |     Version 2.0
  7 |     
  8 |     The primary goals of this format is to allow a simple XML format 
  9 |     that is mostly human readable. The generation and parsing of the 
 10 |     various data types are done through the TypeConverter classes 
 11 |     associated with the data types.
 12 |     
 13 |     Example:
 14 |     
 15 |     ... ado.net/XML headers & schema ...
 16 |     <resheader name="resmimetype">text/microsoft-resx</resheader>
 17 |     <resheader name="version">2.0</resheader>
 18 |     <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
 19 |     <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
 20 |     <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
 21 |     <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
 22 |     <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
 23 |         <value>[base64 mime encoded serialized .NET Framework object]</value>
 24 |     </data>
 25 |     <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
 26 |         <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
 27 |         <comment>This is a comment</comment>
 28 |     </data>
 29 |                 
 30 |     There are any number of "resheader" rows that contain simple 
 31 |     name/value pairs.
 32 |     
 33 |     Each data row contains a name, and value. The row also contains a 
 34 |     type or mimetype. Type corresponds to a .NET class that support 
 35 |     text/value conversion through the TypeConverter architecture. 
 36 |     Classes that don't support this are serialized and stored with the 
 37 |     mimetype set.
 38 |     
 39 |     The mimetype is used for serialized objects, and tells the 
 40 |     ResXResourceReader how to depersist the object. This is currently not 
 41 |     extensible. For a given mimetype the value must be set accordingly:
 42 |     
 43 |     Note - application/x-microsoft.net.object.binary.base64 is the format 
 44 |     that the ResXResourceWriter will generate, however the reader can 
 45 |     read any of the formats listed below.
 46 |     
 47 |     mimetype: application/x-microsoft.net.object.binary.base64
 48 |     value   : The object must be serialized with 
 49 |             : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
 50 |             : and then encoded with base64 encoding.
 51 |     
 52 |     mimetype: application/x-microsoft.net.object.soap.base64
 53 |     value   : The object must be serialized with 
 54 |             : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
 55 |             : and then encoded with base64 encoding.
 56 | 
 57 |     mimetype: application/x-microsoft.net.object.bytearray.base64
 58 |     value   : The object must be serialized into a byte array 
 59 |             : using a System.ComponentModel.TypeConverter
 60 |             : and then encoded with base64 encoding.
 61 |     -->
 62 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 63 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 64 |     <xsd:element name="root" msdata:IsDataSet="true">
 65 |       <xsd:complexType>
 66 |         <xsd:choice maxOccurs="unbounded">
 67 |           <xsd:element name="metadata">
 68 |             <xsd:complexType>
 69 |               <xsd:sequence>
 70 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
 71 |               </xsd:sequence>
 72 |               <xsd:attribute name="name" use="required" type="xsd:string" />
 73 |               <xsd:attribute name="type" type="xsd:string" />
 74 |               <xsd:attribute name="mimetype" type="xsd:string" />
 75 |               <xsd:attribute ref="xml:space" />
 76 |             </xsd:complexType>
 77 |           </xsd:element>
 78 |           <xsd:element name="assembly">
 79 |             <xsd:complexType>
 80 |               <xsd:attribute name="alias" type="xsd:string" />
 81 |               <xsd:attribute name="name" type="xsd:string" />
 82 |             </xsd:complexType>
 83 |           </xsd:element>
 84 |           <xsd:element name="data">
 85 |             <xsd:complexType>
 86 |               <xsd:sequence>
 87 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
 88 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
 89 |               </xsd:sequence>
 90 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
 91 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
 92 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
 93 |               <xsd:attribute ref="xml:space" />
 94 |             </xsd:complexType>
 95 |           </xsd:element>
 96 |           <xsd:element name="resheader">
 97 |             <xsd:complexType>
 98 |               <xsd:sequence>
 99 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
100 |               </xsd:sequence>
101 |               <xsd:attribute name="name" type="xsd:string" use="required" />
102 |             </xsd:complexType>
103 |           </xsd:element>
104 |         </xsd:choice>
105 |       </xsd:complexType>
106 |     </xsd:element>
107 |   </xsd:schema>
108 |   <resheader name="resmimetype">
109 |     <value>text/microsoft-resx</value>
110 |   </resheader>
111 |   <resheader name="version">
112 |     <value>2.0</value>
113 |   </resheader>
114 |   <resheader name="reader">
115 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
116 |   </resheader>
117 |   <resheader name="writer">
118 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
119 |   </resheader>
120 |   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
121 |   <data name="Image1" type="System.Resources.ResXFileRef, System.Windows.Forms">
122 |     <value>Image1.png;System.Drawing.Bitmap, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
123 |   </data>
124 |   <data name="String1" xml:space="preserve">
125 |     <value>some string</value>
126 |   </data>
127 |   <data name="String2" xml:space="preserve">
128 |     <value>some multiline string A
129 | some multiline string B
130 | some multiline string C
131 | 	</value>
132 |   </data>
133 |   <data name="String3" xml:space="preserve">
134 |     <value>some string</value>
135 |   </data>
136 |   <data name="String4" xml:space="preserve">
137 |     <value>some string</value>
138 |   </data>
139 |   <data name="String5: a" xml:space="preserve">
140 |     <value>anything</value>
141 |   </data>
142 | </root>
143 | 
144 | 


--------------------------------------------------------------------------------
/Tests/test2.Designer.cs:
--------------------------------------------------------------------------------
 1 | //------------------------------------------------------------------------------
 2 | // <auto-generated>
 3 | //     This code was generated by a tool.
 4 | //     Runtime Version:4.0.30319.42000
 5 | //
 6 | //     Changes to this file may cause incorrect behavior and will be lost if
 7 | //     the code is regenerated.
 8 | // </auto-generated>
 9 | //------------------------------------------------------------------------------
10 | 
11 | namespace MiKoSolutions.SemanticParsers.ResX {
12 |     using System;
13 |     
14 |     
15 |     /// <summary>
16 |     ///   A strongly-typed resource class, for looking up localized strings, etc.
17 |     /// </summary>
18 |     // This class was auto-generated by the StronglyTypedResourceBuilder
19 |     // class via a tool like ResGen or Visual Studio.
20 |     // To add or remove a member, edit your .ResX file then rerun ResGen
21 |     // with the /str option, or rebuild your VS project.
22 |     [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")]
23 |     [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
24 |     [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
25 |     internal class test2 {
26 |         
27 |         private static global::System.Resources.ResourceManager resourceMan;
28 |         
29 |         private static global::System.Globalization.CultureInfo resourceCulture;
30 |         
31 |         [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
32 |         internal test2() {
33 |         }
34 |         
35 |         /// <summary>
36 |         ///   Returns the cached ResourceManager instance used by this class.
37 |         /// </summary>
38 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
39 |         internal static global::System.Resources.ResourceManager ResourceManager {
40 |             get {
41 |                 if (object.ReferenceEquals(resourceMan, null)) {
42 |                     global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MiKoSolutions.SemanticParsers.ResX.test2", typeof(test2).Assembly);
43 |                     resourceMan = temp;
44 |                 }
45 |                 return resourceMan;
46 |             }
47 |         }
48 |         
49 |         /// <summary>
50 |         ///   Overrides the current thread's CurrentUICulture property for all
51 |         ///   resource lookups using this strongly typed resource class.
52 |         /// </summary>
53 |         [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
54 |         internal static global::System.Globalization.CultureInfo Culture {
55 |             get {
56 |                 return resourceCulture;
57 |             }
58 |             set {
59 |                 resourceCulture = value;
60 |             }
61 |         }
62 |         
63 |         /// <summary>
64 |         ///   Looks up a localized string similar to something.
65 |         /// </summary>
66 |         internal static string String1 {
67 |             get {
68 |                 return ResourceManager.GetString("String1", resourceCulture);
69 |             }
70 |         }
71 |         
72 |         /// <summary>
73 |         ///   Looks up a localized string similar to more text
74 |         ///with line break.
75 |         /// </summary>
76 |         internal static string String2 {
77 |             get {
78 |                 return ResourceManager.GetString("String2", resourceCulture);
79 |             }
80 |         }
81 |     }
82 | }
83 | 


--------------------------------------------------------------------------------
/Tests/test2.resx:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <root>
 3 |   <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
 4 |     <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
 5 |     <xsd:element name="root" msdata:IsDataSet="true">
 6 |       <xsd:complexType>
 7 |         <xsd:choice maxOccurs="unbounded">
 8 |           <xsd:element name="metadata">
 9 |             <xsd:complexType>
10 |               <xsd:sequence>
11 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" />
12 |               </xsd:sequence>
13 |               <xsd:attribute name="name" use="required" type="xsd:string" />
14 |               <xsd:attribute name="type" type="xsd:string" />
15 |               <xsd:attribute name="mimetype" type="xsd:string" />
16 |               <xsd:attribute ref="xml:space" />
17 |             </xsd:complexType>
18 |           </xsd:element>
19 |           <xsd:element name="assembly">
20 |             <xsd:complexType>
21 |               <xsd:attribute name="alias" type="xsd:string" />
22 |               <xsd:attribute name="name" type="xsd:string" />
23 |             </xsd:complexType>
24 |           </xsd:element>
25 |           <xsd:element name="data">
26 |             <xsd:complexType>
27 |               <xsd:sequence>
28 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
29 |                 <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
30 |               </xsd:sequence>
31 |               <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
32 |               <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
33 |               <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
34 |               <xsd:attribute ref="xml:space" />
35 |             </xsd:complexType>
36 |           </xsd:element>
37 |           <xsd:element name="resheader">
38 |             <xsd:complexType>
39 |               <xsd:sequence>
40 |                 <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
41 |               </xsd:sequence>
42 |               <xsd:attribute name="name" type="xsd:string" use="required" />
43 |             </xsd:complexType>
44 |           </xsd:element>
45 |         </xsd:choice>
46 |       </xsd:complexType>
47 |     </xsd:element>
48 |   </xsd:schema>
49 |   <resheader name="resmimetype">
50 |     <value>text/microsoft-resx</value>
51 |   </resheader>
52 |   <resheader name="version">
53 |     <value>2.0</value>
54 |   </resheader>
55 |   <resheader name="reader">
56 |     <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
57 |   </resheader>
58 |   <resheader name="writer">
59 |     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
60 |   </resheader>
61 |   <data name="String1" xml:space="preserve">
62 |     <value>something</value>
63 |   </data>
64 |   <data name="String2" xml:space="preserve">
65 |     <value>more text
66 | with line break</value>
67 |     <comment>Some comment</comment>
68 |   </data>
69 | </root>


--------------------------------------------------------------------------------
/appveyor.yml:
--------------------------------------------------------------------------------
 1 | # Documentation/Reference: https://www.appveyor.com/docs/appveyor-yml/
 2 | 
 3 | # Semantic Versioning http://semver.org/
 4 | version: 0.0.{build}
 5 | 
 6 | image: Visual Studio 2017
 7 | 
 8 | # branches to build
 9 | branches:
10 |   # whitelist
11 |   only:
12 |     - master
13 | 
14 | init:
15 | - git config --global core.autocrlf true
16 | 
17 | # environment:
18 | 
19 | install:
20 |   - choco install gitversion.portable -pre -y
21 |   
22 | # Install NUnit console runner
23 | #  - ps: Start-FileDownload $env:NUnitRunnerUri -FileName NUnitInstaller.zip
24 | #  - cmd: 7z x NUnitInstaller.zip -y
25 |   
26 | # clone directory
27 | clone_folder: c:\projects\ResXSemanticParsers
28 | 
29 | # fetch repository as zip archive (when next line is uncommented)
30 | # shallow_clone: true
31 | 
32 | # skip specific commits
33 | skip_commits:
34 |   files:
35 |     - /*.md
36 | 
37 | before_build:
38 | - nuget restore "c:\projects\ResXSemanticParsers\ResXSemanticParser.sln"
39 | 
40 | # enable patching of AssemblyInfo.* files
41 | assembly_info:
42 |   patch: true
43 |   file: AssemblyInfo.*
44 |   assembly_version: "{version}"
45 |   assembly_file_version: "{version}"
46 |   assembly_informational_version: "{version}"
47 | 
48 | build:
49 |   parallel: true
50 |   project: ResXSemanticParser.sln
51 |   verbosity: minimal
52 | 
53 | platform:
54 |   - Any CPU
55 | 
56 | configuration:
57 |   - Debug
58 | #  - Release
59 | 
60 | test_script:
61 | -  .\packages\OpenCover.4.6.519\tools\OpenCover.Console.exe -register:user -target:"nunit3-console.exe" -targetargs:" "".\Tests\bin\Tests.dll"" --workers=16 " -returntargetcode -filter:"+[MiKo*]* -[*Test*]*" -excludebyattribute:*.ExcludeFromCodeCoverage* -excludebyfile:*\*Designer.cs -hideskipped:All -output:"c:\projects\ResXSemanticParsers\CodeCoverage.xml"
62 | 
63 | # Codecov Flags (https://docs.codecov.io/v4.3.6/docs/flags)
64 | - .\packages\Codecov.1.1.0\tools\codecov.exe -f "c:\projects\ResXSemanticParsers\CodeCoverage.xml" --flag api
65 | 
66 | # cache:
67 | 
68 | 


--------------------------------------------------------------------------------
/codecov.yml:
--------------------------------------------------------------------------------
 1 | # https://docs.codecov.io/docs/codecov-yaml
 2 | # https://github.com/codecov/support/wiki/Codecov-Yaml
 3 | 
 4 | coverage:
 5 |   range: 70..100
 6 |   round: down
 7 |   precision: 2
 8 |   
 9 | ignore:
10 |       - Tests/
11 | 
12 | coverage:
13 |   status:
14 |     project:
15 |       default: off
16 |       api:
17 |         target: 100%
18 |         flags: api
19 | 
20 | flags:
21 |   api:
22 |     paths:
23 |       - Parser/
24 |   test:
25 |     paths:
26 |       - Tests/
27 | 
28 | codecov:
29 |   token: e2924b31-58b4-44d7-8093-b315286bf58f


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