Merge pull request #10 from castle-it/release-1.2

Release 1.2

Author: tghamm

Castle.Sharp2Js.Nuget/Package.nuspec

@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>sharp2Js</id>
-    <version>1.1.1</version>
+    <version>1.2.0</version>
     <title>sharp2Js</title>
     <authors>Grant Hamm, Jared Kremer</authors>
     <owners>Castle Worldwide, Inc</owners>

Castle.Sharp2Js.Nuget/lib/Castle.Sharp2Js.xml

@@ -1,29 +1,54 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.Serialization;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace Castle.Sharp2Js.Tests.DTOs
 {
+    [ExcludeFromCodeCoverage]
     public class RecursiveTest
     {
         public string Name { get; set; }
         public List<RecursiveTest> RecursiveTests { get; set; }
     }
-
+    [ExcludeFromCodeCoverage]
     public class ArrayTypeTest
     {
         public string[] Strings { get; set; }
     }
-
+    [ExcludeFromCodeCoverage]
     public class AttributeInformationTest
     {
         [DataMember(Name = "TestName")]
         public string TypeName { get; set; }
         [IgnoreDataMember]
         public bool IgnoreMe { get; set; }
+        [DefaultValue(23.19)]
+        public double NumberValue1 { get; set; }
+
+        [DefaultValue("HelloWorld")]
+        public string StringValue1 { get; set; }
+
+        [DataMember(Name = " ")]
+        public string InvalidName1 { get; set; }
+
+        public List<StructTest> StructTests { get; set; }
+    }
+    [ExcludeFromCodeCoverage]
+    public struct StructTest
+    {
+        public int SructValue { get; set; }
+    }
+    [ExcludeFromCodeCoverage]
+    public class CamelCaseTest
+    {
+        public string WKTPolygon { get; set; }
+        public string alreadyUnderscored { get; set; }
+        public string RegularCased { get; set; }
     }
 
 }

Castle.Sharp2Js.Tests/DTOs/SampleModel.cs

@@ -1,11 +1,15 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
 using Castle.Sharp2Js.SampleData;
 using Castle.Sharp2Js.Tests.DTOs;
