Merge pull request #18 from FrendsPlatform/ISSUE-16

ISSUE-16: Added option to ignore quotes in row data

Author: ttossavainen

Frends.Csv.Tests/Tests.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Data;
 using Newtonsoft.Json.Linq;
 using NUnit.Framework;
 
@@ -27,10 +26,10 @@ public void TestParseSkipRowsWithAutomaticHeaders()
             dynamic resultJArray = result.ToJson();
             var resultXml = result.ToXml();
             var resultData = result.Data;
-            Assert.That(resultData.Count, Is.EqualTo(2));
-            Assert.That(resultJArray.Count, Is.EqualTo(2));
-            Assert.That(resultXml, Does.Contain("<year>2000</year>"));
-            Assert.That(resultJArray[0].price.ToString(), Is.EqualTo("2,34"));
+            Assert.AreEqual(resultData.Count, 2);
+            Assert.AreEqual(resultJArray.Count, 2);
+            Assert.IsTrue(resultXml.Contains("<year>2000</year>"));
+            Assert.AreEqual(resultJArray[0].price.ToString(), "2,34");
         }
 
         [Test]
@@ -54,10 +53,10 @@ public void TestParseWithColumnSpecAndMissingHeader()
             var resultJArray = result.ToJson() as JArray;
             var resultXml = result.ToXml();
             var resultData = result.Data;
-            Assert.That(resultData.Count, Is.EqualTo(2));
-            Assert.That(resultJArray.Count, Is.EqualTo(2));
-            Assert.That(resultXml, Does.Contain("<Year>2000</Year>"));
-            Assert.That(resultJArray[0]["Price"].Value<decimal>(), Is.EqualTo(2.34));
+            Assert.AreEqual(resultData.Count, 2);
+            Assert.AreEqual(resultJArray.Count, 2);
+            Assert.IsTrue(resultXml.Contains("<Year>2000</Year>"));
+            Assert.AreEqual(resultJArray[0]["Price"].Value<decimal>(), 2.34);
         }
 
         [Test]
@@ -76,10 +75,10 @@ public void TestParseWithNoColumnSpecAndNoHeader()
             var resultJArray = result.ToJson() as JArray;
             var resultXml = result.ToXml();
             var resultData = result.Data;
-            Assert.That(resultData.Count, Is.EqualTo(2));
-            Assert.That(resultJArray.Count, Is.EqualTo(2));
-            Assert.That(resultXml, Does.Contain("<0>2000</0>"));
-            Assert.That(resultJArray[0]["3"].Value<string>(), Is.EqualTo("2,34"));
+            Assert.AreEqual(resultData.Count, 2);
+            Assert.AreEqual(resultJArray.Count, 2);
+            Assert.IsTrue(resultXml.Contains("<0>2000</0>"));
+            Assert.AreEqual(resultJArray[0]["3"].Value<string>(), "2,34");
         }
 
         [Test]
@@ -105,36 +104,36 @@ public void TestParseWillAllKindOfDataTypes()
                 },
                 Delimiter = ";",
                 Csv = csv
-            }, new ParseOption() { ContainsHeaderRow = true, CultureInfo = "fi-FI" });
-            var resultJson = (JArray)result.ToJson();
-            Assert.That(resultJson[0]["Long"].Value<long>(), Is.EqualTo(4294967296));
+            }, new ParseOption() { ContainsHeaderRow = true, CultureInfo = "fi-FI", IgnoreReferences = true });
+            var resultJson = (JArray) result.ToJson();
+            Assert.AreEqual(resultJson[0]["Long"].Value<long>(), 4294967296);
             var resultXml = result.ToXml();
-            Assert.That(resultXml, Does.Contain("<DateTime2>1.5.2008 10.34.42</DateTime2>"));
+            Assert.IsTrue(resultXml.Contains("<DateTime2>1.5.2008 10.34.42</DateTime2>"));
             var resultData = result.Data;
             var itemArray = resultData[0];
