Quick start for install-crystal GitHub Action

Set up your Crystal project on GitHub for continuous testing.

---

I am developing an application a library (also track updates of deps).

---

I want to support Linux, macOS, Windows.
I want to support latest Crystal, a particular older version and follow Crystal nightlies.
I format code with crystal tool format.
Cache dependencies (worth only if there are many).

---

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == 'latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: ~/.cache/shards
          key: ${{ runner.os }}-shards-${{ hashFiles('shard.yml') }}
          restore-keys: ${{ runner.os }}-shards-
      - name: Install shards
        run: shards update --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Check formatting
        run: crystal tool format --check
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        crystal: [1.2, latest, nightly]
    runs-on: ubuntu-latest
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [latest, nightly]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, macos-latest]
        crystal: [1.2, latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == 'latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal != 'nightly' && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Install shards
        run: shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

Add this content to your GitHub repository as .github/workflows/ci.yml:

# This CI job installs Crystal and shard dependencies, then executes `crystal spec` to run the test suite
# More configuration options are available at https://crystal-lang.github.io/install-crystal/configurator.html

on:
  push:
  pull_request:
    branches: [master]
  schedule:
    - cron: '0 6 * * 6'  # Every Saturday 6 AM
jobs:
  test:
    strategy:
      fail-fast: false
      matrix:
        include:
          - os: ubuntu-latest
          - os: ubuntu-latest
            crystal: 1.2
          - os: ubuntu-latest
            crystal: nightly
          - os: macos-latest
          - os: windows-latest
    runs-on: ${{ matrix.os }}
    defaults:
      run:
        shell: bash
    steps:
      - name: Download source
        uses: actions/checkout@v4
      - name: Install Crystal
        uses: crystal-lang/install-crystal@v1
        with:
          crystal: ${{ matrix.crystal }}
      - name: Cache shards
        uses: actions/cache@v4
        with:
          path: lib
          key: ${{ runner.os }}-shards-${{ hashFiles('**/shard.lock') }}
      - name: Install shards
        run: shards check || shards install --ignore-crystal-version
      - name: Run tests
        run: crystal spec --order=random
      - name: Build
        run: shards build
      - name: Check formatting
        run: crystal tool format; git diff --exit-code
        if: matrix.crystal == null && matrix.os == 'ubuntu-latest'

Make sure to check shard.lock in to source control. And shard.yml should be checked in, of course.

I don't trust an external action.

Copy the commit hash of the latest release instead of the "v1" part in crystal-lang/install-crystal@v1.