Merge pull request #6 from massix/feat/configuration

Add configuration

Author: massix

Makefile

@@ -2,8 +2,6 @@ GLEAM := $(shell command -v gleam)
 DOCKER_HUB_REPOSITORY ?= massix86/gleeter
 DOCKER_PLATFORM ?= linux/amd64
 
-.PHONY: test
-
 all: build
 
 .PHONY: deps
@@ -26,6 +24,10 @@ check-format:
 package: build
 	$(GLEAM) export erlang-shipment
 
+.PHONY: serve
+serve: build
+	GLEETER_DEBUG=1 $(GLEAM) run -- serve 8080 comics
+
 .PHONY: docker
 docker:
 	nix build .#version-file

README.md

@@ -60,6 +60,54 @@ Gleeter understands the following commands:
 *   `id <number>`: Fetches the comic with the specified ID and displays it in the terminal. Replace `<number>` with the desired comic ID.
 *   `serve <port> <base_path>`: Starts a web server to serve the comics. `<port>` is optional and defaults to 8080. `<base_path>` is also optional and defaults to "". For example, `gleeter serve 3000 /comics` will start the server on port 3000 and serve the comics under the `/comics` path.
 
+## Configuration File
+
+Gleeter uses a TOML configuration file to customize its behavior. The configuration file allows you to configure the starting comic for random mode, set screen dimensions, and define aliases for comic IDs.
+
+### Syntax
+
+Here's an example configuration file (based on `test_data/config.toml`):
+
+```toml
+random_start = 38
+
+[screen]
+max_cols = 80
+max_lines = 23
+
+[[alias]]
+name = "bobbytables"
+type = "id"
+id = 987
+
+[[alias]]
+name = "rnd"
+type = "random"
+
+[[alias]]
+name = "l"
+type = "latest"
+```
+
+### Structure and Usage
+
+The configuration file is loaded when Gleeter starts. Gleeter looks for the configuration file in `$XDG_CONFIG_HOME/gleeter/config.toml` or `$HOME/.config/gleeter/config.toml`. If neither of these is found, it uses `./config.toml`.  The settings defined in the file are used to initialize the application and control its behavior.
+
+*   **`random_start`**: Specifies the starting comic number for the random comic selection. If not specified, a default value is used.
+
+*   **`[screen]`**: This section configures the screen dimensions for displaying comics.
+    *   `max_cols`: Specifies the maximum number of columns to use for displaying the comic.
+    *   `max_lines`: Specifies the maximum number of lines to use for displaying the comic.
+
+*   **`[[alias]]`**: This section defines aliases for accessing comics. You can define multiple aliases.
+    *   `name`: The name of the alias.
+    *   `type`: The type of alias. Valid values are `"id"`, `"random"`, and `"latest"`.
+    *   `id`: (Only required for `"id"` aliases) The comic ID to associate with the alias.
+
+The `src/gleeter/config.gleam` file defines the structure of the configuration data and how it is parsed from the TOML file.
+
+To modify Gleeter's behavior, simply edit the configuration file and restart the application.
+
 ### Serve mode details
 
 When Gleeter is run in `serve` mode, it starts an HTTP server that exposes the following endpoints:
@@ -78,6 +126,26 @@ You can customize the base path for these endpoints by using the `<base_path>` a
 
 Gleeter also supports receiving the terminal size via HTTP headers. You can send the `X-TERMINAL-COLUMNS` and `X-TERMINAL-ROWS` headers with your request to specify the terminal size. This allows Gleeter to properly format the comic for your terminal. If these headers are not provided, Gleeter will use a default terminal size. Please be aware that for the resizing to work, you need to send **both** headers.
 
