Discard body for Get, Head, and Options

Author: lpil

README.md

@@ -3,32 +3,53 @@
 Bindings to Erlang's built in HTTP client, `httpc`.
 
 ```rust
-import gleam/httpc.{Response, None}
+import gleam/httpc.{Response, NoBody}
 import gleam/http.{Get}
-import gleam/expect
+import gleam/bit_string
+import gleam/should
 
 pub fn request_test() {
-  let response = httpc.request(
+  // Make a HTTP request
+  try response = httpc.request(
     method: Get,
     url: "https://test-api.service.hmrc.gov.uk/hello/world",
     headers: [tuple("accept", "application/vnd.hmrc.1.0+json")],
-    body: None,
+    body: NoBody,
   )
-  expect.equal(response, Ok(Response(
+
+  // We get back a Response record
+  should.equal(response, Response(
     status: 200,
     headers: [tuple("content-type", "application/json")],
-    body: "{\"message\":\"Hello World\"}",
-  )))
+    body: <<"{\"message\":\"Hello World\"}">>,
+  ))
+
+  // We can convert the response body into a String if it is valid utf-8
+  bit_string.to_string(response.body)
 }
 ```
 
 ## Installation
 
-If [available in Hex](https://hex.pm/docs/publish) this package can be installed
-by adding `gleam_httpc` to your `rebar.config` dependencies:
+If this package can be installed by adding `gleam_httpc` to your
+`rebar.config` dependencies:
 
 ```erlang
 {deps, [
     gleam_httpc
 ]}.
 ```
+
+You may also need to add the `gleam_httpc` OTP application to your `.app.src`
+file, depending on how you run your program.
+
+```erlang
+{applications, [
+  kernel,
+  stdlib,
+  ssl,
+  inets,
+  gleam_stdlib,
+  gleam_httpc
+]},
+```

rebar.config

@@ -8,6 +8,6 @@
 {project_plugins, [rebar_gleam]}.
 
 {deps, [
-    {gleam_stdlib, "0.6.0"},
+    {gleam_stdlib, "0.10.0"},
     {gleam_http, {git, "https://github.com/gleam-lang/gleam_http", {branch, "master"}}}
 ]}.

rebar.lock

@@ -2,81 +2,62 @@ import gleam/dynamic.{Dynamic}
 import gleam/http.{Method}
 import gleam/list
 
-external type Charlist;
+external type Charlist
 
-external fn binary_to_list(String) -> Charlist
-  = "erlang" "binary_to_list"
+external fn binary_to_list(String) -> Charlist =
+  "erlang" "binary_to_list"
 
-external fn list_to_binary(Charlist) -> String
-  = "erlang" "list_to_binary"
+external fn list_to_binary(Charlist) -> String =
+  "erlang" "list_to_binary"
 
-external type ErlHttpOption;
+external type ErlHttpOption
 
 type BodyFormat {
   Binary
-};
+}
 
 type ErlOption {
   BodyFormat(BodyFormat)
-};
+}
 
 external fn erl_request(
   Method,
   tuple(Charlist, List(tuple(Charlist, Charlist)), Charlist, String),
   List(ErlHttpOption),
   List(ErlOption),
 ) -> Result(
-  tuple(
-    tuple(Charlist, Int, Charlist),
-    List(tuple(Charlist, Charlist)),
-    String,
-  ),
+  tuple(tuple(Charlist, Int, Charlist), List(tuple(Charlist, Charlist)), String),
   Dynamic,
-)
-  = "httpc" "request"
+) =
+  "httpc" "request"
 
 external fn erl_request_no_body(
   Method,
   tuple(Charlist, List(tuple(Charlist, Charlist))),
   List(ErlHttpOption),
   List(ErlOption),
 ) -> Result(
-  tuple(
-    tuple(Charlist, Int, Charlist),
-    List(tuple(Charlist, Charlist)),
-    String,
-  ),
+  tuple(tuple(Charlist, Int, Charlist), List(tuple(Charlist, Charlist)), String),
   Dynamic,
-)
-  = "httpc" "request"
+) =
+  "httpc" "request"
 
 pub type RequestBody {
-  Text(
-    content_type: String,
-    body: String,
-  )
-
-  None
+  StringBody(content_type: String, body: String)
+  BitBody(content_type: String, body: BitString)
+  NoBody
 }
 
 pub type Response {
-  Response(
-    status: Int,
-    headers: List(tuple(String, String)),
-    body: String,
-  )
+  Response(status: Int, headers: List(tuple(String, String)), body: String)
 }
 
