Stub anything that looks like a Refit interface

InterfaceStubGenerator/GeneratedInterfaceStubTemplate.mustache

@@ -46,8 +46,13 @@ namespace {{Namespace}}
 {{#MethodList}}
         public virtual {{ReturnType}} {{Name}}({{ArgumentListWithTypes}})
         {
+{{#IsRefitMethod}}    
             var arguments = new object[] { {{ArgumentList}} };
             return ({{ReturnType}}) methodImpls["{{Name}}"](Client, arguments);
+{{/IsRefitMethod}}
+{{^IsRefitMethod}}
+            throw new NotImplementedException("Either this method has no Refit HTTP method attribute or you've used something other than a string literal for the 'path' argument.");
+{{/IsRefitMethod}}
         }
 
 {{/MethodList}}

InterfaceStubGenerator/InterfaceStubGenerator.cs

@@ -14,8 +14,8 @@
 
 namespace Refit.Generator
 {
-    // * Find all calls to RestService.For<T>, extract all T's
-    // * Search for all Interfaces, find the method definitions
+    // * Search for all Interfaces, find the method definitions 
+    //   and make sure there's at least one Refit attribute on one
     // * Generate the data we need for the template based on interface method
     //   defn's
     // * Get this into an EXE in tools, write a targets file to beforeBuild execute it
@@ -30,11 +30,8 @@ public class InterfaceStubGenerator
         public string GenerateInterfaceStubs(string[] paths)
         {
             var trees = paths.Select(x => CSharpSyntaxTree.ParseFile(x)).ToList();
-            var interfaceNamesToFind = trees.SelectMany(FindInterfacesToGenerate).Distinct().ToList();
 
-            var interfacesToGenerate = trees.SelectMany(x => x.GetRoot().DescendantNodes().OfType<InterfaceDeclarationSyntax>())
-                .Where(x => interfaceNamesToFind.Contains(x.Identifier.ValueText))
-                .ToList();
+            var interfacesToGenerate = trees.SelectMany(FindInterfacesToGenerate).ToList();
 
             var templateInfo = GenerateTemplateInfoForInterfaceList(interfacesToGenerate);
 
@@ -43,21 +40,37 @@ public string GenerateInterfaceStubs(string[] paths)
             return text;
         }
 
-        public List<string> FindInterfacesToGenerate(SyntaxTree tree)
+        public List<InterfaceDeclarationSyntax> FindInterfacesToGenerate(SyntaxTree tree)
         {
-            var restServiceCalls = tree.GetRoot().DescendantNodes()
-                .OfType<MemberAccessExpressionSyntax>()
-                .Where(x => x.Expression is IdentifierNameSyntax &&
-                    ((IdentifierNameSyntax)x.Expression).Identifier.ValueText == "RestService" &&
-                    x.Name.Identifier.ValueText == "For");
-
-            return restServiceCalls
-                .SelectMany(x => ((GenericNameSyntax)x.Name).TypeArgumentList.Arguments)
-                .Select(x => ((IdentifierNameSyntax)x).Identifier.ValueText)
-                .Distinct()
+            var nodes = tree.GetRoot().DescendantNodes().ToList();
+
+            // Make sure this file imports Refit. If not, we're not going to 
+            // find any Refit interfaces
+            // NB: This falls down in the tests unless we add an explicit "using Refit;",
+            // but we can rely on this being there in any other file
+            if (nodes.OfType<UsingDirectiveSyntax>().All(u => u.Name.ToFullString() != "Refit"))
+                return new List<InterfaceDeclarationSyntax>();
+
+            return nodes.OfType<InterfaceDeclarationSyntax>()
+                .Where(i => i.Members.OfType<MethodDeclarationSyntax>().Any(HasRefitHttpMethodAttribute))
                 .ToList();
         }
 
+        static readonly HashSet<string> httpMethodAttributeNames = new HashSet<string>(
+            new[] {"Get", "Head", "Post", "Put", "Delete"}
+                .SelectMany(x => new[] {"{0}", "{0}Attribute"}.Select(f => string.Format(f, x))));
+
+        public bool HasRefitHttpMethodAttribute(MethodDeclarationSyntax method)
+        {
+            // We could also verify that the single argument is a string, 
+            // but what if somebody is dumb and uses a constant?
+            // Could be turtles all the way down.
+            return method.AttributeLists.SelectMany(a => a.Attributes)
+                .Any(a => httpMethodAttributeNames.Contains(a.Name.ToFullString().Split('.').Last()) &&
+                    a.ArgumentList.Arguments.Count == 1 &&
+                    a.ArgumentList.Arguments[0].Expression.CSharpKind() == SyntaxKind.StringLiteralExpression);
+        }
+
         public TemplateInformation GenerateTemplateInfoForInterfaceList(List<InterfaceDeclarationSyntax> interfaceList)
         {
             var usings = interfaceList
@@ -100,6 +113,7 @@ public ClassTemplateInfo GenerateClassInfoForInterface(InterfaceDeclarationSynta
                         .Select(y => y.Identifier.ValueText)),
                     ArgumentListWithTypes = String.Join(",", x.ParameterList.Parameters
                         .Select(y => String.Format("{0} {1}", y.Type.ToString(), y.Identifier.ValueText))),
+                    IsRefitMethod = HasRefitHttpMethodAttribute(x)
                 })
                 .ToList();
 
@@ -142,6 +156,7 @@ public class MethodTemplateInfo
         public string Name { get; set; }
         public string ArgumentListWithTypes { get; set; }
         public string ArgumentList { get; set; }
+        public bool IsRefitMethod { get; set; }
     }
 
     public class TemplateInformation

Refit-Tests/GitHubApi.cs

@@ -4,6 +4,7 @@
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
+using Refit; // InterfaceStubGenerator looks for this
 
 namespace Refit.Tests
 {

Refit-Tests/InterfaceStubGenerator.cs

@@ -10,6 +10,7 @@
 using NUnit.Framework;
 using Nustache;
 using Nustache.Core;
+using Refit; // InterfaceStubGenerator looks for this
 using Refit.Generator;
 
 namespace Refit.Tests
@@ -33,12 +34,39 @@ public void GenerateInterfaceStubsSmokeTest()
         [Test]
         public void FindInterfacesSmokeTest()
         {
-            var input = IntegrationTestHelper.GetPath("RestService.cs");
+            var input = IntegrationTestHelper.GetPath("GitHubApi.cs");
             var fixture = new InterfaceStubGenerator();
 
             var result = fixture.FindInterfacesToGenerate(CSharpSyntaxTree.ParseFile(input));
-            Assert.AreEqual(3, result.Count);
-            Assert.True(result.Any(x => x == "IGitHubApi"));
+            Assert.AreEqual(1, result.Count);
+            Assert.True(result.Any(x => x.Identifier.ValueText == "IGitHubApi"));
+
+            input = IntegrationTestHelper.GetPath("InterfaceStubGenerator.cs");
+
+            result = fixture.FindInterfacesToGenerate(CSharpSyntaxTree.ParseFile(input));
+            Assert.AreEqual(1, result.Count);
+            Assert.True(result.Any(x => x.Identifier.ValueText == "IAmARefitInterfaceButNobodyUsesMe"));
+            Assert.True(result.All(x => x.Identifier.ValueText != "IAmNotARefitInterface"));
+        }
+
+        [Test]
+        public void HasRefitHttpMethodAttributeSmokeTest()
+        {
+            var file = CSharpSyntaxTree.ParseFile(IntegrationTestHelper.GetPath("InterfaceStubGenerator.cs"));
+            var fixture = new InterfaceStubGenerator();
+
+            var input = file.GetRoot().DescendantNodes()
+                .OfType<InterfaceDeclarationSyntax>()
+                .SelectMany(i => i.Members.OfType<MethodDeclarationSyntax>())
+                .ToList();
+
+            var result = input
+                .ToDictionary(m => m.Identifier.ValueText, fixture.HasRefitHttpMethodAttribute);
+
+            Assert.IsTrue(result["RefitMethod"]);
+            Assert.IsTrue(result["AnotherRefitMethod"]);
+            Assert.IsFalse(result["NoConstantsAllowed"]);
+            Assert.IsFalse(result["NotARefitMethod"]);
         }
 
         [Test]
@@ -69,7 +97,7 @@ public void GenerateTemplateInfoForInterfaceListSmokeTest()
                 .ToList();
 
             var result = fixture.GenerateTemplateInfoForInterfaceList(input);
-            Assert.AreEqual(2, result.ClassList.Count);
+            Assert.AreEqual(4, result.ClassList.Count);
         }
 
         [Test]
@@ -86,4 +114,26 @@ public void RetainsAliasesInUsings()
             CollectionAssert.Contains(usingList, "CollisionB");
         }
     }
+
+    public static class ThisIsDumbButMightHappen
+    {
+        public const string PeopleDoWeirdStuff = "But we don't let them";
+    }
+
+    public interface IAmARefitInterfaceButNobodyUsesMe
+    {
+        [Get("whatever")]
+        Task RefitMethod();
+
+        [Refit.GetAttribute("something-else")]
+        Task AnotherRefitMethod();
+
+        [Get(ThisIsDumbButMightHappen.PeopleDoWeirdStuff)]
+        Task NoConstantsAllowed();
+    }
+
+    public interface IAmNotARefitInterface
+    {
+        Task NotARefitMethod();
+    }
 }