+On top of that, Serve mode will also honour all the aliases defined in the [configuration file](#configuration-file), and expose them all at the root of the `base_path`. As a quick example, imagine you have the following defined in the `config.toml` file:
+```toml
+[[alias]]
+name = "bobbytables"
+type = "id"
+id = 987
+
+[[alias]]
+name = "rnd"
+type = "random"
+
+[[alias]]
+name = "l"
+type = "latest"
+```
+
+And you start the server with `gleeter serve 8080 /comics`, on top of the URLs mentioned above, you will also get the following:
+*   `/comics/bobbytables`, which will be an alias for `/comics/id/987`
+*   `/comics/rnd`, which will be an alias for `/comics/random`
+*   `/comics/l`, which will be an alias for `/comics/latest`
 
 ## How to install
 

flake.nix

@@ -10,7 +10,7 @@
         pkgs = import nixpkgs { inherit system; };
         inherit (pkgs) mkShell;
         gleamPackagesHash = "sha256-DIY9OA3ZigaVC2gxvwgCrF8rjNIraSy7mVqudp62x4M=";
-        version = "1.2.0";
+        version = "1.3.0";
         pname = "gleeter";
         src = ./.;
         gleam-helper = pkgs.callPackage ./nix/gleam-helper.nix { };

gleam.toml

@@ -18,6 +18,7 @@ envoy = ">= 1.0.2 and < 2.0.0"
 term_size = ">= 1.0.1 and < 2.0.0"
 messua = ">= 1.1.1 and < 2.0.0"
 gleam_erlang = ">= 0.34.0 and < 1.0.0"
+tom = ">= 1.1.1 and < 2.0.0"
 
 [dev-dependencies]
 startest = ">= 0.6.0 and < 1.0.0"

manifest.toml

@@ -75,3 +75,4 @@ simplifile = { version = ">= 2.2.1 and < 3.0.0" }
 sqlight = { version = ">= 1.0.1 and < 2.0.0" }
 startest = { version = ">= 0.6.0 and < 1.0.0" }
 term_size = { version = ">= 1.0.1 and < 2.0.0" }
+tom = { version = ">= 1.1.1 and < 2.0.0" }

src/application_behavior.gleam

@@ -1,6 +1,8 @@
 import argv
 import gleam/int
+import gleam/list
 import gleam/result
+import gleeter/config
 
 pub type ApplicationBehavior {
   RandomComic
@@ -11,10 +13,12 @@ pub type ApplicationBehavior {
   Serve(port: Int, base_path: String)
 }
 
-pub fn get_application_behavior() -> ApplicationBehavior {
+pub fn get_application_behavior(
+  cfg: config.Configuration,
+) -> ApplicationBehavior {
   let args = argv.load().arguments
 
-  parse_arguments(args)
+  parse_arguments(args, cfg.aliases)
 }
 
 fn parse_serve(args: List(String)) -> ApplicationBehavior {
@@ -31,19 +35,33 @@ fn parse_serve(args: List(String)) -> ApplicationBehavior {
   }
 }
 
-pub fn parse_arguments(args: List(String)) -> ApplicationBehavior {
+pub fn parse_arguments(
+  args: List(String),
+  aliases: List(config.Alias),
+) -> ApplicationBehavior {
   case args {
-    [] | ["help", ..] -> Help
-    ["version", ..] -> PrintVersion
+    [] | ["help", ..] | ["--help", ..] -> Help
+    ["version", ..] | ["--version", ..] -> PrintVersion
     ["random", ..] -> RandomComic
     ["latest", ..] -> LatestComic
     ["id", id, ..] -> {
       case int.parse(id) {
         Ok(id) -> WithIDComic(id)
-        _ -> LatestComic
+        _ -> Help
       }
     }
     ["serve", ..rest] -> parse_serve(rest)
-    _ -> PrintVersion
+    [alias] -> {
+      case list.filter(aliases, fn(x) { x.name == alias }) |> list.first() {
+        Ok(alias) ->
+          case alias {
+            config.IdAlias(_, id) -> WithIDComic(id)
+            config.LatestAlias(_) -> LatestComic
+            config.RandomAlias(_) -> RandomComic
+          }
+        Error(_) -> Help
+      }
+    }
+    _ -> Help
   }
 }

src/gleeter.gleam

@@ -8,6 +8,7 @@ import gleam/io
 import gleam/list
 import gleam/option
 import gleam/result
+import gleeter/config
 import kitty/graphics
 import png
 import serve
@@ -70,14 +71,21 @@ fn get_comic(cache: cache.Cache, id: Int) -> Result(cache.ComicWithData, Nil) {
   }
 }
 
-fn print_comic(cache: cache.Cache, in: PrintComic) -> Result(Nil, Nil) {
+fn print_comic(
+  cache: cache.Cache,
+  config: config.Configuration,
+  in: PrintComic,
+) -> Result(Nil, Nil) {
   use cached_comic <- result.try(case in {
     Latest -> get_comic(cache, 0)
     Random -> {
-      use api.Xkcd(number:, ..) <- result.try(
+      use api.Xkcd(number: highest, ..) <- result.try(
         api.get_latest() |> result.map_error(print_api_error),
       )
-      let random_comic = int.random(number)
+      let random_comic = case config.random_start {
+        option.Some(start) -> int.random(highest - start) + start
+        option.None -> int.random(highest)
+      }
       get_comic(cache, random_comic)
     }
     ID(id) -> get_comic(cache, id)
@@ -87,6 +95,26 @@ fn print_comic(cache: cache.Cache, in: PrintComic) -> Result(Nil, Nil) {
   use image_size <- result.try(png.get_image_size(raw_data))
   let terminal_size = graphics.get_terminal_size()
 
+  // Set new max_cols and max_lines if they were specified in the configuration
+  let terminal_size = case config.max_lines, config.max_cols {
+    option.Some(max_rows), option.Some(max_cols) ->
+      graphics.TerminalSize(
+        int.min(max_rows, terminal_size.rows),
+        int.min(max_cols, terminal_size.columns),
+      )
+    option.Some(max_rows), option.None ->
+      graphics.TerminalSize(
+        int.min(max_rows, terminal_size.rows),
+        terminal_size.columns,
+      )
+    option.None, option.Some(max_cols) ->
+      graphics.TerminalSize(
+        terminal_size.rows,
+        int.min(max_cols, terminal_size.columns),
+      )
+    option.None, option.None -> terminal_size
+  }
+
   let api.Xkcd(publication_date:, title:, alternative_text:, number:, link:, ..) =
     xkcd
   io.print("[" <> int.to_string(number) <> "] ")
@@ -120,12 +148,21 @@ fn print_help() -> Result(Nil, Nil) {
 pub fn main() -> Result(Nil, Nil) {
   let cache = cache.new(cache.get_cache_location())
   let now = birl.now()
-  let r = case application_behavior.get_application_behavior() {
+  let configuration_path = config.get_configuration_file()
+  debug_print("Configuration path: " <> configuration_path)
+
+  let configuration = config.parse(configuration_path)
+
+  let r = case application_behavior.get_application_behavior(configuration) {
     application_behavior.PrintVersion -> print_version()
-    application_behavior.LatestComic -> print_comic(cache, Latest)
-    application_behavior.RandomComic -> print_comic(cache, Random)
-    application_behavior.WithIDComic(id) -> print_comic(cache, ID(id))
-    application_behavior.Serve(p, b) -> serve.serve(p, b, cache) |> Ok
+    application_behavior.LatestComic ->
+      print_comic(cache, configuration, Latest)
+    application_behavior.RandomComic ->
+      print_comic(cache, configuration, Random)
+    application_behavior.WithIDComic(id) ->
+      print_comic(cache, configuration, ID(id))
+    application_behavior.Serve(p, b) ->
+      serve.serve(p, b, cache, configuration) |> Ok
     application_behavior.Help -> print_help()
   }
   let end = birl.now()

src/gleeter/config.gleam

@@ -0,0 +1,118 @@
+import envoy
+import gleam/dict
+import gleam/list
+import gleam/option
+import gleam/result
+import simplifile
+import tom
+
+pub type Configuration {
+  Configuration(
+    random_start: option.Option(Int),
+    max_cols: option.Option(Int),
+    max_lines: option.Option(Int),
+    aliases: List(Alias),
+  )
+}
+
+pub type Alias {
+  IdAlias(name: String, comic_id: Int)
+  LatestAlias(name: String)
+  RandomAlias(name: String)
+}
+
+pub type ConfigFile =
+  String
+
+fn default() -> Configuration {
+  Configuration(
+    random_start: option.None,
+    max_cols: option.None,
+    max_lines: option.None,
+    aliases: [],
+  )
+}
+
+type NextFunction(a) =
+  fn(a) -> Configuration
+
+fn or_default(in: Result(a, b), next: NextFunction(a)) -> Configuration {
+  case in {
+    Ok(a) -> next(a)
+    Error(_) -> default()
+  }
+}
+
+fn or_none(
+  in: Result(a, b),
+  next: NextFunction(option.Option(a)),
+) -> Configuration {
+  case in {
+    Ok(a) -> next(option.Some(a))
+    Error(_) -> next(option.None)
+  }
+}
+
+fn or_empty(
+  in: Result(List(a), b),
+  next: NextFunction(List(a)),
+) -> Configuration {
+  case in {
+    Ok(a) -> next(a)
+    Error(_) -> next([])
+  }
+}
+
+fn parse_alias(in: dict.Dict(String, tom.Toml)) -> option.Option(Alias) {
+  let name = tom.get_string(in, ["name"]) |> option.from_result
+  let alias_type = tom.get_string(in, ["type"]) |> option.from_result
+  let comic_id = tom.get_int(in, ["id"]) |> option.from_result
+
+  case name, alias_type, comic_id {
+    option.Some(name), option.Some("id"), option.Some(comic_id) -> {
+      IdAlias(name, comic_id) |> option.Some
+    }
+    option.Some(name), option.Some("latest"), _ -> {
+      LatestAlias(name) |> option.Some
+    }
+    option.Some(name), option.Some("random"), _ -> {
+      RandomAlias(name) |> option.Some
+    }
+    _, _, _ -> option.None
+  }
+}
+
+pub fn get_configuration_file() -> ConfigFile {
+  let assert Ok(path) =
+    envoy.get("XDG_CONFIG_HOME")
+    |> result.or(envoy.get("HOME") |> result.map(fn(s) { s <> "/.config" }))
+    |> result.or(Ok("."))
+
+  path <> "/gleeter/config.toml"
+}
+
+pub fn parse(in: ConfigFile) -> Configuration {
+  use file_content <- or_default(simplifile.read(in))
+  use parsed <- or_default(tom.parse(file_content))
+
+  use random_start <- or_none(tom.get_int(parsed, ["random_start"]))
+  use max_cols <- or_none(tom.get_int(parsed, ["screen", "max_cols"]))
+  use max_lines <- or_none(tom.get_int(parsed, ["screen", "max_lines"]))
+
+  use aliases <- or_empty(tom.get_array(parsed, ["alias"]))
+  let aliases =
+    list.map(aliases, fn(alias) {
+      case tom.as_table(alias) {
+        Ok(alias) -> parse_alias(alias)
+        Error(_) -> option.None
+      }
+    })
+    |> list.filter(option.is_some)
+    |> list.map(fn(s) {
+      // We are pretty sure this cannot fail
+      let assert option.Some(alias) = s
+      alias
+    })
+
+  Configuration(random_start, max_cols, max_lines, aliases)
+}