+using Jint.Parser.Ast;
 using NUnit.Framework;
 
 namespace Castle.Sharp2Js.Tests
 {
+    [ExcludeFromCodeCoverage]
     [TestFixture]
     public class JsGeneratorTests
     {
@@ -182,6 +186,168 @@ public void DataMemberAttributeHandling()
 
         }
 
+        [Test]
+        public void DefaultValueHandling()
+        {
+            //Generate a basic javascript model from a C# class
+
+            var modelType = typeof(AttributeInformationTest);
+
+            var outputJs = JsGenerator.Generate(new[] { modelType }, new JsGeneratorOptions()
+            {
+                ClassNameConstantsToRemove = new List<string>() { "Dto" },
+                CamelCase = true,
+                IncludeMergeFunction = false,
+                OutputNamespace = "models",
+                RespectDataMemberAttribute = true,
+                RespectDefaultValueAttribute = true
+            });
+
+            Assert.IsTrue(!string.IsNullOrEmpty(outputJs));
+
+            var js = new Jint.Parser.JavaScriptParser();
+
+            try
+            {
+                js.Parse(outputJs);
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail("Expected no exception parsing javascript, but got: " + ex.Message);
+            }
+
+
+        }
+
+        [Test]
+        public void UnexpectedStateHandling()
+        {
+            //Generate a basic javascript model from a C# class
+
+            var modelType = typeof(AttributeInformationTest);
+
+            var outputJs = JsGenerator.Generate(new[] { modelType }, new JsGeneratorOptions()
+            {
+                ClassNameConstantsToRemove = null,
+                CamelCase = true,
+                IncludeMergeFunction = false,
+                OutputNamespace = "models",
+                RespectDataMemberAttribute = false,
+                RespectDefaultValueAttribute = false
+            });
+
+            Assert.IsTrue(!string.IsNullOrEmpty(outputJs));
+
+            var js = new Jint.Parser.JavaScriptParser();
+
+            try
+            {
+                js.Parse(outputJs);
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail("Expected no exception parsing javascript, but got: " + ex.Message);
+            }
+
+
+        }
+
+        [Test]
+        public void FatalStateHandling()
+        {
+            //Generate a basic javascript model from a C# class
+
+            var modelType = typeof(AttributeInformationTest);
+            var tempOptions = JsGenerator.Options;
+            JsGenerator.Options = null;
+
+            Assert.Catch<ArgumentNullException>((() =>
+            {
+                var outputJs = JsGenerator.Generate(new[] { modelType });
+            }), "Expected engine to throw ArguementNullException when Options are null");
+
+            JsGenerator.Options = tempOptions;
+
+        }
+
+
+        [Test]
+        public void CamelCaseHandling()
+        {
+            //Generate a basic javascript model from a C# class
+
+            var modelType = typeof(CamelCaseTest);
+
+            var outputJs = JsGenerator.Generate(new[] { modelType }, new JsGeneratorOptions()
+            {
+                ClassNameConstantsToRemove = new List<string>() { "Dto" },
+                CamelCase = true,
+                IncludeMergeFunction = false,
+                OutputNamespace = "models",
+                RespectDataMemberAttribute = true,
+                RespectDefaultValueAttribute = true
+            });
+
+            Assert.IsTrue(!string.IsNullOrEmpty(outputJs));
+
+            var js = new Jint.Parser.JavaScriptParser();
+
+            Program res = null;
+
+            try
+            {
+                res = js.Parse(outputJs);
+
+            }
+            catch (Exception ex)
+            {
+                Assert.Fail("Expected no exception parsing javascript, but got: " + ex.Message);
+            }
+
+
+            var classExpression = res.Body.First().As<ExpressionStatement>();
+
+            var functionDefinition =
+                classExpression.Expression.As<AssignmentExpression>().Right.As<FunctionExpression>()
+                    .Body.As<BlockStatement>()
+                    .Body;
+
+            var firstMemberDefinition =
+                functionDefinition.Skip(1)
+                    .Take(1)
+                    .First()
+                    .As<ExpressionStatement>()
+                    .Expression.As<AssignmentExpression>();
+
+            var memberName = firstMemberDefinition.Left.As<MemberExpression>().Property.As<Identifier>().Name;
+
+            Assert.IsTrue(memberName == "wktPolygon");
+
+            var secondMemberDefinition =
+                functionDefinition.Skip(2)
+                    .Take(1)
+                    .First()
+                    .As<ExpressionStatement>()
+                    .Expression.As<AssignmentExpression>();
+
+            var secondMemberName = secondMemberDefinition.Left.As<MemberExpression>().Property.As<Identifier>().Name;
+
+            Assert.IsTrue(secondMemberName == "alreadyUnderscored");
+
+            var thirdMemberDefinition =
+                functionDefinition.Skip(3)
+                    .Take(1)
+                    .First()
+                    .As<ExpressionStatement>()
+                    .Expression.As<AssignmentExpression>();
+
+            var thirdMemberName = thirdMemberDefinition.Left.As<MemberExpression>().Property.As<Identifier>().Name;
+
+            Assert.IsTrue(thirdMemberName == "regularCased");
+
+
+        }
+
     }
 
 

Castle.Sharp2Js.Tests/JsGeneratorTests.cs

@@ -8,10 +8,13 @@ models.AddressInformation = function (cons, overrideObj) {
 	this.Name = cons.Name;
 	this.Address = cons.Address;
 	this.ZipCode = cons.ZipCode;
-	if (!overrideObj.OwnerInformation) {
-		this.Owner = new models.OwnerInformation(cons.Owner);
-	} else {
-		this.Owner = new overrideObj.OwnerInformation(cons.Owner, overrideObj);
+	this.Owner = null;
+	if (cons.Owner) {
+		if (!overrideObj.OwnerInformation) {
+			this.Owner = new models.OwnerInformation(cons.Owner);
+		} else {
+			this.Owner = new overrideObj.OwnerInformation(cons.Owner, overrideObj);
+		}
 	}
 	this.Features = new Array(cons.Features == null ? 0 : cons.Features.length );
 	if(cons.Features != null) {