Support places in Attribute scopes (#72)

We had the notion of both roles and places in Attributes in Technique
v0, but so far in v1 we'd only implemented role Attributes with the
`@role` notation. This branch adds `^place`, using the caret we're now
using as the marker for place Attributes.

Author: istathar

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "technique"
-version = "0.3.5"
+version = "0.3.6"
 edition = "2021"
 description = "A domain specific language for procedures."
 authors = [ "Andrew Cowie" ]

Cargo.toml

@@ -0,0 +1,30 @@
+% technique v1
+
+making_coffee :
+
+These are the steps.
+
+    1.  First
+        @chef
+            -   First sub task
+            -   Second sub task
+    2.  Second
+        @chef + @barista
+            -   Third sub task
+            -   Fourth sub task
+    3.  Third
+        ^kitchen
+            -   Fifth sub task
+            -   Sixth sub task
+    4.  Four
+        ^kitchen + ^bathroom
+            -   Seventh sub task
+            -   Eighth sub task
+    5.  Five
+        @chef + ^bathroom
+            -   Ninth sub task
+            -   Tenth sub task
+    6.  Six
+        ^kitchen + @barista
+            -   Ninth sub task
+            -   Tenth sub task

examples/golden/ManyAttributes.t

@@ -866,7 +866,7 @@ impl<'i> Formatter<'i> {
                     self.add_fragment_reference(Syntax::Attribute, name.0);
                 }
                 Attribute::Place(name) => {
-                    self.add_fragment_reference(Syntax::Attribute, "#");
+                    self.add_fragment_reference(Syntax::Attribute, "^");
                     self.add_fragment_reference(Syntax::Attribute, name.0);
                 }
             }

src/formatting/formatter.rs

