move things around a bit, rename

Author: dropwhile

README.md

@@ -1,20 +1,20 @@
-# gbase32
+# gbase32_clockwork
 
-[![Package Version](https://img.shields.io/hexpm/v/gbase32)](https://hex.pm/packages/gbase32)
-[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/gbase32/)
+[![Package Version](https://img.shields.io/hexpm/v/gbase32_clockwork)](https://hex.pm/packages/gbase32_clockwork)
+[![Hex Docs](https://img.shields.io/badge/hex-docs-ffaff3)](https://hexdocs.pm/gbase32_clockwork/)
 
 ```sh
-gleam add gbase32
+gleam add gbase32_clockwork
 ```
 ```gleam
-import gbase32
+import gbase32_clockwork
 
 pub fn main() {
   // TODO: An example of the project in use
 }
 ```
 
-Further documentation can be found at <https://hexdocs.pm/gbase32>.
+Further documentation can be found at <https://hexdocs.pm/gbase32_clockwork>.
 
 ## Development
 

gleam.toml

@@ -1,4 +1,4 @@
-name = "gbase32"
+name = "gbase32_clockwork"
 version = "1.0.0"
 gleam = ">= 0.32.0"
 
@@ -15,7 +15,6 @@ gleam = ">= 0.32.0"
 
 [dependencies]
 gleam_stdlib = "~> 0.34 or ~> 1.0"
-glearray = "~> 0.2"
 
 [dev-dependencies]
 gleeunit = "~> 1.0"

manifest.toml

@@ -3,11 +3,9 @@
 
 packages = [
   { name = "gleam_stdlib", version = "0.36.0", build_tools = ["gleam"], requirements = [], otp_app = "gleam_stdlib", source = "hex", outer_checksum = "C0D14D807FEC6F8A08A7C9EF8DFDE6AE5C10E40E21325B2B29365965D82EB3D4" },
-  { name = "glearray", version = "0.2.1", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "glearray", source = "hex", outer_checksum = "908154F695D330E06A37FAB2C04119E8F315D643206F8F32B6A6C14A8709FFF4" },
   { name = "gleeunit", version = "1.0.2", build_tools = ["gleam"], requirements = ["gleam_stdlib"], otp_app = "gleeunit", source = "hex", outer_checksum = "D364C87AFEB26BDB4FB8A5ABDE67D635DC9FA52D6AB68416044C35B096C6882D" },
 ]
 
 [requirements]
 gleam_stdlib = { version = "~> 0.34 or ~> 1.0" }
-glearray = { version = "~> 0.2"}
 gleeunit = { version = "~> 1.0" }

src/gbase32/codebook.gleam

@@ -1,31 +1,35 @@
 import gleam/string
 import gleam/iterator.{Next}
-import gleam/dict
 import gleam/list
-import gbase32/codebook.{
-  type CodeBook, type DecodeBook, type EncodeBook, type Options, CodeBook,
-  Lowercase,
+import gleam/dict
+import gbase32_clockwork/encoder.{decode, encode}
+import gbase32_clockwork/options.{type Options, Lowercase}
+import gbase32_clockwork/codebook.{
+  type CodeBook, type DecodeBook, type DecodeFn, type EncodeBook, type EncodeFn,
+  CodeBook,
 }
 
-pub const clockwork = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
+const clockwork_codebook = "0123456789abcdefghjkmnpqrstvwxyz"
 
 pub fn new(options options: List(Options)) -> CodeBook {
   let clockwork_case = case list.contains(options, Lowercase) {
     True ->
-      clockwork
+      clockwork_codebook
       |> string.lowercase
-    False -> clockwork
+    False ->
+      clockwork_codebook
+      |> string.uppercase
   }
 
-  let encoder: EncodeBook =
+  let encodebook: EncodeBook =
     clockwork_case
     |> string.to_graphemes()
     |> iterator.from_list()
     |> iterator.transform(0, fn(i, el) { Next(#(i, el), i + 1) })
     |> iterator.to_list()
     |> dict.from_list()
 
-  let decoder_lower: DecodeBook =
+  let decodebook_lower: DecodeBook =
     clockwork_case
     |> string.lowercase()
     |> string.to_graphemes()
@@ -34,8 +38,8 @@ pub fn new(options options: List(Options)) -> CodeBook {
     |> iterator.to_list()
     |> dict.from_list()
 
-  let decoder_upper: DecodeBook =
-    clockwork
+  let decodebook_upper: DecodeBook =
+    clockwork_codebook
     |> string.uppercase()
     |> string.to_graphemes()
     |> iterator.from_list()
@@ -44,7 +48,7 @@ pub fn new(options options: List(Options)) -> CodeBook {
     |> dict.from_list()
 
   // add aliases
-  let decoder_updates =
+  let decodebook_updates =
     dict.from_list([
       #("O", 0),
       #("o", 0),
@@ -54,10 +58,13 @@ pub fn new(options options: List(Options)) -> CodeBook {
       #("l", 1),
     ])
 
-  let decoder =
-    decoder_lower
-    |> dict.merge(decoder_upper)
-    |> dict.merge(decoder_updates)
+  let decodebook =
+    decodebook_lower
+    |> dict.merge(decodebook_upper)
+    |> dict.merge(decodebook_updates)
+
+  let encode_fn: EncodeFn = encode(encodebook, _)
+  let decode_fn: DecodeFn = decode(decodebook, _)
 
-  CodeBook(encoder: encoder, decoder: decoder, options: options)
+  CodeBook(encode: encode_fn, decode: decode_fn, options: options)
 }

src/gbase32/clockwork.gleam src/gbase32_clockwork.gleamsrc/gbase32/clockwork.gleam renamed to src/gbase32_clockwork.gleam

@@ -0,0 +1,18 @@
+import gleam/dict.{type Dict}
+import gbase32_clockwork/options.{type Options}
+
+pub type EncodeBook =
+  Dict(Int, String)
+
+pub type DecodeBook =
+  Dict(String, Int)
+
+pub type EncodeFn =
+  fn(String) -> Result(String, String)
+
+pub type DecodeFn =
+  fn(String) -> Result(String, String)
+
+pub type CodeBook {
+  CodeBook(encode: EncodeFn, decode: DecodeFn, options: List(Options))
+}

src/gbase32_clockwork/codebook.gleam

@@ -5,21 +5,21 @@ import gleam/int.{bitwise_shift_left}
 import gleam/list
 import gleam/result
 import gleam/string
-import gbase32/codebook.{type CodeBook}
+import gbase32_clockwork/codebook.{type DecodeBook, type EncodeBook}
 
-fn to_symbol(c: Int, codebook: CodeBook) -> Result(String, String) {
-  dict.get(codebook.encoder, c)
+fn to_symbol(c: Int, codebook: EncodeBook) -> Result(String, String) {
+  dict.get(codebook, c)
   |> result.map_error(fn(_) { "Encoding outside range" })
 }
 
-fn from_symbol(sym: String, codebook: CodeBook) -> Result(Int, String) {
+fn from_symbol(sym: String, codebook: DecodeBook) -> Result(Int, String) {
   sym
-  |> dict.get(codebook.decoder, _)
+  |> dict.get(codebook, _)
   |> result.map_error(fn(_) { "Encoding outside range" })
 }
 
 fn encode_rec(
-  codebook: CodeBook,
+  codebook: EncodeBook,
   input: BitArray,
   acc: Result(BytesBuilder, String),
 ) -> Result(BytesBuilder, String) {
@@ -71,7 +71,7 @@ fn encode_rec(
 }
 
 fn decode_rec(
-  codebook: CodeBook,
+  codebook: DecodeBook,
   input: List(String),
   counter: Int,
   acc: Result(BytesBuilder, String),
@@ -105,7 +105,7 @@ fn decode_rec(
   }
 }
 
-pub fn encode(codebook: CodeBook, input: String) -> Result(String, String) {
+pub fn encode(codebook: EncodeBook, input: String) -> Result(String, String) {
   let encoded =
     input
     |> bit_array.from_string()
@@ -122,7 +122,7 @@ pub fn encode(codebook: CodeBook, input: String) -> Result(String, String) {
   }
 }
 
-pub fn decode(codebook: CodeBook, input: String) -> Result(String, String) {
+pub fn decode(codebook: DecodeBook, input: String) -> Result(String, String) {
   let decoded =
     input
     |> string.trim()

src/gbase32.gleam src/gbase32_clockwork/encoder.gleamsrc/gbase32.gleam renamed to src/gbase32_clockwork/encoder.gleam

@@ -0,0 +1,4 @@
+pub type Options {
+  WithPadding
+  Lowercase
+}

src/gbase32_clockwork/options.gleam

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