-            Assert.That(itemArray[0].GetType(), Is.EqualTo(typeof(int)));
-            Assert.That(itemArray[0], Is.EqualTo(1997));
+            Assert.AreEqual(itemArray[0].GetType(), typeof(int));
+            Assert.AreEqual(itemArray[0], 1997);
 
-            Assert.That(itemArray[1].GetType(), Is.EqualTo(typeof(string)));
-            Assert.That(itemArray[1], Is.EqualTo("Fo;rd"));
+            Assert.AreEqual(itemArray[1].GetType(), typeof(string));
+            Assert.AreEqual(itemArray[1], "Fo;rd");
 
-            Assert.That(itemArray[2].GetType(), Is.EqualTo(typeof(decimal)));
-            Assert.That(itemArray[2], Is.EqualTo(2.34d));
+            Assert.AreEqual(itemArray[2].GetType(), typeof(decimal));
+            Assert.AreEqual(itemArray[2], 2.34d);
 
-            Assert.That(itemArray[3].GetType(), Is.EqualTo(typeof(bool)));
-            Assert.That(itemArray[3], Is.EqualTo(true));
+            Assert.AreEqual(itemArray[3].GetType(), typeof(bool));
+            Assert.AreEqual(itemArray[3], true);
 
-            Assert.That(itemArray[4].GetType(), Is.EqualTo(typeof(bool)));
-            Assert.That(itemArray[4], Is.EqualTo(true));
+            Assert.AreEqual(itemArray[4].GetType(), typeof(bool));
+            Assert.AreEqual(itemArray[4], true);
 
-            Assert.That(itemArray[5].GetType(), Is.EqualTo(typeof(long)));
-            Assert.That(itemArray[5], Is.EqualTo(4294967296));
+            Assert.AreEqual(itemArray[5].GetType(), typeof(long));
+            Assert.AreEqual(itemArray[5], 4294967296);
 
-            Assert.That(itemArray[6].GetType(), Is.EqualTo(typeof(char)));
-            Assert.That(itemArray[6], Is.EqualTo('f'));
+            Assert.AreEqual(itemArray[6].GetType(), typeof(char));
+            Assert.AreEqual(itemArray[6], 'f');
 
-            Assert.That(itemArray[7].GetType(), Is.EqualTo(typeof(DateTime)));
-            Assert.That(itemArray[7], Is.EqualTo(new DateTime(2008, 9, 15)));
+            Assert.AreEqual(itemArray[7].GetType(), typeof(DateTime));
+            Assert.AreEqual(itemArray[7], new DateTime(2008, 9, 15));
 
             Assert.That(itemArray[8].GetType(), Is.EqualTo(typeof(DateTime)));
             Assert.That(itemArray[8], Is.EqualTo(new DateTime(2008, 5, 1, 10, 34, 42)));
@@ -156,15 +155,15 @@ public void TestParseTreatMissingFieldsAsNullSetToTrue()
                 Csv = csv
             }, new ParseOption() { ContainsHeaderRow = true, CultureInfo = "fi-FI", TreatMissingFieldsAsNulls = true });
             var resultJson = (JArray)result.ToJson();
-            Assert.That(resultJson[2].Value<string>("header3"), Is.EqualTo(null));
+            Assert.AreEqual(resultJson[2].Value<string>("header3"), null);
 
             var resultXml = result.ToXml();
-            Assert.That(resultXml, Does.Contain("<header3 />"));
+            Assert.IsTrue(resultXml.Contains("<header3 />"));
 
             var resultData = result.Data;
             var nullItem = resultData[2][2];
 
-            Assert.That(nullItem, Is.EqualTo(null));
+            Assert.AreEqual(nullItem, null);
         }
 
         [Test]