@@ -765,7 +765,7 @@ impl<'i> Parser<'i> {
                     } else if is_code_block(content) {
                         let expression = outer.read_code_block()?;
                         elements.push(Element::CodeBlock(expression));
-                    } else if is_role_assignment(content) {
+                    } else if is_attribute_assignment(content) {
                         let attribute_block = outer.read_attribute_scope()?;
                         elements.push(Element::Steps(vec![attribute_block]));
                     } else if is_step(content) {
@@ -796,14 +796,14 @@ impl<'i> Parser<'i> {
                                     && !is_procedure_title(line)
                                     && !is_code_block(line)
                                     && !malformed_step_pattern(line)
-                                    && !is_role_assignment(line)
+                                    && !is_attribute_assignment(line)
                             },
                             |line| {
                                 is_step(line)
                                     || is_procedure_title(line)
                                     || is_code_block(line)
                                     || malformed_step_pattern(line)
-                                    || is_role_assignment(line)
+                                    || is_attribute_assignment(line)
                             },
                             |inner| {
                                 let content = inner.source;
@@ -1672,7 +1672,7 @@ impl<'i> Parser<'i> {
                     || is_substep_dependent(line)
                     || is_substep_parallel(line)
                     || is_subsubstep_dependent(line)
-                    || is_role_assignment(line)
+                    || is_attribute_assignment(line)
                     || is_enum_response(line)
                     || malformed_step_pattern(line)
                     || malformed_response_pattern(line)
@@ -1927,32 +1927,43 @@ impl<'i> Parser<'i> {
         self.offset += i;
     }
 
-    /// Parse role assignments like @surgeon, @nurse, or @marketing + @sales
-    fn read_role_assignments(&mut self) -> Result<Vec<Attribute<'i>>, ParsingError<'i>> {
+    /// Parse attributes (roles and/or places) like @surgeon, ^kitchen, or @chef + ^bathroom
+    fn read_attributes(&mut self) -> Result<Vec<Attribute<'i>>, ParsingError<'i>> {
         self.take_line(|inner| {
             let mut attributes = Vec::new();
 
             let line = inner.source;
 
-            // Handle multiple roles separated by +
-            let role_parts: Vec<&str> = line
+            // Handle multiple attributes separated by +
+            let parts: Vec<&str> = line
                 .split('+')
                 .collect();
 
-            for part in role_parts {
-                let re = regex!(r"^\s*@([a-z][a-z0-9_]*)\s*$");
-                let cap = re
-                    .captures(part.trim_ascii())
-                    .ok_or(ParsingError::InvalidStep(inner.offset))?;
-
-                let role_name = cap
-                    .get(1)
-                    .ok_or(ParsingError::Expected(inner.offset, "role name after @"))?
-                    .as_str();
-
-                let identifier = validate_identifier(role_name)
-                    .ok_or(ParsingError::InvalidIdentifier(inner.offset, role_name))?;
-                attributes.push(Attribute::Role(identifier));
+            for part in parts {
+                let trimmed = part.trim_ascii();
+
+                // Check if it's a role '@'
+                if let Some(captures) = regex!(r"^@([a-z][a-z0-9_]*)$").captures(trimmed) {
+                    let role_name = captures
+                        .get(1)
+                        .ok_or(ParsingError::Expected(inner.offset, "role name after @"))?
+                        .as_str();
+                    let identifier = validate_identifier(role_name)
+                        .ok_or(ParsingError::InvalidIdentifier(inner.offset, role_name))?;
+                    attributes.push(Attribute::Role(identifier));
+                }
+                // Check if it's a place '^'
+                else if let Some(captures) = regex!(r"^\^([a-z][a-z0-9_]*)$").captures(trimmed) {
+                    let place_name = captures
+                        .get(1)
+                        .ok_or(ParsingError::Expected(inner.offset, "place name after ^"))?
+                        .as_str();
+                    let identifier = validate_identifier(place_name)
+                        .ok_or(ParsingError::InvalidIdentifier(inner.offset, place_name))?;
+                    attributes.push(Attribute::Place(identifier));
+                } else {
+                    return Err(ParsingError::InvalidStep(inner.offset));
+                }
             }
 
             Ok(attributes)
@@ -1972,7 +1983,7 @@ impl<'i> Parser<'i> {
 
             let content = self.source;
 
-            if is_role_assignment(content) {
+            if is_attribute_assignment(content) {
                 let block = self.read_attribute_scope()?;
                 scopes.push(block);
             } else if is_substep_dependent(content) {
@@ -2004,10 +2015,10 @@ impl<'i> Parser<'i> {
         Ok(scopes)
     }
 
-    /// Parse an attribute block (role assignment) with its subscopes
+    /// Parse an attribute block (role or place assignment) with its subscopes
     fn read_attribute_scope(&mut self) -> Result<Scope<'i>, ParsingError<'i>> {
-        self.take_block_lines(is_role_assignment, is_role_assignment, |outer| {
-            let attributes = outer.read_role_assignments()?;
+        self.take_block_lines(is_attribute_assignment, is_attribute_assignment, |outer| {
+            let attributes = outer.read_attributes()?;
             let subscopes = outer.read_scopes()?;
 
             Ok(Scope::AttributeBlock {
@@ -2266,7 +2277,7 @@ fn is_procedure_body(content: &str) -> bool {
     // Check for procedure body indicators. At the end, if it doesn't look like signature, it's body.
     is_procedure_title(content)
         || is_step(content)
-        || is_role_assignment(content)
+        || is_attribute_assignment(content)
         || is_code_block(content)
         || is_enum_response(content)
         || (!is_signature_part(content))
@@ -2390,11 +2401,6 @@ fn is_subsubstep_dependent(content: &str) -> bool {
     re.is_match(content)
 }
 
-fn is_role_assignment(content: &str) -> bool {
-    let re = regex!(r"^\s*@[a-z][a-z0-9_]*(\s*\+\s*@[a-z][a-z0-9_]*)*");
-    re.is_match(content)
-}
-
 fn is_enum_response(content: &str) -> bool {
     let re = regex!(r"^\s*'.+?'");
     re.is_match(content)
@@ -2427,6 +2433,12 @@ fn is_string_literal(content: &str) -> bool {
     re.is_match(content)
 }
 
+fn is_attribute_assignment(input: &str) -> bool {
+    // Matches any combination of @ and ^ attributes separated by +
+    let re = regex!(r"^\s*[@^][a-z][a-z0-9_]*(\s*\+\s*[@^][a-z][a-z0-9_]*)*");
+    re.is_match(input)
+}
+
 #[cfg(test)]
 mod check {
     use super::*;
@@ -2955,11 +2967,16 @@ making_coffee(b, m) :
         assert!(is_subsubstep_dependent("xi. Eleven"));
         assert!(is_subsubstep_dependent("xxxix. Thirty-nine"));
 
-        // Test role assignments
-        assert!(is_role_assignment("@surgeon"));
-        assert!(is_role_assignment("  @nursing_team"));
-        assert!(!is_role_assignment("surgeon"));
-        assert!(!is_role_assignment("@123invalid"));
+        // Test attribute assignments
+        assert!(is_attribute_assignment("@surgeon"));
+        assert!(is_attribute_assignment("  @nursing_team"));
+        assert!(is_attribute_assignment("^kitchen"));
+        assert!(is_attribute_assignment("  ^garden  "));
+        assert!(is_attribute_assignment("@chef + ^kitchen"));
+        assert!(is_attribute_assignment("^room1 + @barista"));
+        assert!(!is_attribute_assignment("surgeon"));
+        assert!(!is_attribute_assignment("@123invalid"));
+        assert!(!is_attribute_assignment("^InvalidPlace"));
 
         // Test enum responses
         assert!(is_enum_response("'Yes'"));
@@ -4126,68 +4143,84 @@ echo test
     }
 
     #[test]
-    fn reading_role_assignments() {
+    fn reading_attributes() {
         let mut input = Parser::new();
 
-        // Test simple role assignment
-        input.initialize("@surgeon");
-        let result = input.read_role_assignments();
-        assert_eq!(result, Ok(vec![Attribute::Role(Identifier("surgeon"))]));
+        // Test simple role
+        input.initialize("@chef");
+        let result = input.read_attributes();
+        assert_eq!(result, Ok(vec![Attribute::Role(Identifier("chef"))]));
 
-        // Test role assignment with whitespace
-        input.initialize("  @nurse  ");
-        let result = input.read_role_assignments();
-        assert_eq!(result, Ok(vec![Attribute::Role(Identifier("nurse"))]));
+        // Test simple place
+        input.initialize("^kitchen");
+        let result = input.read_attributes();
+        assert_eq!(result, Ok(vec![Attribute::Place(Identifier("kitchen"))]));
 
-        // Test role assignment with underscores
-        input.initialize("@nursing_team");
-        let result = input.read_role_assignments();
+        // Test multiple roles
+        input.initialize("@master_chef + @barista");
+        let result = input.read_attributes();
         assert_eq!(
             result,
-            Ok(vec![Attribute::Role(Identifier("nursing_team"))])
+            Ok(vec![
+                Attribute::Role(Identifier("master_chef")),
+                Attribute::Role(Identifier("barista"))
+            ])
         );
 
-        // Test role assignment with numbers
-        input.initialize("@team1");
-        let result = input.read_role_assignments();
-        assert_eq!(result, Ok(vec![Attribute::Role(Identifier("team1"))]));
+        // Test multiple places
+        input.initialize("^kitchen + ^bath_room");
+        let result = input.read_attributes();
+        assert_eq!(
+            result,
+            Ok(vec![
+                Attribute::Place(Identifier("kitchen")),
+                Attribute::Place(Identifier("bath_room"))
+            ])
+        );
 
-        // Test multiple roles with +
-        input.initialize("@marketing + @sales");
-        let result = input.read_role_assignments();
+        // Test mixed roles and places
+        input.initialize("@chef + ^bathroom");
+        let result = input.read_attributes();
         assert_eq!(
             result,
             Ok(vec![
-                Attribute::Role(Identifier("marketing")),
-                Attribute::Role(Identifier("sales"))
+                Attribute::Role(Identifier("chef")),
+                Attribute::Place(Identifier("bathroom"))
             ])
         );
 
-        // Test multiple roles with + and extra whitespace
-        input.initialize("@operators + @users + @management");
-        let result = input.read_role_assignments();
+        // Test mixed places and roles
+        input.initialize("^kitchen + @barista");
+        let result = input.read_attributes();
         assert_eq!(
             result,
             Ok(vec![
-                Attribute::Role(Identifier("operators")),
-                Attribute::Role(Identifier("users")),
-                Attribute::Role(Identifier("management"))
+                Attribute::Place(Identifier("kitchen")),
+                Attribute::Role(Identifier("barista"))
             ])
         );
 
-        // Test invalid role assignment - uppercase
-        input.initialize("@Surgeon");
-        let result = input.read_role_assignments();
-        assert!(result.is_err());
+        // Test complex mixed attributes
+        input.initialize("@chef + ^kitchen + @barista + ^dining_room");
+        let result = input.read_attributes();
+        assert_eq!(
+            result,
+            Ok(vec![
+                Attribute::Role(Identifier("chef")),
+                Attribute::Place(Identifier("kitchen")),
+                Attribute::Role(Identifier("barista")),
+                Attribute::Place(Identifier("dining_room"))
+            ])
+        );
 
-        // Test invalid role assignment - missing @
-        input.initialize("surgeon");
-        let result = input.read_role_assignments();
+        // Test invalid - uppercase
+        input.initialize("^Kitchen");
+        let result = input.read_attributes();
         assert!(result.is_err());
 
-        // Test invalid role assignment - empty
-        input.initialize("@");
-        let result = input.read_role_assignments();
+        // Test invalid - no marker
+        input.initialize("kitchen");
+        let result = input.read_attributes();
         assert!(result.is_err());
     }