feat(api): Add support for generics

Add support for generics - thanks to @lavinski

Author: gkinsman

src/Typescript.Tests/Generics/GenericsGeneratorTests.Generator_TypeWithGenericArguments_GeneratesSuccessfully.approved.txt

@@ -0,0 +1,6 @@
+declare namespace Api {
+  interface TypeWithGenericArguments extends BaseType<Alpha, Beta> {
+  }
+  interface BaseType<T1, T2> {
+  }
+}

src/Typescript.Tests/Generics/GenericsGeneratorTests.Generator_TypeWithOpenGenericArguments_GeneratesSuccessfully.approved.txt

@@ -0,0 +1,4 @@
+declare namespace Api {
+  interface TypeWithOpenGenericArguments<T> {
+  }
+}

src/Typescript.Tests/Generics/GenericsGeneratorTests.cs

@@ -0,0 +1,50 @@
+using System;
+using Assent;
+using Typescriptr;
+using Typescriptr.Formatters;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Typescript.Tests.Generics
+{
+    public class GenericsGeneratorTests
+    {
+        class Alpha { }
+        class Beta { }
+
+        class BaseType<T1, T2>
+        {
+        }
+
+        class TypeWithGenericArguments : BaseType<Alpha, Beta>
+        {
+        }
+
+        [Fact]
+        public void Generator_TypeWithGenericArguments_GeneratesSuccessfully()
+        {
+            var generator = TypeScriptGenerator.CreateDefault();
+            var generated = generator.Generate(new[] {typeof(TypeWithGenericArguments) });
+
+            var result = generated.Types;
+
+            this.Assent(result);
+        }
+
+        class TypeWithOpenGenericArguments<T>
+        {
+        }
+
+        [Fact]
+        public void Generator_TypeWithOpenGenericArguments_GeneratesSuccessfully()
+        {
+            var generator = TypeScriptGenerator.CreateDefault();
+            var generated = generator.Generate(new[] { typeof(TypeWithOpenGenericArguments<>) });
+
+            var result = generated.Types;
+
+            this.Assent(result);
+        }
+
+    }
+}

src/Typescript.Tests/Inheritence/InheritenceGeneratorTests.Generator_TypeWithBaseClass_GeneratesSuccessfully.approved.txt

@@ -0,0 +1,7 @@
+declare namespace Api {
+  interface TypeWithBaseClass extends BaseClass {
+  }
+  interface BaseClass {
+    property: string;
+  }
+}

src/Typescript.Tests/Inheritence/InheritenceGeneratorTests.cs

@@ -0,0 +1,31 @@
+using System;
+using Assent;
+using Typescriptr;
+using Typescriptr.Formatters;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Typescript.Tests.Inheritence
+{
+    public class InheritenceGeneratorTests
+    {
+        class BaseClass
+        {
+            public string Property { get; set; }
+        }
+
+        class TypeWithBaseClass : BaseClass
+        {
+            
+        }
+
+        [Fact]
+        public void Generator_TypeWithBaseClass_GeneratesSuccessfully()
+        {
+            var generator = TypeScriptGenerator.CreateDefault();
+            var generated = generator.Generate(new[] {typeof(TypeWithBaseClass) });
+
+            this.Assent(generated.Types);
+        }
+    }
+}

src/Typescriptr/TypeScriptGenerator.cs

@@ -172,7 +172,24 @@ private void RenderType(StringBuilder builder, Type type)
                 : MemberTypes.Property | MemberTypes.Field;
 
             var members = type.GetMembers().Where(m => memberTypesToInclude.HasFlag(m.MemberType));
-            builder.AppendLine($"interface {type.Name} {{");
+
+            bool ShouldExport(Type t)
+            {
+                return t != typeof(Object)
+                    && t != typeof(ValueType)
+                    && t != null;
+            }
+            var baseType = type.BaseType;
+            var hasBaseType = ShouldExport(baseType);
+
+            builder.Append($"interface ");
+            RenderTypeName(builder, type);
+            if (hasBaseType) {
+                builder.Append($" extends ");
+                RenderTypeName(builder, baseType);
+            }
+
+            builder.AppendLine(" {");
 
             foreach (var memberInfo in members)
             {
@@ -187,16 +204,39 @@ private void RenderType(StringBuilder builder, Type type)
                 if (_useCamelCasePropertyNames)
                     memberName = memberName.ToCamelCase();
 
-                RenderProperty(builder, memberType, memberName);
+                if (memberInfo.DeclaringType == type) {
+                    RenderProperty(builder, memberType, memberName);
+                }
             }
 
             builder.AppendLine("}");
             _typesGenerated.Add(type);
 
-            var baseType = type.BaseType;
-            if (baseType != typeof(Object) && baseType != typeof(ValueType) && baseType != null)
-                if (!_typesGenerated.Contains(baseType))
-                    _typeStack.Push(baseType);
+            if (hasBaseType) {
+                var addedType = baseType.IsGenericType ? baseType.GetGenericTypeDefinition() : baseType;
+                if (!_typesGenerated.Contains(addedType))
+                    _typeStack.Push(addedType);
+            }
+        }
+
+        private void RenderTypeName(StringBuilder builder, Type type)
+        {
+            var friendlyName = type.Name;
+            if (type.IsGenericType) {
+                var backtickIndex = friendlyName.IndexOf('`');
+                if (backtickIndex > 0) {
+                    builder.Append(friendlyName.Remove(backtickIndex));
+                }
+                builder.Append("<");
+                var typeParameters = type.GetGenericArguments();
+                for (var i = 0; i < typeParameters.Length; ++i) {
+                    if (i > 0) { builder.Append(", "); }
+                    RenderTypeName(builder, typeParameters[i]);
+                }
+                builder.Append(">");
+            } else {
+                builder.Append(friendlyName);
+            }
         }
 
         private string TypeNameRenderer(Type type)