.makim.yaml

version: 1.0.0
env:
  CFLAGS_EXTRA: "\
    -fsanitize=address\
    "
  ASAN_OPTIONS_DEFAULT: "\
    fast_unwind_on_malloc=0\
    :verbosity=1\
    :strict_string_checks=1\
    :check_initialization_order=1\
    :strict_init_order=1\
    :atexit=1\
    :print_legend=1\
    :detect_leaks=1\
    "
  LSAN_OPTIONS_DEFAULT: "\
    fast_unwind_on_malloc=0\
    :verbosity=1\
    :log_threads=1\
    :log_pointers=1\
    :strict_string_checks=1\
    :detect_leaks=1\
    "
  MESON_EXTRA_DEBUG: "-Db_coverage=true \
    -Doptimization=0 \
    --debug \
    -Db_sanitize=address \
    "
groups:
  clean:
    targets:
      gcda:
        help: Remove temporary gcda files
        run: |
          touch tmp.gcda
          find . -name "*.gcda" -print0 | xargs -0 rm

      all:
        help: Remove all unnecessary temporary files
        dependencies:
          - target: clean.gcda
        run: |
          rm -rf build/*
          rm -f bin/*
          mkdir -p build
  build:
    targets:
      install:
        help: Install Arx locally
        run: meson install -C build

      release:
        help: Build Arx for release
        args:
          asan-options:
            help: |
              Define a custom value for the environment variable
              `ASAN_OPTIONS`
            type: string
            default: ''
          lsan-options:
            help: |
              Define a custom value for the environment variable
              `LSAN_OPTIONS`
            type: string
            default: ''
          build-type:
            help: |
              Define the build type, options are:
              plain, debug, debugoptimized, release, minsize, and custom
            type: string
            default: release
          clean:
            help: Clean temporary files before the building step
            type: bool
            action: store_true
          meson-extra:
            help: Extra arguments for the build step
            type: string
            default: ''
        dependencies:
          - target: clean.all
            if: {{ args.clean }}
          - target: clean.gcda
        shell: bash
        run: |
          export ASAN_OPTIONS='{{ args.asan_options or env.ASAN_OPTIONS_DEFAULT }}'
          export LSAN_OPTIONS='{{ args.lsan_options or env.LSAN_OPTIONS_DEFAULT }}'

          meson setup \
            --prefix $CONDA_PREFIX \
            --libdir $CONDA_PREFIX/lib \
            --includedir $CONDA_PREFIX/include \
            --buildtype={{ args.build_type }} \
            --native-file meson.native {{ args.meson_extra }} \
            build .
          meson compile -C build

      debug:
        help: Build for debugging (+debug)
        args:
          clean:
            help: Clean temporary files before the building step
            type: bool
            action: store_true
        dependencies:
          - target: build.release
            args:
              build-type: "debug"
              meson-extra: {{ env.MESON_EXTRA_DEBUG }}
              clean: {{ args.clean }}
              asan-options: {{ env.ASAN_OPTIONS_DEFAULT }}
              lsan-options: {{ env.LSAN_OPTIONS_DEFAULT }}

      dev:
        help: Build for development (+tests +debug)
        args:
          clean:
            help: Clean temporary files before the building step
            type: bool
            action: store_true
        dependencies:
          - target: build.release
            args:
              build-type: "debug"
              meson-extra: {{ env.MESON_EXTRA_DEBUG }} -Ddev=enabled
              clean: {{ args.clean }}
              asan-options: {{ env.ASAN_OPTIONS_DEFAULT }}
              lsan-options: {{ env.LSAN_OPTIONS_DEFAULT }}

  env:
    targets:
      create-file:
        help: Create a .env file
        run: |
          touch .env
          echo -n @("HOST_UID=" + $(id -u) + "HOST_GID=" + $(id -g)) > .env

  conda:
    targets:
      build:
        help: Create the conda package for arx
        run: |
          cd conda/recipe
          conda build purge
          conda mambabuild .

  release:
    vars:
      app: |
        npx --yes \
        -p semantic-release \
        -p "conventional-changelog-conventionalcommits" \
        -p "@semantic-release/commit-analyzer" \
        -p "@semantic-release/release-notes-generator" \
        -p "@semantic-release/changelog" \
        -p "@semantic-release/exec" \
        -p "@semantic-release/github" \
        -p "@semantic-release/git" \
        -p "@google/semantic-release-replace-plugin" \
        semantic-release

    targets:
      ci:
        help: Run semantic-release on CI
        run: {{ vars.app }} --ci

      dry:
        help: Run semantic-release on CI for tests in dry-run mode.
        run: {{ vars.app }} --dry-run

  docs:
    targets:
      api:
        help: Build API docs
        run: |
          mkdir -p build/docs
          doxygen Doxyfile
          ./scripts/format_releases.sh

      build:
        help: Build the general docs pages
        dependencies:
          - target: docs.clean
          - target: docs.api
        run: |
          mkdocs build --config-file docs/mkdocs.yaml --dirty
          echo "arxlang.org" > ./build/docs/CNAME

      clean:
        help: Clean temporary documentation files
        run: |
          rm -rf ./build/docs

      preview:
        help: Preview documentation result locally
        dependencies:
          - target: docs.clean
          - target: docs.api
        run: mkdocs serve --config-file docs/mkdocs.yaml --watch docs

  tests:
    shell: bash
    # env:
    #     ASAN_OPTIONS: {{ env.ASAN_OPTIONS_DEFAULT }}
    #     LSAN_OPTIONS: {{ env.LSAN_OPTIONS_DEFAULT }}
    targets:
      sanitizer:
        help: Run sanitizer tests
        run: meson test -C build -v

      code-coverage:
        help: Check code coverage by tests
        run: ninja coverage -C build

      gen-object-examples:
        help: Run test for object generation
        args:
          debug:
            help: Debug Mode
            type: bool
            action: store_true
          examples-name:
            help: Name of the tests to be executed
            type: string
            default: "constant fibonacci sum average print-star"
        shell: bash
        run: |
          set -e

          TMP_DIR=/tmp/arx
          rm -f ${TMP_DIR}/*
          mkdir -p "${TMP_DIR}"

          GDB=""
          DEBUG_FLAGS=""

          if [[ "{{ args.debug  }}" == "True" ]]; then
            GDB="gdb core --args"
            DEBUG_FLAGS="-g -O0"
          fi

          TEST_DIR_PATH="./tests"

          # load utils functions
          . "${TEST_DIR_PATH}/scripts/utils.sh"

          ARX="${GDB} ./build/arx --build-lib"
          MAIN_EXE="${TMP_DIR}/main"

          LD_LIBRARY_PATH=${CONDA_PREFIX}/lib:$LD_LIBRARY_PATH
          export LD_LIBRARY_PATH

          LLVM_MODULES="core executionengine interpreter analysis native bitwriter"

          CLANG_EXTRA="${CLANG_EXTRA} -fno-omit-frame-pointer"
          CLANG_EXTRA="${CLANG_EXTRA} $(llvm-config --cxxflags)"
          CLANG_EXTRA="${CLANG_EXTRA} $(llvm-config --ldflags --libs ${LLVM_MODULES})"
          CLANG_EXTRA="${CLANG_EXTRA} $(pkg-config --cflags --libs arrow-glib)"
          CLANG_EXTRA=$(echo "${CLANG_EXTRA}" | sed s/-std=c++14/-std=c++20/g)

          rm --force "${TMP_DIR}/*.o"

          for test_name in {{ args.examples_name }}; do
            print_header "${test_name}"
            OBJECT_FILE="${TMP_DIR}/${test_name}.o"

            echo "Arx build ..."
            ${ARX} --output "${OBJECT_FILE}" --input "examples/${test_name}.arx"

            echo "clang build ..."
            set -x
            clang++ \
              ${CLANG_EXTRA} \
              ${DEBUG_FLAGS} \
              -fPIC \
              "${TEST_DIR_PATH}/integration/${test_name}.cpp" \
              ${OBJECT_FILE} \
              -o "${TMP_DIR}/main"
            set +x

            echo ">>> RUN THE PROGRAM:"
            chmod +x ${MAIN_EXE}
            ${GDB} ${MAIN_EXE}
          done

      gen-ast-examples:
        help: Run test for AST generation
        args:
          debug:
            help: Debug Mode
            type: bool
            action: store_true
          examples-name:
            help: Name of the tests to be executed
            type: string
            default: "constant fibonacci sum average print-star"
        run: |
          set -e

          TMP_DIR=/tmp/arx
          mkdir -p "${TMP_DIR}"

          GDB=""
          if [[ "{{ args.debug  }}" == "True" ]]; then
            GDB="gdb --args"
          fi

          TEST_DIR_PATH="./tests"

          # load utils functions
          . "${TEST_DIR_PATH}/scripts/utils.sh"

          ARX="${GDB} ./build/arx"
          MAIN_EXE="${TMP_DIR}/main"

          for test_name in {{ args.examples_name }}; do
            print_header "${test_name}"
            ${ARX} --show-ast --input "examples/${test_name}.arx"
          done


      gen-llvm-ir-examples:
        help: Run test for LLVM IR
        args:
          debug:
            help: Debug Mode
            type: bool
            action: store_true
        run: |
          TMP_DIR=/tmp/arx
          mkdir -p "${TMP_DIR}"

          GDB=""
          if [[ "{{ args.debug  }}" == "True" ]]; then
            GDB="gdb --args"
          fi

          TEST_DIR_PATH="./tests"

          # load utils functions
          . "${TEST_DIR_PATH}/scripts/utils.sh"

          ARX="${GDB} ./build/arx"
          MAIN_EXE="${TMP_DIR}/main"

          for test_name in "constant" "fibonacci" "sum" "average" "print-star"; do
            print_header "${test_name}"
            ${ARX} --show-llvm-ir --input "examples/${test_name}.arx"
          done

      gen-all-examples:
        help: Test all code generation for the example arx files
        dependencies:
          - target: tests.gen-ast-examples
          - target: tests.gen-object-examples
          - target: tests.gen-llvm-ir-examples

      all:
        help: Run sanitizer tests and code generation for examples
        dependencies:
          - target: tests.sanitizer
          - target: tests.gen-all-examples

      lint:
        help: Run linter tools
        run: pre-commit run --all-files --verbose

  debug:
    targets:
      source-build:
        help: Debug arx via an example file
        args:
          example-name:
            help: Name of the tests that should be executed
            type: string
            required: true
          debug:
            help: Use gdb
            type: bool
            action: store_true
          memory-leak-info:
            help: Show ASAN/LSAN information
            type: bool
            action: store_true
        shell: bash
        run: |
          {% if args.memory_leak_info %}
          export ASAN_OPTIONS={{ env.ASAN_OPTIONS_DEFAULT }}
          export LSAN_OPTIONS={{ env.LSAN_OPTIONS_DEFAULT }}
          {% endif %}
          {{ "gdb --args" if args.debug else "" }} build/arx \
            --input `pwd`/examples/{{ args.example_name }}.arx \
            --output "{{ env.OUTPUT_DIR }}/{{ args.example_name }}.o" \
            --build-lib

      readelf:
        help: Read ELF from an object file
        args:
          example-name:
            help: Name of the tests that should be executed
            type: string
            required: true
          memory-leak-info:
            help: Show ASAN/LSAN information
            type: bool
            action: store_true
        dependencies:
          - target: debug.source-build
            args:
              example-name: {{ args.example_name }}
              memory-leak-info: {{ args.memory_leak_info }}
        run: |
          readelf --all "{{ env.OUTPUT_DIR }}/{{ args.example_name }}.o"

      objdump:
        help: Debug object files using objdump
        args:
          example-name:
            help: Name of the tests that should be executed
            type: string
            required: true
          memory-leak-info:
            help: Show ASAN/LSAN information
            type: bool
            action: store_true
          options:
            help: Options to be given to objdump
            type: string
            default: "-d -Mintel"
        dependencies:
          - target: debug.source-build
            args:
              example-name: {{ args.example_name }}
              memory-leak-info: {{ args.memory_leak_info }}
        run: |
          objdump {{ args.options }} "{{ env.OUTPUT_DIR }}/{{ args.example_name }}.o"