added versioning to syllabus and added Release 1.0.1 to the versioned docs

.github/workflows/pr-preview-surge.yml

@@ -64,7 +64,7 @@ jobs:
         run: npm ci
 
       - name: Build
-        run: npm run build
+        run: npm run build:preview
 
       - name: Upload build artifact
         uses: actions/upload-artifact@v4

.github/workflows/release-pages.yml

@@ -18,6 +18,24 @@ jobs:
           ref: ${{ github.event.release.tag_name }}
           fetch-depth: 0
 
+      - name: Verify matching versioned docs exist
+        shell: bash
+        run: |
+          RELEASE_TAG="${{ github.event.release.tag_name }}"
+          # Strip a leading 'v' from the tag (e.g. v1.0.1 → 1.0.1)
+          VERSION="${RELEASE_TAG#v}"
+          DOCS_DIR="website/versioned_docs/version-${VERSION}"
+
+          if [[ ! -d "${DOCS_DIR}" ]]; then
+            echo "::error::Missing docs snapshot for release tag '${RELEASE_TAG}'."
+            echo "Expected directory: ${DOCS_DIR}"
+            echo "Available directories in website/versioned_docs:"
+            ls -1 website/versioned_docs || true
+            exit 1
+          fi
+
+          echo "Found matching docs directory: ${DOCS_DIR}"
+
       - name: Use Node.js
         uses: actions/setup-node@v4
         with:
@@ -31,7 +49,7 @@ jobs:
 
       - name: Build website
         working-directory: ./website
-        run: npm run build
+        run: npm run build:production
 
       - name: Deploy to gh-pages
         uses: peaceiris/actions-gh-pages@v3

website/README.md

@@ -30,6 +30,20 @@ $ npm run build
 
 This command generates static content into the `build` directory and can be served using any static contents hosting service.
 
+Build modes:
+
+```
+$ npm run build:preview
+```
+
+Builds docs with both released versions and `next` content.
+
+```
+$ npm run build:production
+```
+
+Builds docs with released versions only (hides `next`).
+
 ### Deployment
 
 Using SSH:

website/docusaurus.config.ts

@@ -1,15 +1,21 @@
-// @ts-check
-// Note: type annotations allow type checking and IDEs autocompletion
-
-const lightCodeTheme = require('prism-react-renderer').themes.vsLight;
-const darkCodeTheme = require('prism-react-renderer').themes.dracula;
+import { themes as prismThemes } from 'prism-react-renderer';
 import remarkDirective from "remark-directive";
 import remarkTermDirective from "./src/remark/remark-term-directive.js";
 import codeMaxLineLength from './src/remark/remark-code-max-line-length.js';
+import type { Config } from '@docusaurus/types';
+import type * as Preset from '@docusaurus/preset-classic';
+
+const rawDocsBuildMode = process.env.DOCS_BUILD_MODE ?? 'preview';
 
+if (!['preview', 'production'].includes(rawDocsBuildMode)) {
+  throw new Error(
+    `Invalid DOCS_BUILD_MODE: "${rawDocsBuildMode}". Expected "preview" or "production".`,
+  );
+}
 
