Feature: Added multi-line parsing via double quotes & Fix: Pipelines

.github/workflows/build.yml

@@ -13,9 +13,9 @@ jobs:
       - uses: actions/checkout@v3
 
       - name: Use .NET 8 SDK
-        uses: actions/setup-dotnet@v2
+        uses: actions/setup-dotnet@v4
         with:
-          dotnet-version: 8.0
+          dotnet-version: 8.0.x
 
       - name: Restore dependencies
         run: dotnet restore ./src/**/*.csproj
@@ -24,12 +24,10 @@ jobs:
         run: dotnet build ./src/**/*.csproj -c Release --no-restore
 
       - name: Run tests with code coverage
-        run: dotnet test ./src/**/*.csproj -c Release --no-restore \
-          --collect-coverage true --coverage-directory ./coverage \
-          --coverage-format lcov
+        run: dotnet test dotenv.net.sln /p:CollectCoverage=true /p:CoverletOutputFormat=lcov /p:CoverletOutput=./coverage/
 
       - name: Upload coverage to Coveralls
-        uses: coveralls-actions/coveralls-action@v1.3.1
+        uses: coverallsapp/github-action@v1.1.2
         with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          coveralls-file: ./coverage/coverage.info
+          github-token: ${{ github.token }}
+          path-to-lcov: ${{ github.workspace }}/tests/dotenv.net.Tests/coverage/coverage.info

README.md

