koatl 0.3.19__tar.gz → 0.3.20__tar.gz

{koatl-0.3.19 → koatl-0.3.20}/Cargo.lock

@@ -190,7 +190,7 @@ checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
 
 [[package]]
 name = "koatl"
-version = "0.3.19"
+version = "0.3.20"
 dependencies = [
  "ariadne",
  "koatl-core",

{koatl-0.3.19 → koatl-0.3.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: koatl
-Version: 0.3.19
+Version: 0.3.20
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{koatl-0.3.19 → koatl-0.3.20}/koatl/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "koatl"
-version = "0.3.19"
+version = "0.3.20"
 edition = "2021"
 homepage = "https://koatl.org"
 

{koatl-0.3.19 → koatl-0.3.20}/koatl/src/emit_py.rs

@@ -708,11 +708,17 @@ impl<'src> PyExprExt<'src> for SPyExpr<'src> {
                         PyFstrPart::Str(s) => {
                             values.push(ctx.ast_node("Constant", (s.as_ref(),), &self.tl_span)?);
                         }
-                        PyFstrPart::Expr(expr, _format_spec) => {
+                        PyFstrPart::Expr(expr, format_spec) => {
                             let expr_ast = expr.emit_py(ctx)?;
+                            let format_spec_ast = if let Some(spec) = format_spec {
+                                spec.emit_py(ctx)?
+                            } else {
+                                ctx.py.None()
+                            };
+
                             values.push(ctx.ast_node(
                                 "FormattedValue",
-                                (expr_ast, -1, ctx.py.None()),
+                                (expr_ast, -1, format_spec_ast),
                                 &self.tl_span,
                             )?);
                         }

koatl-0.3.20/koatl/tests/e2e/base/fstr.tl

@@ -0,0 +1,51 @@
+import util.assert_eq
+
+assert_eq(f"{1}", "1")
+
+x = 1
+
+fstr = f"x = {x + 1}"
+assert_eq(fstr, "x = 2")
+
+fstr = f"x = {(y => y)(x)}"
+assert_eq(fstr, "x = 1")
+
+fstr = f"={(
+    let a = 1
+    let b = 2
+    let c = 3
+    a * b * c
+)}="
+assert_eq(fstr, "=6=")
+
+assert_eq(f"{{}}", "{}")
+assert_eq(f"{{{1}}}", "{1}")
+
+assert_eq(f"""
+
+{{1}}
+{2 * 5}""", "\n\n{1}\n10")
+
+# Test format specifiers
+num = 42
+assert_eq(f"{num%d}", "42")
+assert_eq(f"{num%05d}", "00042")
+assert_eq(f"{num%>5d}", "   42")
+assert_eq(f"{num%<5d}", "42   ")
+assert_eq(f"{num%^5d}", " 42  ")
+
+pi = 3.14159
+assert_eq(f"{pi%.2f}", "3.14")
+assert_eq(f"{pi%.4f}", "3.1416")
+
+hex_num = 255
+assert_eq(f"{hex_num%x}", "ff")
+assert_eq(f"{hex_num%X}", "FF")
+assert_eq(f"{hex_num%#x}", "0xff")
+
+# Test multiple format specs in one string
+assert_eq(f"{num%05d} and {pi%.2f}", "00042 and 3.14")
+
+# Test format spec with expressions
+assert_eq(f"{1 + 1%d}", "2")
+assert_eq(f"{(10 * 5)%03d}", "050")

{koatl-0.3.19 → koatl-0.3.20}/koatl-parser/src/lexer.rs

@@ -970,9 +970,11 @@ impl<'src> TokenizeCtx<'src> {
                 seen_quotes += 1;
 
                 if seen_quotes == ending_char_count {
-                    let span = self.span_since(&marker);
+                    // Use ending_marker for the span/slice end position, not current cursor,
+                    // because we may have consumed some ending quotes already
+                    let span = Span::new(marker..ending_marker);
                     tokens.push(SToken::new(
-                        Token::FstrInner(self.slice_since(&marker), current_str),
+                        Token::FstrInner(&self.input[marker..ending_marker], current_str),
                         span,
                         Vec::new(),
                     ));

koatl-0.3.19/koatl/tests/e2e/base/fstr.tl

@@ -1,27 +0,0 @@
-import util.assert_eq
-
-assert_eq(f"{1}", "1")
-
-x = 1
-
-fstr = f"x = {x+1}"
-assert_eq(fstr, "x = 2")
-
-fstr = f"x = {(y => y)(x)}"
-assert_eq(fstr, "x = 1")
-
-fstr = f"={(
-    let a = 1
-    let b = 2
-    let c = 3
-    a * b * c
-)}="
-assert_eq(fstr, "=6=")
-
-assert_eq(f"{{}}", "{}")
-assert_eq(f"{{{1}}}", "{1}")
-
-assert_eq(f"""
-
-{{1}}
-{2 * 5}""", "\n\n{1}\n10")