Use raw string literals if supported by the target language

In the cases where the values go through .editorconfig (such as constants and project properties), this isn't necessary (or supported) right now since .editorconfig will truncate multi-line values Closes #243
devlooped · Jul 3, 2023 · 6c39058 · 6c39058
1 parent 7b2ea8d
commit 6c39058
Show file tree

Hide file tree

Showing 16 changed files with 98 additions and 27 deletions.
diff --git a/src/Directory.props b/src/Directory.props
@@ -17,6 +17,7 @@
     <PackageScribanIncludeSource>true</PackageScribanIncludeSource>
 
     <SuppressNETCoreSdkPreviewMessage>true</SuppressNETCoreSdkPreviewMessage>
+    <NoWarn>MSB3277;$(NoWarn)</NoWarn>
   </PropertyGroup>
 
   <PropertyGroup Label="Build">

diff --git a/src/ThisAssembly.AssemblyInfo/AssemblyInfoGenerator.cs b/src/ThisAssembly.AssemblyInfo/AssemblyInfoGenerator.cs
@@ -39,7 +39,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 .Collect();
 
             context.RegisterSourceOutput(
-                metadata.Combine(context.CompilationProvider.Select((s, _) => s.Language)),
+                metadata.Combine(context.ParseOptionsProvider),
                 GenerateSource);
         }
 
@@ -66,12 +66,15 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             return new KeyValuePair<string, string>(key, value);
         }
 
-        static void GenerateSource(SourceProductionContext spc, (ImmutableArray<KeyValuePair<string, string>> attributes, string language) arg2)
+        static void GenerateSource(SourceProductionContext spc, (ImmutableArray<KeyValuePair<string, string>> attributes, ParseOptions parse) arg)
         {
-            var (attributes, language) = arg2;
+            var (attributes, parse) = arg;
 
             var model = new Model(attributes.ToList());
-            var file = language.Replace("#", "Sharp") + ".sbntxt";
+            if (parse is CSharpParseOptions cs && (int)cs.LanguageVersion >= 11)
+                model.RawStrings = true;
+
+            var file = parse.Language.Replace("#", "Sharp") + ".sbntxt";
             var template = Template.Parse(EmbeddedResource.GetContent(file), file);
             var output = template.Render(model, member => member.Name);
 

diff --git a/src/ThisAssembly.AssemblyInfo/CSharp.sbntxt b/src/ThisAssembly.AssemblyInfo/CSharp.sbntxt
@@ -24,8 +24,14 @@ partial class ThisAssembly
     public static partial class Info
     {
         {{~ for prop in Properties ~}}
+        {{~ if RawStrings ~}}
+        public const string {{ prop.Key }} = 
+"""
+{{ prop.Value }}
+""";
+        {{~ else ~}}
         public const string {{ prop.Key }} = @"{{ prop.Value }}";
-
+        {{~ end ~}}
         {{~ end ~}}
     }
 }
