.gitlab-ci.yml

stages:
  - lint_and_test
  - concepts
  - examples
  - coverage
  - doc
  - deploy_testpypi
  - test_testpypi
  - deploy_pypi

version_badge:
  stage: lint_and_test
  image: debian:12
  script:
    - apt update
    - apt install -y python3 python3-pip python3-venv bc curl
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - mkdir -p badges
    - uv run anybadge --label=version --value=`uv version --short` --file=badges/version.svg
  artifacts:
    paths:
      - badges/version.svg

test_ci_vars:
  stage: lint_and_test
  image: alpine
  script:
    - echo $CI_COMMIT_TAG
    - echo $CI_COMMIT_BRANCH
    - echo $IS_PRIVATE_GITLAB_INSTANCE

count_todos_in_code:
  stage: lint_and_test
  image: debian:12
  variables:
    GOAL: "60"
  script:
    - apt update
    - apt install -y python3 python3-pip python3-venv bc curl
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - make todo | tee todo.log
    - TODOS=$(grep -oP 'TODOs=\K[\d]+' todo.log)
    - |
      if [ "$(echo "$TODOS > $GOAL" | bc)" -eq 1 ]; then
        echo "ERROR: Number of TODOs $TODOS is over goal $GOAL"
        exit 1
      else
        echo "SUCCESS: Number of TODOs $TODOS is equal or lower than goal $GOAL"
      fi
  coverage: /Count=([\d]+)/
  artifacts:
    when: always
    paths:
      - badges/todo.svg

lint_python:
  stage: lint_and_test
  image: debian:12
  variables:
    GOAL: "92"
  script:
    - apt update
    - apt install -y python3 python3-pip python3-venv bc curl
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - make lint | tee pylint.log
    - RATING=$(grep -oP 'Your code has been rated at \K[\d.]+' pylint.log)
    - PERCENTAGE=$(echo "$RATING * 10" | bc)
    - printf "lint score is %.2f %%\n" "$PERCENTAGE"
    - |
      if [ "$(echo "$PERCENTAGE < $GOAL" | bc)" -eq 1 ]; then
        echo "ERROR: Lint score $PERCENTAGE is below goal $GOAL"
        exit 1
      else
        echo "SUCCESS: Lint score $PERCENTAGE equal or better than goal $GOAL"
      fi
  coverage: /lint score is ([\d]+\.[\d]+)/