@@ -107,6 +107,21 @@ var envVars = DotEnv.Read();
 Console.WriteLine(envVars["KEY"]); // would print out whatever value was associated with the 'KEY'
 ```
 
+### Defining env variables
+
+Environment variables can be defined in various ways:
+
+* \# I am comment
+* hello=world
+* SINGLE_QUOTES='single'
+* DOUBLE_QUOTES="double"
+
+Any variable starting with # will be ignored by the parser. 
+
+Any variable containing no quotes or single quotes will be read as a variable.
+
+Any variable containing double quotes will be considered a multi-line variable, and can thus either be finished in the same line - or another line.
+
 <br>
 
 ### Fluent API

src/dotenv.net/Parser.cs

@@ -1,71 +1,89 @@
 using System;
 using System.Collections.Generic;
+using System.Text;
 
 namespace dotenv.net;
 
 internal static class Parser
 {
-    private static readonly char[] SingleQuote = { '\'' };
-    private static readonly char[] DoubleQuotes = { '"' };
+    private const string SingleQuote = "'";
+    private const string DoubleQuotes = "\"";
 
-    internal static ReadOnlySpan<KeyValuePair<string, string>> Parse(ReadOnlySpan<string> dotEnvRows,
-        bool shouldTrimValue)
+    internal static ReadOnlySpan<KeyValuePair<string, string>> Parse(ReadOnlySpan<string> rawEnvRows,
+        bool trimValues)
     {
-        var validEntries = new List<KeyValuePair<string, string>>();
+        var keyValuePairs = new List<KeyValuePair<string, string>>();
 
-        foreach (var dotEnvRow in dotEnvRows)
+        for (var i = 0; i < rawEnvRows.Length; i++)
         {
-            var row = new ReadOnlySpan<char>(dotEnvRow.TrimStart().ToCharArray());
-
-            if (row.IsEmpty)
-                continue;
-
-            if (row.IsComment())
-                continue;
-
-            if (row.HasNoKey(out var index))
-                continue;
-
-            var key = row.Key(index);
-            var value = row.Value(index, shouldTrimValue);
-            validEntries.Add(new KeyValuePair<string, string>(key, value));
+            var rawEnvRow = rawEnvRows[i];
+
+            if(rawEnvRow.StartsWith("#")) continue;
+
+            if (rawEnvRow.Contains("=\""))
+            {
+                var key = rawEnvRow.Substring(0, rawEnvRow.IndexOf("=\"", StringComparison.Ordinal));
+                var valueStringBuilder = new StringBuilder();
+                valueStringBuilder.Append(rawEnvRow.Substring(rawEnvRow.IndexOf("=\"", StringComparison.Ordinal) + 2));
+
+                while (!rawEnvRow.EndsWith("\""))
+                {
+                    i++;
+                    if (i >= rawEnvRows.Length)
+                    {
+                        break;
+                    }
+                    rawEnvRow = rawEnvRows[i];
+                    valueStringBuilder.AppendLine();
+                    valueStringBuilder.Append(rawEnvRow);
+                }
+                //Remove last "
+                valueStringBuilder.Remove(valueStringBuilder.Length - 1, 1);
+
+                var value = valueStringBuilder.ToString();
+                if (trimValues)
+                {
+                    value = value.Trim();
+                }
+
+                keyValuePairs.Add(new KeyValuePair<string, string>(key, value));
+            }
+            else
+            {
+                //Check that line is not empty
+                var rawEnvEmpty = rawEnvRow.Trim();
+                if(string.IsNullOrEmpty(rawEnvEmpty)) continue;
+
+                // Regular key-value pair
+                var keyValue = rawEnvRow.Split(['='], 2);
+
+                var key = keyValue[0].Trim();
+                var value = keyValue[1];
+
+                if(string.IsNullOrEmpty(key)) continue;
+
+                if (IsQuoted(value))
+                {
+                    value = StripQuotes(value);
+                }
+
+                if (trimValues)
+                {
+                    value = value.Trim();
+                }
+
+                keyValuePairs.Add(new KeyValuePair<string, string>(key, value));
+            }
         }
 
-        return new ReadOnlySpan<KeyValuePair<string, string>>(validEntries.ToArray());
+        return keyValuePairs.ToArray();
     }
 
-    private static bool IsComment(this ReadOnlySpan<char> row) => row[0] == '#';
+    private static bool IsQuoted(string value) => (value.StartsWith(SingleQuote) && value.EndsWith(SingleQuote))
+                                                                 || (value.StartsWith(DoubleQuotes) && value.EndsWith(DoubleQuotes));
 
-    private static bool HasNoKey(this ReadOnlySpan<char> row, out int index)
+    private static string StripQuotes(string value)
     {
-        index = row.IndexOf('=');
-        return index <= 0;
-    }
-
-    private static bool IsQuoted(this ReadOnlySpan<char> row) =>
-        (row.StartsWith(SingleQuote) && row.EndsWith(SingleQuote))
-        || (row.StartsWith(DoubleQuotes) && row.EndsWith(DoubleQuotes));
-
-    private static ReadOnlySpan<char> StripQuotes(this ReadOnlySpan<char> row) => row.Trim('\'').Trim('\"');
-
-    private static string Key(this ReadOnlySpan<char> row, int index)
-    {
-        var untrimmedKey = row.Slice(0, index);
-        return untrimmedKey.Trim().ToString();
-    }
-
-    private static string Value(this ReadOnlySpan<char> row, int index, bool trimValue)
-    {
-        var value = row.Slice(index + 1);
-
-        // handle quoted values
-        if (value.IsQuoted()) 
-            value = value.StripQuotes();
-
-        // trim output if requested
-        if (trimValue) 
-            value = value.Trim();
-
-        return value.ToString();
+        return value.Substring(1, value.Length - 2);
     }
 }

tests/dotenv.net.Tests/DotEnv.Fluent.Tests.cs

@@ -12,6 +12,7 @@ public class DotEnvFluentTests
     private const string WhitespacesEnvFileName = "whitespaces.env";
     private const string NonExistentEnvFileName = "non-existent.env";
     private const string QuotationsEnvFileName = "quotations.env";
+    private const string MultiLinesEnvFileName = "multi-lines.env";
     private const string AsciiEnvFileName = "ascii.env";
     private const string GenericEnvFileName = "generic.env";
     private const string IncompleteEnvFileName = "incomplete.env";
@@ -127,6 +128,25 @@ public void ConfigShouldLoadEnvWithQuotedValues()
             .Be("single");
     }
 
+    [Fact]
+    public void ConfigLoadsMultilineEnvs()
+    {
+        DotEnv.Fluent()
+            .WithEnvFiles(MultiLinesEnvFileName)
+            .WithTrimValues()
+            .Load();
+
+        EnvReader.GetStringValue("DOUBLE_QUOTE")
+            .Should()
+            .Be("double");
+        EnvReader.GetStringValue("DOUBLE_QUOTE_MULTI_LINE")
+            .Should()
+            .Be($"dou{Environment.NewLine}bler");
+        EnvReader.GetStringValue("DOUBLE_QUOTE_EVEN_MORE_LINES")
+            .Should()
+            .Be($"dou{Environment.NewLine}{Environment.NewLine}b{Environment.NewLine}{Environment.NewLine}lest");
+    }
+
     [Fact]
     public void ConfigShouldLoadEnvWithInvalidEnvEntries()
     {
@@ -139,4 +159,4 @@ public void ConfigShouldLoadEnvWithInvalidEnvEntries()
             .Should()
             .BeFalse();
     }
-}
+}

tests/dotenv.net.Tests/dotenv.net.Tests.csproj

@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net5.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
     <IsPackable>false</IsPackable>
     <PackageVersion></PackageVersion>
     <AssemblyVersion>3.1.0</AssemblyVersion>
@@ -9,7 +9,11 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="coverlet.msbuild" Version="3.0.3">
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.msbuild" Version="6.0.2">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
       <PrivateAssets>all</PrivateAssets>
     </PackageReference>
@@ -40,6 +44,9 @@
     <None Update="incomplete.env">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="multi-lines.env">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\src\dotenv.net\dotenv.net.csproj" />

tests/dotenv.net.Tests/multi-lines.env

@@ -0,0 +1,8 @@
+DOUBLE_QUOTE="double"
+DOUBLE_QUOTE_MULTI_LINE="dou
+bler"
+DOUBLE_QUOTE_EVEN_MORE_LINES="dou
+
+b
+
+lest"