Refit-Tests/NamespaceCollisionApi.cs

@@ -1,6 +1,7 @@
 using System.Threading.Tasks;
 using SomeType = CollisionA.SomeType;
 using CollisionB;
+using Refit; // InterfaceStubGenerator looks for this
 
 namespace Refit.Tests
 {

Refit-Tests/RefitStubs.cs

@@ -4,11 +4,18 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Refit;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using NUnit.Framework;
+using Nustache;
+using Nustache.Core;
+using Refit.Generator;
 using SomeType = CollisionA.SomeType;
 using CollisionB;
 using System.Net;
 using System.Reactive.Linq;
-using NUnit.Framework;
 using Newtonsoft.Json;
 
 /* ******** Hey You! *********
@@ -92,6 +99,42 @@ public virtual Task NothingToSeeHere()
     }
 }
 
+namespace Refit.Tests
+{
+    using RefitInternalGenerated;
+
+    [Preserve]
+    public partial class AutoGeneratedIAmARefitInterfaceButNobodyUsesMe : IAmARefitInterfaceButNobodyUsesMe
+    {
+        public HttpClient Client { get; protected set; }
+        readonly Dictionary<string, Func<HttpClient, object[], object>> methodImpls;
+
+        public AutoGeneratedIAmARefitInterfaceButNobodyUsesMe(HttpClient client, IRequestBuilder requestBuilder)
+        {
+            methodImpls = requestBuilder.InterfaceHttpMethods.ToDictionary(k => k, v => requestBuilder.BuildRestResultFuncForMethod(v));
+            Client = client;
+        }
+
+        public virtual Task RefitMethod()
+        {
+            var arguments = new object[] {  };
+            return (Task) methodImpls["RefitMethod"](Client, arguments);
+        }
+
+        public virtual Task AnotherRefitMethod()
+        {
+            var arguments = new object[] {  };
+            return (Task) methodImpls["AnotherRefitMethod"](Client, arguments);
+        }
+
+        public virtual Task NoConstantsAllowed()
+        {
+            throw new NotImplementedException("Either this method has no Refit HTTP method attribute or you've used something other than a string literal for the 'path' argument.");
+        }
+
+    }
+}
+
 namespace Refit.Tests
 {
     using RefitInternalGenerated;
@@ -167,4 +210,34 @@ public virtual Task Post()
     }
 }
 
+namespace Refit.Tests
+{
+    using RefitInternalGenerated;
+
+    [Preserve]
+    public partial class AutoGeneratedIAmHalfRefit : IAmHalfRefit
+    {
+        public HttpClient Client { get; protected set; }
+        readonly Dictionary<string, Func<HttpClient, object[], object>> methodImpls;
+
+        public AutoGeneratedIAmHalfRefit(HttpClient client, IRequestBuilder requestBuilder)
+        {
+            methodImpls = requestBuilder.InterfaceHttpMethods.ToDictionary(k => k, v => requestBuilder.BuildRestResultFuncForMethod(v));
+            Client = client;
+        }
+
+        public virtual Task Post()
+        {
+            var arguments = new object[] {  };
+            return (Task) methodImpls["Post"](Client, arguments);
+        }
+
+        public virtual Task Get()
+        {
+            throw new NotImplementedException("Either this method has no Refit HTTP method attribute or you've used something other than a string literal for the 'path' argument.");
+        }
+
+    }
+}
+
 

Refit-Tests/RestService.cs

@@ -8,6 +8,7 @@
 
 using NUnit.Framework;
 using Newtonsoft.Json;
+using Refit; // InterfaceStubGenerator looks for this
 
 namespace Refit.Tests
 {
@@ -31,6 +32,19 @@ public interface IRequestBin
         Task Post();
     }
 
+    public interface INoRefitHereBuddy
+    {
+        Task Post();
+    }
+
+    public interface IAmHalfRefit
+    {
+        [Post("/anything")]
+        Task Post();
+
+        Task Get();
+    }
+
     [TestFixture]
     public class RestServiceIntegrationTests
     {
@@ -173,5 +187,26 @@ public async Task CanGetDataOutOfErrorResponses()
                 Assert.IsNotNull(content["documentation_url"]);
             }
         }
+
+        [Test]
+        public void NonRefitInterfacesThrowMeaningfulExceptions() 
+        {
+            try {
+                RestService.For<INoRefitHereBuddy>("http://example.com");
+            } catch (InvalidOperationException exception) {
+                StringAssert.StartsWith("INoRefitHereBuddy", exception.Message);
+            }
+        }
+
+        [Test]
+        public async Task NonRefitMethodsThrowMeaningfulExceptions() 
+        {
+            try {
+                var fixture = RestService.For<IAmHalfRefit>("http://example.com");
+                await fixture.Get();
+            } catch (NotImplementedException exception) {
+                StringAssert.Contains("no Refit HTTP method attribute", exception.Message);
+            }
+        }
     }
 }

Refit/RestService.cs

@@ -21,6 +21,9 @@ public static T For<T>(HttpClient client)
             var typeName = typeof(T).AssemblyQualifiedName.Replace(typeof(T).Name, className);
             var generatedType = Type.GetType(typeName);
 
+            if(generatedType == null)
+                throw new InvalidOperationException(typeof(T).Name + " doesn't look like a Refit interface. Make sure it has at least one method with a Refit HTTP method attribute and Refit is installed in the project.");
+
             return (T)Activator.CreateInstance(generatedType, client, requestBuilder);
         }