test_all:
  stage: lint_and_test
  image: debian:12
  script:
    - apt update
    - apt install -y python3 python3-pip python3-venv curl
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - make test
    - mv .coverage .coverage.pytest
  artifacts:
    when: always
    paths:
      - test/drom2psl/*.psl
      - .coverage.pytest
      - results.xml
    reports:
      junit:
        - results.xml

run_concepts_questa: &run_concepts_questa
  rules:
    - if: $IS_PRIVATE_GITLAB_INSTANCE == "True"
  stage: concepts
  image: registry.woden.us.es/containers/questa:2025.1_2
  variables:
    TOOLCHAIN: "questa"
  tags:
    - fast
  parallel:
    matrix:
      - DESIGN:
        - adding_drom_sources
        - assertion_decomposition
        - assert_to_assume
        - blackbox_example
        - blackbox_instance
        - counter_abstraction
        - cutpoint_example
        - defining_clocks_and_resets
        - design_configurations
        - design_configurations_reachability
        - hooks
        - inheriting_multiple_vunits
        - inheriting_vunits
        - multiple_designs
        - parameterized_properties
        - parameterized_sequences
        - symbolic_constants
        - user_defined_hdltypes
        - user_defined_hdltypes_in_external_package
        - user_defined_hdltypes_in_package
  before_script:
    - unset LM_LICENSE_FILE
    - export SALT_LICENSE_SERVER=29000@popote.us.es
    - yum install -y git python39 java-1.8.0-openjdk
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
  script:
    - make UVFLAGS=--dev PYTHON="coverage run --data-file=.coverage.$TOOLCHAIN.$DESIGN" $DESIGN
  after_script:
    - mv fvm_out/dashboard/$DESIGN/report fvm_out/dashboard/$DESIGN/report.$TOOLCHAIN.$DESIGN
  artifacts:
    when: always
    paths:
      - .coverage.$TOOLCHAIN.$DESIGN
      - fvm_out/fvm_results/*.xml
      - fvm_out/fvm_results/executor.json
      - fvm_out/dashboard/$DESIGN/results/*.html
      - fvm_out/dashboard/$DESIGN/results/*.json
      - fvm_out/dashboard/$DESIGN/results/*.log
      - fvm_out/dashboard/$DESIGN/report.$TOOLCHAIN.$DESIGN
    reports:
      junit:
        - fvm_out/fvm_results/*.xml

.run_concepts_sby: &run_concepts_sby
  <<: *run_concepts_questa
  image: registry.gitlab.com/hgpub/fosshdl-dist
  variables:
    TOOLCHAIN: "sby"
  before_script:
    - DEBIAN_FRONTEND=noninteractive apt update && apt install -y python3 python3-pip python3-venv
    - source /home/salas/fosshdl/env.rc
    - export FVM_TOOLCHAIN=sby
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"

run_test_examples_questa:
  <<: *run_concepts_questa
  stage: examples
  parallel:
    matrix:
      - DESIGN:
        - counter_psl_in_vhdl
        - wishbone_sequence

run_examples_questa:
  <<: *run_concepts_questa
  stage: examples
  parallel:
    matrix:
      - DESIGN:
        - arbiter_prior
        - arbiter_rr
        - axi_lite_slave
        - counter
        - div32
        - dualcounter
        - fifo_async
        - fifo_sync
        - ipv6
        - linearinterpolator
        - sdram
        - uart_tx

.run_examples_sby:
  <<: *run_concepts_sby
  stage: examples
  parallel:
    matrix:
      - DESIGN:
        - arbiter_prior
        - arbiter_rr
        - axi_lite_slave
        - counter
        - div32
        - dualcounter
        - fifo_async
        - fifo_sync
        - ipv6
        - ipv6TX
        - linearinterpolator
        - sdram
        - uart_tx

# Test that steps do not require any information from previous steps, so users
# can run them independently if needed.
run_steps_independently_questa:
  rules:
    - if: $IS_PRIVATE_GITLAB_INSTANCE == "True"
  stage: examples
  image: registry.woden.us.es/containers/questa:2025.1_2
  tags:
    - fast
  variables:
    TOOLCHAIN: "questa"
  parallel:
    matrix:
      - DESIGN:
        - counter
        - arbiter_prior
        STEP:
        - lint
        - friendliness
        - rulecheck
        - xverify
        - reachability
        - resets
        - clocks
        - prove
  before_script:
    - unset LM_LICENSE_FILE
    - export SALT_LICENSE_SERVER=29000@popote.us.es
    - yum install -y python39 java-1.8.0-openjdk git
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
  script:
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.$DESIGN.$STEP -m examples.$DESIGN.formal -s $STEP
  artifacts:
    when: always
    paths:
      - .coverage.*

run_options_questa:
  rules:
    - if: $IS_PRIVATE_GITLAB_INSTANCE == "True"
  stage: concepts
  image: registry.woden.us.es/containers/questa:2025.1_2
  tags:
    - fast
  variables:
    TOOLCHAIN: "questa"
  before_script:
    - unset LM_LICENSE_FILE
    - export SALT_LICENSE_SERVER=29000@popote.us.es
    - yum install -y python39 java-1.8.0-openjdk
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
  script:
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.hooks.verbose concepts/hooks/formal.py -v
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.hooks.list concepts/hooks/formal.py -l
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.design_configurations.list concepts/design_configurations/formal.py -l
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.hooks.outdir concepts/hooks/formal.py -o fvm_out_2
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.hooks.design concepts/hooks/formal.py -d counter
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.hooks.prove concepts/hooks/formal.py -s prove
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.hooks.prove_list concepts/hooks/formal.py -s prove -l
    - uv run --dev coverage run --data-file=.coverage.$TOOLCHAIN.vunits.continue test/examples/inheriting_vunits_fail/formal.py -c
    - make clean
  artifacts:
    when: always
    paths:
      - .coverage.$TOOLCHAIN.hooks.verbose
      - .coverage.$TOOLCHAIN.hooks.list
      - .coverage.$TOOLCHAIN.design_configurations.list
      - .coverage.$TOOLCHAIN.hooks.outdir
      - .coverage.$TOOLCHAIN.hooks.design
      - .coverage.$TOOLCHAIN.hooks.prove
      - .coverage.$TOOLCHAIN.hooks.prove_list
      - .coverage.$TOOLCHAIN.vunits.continue

# Generate sphinx documentation
apidoc:
  stage: doc
  image: debian:12
  variables:
    GOAL: 98
  script:
    - apt update
    - apt install -y python3 python3-pip python3-venv bc curl
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - make docs 2>&1 | tee docs.log
    - UNDOCUMENTED=$(grep -oP 'Total undocumented members= \K[\d]+' docs.log)
    - |
      if [ "$(echo "$UNDOCUMENTED > $GOAL" | bc)" -eq 1 ]; then
        echo "ERROR: Number of undocumented $UNDOCUMENTED is over goal $GOAL"
        exit 1
      else
        echo "SUCCESS: Number of undocumented $UNDOCUMENTED is equal or lower than goal $GOAL"
      fi
  artifacts:
    when: always
    paths:
      - doc/sphinx/build/html
      - badges/undocumented.svg
  coverage: /Total undocumented members= ([\d]+)/

# Merge python coverage files from previous stages
pycoverage:
  stage: coverage
  image: debian:12
  before_script:
    - |
      # When not running the examples and concepts, python coverage is lower
      if [ "$IS_PRIVATE_GITLAB_INSTANCE" == "True" ]; then
        export GOAL="92"
      else
        export GOAL="45"
      fi
  script:
    - apt update
    - apt install -y python3 python3-pip python3-venv bc curl
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - make pycoverage | tee pycoverage.log
    - LASTFIELD=$(grep 'TOTAL' pycoverage.log | awk '{print $NF}')
    - PERCENTAGE=${LASTFIELD%\%}
    - |
      if [ "$(echo "$PERCENTAGE < $GOAL" | bc)" -eq 1 ]; then
        echo "ERROR: Python coverage $PERCENTAGE is below goal $GOAL"
        exit 1
      else
        echo "SUCCESS: Python coverage $PERCENTAGE equal or better than goal $GOAL"
      fi
  coverage: /TOTAL.*\s+(\d+\%)/
  artifacts:
    when: always
    paths:
      - htmlcov
    reports:
      coverage_report:
        coverage_format: cobertura
        path: coverage.xml

# Deploy to testPyPI, but only if we have pushed a git tag, which should have
# only been pushed to the main branch (the bump_version.sh script enforces
# this), and we are in the private instance, which has the API tokens as CI/CD
# variables
#
# Sometimes testpypi seems to randomly fail, giving a not available error even
# if the upload was successful. If we stop there, since we only publish on
# tagged commits, this forces us to create a new, different tag. Instead, the
# check-url should allow us to re-run this job and not get errors if the files
# are already uploaded, or at least allow the pipeline to continue.
deploy_to_testpypi: &deploy_to_testpypi
  variables:
    PUBLISH_URL: "https://test.pypi.org/legacy/"
    CHECK_URL:   "https://test.pypi.org/simple/"
  allow_failure: true
  stage: deploy_testpypi
  rules:
    - if: $CI_COMMIT_TAG && $IS_PRIVATE_GITLAB_INSTANCE == "True"
  image: debian:12
  before_script:
    - apt update
    - apt install -y python3 python3-pip python3-venv curl
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - uv build
  script:
    - uv publish --publish-url $PUBLISH_URL --check-url $CHECK_URL --token $TESTPYPI_API_TOKEN

# Get the recently published fvm from testpypi and try to run the tests
# Of couse we only do this if we have deployed to testpypi, but we can also run
# this on the public instance
# Here we don't want to use uv to run the tests, we only use uv to get the
# version number
# Then we install, using pip, the specific version from testpypi in a clean
# venv and run the tests with that version
# We remove the src/ folder in this job before running pytest to ensure we are
# finding the installed fvm (inside the testvenv)
# Tests may fail if the tests in the test/ folder do not match the installed
# version from testpypi (for example if the repo is 0.1.1 and we install
# 0.1.0), but as far as we know that shouldn't happen since we get the version
# from the repo using uv
# Let's test on multiple linux flavors that have python3.9 or later
test_from_testpypi:
  stage: test_testpypi
  rules:
    - if: $CI_COMMIT_TAG
  image: $DOCKERIMAGE
  parallel:
    matrix:
      - DOCKERIMAGE:
          - "debian:12"
          - "debian:13"
          - "ubuntu:22.04"
          - "ubuntu:24.04"
          - "alpine:3"
          - "rockylinux:9"
          - "fedora:41"
          - "fedora:42"
  script:
    - |
      # Check the value of the DOCKERIMAGE variable
      case "$DOCKERIMAGE" in
        # Match images containing 'alpine'
        *alpine*)
          echo "Setting up Alpine Linux (apk)"
          apk update
          apk add --no-cache python3 py3-pip curl
          ;;

        # Match images containing 'debian' or 'ubuntu'
        *debian* | *ubuntu*)
          echo "Setting up Debian/Ubuntu Linux (apt)"
          apt-get update
          apt-get install -y python3 python3-pip python3-venv curl
          ;;

        # Match images containing 'rocky', 'fedora', or 'centos'
        *rocky* | *fedora* | *centos*)
          echo "Setting up Rocky/Fedora/Centos/RHEL Linux ($PACKAGE_MANAGER)"
          # No need to $PACKAGE_MANAGER update (that would update installed packages)
          # Fedora and rocky, as alpine, provide python3-venv with python3.
          # They also come with curl so we don't need to install it
          dnf install -y python3 python3-pip
          ;;

        *)
          echo "Error: Unsupported Docker image base: $DOCKERIMAGE"
          exit 1
          ;;
      esac
    - curl -LsSf https://astral.sh/uv/install.sh | sh
    - export PATH="$HOME/.local/bin:$PATH"
    - python3 -m venv testvenv
    - source testvenv/bin/activate
    - pip3 install --extra-index-url https://test.pypi.org/simple/ fvm-formal==`uv version --short`
    - pip3 install pytest
    - echo "[pytest]" > pytest.ini
    - echo "pythonpath = ." >> pytest.ini
    - rm -rf src/
    - pytest -v

deploy_to_pypi:
  <<: *deploy_to_testpypi
  stage: deploy_pypi
  variables:
    PUBLISH_URL: "https://upload.pypi.org/legacy/"
    CHECK_URL:   "https://pypi.org/simple/"
  script:
    - uv publish --publish-url $PUBLISH_URL --check-url $CHECK_URL --token $PYPI_API_TOKEN