@@ -193,7 +192,7 @@ public void TestParseTreatMissingFieldsAsNullDefaultValue()
         {
             var options = new ParseOption();
 
-            Assert.That(options.TreatMissingFieldsAsNulls, Is.EqualTo(false));
+            Assert.AreEqual(options.TreatMissingFieldsAsNulls, false);
         }
 
         [Test]
@@ -216,40 +215,39 @@ public void TestWriteFromListTable()
                 new List<object>() {100, "Dilantin", "Melanie", date}
             };
 
-            var result = Csv.Create(new CreateInput() { InputType = CreateInputType.List, Delimiter = ";", Data = data, Headers = headers }, new CreateOption() { CultureInfo = "fi-FI" });
-            Assert.That(result.Csv,
-Is.EqualTo(
+            var result = Csv.Create(new CreateInput() { InputType = CreateInputType.List, Delimiter = ";", Data = data, Headers = headers}, new CreateOption() { CultureInfo = "fi-FI" });
+            Assert.AreEqual(result.Csv,
 @"Dosage;Drug;Patient;Date
 25;Indocin;David;1.1.2000 0.00.00
 50;Enebrel;Sam;1.1.2000 0.00.00
 10;Hydralazine;Christoff;1.1.2000 0.00.00
 21;""Combiv;ent"";Janet;1.1.2000 0.00.00
 100;Dilantin;Melanie;1.1.2000 0.00.00
-"));
+");
         }
 
         [Test]
         public void TestWriteFromJson()
         {
             var json = @"[{""cool"":""nice"", ""what"": ""no""}, {""cool"":""not"", ""what"": ""yes""}, {""cool"":""maybe"", ""what"": ""never""}]";
-            var result = Csv.Create(new CreateInput() { InputType = CreateInputType.Json, Delimiter = ";", Json = json }, new CreateOption());
-            Assert.That(result.Csv,
-Is.EqualTo(@"cool;what
+            var result = Csv.Create(new CreateInput() { InputType = CreateInputType.Json, Delimiter = ";", Json = json}, new CreateOption());
+            Assert.AreEqual(result.Csv,
+@"cool;what
 nice;no
 not;yes
 maybe;never
-"));
+");
         }
 
         [Test]
         public void TestNullInputValue()
         {
             var json = @"[{""ShouldStayNull"":""null"", ""ShouldBeReplaced"": null}]";
             var result = Csv.Create(new CreateInput() { InputType = CreateInputType.Json, Delimiter = ";", Json = json }, new CreateOption() { ReplaceNullsWith = "replacedvalue" });
-            Assert.That(result.Csv,
-Is.EqualTo(@"ShouldStayNull;ShouldBeReplaced
+            Assert.AreEqual(result.Csv,
+@"ShouldStayNull;ShouldBeReplaced
 null;replacedvalue
-"));
+");
         }
 
         [Test]
@@ -260,16 +258,23 @@ public void TestNoQuotesOption()
 ""bar"" : ""I would not""
 }]";
             var result2 = Csv.Create(new CreateInput() { InputType = CreateInputType.Json, Delimiter = ";", Json = json }, new CreateOption() { NeverAddQuotesAroundValues = false });
-            Assert.That(result2.Csv,
-                Is.EqualTo(@"foo;bar
+            Assert.AreEqual(result2.Csv,
+                @"foo;bar
 "" Normally I would have quotes "";I would not
-"));
+");
 
             var result1 = Csv.Create(new CreateInput() { InputType = CreateInputType.Json, Delimiter = ";", Json = json }, new CreateOption() { NeverAddQuotesAroundValues = true });
-            Assert.That(result1.Csv,
-                Is.EqualTo(@"foo;bar
+            Assert.AreEqual(result1.Csv,
+                @"foo;bar
  Normally I would have quotes ;I would not
-"));
+");
+
+
+      
+
+
+
+
         }
 
         [Test]
@@ -280,10 +285,10 @@ public void TestDatetimeValue()
 ""string"" : ""foo""
 }]";
             var result = Csv.Create(new CreateInput() { InputType = CreateInputType.Json, Delimiter = ";", Json = json }, new CreateOption() { });
-            Assert.That(result.Csv,
- Is.EqualTo(@"datetime;string
+            Assert.AreEqual(result.Csv,
+@"datetime;string
 2018-11-22T10:30:55;foo
-"));
+");
         }
 
         [Test]
@@ -295,10 +300,10 @@ public void TestDecimalValues()
 ""baz"" : 0.000000000000000000000000000000000000000000000000000000001
 }]";
             var result = Csv.Create(new CreateInput() { InputType = CreateInputType.Json, Delimiter = ";", Json = json }, new CreateOption() { });
-            Assert.That(result.Csv,
- Is.EqualTo(@"foo;bar;baz
+            Assert.AreEqual(result.Csv,
+ @"foo;bar;baz
 0.1;1.00;0.000000000000000000000000000000000000000000000000000000001
-"));
+");
         }
 
         [Test]
@@ -323,10 +328,10 @@ public void ParseAndWriteShouldUseSeparateCultures()
 
             var result = Csv.Create(new CreateInput() { InputType = CreateInputType.List, Delimiter = ";", Data = parseResult.Data, Headers = parseResult.Headers }, new CreateOption() { CultureInfo = "fi-FI" });
 
-            Assert.That(result.Csv, Is.EqualTo(
+            Assert.AreEqual(result.Csv, 
                 @"First;Second;Number;Date
 Foo;"" bar"";100;1.1.2000 0.00.00
-"));
+");
         }
 
         [Test]
@@ -346,10 +351,10 @@ public void TestParseRowsWithAutomaticHeadersWhiteSpaceRemovalDefault()
             dynamic resultJArray = result.ToJson();
             var resultXml = result.ToXml();
             var resultData = result.Data;
-            Assert.That(resultData.Count, Is.EqualTo(2));
-            Assert.That(resultJArray.Count, Is.EqualTo(2));
-            Assert.That(resultXml, Does.Contain("<year of the z>"));
-            Assert.That(resultJArray[0].price.ToString(), Is.EqualTo("2,34"));
+            Assert.AreEqual(resultData.Count, 2);
+            Assert.AreEqual(resultJArray.Count, 2);
+            Assert.IsTrue(resultXml.Contains("<year of the z>"));
+            Assert.AreEqual(resultJArray[0].price.ToString(), "2,34");
         }
 
         [Test]
@@ -369,10 +374,31 @@ public void TestParseRowsWithAutomaticHeadersWhiteSpaceRemovalGiven()
             dynamic resultJArray = result.ToJson();
             var resultXml = result.ToXml();
             var resultData = result.Data;
-            Assert.That(resultData.Count, Is.EqualTo(2));
-            Assert.That(resultJArray.Count, Is.EqualTo(2));
-            Assert.That(resultXml, Does.Contain("<year_of_the_z>"));
-            Assert.That(resultJArray[0].price.ToString(), Is.EqualTo("2,34"));
+            Assert.AreEqual(resultData.Count, 2);
+            Assert.AreEqual(resultJArray.Count, 2);
+            Assert.IsTrue(resultXml.Contains("<year_of_the_z>"));
+            Assert.AreEqual(resultJArray[0].price.ToString(), "2,34");
         }
+
+        [Test]
+        public void TestParseIgnoresQuotesInRowData()
+        {
+            var csv = "asdasd\nCoolio\nyear;car\";mark;price\n1997;Ford;E350;2,34\n2000;Mercury;Cougar;2,38";
+            var result = Csv.Parse(new ParseInput()
+            {
+                ColumnSpecifications = new ColumnSpecification[0],
+                Delimiter = ";",
+                Csv = csv
+            }, new ParseOption() { ContainsHeaderRow = true, SkipRowsFromTop = 2, SkipEmptyRows = false, IgnoreQuotes = true });
+
+            dynamic resultJArray = result.ToJson();
+            var resultXml = result.ToXml();
+            var resultData = result.Data;
+            Assert.AreEqual(resultData.Count, 2);
+            Assert.AreEqual(resultJArray.Count, 2);
+            Assert.IsTrue(resultXml.Contains("<year>2000</year>"));
+            Assert.AreEqual(resultJArray[0].price.ToString(), "2,34");
+        }
+
     }
 }

Frends.Csv/Csv.cs

@@ -20,13 +20,31 @@ public class Csv
         /// <returns>Object { List&lt;List&lt;object&gt;&gt; Data, List&lt;string&gt; Headers, JToken ToJson(), string ToXml() } </returns>
         public static ParseResult Parse([PropertyTab] ParseInput input, [PropertyTab] ParseOption option)
         {
-            var configuration = new CsvConfiguration(new CultureInfo(option.CultureInfo))
+            CsvConfiguration configuration;
+
+            if (!option.IgnoreReferences && option.IgnoreQuotes)
             {
-                HasHeaderRecord = option.ContainsHeaderRow,
-                Delimiter = input.Delimiter,
-                TrimOptions = option.TrimOutput ? TrimOptions.None : TrimOptions.Trim,
-                IgnoreBlankLines = option.SkipEmptyRows
-            };
+                configuration = new CsvConfiguration(new CultureInfo(option.CultureInfo))
+                {
+                    HasHeaderRecord = option.ContainsHeaderRow,
+                    Delimiter = input.Delimiter,
+                    TrimOptions = option.TrimOutput ? TrimOptions.None : TrimOptions.Trim,
+                    IgnoreBlankLines = option.SkipEmptyRows,
+                    IgnoreReferences = option.IgnoreReferences,
+                    Mode = !option.IgnoreReferences && option.IgnoreQuotes ? CsvMode.NoEscape : CsvMode.Escape,
+                };
+            }
+            else
+            {
+                configuration = new CsvConfiguration(new CultureInfo(option.CultureInfo))
+                {
+                    HasHeaderRecord = option.ContainsHeaderRow,
+                    Delimiter = input.Delimiter,
+                    TrimOptions = option.TrimOutput ? TrimOptions.None : TrimOptions.Trim,
+                    IgnoreBlankLines = option.SkipEmptyRows,
+                    IgnoreReferences = option.IgnoreReferences
+                };
+            }
 
             // Setting the MissingFieldFound -delegate property of configuration to null when
             // option.TreatMissingFieldsAsNulls is set to true for returning null values for missing fields.

Frends.Csv/Definitions.cs

@@ -6,7 +6,6 @@
 using System.IO;
 using System.Text;
 using System.Xml;
-using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using Formatting = Newtonsoft.Json.Formatting;
 
@@ -164,6 +163,18 @@ public class ParseOption
         /// </summary>
         [DefaultValue("false")]
         public bool TreatMissingFieldsAsNulls { get; set; } = false;
+        /// <summary>
+        /// A flag to let the reader know if reference should be ignored.
+        /// </summary>
+        [DefaultValue("false")]
+        public bool IgnoreReferences { get; set; } = false;
+
+        /// <summary>
+        /// A flag to let the reader know if quotes should be ignored.
+        /// </summary>
+        [DefaultValue("false")]
+        public bool IgnoreQuotes { get; set; } = false;
+
     }
 
     public class ParseResult

Frends.Csv/Frends.Csv.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;net461</TargetFrameworks>
-    <Version>1.0.0</Version>
+    <Version>1.0.1</Version>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <Company>HiQ Finland</Company>
     <Authors>HiQ Finland</Authors>
@@ -15,7 +15,7 @@
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="CsvHelper" Version="30.0.1" />
-    <PackageReference Include="Newtonsoft.Json" Version="12.0.1" />
-    <PackageReference Include="System.ComponentModel.Annotations" Version="4.7.0" />
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
   </ItemGroup>
 </Project>