mdoc: Support for Javascript signatures

Added Javascript usage formatter
Added unit tests
Added `check-monodocer-javascript` integration test
`MemberSignature` and `TypsSignature` can contain just `Usage` attribute now, fixed XSD schema

13 files changed, 518 insertions, 2 deletions

diff --git a/mdoc/mdoc.Test/BasicFormatterTests.cs b/mdoc/mdoc.Test/BasicFormatterTests.cs
index 4bbefe15..3cb521e6 100644
--- a/mdoc/mdoc.Test/BasicFormatterTests.cs
+++ b/mdoc/mdoc.Test/BasicFormatterTests.cs
@@ -107,7 +107,7 @@ namespace mdoc.Test
         protected void TestPropertySignature(Type type, string expected, string memberName)
         {
             var signature = GetPropertySignature(type, memberName);
-            Assert.AreEqual(expected, signature);
+            Assert.AreEqual(FormatEndings(expected), signature);
         }
 
         private string GetPropertySignature(Type type, string memberName)
@@ -131,7 +131,7 @@ namespace mdoc.Test
         protected void TestFieldSignature(Type type, string expected, string memberName)
         {
             var usage = GetFieldUsage(type, memberName);
-            Assert.AreEqual(expected, usage);
+            Assert.AreEqual(FormatEndings(expected), usage);
         }
 
         private string GetFieldUsage(Type type, string memberName)
