From 2027dc5e53e2f17cfe39654fb85d856f587cb5f6 Mon Sep 17 00:00:00 2001
From: Glade Miller <glade.miller@insidesales.com>
Date: Mon, 3 Jun 2019 10:44:43 -0600
Subject: [PATCH] Added HEAD, CONNECT, OPTIONS and TRACE to the codegen

---
 actix-web-codegen/src/lib.rs          | 52 +++++++++++++++++++++++++++
 actix-web-codegen/src/route.rs        |  8 +++++
 actix-web-codegen/tests/test_macro.rs | 40 +++++++++++++++++++++
 3 files changed, 100 insertions(+)

diff --git a/actix-web-codegen/src/lib.rs b/actix-web-codegen/src/lib.rs
index 70cde90e4..dfa3079b0 100644
--- a/actix-web-codegen/src/lib.rs
+++ b/actix-web-codegen/src/lib.rs
@@ -11,6 +11,10 @@
 //! - [post](attr.post.html)
 //! - [put](attr.put.html)
 //! - [delete](attr.delete.html)
+//! - [head](attr.head.html)
+//! - [connect](attr.connect.html)
+//! - [options](attr.options.html)
+//! - [trace](attr.trace.html)
 //!
 //! ### Attributes:
 //!
@@ -92,3 +96,51 @@ pub fn delete(args: TokenStream, input: TokenStream) -> TokenStream {
     let gen = route::Args::new(&args, input, route::GuardType::Delete);
     gen.generate()
 }
+
+/// Creates route handler with `HEAD` method guard.
+///
+/// Syntax: `#[head("path"[, attributes])]`
+///
+/// Attributes are the same as in [head](attr.head.html)
+#[proc_macro_attribute]
+pub fn head(args: TokenStream, input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as syn::AttributeArgs);
+    let gen = route::Args::new(&args, input, route::GuardType::Head);
+    gen.generate()
+}
+
+/// Creates route handler with `CONNECT` method guard.
+///
+/// Syntax: `#[connect("path"[, attributes])]`
+///
+/// Attributes are the same as in [connect](attr.connect.html)
+#[proc_macro_attribute]
+pub fn connect(args: TokenStream, input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as syn::AttributeArgs);
+    let gen = route::Args::new(&args, input, route::GuardType::Connect);
+    gen.generate()
+}
+
+/// Creates route handler with `OPTIONS` method guard.
+///
+/// Syntax: `#[options("path"[, attributes])]`
+///
+/// Attributes are the same as in [options](attr.options.html)
+#[proc_macro_attribute]
+pub fn options(args: TokenStream, input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as syn::AttributeArgs);
+    let gen = route::Args::new(&args, input, route::GuardType::Options);
+    gen.generate()
+}
+
+/// Creates route handler with `TRACE` method guard.
+///
+/// Syntax: `#[trace("path"[, attributes])]`
+///
+/// Attributes are the same as in [trace](attr.trace.html)
+#[proc_macro_attribute]
+pub fn trace(args: TokenStream, input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as syn::AttributeArgs);
+    let gen = route::Args::new(&args, input, route::GuardType::Trace);
+    gen.generate()
+}
\ No newline at end of file
diff --git a/actix-web-codegen/src/route.rs b/actix-web-codegen/src/route.rs
index 1a5f79298..3908f6a8b 100644
--- a/actix-web-codegen/src/route.rs
+++ b/actix-web-codegen/src/route.rs
@@ -25,6 +25,10 @@ pub enum GuardType {
     Post,
     Put,
     Delete,
+    Head,
+    Connect,
+    Options,
+    Trace
 }
 
 impl fmt::Display for GuardType {
@@ -34,6 +38,10 @@ impl fmt::Display for GuardType {
             &GuardType::Post => write!(f, "Post"),
             &GuardType::Put => write!(f, "Put"),
             &GuardType::Delete => write!(f, "Delete"),
+            &GuardType::Head => write!(f, "Head"),
+            &GuardType::Connect => write!(f, "Connect"),
+            &GuardType::Options => write!(f, "Options"),
+            &GuardType::Trace => write!(f, "Trace"),
         }
     }
 }
diff --git a/actix-web-codegen/tests/test_macro.rs b/actix-web-codegen/tests/test_macro.rs
index cd899d48d..8adacab45 100644
--- a/actix-web-codegen/tests/test_macro.rs
+++ b/actix-web-codegen/tests/test_macro.rs
@@ -19,6 +19,26 @@ fn post_test() -> impl Responder {
     HttpResponse::NoContent()
 }
 
+#[head("/test")]
+fn head_test() -> impl Responder {
+    HttpResponse::Ok()
+}
+
+#[connect("/test")]
+fn connect_test() -> impl Responder {
+    HttpResponse::Ok()
+}
+
+#[options("/test")]
+fn options_test() -> impl Responder {
+    HttpResponse::Ok()
+}
+
+#[trace("/test")]
+fn trace_test() -> impl Responder {
+    HttpResponse::Ok()
+}
+
 #[get("/test")]
 fn auto_async() -> impl Future<Item = HttpResponse, Error = actix_web::Error> {
     future::ok(HttpResponse::Ok().finish())
@@ -75,6 +95,10 @@ fn test_body() {
             App::new()
                 .service(post_test)
                 .service(put_test)
+                .service(head_test)
+                .service(connect_test)
+                .service(options_test)
+                .service(trace_test)
                 .service(test),
         )
     });
@@ -82,6 +106,22 @@ fn test_body() {
     let response = srv.block_on(request.send()).unwrap();
     assert!(response.status().is_success());
 
+    let request = srv.request(http::Method::HEAD, srv.url("/test"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::CONNECT, srv.url("/test"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::OPTIONS, srv.url("/test"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert!(response.status().is_success());
+
+    let request = srv.request(http::Method::TRACE, srv.url("/test"));
+    let response = srv.block_on(request.send()).unwrap();
+    assert!(response.status().is_success());
+
     let request = srv.request(http::Method::PUT, srv.url("/test"));
     let response = srv.block_on(request.send()).unwrap();
     assert!(response.status().is_success());