diff --git a/src/ThisAssembly.AssemblyInfo/Model.cs b/src/ThisAssembly.AssemblyInfo/Model.cs
@@ -8,6 +8,7 @@ public class Model
     {
         public Model(IEnumerable<KeyValuePair<string, string>> properties) => Properties = properties.ToList();
 
+        public bool RawStrings { get; set; } = false;
         public string Version => Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
 
         public List<KeyValuePair<string, string>> Properties { get; }

diff --git a/src/ThisAssembly.AssemblyInfo/ThisAssembly.AssemblyInfo.csproj b/src/ThisAssembly.AssemblyInfo/ThisAssembly.AssemblyInfo.csproj
@@ -39,4 +39,8 @@ on the `ThisAssembly.Info` class.
     <PackageReference Include="PolySharp" Version="1.13.2" PrivateAssets="All" />
   </ItemGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="ThisAssembly.Tests"/>
+  </ItemGroup>
+
 </Project>
diff --git a/src/ThisAssembly.Constants/CSharp.sbntxt b/src/ThisAssembly.Constants/CSharp.sbntxt
@@ -22,7 +22,14 @@
     {
         {{~ for value in $0.Values ~}}
         {{- summary value ~}}
-	    public const string {{ value.Name | string.replace "-" "_" | string.replace " " "_" }} =  @"{{ value.Value }}";
+        {{~ if RawStrings ~}}
+	    public const string {{ value.Name | string.replace "-" "_" | string.replace " " "_" }} = 
+"""
+{{ value.Value }}
+""";
+        {{~ else ~}}
+	    public const string {{ value.Name | string.replace "-" "_" | string.replace " " "_" }} = @"{{ value.Value }}";
+        {{~ end ~}}
         {{~ end ~}}
 
         {{ for area in $0.NestedAreas 

diff --git a/src/ThisAssembly.Constants/ConstantsGenerator.cs b/src/ThisAssembly.Constants/ConstantsGenerator.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Text;
 using Scriban;
 
@@ -30,28 +31,32 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                         comment: string.IsNullOrWhiteSpace(comment) ? null : comment,
                         root: string.IsNullOrWhiteSpace(root) ? "Constants" : root!);
                 })
-                .Combine(context.CompilationProvider.Select((p, _) => p.Language));
+                .Combine(context.ParseOptionsProvider);
 
             context.RegisterSourceOutput(
                 files,
                 GenerateConstant);
 
         }
 
