simplify interfaces

Author: dropwhile

README.md

@@ -17,20 +17,30 @@ Inspired by [shiguredo/base32_clockwork][1] and [this gist][2].
 gleam add gbase32_clockwork
 ```
 ```gleam
-import gbase32_clockwork
-import gbase32_clockwork/options.{Lowercase}
+import gbase32_clockwork/gbase32
+import gleam/result
+import gleam/string
+import gleeunit/should
 
 pub fn main() {
-  let codebook = gbase32_clockwork.new([])
+  // create a reusable encoder
+  let encode = gbase32.new_encoder()
+  
+  // by default, lowercase is emitted
+  encode("foobar")
+  |> should.equal(Ok("csqpyrk1e8"))
 
-  codebook.encode("foobar")
+  // to emit as uppercase, simply uppercase the output string
+  encode("foobar")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("CSQPYRK1E8"))
 
-  // to emit as lowercase
-  let codebook_lc = gbase32_clockwork.new([Lowercase])
-  
-  codebook.encode("foobar")
-  |> should.equal(Ok("csqpyrk1e8"))
+  // create a reusable encoder
+  let decode = gbase32.new_encoder()
+
+  // a decoder will decode both upper and lowercase
+  decode("CSQPYRG")
+  |> should.equal(Ok("foob"))
 }
 ```
 

gleam.toml

@@ -1,5 +1,5 @@
 name = "gbase32_clockwork"
-version = "1.0.0"
+version = "2.0.0"
 gleam = ">= 0.32.0"
 
 description = "base32 clockwork in gleam"

manifest.toml

@@ -2,8 +2,8 @@
 # You typically do not need to edit this file
 
 packages = [
-  { name = "gleam_stdlib", version = "0.38.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "663CF11861179AF415A625307447775C09404E752FF99A24E2057C835319F1BE" },
-  { name = "gleeunit", version = "1.1.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "72CDC3D3F719478F26C4E2C5FED3E657AC81EC14A47D2D2DEBB8693CA3220C3B" },
+  { name = "gleam_stdlib", version = "0.40.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "86606B75A600BBD05E539EB59FABC6E307EEEA7B1E5865AFB6D980A93BCB2181" },
+  { name = "gleeunit", version = "1.2.0", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "F7A7228925D3EE7D0813C922E062BFD6D7E9310F0BEE585D3A42F3307E3CFD13" },
 ]
 
 [requirements]

src/gbase32_clockwork.gleam

@@ -1,12 +1,60 @@
-import gbase32_clockwork/codebook.{type DecodeBook, type EncodeBook}
 import gleam/bit_array
 import gleam/bytes_builder.{type BytesBuilder}
-import gleam/dict
+import gleam/dict.{type Dict}
 import gleam/int.{bitwise_shift_left}
 import gleam/list
 import gleam/result
 import gleam/string
 
+const clockwork_codebook = "0123456789abcdefghjkmnpqrstvwxyz"
+
+type EncodeBook =
+  Dict(Int, String)
+
+type DecodeBook =
+  Dict(String, Int)
+
+pub type EncodeFn =
+  fn(String) -> Result(String, String)
+
+pub type DecodeFn =
+  fn(String) -> Result(String, String)
+
+/// Create a new encoder that can be be reused to encode strings in base32 clockwork
+///
+pub fn new_encoder() -> EncodeFn {
+  let encodebook: EncodeBook =
+    clockwork_codebook
+    |> string.to_graphemes()
+    |> list.index_map(fn(x, i) { #(i, x) })
+    |> dict.from_list()
+
+  encode(encodebook, _)
+}
+
+/// Create a new decoder that can be be reused to decode strings from base32 clockwork
+///
+pub fn new_decoder() -> DecodeFn {
+  let decodebook: DecodeBook =
+    clockwork_codebook
+    |> string.to_graphemes()
+    |> list.index_map(fn(x, i) { #(x, i) })
+    |> dict.from_list()
+    |> dict.merge(
+      // add some aliases to help decode user entry errors
+      dict.from_list([
+        #("O", 0),
+        #("o", 0),
+        #("I", 1),
+        #("i", 1),
+        #("L", 1),
+        #("l", 1),
+      ]),
+    )
+
+  decode(decodebook, _)
+}
+
 fn to_symbol(c: Int, codebook: EncodeBook) -> Result(String, String) {
   dict.get(codebook, c)
   |> result.map_error(fn(_) { "Encoding outside range" })
@@ -105,7 +153,7 @@ fn decode_rec(
   }
 }
 
-pub fn encode(codebook: EncodeBook, input: String) -> Result(String, String) {
+fn encode(codebook: EncodeBook, input: String) -> Result(String, String) {
   let encoded =
     input
     |> bit_array.from_string()
@@ -122,10 +170,11 @@ pub fn encode(codebook: EncodeBook, input: String) -> Result(String, String) {
   }
 }
 
-pub fn decode(codebook: DecodeBook, input: String) -> Result(String, String) {
+fn decode(codebook: DecodeBook, input: String) -> Result(String, String) {
   let decoded =
     input
     |> string.trim()
+    |> string.lowercase
     |> string.to_graphemes()
     |> list.filter(fn(x) { x != "=" })
     |> decode_rec(codebook, _, 0, Ok(bytes_builder.new()))

src/gbase32_clockwork/codebook.gleam

@@ -1,5 +1,6 @@
-import gbase32_clockwork
-import gbase32_clockwork/options.{Lowercase}
+import gbase32_clockwork/gbase32
+import gleam/result
+import gleam/string
 import gleeunit
 import gleeunit/should
 
@@ -8,106 +9,113 @@ pub fn main() {
 }
 
 pub fn encode_uppercase_test() {
-  let codebook = gbase32_clockwork.new([])
+  let encode = gbase32.new_encoder()
 
-  codebook.encode("")
+  encode("")
   |> should.equal(Ok(""))
 
-  codebook.encode("f")
+  encode("f")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("CR"))
 
-  codebook.encode("fo")
+  encode("fo")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("CSQG"))
 
-  codebook.encode("foo")
+  encode("foo")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("CSQPY"))
 
-  codebook.encode("foob")
+  encode("foob")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("CSQPYRG"))
 
-  codebook.encode("fooba")
+  encode("fooba")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("CSQPYRK1"))
 
-  codebook.encode("foobar")
+  encode("foobar")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("CSQPYRK1E8"))
 
-  codebook.encode("Wow, it works!")
+  encode("Wow, it works!")
+  |> result.map(string.uppercase)
   |> should.equal(Ok("AXQQEB10D5T20XVFE9NQ688"))
 }
 
 pub fn encode_lowercase_test() {
-  let codebook = gbase32_clockwork.new([Lowercase])
+  let encode = gbase32.new_encoder()
 
-  codebook.encode("")
+  encode("")
   |> should.equal(Ok(""))
 
-  codebook.encode("f")
+  encode("f")
   |> should.equal(Ok("cr"))
 
-  codebook.encode("fo")
+  encode("fo")
   |> should.equal(Ok("csqg"))
 
-  codebook.encode("foo")
+  encode("foo")
   |> should.equal(Ok("csqpy"))
 
-  codebook.encode("foob")
+  encode("foob")
   |> should.equal(Ok("csqpyrg"))
 
-  codebook.encode("fooba")
+  encode("fooba")
   |> should.equal(Ok("csqpyrk1"))
 
-  codebook.encode("foobar")
+  encode("foobar")
   |> should.equal(Ok("csqpyrk1e8"))
 
-  codebook.encode("Wow, it works!")
+  encode("Wow, it works!")
   |> should.equal(Ok("axqqeb10d5t20xvfe9nq688"))
 }
 
 pub fn decode_test() {
-  let codebook = gbase32_clockwork.new([])
+  let decode = gbase32.new_decoder()
 
-  codebook.decode("")
+  decode("")
   |> should.equal(Ok(""))
 
-  codebook.decode("CR")
+  decode("CR")
   |> should.equal(Ok("f"))
 
-  codebook.decode("CSQG")
+  decode("CSQG")
   |> should.equal(Ok("fo"))
 
-  codebook.decode("CSQPY")
+  decode("CSQPY")
   |> should.equal(Ok("foo"))
 
-  codebook.decode("CSQPYRG")
+  decode("CSQPYRG")
   |> should.equal(Ok("foob"))
 
-  codebook.decode("CSQPYRK1")
+  decode("CSQPYRK1")
   |> should.equal(Ok("fooba"))
 
-  codebook.decode("CSQPYRK1E8")
+  decode("CSQPYRK1E8")
   |> should.equal(Ok("foobar"))
 
-  codebook.decode(" CSQPYRK1E8  ")
+  decode(" CSQPYRK1E8  ")
   |> should.equal(Ok("foobar"))
 
-  codebook.decode("CSQPYRK1E8====")
+  decode("CSQPYRK1E8====")
   |> should.equal(Ok("foobar"))
 
-  codebook.decode(" CSQPYRK1E8==== ")
+  decode(" CSQPYRK1E8==== ")
   |> should.equal(Ok("foobar"))
 
-  codebook.decode("AXQQEB10D5T20XVFE9NQ688")
+  decode("AXQQEB10D5T20XVFE9NQ688")
   |> should.equal(Ok("Wow, it works!"))
 
-  codebook.decode("cSqPy")
+  decode("cSqPy")
   |> should.equal(Ok("foo"))
 
-  codebook.decode("CSQPYRKi")
+  decode("CSQPYRKi")
   |> should.equal(Ok("fooba"))
 
-  codebook.decode("csqpyrk1e8")
+  decode("csqpyrk1e8")
   |> should.equal(Ok("foobar"))
 
-  codebook.decode("C-SQPY")
+  decode("C-SQPY")
   |> should.equal(Error("Encoding outside range"))
 }