-/** @type {import('@docusaurus/types').Config} */
-const config = {
+const includeCurrentVersion = rawDocsBuildMode === 'preview';
+
+const config: Config = {
   title: 'Syllabus of Robot Framework® Certified Professional',
   tagline: 'The foundation for the "Robot Framework® Certified Professional" (RFCP®) exam and training',
   url: 'https://robotframework.org',
@@ -25,105 +31,111 @@ const config = {
   future: {
     v4: true, // Improve compatibility with the upcoming Docusaurus v4
   },
-  organizationName: 'robotframework', // Usually your GitHub org/user name.
-  projectName: 'robotframework-RFCP-syllabus', // Usually your repo name.
+  organizationName: 'robotframework',
+  projectName: 'robotframework-RFCP-syllabus',
   trailingSlash: false,
   presets: [
     [
       'classic',
-      /** @type {import('@docusaurus/preset-classic').Options} */
       ({
         docs: {
+          includeCurrentVersion,
           admonitions: {
             keywords: ['lo', 'K1', 'K2', 'K3', 'note', 'tip', 'info', 'warning', 'danger'],
             extendDefaults: true,
           },
-          routeBasePath: '/docs',
-          sidebarPath: require.resolve('./sidebars.js'),
-          // Please change this to your repo.
-          // editUrl: 'https://github.com/robotframework/robotframework-RFCP-syllabus/edit/docusaurus/website',
+          sidebarPath: './sidebars.ts',
           remarkPlugins: [remarkDirective, remarkTermDirective, [codeMaxLineLength, { max: 100 }]],
         },
         blog: false,
         theme: {
-          customCss: require.resolve('./src/css/custom.css'),
+          customCss: './src/css/custom.css',
         },
-      }),
+      } satisfies Preset.Options),
     ],
   ],
-  themeConfig:
-    /** @type {import('@docusaurus/preset-classic').ThemeConfig} */
-    ({
-      colorMode: {
-        defaultMode: 'dark',
-        disableSwitch: false,
-        respectPrefersColorScheme: false,
+  themeConfig: ({
+    colorMode: {
+      defaultMode: 'dark',
+      disableSwitch: false,
+      respectPrefersColorScheme: true,
+    },
+    navbar: {
+      title: 'RFCP-Syllabus',
+      logo: {
+        alt: 'Robot Framework Logo',
+        src: 'img/robot-framework.svg',
+        srcDark: 'img/robot-framework-dark.svg',
       },
-      navbar: {
-        title: 'RFCP-Syllabus',
-        logo: {
-          alt: 'Robot Framework Logo',
-          src: 'img/robot-framework.svg',
-          srcDark: 'img/robot-framework-dark.svg',
+      items: [
+        {
+          type: 'doc',
+          docId: 'overview',
+          label: 'Introduction',
+          position: 'left',
         },
-        items: [
-          {
-            label: 'Introduction',
-            to: '/docs/overview',
-            position: 'left',
-          },
-          {
-            label: 'Chapter 1',
-            to: '/docs/chapter-01/overview',
-            position: 'left',
-          },
-          {
-            label: 'Chapter 2',
-            to: '/docs/chapter-02/overview',
-            position: 'left',
-          },
-          {
-            label: 'Chapter 3',
-            to: '/docs/chapter-03/overview',
-            position: 'left',
-          },
-          {
-            label: 'Chapter 4',
-            to: '/docs/chapter-04/overview',
-            position: 'left',
-          },
-          {
-            label: 'Chapter 5',
-            to: '/docs/chapter-05/overview',
-            position: 'left',
-          },
-          {
-            label: 'Example Exam',
-            to: '/docs/example-exam',
-            position: 'left',
-          },
-          {
-            label: 'LOs',
-            to: '/docs/learning_objectives',
-            position: 'left',
-          },
-        ],
-      },
-      footer: {
-        style: 'dark',
-        links: [
-        ],
-        copyright: `Copyright © ${new Date().getFullYear()} Robot Framework® Foundation - Syllabus of Robot Framework® Certified Professional`,
-      },
-      prism: {
-        theme: lightCodeTheme,
-        darkTheme: darkCodeTheme,
-        additionalLanguages: ['robotframework', 'python'],
-      },
-    }),
+        {
+          type: 'doc',
+          docId: 'chapter-01/overview',
+          label: 'Chapter 1',
+          position: 'left',
+        },
+        {
+          type: 'doc',
+          docId: 'chapter-02/overview',
+          label: 'Chapter 2',
+          position: 'left',
+        },
+        {
+          type: 'doc',
+          docId: 'chapter-03/overview',
+          label: 'Chapter 3',
+          position: 'left',
+        },
+        {
+          type: 'doc',
+          docId: 'chapter-04/overview',
+          label: 'Chapter 4',
+          position: 'left',
+        },
+        {
+          type: 'doc',
+          docId: 'chapter-05/overview',
+          label: 'Chapter 5',
+          position: 'left',
+        },
+        {
+          type: 'doc',
+          docId: 'example-exam/Example-exam',
+          label: 'Example Exam',
+          position: 'left',
+        },
+        {
+          type: 'doc',
+          docId: 'learning_objectives',
+          label: 'LOs',
+          position: 'left',
+        },
+        {
+          type: 'docsVersionDropdown',
+          position: 'right',
+          dropdownActiveClassDisabled: true,
+        },
+      ],
+    },
+    footer: {
+      style: 'dark',
+      copyright: `Copyright © ${new Date().getFullYear()} Robot Framework® Foundation - Syllabus of Robot Framework® Certified Professional`,
+    },
+    prism: {
+      theme: prismThemes.vsLight,
+      darkTheme: prismThemes.dracula,
+      additionalLanguages: ['robotframework', 'python'],
+    },
+  } satisfies Preset.ThemeConfig),
   plugins: [
-    require.resolve('docusaurus-lunr-search')
+    'docusaurus-lunr-search',
   ],
 };
 
-module.exports = config;
+export default config;

website/package.json

@@ -8,6 +8,8 @@
     "start": "docusaurus start",
     "start-public": "docusaurus start --host 0.0.0.0",
     "build": "docusaurus build",
+    "build:preview": "DOCS_BUILD_MODE=preview npm run build",
+    "build:production": "DOCS_BUILD_MODE=production npm run build",
     "swizzle": "docusaurus swizzle",
     "deploy": "docusaurus deploy",
     "clear": "docusaurus clear",

website/src/css/custom.css

@@ -582,4 +582,9 @@ h5,
 h6 {
   font-family: var(--ifm-font-family-heading);
   letter-spacing: -0.11em;
+}
+
+/* Hide the per-page version badge; the navbar version dropdown is sufficient */
+.theme-doc-version-badge {
+  display: none;
 }

website/src/remark/remark-code-max-line-length.js

@@ -8,6 +8,13 @@ export default function codeMaxLineLength(options = {}) {
   const max = options.max ?? 100;
 
   return (tree, file) => {
+    const sourcePath = file.path ?? file.history?.[0] ?? '';
+
+    // Versioned docs are snapshots and should not fail on current lint rules.
+    if (/(^|[\\/])versioned_docs([\\/]|$)/.test(sourcePath)) {
+      return;
+    }
+
     visit(tree, 'code', (node) => {
       // Optional: allow opt-out with "nolint" in code block meta:
       // ```js nolint

website/versioned_docs/version-1.0.1/chapter-01/00_overview.md

@@ -0,0 +1,3 @@
+# 1 Introduction to Robot Framework
+
+The upcoming chapters provide a concise overview of Robot Framework, including its core structure, use cases in test automation and Robotic Process Automation (RPA), and key specification styles like keyword-driven and behavior-driven testing. You'll learn about its architecture, syntax, and how test cases and tasks are organized. Additionally, the chapters explain the open-source licensing under Apache 2.0, the role of the Robot Framework Foundation in maintaining the ecosystem, and the foundational web resources available for further exploration and contributions.

website/versioned_docs/version-1.0.1/chapter-01/01_purpose.md

@@ -0,0 +1,65 @@
+# 1.1 Purpose / Use Cases
+
+::::lo[Learning Objectives]
+
+:::K1[LO-1.1]
+
+Recall the two main use cases of Robot Framework
+
+:::
+
+::::
+
+Robot Framework is a versatile, open-source automation framework that supports both **test automation** and **robotic process automation (RPA)**.
+Initially designed for acceptance testing, it has since evolved to cover other types of testing and various automation tasks in both IT and business environments.
+Its keyword-driven approach allows users to create reusable components, making it accessible even to those with minimal programming skills.
+Robot Framework can be extended through a vast array of third-party or custom made keyword libraries, allowing it to automate interactions with APIs, user interfaces, databases, and many more technologies.
+
+
+
+## 1.1.1 Test Automation
+
+::::lo[Learning Objectives]
+
+:::K1[LO-1.1.1]
+
+Recall the test levels Robot Framework is mostly used for
+
+:::
+
+::::
+
+Robot Framework is widely used at various levels of testing, primarily focusing on:
+
+- **System Testing**: Involves verifying the complete system’s behavior and capabilities. It often includes both functional and non-functional aspects (e.g., accessibility, security) and may use simulated components.
+
+- **System Integration Testing**: Focuses on the interaction between the system under test and external services, as well as on the integration of multiple systems into a larger system, ensuring that all integrated components communicate and function together as expected.
+
+- **Acceptance Testing**: Aims to validate that the system meets business requirements and is ready for deployment or release. This often includes different forms of acceptance testing (e.g., user acceptance, operational acceptance, regulatory acceptance) and is frequently written or conducted by end-users or stakeholders to confirm the system’s readiness for use. Acceptance tests, often defined by business stakeholders in approaches like Acceptance Test-Driven Development (ATDD), can be automated and executed earlier in the development process. This ensures that the solution aligns with business requirements from the start and provides immediate feedback, reducing costly changes later.
+
+- **End-to-End Testing**: Verifies that a complete workflow or process within the system operates as intended, covering all interconnected subsystems, interfaces, and external components. End-to-end tests ensure the correct functioning of the application in real-world scenarios by simulating user interactions from start to finish.
+
+Robot Framework's flexibility and support for external libraries make it an excellent tool for automating these comprehensive test cases, ensuring seamless interaction between components and validating the system's behavior also in production or production-like conditions.
+
+Robot Framework is typically not used for **component testing** nor **integration testing** because its primary strength lies in higher-level testing, such as system, acceptance, and end-to-end testing, where behavior-driven and keyword-based approaches excel. Component testing requires low-level, granular tests focusing on individual units of code, often necessitating direct interaction with the codebase, mocking, or stubbing, which are better handled by unit testing frameworks like JUnit, pytest, or NUnit. Similarly, integration testing at a low level often requires precise control over service interactions, such as API stubs or protocol-level testing, which may not align with Robot Framework's abstraction-oriented design. While Robot Framework can technically handle these cases through custom libraries, its overhead and design philosophy make it less efficient compared to tools specifically tailored for low-level and tightly scoped testing tasks.
+
+
+### 1.1.1.1 Synthetic Monitoring
+
+Beyond traditional test levels, **Synthetic Monitoring**, also referred to as **Active Monitoring** or **Proactive Monitoring**, is a proactive approach that simulates user interactions with live systems at regular intervals. It detects performance issues or downtime early with the goal of detecting such failure before they affect actual users.
+
+
+
+## 1.1.2 Robotic Process Automation (RPA)
+
+Robotic Process Automation (RPA) uses software bots to perform tasks and interactions normally performed by humans, without requiring changes to the underlying applications.
+
+Robot Framework, with its keyword-driven approach, vast ecosystem of libraries, simplicity, and scalability, is widely adopted for RPA tasks.
+Robot Framework allows users to automate most workflows using ready-made keyword libraries that provide a wide range of functionalities. These libraries can be combined and reused in user-defined keywords, making automation simple and efficient. For custom functionalities or more complex tasks, Robot Framework also offers the flexibility to create custom keyword libraries using Python, enabling advanced use cases and seamless integration with unique systems.
+
+Common use cases of RPA with Robot Framework include:
+
+- **Data extraction and manipulation**: Automating data transfers and processing between systems.
+- **Task / Process automation**: Automating tasks such as form submissions, clicks, and file operations across web or desktop applications.
+
+