-        void GenerateConstant(SourceProductionContext spc, ((string name, string value, string? comment, string root), string language) args)
+        void GenerateConstant(SourceProductionContext spc, ((string name, string value, string? comment, string root), ParseOptions parse) args)
         {
-            var ((name, value, comment, root), language) = args;
+            var ((name, value, comment, root), parse) = args;
 
             var rootArea = Area.Load(new List<Constant> { new Constant(name, value, comment), }, root);
-            var file = language.Replace("#", "Sharp") + ".sbntxt";
+            var file = parse.Language.Replace("#", "Sharp") + ".sbntxt";
             var template = Template.Parse(EmbeddedResource.GetContent(file), file);
-            var output = template.Render(new Model(rootArea), member => member.Name);
+            var model = new Model(rootArea);
+            if (parse is CSharpParseOptions cs && (int)cs.LanguageVersion >= 11)
+                model.RawStrings = true;
+
+            var output = template.Render(model, member => member.Name);
 
             // Apply formatting since indenting isn't that nice in Scriban when rendering nested 
             // structures via functions.
-            if (language == LanguageNames.CSharp)
+            if (parse.Language == LanguageNames.CSharp)
             {
-                output = Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseCompilationUnit(output)
+                output = SyntaxFactory.ParseCompilationUnit(output)
                     .NormalizeWhitespace()
                     .GetText()
                     .ToString();

diff --git a/src/ThisAssembly.Constants/Model.cs b/src/ThisAssembly.Constants/Model.cs
@@ -7,6 +7,7 @@
 [DebuggerDisplay("Values = {RootArea.Values.Count}")]
 record Model(Area RootArea)
 {
+    public bool RawStrings { get; set; } = false;
     public string Version => Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
 }
 

diff --git a/src/ThisAssembly.Metadata/CSharp.sbntxt b/src/ThisAssembly.Metadata/CSharp.sbntxt
@@ -24,8 +24,16 @@ partial class ThisAssembly
     public static partial class Metadata
     {
         {{~ for md in Metadata ~}}
-        /// <summary>{{ md.Key }} = {{ md.Value }}</summary>
+        /// <summary>{{ md.Key }} = {{ md.Value | string.split "\n" | array.first | string.replace "\r" "" | string.lstrip | string.rstrip }}</summary>
+        {{~ if RawStrings ~}}
+        public const string {{ md.Key }} = 
+"""
+{{ md.Value }}
+""";
+        {{~ else ~}}
+        /// <summary>{{ prop.Key }} = {{ prop.Value }}</summary>
         public const string {{ md.Key }} = @"{{ md.Value }}";
+        {{~ end ~}}
 
         {{~ end ~}}
     }

diff --git a/src/ThisAssembly.Metadata/MetadataGenerator.cs b/src/ThisAssembly.Metadata/MetadataGenerator.cs
@@ -6,9 +6,11 @@
 using System.Threading;
 using System.Xml.Linq;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Text;
 using Scriban;
+using Scriban.Parsing;
 
 namespace ThisAssembly
 {
@@ -26,7 +28,7 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 .Collect();
 
             context.RegisterSourceOutput(
-                metadata.Combine(context.CompilationProvider.Select((s, _) => s.Language)),
+                metadata.Combine(context.ParseOptionsProvider),
                 GenerateSource);
         }
 
@@ -54,12 +56,15 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             return new KeyValuePair<string, string>(key, value);
         }
 
-        void GenerateSource(SourceProductionContext spc, (ImmutableArray<KeyValuePair<string, string>> attributes, string language) arg2)
+        void GenerateSource(SourceProductionContext spc, (ImmutableArray<KeyValuePair<string, string>> attributes, ParseOptions parse) arg)
         {
-            var (attributes, language) = arg2;
+            var (attributes, parse) = arg;
 
             var model = new Model(attributes.ToList());
-            var file = language.Replace("#", "Sharp") + ".sbntxt";
+            if (parse is CSharpParseOptions cs && (int)cs.LanguageVersion >= 11)
+                model.RawStrings = true;
+
+            var file = parse.Language.Replace("#", "Sharp") + ".sbntxt";
             var template = Template.Parse(EmbeddedResource.GetContent(file), file);
             var output = template.Render(model, member => member.Name);
 

diff --git a/src/ThisAssembly.Metadata/Model.cs b/src/ThisAssembly.Metadata/Model.cs
@@ -8,6 +8,7 @@ public class Model
     {
         public Model(IEnumerable<KeyValuePair<string, string>> metadata) => Metadata = metadata.ToList();
 
+        public bool RawStrings { get; set; } = false;
         public string Version => Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
 
         public List<KeyValuePair<string, string>> Metadata { get; }

diff --git a/src/ThisAssembly.Project/CSharp.sbntxt b/src/ThisAssembly.Project/CSharp.sbntxt
@@ -24,9 +24,15 @@ partial class ThisAssembly
     public static partial class Project
     {
         {{~ for prop in Properties ~}}
+        {{~ if RawStrings ~}}
+        public const string {{ prop.Key }} = 
+"""
+{{ prop.Value }}
+""";
+        {{~ else ~}}
         /// <summary>{{ prop.Key }} = {{ prop.Value }}</summary>
         public const string {{ prop.Key }} = @"{{ prop.Value }}";
-
+        {{~ end ~}}
         {{~ end ~}}
     }
 }
diff --git a/src/ThisAssembly.Project/Model.cs b/src/ThisAssembly.Project/Model.cs
@@ -8,6 +8,7 @@ public class Model
     {
         public Model(IEnumerable<KeyValuePair<string, string>> properties) => Properties = properties.ToList();
 
+        public bool RawStrings { get; set; } = false;
         public string Version => Assembly.GetExecutingAssembly().GetName().Version.ToString(3);
 
         public List<KeyValuePair<string, string>> Properties { get; }

diff --git a/src/ThisAssembly.Project/ProjectPropertyGenerator.cs b/src/ThisAssembly.Project/ProjectPropertyGenerator.cs
@@ -4,6 +4,7 @@
 using System.Linq;
 using System.Text;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Text;
 using Scriban;
 
@@ -30,16 +31,19 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
                 .Collect();
 
             context.RegisterSourceOutput(
-                properties.Combine(context.CompilationProvider.Select((s, _) => s.Language)),
+                properties.Combine(context.ParseOptionsProvider),
                 GenerateSource);
         }
 
-        void GenerateSource(SourceProductionContext spc, (ImmutableArray<KeyValuePair<string, string?>> properties, string language) arg2)
+        void GenerateSource(SourceProductionContext spc, (ImmutableArray<KeyValuePair<string, string?>> properties, ParseOptions parse) arg)
         {
-            var (properties, language) = arg2;
+            var (properties, parse) = arg;
 
             var model = new Model(properties);
-            var file = language.Replace("#", "Sharp") + ".sbntxt";
+            if (parse is CSharpParseOptions cs && (int)cs.LanguageVersion >= 11)
+                model.RawStrings = true;
+
+            var file = parse.Language.Replace("#", "Sharp") + ".sbntxt";
             var template = Template.Parse(EmbeddedResource.GetContent(file), file);
             var output = template.Render(model, member => member.Name);
 

diff --git a/src/ThisAssembly.Tests/Tests.cs b/src/ThisAssembly.Tests/Tests.cs
@@ -19,8 +19,13 @@ public void CanUseInfo()
 
     [Fact]
     public void CanUseInfoDescription()
-        => Assert.Equal(@"A Description
-with a newline".ReplaceLineEndings(), ThisAssembly.Info.Description.ReplaceLineEndings());
+        => Assert.Equal(
+            """
+            A Description
+                  with a newline and
+                  * Some "things" with quotes
+                  // Some comments too.
+            """.ReplaceLineEndings(), ThisAssembly.Info.Description.ReplaceLineEndings());
 
     [Fact]
     public void CanUseConstants()

diff --git a/src/ThisAssembly.Tests/ThisAssembly.Tests.csproj b/src/ThisAssembly.Tests/ThisAssembly.Tests.csproj
@@ -3,8 +3,16 @@
   <PropertyGroup>
     <IsPackable>false</IsPackable>
     <TargetFramework>net7.0</TargetFramework>
+    <Multiline>
+      A Description
+      with a newline and
+      * Some "things" with quotes
+      // Some comments too.
+    </Multiline>
     <Description>A Description
-with a newline</Description>
+      with a newline and
+      * Some "things" with quotes
+      // Some comments too.</Description>
     <TargetFramework Condition="'$(BuildingInsideVisualStudio)' == 'true'">net472</TargetFramework>
     <RootNamespace>ThisAssemblyTests</RootNamespace>
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
@@ -54,20 +62,25 @@ with a newline</Description>
   <ItemGroup>
     <ProjectProperty Include="Foo" />
     <ProjectProperty Include="Foo" />
+    <ProjectProperty Include="Description" />
+    <!-- Multiline values that go through .editorconfig will get truncated, unfortunately -->
+    <ProjectProperty Include="Multiline" />
+    <Constant Include="Foo.Raw" Value="$(Multiline)" Comment="$(Multiline)" />
     <Constant Include="Foo.Bar" Value="Baz" Comment="Yay!" />
     <Constant Include="Foo.Hello" Value="World" Comment="Comments make everything better 😍" />
     <FileConstant Include="@(None)" />
     <FileConstant Update="@(FileConstant -&gt; WithMetadataValue('Filename', 'Readme'))">
       <Link>Included/%(Filename)%(Extension)</Link>
     </FileConstant>
     <AssemblyMetadata Include="Foo" Value="Bar" />
+    <AssemblyMetadata Include="Raw" Value="$(Multiline)" />
   </ItemGroup>
 
   <ItemGroup>
     <Compile Include="..\ThisAssembly.Strings\Model.cs" Link="Model.cs" />
   </ItemGroup>
 
-  <Import Project="..\ThisAssembly.Prerequisites.targets"/>
+  <Import Project="..\ThisAssembly.Prerequisites.targets" />
   <Import Project="..\*\*.targets" />
 
 </Project>