ci.yml

name: CI

on:
  workflow_dispatch:
  pull_request:
    branches: [ main ]
  push:
    branches: [ main ]

# Cancel any in-flight jobs for the same PR/branch so there's only one active
# at a time
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

env:
  RUST_BACKTRACE: full

jobs:
  rustfmt:
    name: Rustfmt
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@nightly
        with:
          components: rustfmt
      - run: cargo fmt --all -- --check
      - run: cd ${{ github.workspace }}/examples && cargo fmt --all -- --check

  clippy:
    name: Clippy
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Setup Chrome
        uses: browser-actions/setup-chrome@v1
        with:
          chrome-version: 'latest'
          install-chromedriver: true
      - uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy
          targets: wasm32-unknown-unknown
      # lint the main library workspace for non-wasm target
      - run: cargo clippy --features all -- -D warnings -A deprecated
      # lint the non-wasm examples
      - run: cd ${{ github.workspace }}/examples && cargo clippy --workspace --exclude "wasm*" --exclude "kaleido" -- -D warnings
      # lint the plotly library for wasm target
      - run: cargo clippy --package plotly --target wasm32-unknown-unknown -- -D warnings
      # lint the wasm examples
      - run: cd ${{ github.workspace }}/examples/wasm-yew && cargo clippy --target wasm32-unknown-unknown --all

  semver:
    name: semver
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Check semver
        uses: obi1kenobi/cargo-semver-checks-action@v2
        with:
          package: plotly
          feature-group: only-explicit-features
          features: kaleido
          rust-toolchain: stable
          release-type: minor

  test:
    name: Tests
    strategy:
      fail-fast: false
      matrix:
        # os: [ubuntu-latest, windows-latest, macos-latest]
        os: [ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Setup Chrome
        uses: browser-actions/setup-chrome@v1
        with:
          chrome-version: 'latest'
          install-chromedriver: true
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
      - run: cargo test --workspace --features plotly_ndarray,plotly_image,static_export_default --exclude plotly_kaleido
      - if: ${{ matrix.os == 'windows-latest' }}
        run: gci -recurse -filter "*example*"

  code-coverage:
    name: Code Coverage
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          components: llvm-tools-preview
      - uses: taiki-e/install-action@cargo-llvm-cov
      - uses: codecov/codecov-action@v3

  build_examples:
    name: Build Examples
    strategy:
      fail-fast: false
      matrix:
        example: # missing jupyter
          [
          3d_charts,
          basic_charts,
          custom_controls,
          customization,
          financial_charts,
          images,
          kaleido,
          maps,
          ndarray,
          scientific_charts,
          shapes,
          static_export,
          subplots,
          themes,
        ]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Chrome (for static_export)
        if: matrix.example == 'static_export'
        uses: browser-actions/setup-chrome@v1
        with:
          chrome-version: 'latest'
          install-chromedriver: true
    
      - uses: dtolnay/rust-toolchain@stable
      - run: cd ${{ github.workspace }}/examples/${{ matrix.example }} && cargo build

  build_wasm_examples:
    name: Build Wasm Examples
    strategy:
      fail-fast: false
      matrix:
        example: [basic, callback-example]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          targets: wasm32-unknown-unknown
      - run: cd ${{ github.workspace }}/examples/wasm-yew/${{ matrix.example }} && cargo build --target wasm32-unknown-unknown

  test_static_export_chrome:
    name: Test Static Export with Chrome (Windows)
    runs-on: windows-latest
    timeout-minutes: 30
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Chrome and chromedriver
        id: setup-chrome
        uses: browser-actions/setup-chrome@v1
        with:
          chrome-version: 'latest'
          install-chromedriver: true
      
      - uses: dtolnay/rust-toolchain@stable
      
      - name: Cache cargo registry
        uses: actions/cache@v4
        with:
          path: |
            ~/.cargo/registry/index/
            ~/.cargo/registry/cache/
            ~/.cargo/git/db/
          key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
          restore-keys: |
            ${{ runner.os }}-cargo-registry-
      
      - name: Debug - Show setup-chrome outputs
        run: |
          Write-Host "=== Setup Chrome Action Outputs ==="
          Write-Host "chrome-version: ${{ steps.setup-chrome.outputs.chrome-version }}"
          Write-Host "chrome-path: ${{ steps.setup-chrome.outputs.chrome-path }}"
          Write-Host "chromedriver-version: ${{ steps.setup-chrome.outputs.chromedriver-version }}"
          Write-Host "chromedriver-path: ${{ steps.setup-chrome.outputs.chromedriver-path }}"
          Write-Host "================================"
      
      - name: Debug - System information
        run: |
          Write-Host "=== System Information ==="
          Write-Host "OS Version: $(Get-ComputerInfo | Select-Object -ExpandProperty WindowsProductName)"
          Write-Host "Architecture: $(Get-ComputerInfo | Select-Object -ExpandProperty OsArchitecture)"
          Write-Host "Available memory: $((Get-CimInstance Win32_OperatingSystem).FreePhysicalMemory / 1MB) MB"
          Write-Host "=========================="
      
      - name: Debug - Check Chrome and chromedriver installation
        run: |
          Write-Host "=== Chrome and Chromedriver Check ==="
          
          # Check if Chrome is in PATH
          try {
            $chromeVersion = & chrome.exe --version 2>$null
            Write-Host "Chrome in PATH: $chromeVersion"
          } catch {
            Write-Host "Chrome not found in PATH"
          }
          
          # Check if chromedriver is in PATH
          try {
            $chromedriverVersion = & chromedriver.exe --version 2>$null
            Write-Host "Chromedriver in PATH: $chromedriverVersion"
          } catch {
            Write-Host "Chromedriver not found in PATH"
          }
          
          # Check specific paths from action outputs
          $chromePath = "${{ steps.setup-chrome.outputs.chrome-path }}"
          $chromedriverPath = "${{ steps.setup-chrome.outputs.chromedriver-path }}"
          
          Write-Host "Chrome path from action: $chromePath"
          Write-Host "Chromedriver path from action: $chromedriverPath"
          
          if (Test-Path $chromePath) {
            Write-Host "Chrome file exists: $(Get-Item $chromePath | Select-Object -ExpandProperty FullName)"
            Write-Host "Chrome file size: $((Get-Item $chromePath).Length) bytes"
          } else {
            Write-Host "Chrome file does not exist at specified path"
          }
          
          if (Test-Path $chromedriverPath) {
            Write-Host "Chromedriver file exists: $(Get-Item $chromedriverPath | Select-Object -ExpandProperty FullName)"
            Write-Host "Chromedriver file size: $((Get-Item $chromedriverPath).Length) bytes"
            
            # Test if chromedriver is executable
            try {
              $testResult = & $chromedriverPath --version 2>&1
              Write-Host "Chromedriver executable test: $testResult"
            } catch {
              Write-Host "Chromedriver executable test failed: $_"
            }
          } else {
            Write-Host "Chromedriver file does not exist at specified path"
          }
          
          # Try to find chromedriver in common locations
          Write-Host "=== Searching for chromedriver in common locations ==="
          $commonPaths = @(
            "C:\Program Files\Google\Chrome\Application\chromedriver.exe",
            "C:\Program Files (x86)\Google\Chrome\Application\chromedriver.exe",
            "$env:USERPROFILE\AppData\Local\Google\Chrome\Application\chromedriver.exe",
            "$env:PROGRAMFILES\Google\Chrome\Application\chromedriver.exe",
            "$env:PROGRAMFILES(X86)\Google\Chrome\Application\chromedriver.exe"
          )
          
          foreach ($path in $commonPaths) {
            if (Test-Path $path) {
              Write-Host "Found chromedriver at: $path"
              try {
                $version = & $path --version 2>&1
                Write-Host "  Version: $version"
              } catch {
                Write-Host "  Version check failed: $_"
              }
            }
          }
          
          Write-Host "================================"
      
      - name: Debug - Check Rust toolchain and dependencies
        run: |
          Write-Host "=== Rust Toolchain Check ==="
          rustc --version
          cargo --version
          Write-Host "Current directory: $(Get-Location)"
          Write-Host "Workspace contents:"
          Get-ChildItem -Name | Sort-Object
          Write-Host "=========================="
      
      - name: Debug - Check plotly_static package
        run: |
          Write-Host "=== Plotly Static Package Check ==="
          cd plotly_static
          Write-Host "Package contents:"
          Get-ChildItem -Name | Sort-Object
          Write-Host "Cargo.toml contents:"
          Get-Content Cargo.toml
          Write-Host "================================"
      
      - name: Debug - Test chromedriver functionality
        run: |
          Write-Host "=== Testing Chromedriver Functionality ==="
          
          # Test if chromedriver is in PATH and working
          try {
            $chromedriverVersion = & chromedriver.exe --version 2>&1
            Write-Host "Chromedriver in PATH: $chromedriverVersion"
            
            # Try to start chromedriver in background
            Write-Host "Testing chromedriver startup..."
            $process = Start-Process -FilePath "chromedriver.exe" -ArgumentList "--port=4444" -PassThru -WindowStyle Hidden
            Start-Sleep -Seconds 3
            
            # Check if it's running
            $isRunning = Get-Process -Name "chromedriver" -ErrorAction SilentlyContinue
            if ($isRunning) {
              Write-Host "Chromedriver started successfully, PID: $($process.Id)"
              
              # Test WebDriver status endpoint
              try {
                $response = Invoke-WebRequest -Uri "http://localhost:4444/status" -TimeoutSec 5
                Write-Host "WebDriver status response: $($response.StatusCode)"
                Write-Host "Response content: $($response.Content)"
              } catch {
                Write-Host "WebDriver status check failed: $_"
              }
              
              # Stop the process
              Stop-Process -Id $process.Id -Force
              Write-Host "Chromedriver stopped"
            } else {
              Write-Host "Chromedriver failed to start"
            }
          } catch {
            Write-Host "Chromedriver test failed: $_"
          }
          
          Write-Host "================================"
      
      - name: Debug - Test Rust WebDriver spawning
        run: |
          Write-Host "=== Testing Rust WebDriver Spawning ==="
          
          # Set environment variables - WEBDRIVER_PATH should point to full executable path
          $env:WEBDRIVER_PATH = "${{ steps.setup-chrome.outputs.chromedriver-path }}"
          $env:CHROME_PATH = "${{ steps.setup-chrome.outputs.chrome-path }}"
          $env:RUST_LOG = "debug"
          $env:RUST_BACKTRACE = "1"
          
          Write-Host "Environment variables:"
          Write-Host "WEBDRIVER_PATH: $env:WEBDRIVER_PATH"
          Write-Host "CHROME_PATH: $env:CHROME_PATH"
          
          # Try to compile and run a simple test
          Write-Host "Compiling simple WebDriver test..."
          cd plotly_static
          
          # Try to run a simple WebDriver test
          try {
            Write-Host "Testing WebDriver creation with cargo test..."
            cargo test --verbose --package plotly_static --features chromedriver tests::save_png -- --nocapture
          } catch {
            Write-Host "Simple WebDriver test failed: $_"
          }
          
          Write-Host "================================"
      
      - name: Debug - Pre-update cargo index
        run: |
          Write-Host "=== Pre-update Cargo Index Check ==="
          Write-Host "Current cargo index status:"
          cargo search --limit 1 plotly 2>&1 | Select-String -Pattern "Updating|Downloading|error" || Write-Host "Index seems up to date"
          Write-Host "================================"
      
      - name: Update cargo index (if needed)
        run: |
          Write-Host "=== Updating Cargo Index ==="
          # Force update the index with a timeout
          $timeout = 300  # 5 minutes
          $job = Start-Job -ScriptBlock {
            cargo update --dry-run
          }
          
          try {
            Wait-Job $job -Timeout $timeout
            $result = Receive-Job $job
            Write-Host "Cargo update result: $result"
            if ($job.State -eq "Completed") {
              Write-Host "Cargo index updated successfully"
            } else {
              Write-Host "Cargo index update timed out, continuing anyway"
              Stop-Job $job
            }
          } catch {
            Write-Host "Cargo index update failed: $_"
            Write-Host "Continuing with test anyway..."
          } finally {
            if ($job) {
              Remove-Job $job -Force -ErrorAction SilentlyContinue
            }
          }
          Write-Host "================================"
      
      - name: Pre-compile dependencies
        run: |
          Write-Host "=== Pre-compiling Dependencies ==="
          
          # Set environment variables - WEBDRIVER_PATH should point to full executable path
          $env:WEBDRIVER_PATH = "${{ steps.setup-chrome.outputs.chromedriver-path }}"
          $env:CHROME_PATH = "${{ steps.setup-chrome.outputs.chrome-path }}"
          $env:RUST_LOG = "debug"
          $env:RUST_BACKTRACE = "1"
          
          Write-Host "Pre-compiling plotly_static with features..."
          # Note: We don't need webdriver_download feature since chromedriver is already installed
          cargo check --verbose --package plotly_static --features chromedriver
          
          Write-Host "Dependencies pre-compiled successfully"
      
      - name: Run PNG export test with Chrome
        run: |
          Write-Host "=== Starting PNG Export Test ==="
          
          # Try to find chromedriver if action output path doesn't work
          $chromedriverPath = "${{ steps.setup-chrome.outputs.chromedriver-path }}"
          if (-not (Test-Path $chromedriverPath)) {
            Write-Host "Action output chromedriver path not found, searching for alternatives..."
            
            # Try common locations
            $commonPaths = @(
              "C:\Program Files\Google\Chrome\Application\chromedriver.exe",
              "C:\Program Files (x86)\Google\Chrome\Application\chromedriver.exe",
              "$env:USERPROFILE\AppData\Local\Google\Chrome\Application\chromedriver.exe",
              "$env:PROGRAMFILES\Google\Chrome\Application\chromedriver.exe",
              "$env:PROGRAMFILES(X86)\Google\Chrome\Application\chromedriver.exe"
            )
            
            foreach ($path in $commonPaths) {
              if (Test-Path $path) {
                Write-Host "Using chromedriver from: $path"
                $chromedriverPath = $path
                break
              }
            }
          }
          
          # Set environment variables - WEBDRIVER_PATH should point to full executable path
          $env:WEBDRIVER_PATH = $chromedriverPath
          
          # Find the Chrome installed by setup-chrome action (the chrome-path output is unreliable)
          $chromeVersion = "${{ steps.setup-chrome.outputs.chrome-version }}"
          $chromePath = "C:\hostedtoolcache\windows\setup-chrome\chromium\$chromeVersion\x64\chrome.exe"
          
          if (Test-Path $chromePath) {
            $env:CHROME_PATH = $chromePath
            Write-Host "Using Chrome from setup-chrome installation: $env:CHROME_PATH"
          } else {
            # Fallback: search for Chrome in the tool cache
            $toolCacheDir = "C:\hostedtoolcache\windows\setup-chrome\chromium"
            if (Test-Path $toolCacheDir) {
              $chromeExe = Get-ChildItem -Path $toolCacheDir -Recurse -Name "chrome.exe" | Select-Object -First 1
              if ($chromeExe) {
                $fullChromePath = Join-Path $toolCacheDir $chromeExe
                $env:CHROME_PATH = $fullChromePath
                Write-Host "Using Chrome from tool cache search: $env:CHROME_PATH"
              } else {
                Write-Host "Chrome not found in tool cache, using system Chrome"
                $env:CHROME_PATH = "C:\Program Files\Google\Chrome\Application\chrome.exe"
              }
            } else {
              Write-Host "Tool cache not found, using system Chrome"
              $env:CHROME_PATH = "C:\Program Files\Google\Chrome\Application\chrome.exe"
            }
          }
          
          $env:RUST_LOG = "debug"
          $env:RUST_BACKTRACE = "1"
          
          Write-Host "Environment variables set:"
          Write-Host "WEBDRIVER_PATH: $env:WEBDRIVER_PATH"
          Write-Host "CHROME_PATH: $env:CHROME_PATH"
          Write-Host "RUST_LOG: $env:RUST_LOG"
          Write-Host "RUST_BACKTRACE: $env:RUST_BACKTRACE"
          
          # Debug: Check what Chrome versions are available
          Write-Host "Available Chrome installations:"
          if (Test-Path "$env:CHROME_PATH") {
            Write-Host "Chrome at CHROME_PATH: $env:CHROME_PATH"
            try {
              $chromeVersion = & "$env:CHROME_PATH" --version 2>&1
              Write-Host "Chrome version: $chromeVersion"
            } catch {
              Write-Host "Failed to get Chrome version: $_"
            }
          }
          
          # Check system Chrome
          $systemChrome = "C:\Program Files\Google\Chrome\Application\chrome.exe"
          if (Test-Path $systemChrome) {
            Write-Host "System Chrome found at: $systemChrome"
            try {
              $systemChromeVersion = & $systemChrome --version 2>&1
              Write-Host "System Chrome version: $systemChromeVersion"
            } catch {
              Write-Host "Failed to get system Chrome version: $_"
            }
          }
          
          # Check if CHROME_BIN environment variable is being set correctly
          Write-Host "CHROME_BIN environment variable will be set to: $env:CHROME_PATH"
          
          # Test the Chrome version that will be used
          if (Test-Path $env:CHROME_PATH) {
            try {
              $chromeVersion = & $env:CHROME_PATH --version 2>&1
              Write-Host "Chrome version that will be used: $chromeVersion"
            } catch {
              Write-Host "Failed to get Chrome version: $_"
            }
          } else {
            Write-Host "WARNING: Chrome path does not exist: $env:CHROME_PATH"
          }
          
          # Verify the paths exist
          if (-not (Test-Path $env:WEBDRIVER_PATH)) {
            Write-Error "Chromedriver executable not found at: $env:WEBDRIVER_PATH"
            Write-Host "Available chromedriver locations:"
            Get-ChildItem -Path "C:\Program Files\Google\Chrome\Application\" -Name "chromedriver*" -ErrorAction SilentlyContinue
            Get-ChildItem -Path "C:\Program Files (x86)\Google\Chrome\Application\" -Name "chromedriver*" -ErrorAction SilentlyContinue
            exit 1
          }
          if (-not (Test-Path $env:CHROME_PATH)) {
            Write-Error "Chrome not found at: $env:CHROME_PATH"
            exit 1
          }
          
          Write-Host "All paths verified, starting cargo test..."
          
          # Run the test directly without PowerShell job complexity
          # Note: We don't need webdriver_download feature since chromedriver is already installed
          cargo test --verbose --package plotly_static --features chromedriver tests::save_png -- --nocapture
          
          Write-Host "=== PNG Export Test Completed ==="

  build_book:
    name: Build Book 
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Setup Chrome (for static_export)
        uses: browser-actions/setup-chrome@v1
        with:
          chrome-version: 'latest'
          install-chromedriver: true
        id: setup-chrome
      
      - uses: dtolnay/rust-toolchain@stable
      - run: cargo install mdbook --no-default-features --features search --vers "^0.4" --locked --quiet
      - name: Build examples to generate needed html files
        run: |
          cd ${{ github.workspace }}/examples/basic_charts && cargo run
          cd ${{ github.workspace }}/examples/statistical_charts && cargo run
          cd ${{ github.workspace }}/examples/scientific_charts && cargo run
          cd ${{ github.workspace }}/examples/financial_charts && cargo run
          cd ${{ github.workspace }}/examples/3d_charts && cargo run
          cd ${{ github.workspace }}/examples/subplots && cargo run
          cd ${{ github.workspace }}/examples/shapes && cargo run
          cd ${{ github.workspace }}/examples/themes && cargo run
          cd ${{ github.workspace }}/examples/static_export && cargo run
      - name: Build book 
        run: mdbook build docs/book