-fn charlist_header(header: tuple(String, String))
-  -> tuple(Charlist, Charlist)
-{
+fn charlist_header(header: tuple(String, String)) -> tuple(Charlist, Charlist) {
   let tuple(k, v) = header
   tuple(binary_to_list(k), binary_to_list(v))
 }
 
-fn string_header(header: tuple(Charlist, Charlist))
-  -> tuple(String, String)
-{
+fn string_header(header: tuple(Charlist, Charlist)) -> tuple(String, String) {
   let tuple(k, v) = header
   tuple(list_to_binary(k), list_to_binary(v))
 }
@@ -93,24 +74,23 @@ pub fn request(
   let erl_http_options = []
   let erl_options = [BodyFormat(Binary)]
 
-  let response = case body {
-    Text(content_type: content_type, body: body) -> {
+  let response = case method, body {
+    http.Options, _ | http.Head, _ | http.Get, _ | _, NoBody -> {
+      let request = tuple(erl_url, erl_headers)
+      erl_request_no_body(method, request, erl_http_options, erl_options)
+    }
+    _, StringBody(content_type: content_type, body: body) -> {
       let erl_content_type = binary_to_list(content_type)
       let request = tuple(erl_url, erl_headers, erl_content_type, body)
       erl_request(method, request, erl_http_options, erl_options)
     }
-
-    None -> {
-      let request = tuple(erl_url, erl_headers)
-      erl_request_no_body(method, request, erl_http_options, erl_options)
-    }
   }
 
   case response {
-    Error(error) ->
-      Error(error)
+    Error(error) -> Error(error)
 
-    Ok(tuple(tuple(_http_version, status, _status), headers, resp_body)) ->
-      Ok(Response(status, list.map(headers, string_header), resp_body))
+    Ok(
+      tuple(tuple(_http_version, status, _status), headers, resp_body),
+    ) -> Ok(Response(status, list.map(headers, string_header), resp_body))
   }
 }

src/gleam/httpc.gleam

@@ -1,17 +1,70 @@
-import gleam/httpc.{None}
-import gleam/http.{Get}
+import gleam/httpc.{NoBody, StringBody}
+import gleam/http.{Get, Head, Options}
 import gleam/list
-import gleam/expect
+import gleam/should
 
 pub fn request_test() {
-  let Ok(response) = httpc.request(
+  let Ok(
+    response,
+  ) = httpc.request(
     method: Get,
     url: "https://test-api.service.hmrc.gov.uk/hello/world",
     headers: [tuple("accept", "application/vnd.hmrc.1.0+json")],
-    body: None,
+    body: NoBody,
   )
   let httpc.Response(status, headers, body) = response
-  expect.equal(status, 200)
-  expect.equal(list.key_find(headers, "content-type"), Ok("application/json"))
-  expect.equal(body, "{\"message\":\"Hello World\"}")
+  should.equal(status, 200)
+  should.equal(list.key_find(headers, "content-type"), Ok("application/json"))
+  should.equal(body, "{\"message\":\"Hello World\"}")
+}
+
+pub fn get_request_discards_body_test() {
+  let Ok(
+    response,
+  ) = httpc.request(
+    method: Get,
+    url: "https://test-api.service.hmrc.gov.uk/hello/world",
+    headers: [tuple("accept", "application/vnd.hmrc.1.0+json")],
+    body: StringBody(content_type: "application/json", body: "{}"),
+  )
+  let httpc.Response(status, headers, body) = response
+  should.equal(status, 200)
+  should.equal(list.key_find(headers, "content-type"), Ok("application/json"))
+  should.equal(body, "{\"message\":\"Hello World\"}")
+}
+
+pub fn head_request_discards_body_test() {
+  let Ok(
+    response,
+  ) = httpc.request(
+    method: Head,
+    url: "https://postman-echo.com/get",
+    headers: [],
+    body: StringBody(content_type: "application/json", body: "{}"),
+  )
+  let httpc.Response(status, headers, body) = response
+  should.equal(status, 200)
+  should.equal(
+    list.key_find(headers, "content-type"),
+    Ok("application/json; charset=utf-8"),
+  )
+  should.equal(body, "")
+}
+
+pub fn options_request_discards_body_test() {
+  let Ok(
+    response,
+  ) = httpc.request(
+    method: Options,
+    url: "https://postman-echo.com/get",
+    headers: [],
+    body: StringBody(content_type: "application/json", body: "{}"),
+  )
+  let httpc.Response(status, headers, body) = response
+  should.equal(status, 200)
+  should.equal(
+    list.key_find(headers, "content-type"),
+    Ok("text/html; charset=utf-8"),
+  )
+  should.equal(body, "GET,HEAD,PUT,POST,DELETE,PATCH")
 }