Record input from user in PFFTT file

src/parsing/checks/parser.rs

@@ -2647,3 +2647,34 @@ This is { exec(a,
         _ => panic!("Third element should be text"),
     }
 }
+
+#[test]
+fn code_inline_binding() {
+    let mut input = Parser::new();
+    input.initialize("inspect { item } ~ seen\n");
+    let paragraphs = input
+        .read_descriptive()
+        .unwrap();
+
+    let descriptives = &paragraphs[0].0;
+    assert_eq!(descriptives.len(), 2);
+
+    match &descriptives[0] {
+        Descriptive::Text(text) => assert_eq!(*text, "inspect"),
+        _ => panic!("First element should be text"),
+    }
+
+    match &descriptives[1] {
+        Descriptive::Binding(bound, names) => {
+            match bound.as_ref() {
+                Descriptive::CodeInline(Expression::Variable(Identifier { value, .. }, _)) => {
+                    assert_eq!(*value, "item")
+                }
+                _ => panic!("Bound part should be a code inline variable"),
+            }
+            assert_eq!(names.len(), 1);
+            assert_eq!(names[0].value, "seen");
+        }
+        _ => panic!("Second element should be a binding"),
+    }
+}

src/parsing/parser.rs

@@ -2402,11 +2402,40 @@ impl<'i> Parser<'i> {
 
                                 if c == '{' {
                                     let expressions = parser.read_code_block()?;
+                                    let mut inlines = vec![];
                                     for expr in expressions {
                                         if let Expression::Separator = expr {
                                             continue;
                                         }
-                                        content.push(Descriptive::CodeInline(expr));
+                                        inlines.push(Descriptive::CodeInline(expr));
+                                    }
+
+                                    parser.trim_whitespace();
+                                    if parser.peek_next_char() == Some('~') {
+                                        parser.advance(1);
+                                        parser.trim_whitespace();
+                                        let start_pos = parser.offset;
+                                        let variable = parser.read_identifier()?;
+
+                                        parser.trim_whitespace();
+                                        if parser
+                                            .source
+                                            .starts_with(',')
+                                        {
+                                            return Err(ParsingError::MissingParenthesis(
+                                                Span::new(start_pos, 0),
+                                            ));
+                                        }
+
+                                        if let Some(last) = inlines.pop() {
+                                            content.extend(inlines);
+                                            content.push(Descriptive::Binding(
+                                                Box::new(last),
+                                                vec![variable],
+                                            ));
+                                        }
+                                    } else {
+                                        content.extend(inlines);
                                     }
                                 } else if parser
                                     .source