diff --git a/mdoc/mdoc.Test/JsMemberFormatterTests.cs b/mdoc/mdoc.Test/JsMemberFormatterTests.cs
new file mode 100644
index 00000000..a710457e
--- /dev/null
+++ b/mdoc/mdoc.Test/JsMemberFormatterTests.cs
@@ -0,0 +1,40 @@
+using mdoc.Mono.Documentation.Updater.Formatters;
+using mdoc.Test.SampleClasses;
+using NUnit.Framework;
+
+namespace mdoc.Test
+{
+    [TestFixture]
+    [Category("Javascript")]
+    [Category("Usage")]
+    class JsMemberFormatterTests : BasicFormatterTests<JsMemberFormatter>
+    {
+        protected override JsMemberFormatter formatter => new JsMemberFormatter();
+
+
+        #region Methods
+        [Test]
+        [Category("Methods")]
+        public void Test_AyncMethod()
+            => TestMethodSignature(typeof(SomeClass),
+                "function asyncMethod()",
+                nameof(SomeClass.AsyncMethod));
+        #endregion
+
+        #region Types
+        [Test]
+        [Category("Types")]
+        [Category("Constructors")]
+        public void Test_Constructor_0()
+            => TestTypeSignature(typeof(TestClass),
+                "function TestClass()");
+
+        [Test]
+        [Category("Types")]
+        [Category("Constructors")]
+        public void Test_Constructor_1()
+            => TestTypeSignature(typeof(SomeClass),
+                "function SomeClass(i, j)");
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/JsUsageFormatterTests.cs b/mdoc/mdoc.Test/JsUsageFormatterTests.cs
new file mode 100644
index 00000000..ac2cf6f1
--- /dev/null
+++ b/mdoc/mdoc.Test/JsUsageFormatterTests.cs
@@ -0,0 +1,286 @@
+using mdoc.Mono.Documentation.Updater.Formatters;
+using mdoc.Test.SampleClasses;
+using Mono.Documentation.Updater;
+using NUnit.Framework;
+
+namespace mdoc.Test
+{
+    [TestFixture]
+    [Category("Javascript")]
+    [Category("Usage")]
+    class JsUsageFormatterTests : BasicFormatterTests<JsUsageFormatter>
+    {
+        protected override JsUsageFormatter formatter => new JsUsageFormatter();
+
+        #region IsSupported
+        [Test]
+        public void Test_IsSupportedType_WebHostHidden()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetType(typeof(WebHostHiddenTestClass))));
+        }
+
+        [Test]
+        public void Test_IsSupportedMember_WebHostHidden()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(WebHostHiddenTestClass), 
+                i => i.Name == nameof(WebHostHiddenTestClass.SomeMethod))));
+        }
+
+        [Test]
+        public void Test_IsSupportedType_Generic()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetType(typeof(SomeGenericClass<>))));
+        }
+
+        [Test]
+        public void Test_IsSupportedMember_Generic()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(SomeGenericClass<>),
+                i => i.Name == "SomeMethod")));
+        }
+
+        [Test]
+        public void Test_IsSupportedMember_Generic2()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(SomeGenericClass<>),
+                i => i.Name == "SomeMethod2")));
+        }
+
+        [Test]
+        public void Test_IsSupportedMember_Generic3()
+        {
+            // WinRT doesn't support public types with generic parameters
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(SomeGenericClass<>),
+                i => i.Name == "SomeMethod3")));
+        }
+
+        [Test]
+        public void Test_IsSupported_MethodWithWebHostHiddenParameter()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(SomeClass),
+                i => i.Name == nameof(SomeClass.SomeMethodWebHostHiddenParameter))));
+        }
+
+        [Test]
+        public void Test_IsSupported_MethodWithWebHostHiddenReturn()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(SomeClass),
+                i => i.Name == nameof(SomeClass.SomeMethodWebHostHiddenReturn))));
+        }
+
+        [Test]
+        public void Test_IsSupportedMember_Operator()
+        {
+            // Operator overloads are not supported as they are not supported for Windows Runtime 
+            // (that is to say, they are not supported at the ABI level). 
+            // C# supports operator overloading, and C# implementations get compiled to metadata as static methods 
+            // on the type in question, such as TypeName::op_Equality, TypeName::op_GreaterThan, etc. 
+            // You can see a list on StackOverflow.  As long as they’re public, they can be invoked by name 
+            // just like any other static method.
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(TestClass),
+                i => i.Name == "op_UnaryPlus")));
+        }
+
+        [Test]
+        public void Test_IsSupportedMember_NotOperator()
+        {
+            Assert.IsFalse(formatter.IsSupported(GetMethod(typeof(SomeClass),
+                i => i.Name == nameof(SomeClass.op_NotOperator))));
+        }
+
+        #endregion
+
+        #region Fields
+        [Test]
+        [Category("Fields")]
+        public void Test_Field()
+            => TestFieldSignature(typeof(SomeStruct),
+                null, nameof(SomeStruct.IntMember));
+        #endregion
+
+        #region Properties
+        [Test]
+        [Category("Properties")]
+        public void Test_Property_0()
+            => TestPropertySignature(typeof(SomeClass),
+@"var int32 = someClass.property;
+someClass.property = int32;", 
+nameof(SomeClass.Property));
+
+        [Test]
+        [Category("Properties")]
+        public void Test_Property_1()
+            => TestPropertySignature(typeof(SomeClass),
+@"var testClass = someClass.property2;
+someClass.property2 = testClass;", 
+nameof(SomeClass.Property2));
+
+        [Test]
+        [Category("Properties")]
+        public void Test_Property_2()
+            => TestPropertySignature(typeof(SomeClass),
+                "var testClass = someClass.property3;",
+                nameof(SomeClass.Property3));
+
+        [Test]
+        [Category("Properties")]
+        public void Test_Property_3()
+            => TestPropertySignature(typeof(SomeClass),
+                "someClass.property4 = testClass;",
+                nameof(SomeClass.Property4));
+        
+        [Test]
+        [Category("Properties")]
+        public void Test_Static_Property_0()
+            => TestPropertySignature(typeof(SomeClass),
+@"var int32 = SomeClass.staticProperty;
+SomeClass.staticProperty = int32;",
+nameof(SomeClass.StaticProperty));
+        #endregion
+
+        #region Types
+        [Test]
+        [Category("Types")]
+        [Category("Enums")]
+        public void Test_Enum_0()
+            => TestTypeSignature(typeof(SomeEnum), "var value = mdoc.Test.SampleClasses.SomeEnum.testEnumElement1");
+
+        [Test]
+        [Category("Types")]
+        [Category("Enums")]
+        public void Test_Enum_1()
+            => TestTypeSignature(typeof(SomeEmptyEnum), null);
+
+        [Test]
+        [Category("Types")]
+        [Category("Struct")]
+        public void Test_Struct()
+            => TestTypeSignature(typeof(SomeStruct),
+@"var someStruct = {
+intMember : /* Your value */,
+staticMember : /* Your value */,
+testClassMember : /* Your value */
+}");
+
+        [Test]
+        [Category("Types")]
+        [Category("Deleagates")]
+        public void Test_Delegate()
+            => TestTypeSignature(typeof(SomeDelegate),
+@"var someDelegateHandler = function(str){
+/* Your code */
+}");
+
+        [Test]
+        [Category("Types")]
+        [Category("Class")]
+        public void Test_Class_0()
+            => TestTypeSignature(typeof(SomeClass),
+@"var someClass = new SomeClass(i, j);");
+
+        [Test]
+        [Category("Types")]
+        [Category("Class")]
+        public void Test_Class_1()
+            => TestTypeSignature(typeof(SomeClassWithManyConstructors), null);
+
+        #endregion
+
+        #region Methods
+        [Test]
+        [Category("Methods")]
+        public void Test_AyncMethod()
+            => TestMethodSignature(typeof(SomeClass),
+                "someClass.asyncMethod().done( /* Your success and error handlers */ )",
+                nameof(SomeClass.AsyncMethod));
+
+        [Test]
+        [Category("Methods")]
+        public void Test_StaticAyncMethod()
+            => TestMethodSignature(typeof(SomeClass),
+                "mdoc.Test.SampleClasses.SomeClass.staticAsyncMethod().done( /* Your success and error handlers */ )",
+                nameof(SomeClass.StaticAsyncMethod));
+
+        [Test]
+        [Category("Methods")]
+        public void Test_Method()
+            => TestMethodSignature(typeof(SomeClass),
+                "someClass.someMethod()",
+                nameof(SomeClass.SomeMethod));
+
+        [Test]
+        [Category("Methods")]
+        public void Test_StaticMethod()
+            => TestMethodSignature(typeof(SomeClass),
+                "mdoc.Test.SampleClasses.SomeClass.someStaticMethod()",
+                nameof(SomeClass.SomeStaticMethod));
+
+        [Test]
+        [Category("Methods")]
+        public void Test_MethodWithParameters()
+            => TestMethodSignature(typeof(SomeClass),
+                "someClass.someMethodWithParameters(someClass, i)",
+                nameof(SomeClass.SomeMethodWithParameters));
+
+        [Test]
+        [Category("Methods")]
+        public void Test_MethodWithReturn()
+            => TestMethodSignature(typeof(SomeClass),
+                "var int32 = someClass.someMethod2()",
+                nameof(SomeClass.SomeMethod2));
+
+        [Test]
+        [Category("Methods")]
+        public void Test_MethodWithReturnBool()
+            => TestMethodSignature(typeof(SomeClass),
+                "var boolean = someClass.someMethodWithReturnBool()",
+                nameof(SomeClass.SomeMethodWithReturnBool));
+
+        [Test]
+        [Category("Methods")]
+        public void Test_StaticMethodWithReturn()
+            => TestMethodSignature(typeof(SomeClass),
+                "var int32 = mdoc.Test.SampleClasses.SomeClass.someStaticMethod2()",
+                nameof(SomeClass.SomeStaticMethod2));
+
+        [Test]
+        [Category("Methods")]
+        [Category("Constructors")]
+        public void Test_Constructor()
+            => TestMethodSignature(typeof(TestClass),
+                "var testClass = new TestClass();",
+                ".ctor");
+        #endregion
+
+        #region Events
+        [Test]
+        [Category("Events")]
+        public void Test_Event()
+            => TestEventSignature(typeof(SomeClass),
+"function onAppMemoryUsageIncreased(eventArgs) { /* Your code */ }" + MemberFormatter.GetLineEnding() +
+"someClass.addEventListener(\"appmemoryusageincreased\", onAppMemoryUsageIncreased);" + MemberFormatter.GetLineEnding() +
+"someClass.removeEventListener(\"appmemoryusageincreased\", onAppMemoryUsageIncreased);" + MemberFormatter.GetLineEnding() +
+"- or -" + MemberFormatter.GetLineEnding() +
+"someClass.onappmemoryusageincreased = onAppMemoryUsageIncreased;",
+                nameof(SomeClass.AppMemoryUsageIncreased));
+
+        [Test]
+        [Category("Events")]
+        public void Test_StaticEvent()
+            => TestEventSignature(typeof(SomeClass),
+"function onStaticEvent(eventArgs) { /* Your code */ }" + MemberFormatter.GetLineEnding() +
+"mdoc.Test.SampleClasses.SomeClass.addEventListener(\"staticevent\", onStaticEvent);" + MemberFormatter.GetLineEnding() +
+"mdoc.Test.SampleClasses.SomeClass.removeEventListener(\"staticevent\", onStaticEvent);" + MemberFormatter.GetLineEnding() +
+"- or -" + MemberFormatter.GetLineEnding() +
+"mdoc.Test.SampleClasses.SomeClass.onstaticevent = onStaticEvent;",
+                nameof(SomeClass.StaticEvent));
+
+        [Test]
+        [Category("Events")]
+        public void Test_EventPrivate()
+            => TestEventSignature(typeof(SomeClass),
+                null,
+                "PrivateEvent");
+        #endregion
+    }
+}
diff --git a/mdoc/mdoc.Test/SampleClasses/SomeClass.cs b/mdoc/mdoc.Test/SampleClasses/SomeClass.cs
new file mode 100644
index 00000000..be72f7f3
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/SomeClass.cs
@@ -0,0 +1,96 @@
+using System;
+using Windows.Foundation.Metadata;
+
+namespace mdoc.Test.SampleClasses
+{
+    public class SomeClass
+    {
+        public SomeClass(int i)
+        {
+            
+        }
+
+        public SomeClass(int i, int j)
+        {
+            
+        }
+
+        public int Field;
+
+        public int Property { get; set; }
+
+        public static int StaticProperty { get; set; }
+
+        public TestClass Property2 { get; set; }
+        public static TestClass StaticProperty2 { get; set; }
+
+        public TestClass Property3 { get; }
+
+        public TestClass Property4
+        {
+            set
+            {
+                
+            }
+        }
+
+        public async void AsyncMethod()
+        {
+            
+        }
+
+        public static async void StaticAsyncMethod()
+        {
+            
+        }
+
+        public void SomeMethodWithParameters(SomeClass someClass, int i)
+        {
+            
+        }
+
+        public void SomeMethod()
+        {
+            
+        }
+
+        public void SomeMethodWebHostHiddenParameter([WebHostHidden] int parameter)
+        {
+            
+        }
+
+        [return: WebHostHidden()]
+        public int SomeMethodWebHostHiddenReturn(int parameter)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static void SomeStaticMethod()
+        {
+            
+        }
+
+        public int SomeMethod2()
+        {
+            return 0;
+        }
+
+        public static int SomeStaticMethod2()
+        {
+            return 0;
+        }
+
+        public bool SomeMethodWithReturnBool()
+        {
+            return true;
+        }
+
+        public void op_NotOperator()
+        {
+        }
+
+        public event EventHandler<object> AppMemoryUsageIncreased;
+        public static event EventHandler<object> StaticEvent;
+        private static event EventHandler<object> PrivateEvent;
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/SomeClassWithManyConstructors.cs b/mdoc/mdoc.Test/SampleClasses/SomeClassWithManyConstructors.cs
new file mode 100644
index 00000000..edbc4f60
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/SomeClassWithManyConstructors.cs
@@ -0,0 +1,15 @@
+namespace mdoc.Test.SampleClasses
+{
+    public sealed class SomeClassWithManyConstructors
+    {
+        public SomeClassWithManyConstructors(int i)
+        {
+
+        }
+
+        public SomeClassWithManyConstructors(float i)
+        {
+
+        }
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/SomeDelegate.cs b/mdoc/mdoc.Test/SampleClasses/SomeDelegate.cs
new file mode 100644
index 00000000..7c5b6cb2
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/SomeDelegate.cs
@@ -0,0 +1,4 @@
+namespace mdoc.Test.SampleClasses
+{
+    public delegate void SomeDelegate(string str);
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/SomeEmptyEnum.cs b/mdoc/mdoc.Test/SampleClasses/SomeEmptyEnum.cs
new file mode 100644
index 00000000..350bc3b9
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/SomeEmptyEnum.cs
@@ -0,0 +1,6 @@
+namespace mdoc.Test.SampleClasses
+{
+    public enum SomeEmptyEnum
+    {
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/SomeEnum.cs b/mdoc/mdoc.Test/SampleClasses/SomeEnum.cs
new file mode 100644
index 00000000..87593b0d
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/SomeEnum.cs
@@ -0,0 +1,8 @@
+namespace mdoc.Test.SampleClasses
+{
+    public enum SomeEnum
+    {
+        TestEnumElement1,
+        TestEnumElement2,
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/SomeGenericClass.cs b/mdoc/mdoc.Test/SampleClasses/SomeGenericClass.cs
new file mode 100644
index 00000000..5d0bbf22
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/SomeGenericClass.cs
@@ -0,0 +1,18 @@
+namespace mdoc.Test.SampleClasses
+{
+    public class SomeGenericClass<T>
+    {
+        public void SomeMethod<T>(T t)
+        {
+            
+        }
+        public void SomeMethod2(T t)
+        {
+            
+        }
+        public void SomeMethod3(int t)
+        {
+            
+        }
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/SomeStruct.cs b/mdoc/mdoc.Test/SampleClasses/SomeStruct.cs
new file mode 100644
index 00000000..49fa8900
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/SomeStruct.cs
@@ -0,0 +1,9 @@
+namespace mdoc.Test.SampleClasses
+{
+    public struct SomeStruct
+    {
+        public int IntMember;
+        public static int StaticMember;
+        public TestClass TestClassMember;
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/WebHostHiddenAttribute.cs b/mdoc/mdoc.Test/SampleClasses/WebHostHiddenAttribute.cs
new file mode 100644
index 00000000..6931f0e9
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/WebHostHiddenAttribute.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace Windows.Foundation.Metadata
+{
+    public class WebHostHiddenAttribute : Attribute
+    {
+        
+    }
+}
\ No newline at end of file
diff --git a/mdoc/mdoc.Test/SampleClasses/WebHostHiddenTestClass.cs b/mdoc/mdoc.Test/SampleClasses/WebHostHiddenTestClass.cs
new file mode 100644
index 00000000..765e8198
--- /dev/null
+++ b/mdoc/mdoc.Test/SampleClasses/WebHostHiddenTestClass.cs
@@ -0,0 +1,14 @@
+using Windows.Foundation.Metadata;
+
+namespace mdoc.Test.SampleClasses
+{
+    [WebHostHidden]
+    public class WebHostHiddenTestClass
+    {
+        [WebHostHidden]
+        public void SomeMethod()
+        {
+            
+        }
+    }
+}
diff --git a/mdoc/mdoc.Test/mdoc.Test.csproj b/mdoc/mdoc.Test/mdoc.Test.csproj
index f15adf7a..4feee40c 100644
--- a/mdoc/mdoc.Test/mdoc.Test.csproj
+++ b/mdoc/mdoc.Test/mdoc.Test.csproj
@@ -49,9 +49,20 @@
     <Compile Include="FormatterTests.cs" />

     <Compile Include="FSharp\FSharpFormatterTests.cs" />

     <Compile Include="FSharp\FSharpUsageFormatterTests.cs" />

+    <Compile Include="JsMemberFormatterTests.cs" />

+    <Compile Include="JsUsageFormatterTests.cs" />

+    <Compile Include="SampleClasses\SomeDelegate.cs" />

     <Compile Include="SampleClasses\TestClass.cs" />

+    <Compile Include="SampleClasses\SomeGenericClass.cs" />

+    <Compile Include="SampleClasses\WebHostHiddenTestClass.cs" />

+    <Compile Include="SampleClasses\SomeClass.cs" />

+    <Compile Include="SampleClasses\SomeClassWithManyConstructors.cs" />

+    <Compile Include="SampleClasses\SomeEmptyEnum.cs" />

+    <Compile Include="SampleClasses\SomeEnum.cs" />

     <Compile Include="SampleClasses\TestPrivateClass.cs" />

     <Compile Include="SampleClasses\TestClassTwo.cs" />

+    <Compile Include="SampleClasses\SomeStruct.cs" />

+    <Compile Include="SampleClasses\WebHostHiddenAttribute.cs" />

     <Compile Include="VBFormatterTests.cs" />

   </ItemGroup>

   <ItemGroup>