feat: Aiming for Cooklang feature completenes (#15)

* feat: implement note blocks per Cooklang spec proposal

Add support for note blocks using the > syntax at start of lines.
Notes are supplementary information that appears in recipe details
but not during cooking mode.

Syntax:
  > This is a single-line note.
  > This is a multi-line note
  > that continues on multiple lines.

Implementation:
- Add NOTE token type to token/token.go
- Implement readNote() in lexer to handle > at start of line
- Add Note struct with StepComponent interface methods
- Update parser to handle NOTE tokens (creates separate step)
- Update ToCooklangRecipe to convert note components
- Update HTML and Markdown renderers to render notes as blockquotes
- Add comprehensive tests for note lexing

Per spec proposal: https://github.com/cooklang/spec/blob/main/proposals/0005-note-blocks.md

* test: add comprehensive tests for comments, sections, and notes

- Add lexer tests for single-line comments (-- comment)
- Add parser tests for notes (TestNoteParsing, TestMultipleNotes, TestNoteWithSections)
- Fix parser to handle NOTE tokens after newlines (was falling through to default case)

This ensures notes work correctly when appearing after section headers
or other block-level elements.

* feat: add canonical_extensions.yaml spec tests for block comments, sections, and notes

Add comprehensive YAML test spec file covering:
- Block comments [- comment -]
- Sections (= Section Name =)
- Notes (> note text)
- Combined extended features

These tests document the current parser behavior for extended
Cooklang syntax features from the official spec's Advanced section.

* feat: implement fixed quantities for ingredients (=prefix)

- Add Fixed field to Component struct (parser) and Ingredient struct
- Update parseQuantityAndUnit to detect leading '=' and set isFixed flag
- Update ToCooklangRecipe to propagate Fixed field to Ingredient
- Update Ingredient.Render() to output '=' prefix for fixed quantities
- Add spec tests for fixed quantities in canonical_extensions.yaml
- Fix flaky example test by sorting ingredients for deterministic output

Fixed quantities (e.g., @salt{=1%tsp}) indicate amounts that should not
scale when adjusting recipe servings, as documented in the Cooklang spec.

* test: add unit tests for token package

- TestLookupIdent: verify keyword lookup for @, #, ~ and fallback to IDENT
- TestTokenType: ensure all token type constants are unique and non-empty
- TestToken: basic struct instantiation test

Author: hilli

cooklang.go

@@ -219,13 +219,18 @@ func (Cookware) isStepComponent()    {}
 func (Ingredient) isStepComponent()  {}
 func (Section) isStepComponent()     {}
 func (Comment) isStepComponent()     {}
+func (Note) isStepComponent()        {}
 
 // Render returns the Cooklang syntax representation of this ingredient.
-// Examples: "@flour{500%g}", "@salt{}", "@milk{2%cups}(cold)"
+// Examples: "@flour{500%g}", "@salt{}", "@milk{2%cups}(cold)", "@yeast{=1%packet}"
 func (i Ingredient) Render() string {
 	var result string
+	fixedPrefix := ""
+	if i.Fixed {
+		fixedPrefix = "="
+	}
 	if i.Quantity > 0 {
-		result = fmt.Sprintf("@%s{%g%%%s}", i.Name, i.Quantity, i.Unit)
+		result = fmt.Sprintf("@%s{%s%g%%%s}", i.Name, fixedPrefix, i.Quantity, i.Unit)
 	} else if i.Quantity == -1 {
 		// -1 indicates "some" quantity
 		result = fmt.Sprintf("@%s{}", i.Name)
@@ -349,16 +354,29 @@ func (cm Comment) RenderDisplay() string {
 	return cm.Text
 }
 
+// Render returns the Cooklang syntax representation of this note.
+// Example: "> This is a note"
+func (n Note) Render() string {
+	return fmt.Sprintf("> %s", n.Text)
+}
+
+// RenderDisplay returns note text suitable for display.
+func (n Note) RenderDisplay() string {
+	return n.Text
+}
+
 // Ingredient represents a recipe ingredient with quantity, unit, and optional annotations.
 // Ingredients support unit conversion and consolidation for shopping lists.
 //
 // Example Cooklang syntax: @flour{500%g}, @salt{}, @milk{2%cups}
 //
 // The Quantity field uses -1 to represent "some" (unspecified amount).
+// The Fixed field indicates a quantity that should not scale with servings (e.g., @salt{=1%tsp}).
 type Ingredient struct {
 	Name           string        `json:"name,omitempty"`           // Ingredient name (e.g., "flour", "sugar")
 	Quantity       float32       `json:"quantity,omitempty"`       // Amount (-1 means "some", 0 means none specified)
 	Unit           string        `json:"unit,omitempty"`           // Unit of measurement (e.g., "g", "cup", "tbsp")
+	Fixed          bool          `json:"fixed,omitempty"`          // Fixed quantity doesn't scale with servings
 	TypedUnit      *units.Unit   `json:"typed_unit,omitempty"`     // Typed unit for conversion operations
 	Subinstruction string        `json:"value,omitempty"`          // Additional preparation instructions
 	Annotation     string        `json:"annotation,omitempty"`     // Optional annotation (e.g., "finely chopped")
@@ -445,6 +463,20 @@ type Comment struct {
 	CooklangRenderable
 }
 
+// Note represents a note block in a recipe.
+// Notes are supplementary information that appears in recipe details but not during cooking mode.
+// They are used for background stories, tips, or personal anecdotes related to the recipe.
+//
+// Example Cooklang syntax:
+// > This dish is even better the next day, after the flavors have melded overnight.
+// > This is a multi-line note
+// > that continues here.
+type Note struct {
+	Text          string        `json:"text,omitempty"`           // Note text
+	NextComponent StepComponent `json:"next_component,omitempty"` // Next component in the step
+	CooklangRenderable
+}
+
 // ParseFile reads and parses a Cooklang recipe file, returning a Recipe object.
 // It automatically detects and includes associated image files matching the recipe filename.
 //
@@ -721,6 +753,7 @@ func ToCooklangRecipe(pRecipe *parser.Recipe) *Recipe {
 					Name:       component.Name,
 					Quantity:   quant,
 					Unit:       component.Unit,
+					Fixed:      component.Fixed,
 					TypedUnit:  CreateTypedUnit(component.Unit),
 					Annotation: component.Value,
 				}
@@ -759,6 +792,10 @@ func ToCooklangRecipe(pRecipe *parser.Recipe) *Recipe {
 					Text:    component.Value,
 					IsBlock: true,
 				}
+			case "note":
+				stepComp = &Note{
+					Text: component.Value,
+				}
 			}
 
 			if stepComp != nil {
@@ -1044,6 +1081,15 @@ func (cm *Comment) GetNext() StepComponent {
 	return cm.NextComponent
 }
 
+// SetNext and GetNext methods for Note
+func (n *Note) SetNext(next StepComponent) {
+	n.NextComponent = next
+}
+
+func (n *Note) GetNext() StepComponent {
+	return n.NextComponent
+}
+
 // IngredientList represents a collection of ingredients with unit consolidation capabilities.
 // It provides methods for grouping, converting, and consolidating ingredients for shopping lists
 // and recipe scaling operations.

example_test.go

@@ -218,6 +218,11 @@ Second layer: @cheese{150%g} and @tomato{3}.`
 		log.Fatal(err)
 	}
 
+	// Sort ingredients by name for consistent output
+	sort.Slice(collected.Ingredients, func(i, j int) bool {
+		return collected.Ingredients[i].Name < collected.Ingredients[j].Name
+	})
+
 	fmt.Println("Shopping list:")
 	for _, ing := range collected.Ingredients {
 		if ing.Unit != "" {

lexer/lexer.go

@@ -86,6 +86,13 @@ func (l *Lexer) NextToken() token.Token {
 			return l.readSectionHeader()
 		}
 		tok = newToken(token.SECTION, l.ch)
+	case '>': // Note block
+		// Check if this is at the start of a line (note block)
+		if l.position == 0 || (l.position > 0 && (l.input[l.position-1] == '\n' || l.input[l.position-1] == '\r')) {
+			return l.readNote()
+		}
+		// Otherwise treat as regular text
+		tok = newToken(token.ILLEGAL, l.ch)
 	case '-':
 		if l.peekChar() == '-' {
 			if l.peekCharAt(1) == '-' {
@@ -460,3 +467,73 @@ func (l *Lexer) readSectionHeader() token.Token {
 		Literal: sectionName,
 	}
 }
+
+// readNote reads a note block starting with > and continuing until a blank line
+// Notes can span multiple lines, each optionally starting with >
+// Per spec: all > markers are stripped from the output
+func (l *Lexer) readNote() token.Token {
+	var noteContent strings.Builder
+
+	for {
+		// Skip the > character at start of line
+		if l.ch == '>' {
+			l.readChar()
+		}
+
+		// Skip whitespace after >
+		for l.ch == ' ' || l.ch == '\t' {
+			l.readChar()
+		}
+
+		// Read content until end of line
+		lineStart := l.position
+		for l.ch != '\n' && l.ch != '\r' && l.ch != 0 {
+			l.readChar()
+		}
+
+		// Add the line content
+		lineContent := l.input[lineStart:l.position]
+		if noteContent.Len() > 0 && len(lineContent) > 0 {
+			noteContent.WriteString(" ") // Join lines with space
+		}
+		noteContent.WriteString(lineContent)
+
+		// Check for newline
+		switch l.ch {
+		case '\r':
+			l.readChar() // consume \r
+			if l.ch == '\n' {
+				l.readChar() // consume \n in CRLF
+			}
+		case '\n':
+			l.readChar() // consume \n
+		}
+
+		// Check if next line continues the note (starts with > or is non-blank continuation)
+		// A blank line ends the note
+		if l.ch == 0 {
+			break // EOF
+		}
+
+		// Check for blank line (end of note)
+		if l.ch == '\n' || l.ch == '\r' {
+			break // Blank line ends the note
+		}
+
+		// If next line starts with >, continue reading the note
+		if l.ch == '>' {
+			continue
+		}
+
+		// Per spec: lines can continue without > too (until blank line)
+		// But we need to check if it's actually content or another block type
+		// For simplicity, only continue if line starts with > (stricter interpretation)
+		// This avoids consuming regular recipe steps as part of notes
+		break
+	}
+
+	return token.Token{
+		Type:    token.NOTE,
+		Literal: strings.TrimSpace(noteContent.String()),
+	}
+}