Updating the gleam stdlib minor version and changing *_builder API to *_tree API

gleam.toml

···
 name = "wisp"
-version = "1.2.0"
+version = "1.2.1"
 gleam = ">= 1.1.0"
 description = "A practical web framework for Gleam"
 licences = ["Apache-2.0"]
···
 gleam_erlang = ">= 0.21.0 and < 2.0.0"
 gleam_http = ">= 3.5.0 and < 4.0.0"
 gleam_json = ">= 0.6.0 and < 3.0.0"
-gleam_stdlib = ">= 0.29.0 and < 2.0.0"
+gleam_stdlib = ">= 0.34.0 and < 2.0.0"
 mist = ">= 1.2.0 and < 4.0.0"
 simplifile = ">= 2.0.0 and < 3.0.0"
 marceau = ">= 1.1.0 and < 2.0.0"

manifest.toml

···
 packages = [
   { name = "birl", version = "1.7.1", build_tools = ["gleam"], requirements = ["gleam_stdlib", "ranger"], otp_app = "birl", source = "hex", outer_checksum = "5C66647D62BCB11FE327E7A6024907C4A17954EF22865FE0940B54A852446D01" },
   { name = "directories", version = "1.1.0", build_tools = ["gleam"], requirements = ["envoy", "gleam_stdlib", "platform", "simplifile"], otp_app = "directories", source = "hex", outer_checksum = "BDA521A4EB9EE3A7894F0DC863797878E91FF5C7826F7084B2E731E208BDB076" },
-  { name = "envoy", version = "1.0.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "envoy", source = "hex", outer_checksum = "CFAACCCFC47654F7E8B75E614746ED924C65BD08B1DE21101548AC314A8B6A41" },
+  { name = "envoy", version = "1.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "envoy", source = "hex", outer_checksum = "95FD059345AA982E89A0B6E2A3BF1CF43E17A7048DCD85B5B65D3B9E4E39D359" },
   { name = "exception", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "exception", source = "hex", outer_checksum = "F5580D584F16A20B7FCDCABF9E9BE9A2C1F6AC4F9176FA6DD0B63E3B20D450AA" },
-  { name = "filepath", version = "1.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "EFB6FF65C98B2A16378ABC3EE2B14124168C0CE5201553DE652E2644DCFDB594" },
-  { name = "gleam_crypto", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_crypto", source = "hex", outer_checksum = "ADD058DEDE8F0341F1ADE3AAC492A224F15700829D9A3A3F9ADF370F875C51B7" },
-  { name = "gleam_erlang", version = "0.26.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "3DF72F95F4716883FA51396FB0C550ED3D55195B541568CAF09745984FD37AD1" },
-  { name = "gleam_http", version = "3.7.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_http", source = "hex", outer_checksum = "EA66440C2269F7CED0F6845E5BD0DB68095775D627FA709A841CA78A398D6D56" },
-  { name = "gleam_json", version = "2.0.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "CB10B0E7BF44282FB25162F1A24C1A025F6B93E777CCF238C4017E4EEF2CDE97" },
-  { name = "gleam_otp", version = "0.12.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "CD5FC777E99673BDB390092DF85E34EAA6B8EE1882147496290AB3F45A4960B1" },
-  { name = "gleam_stdlib", version = "0.40.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "86606B75A600BBD05E539EB59FABC6E307EEEA7B1E5865AFB6D980A93BCB2181" },
+  { name = "filepath", version = "1.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "filepath", source = "hex", outer_checksum = "67A6D15FB39EEB69DD31F8C145BB5A421790581BD6AA14B33D64D5A55DBD6587" },
+  { name = "gleam_crypto", version = "1.4.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_crypto", source = "hex", outer_checksum = "8AE56026B3E05EBB1F076778478A762E9EB62B31AEEB4285755452F397029D22" },
+  { name = "gleam_erlang", version = "0.30.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_erlang", source = "hex", outer_checksum = "760618870AE4A497B10C73548E6E44F43B76292A54F0207B3771CBB599C675B4" },
+  { name = "gleam_http", version = "3.7.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_http", source = "hex", outer_checksum = "A9EE0722106FCCAB8AD3BF9D0A3EFF92BFE8561D59B83BAE96EB0BE1938D4E0F" },
+  { name = "gleam_json", version = "2.1.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleam_json", source = "hex", outer_checksum = "0A57FB5666E695FD2BEE74C0428A98B0FC11A395D2C7B4CDF5E22C5DD32C74C6" },
+  { name = "gleam_otp", version = "0.14.1", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_stdlib"], otp_app = "gleam_otp", source = "hex", outer_checksum = "5A8CE8DBD01C29403390A7BD5C0A63D26F865C83173CF9708E6E827E53159C65" },
+  { name = "gleam_stdlib", version = "0.43.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "69EF22E78FDCA9097CBE7DF91C05B2A8B5436826D9F66680D879182C0860A747" },
   { name = "gleeunit", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "F7A7228925D3EE7D0813C922E062BFD6D7E9310F0BEE585D3A42F3307E3CFD13" },
   { name = "glisten", version = "6.0.0", build_tools = ["gleam"], requirements = ["gleam_erlang", "gleam_otp", "gleam_stdlib", "logging", "telemetry"], otp_app = "glisten", source = "hex", outer_checksum = "912132751031473CB38F454120124FFC96AF6B0EA33D92C9C90DB16327A2A972" },
   { name = "gramps", version = "2.0.3", build_tools = ["gleam"], requirements = ["gleam_crypto", "gleam_erlang", "gleam_http", "gleam_stdlib"], otp_app = "gramps", source = "hex", outer_checksum = "3CCAA6E081225180D95C79679D383BBF51C8D1FDC1B84DA1DA444F628C373793" },
   { name = "hpack_erl", version = "0.3.0", build_tools = ["rebar3"], requirements = [], otp_app = "hpack", source = "hex", outer_checksum = "D6137D7079169D8C485C6962DFE261AF5B9EF60FBC557344511C1E65E3D95FB0" },
   { name = "logging", version = "1.3.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "logging", source = "hex", outer_checksum = "1098FBF10B54B44C2C7FDF0B01C1253CAFACDACABEFB4B0D027803246753E06D" },
-  { name = "marceau", version = "1.2.0", build_tools = ["gleam"], requirements = [], otp_app = "marceau", source = "hex", outer_checksum = "5188D643C181EE350D8A20A3BDBD63AF7B6C505DE333CFBE05EF642ADD88A59B" },
+  { name = "marceau", version = "1.3.0", build_tools = ["gleam"], requirements = [], otp_app = "marceau", source = "hex", outer_checksum = "2D1C27504BEF45005F5DFB18591F8610FB4BFA91744878210BDC464412EC44E9" },
   { name = "mist", version = "3.0.0", build_tools = ["gleam"], requirements = ["birl", "gleam_erlang", "gleam_http", "gleam_otp", "gleam_stdlib", "glisten", "gramps", "hpack_erl", "logging"], otp_app = "mist", source = "hex", outer_checksum = "CDA1A74E768419235E16886463EC4722EFF4AB3F8D820A76EAD45D7C167D7282" },
   { name = "platform", version = "1.0.0", build_tools = ["gleam"], requirements = [], otp_app = "platform", source = "hex", outer_checksum = "8339420A95AD89AAC0F82F4C3DB8DD401041742D6C3F46132A8739F6AEB75391" },
   { name = "ranger", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "ranger", source = "hex", outer_checksum = "1566C272B1D141B3BBA38B25CB761EF56E312E79EC0E2DFD4D3C19FB0CC1F98C" },
···
 gleam_erlang = { version = ">= 0.21.0 and < 2.0.0" }
 gleam_http = { version = ">= 3.5.0 and < 4.0.0" }
 gleam_json = { version = ">= 0.6.0 and < 3.0.0" }
-gleam_stdlib = { version = ">= 0.29.0 and < 2.0.0" }
+gleam_stdlib = { version = ">= 0.34.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
 logging = { version = ">= 1.2.0 and < 2.0.0" }
 marceau = { version = ">= 1.1.0 and < 2.0.0" }

src/wisp.gleam

···
 import exception
 import gleam/bit_array
 import gleam/bool
-import gleam/bytes_builder.{type BytesBuilder}
+import gleam/bytes_tree.{type BytesTree}
 import gleam/crypto
 import gleam/dict.{type Dict}
 import gleam/dynamic.{type Dynamic}
···
 import gleam/option.{type Option}
 import gleam/result
 import gleam/string
-import gleam/string_builder.{type StringBuilder}
+import gleam/string_tree.{type StringTree}
 import gleam/uri
 import logging
 import marceau
···
 pub type Body {
   /// A body of unicode text.
   ///
-  /// The body is represented using a `StringBuilder`. If you have a `String`
-  /// you can use the `string_builder.from_string` function to convert it.
+  /// The body is represented using a `StringTree`. If you have a `String`
+  /// you can use the `string_tree.from_string` function to convert it.
   ///
-  Text(StringBuilder)
+  Text(StringTree)
   /// A body of binary data.
   ///
-  /// The body is represented using a `BytesBuilder`. If you have a `BitArray`
-  /// you can use the `bytes_builder.from_bit_array` function to convert it.
+  /// The body is represented using a `BytesTree`. If you have a `BitArray`
+  /// you can use the `bytes_tree.from_bit_array` function to convert it.
   ///
-  Bytes(BytesBuilder)
+  Bytes(BytesTree)
   /// A body of the contents of a file.
   ///
   /// This will be sent efficiently using the `send_file` function of the
···
 /// # Examples
 ///
 /// ```gleam
+/// let content = bytes_tree.from_string("Hello, Joe!")
 /// response(200)
-/// |> file_download_from_memory(named: "myfile.txt", containing: "Hello, Joe!")
+/// |> file_download_from_memory(named: "myfile.txt", containing: content)
 /// // -> Response(
 /// //   200,
 /// //   [#("content-disposition", "attachment; filename=\"myfile.txt\"")],
···
 pub fn file_download_from_memory(
   response: Response,
   named name: String,
-  containing data: BytesBuilder,
+  containing data: BytesTree,
 ) -> Response {
   let name = uri.percent_encode(name)
   response
···
 /// # Examples
 ///
 /// ```gleam
-/// let body = string_builder.from_string("<h1>Hello, Joe!</h1>")
+/// let body = string_tree.from_string("<h1>Hello, Joe!</h1>")
 /// html_response(body, 200)
 /// // -> Response(200, [#("content-type", "text/html")], Text(body))
 /// ```
 ///
-pub fn html_response(html: StringBuilder, status: Int) -> Response {
+pub fn html_response(html: StringTree, status: Int) -> Response {
   HttpResponse(
     status,
     [#("content-type", "text/html; charset=utf-8")],
···
 /// # Examples
 ///
 /// ```gleam
-/// let body = string_builder.from_string("{\"name\": \"Joe\"}")
+/// let body = string_tree.from_string("{\"name\": \"Joe\"}")
 /// json_response(body, 200)
 /// // -> Response(200, [#("content-type", "application/json")], Text(body))
 /// ```
 ///
-pub fn json_response(json: StringBuilder, status: Int) -> Response {
+pub fn json_response(json: StringTree, status: Int) -> Response {
   HttpResponse(
     status,
     [#("content-type", "application/json; charset=utf-8")],
···
 /// # Examples
 ///
 /// ```gleam
-/// let body = string_builder.from_string("<h1>Hello, Joe!</h1>")
+/// let body = string_tree.from_string("<h1>Hello, Joe!</h1>")
 /// response(201)
 /// |> html_body(body)
 /// // -> Response(201, [#("content-type", "text/html; charset=utf-8")], Text(body))
 /// ```
 ///
-pub fn html_body(response: Response, html: StringBuilder) -> Response {
+pub fn html_body(response: Response, html: StringTree) -> Response {
   response
   |> response.set_body(Text(html))
   |> response.set_header("content-type", "text/html; charset=utf-8")
···
 /// # Examples
 ///
 /// ```gleam
-/// let body = string_builder.from_string("{\"name\": \"Joe\"}")
+/// let body = string_tree.from_string("{\"name\": \"Joe\"}")
 /// response(201)
 /// |> json_body(body)
 /// // -> Response(201, [#("content-type", "application/json; charset=utf-8")], Text(body))
 /// ```
 ///
-pub fn json_body(response: Response, json: StringBuilder) -> Response {
+pub fn json_body(response: Response, json: StringTree) -> Response {
   response
   |> response.set_body(Text(json))
   |> response.set_header("content-type", "application/json; charset=utf-8")
 }
 
-/// Set the body of a response to a given string builder.
+/// Set the body of a response to a given string tree.
 ///
 /// You likely want to also set the request `content-type` header to an
 /// appropriate value for the format of the content.
···
 /// # Examples
 ///
 /// ```gleam
-/// let body = string_builder.from_string("Hello, Joe!")
+/// let body = string_tree.from_string("Hello, Joe!")
 /// response(201)
-/// |> string_builder_body(body)
+/// |> string_tree_body(body)
 /// // -> Response(201, [], Text(body))
 /// ```
 ///
-pub fn string_builder_body(
-  response: Response,
-  content: StringBuilder,
-) -> Response {
+pub fn string_tree_body(response: Response, content: StringTree) -> Response {
   response
   |> response.set_body(Text(content))
 }
 
-/// Set the body of a response to a given string builder.
+/// Set the body of a response to a given string.
 ///
 /// You likely want to also set the request `content-type` header to an
 /// appropriate value for the format of the content.
···
 /// // -> Response(
 /// //   201,
 /// //   [],
-/// //   Text(string_builder.from_string("Hello, Joe"))
+/// //   Text(string_tree.from_string("Hello, Joe"))
 /// // )
 /// ```
 ///
 pub fn string_body(response: Response, content: String) -> Response {
   response
-  |> response.set_body(Text(string_builder.from_string(content)))
+  |> response.set_body(Text(string_tree.from_string(content)))
 }
 
 /// Escape a string so that it can be safely included in a HTML document.
···
     http.Get, True -> {
       let path =
         path
-        |> string.drop_left(string.length(prefix))
+        |> string.drop_start(string.length(prefix))
         |> string.replace(each: "..", with: "")
         |> internal.join_path(directory, _)
 

src/wisp/testing.gleam

···
 import gleam/bit_array
-import gleam/bytes_builder
+import gleam/bytes_tree
 import gleam/crypto
 import gleam/http
 import gleam/http/request
 import gleam/json.{type Json}
 import gleam/option.{None, Some}
 import gleam/string
-import gleam/string_builder
+import gleam/string_tree
 import gleam/uri
 import simplifile
 import wisp.{type Request, type Response, Bytes, Empty, File, Text}
···
 pub fn string_body(response: Response) -> String {
   case response.body {
     Empty -> ""
-    Text(builder) -> string_builder.to_string(builder)
+    Text(tree) -> string_tree.to_string(tree)
     Bytes(bytes) -> {
-      let data = bytes_builder.to_bit_array(bytes)
+      let data = bytes_tree.to_bit_array(bytes)
       let assert Ok(string) = bit_array.to_string(data)
       string
     }
···
 pub fn bit_array_body(response: Response) -> BitArray {
   case response.body {
     Empty -> <<>>
-    Bytes(builder) -> bytes_builder.to_bit_array(builder)
-    Text(builder) ->
-      bytes_builder.to_bit_array(bytes_builder.from_string_builder(builder))
+    Bytes(tree) -> bytes_tree.to_bit_array(tree)
+    Text(tree) -> bytes_tree.to_bit_array(bytes_tree.from_string_tree(tree))
     File(path) -> {
       let assert Ok(contents) = simplifile.read_bits(path)
       contents

src/wisp/wisp_mist.gleam

···
 import exception
-import gleam/bytes_builder
+import gleam/bytes_tree
 import gleam/http/request.{type Request as HttpRequest}
 import gleam/http/response.{type Response as HttpResponse}
 import gleam/option
···
   chunk: Result(mist.Chunk, mist.ReadError),
 ) -> Result(internal.Read, Nil) {
   chunk
-  |> result.nil_error
+  |> result.replace_error(Nil)
   |> result.map(fn(chunk) {
     case chunk {
       mist.Done -> internal.ReadingFinished
···
 
 fn mist_response(response: wisp.Response) -> HttpResponse(mist.ResponseData) {
   let body = case response.body {
-    wisp.Empty -> mist.Bytes(bytes_builder.new())
-    wisp.Text(text) -> mist.Bytes(bytes_builder.from_string_builder(text))
+    wisp.Empty -> mist.Bytes(bytes_tree.new())
+    wisp.Text(text) -> mist.Bytes(bytes_tree.from_string_tree(text))
     wisp.Bytes(bytes) -> mist.Bytes(bytes)
     wisp.File(path) -> mist_send_file(path)
   }
···
     Error(error) -> {
       wisp.log_error(string.inspect(error))
       // TODO: return 500
-      mist.Bytes(bytes_builder.new())
+      mist.Bytes(bytes_tree.new())
     }
   }
 }

test/wisp/testing_test.gleam

···
 import gleam/http/response
 import gleam/json
 import gleam/option.{None, Some}
-import gleam/string_builder
+import gleam/string_tree
 import gleeunit/should
 import wisp
 import wisp/testing
···
 
 pub fn string_body_text_test() {
   wisp.ok()
-  |> response.set_body(wisp.Text(string_builder.from_string("Hello, Joe!")))
+  |> response.set_body(wisp.Text(string_tree.from_string("Hello, Joe!")))
   |> testing.string_body
   |> should.equal("Hello, Joe!")
 }
···
 
 pub fn bit_array_body_text_test() {
   wisp.ok()
-  |> response.set_body(wisp.Text(string_builder.from_string("Hello, Joe!")))
+  |> response.set_body(wisp.Text(string_tree.from_string("Hello, Joe!")))
   |> testing.bit_array_body
   |> should.equal(<<"Hello, Joe!":utf8>>)
 }

test/wisp_test.gleam

···
 import gleam/list
 import gleam/set
 import gleam/string
-import gleam/string_builder
+import gleam/string_tree
 import gleeunit
 import gleeunit/should
 import simplifile
···
 }
 
 pub fn json_response_test() {
-  let body = string_builder.from_string("{\"one\":1,\"two\":2}")
+  let body = string_tree.from_string("{\"one\":1,\"two\":2}")
   let response = wisp.json_response(body, 201)
   response.status
   |> should.equal(201)
···
 }
 
 pub fn html_response_test() {
-  let body = string_builder.from_string("Hello, world!")
+  let body = string_tree.from_string("Hello, world!")
   let response = wisp.html_response(body, 200)
   response.status
   |> should.equal(200)
···
 }
 
 pub fn html_body_test() {
-  let body = string_builder.from_string("Hello, world!")
+  let body = string_tree.from_string("Hello, world!")
   let response =
     wisp.method_not_allowed([http.Get])
     |> wisp.html_body(body)
···
     list.key_find(request.headers, "x-original-method")
     |> should.equal(header)
 
-    string_builder.from_string("Hello!")
+    string_tree.from_string("Hello!")
     |> wisp.html_response(201)
   }
 
···
   |> should.equal(Response(
     201,
     [#("content-type", "text/html; charset=utf-8")],
-    wisp.Text(string_builder.from_string("Hello!")),
+    wisp.Text(string_tree.from_string("Hello!")),
   ))
 
   testing.get("/", [])
···
   |> should.equal(Response(
     200,
     [],
-    wisp.Text(string_builder.from_string("Hello, world!")),
+    wisp.Text(string_tree.from_string("Hello, world!")),
   ))
 }
 
-pub fn string_builder_body_test() {
+pub fn string_tree_body_test() {
   wisp.ok()
-  |> wisp.string_builder_body(string_builder.from_string("Hello, world!"))
+  |> wisp.string_tree_body(string_tree.from_string("Hello, world!"))
   |> should.equal(Response(
     200,
     [],
-    wisp.Text(string_builder.from_string("Hello, world!")),
+    wisp.Text(string_tree.from_string("Hello, world!")),
   ))
 }
 
 pub fn json_body_test() {
   wisp.ok()
-  |> wisp.json_body(string_builder.from_string("{\"one\":1,\"two\":2}"))
+  |> wisp.json_body(string_tree.from_string("{\"one\":1,\"two\":2}"))
   |> should.equal(Response(
     200,
     [#("content-type", "application/json; charset=utf-8")],
-    wisp.Text(string_builder.from_string("{\"one\":1,\"two\":2}")),
+    wisp.Text(string_tree.from_string("{\"one\":1,\"two\":2}")),
   ))
 }