Add glossary links to Chapter 5 files

- Added GlossaryTerm components to chapter-05 overview, advanced variables, and control structures
- No section renumbering or LO changes
- Glossary linker correctly skips learning_objectives.md

Author: solomon.legodi

website/docs/chapter-05/00_overview.md

@@ -3,3 +3,4 @@
 This chapter introduces more advanced constructs of Robot Framework.
 These topics are often not needed for simple automation cases but can be very useful in more complex situations.
 Although it is not expected that Robot Framework Certified Professionals will be able to use them, it is important to be aware of the possibilities and to understand the basic concepts.
+

website/docs/chapter-05/01_advanced_variables.md

@@ -305,11 +305,11 @@ As long as a value is iterable, it can be assigned to a list variable using the
 
 **Note**: Strings are iterable in Python; however, they are explicitly **NOT** converted to a list when assigned to a list variable to prevent mistakes.
 
-### 5.1.3.1 Accessing List Variables
+### 5.1.4.2 Accessing List Variables
 
 ::::lo[Learning Objectives]
 
-:::K1[LO-5.1.3.1]
+:::K1[LO-5.1.4.2]
 
 Recall that `@{list}` unpacks the values of a list variable when accessed
 
@@ -343,17 +343,17 @@ This is particularly needed when using FOR-Loops. See [5.2.4 FOR Loops](chapter-
 
 
 
-## 5.1.4 Dict-Like
+## 5.1.5 Dict-Like
 
 As explained in the `*** Variables ***` section under [3.2.2.4 Dictionary Variable Definition](chapter-03/02_variables.md#3224-dictionary-variable-definition), Robot Framework natively supports creating dictionaries.
 However, the ampersand-syntax `&{var}` has different meanings when assigning values and when accessing values.
 
 
-### 5.1.4.1 Assigning Dictionary Variables
+### 5.1.5.1 Assigning Dictionary Variables
 
 ::::lo[Learning Objectives]
 
-:::K1[LO-5.1.4.1]
+:::K1[LO-5.1.5.1]
 
 Recall that assignments to `&{dict}` variables automatically convert values to Robot Framework Dictionaries and enable dot-access
 
@@ -375,11 +375,11 @@ Test Dictionary Variables
 In the following example, the first assignment to `&{participant}` causes an automatic conversion to a Robot Framework Dictionary, also known as DotDict. These special dictionary types can be accessed using dot-access like `${participant.name}` or `${participant.age}`, instead of the usual dictionary access like `${trainer}[name]` or `${trainer}[age]`.
 
 
-### 5.1.4.2 Accessing Dictionary Variables
+### 5.1.5.2 Accessing Dictionary Variables
 
 ::::lo[Learning Objectives]
 
-:::K1[LO-5.1.4.2]
+:::K1[LO-5.1.5.2]
 
 Recall that `&{dict}` unpacks to multiple key=value pairs when accessed
 
@@ -417,11 +417,11 @@ The dictionary keys act as the argument names and the values as the argument val
 
 
 
-## 5.1.5 Built-In Variables
+## 5.1.6 Built-In Variables
 
 ::::lo[Learning Objectives]
 
-:::K1[LO-5.1.5]
+:::K1[LO-5.1.6]
 
 Recall that Robot Framework provides access to execution information via Built-In variables
 

website/docs/chapter-05/02_control_structures.md

@@ -4,7 +4,7 @@ import GlossaryTerm from '@site/src/components/Glossary/GlossaryTerm';
 # 5.2 Control Structures
 
 Robot Framework is a Turing-complete language and supports all common <GlossaryTerm term={"Control Structure"}>control structures</GlossaryTerm>, including IF-Statements, FOR-Loops, WHILE-Loops and more.
-While it is not expected that RFCPs can write complex control structures, they should understand their purpose.
+While it is not expected that RFCPs can write complex <GlossaryTerm term={"Control Structure"}>control structures</GlossaryTerm>, they should understand their purpose.
 
 In some cases, it is necessary to use control structures to handle different cases, iterate over a list of values, or execute an action until a condition is met.
 
@@ -24,9 +24,9 @@ Understand the purpose and basic concept of IF-Statements
 The `IF` / `ELSE IF` / `ELSE` syntax in Robot Framework is used to control the flow of <GlossaryTerm term={"Test Case"}>test</GlossaryTerm>|<GlossaryTerm term={"Task"}>task</GlossaryTerm> execution by allowing certain <GlossaryTerm term={"Keyword"}>keywords</GlossaryTerm> to run only when specific conditions are met.
 This is achieved by evaluating conditions written as Python expressions, enabling dynamic decision-making within your tests|<GlossaryTerm term={"Task"}>tasks</GlossaryTerm>.
 
-The `IF` statement begins with the `IF` token and ends with an `END`, enclosing the keywords executed when the condition is true.
+The `IF` statement begins with the `IF` token and ends with an `END`, enclosing the <GlossaryTerm term={"Keyword"}>keywords</GlossaryTerm> executed when the condition is true.
 An optional `ELSE` or `ELSE IF` can specify alternative actions when the initial condition is false.
-This structure enhances the flexibility and responsiveness of your tests|tasks, allowing them to adapt based on <GlossaryTerm term={"Variable"}>variables</GlossaryTerm> and outcomes encountered during execution.
+This structure enhances the flexibility and responsiveness of your tests|<GlossaryTerm term={"Task"}>tasks</GlossaryTerm>, allowing them to adapt based on <GlossaryTerm term={"Variable"}>variables</GlossaryTerm> and outcomes encountered during execution.
 
 
 ### 5.2.1.1 Basic IF Syntax
@@ -90,9 +90,9 @@ Quick Check
     IF    $user == 'Admin'    Log    Admin access granted.
 ```
 
-Executes the `Log` keyword if `${user}` equals to the string `'Admin'`.
+Executes the `Log` <GlossaryTerm term={"Keyword"}>keyword</GlossaryTerm> if `${user}` equals to the string `'Admin'`.
 
-No `END` is needed for inline IF.
+No `END` is needed for <GlossaryTerm term={"Inline IF"}>inline IF</GlossaryTerm>.
 
 ## 5.2.4 FOR Loops
 
@@ -117,7 +117,7 @@ The other types are `FOR-IN-RANGE`, `FOR-IN-ENUMERATE`, and `FOR-IN-ZIP`, which
 - `FOR-IN-ENUMERATE` iterates over a list of values and their indexes.
 - `FOR-IN-ZIP` iterates over multiple lists simultaneously.
 
-The `FOR` loop begins with the `FOR` token, followed by a loop <GlossaryTerm term={"Variable"}>variable</GlossaryTerm>, the `IN` token, and the iterable variable or list of values.
+The `FOR` loop begins with the `FOR` token, followed by a loop <GlossaryTerm term={"Variable"}>variable</GlossaryTerm>, the `IN` token, and the iterable <GlossaryTerm term={"Variable"}>variable</GlossaryTerm> or list of values.
 The loop variable takes on each value in the sequence one at a time, executing the enclosed keywords for each value.
 
 
@@ -216,7 +216,7 @@ Scroll Down Until Element Visible
 ```
 
 `WHILE` loops have a configurable iteration limit in Robot Framework.
-When the maximum number of iterations is reached, the loop exits with a failure, causing the test|task or keyword to fail.
+When the maximum number of iterations is reached, the loop exits with a failure, causing the <GlossaryTerm term={"Test Case"}>test</GlossaryTerm>|<GlossaryTerm term={"Task"}>task</GlossaryTerm> or keyword to fail.
 This prevents infinite loops and ensures that tests|tasks do not hang indefinitely.
 
 
@@ -301,3 +301,4 @@ Get Older Participants
     RETURN    ${older_participants}
 ```
 
+