.travis.yml

sudo: false

language: c

stages:
    -   name: test

    -   name: build
        # Don't run build stage for pull requests to save time and resources.
        if: type != pull_request


jobs:
    include:
        # Build with gcc and run tests on Ubuntu.
        -   &test-ubuntu
            stage: test
            os: linux
            compiler: gcc

            addons:
                apt:
                    packages:
                        - valgrind
                        - bison
                        - automake

            before_install:
                - uname -s
                - rvm install ruby-1.9.3-p551
                - rvm use 1.9.3
                - rm src/{lexer,parser}.{c,h}
                - sed -i.bak '/^AM_INIT_AUTOMAKE(\[-Wno-portability 1\.14\])$/s/14/11/' modules/oniguruma/configure.ac

            install:
                - bundle install --gemfile=docs/Gemfile
                - wget http://ftp.debian.org/debian/pool/main/b/bison/bison_3.0.2.dfsg-2_amd64.deb
                - ar p bison_3.0.2.dfsg-2_amd64.deb data.tar.xz | tar xJ
                - if [ -n "$COVERAGE" ]; then pip install --user cpp-coveralls; fi

            before_script:
                # If this is OS X we'll get bison from brew, else we'll get bison
                # from the .deb unpacked above in the install section.
                - PATH=/usr/local/opt/bison/bin:$PWD/usr/bin:$PATH
                - echo SHELL=$SHELL
                - echo PATH=$PATH
                - which bison
                - bison --version
                - autoreconf -if
                - ./configure --with-oniguruma=builtin YACC="$(which bison) -y" $COVERAGE

            script:
                # When using the bison from Debian we need to tell that bison where
                # to find its data.  Yay non-relocatable code.  Not.
                - echo PATH=$PATH
                - which bison
                - make BISON_PKGDATADIR=$PWD/usr/share/bison src/parser.c || make src/parser.c
                # Make dist!
                #
                # Make it first to fail the build early, before we test with
                # valgrind.
                - make dist
                # Build and test the dist (without valgrind)
                - |
                    (
                    tar xvf jq-`scripts/version`.tar.gz &&
                    cd jq-`scripts/version` &&
                    pwd &&
                    ./configure --disable-valgrind --with-oniguruma=builtin YACC="$(which bison) -y" $COVERAGE &&
                    make BISON_PKGDATADIR=$PWD/usr/share/bison src/parser.c || make src/parser.c &&
                    make -j4 &&
                    make check -j4 || true
                    )
                # Build and test the HEAD
                - make -j4
                - make check -j4

            after_failure:
                - cat test-suite.log
                - cat tests/*.log


        # Build with clang and run tests on Ubuntu.
        -   <<: *test-ubuntu
            compiler: clang


        # Build with gcc and run tests with gcov on Ubuntu.
        -   <<: *test-ubuntu
            env: COVERAGE="--disable-valgrind --enable-gcov"

            after_script:
                - rm -rf src/.libs # don't care about coverage for libjq
                - coveralls --gcov-options '\-lp'
                    -e src/lexer.c -e src/parser.c -e src/jv_dtoa.c


        # Build with gcc and run tests on macOS.
        -   &test-osx
            <<: *test-ubuntu
            os: osx

            before_install:
                - uname -s
                - brew update
                - brew install flex bison
                - rvm install ruby-1.9.3-p551
                - rvm use 1.9.3
                - gem install bundler
                - rm src/{lexer,parser}.{c,h}
                - sed -i.bak '/^AM_INIT_AUTOMAKE(\[-Wno-portability 1\.14\])$/s/14/11/' modules/oniguruma/configure.ac

            install:
                - bundle install --gemfile=docs/Gemfile
                - if [ -n "$COVERAGE" ]; then pip install --user cpp-coveralls; fi


        # Build with clang and run tests on macOS.
        -   <<: *test-osx
            compiler: clang


        # Build with gcc and run tests on Alpine Linux v3.7 (inside chroot).
        # Note: Alpine uses musl libc.
        -   &test-alpine
            stage: test
            os: linux
            language: minimal
            compiler: gcc
            sudo: true

            before_install:
                - "wget 'https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.7.0/alpine-chroot-install' \
                    && echo '090d323d887ef3a2fd4e752428553f22a52b87bb  alpine-chroot-install' | sha1sum -c || travis_terminate 1"
                - alpine() { /alpine/enter-chroot -u "$USER" "$@"; }

            install:
                - sudo sh alpine-chroot-install -b v3.7 -a "$ARCH"
                    -p 'build-base automake autoconf bison libtool oniguruma-dev'

            before_script:
                - autoreconf -if

            script:
                - alpine ./configure --disable-docs
                - alpine make
                - alpine make check


        # Build release binary statically linked with musl libc on Alpine Linux
        # (inside chroot). If building a tagged commit, then deploy release
        # tarball to GitHub Releases.
        -   &build-alpine
            <<: *test-alpine
            stage: build
            env: ARCH=x86_64

            script:
                - alpine ./configure --disable-docs --enable-all-static
                    CFLAGS='-Os -static -no-pie' CXXFLAGS='-Os -static -no-pie'
                - alpine make
                - alpine strip jq

                - jq -V
                - ls -lah jq
                - file jq
                # Ensure that the built executable is really statically linked.
                - file jq | grep -Fw 'statically linked'

            before_deploy:
                - PKGNAME="jq-$TRAVIS_TAG-$ARCH-linux"
                - mkdir $PKGNAME && mv jq $PKGNAME/
                - tar -czf $PKGNAME.tar.gz $PKGNAME/
                - sha256sum $PKGNAME.tar.gz > $PKGNAME.tar.gz.sha256

            deploy:
                provider: releases
                api_key:
                    secure:  # TODO: put encrypted GitHub token here!
                file: jq-$TRAVIS_TAG-*.tar.gz*
                file_glob: true
                skip_cleanup: true
                on:
                    tags: true

        # Build binaries for other architectures using QEMU user-mode emulation.
        -   <<: *build-alpine
            env: ARCH=x86

        -   <<: *build-alpine
            env: ARCH=aarch64

        -   <<: *build-alpine
            env: ARCH=armhf

        -   <<: *build-alpine
            env: ARCH=ppc64le


notifications:
    email: false