add syntax to call static methods

Author: Jett Jones

.gitignore

@@ -1,12 +1,13 @@
 Debug
 *.log
-_Resharper.Sharp
+_Resharper.*
 .node-gyp
 bindings.sln*
 ipch
 Release
 *\ipch
 *.sdf
+Sharp/Sharp.opensdf
 *.suo
 *\bin\*
 *\obj\*

Sharp.sln

@@ -14,10 +14,10 @@ WrapAssembly::WrapAssembly(Assembly^ a)
 }
 
 Handle<Value> WrapAssembly::AssemblyName(const Arguments& args)
-{   
+{
     HandleScope scope;
     WrapAssembly* self = node::ObjectWrap::Unwrap<WrapAssembly>(args.This());
-        
+
     Handle<Value> result = v8sharp::V8Interop::ToV8(self->_assembly->FullName);
 
     return scope.Close(result);
@@ -46,16 +46,16 @@ Handle<Value> WrapAssembly::CreateInstance(const Arguments& args)
         return ThrowException(v8::Exception::TypeError(
             v8::String::New("First argument must be a string, for class name.")));
     }
-        
+
     HandleScope scope;
     WrapAssembly* self = node::ObjectWrap::Unwrap<WrapAssembly>(args.This());
-        
+
     System::String^ path =  (System::String^)v8sharp::V8Interop::FromV8(args[0]);
 
     try
     {
         Type^ t = self->_assembly->GetType(path);
-            
+
         if (t == nullptr)
         {
             throw gcnew System::NotSupportedException("Class: '" + path + "' was not found");
@@ -67,7 +67,7 @@ Handle<Value> WrapAssembly::CreateInstance(const Arguments& args)
         int otherArgCount = args.Length() - 1;
         for (int i = 0; i < cInfoList->Length; i++)
         {
-            ConstructorInfo^ ci = cInfoList[i]; 
+            ConstructorInfo^ ci = cInfoList[i];
             array<System::Reflection::ParameterInfo^>^ params = ci->GetParameters();
             if (params->Length == otherArgCount)
             {
@@ -86,14 +86,46 @@ Handle<Value> WrapAssembly::CreateInstance(const Arguments& args)
 
         array<System::Object^>^ argList = Helpers::ConvertArguments(args, 1, matches[0]->GetParameters());
         System::Object^ result = matches[0]->Invoke(argList);
-        
+
         return scope.Close(WrapInstance::New(t, result));
     }
     catch (System::Exception^ e)
     {
         v8::Handle<v8::Value> str =  v8sharp::V8Interop::ToV8(Helpers::GetError(e));
         v8::Handle<v8::String> err = v8::Handle<v8::String>::Cast(str);
-            
+
+        return ThrowException(v8::Exception::Error(err));
+    }
+}
+
+Handle<Value> WrapAssembly::StaticInstance(const Arguments& args)
+{
+    if (args.Length() < 1 || !args[0]->IsString()) {
+        return ThrowException(v8::Exception::TypeError(
+            v8::String::New("First argument must be a string, for class name.")));
+    }
+
+    HandleScope scope;
+    WrapAssembly* self = node::ObjectWrap::Unwrap<WrapAssembly>(args.This());
+
+    System::String^ path =  (System::String^)v8sharp::V8Interop::FromV8(args[0]);
+
+    try
+    {
+        Type^ t = self->_assembly->GetType(path);
+
+        if (t == nullptr)
+        {
+            throw gcnew System::NotSupportedException("Class: '" + path + "' was not found");
+        }
+
+        return scope.Close(WrapInstance::New(t, nullptr));
+    }
+    catch (System::Exception^ e)
+    {
+        v8::Handle<v8::Value> str =  v8sharp::V8Interop::ToV8(Helpers::GetError(e));
+        v8::Handle<v8::String> err = v8::Handle<v8::String>::Cast(str);
+
         return ThrowException(v8::Exception::Error(err));
     }
 }
@@ -108,10 +140,11 @@ Handle<v8::Value> WrapAssembly::New(Assembly ^ a)
 
     WrapAssembly* self = new WrapAssembly(a);
     self->Wrap(result);
-                
+
     result->Set(v8::String::NewSymbol("assembly"), v8sharp::V8Interop::ToV8(self->_assembly->FullName));
     result->Set(v8::String::NewSymbol("types"), FunctionTemplate::New(ListTypes)->GetFunction() );
     result->Set(v8::String::NewSymbol("new"), FunctionTemplate::New(CreateInstance)->GetFunction() );
-        
+    result->Set(v8::String::NewSymbol("static"), FunctionTemplate::New(StaticInstance)->GetFunction() );
+
     return scope.Close(result);
 }

Sharp/WrapAssembly.cpp

@@ -16,6 +16,7 @@ class WrapAssembly : public node::ObjectWrap
     static v8::Handle<v8::Value> AssemblyName(const v8::Arguments& args);
     static v8::Handle<v8::Value> ListTypes(const v8::Arguments& args);
     static v8::Handle<v8::Value> CreateInstance(const v8::Arguments& args);
+    static v8::Handle<v8::Value> StaticInstance(const v8::Arguments& args);
 
     static v8::Handle<v8::Value> New(System::Reflection::Assembly ^ a);
 };

Sharp/WrapAssembly.h

@@ -8,7 +8,7 @@ using namespace System::Reflection;
 using namespace v8;
 
 Handle<Value> WrapInstance::New(System::Type^ t, System::Object^ o)
-{   
+{
     HandleScope scope;
 
     Local<ObjectTemplate> oTemplate = ObjectTemplate::New();
@@ -22,14 +22,14 @@ Handle<Value> WrapInstance::New(System::Type^ t, System::Object^ o)
     result->Set(v8::String::NewSymbol("methods"), FunctionTemplate::New(ListMethods)->GetFunction() );
     result->Set(v8::String::NewSymbol("call"), FunctionTemplate::New(CallMethod)->GetFunction() );
     result->Set(v8::String::NewSymbol("async"), FunctionTemplate::New(Async)->GetFunction() );
-        
+
     result->SetHiddenValue(v8::String::NewSymbol("__wrapper"), v8::Boolean::New(true));
 
     // Debug code for checking how the hidden values might work.
     //Handle<v8::Value> val1 = result->GetHiddenValue(v8::String::NewSymbol("__wrapper"));
     //Handle<v8::Value> val2 = result->GetHiddenValue(v8::String::NewSymbol("__bogus"));
 
-    //bool null1 = val1.IsEmpty(); 
+    //bool null1 = val1.IsEmpty();
     //bool null2 = val2.IsEmpty();
 
     return scope.Close(result);
@@ -63,30 +63,34 @@ WrapInstance::WrapInstance(System::Type^ t, System::Object^ i)
 {
     _type = t;
     _instance = i;
+    _isStatic = i == nullptr;
 }
 
 Handle<Value> WrapInstance::GetClassName(const Arguments& args)
 {
     HandleScope scope;
     WrapInstance* self = node::ObjectWrap::Unwrap<WrapInstance>(args.This());
-        
+
     Handle<Value> result = v8sharp::V8Interop::ToV8(self->_type->Name);
 
     return scope.Close(result);
 }
-    
+
 Handle<Value> WrapInstance::ListMethods(const Arguments& args)
 {
     HandleScope scope;
     WrapInstance* self = node::ObjectWrap::Unwrap<WrapInstance>(args.This());
-        
-    List<System::String^>^ methods = gcnew List<System::String^>(); 
-        
-    for each(MethodInfo^ m in self->_type->GetMethods())
+
+    List<System::String^>^ methods = gcnew List<System::String^>();
+
+    BindingFlags flags = BindingFlags::Public | BindingFlags::Instance;
+    flags = (self->_isStatic) ? BindingFlags::Public | BindingFlags::Static : flags;
+
+    for each(MethodInfo^ m in self->_type->GetMethods(flags))
     {
         methods->Add(m->Name);
     }
-        
+
     Handle<Value> result = v8sharp::V8Interop::ToV8(methods->ToArray());
 
     return scope.Close(result);
@@ -112,13 +116,13 @@ Handle<Value> WrapInstance::CallMethod(const Arguments& args)
         {
             throw gcnew System::NotSupportedException(System::String::Format("Method {0} not found", path));
         }
-        
+
         array<System::Object^>^ argList = Helpers::ConvertArguments(args, 1, m->GetParameters());
 
         System::Object^ r = m->Invoke(self->_instance, argList);
-                    
+
         Handle<Value> result = v8sharp::V8Interop::ToV8(r);
-        
+
         return scope.Close(result);
     }
     catch(System::Exception^ e)
@@ -129,7 +133,7 @@ Handle<Value> WrapInstance::CallMethod(const Arguments& args)
         return ThrowException(v8::Exception::Error(err));
     }
 }
-    
+
 Handle<Value> WrapInstance::Async(const Arguments& args)
 {
     HandleScope scope;
@@ -168,7 +172,7 @@ Handle<Value> WrapInstance::Async(const Arguments& args)
     {
         v8::Handle<v8::Value> str =  v8sharp::V8Interop::ToV8(Helpers::GetError(e));
         v8::Handle<v8::String> err = v8::Handle<v8::String>::Cast(str);
-            
+
         return ThrowException(v8::Exception::Error(err));
     }
 
@@ -178,7 +182,7 @@ Handle<Value> WrapInstance::Async(const Arguments& args)
 
     return Undefined();
 }
-    
+
 // this runs on the worker thread and should not callback or interact with node/v8 in any way
 void WrapInstance::StartAsync(uv_work_t* req)
 {
@@ -187,7 +191,7 @@ void WrapInstance::StartAsync(uv_work_t* req)
     try
     {
         baton->error = false;
-        baton->result = baton->method->Invoke(baton->caller->_instance, baton->args); 
+        baton->result = baton->method->Invoke(baton->caller->_instance, baton->args);
     }
     catch(System::Exception^ e)
     {
@@ -202,7 +206,7 @@ void WrapInstance::AfterAsync(uv_work_t *req)
     HandleScope scope;
     Baton* baton = static_cast<Baton*>(req->data);
 
-    if (baton->error) 
+    if (baton->error)
     {
         Handle<v8::Value> str =  v8sharp::V8Interop::ToV8(baton->error_message);
         Handle<v8::String> err = Handle<v8::String>::Cast(str);
@@ -215,9 +219,9 @@ void WrapInstance::AfterAsync(uv_work_t *req)
 
         if (try_catch.HasCaught()) {
             node::FatalException(try_catch);
-        }        
-    } 
-    else 
+        }
+    }
+    else
     {
         const unsigned argc = 2;
         Local<Value> argv[argc] = {

Sharp/WrapInstance.cpp

@@ -30,6 +30,7 @@ class WrapInstance : node::ObjectWrap
 private:
     gcroot<System::Object^> _instance;
     gcroot<System::Type^> _type;
+    bool _isStatic;
 
     WrapInstance(System::Type^ t, System::Object^ i);
 

Sharp/WrapInstance.h

@@ -0,0 +1,26 @@
+
+namespace StubClass
+{
+    public class Static
+    {
+        public static Static Instance()
+        {
+            return new Static();
+        }
+
+        public static int GetInt()
+        {
+            return 574716;
+        }
+
+        public static string GetString()
+        {
+            return "static";
+        }
+
+        public string InstanceString()
+        {
+            return "instance." + this.GetHashCode();
+        }
+    }
+}

StubClass/Static.cs

@@ -39,6 +39,7 @@
     <Compile Include="Input.cs" />
     <Compile Include="Output.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Static.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

StubClass/StubClass.csproj

@@ -26,3 +26,9 @@ console.log(str);
 
 str = stub.new('StubClass.Constructor', oc.call('ReturnObject')).call('ToString')
 console.log(str);
+
+// calling static methods
+var ss = stub.static('StubClass.Static')
+console.log('Static1: ' + ss.call('GetInt'));
+
+console.log('Static2: '+ ss.call('Instance').call('InstanceString'));