feat: separe linguify into linguify and linguify-raw (#32)

* feat: separe linguify into linguify and linguify-raw

* fix: formatting

* fix: add arguments to the linguify functions and fix tests accordingly

* formatting: remove ) and fix fluent tests formatting

---------

Co-authored-by: ImTrisha <imtrisha@randomdevs.org>

Author: im-trisha

manual.pdf

@@ -1,3 +1,3 @@
-#import "linguify.typ" as lflib: set-database, reset-database, database-at, linguify
+#import "linguify.typ" as lflib: database-at, linguify, linguify-raw, reset-database, set-database
 #import "fluent.typ": load-ftl-data
 #import "utils.typ" as utils: if-auto-then

src/lib.typ

@@ -182,22 +182,20 @@
 
     // if the key is not found in the fallback language
 
-    error-message = error-message + " Also, the fallback language `" + fallback-lang + "` does not contain the key `" + key + "`."
-
+    error-message += " Also, the fallback language `" + fallback-lang + "` does not contain the key `" + key + "`."
   } else {
     // if no fallback language is set
-    error-message = error-message + " Also, no fallback language is set."
+    error-message += " Also, no fallback language is set."
   }
 
   return error(error-message)
 }
 
-
 /// fetch a string in the required language.
-/// provides context for `_linguify` function which implements the logic part.
+/// must have a context beforehand to access the global database/lang
 ///
 /// -> content
-#let linguify(
+#let linguify-raw(
   /// The key at which to retrieve the item.
   /// -> string
   key,
@@ -212,19 +210,32 @@
   default: auto,
   args: auto,
 ) = {
-  let impl() = {
-    let result = _linguify(key, from: from, lang: lang, args: args)
-    if is-ok(result) {
-      result.ok
-    } else {
-      if-auto-then(default, () => panic(result.error))
-    }
-  }
-
-  if from == auto or lang == auto {
-    // context is needed to use the default database or current language
-    context impl()
+  let result = _linguify(key, from: from, lang: lang, args: args)
+  if is-ok(result) {
+    result.ok
   } else {
-    impl()
+    if-auto-then(default, () => panic(result.error))
   }
 }
+
+/// fetch a string in the required language.
+/// provides context for `linguify-raw` function.
+///
+/// -> content
+#let linguify(
+  /// The key at which to retrieve the item.
+  /// -> string
+  key,
+  /// database to fetch the item from. If auto linguify's global database will used.
+  /// -> dictionary
+  from: auto,
+  /// the language to look for, if auto use `context text.lang` (default)
+  /// -> string
+  lang: auto,
+  /// A default value to return if the key is not part of the database.
+  /// -> any
+  default: auto,
+  args: auto,
+) = {
+  context linguify-raw(key, from: from, lang: lang, default: default, args: args)
+}

src/linguify.typ

@@ -4,14 +4,19 @@
 
 #set-database(data)
 
-// Database and language are known: string
-#assert.eq(type(linguify("apple", from: data, lang: "en")), str)
+// Database and language are known, so we dont have to provide the context
+#assert.eq(type(linguify-raw("apple", from: data, lang: "en")), str)
 
-// Only database known: content (context)
-#assert.eq(type(linguify("apple", from: data)), content)
+// Only database known, so we have to provide context
+#context assert.eq(type(linguify-raw("apple", from: data)), str)
 
-// Only language known: content (context)
-#assert.eq(type(linguify("apple", lang: "en")), content)
+// Only language known, so we have to provide context
+#context assert.eq(type(linguify-raw("apple", lang: "en")), str)
 
-// Neither known: content (context)
-#assert.eq(type(linguify("apple")), content)
+// Assert that without context and without any of `lang` or `from`, the function panics.
+
+#assert-panic(() => linguify-raw("apple"))
+
+#assert-panic(() => linguify-raw("apple", from: data))
+
+#assert-panic(() => linguify-raw("apple", lang: "en"))

tests/context-free/test.typ

@@ -1,4 +1,5 @@
 // #include "fluent-test/test.typ"
+
 #import "/src/lib.typ": *
 
 #let de = smallcaps("DE:")

tests/fluent/test.typ

@@ -6,4 +6,4 @@
 #outline()
 
 = red
-green
+green

tests/outline-location/ref.typ

@@ -20,4 +20,4 @@
 // This key is NOT found in the header!
 = #linguify("red")
 // This key IS found in regular text
-#linguify("green")
+#linguify("green")

tests/outline-location/test.typ

@@ -4,7 +4,7 @@
 
 #let test-data = {
   assert(db != none)
-  assert(db.at("lang", default: none) != none )
+  assert(db.at("lang", default: none) != none)
 
   set-database(db)
   reset-database()
@@ -46,15 +46,15 @@
   set text(lang: "en")
   context {
     assert(_linguify("apple", from: db) == ok("Apple"))
-    assert(_linguify("pear", from: db)== ok("Pear"))
-    assert(_linguify("banana", from: db) == ok("Banana" ))
+    assert(_linguify("pear", from: db) == ok("Pear"))
+    assert(_linguify("banana", from: db) == ok("Banana"))
 
     assert(_linguify("red", from: db) == ok("red"))
     assert(_linguify("green", from: db) == ok("green"))
     assert(_linguify("yellow", from: db) == ok("yellow"))
 
     assert(is-error(_linguify("test", from: db)))
-   }
+  }
 
   // German (de)
   set text(lang: "de")
@@ -91,26 +91,26 @@
 
 #let test-_linguify-auto-db = {
   set-database(db)
-    // English (en)
+  // English (en)
   set text(lang: "en")
   context {
     assert(_linguify("apple") == ok("Apple"))
-    assert(_linguify("pear")== ok("Pear"))
+    assert(_linguify("pear") == ok("Pear"))
     assert(_linguify("banana") == ok("Banana"))
 
     assert(_linguify("red") == ok("red"))
     assert(_linguify("green") == ok("green"))
     assert(_linguify("yellow") == ok("yellow"))
 
     assert(is-error(_linguify("test")))
-   }
+  }
 
   // German (de)
   set text(lang: "de")
   context {
     assert(_linguify("apple") == ok("Apfel"))
     assert(_linguify("pear") == ok("Birne"))
-    assert(_linguify("banana") == ok("Banane") )
+    assert(_linguify("banana") == ok("Banane"))
 
     // keys not inside db - will fallback to en
     assert(_linguify("red") == ok("red"))
@@ -125,7 +125,7 @@
   context {
     assert(_linguify("apple") == ok("Apple"))
     assert(_linguify("pear") == ok("Pear"))
-    assert(_linguify("banana") == ok("Banana") )
+    assert(_linguify("banana") == ok("Banana"))
 
     assert(_linguify("red") == ok("red"))
     assert(_linguify("green") == ok("green"))
@@ -139,7 +139,7 @@
 
 #let test-args-in-dict-mode = {
   context {
-    assert(_linguify("apple") ==  ok("Apple"))
+    assert(_linguify("apple") == ok("Apple"))
     assert(is-error(_linguify("apple", args: (name: "test"))))
     assert(is-error(_linguify("apple", args: none)))
     assert(is-error(_linguify("apple", args: (:))))
@@ -151,7 +151,7 @@
 }
 
 #let test-linguify-default = {
-  assert.eq(linguify("test", from: db, lang: "en", default: "x"), "x")
+  assert.eq(linguify-raw("test", from: db, lang: "en", default: "x"), "x")
 
   [run `test-linguify-default` successfully]
 }