Add initial top-level action

.eslintignore

@@ -1,3 +0,0 @@
-dist/
-lib/
-node_modules/

.eslintrc.json

@@ -1,54 +0,0 @@
-{
-    "plugins": ["jest", "@typescript-eslint"],
-    "extends": ["plugin:github/recommended"],
-    "parser": "@typescript-eslint/parser",
-    "parserOptions": {
-      "ecmaVersion": 9,
-      "sourceType": "module",
-      "project": "./tsconfig.json"
-    },
-    "rules": {
-      "eslint-comments/no-use": "off",
-      "import/no-namespace": "off",
-      "i18n-text/no-en": "off",
-      "no-unused-vars": "off",
-      "sort-imports": "off",
-      "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }],
-      "@typescript-eslint/explicit-member-accessibility": ["error", {"accessibility": "no-public"}],
-      "@typescript-eslint/no-require-imports": "error",
-      "@typescript-eslint/array-type": "error",
-      "@typescript-eslint/await-thenable": "error",
-      "camelcase": "off",
-      "@typescript-eslint/explicit-function-return-type": ["error", {"allowExpressions": true}],
-      "@typescript-eslint/func-call-spacing": ["error", "never"],
-      "@typescript-eslint/no-array-constructor": "error",
-      "@typescript-eslint/no-empty-interface": "error",
-      "@typescript-eslint/no-explicit-any": "error",
-      "@typescript-eslint/no-extraneous-class": "error",
-      "@typescript-eslint/no-for-in-array": "error",
-      "@typescript-eslint/no-inferrable-types": "error",
-      "@typescript-eslint/no-misused-new": "error",
-      "@typescript-eslint/no-namespace": "error",
-      "@typescript-eslint/no-non-null-assertion": "warn",
-      "@typescript-eslint/no-unnecessary-qualifier": "error",
-      "@typescript-eslint/no-unnecessary-type-assertion": "error",
-      "@typescript-eslint/no-useless-constructor": "error",
-      "@typescript-eslint/no-var-requires": "error",
-      "@typescript-eslint/prefer-for-of": "warn",
-      "@typescript-eslint/prefer-function-type": "warn",
-      "@typescript-eslint/prefer-includes": "error",
-      "@typescript-eslint/prefer-string-starts-ends-with": "error",
-      "@typescript-eslint/promise-function-async": "error",
-      "@typescript-eslint/require-array-sort-compare": ["error", {"ignoreStringArrays":  true}],
-      "@typescript-eslint/restrict-plus-operands": "error",
-      "semi": "off",
-      "@typescript-eslint/semi": ["error", "never"],
-      "@typescript-eslint/type-annotation-spacing": "error",
-      "@typescript-eslint/unbound-method": "error"
-    },
-    "env": {
-      "node": true,
-      "es6": true,
-      "jest/globals": true
-    }
-  }

.github/dco.yml

@@ -1,3 +0,0 @@
-# Disable sign-off checking for members of the Gradle GitHub organization
-require:
-  members: false

.github/dependabot.yml

@@ -1,26 +0,0 @@
-version: 2
-registries:
-  gradle-plugin-portal:
-    type: maven-repository
-    url: https://plugins.gradle.org/m2
-    username: dummy # Required by dependabot
-    password: dummy # Required by dependabot
-updates:
-  - package-ecosystem: "npm"
-    directory: "/"
-    schedule:
-      interval: "daily"
-    ignore:
-      - dependency-name: "@types/node"
-  - package-ecosystem: "gradle"
-    directory: "__tests__/samples/kotlin-dsl"
-    registries:
-      - gradle-plugin-portal
-    schedule:
-      interval: "daily"
-  - package-ecosystem: "gradle"
-    directory: "__tests__/samples/no-wrapper"
-    registries:
-      - gradle-plugin-portal
-    schedule:
-      interval: "daily"

.github/workflows/codeql-analysis.yml

@@ -1,70 +0,0 @@
-# For most projects, this workflow file will not need changing; you simply need
-# to commit it to your repository.
-#
-# You may wish to alter this file to override the set of languages analyzed,
-# or to provide custom queries or build logic.
-#
-# ******** NOTE ********
-# We have attempted to detect the languages in your repository. Please check
-# the `language` matrix defined below to confirm you have the correct set of
-# supported CodeQL languages.
-#
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    # The branches below must be a subset of the branches above
-    branches: [ main ]
-  schedule:
-    - cron: '25 23 * * 2'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript' ]
-        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
-        # Learn more about CodeQL language support at https://git.io/codeql-language-support
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v2
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v1
-      with:
-        languages: ${{ matrix.language }}
-        # If you wish to specify custom queries, you can do so here or in a config file.
-        # By default, queries listed here will override any specified in a config file.
-        # Prefix the list here with "+" to use these queries and those in the config file.
-        # queries: ./path/to/local/query, your-org/your-repo/queries@main
-
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v1
-
-    # ℹ️ Command-line programs to run using the OS shell.
-    # 📚 https://git.io/JvXDl
-
-    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
-    #    and modify them (or add more) to build your code if your project
-    #    uses a compiled language
-
-    #- run: |
-    #   make bootstrap
-    #   make release
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v1

.github/workflows/dev.yml

@@ -1,24 +0,0 @@
-name: Verify generated outputs
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Build
-      run: |
-        npm install
-        npm run all
-    - name: Check for uncommitted changes
-      # Ensure no changes, but ignore node_modules dir since dev/fresh ci deps installed.
-      run: |
-        git diff --exit-code --stat -- . ':!node_modules' \
-        || (echo "##[error] found changed files after build. please 'npm run all'" \
-                 "and check in all changes" \
-            && exit 1)

.github/workflows/failure-cases.yml

@@ -1,34 +0,0 @@
-name: Execute failure cases
-
-on:
-  workflow_dispatch:
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-
-jobs:
-
-  wrapper-missing:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Test wrapper missing
-      uses: ./
-      continue-on-error: true
-      with:
-        build-root-directory: __tests__/samples/no-wrapper
-        arguments: help
-
-  bad-configuration:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Test bad config value
-      uses: ./
-      continue-on-error: true
-      with:
-        build-root-directory: __tests__/samples/no-wrapper
-        arguments: help
-        cache-disabled: yes

.github/workflows/integTest-action-inputs.yml

@@ -1,34 +0,0 @@
-name: Test different action inputs
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-
-jobs:
-  action-inputs:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Invoke with multi-line arguments
-      uses: ./
-      with:
-        build-root-directory: __tests__/samples/groovy-dsl
-        arguments: |
-            --configuration-cache
-            --build-cache
-            -DsystemProperty=FOO
-            -PgradleProperty=BAR
-            test
-            jar

.github/workflows/integTest-caching-config.yml

@@ -1,145 +0,0 @@
-name: Test caching configuration
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
-
-jobs:
-  seed-build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        # Add "enterprise" to main cache entry but omit "notifications"
-        gradle-home-cache-includes: |
-            caches
-            enterprise
-        # Exclude build-cache from main cache entry
-        gradle-home-cache-excludes: |
-            caches/build-cache-1
-    - name: Build using Gradle wrapper
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test
-
-  # Test that the gradle-user-home cache will cache dependencies, by running build with --offline
-  verify-build:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        # Use the same configuration as used in the seed build
-        gradle-home-cache-includes: |
-            caches
-            enterprise
-        gradle-home-cache-excludes: |
-            caches/build-cache-1
-        cache-read-only: true
-    - name: Execute Gradle build with --offline
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --offline
-
-  # Test that build scans are captured when caching is explicitly disabled
-  cache-disabled:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-disabled: true
-    - name: Run Gradle build
-      id: gradle
-      working-directory: __tests__/samples/no-wrapper${{ matrix.build-root-suffix }}
-      run: gradle help "-DgradleVersionCheck=${{matrix.gradle}}"
-    - name: Check build scan url is captured
-      if: ${{ !steps.gradle.outputs.build-scan-url }}
-      uses: actions/github-script@v3
-      with:
-        script: |
-          core.setFailed('No build scan detected')
-
-  # Test that build scans are captured when caching is disabled because Gradle User Home already exists
-  cache-disabled-pre-existing-gradle-home:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Create dummy Gradle User Home
-      run: mkdir -p ~/.gradle/caches
-    - name: Setup Gradle
-      uses: ./
-    - name: Run Gradle build
-      id: gradle
-      working-directory: __tests__/samples/no-wrapper${{ matrix.build-root-suffix }}
-      run: gradle help "-DgradleVersionCheck=${{matrix.gradle}}"
-    - name: Check build scan url is captured
-      if: ${{ !steps.gradle.outputs.build-scan-url }}
-      uses: actions/github-script@v3
-      with:
-        script: |
-          core.setFailed('No build scan detected')
-
-  # Test seed the cache with cache-write-only and verify with cache-read-only
-  seed-build-write-only:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-write-only-
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-write-only: true
-    - name: Build using Gradle wrapper
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test
-
-  verify-write-only-build:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-write-only-
-    needs: seed-build-write-only
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Execute Gradle build with --offline
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --offline
-

.github/workflows/integTest-caching-configuration-cache.yml

@@ -1,141 +0,0 @@
-name: Test save/restore configuration-cache state
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
-
-jobs:
-  # Run initial Gradle builds to push initial cache entries
-  # These builds should start fresh without cache hits, due to the seed injected into the cache key above.
-  seed-build-groovy:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-groovy-
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Groovy build with configuration-cache enabled
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --configuration-cache
-
-  configuration-cache-groovy:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-groovy-
-    needs: seed-build-groovy
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Groovy build with configuration-cache enabled
-      id: execute
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --configuration-cache
-    - name: Check that configuration-cache was used
-      if: ${{ steps.execute.outputs.task_configured == 'yes' }}
-      uses: actions/github-script@v5
-      with:
-        script: |
-          core.setFailed('Configuration cache was not used - task was configured unexpectedly')
-
-  # Check that the build can run when no extracted cache entries are restored
-  no-extracted-cache-entries-restored:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-groovy-
-    needs: seed-build-groovy
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle with no extracted cache entries restored
-      uses: ./
-      env: 
-        GRADLE_BUILD_ACTION_SKIP_RESTORE: "generated-gradle-jars|wrapper-zips|java-toolchains|instrumented-jars|dependencies|kotlin-dsl"
-      with:
-        cache-read-only: true
-    - name: Check execute Gradle build with configuration cache enabled (but not restored)
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --configuration-cache
-
-  seed-build-kotlin:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-kotlin-
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Execute 'help' with configuration-cache enabled
-      working-directory: __tests__/samples/kotlin-dsl
-      run: ./gradlew help --configuration-cache
-
-  modify-build-kotlin:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-kotlin-
-    needs: seed-build-kotlin
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Execute 'test' with configuration-cache enabled
-      working-directory: __tests__/samples/kotlin-dsl
-      run: ./gradlew test --configuration-cache
-
- # Test restore configuration-cache from the third build invocation
-  configuration-cache-kotlin:
-    env:
-      GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-kotlin-
-    needs: modify-build-kotlin
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Execute 'test' again with configuration-cache enabled
-      id: execute
-      working-directory: __tests__/samples/kotlin-dsl
-      run: ./gradlew test --configuration-cache
-    - name: Check that configuration-cache was used
-      if: ${{ steps.execute.outputs.task_configured == 'yes' }}
-      uses: actions/github-script@v5
-      with:
-        script: |
-          core.setFailed('Configuration cache was not used - task was configured unexpectedly')
-

.github/workflows/integTest-caching-gradle-home.yml

@@ -1,85 +0,0 @@
-name: Test save/restore Gradle Home directory
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-
-jobs:
-  seed-build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Build using Gradle wrapper
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test
-
-  # Test that the gradle-user-home cache will cache dependencies, by running build with --offline
-  dependencies-cache:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Execute Gradle build with --offline
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --offline
-
-  # Test that the gradle-user-home cache will cache and restore local build-cache
-  build-cache:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Execute Gradle build and verify tasks from cache
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test -DverifyCachedBuild=true
-
-  # Check that the build can run when Gradle User Home is not fully restored
-  no-extracted-cache-entries-restored:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle with no extracted cache entries restored
-      uses: ./
-      env: 
-        GRADLE_BUILD_ACTION_SKIP_RESTORE: "generated-gradle-jars|wrapper-zips|java-toolchains|instrumented-jars|dependencies|kotlin-dsl"
-      with:
-        cache-read-only: true
-    - name: Check executee Gradle build
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test
-

.github/workflows/integTest-caching-java-toolchain.yml

@@ -1,46 +0,0 @@
-name: Test save/restore java toolchains
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-
-jobs:
-  seed-build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Build using Gradle wrapper
-      working-directory: __tests__/samples/java-toolchain
-      run: ./gradlew test --info
-
-  # Test that the gradle-user-home cache will cache the toolchain, by running build with --offline
-  toolchain-cache:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Execute Gradle build with --offline
-      working-directory: __tests__/samples/java-toolchain
-      run: ./gradlew test --info --offline

.github/workflows/integTest-execution-with-caching.yml

@@ -1,46 +0,0 @@
-name: Test save/restore Gradle state with direct execution
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-
-jobs:
-  seed-build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Exucute Gradle build
-      uses: ./
-      with:
-        build-root-directory: __tests__/samples/groovy-dsl
-        arguments: test
-
-  # Test that the gradle-user-home is restored
-  verify-build:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Execute Gradle build
-      uses: ./
-      with:
-        cache-read-only: true
-        build-root-directory: __tests__/samples/groovy-dsl
-        arguments: test --offline -DverifyCachedBuild=true
-

.github/workflows/integTest-execution.yml

@@ -1,76 +0,0 @@
-name: Test Gradle execution
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-
-jobs:   
-  # Tests for executing with different Gradle versions. 
-  # Each build verifies that it is executed with the expected Gradle version.
-  gradle-execution:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        include:
-          - os: windows-latest
-            script-suffix: '.bat'
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Test use defined Gradle version
-      uses: ./
-      with:
-        gradle-version: 6.9
-        build-root-directory: __tests__/samples/no-wrapper
-        arguments: help -DgradleVersionCheck=6.9
-    - name: Test use Gradle version alias
-      uses: ./
-      with:
-        gradle-version: release-candidate
-        build-root-directory: __tests__/samples/no-wrapper
-        arguments: help
-    - name: Test use defined Gradle executable
-      uses: ./
-      with:
-        gradle-executable: __tests__/samples/groovy-dsl/gradlew${{ matrix.script-suffix }}
-        build-root-directory: __tests__/samples/no-wrapper
-        arguments: help -DgradleVersionCheck=7.4.1
-
-  gradle-versions:
-    strategy:
-      matrix:
-        gradle: [7.3, 6.9, 5.6.4, 4.10.3]
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        include:
-          - gradle: 5.6.4
-            build-root-suffix: -gradle-5
-          - gradle: 4.10.3
-            build-root-suffix: -gradle-4
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Run Gradle build
-      uses: ./
-      id: gradle
-      with:
-        gradle-version: ${{matrix.gradle}}
-        build-root-directory: __tests__/samples/no-wrapper${{ matrix.build-root-suffix }}
-        arguments: help -DgradleVersionCheck=${{matrix.gradle}}
-    - name: Check build scan url
-      if: ${{ !steps.gradle.outputs.build-scan-url }}
-      uses: actions/github-script@v3
-      with:
-        script: |
-          core.setFailed('No build scan detected')    
-  
-   

.github/workflows/integTest-gradle-user-home.yml

@@ -1,67 +0,0 @@
-name: Test caching with a custom GRADLE_USER_HOME
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-  GRADLE_USER_HOME: ${{github.workspace}}/custom/gradle/home
-
-jobs:
-  # Run initial Gradle builds to push initial cache entries
-  # These builds should start fresh without cache hits, due to the seed injected into the cache key above.
-  seed-build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Build using Gradle wrapper
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --info
-
-  # Test that the gradle-user-home cache will cache dependencies, by running build with --offline
-  dependencies-cache:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Execute Gradle build with --offline
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test --offline --info
-
-  # Test that the gradle-user-home cache will cache and restore local build-cache
-  build-cache:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        cache-read-only: true
-    - name: Execute Gradle build and verify tasks from cache
-      working-directory: __tests__/samples/groovy-dsl
-      run: ./gradlew test -DverifyCachedBuild=true --info

.github/workflows/integTest-gradle-versions.yml

@@ -1,80 +0,0 @@
-name: Test provision different Gradle versions
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-
-jobs:   
-  # Tests for executing with different Gradle versions. 
-  # Each build verifies that it is executed with the expected Gradle version.
-  provision-gradle:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        include:
-          - os: windows-latest
-            script-suffix: '.bat'
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle with v6.9
-      uses: ./
-      with:
-        gradle-version: 6.9
-    - name: Test uses Gradle v6.9
-      working-directory: __tests__/samples/no-wrapper
-      run: gradle help "-DgradleVersionCheck=6.9"
-    - name: Setup Gradle with v7.1.1
-      uses: ./
-      with:
-        gradle-version: 7.1.1
-    - name: Test uses Gradle v7.1.1
-      working-directory: __tests__/samples/no-wrapper
-      run: gradle help "-DgradleVersionCheck=7.1.1"
-    - name: Setup Gradle with release-candidate
-      uses: ./
-      with:
-        gradle-version: release-candidate
-    - name: Test use release-candidate
-      working-directory: __tests__/samples/no-wrapper
-      run: gradle help
-  
-  gradle-versions:
-    strategy:
-      matrix:
-        gradle: [7.3, 6.9, 5.6.4, 4.10.3]
-        os: [ubuntu-latest, windows-latest, macos-latest]
-        include:
-          - gradle: 5.6.4
-            build-root-suffix: -gradle-5
-          - gradle: 4.10.3
-            build-root-suffix: -gradle-4
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-      with:
-        gradle-version: ${{ matrix.gradle }}
-    - name: Run Gradle build
-      id: gradle
-      working-directory: __tests__/samples/no-wrapper${{ matrix.build-root-suffix }}
-      run: gradle help "-DgradleVersionCheck=${{matrix.gradle}}"
-    - name: Check build scan url
-      if: ${{ !steps.gradle.outputs.build-scan-url }}
-      uses: actions/github-script@v3
-      with:
-        script: |
-          core.setFailed('No build scan detected')    
-  
-   

.github/workflows/integTest-sample-gradle-plugin.yml

@@ -1,44 +0,0 @@
-name: Test caching with Gradle Plugin project using TestKit
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
-
-jobs:
-  seed-build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Build gradle-plugin project
-      working-directory: __tests__/samples/gradle-plugin
-      run: ./gradlew build
-
-  verify-build:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Build gradle-plugin project
-      working-directory: __tests__/samples/gradle-plugin
-      run: ./gradlew build --offline

.github/workflows/integTest-sample-kotlin-dsl.yml

@@ -1,44 +0,0 @@
-name: Test caching with Kotlin DSL
-
-on:
-  pull_request:
-    types: [assigned, review_requested]
-  push:
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}
-
-env:
-  GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX: ${{github.workflow}}#${{github.run_number}}:${{github.run_attempt}}-
-  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
-
-jobs:
-  seed-build:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Build kotlin-dsl project
-      working-directory: __tests__/samples/kotlin-dsl
-      run: ./gradlew build
-
-  verify-build:
-    needs: seed-build
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - name: Checkout sources
-      uses: actions/checkout@v2
-    - name: Setup Gradle
-      uses: ./
-    - name: Build kotlin-dsl project
-      working-directory: __tests__/samples/kotlin-dsl
-      run: ./gradlew build --offline

.github/workflows/pr-build-scan-comment.yml

@@ -1,28 +0,0 @@
-name: Add a build scan comment to PR
-on:
-  pull_request:
-    types: [assigned, review_requested]
-jobs:
-  gradle:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-java@v2
-      with:
-        distribution: temurin
-        java-version: 11
-    - uses: ./
-    - id: gradle
-      working-directory: __tests__/samples/kotlin-dsl
-      run: ./gradlew help
-    - name: "Comment build scan url"
-      uses: actions/github-script@v5
-      with:
-        github-token: ${{secrets.GITHUB_TOKEN}}
-        script: |
-          github.rest.issues.createComment({
-            issue_number: context.issue.number,
-            owner: context.repo.owner,
-            repo: context.repo.repo,
-            body: 'PR ready for review: ${{ steps.gradle.outputs.build-scan-url }}'
-          })

.gitignore

@@ -1,106 +0,0 @@
-# Dependency directory
-node_modules
-
-# Rest pulled from https://github.com/github/gitignore/blob/master/Node.gitignore
-# Logs
-logs
-*.log
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-lerna-debug.log*
-
-# Diagnostic reports (https://nodejs.org/api/report.html)
-report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
-
-# Runtime data
-pids
-*.pid
-*.seed
-*.pid.lock
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-*.lcov
-
-# nyc test coverage
-.nyc_output
-
-# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Bower dependency directory (https://bower.io/)
-bower_components
-
-# node-waf configuration
-.lock-wscript
-
-# Compiled binary addons (https://nodejs.org/api/addons.html)
-build/Release
-
-# Dependency directories
-jspm_packages/
-
-# TypeScript v1 declaration files
-typings/
-
-# TypeScript cache
-*.tsbuildinfo
-
-# Optional npm cache directory
-.npm
-
-# Optional eslint cache
-.eslintcache
-
-# Optional REPL history
-.node_repl_history
-
-# Output of 'npm pack'
-*.tgz
-
-# Yarn Integrity file
-.yarn-integrity
-
-# dotenv environment variables file
-.env
-.env.test
-
-# parcel-bundler cache (https://parceljs.org/)
-.cache
-
-# next.js build output
-.next
-
-# nuxt.js build output
-.nuxt
-
-# vuepress build output
-.vuepress/dist
-
-# Serverless directories
-.serverless/
-
-# FuseBox cache
-.fusebox/
-
-# DynamoDB Local files
-.dynamodb/
-
-# OS metadata
-.DS_Store
-Thumbs.db
-
-# Ignore built ts files
-__tests__/runner/*
-# lib/**/*
-
-# IntelliJ IDEA config files
-.idea/
-*.iml
-
-# ASDF tool configuration
-.tool-versions

.prettierignore

@@ -1,3 +0,0 @@
-dist/
-lib/
-node_modules/

.prettierrc.json

@@ -1,11 +0,0 @@
-{
-    "printWidth": 120,
-    "tabWidth": 4,
-    "useTabs": false,
-    "semi": false,
-    "singleQuote": true,
-    "trailingComma": "none",
-    "bracketSpacing": false,
-    "arrowParens": "avoid",
-    "parser": "typescript"
-  }

CODE_OF_CONDUCT.md

@@ -1,76 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
- advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at paul@nosphere.org. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org
-
-For answers to common questions about this code of conduct, see
-https://www.contributor-covenant.org/faq

LICENSE

@@ -1,22 +0,0 @@
-
-The MIT License (MIT)
-
-Copyright (c) 2018 GitHub, Inc. and contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

README.md

@@ -1,327 +1,3 @@
-# Execute Gradle builds in GitHub Actions workflows
+# GitHub Actions for Gradle builds
 
-This GitHub Action can be used to configure Gradle and optionally execute a Gradle build on any platform supported by GitHub Actions.
-
-## Use the action to setup Gradle
-
-If you have an existing workflow invoking Gradle, you can add an initial "Setup Gradle" Step to benefit from caching, 
-build-scan capture and other features of the gradle-build-action.
-
-All subsequent Gradle invocations will benefit from this initial setup, via `init` scripts added to the Gradle User Home.
-
-```yaml
-name: Run Gradle on PRs
-on: pull_request
-jobs:
-  gradle:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-java@v2
-      with:
-        distribution: temurin
-        java-version: 11
-        
-    - name: Setup Gradle
-      uses: gradle/gradle-build-action@v2
-    
-    - name: Execute Gradle build
-      run: ./gradlew build
-```
-
-## Why use the `gradle-build-action`?
-
-It is possible to directly invoke Gradle in your workflow, and the `actions/setup-java@v2` action provides a simple way to cache Gradle dependencies. 
-
-However, the `gradle-build-action` offers a number of advantages over this approach:
-
-- Easily [run the build with different versions of Gradle](#download-install-and-use-a-specific-gradle-version) using the `gradle-version` parameter. Gradle distributions are automatically downloaded and cached. 
-- More sophisticated and more efficient caching of Gradle User Home between invocations, compared to `setup-java` and most custom configurations using `actions/cache`. [More details below](#caching).
-- Detailed reporting of cache usage and cache configuration options allow you to [optimize the use of the GitHub actions cache](#optimizing-cache-effectiveness).
-- [Automatic capture of build scan links](#build-scans) from the build, making these easier to locate for workflow run.
-
-The `gradle-build-action` is designed to provide these benefits with minimal configuration. 
-These features work both when Gradle is executed via the `gradle-build-action` and for any Gradle execution in subsequent steps.
-
-When using `gradle-build-action` we recommend that you _not_ use `actions/cache` or `actions/setup-java@v2` to explicitly cache the Gradle User Home. Doing so may interfere with the caching provided by this action.
-
-## Use a specific Gradle version
-
-The `gradle-build-action` can download and install a specified Gradle version, adding this installed version to the PATH.
-Downloaded Gradle versions are stored in the GitHub Actions cache, to avoid requiring downloading again later.
-
-```yaml
- - uses: gradle/gradle-build-action@v2
-   with:
-     gradle-version: 6.5
-```
-
-The `gradle-version` parameter can be set to any valid Gradle version.
-
-Moreover, you can use the following aliases:
-
-| Alias | Selects |
-| --- |---|
-| `wrapper`           | The Gradle wrapper's version (default, useful for matrix builds) |
-| `current`           | The current [stable release](https://gradle.org/install/) |
-| `release-candidate` | The current [release candidate](https://gradle.org/release-candidate/) if any, otherwise fallback to `current` |
-| `nightly`           | The latest [nightly](https://gradle.org/nightly/), fails if none. |
-| `release-nightly`   | The latest [release nightly](https://gradle.org/release-nightly/), fails if none.      |
-
-This can be handy to automatically verify your build works with the latest release candidate of Gradle:
-
-```yaml
-name: Test latest Gradle RC
-on:
-  schedule:
-    - cron: 0 0 * * * # daily
-jobs:
-  gradle-rc:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-java@v2
-      with:
-        java-version: 11
-    - uses: gradle/gradle-build-action@v2
-      with:
-        gradle-version: release-candidate
-    - run: gradle build --dry-run # just test build configuration
-```
-
-## Gradle Execution
-
-If the action is configured with an `arguments` input, then Gradle will execute a Gradle build with the arguments provided.
-
-If no `arguments` are provided, the action will not execute Gradle, but will still cache Gradle state and configure build-scan capture for all subsequent Gradle executions.
-
-```yaml
-name: Run Gradle on PRs
-on: pull_request
-jobs:
-  gradle:
-    strategy:
-      matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
-    runs-on: ${{ matrix.os }}
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-java@v2
-      with:
-        java-version: 11
-    
-    - name: Setup and execute Gradle 'test' task
-      uses: gradle/gradle-build-action@v2
-      with:
-        arguments: test
-```
-
-### Multiple Gradle executions in the same Job
-
-It is possible to configure multiple Gradle executions to run sequentially in the same job. 
-The initial Action step will perform the Gradle setup.
-
-```yaml
-- uses: gradle/gradle-build-action@v2
-  with:
-    arguments: assemble
-- uses: gradle/gradle-build-action@v2
-  with:
-    arguments: check
-```
-
-### Gradle command-line arguments
-
-The `arguments` input can used to pass arbitrary arguments to the `gradle` command line.
-Arguments can be supplied in a single line, or as a multi-line input.
-
-Here are some valid examples:
-```yaml
-arguments: build
-arguments: check --scan
-arguments: some arbitrary tasks
-arguments: build -PgradleProperty=foo
-arguments: |
-    build
-    --scan
-    -PgradleProperty=foo
-    -DsystemProperty=bar
-```
-
-If you need to pass environment variables, use the GitHub Actions workflow syntax:
-
-```yaml
-- uses: gradle/gradle-build-action@v2
-  env:
-    CI: true
-  with:
-    arguments: build
-```
-
-### Gradle build located in a subdirectory
-
-By default, the action will execute Gradle in the root directory of your project. 
-Use the `build-root-directory` input to target a Gradle build in a subdirectory.
-
-```yaml
-- uses: gradle/gradle-build-action@v2
-  with:
-    arguments: build
-    build-root-directory: some/subdirectory
-```
-
-### Using a specific Gradle executable
-
-The action will first look for a Gradle wrapper script in the root directory of your project. 
-If not found, `gradle` will be executed from the PATH.
-Use the `gradle-executable` input to execute using a specific Gradle installation.
-
-```yaml
- - uses: gradle/gradle-build-action@v2
-   with:
-     arguments: build
-     gradle-executable: /path/to/installed/gradle
-```
-
-This mechanism can also be used to target a Gradle wrapper script that is located in a non-default location.
-
-## Caching
-
-By default, this action aims to cache any and all reusable state that may be speed up a subsequent build invocation. 
-
-The state that is cached includes:
-- Any distributions downloaded to satisfy a `gradle-version` parameter ;
-- A subset of the Gradle User Home directory, including downloaded dependencies, wrapper distributions, and the local build cache ;
-- Any [configuration-cache](https://docs.gradle.org/nightly/userguide/configuration_cache.html) data stored in the project `.gradle` directory.
-
-To reduce the space required for caching, this action makes a best effort to reduce duplication in cache entries.
-
-Caching is enabled by default. You can disable caching for the action as follows:
-```yaml
-cache-disabled: true
-```
-
-### Cache keys
-
-For distributions downloaded to satisfy a `gradle-version` parametere are stored outside of Gradle User Home and cached separately. The cache key is unique to the downloaded distribution and will not change over time.
-
-The state of the Gradle User Home and configuration-cache are highly dependent on the Gradle execution, so the cache key is composed of the current commit hash and the GitHub actions job id.
-As such, the cache key is likely to change on each subsequent run of GitHub actions. 
-This allows the most recent state to always be available in the GitHub actions cache.
-
-To reduce duplication between cache entries, certain artifacts are cached independently based on their identity.
-Artifacts that are cached independently include downloaded dependencies, downloaded wrapper distributions and generated Gradle API jars.
-For example, this means that all jobs executing a particular version of the Gradle wrapper will share common entries for wrapper distributions and for generated Gradle API jars.
-
-### Using the caches read-only
-
-In some circumstances, it makes sense for a Gradle invocation to read any existing cache entries but not to write changes back.
-For example, you may want to write cache entries for builds on your `main` branch, but not for any PR build invocations.
-
-You can enable read-only caching for any of the caches as follows:
-
-```yaml
-# Only write to the cache for builds on the 'main' branch.
-# Builds on other branches will only read existing entries from the cache.
-cache-read-only: ${{ github.ref != 'refs/heads/main' }}
-```
-
-### Gradle User Home cache tuning
-
-As well as any wrapper distributions, the action will attempt to save and restore the `caches` and `notifications` directories from Gradle User Home.
-
-The contents to be cached can be fine tuned by including and excluding certain paths with Gradle User Home.
-
-```yaml
-# Cache downloaded JDKs in addition to the default directories.
-gradle-home-cache-includes: |
-    caches
-    notifications
-    jdks
-# Exclude the local build-cache from the directories cached.
-gradle-home-cache-excludes: |
-    caches/build-cache-1
-```
-
-You can specify any number of fixed paths or patterns to include or exclude. 
-File pattern support is documented at https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#patterns-to-match-file-paths.
-
-### Cache debugging and analysis
-
-Gradle User Home state will be restored from the cache during the first `gradle-build-action` step for any workflow job. 
-This state will be saved back to the cache at the end of the job, after all Gradle executions have completed.
-A report of all cache entries restored and saved is printed to the action log when saving the cache entries. 
-This report can provide valuable insignt into how much cache space is being used.
-
-It is possible to enable additional debug logging for cache operations. You do via the `GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED` environment variable:
-
-```yaml
-env:
-  GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED: true
-```
-
-Note that this setting will also prevent certain cache operations from running in parallel, further assisting with debugging.
-
-### Optimizing cache effectiveness
-
-Cache storage space for GitHub actions is limited, and writing new cache entries can trigger the deletion of exising entries.
-Eviction of shared cache entries can reduce cache effectiveness, slowing down your `gradle-build-action` steps.
-
-There are a number of actions you can take if your cache use is less effective due to entry eviction.
-
-#### Only write to the cache from the default branch
-
-GitHub cache entries are not shared between builds on different branches. This means that identical cache entries will be stored separately for different branches.
-The exception to the is cache entries for the default (`master`/`main`) branch can be read by actions invoked for other branches.
-
-An easy way to reduce cache usage when you run builds on many different branches is to only permit your default branch to write to the cache,
-with all other branch builds using `cache-read-only`. See [Using the caches read-only](#using-the-caches-read-only) for more details.
-
-Similarly, you could use `cache-read-only` for certain jobs in the workflow, and instead have these jobs reuse the cache content from upstream jobs.
-
-#### Exclude content from Gradle User Home cache
-
-Each build is different, and some builds produce more Gradle User Home content than others.
-[Cache debugging ](#cache-debugging-and-analysis) can provide insight into which cache entries are the largest,
-and you can selectively [exclude content using `gradle-home-cache-exclude`](#gradle-user-home-cache-tuning).
-
-## Build scans
-
-If your build publishes a [build scan](https://gradle.com/build-scans/) the `gradle-build-action` action will:
-- Add a notice with the link to the GitHub Actions user interface
-- For each step that executes Gradle, adds the link to the published build scan as a Step output named `build-scan-url`.
-
-You can then use that link in subsequent actions of your workflow. For example:
-
-```yaml
-# .github/workflows/gradle-build-pr.yml
-name: Run Gradle on PRs
-on: pull_request
-jobs:
-  gradle:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-java@v2
-      with:
-        distribution: temurin
-        java-version: 11
-    - uses: gradle/gradle-build-action@v2
-    - id: gradle
-      run: ./gradlew build
-    - name: "Comment build scan url"
-      uses: actions/github-script@v5
-      if: github.event_name == 'pull_request' && failure()
-      with:
-        github-token: ${{secrets.GITHUB_TOKEN}}
-        script: |
-          github.rest.issues.createComment({
-            issue_number: context.issue.number,
-            owner: context.repo.owner,
-            repo: context.repo.repo,
-            body: '❌ ${{ github.workflow }} failed: ${{ steps.gradle.outputs.build-scan-url }}'
-          })
-```
+This repository contains a set of GitHub Actions that are useful for building Gradle projects on GitHub.

__tests__/cache-reporting.test.ts

@@ -1,95 +0,0 @@
-import {CacheEntryListener, CacheListener} from '../src/cache-reporting'
-
-describe('caching report', () => {
-    describe('reports not fully restored', () => {
-        it('with one requested entry report', async () => {
-            const report = new CacheListener()
-            report.entry('foo').markRequested('1', ['2'])
-            report.entry('bar').markRequested('3').markRestored('4', 500)
-            expect(report.fullyRestored).toBe(false)
-        })
-    })
-    describe('reports fully restored', () => {
-        it('when empty', async () => {
-            const report = new CacheListener()
-            expect(report.fullyRestored).toBe(true)
-        })
-        it('with empty entry reports', async () => {
-            const report = new CacheListener()
-            report.entry('foo')
-            report.entry('bar')
-            expect(report.fullyRestored).toBe(true)
-        })
-        it('with restored entry report', async () => {
-            const report = new CacheListener()
-            report.entry('bar').markRequested('3').markRestored('4', 300)
-            expect(report.fullyRestored).toBe(true)
-        })
-        it('with multiple restored entry reportss', async () => {
-            const report = new CacheListener()
-            report.entry('foo').markRestored('4', 3300)
-            report.entry('bar').markRequested('3').markRestored('4', 333)
-            expect(report.fullyRestored).toBe(true)
-        })
-    })
-    describe('can be stringified and rehydrated', () => {
-        it('when empty', async () => {
-            const report = new CacheListener()
-
-            const stringRep = report.stringify()
-            const reportClone: CacheListener = CacheListener.rehydrate(stringRep)
-
-            expect(reportClone.cacheEntries).toEqual([])
-
-            // Can call methods on rehydrated
-            expect(reportClone.entry('foo')).toBeInstanceOf(CacheEntryListener)
-        })
-        it('with entry reports', async () => {
-            const report = new CacheListener()
-            report.entry('foo')
-            report.entry('bar')
-            report.entry('baz')
-
-            const stringRep = report.stringify()
-            const reportClone: CacheListener = CacheListener.rehydrate(stringRep)
-
-            expect(reportClone.cacheEntries.length).toBe(3)
-            expect(reportClone.cacheEntries[0].entryName).toBe('foo')
-            expect(reportClone.cacheEntries[1].entryName).toBe('bar')
-            expect(reportClone.cacheEntries[2].entryName).toBe('baz')
-
-            expect(reportClone.entry('foo')).toBe(reportClone.cacheEntries[0])
-        })
-        it('with rehydrated entry report', async () => {
-            const report = new CacheListener()
-            const entryReport = report.entry('foo')
-            entryReport.markRequested('1', ['2', '3'])
-            entryReport.markSaved('4', 100)
-
-            const stringRep = report.stringify()
-            const reportClone: CacheListener = CacheListener.rehydrate(stringRep)
-            const entryClone = reportClone.entry('foo')
-
-            expect(entryClone.requestedKey).toBe('1')
-            expect(entryClone.requestedRestoreKeys).toEqual(['2', '3'])
-            expect(entryClone.savedKey).toBe('4')
-        })
-        it('with live entry report', async () => {
-            const report = new CacheListener()
-            const entryReport = report.entry('foo')
-            entryReport.markRequested('1', ['2', '3'])
-
-            const stringRep = report.stringify()
-            const reportClone: CacheListener = CacheListener.rehydrate(stringRep)
-            const entryClone = reportClone.entry('foo')
-
-            // Check type and call method on rehydrated entry report
-            expect(entryClone).toBeInstanceOf(CacheEntryListener)
-            entryClone.markSaved('4', 100)
-
-            expect(entryClone.requestedKey).toBe('1')
-            expect(entryClone.requestedRestoreKeys).toEqual(['2', '3'])
-            expect(entryClone.savedKey).toBe('4')
-        })
-    })
-})

__tests__/cache-utils.test.ts

@@ -1,20 +0,0 @@
-import * as cacheUtils from '../src/cache-utils'
-
-describe('cacheUtils-utils', () => {
-    describe('can hash', () => {
-        it('a string', async () => {
-            const hash = cacheUtils.hashStrings(['foo'])
-            expect(hash).toBe('acbd18db4cc2f85cedef654fccc4a4d8')
-        })
-        it('multiple strings', async () => {
-            const hash = cacheUtils.hashStrings(['foo', 'bar', 'baz'])
-            expect(hash).toBe('6df23dc03f9b54cc38a0fc1483df6e21')
-        })
-        it('normalized filenames', async () => {
-            const fileNames = ['/foo/bar/baz.zip', '../boo.html']
-            const posixHash = cacheUtils.hashFileNames(fileNames)
-            const windowsHash = cacheUtils.hashFileNames(fileNames)
-            expect(posixHash).toBe(windowsHash)
-        })
-    })
-})

__tests__/data/cache-wrapper-test/gradle-wrapper.properties

@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

__tests__/data/crypto-utils-test/.gitattributes

@@ -1,6 +0,0 @@
-#
-# https://help.github.com/articles/dealing-with-line-endings/
-#
-# These are explicitly windows files and should use crlf
-*.bat           text eol=crlf
-

__tests__/data/crypto-utils-test/.gitignore

@@ -1,5 +0,0 @@
-# Ignore Gradle project-specific cache directory
-.gradle
-
-# Ignore Gradle build output directory
-build

__tests__/data/crypto-utils-test/build.gradle

@@ -1,11 +0,0 @@
-plugins {
-    id 'java'
-}
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    testImplementation('junit:junit:4.12')
-}

__tests__/data/crypto-utils-test/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

__tests__/data/crypto-utils-test/gradlew

@@ -1,185 +0,0 @@
-#!/usr/bin/env sh
-
-#
-# Copyright 2015 the original author or authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-##
-##  Gradle start up script for UN*X
-##
-##############################################################################
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn () {
-    echo "$*"
-}
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
-    else
-        JAVACMD="$JAVA_HOME/bin/java"
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
-fi
-
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
-
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
-
-exec "$JAVACMD" "$@"

__tests__/data/crypto-utils-test/gradlew.bat

@@ -1,104 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
-
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
-
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

__tests__/data/crypto-utils-test/settings.gradle

@@ -1,10 +0,0 @@
-/*
- * This file was generated by the Gradle 'init' task.
- *
- * The settings file is used to specify which projects to include in your build.
- *
- * Detailed information about configuring a multi-project build in Gradle can be found
- * in the user manual at https://docs.gradle.org/6.5/userguide/multi_project_builds.html
- */
-
-rootProject.name = 'basic'

__tests__/data/crypto-utils-test/src/test/java/basic/BasicTest.java

@@ -1,10 +0,0 @@
-package basic;
-
-import org.junit.Test;
-
-public class BasicTest {
-    @Test
-    public void test() {
-        assert true;
-    }
-}

__tests__/samples/.gitignore

@@ -1,5 +0,0 @@
-# Ignore Gradle project-specific cache directory
-.gradle
-
-# Ignore Gradle build output directory
-build

__tests__/samples/gradle-plugin/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionSha256Sum=e5444a57cda4a95f90b0c9446a9e1b47d3d7f69057765bfb54bd4f482542d548
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

__tests__/samples/gradle-plugin/gradlew

@@ -1,234 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
-APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

__tests__/samples/gradle-plugin/gradlew.bat

@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

__tests__/samples/gradle-plugin/plugin/build.gradle

@@ -1,60 +0,0 @@
-/*
- * This file was generated by the Gradle 'init' task.
- *
- * This generated file contains a sample Gradle plugin project to get you started.
- * For more details take a look at the Writing Custom Plugins chapter in the Gradle
- * User Manual available at https://docs.gradle.org/7.3/userguide/custom_plugins.html
- * This project uses @Incubating APIs which are subject to change.
- */
-
-plugins {
-    // Apply the Java Gradle plugin development plugin to add support for developing Gradle plugins
-    id 'java-gradle-plugin'
-}
-
-repositories {
-    // Use Maven Central for resolving dependencies.
-    mavenCentral()
-}
-
-testing {
-    suites {
-        // Configure the built-in test suite
-        test {
-            // Use JUnit Jupiter test framework
-            useJUnitJupiter('5.7.2')
-        }
-
-        // Create a new test suite
-        functionalTest(JvmTestSuite) {
-            dependencies {
-                // functionalTest test suite depends on the production code in tests
-                implementation project
-            }
-
-            targets {
-                all {
-                    // This test suite should run after the built-in test suite has run its tests
-                    testTask.configure { shouldRunAfter(test) } 
-                }
-            }
-        }
-    }
-}
-
-gradlePlugin {
-    // Define the plugin
-    plugins {
-        greeting {
-            id = 'org.example.gradle.plugin.greeting'
-            implementationClass = 'org.example.gradle.plugin.GradlePluginPlugin'
-        }
-    }
-}
-
-gradlePlugin.testSourceSets(sourceSets.functionalTest)
-
-tasks.named('check') {
-    // Include functionalTest as part of the check lifecycle
-    dependsOn(testing.suites.functionalTest)
-}

__tests__/samples/gradle-plugin/plugin/src/functionalTest/java/org/example/gradle/plugin/GradlePluginPluginFunctionalTest.java

@@ -1,57 +0,0 @@
-/*
- * This Java source file was generated by the Gradle 'init' task.
- */
-package org.example.gradle.plugin;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.Writer;
-import java.io.FileWriter;
-import java.nio.file.Files;
-import org.gradle.testkit.runner.GradleRunner;
-import org.gradle.testkit.runner.BuildResult;
-import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.io.TempDir;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * A simple functional test for the 'org.example.gradle.plugin.greeting' plugin.
- */
-class GradlePluginPluginFunctionalTest {
-    @TempDir
-    File projectDir;
-
-    private File getBuildFile() {
-        return new File(projectDir, "build.gradle");
-    }
-
-    private File getSettingsFile() {
-        return new File(projectDir, "settings.gradle");
-    }
-
-    @Test void canRunTaskWithGradle691() throws IOException {
-        writeString(getSettingsFile(), "");
-        writeString(getBuildFile(),
-            "plugins {" +
-            "  id('org.example.gradle.plugin.greeting')" +
-            "}");
-
-        // Run the build
-        GradleRunner runner = GradleRunner.create();
-        runner.forwardOutput();
-        runner.withGradleVersion("6.9.1");
-        runner.withPluginClasspath();
-        runner.withArguments("greeting");
-        runner.withProjectDir(projectDir);
-        BuildResult result = runner.build();
-
-        // Verify the result
-        assertTrue(result.getOutput().contains("Hello from plugin 'org.example.gradle.plugin.greeting'"));
-    }
-
-    private void writeString(File file, String string) throws IOException {
-        try (Writer writer = new FileWriter(file)) {
-            writer.write(string);
-        }
-    }
-}

__tests__/samples/gradle-plugin/plugin/src/main/java/org/example/gradle/plugin/GradlePluginPlugin.java

@@ -1,19 +0,0 @@
-/*
- * This Java source file was generated by the Gradle 'init' task.
- */
-package org.example.gradle.plugin;
-
-import org.gradle.api.Project;
-import org.gradle.api.Plugin;
-
-/**
- * A simple 'hello world' plugin.
- */
-public class GradlePluginPlugin implements Plugin<Project> {
-    public void apply(Project project) {
-        // Register a task
-        project.getTasks().register("greeting", task -> {
-            task.doLast(s -> System.out.println("Hello from plugin 'org.example.gradle.plugin.greeting'"));
-        });
-    }
-}

__tests__/samples/gradle-plugin/plugin/src/test/java/org/example/gradle/plugin/GradlePluginPluginTest.java

@@ -1,23 +0,0 @@
-/*
- * This Java source file was generated by the Gradle 'init' task.
- */
-package org.example.gradle.plugin;
-
-import org.gradle.testfixtures.ProjectBuilder;
-import org.gradle.api.Project;
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * A simple unit test for the 'org.example.gradle.plugin.greeting' plugin.
- */
-class GradlePluginPluginTest {
-    @Test void pluginRegistersATask() {
-        // Create a test project and apply the plugin
-        Project project = ProjectBuilder.builder().build();
-        project.getPlugins().apply("org.example.gradle.plugin.greeting");
-
-        // Verify the result
-        assertNotNull(project.getTasks().findByName("greeting"));
-    }
-}

__tests__/samples/gradle-plugin/settings.gradle

@@ -1,12 +0,0 @@
-/*
- * This file was generated by the Gradle 'init' task.
- *
- * The settings file is used to specify which projects to include in your build.
- *
- * Detailed information about configuring a multi-project build in Gradle can be found
- * in the user manual at https://docs.gradle.org/7.3/userguide/multi_project_builds.html
- * This project uses @Incubating APIs which are subject to change.
- */
-
-rootProject.name = 'gradle-plugin'
-include('plugin')

__tests__/samples/groovy-dsl/build.gradle

@@ -1,22 +0,0 @@
-plugins {
-    id 'java'
-}
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    testImplementation('junit:junit:4.12')
-}
-
-tasks.named("test").configure {
-    // Echo an output value so we can detect configuration-cache usage
-    println "::set-output name=task_configured::yes"
-
-    doLast {
-        if (System.properties.verifyCachedBuild) {
-            throw new RuntimeException("Build was not cached: unexpected execution of test task")
-        }
-    }
-}

__tests__/samples/groovy-dsl/gradle.properties

@@ -1 +0,0 @@
-org.gradle.caching=true

__tests__/samples/groovy-dsl/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionSha256Sum=e5444a57cda4a95f90b0c9446a9e1b47d3d7f69057765bfb54bd4f482542d548
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

__tests__/samples/groovy-dsl/gradlew

@@ -1,234 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
-APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

__tests__/samples/groovy-dsl/gradlew.bat

@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

__tests__/samples/groovy-dsl/settings.gradle

@@ -1 +0,0 @@
-rootProject.name = 'basic'

__tests__/samples/groovy-dsl/src/test/java/basic/BasicTest.java

@@ -1,10 +0,0 @@
-package basic;
-
-import org.junit.Test;
-
-public class BasicTest {
-    @Test
-    public void test() {
-        assert true;
-    }
-}

__tests__/samples/java-toolchain/build.gradle

@@ -1,17 +0,0 @@
-plugins {
-    id 'java'
-}
-
-java {
-    toolchain {
-        languageVersion = JavaLanguageVersion.of(16)
-    }
-}
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    testImplementation('junit:junit:4.12')
-}

__tests__/samples/java-toolchain/gradle.properties

@@ -1 +0,0 @@
-org.gradle.caching=true

__tests__/samples/java-toolchain/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionSha256Sum=e5444a57cda4a95f90b0c9446a9e1b47d3d7f69057765bfb54bd4f482542d548
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

__tests__/samples/java-toolchain/gradlew

@@ -1,234 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
-APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

__tests__/samples/java-toolchain/gradlew.bat

@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

__tests__/samples/java-toolchain/settings.gradle

@@ -1 +0,0 @@
-rootProject.name = 'basic'

__tests__/samples/java-toolchain/src/test/java/basic/BasicTest.java

@@ -1,10 +0,0 @@
-package basic;
-
-import org.junit.Test;
-
-public class BasicTest {
-    @Test
-    public void test() {
-        assert true;
-    }
-}

__tests__/samples/kotlin-dsl/build.gradle.kts

@@ -1,29 +0,0 @@
-plugins {
-    `java-library`
-}
-
-repositories {
-    mavenCentral()
-}
-
-dependencies {
-    api("org.apache.commons:commons-math3:3.6.1")
-    implementation("com.google.guava:guava:31.1-jre")
-
-    testImplementation("org.junit.jupiter:junit-jupiter:5.8.2")
-}
-
-tasks.test {
-    useJUnitPlatform()
-}
-
-tasks.named("test").configure {
-    // Echo an output value so we can detect configuration-cache usage
-    println("::set-output name=task_configured::yes")
-
-    doLast {
-        if (System.getProperties().containsKey("verifyCachedBuild")) {
-            throw RuntimeException("Build was not cached: unexpected execution of test task")
-        }
-    }
-}

__tests__/samples/kotlin-dsl/gradle.properties

@@ -1 +0,0 @@
-org.gradle.caching=true

__tests__/samples/kotlin-dsl/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionSha256Sum=e5444a57cda4a95f90b0c9446a9e1b47d3d7f69057765bfb54bd4f482542d548
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

__tests__/samples/kotlin-dsl/gradlew

@@ -1,234 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-##############################################################################
-#
-#   Gradle start up script for POSIX generated by Gradle.
-#
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
-##############################################################################
-
-# Attempt to set APP_HOME
-
-# Resolve links: $0 may be a link
-app_path=$0
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
-APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
-
-warn () {
-    echo "$*"
-} >&2
-
-die () {
-    echo
-    echo "$*"
-    echo
-    exit 1
-} >&2
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-nonstop=false
-case "$( uname )" in                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | MINGW* )  msys=true    ;; #(
-  NONSTOP* )        nonstop=true ;;
-esac
-
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
-
-
-# Determine the Java command to use to start the JVM.
-if [ -n "$JAVA_HOME" ] ; then
-    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
-        # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
-fi
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

__tests__/samples/kotlin-dsl/gradlew.bat

@@ -1,89 +0,0 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
-@if "%DEBUG%" == "" @echo off
-@rem ##########################################################################
-@rem
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
-set APP_BASE_NAME=%~n0
-set APP_HOME=%DIRNAME%
-
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:execute
-@rem Setup the command line
-
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

__tests__/samples/kotlin-dsl/settings.gradle.kts

@@ -1,15 +0,0 @@
-plugins {
-    id("com.gradle.enterprise") version "3.9"
-}
-
-gradleEnterprise {
-    buildScan {
-        termsOfServiceUrl = "https://gradle.com/terms-of-service"
-        termsOfServiceAgree = "yes"
-        publishAlways()
-        isUploadInBackground = false
-    }
-}
-
-rootProject.name = "kotlin-dsl"
-

__tests__/samples/kotlin-dsl/src/main/java/com/example/Library.java

@@ -1,10 +0,0 @@
-/*
- * This Java source file was generated by the Gradle 'init' task.
- */
-package com.example;
-
-public class Library {
-    public boolean someLibraryMethod() {
-        return true;
-    }
-}

__tests__/samples/kotlin-dsl/src/test/java/com/example/LibraryTest.java

@@ -1,14 +0,0 @@
-/*
- * This Java source file was generated by the Gradle 'init' task.
- */
-package com.example;
-
-import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-class LibraryTest {
-    @Test void someLibraryMethodReturnsTrue() {
-        Library classUnderTest = new Library();
-        assertTrue(classUnderTest.someLibraryMethod(), "someLibraryMethod should return 'true'");
-    }
-}

__tests__/samples/no-wrapper-gradle-4/build.gradle

@@ -1,10 +0,0 @@
-plugins {
-    id "com.gradle.build-scan" version "1.16"
-}
-
-buildScan {
-    termsOfServiceUrl = "https://gradle.com/terms-of-service"
-    termsOfServiceAgree = "yes"
-    publishAlways()
-}
-

__tests__/samples/no-wrapper-gradle-4/settings.gradle

@@ -1,8 +0,0 @@
-rootProject.name = 'no-wrapper'
-
-println "Using Gradle version: ${gradle.gradleVersion}"
-
-def gradleVersionCheck = System.properties.gradleVersionCheck
-if (gradleVersionCheck && gradle.gradleVersion != gradleVersionCheck) {
-    throw new RuntimeException("Got the wrong version: expected ${gradleVersionCheck} but was ${gradle.gradleVersion}")
-}

__tests__/samples/no-wrapper-gradle-5/build.gradle

@@ -1,12 +0,0 @@
-plugins {
-    id("com.gradle.build-scan") version("3.7")
-}
-
-gradleEnterprise {
-    buildScan {
-        termsOfServiceUrl = "https://gradle.com/terms-of-service"
-        termsOfServiceAgree = "yes"
-        publishAlways()
-        uploadInBackground = false
-    }
-}

__tests__/samples/no-wrapper-gradle-5/settings.gradle

@@ -1,8 +0,0 @@
-rootProject.name = 'no-wrapper'
-
-println "Using Gradle version: ${gradle.gradleVersion}"
-
-def gradleVersionCheck = System.properties.gradleVersionCheck
-if (gradleVersionCheck && gradle.gradleVersion != gradleVersionCheck) {
-    throw new RuntimeException("Got the wrong version: expected ${gradleVersionCheck} but was ${gradle.gradleVersion}")
-}

__tests__/samples/no-wrapper/build.gradle

@@ -1 +0,0 @@
-// Required to keep dependabot happy

__tests__/samples/no-wrapper/settings.gradle

@@ -1,21 +0,0 @@
-plugins {
-    id "com.gradle.enterprise"  version "3.9"
-}
-
-gradleEnterprise {
-    buildScan {
-        termsOfServiceUrl = "https://gradle.com/terms-of-service"
-        termsOfServiceAgree = "yes"
-        publishAlways()
-        uploadInBackground = false
-    }
-}
-
-rootProject.name = 'no-wrapper'
-
-println "Using Gradle version: ${gradle.gradleVersion}"
-
-def gradleVersionCheck = System.properties.gradleVersionCheck
-if (gradleVersionCheck && gradle.gradleVersion != gradleVersionCheck) {
-    throw new RuntimeException("Got the wrong version: expected ${gradleVersionCheck} but was ${gradle.gradleVersion}")
-}

action.yml

@@ -1,76 +1,13 @@
-name: "Gradle Build Action"
-description: 'Configures Gradle for use in GitHub actions, caching useful state in the GitHub actions cache'
-
-# https://help.github.com/en/articles/metadata-syntax-for-github-actions
-
-inputs:
-  gradle-version:
-    description: Gradle version to use
-    required: false
-
-  cache-disabled:
-    description: When 'true', all caching is disabled. No entries will be written to or read from the cache.
-    required: false
-    default: false
-
-  cache-read-only:
-    description: When 'true', existing entries will be read from the cache but no entries will be written.
-    required: false
-    default: false 
-  # e.g. Use the following setting to only write cache entries from your 'main' branch
-  #     cache-read-only: ${{ github.ref != 'refs/heads/main' }}
-
-  gradle-home-cache-includes:
-    description: Paths within Gradle User Home to cache.
-    required: false
-    default: |
-        caches
-        notifications
-
-  gradle-home-cache-excludes:
-    description: Paths within Gradle User Home to exclude from cache.
-    required: false
-  # e.g. Use the following setting to prevent the local build cache from being saved/restored
-  #      gradle-home-cache-excludes: |
-  #           caches/build-cache-1
-
-  arguments:
-    description: Gradle command line arguments (supports multi-line input)
-    required: false
-
-  build-root-directory:
-    description: Path to the root directory of the build
-    required: false
-
-  gradle-executable:
-    description: Path to the Gradle executable
-    required: false
-
-  # EXPERIMENTAL & INTERNAL ACTION INPUTS
-  # The following action properties allow fine-grained tweaking of the action caching behaviour.
-  # These properties are experimental and not (yet) designed for production use, and may change without notice in a subsequent release of `gradle-build-action`.
-  # Use at your own risk!
-  cache-write-only:
-    description: When 'true', entries will not be restored from the cache but will be saved at the end of the Job. This allows a 'clean' cache entry to be written.
-    required: false
-    default: false
-  gradle-home-cache-strict-match:
-    description: When 'true', the action will not attempt to restore the Gradle User Home entries from other Jobs.
-    required: false
-    default: false
-  workflow-job-context:
-    description: Used to uniquely identify the current job invocation. Defaults to the matrix values for this job; this should not be overridden by users (INTERNAL).
-    required: false
-    default: ${{ toJSON(matrix) }}
-
-outputs:
-  build-scan-url:
-    description: Link to the build scan if any
+name: Build with Gradle
+description: A collection of actions for building Gradle projects, as well as generating a dependency graph via Dependency Submission.
 
 runs:
-  using: 'node16'
-  main: 'dist/main/index.js'
-  post: 'dist/post/index.js'
+  using: "composite"
+  steps:
+  - name: Setup Gradle
+    uses: gradle/gradle-build-action@main
+    with:
+      cache-read-only: true
 
 branding:
   icon: 'box'

jest.config.js

@@ -1,12 +0,0 @@
-module.exports = {
-  clearMocks: true,
-  moduleFileExtensions: ['js', 'ts', 'json'],
-  testEnvironment: 'node',
-  testMatch: ['**/*.test.ts'],
-  testRunner: 'jest-circus/runner',
-  transform: {
-    '^.+\\.ts$': 'ts-jest'
-  },
-  verbose: true,
-  setupFilesAfterEnv: ['./jest.setup.js']
-}

jest.setup.js

@@ -1 +0,0 @@
-jest.setTimeout(10000) // in milliseconds

package.json

@@ -1,53 +0,0 @@
-{
-  "name": "gradle-build-action",
-  "version": "1.0.0",
-  "private": true,
-  "description": "Execute Gradle Build",
-  "scripts": {
-    "postinstall": "patch-package",
-    "format": "prettier --write **/*.ts",
-    "format-check": "prettier --check **/*.ts",
-    "lint": "eslint src/**/*.ts",
-    "build": "ncc build src/main.ts --out dist/main --source-map --minify && ncc build src/post.ts --out dist/post --source-map --minify",
-    "test": "jest",
-    "all": "npm run format && npm run lint && npm run build && npm test"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gradle/gradle-build-action.git"
-  },
-  "keywords": [
-    "github",
-    "actions",
-    "github-actions",
-    "gradle"
-  ],
-  "license": "MIT",
-  "dependencies": {
-    "@actions/cache": "1.0.10",
-    "@actions/core": "1.6.0",
-    "@actions/exec": "1.1.1",
-    "@actions/github": "5.0.0",
-    "@actions/glob": "0.2.1",
-    "@actions/http-client": "1.0.11",
-    "@actions/tool-cache": "1.7.2",
-    "string-argv": "0.3.1"
-  },
-  "devDependencies": {
-    "@types/jest": "27.4.1",
-    "@types/node": "16.11.21",
-    "@types/unzipper": "0.10.5",
-    "@typescript-eslint/parser": "5.15.0",
-    "@zeit/ncc": "0.22.3",
-    "eslint": "8.11.0",
-    "eslint-plugin-github": "4.3.5",
-    "eslint-plugin-jest": "26.1.1",
-    "jest": "27.5.1",
-    "jest-circus": "27.5.1",
-    "js-yaml": "4.1.0",
-    "patch-package": "6.4.7",
-    "prettier": "2.6.0",
-    "ts-jest": "27.1.3",
-    "typescript": "4.6.2"
-  }
-}

patches/@actions+cache+1.0.10.patch

@@ -1,108 +0,0 @@
-diff --git a/node_modules/@actions/cache/lib/cache.d.ts b/node_modules/@actions/cache/lib/cache.d.ts
-index 805a8e5..d3ab419 100644
---- a/node_modules/@actions/cache/lib/cache.d.ts
-+++ b/node_modules/@actions/cache/lib/cache.d.ts
-@@ -5,6 +5,11 @@ export declare class ValidationError extends Error {
- export declare class ReserveCacheError extends Error {
-     constructor(message: string);
- }
-+export declare class CacheEntry {
-+    key: string;
-+    size?: number;
-+    constructor(key: string, size?: number);
-+}
- /**
-  * Restores cache from keys
-  *
-@@ -14,7 +19,7 @@ export declare class ReserveCacheError extends Error {
-  * @param downloadOptions cache download options
-  * @returns string returns the key for the cache hit, otherwise returns undefined
-  */
--export declare function restoreCache(paths: string[], primaryKey: string, restoreKeys?: string[], options?: DownloadOptions): Promise<string | undefined>;
-+export declare function restoreCache(paths: string[], primaryKey: string, restoreKeys?: string[], options?: DownloadOptions): Promise<CacheEntry | undefined>;
- /**
-  * Saves a list of files with the specified key
-  *
-@@ -23,4 +28,4 @@ export declare function restoreCache(paths: string[], primaryKey: string, restor
-  * @param options cache upload options
-  * @returns number returns cacheId if the cache was saved successfully and throws an error if save fails
-  */
--export declare function saveCache(paths: string[], key: string, options?: UploadOptions): Promise<number>;
-+export declare function saveCache(paths: string[], key: string, options?: UploadOptions): Promise<CacheEntry>;
-diff --git a/node_modules/@actions/cache/lib/cache.js b/node_modules/@actions/cache/lib/cache.js
-index e3c43e6..c947d02 100644
---- a/node_modules/@actions/cache/lib/cache.js
-+++ b/node_modules/@actions/cache/lib/cache.js
-@@ -37,6 +37,13 @@ class ReserveCacheError extends Error {
-     }
- }
- exports.ReserveCacheError = ReserveCacheError;
-+class CacheEntry {
-+    constructor(key, size) {
-+        this.key = key;
-+        this.size = size;
-+    }
-+}
-+exports.CacheEntry = CacheEntry;
- function checkPaths(paths) {
-     if (!paths || paths.length === 0) {
-         throw new ValidationError(`Path Validation Error: At least one directory or file path is required`);
-@@ -84,6 +91,7 @@ function restoreCache(paths, primaryKey, restoreKeys, options) {
-         }
-         const archivePath = path.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
-         core.debug(`Archive Path: ${archivePath}`);
-+        const restoredEntry = new CacheEntry(cacheEntry.cacheKey);
-         try {
-             // Download the cache from the cache entry
-             yield cacheHttpClient.downloadCache(cacheEntry.archiveLocation, archivePath, options);
-@@ -91,6 +99,7 @@ function restoreCache(paths, primaryKey, restoreKeys, options) {
-                 yield tar_1.listTar(archivePath, compressionMethod);
-             }
-             const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
-+            restoredEntry.size = archiveFileSize;
-             core.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`);
-             yield tar_1.extractTar(archivePath, compressionMethod);
-             core.info('Cache restored successfully');
-@@ -104,7 +113,7 @@ function restoreCache(paths, primaryKey, restoreKeys, options) {
-                 core.debug(`Failed to delete archive: ${error}`);
-             }
-         }
--        return cacheEntry.cacheKey;
-+        return restoredEntry;
-     });
- }
- exports.restoreCache = restoreCache;
-@@ -135,6 +144,7 @@ function saveCache(paths, key, options) {
-         const archiveFolder = yield utils.createTempDirectory();
-         const archivePath = path.join(archiveFolder, utils.getCacheFileName(compressionMethod));
-         core.debug(`Archive Path: ${archivePath}`);
-+        const savedEntry = new CacheEntry(key);
-         try {
-             yield tar_1.createTar(archiveFolder, cachePaths, compressionMethod);
-             if (core.isDebug()) {
-@@ -142,6 +152,7 @@ function saveCache(paths, key, options) {
-             }
-             const fileSizeLimit = 10 * 1024 * 1024 * 1024; // 10GB per repo limit
-             const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
-+            savedEntry.size = archiveFileSize;
-             core.debug(`File Size: ${archiveFileSize}`);
-             if (archiveFileSize > fileSizeLimit) {
-                 throw new Error(`Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`);
-@@ -158,7 +169,7 @@ function saveCache(paths, key, options) {
-                 core.debug(`Failed to delete archive: ${error}`);
-             }
-         }
--        return cacheId;
-+        return savedEntry;
-     });
- }
- exports.saveCache = saveCache;
-diff --git a/node_modules/@actions/cache/lib/cache.js.map b/node_modules/@actions/cache/lib/cache.js.map
-index ec474b2..7e09719 100644
---- a/node_modules/@actions/cache/lib/cache.js.map
-+++ b/node_modules/@actions/cache/lib/cache.js.map
-@@ -1 +1 @@
--{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"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"}
-\ No newline at end of file
-+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAAA,oDAAqC;AACrC,2CAA4B;AAC5B,6DAA8C;AAC9C,4EAA6D;AAC7D,wCAA6D;AAG7D,MAAa,eAAgB,SAAQ,KAAK;IACxC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAA;QAC7B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,eAAe,CAAC,SAAS,CAAC,CAAA;IACxD,CAAC;CACF;AAND,0CAMC;AAED,MAAa,iBAAkB,SAAQ,KAAK;IAC1C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,mBAAmB,CAAA;QAC/B,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAA;IAC1D,CAAC;CACF;AAND,8CAMC;AAED,MAAa,UAAU;IAIrB,YAAY,GAAW,EAAE,IAAa;QACpC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;CACF;AARD,gCAQC;AAED,SAAS,UAAU,CAAC,KAAe;IACjC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;QAChC,MAAM,IAAI,eAAe,CACvB,wEAAwE,CACzE,CAAA;KACF;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,GAAW;IAC3B,IAAI,GAAG,CAAC,MAAM,GAAG,GAAG,EAAE;QACpB,MAAM,IAAI,eAAe,CACvB,yBAAyB,GAAG,wCAAwC,CACrE,CAAA;KACF;IACD,MAAM,KAAK,GAAG,SAAS,CAAA;IACvB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;QACpB,MAAM,IAAI,eAAe,CACvB,yBAAyB,GAAG,yBAAyB,CACtD,CAAA;KACF;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,SAAsB,YAAY,CAChC,KAAe,EACf,UAAkB,EAClB,WAAsB,EACtB,OAAyB;;QAEzB,UAAU,CAAC,KAAK,CAAC,CAAA;QAEjB,WAAW,GAAG,WAAW,IAAI,EAAE,CAAA;QAC/B,MAAM,IAAI,GAAG,CAAC,UAAU,EAAE,GAAG,WAAW,CAAC,CAAA;QAEzC,IAAI,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAA;QAC5B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAA;QAEhC,IAAI,IAAI,CAAC,MAAM,GAAG,EAAE,EAAE;YACpB,MAAM,IAAI,eAAe,CACvB,4DAA4D,CAC7D,CAAA;SACF;QACD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE;YACtB,QAAQ,CAAC,GAAG,CAAC,CAAA;SACd;QAED,MAAM,iBAAiB,GAAG,MAAM,KAAK,CAAC,oBAAoB,EAAE,CAAA;QAE5D,qCAAqC;QACrC,MAAM,UAAU,GAAG,MAAM,eAAe,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE;YAClE,iBAAiB;SAClB,CAAC,CAAA;QACF,IAAI,EAAC,UAAU,aAAV,UAAU,uBAAV,UAAU,CAAE,eAAe,CAAA,EAAE;YAChC,kBAAkB;YAClB,OAAO,SAAS,CAAA;SACjB;QAED,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAC3B,MAAM,KAAK,CAAC,mBAAmB,EAAE,EACjC,KAAK,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAC1C,CAAA;QACD,IAAI,CAAC,KAAK,CAAC,iBAAiB,WAAW,EAAE,CAAC,CAAA;QAE1C,MAAM,aAAa,GAAG,IAAI,UAAU,CAAC,UAAU,CAAC,QAAS,CAAC,CAAA;QAC1D,IAAI;YACF,0CAA0C;YAC1C,MAAM,eAAe,CAAC,aAAa,CACjC,UAAU,CAAC,eAAe,EAC1B,WAAW,EACX,OAAO,CACR,CAAA;YAED,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE;gBAClB,MAAM,aAAO,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAA;aAC9C;YAED,MAAM,eAAe,GAAG,KAAK,CAAC,yBAAyB,CAAC,WAAW,CAAC,CAAA;YACpE,aAAa,CAAC,IAAI,GAAG,eAAe,CAAA;YACpC,IAAI,CAAC,IAAI,CACP,gBAAgB,IAAI,CAAC,KAAK,CACxB,eAAe,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAChC,QAAQ,eAAe,KAAK,CAC9B,CAAA;YAED,MAAM,gBAAU,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAA;YAChD,IAAI,CAAC,IAAI,CAAC,6BAA6B,CAAC,CAAA;SACzC;gBAAS;YACR,0CAA0C;YAC1C,IAAI;gBACF,MAAM,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA;aACpC;YAAC,OAAO,KAAK,EAAE;gBACd,IAAI,CAAC,KAAK,CAAC,6BAA6B,KAAK,EAAE,CAAC,CAAA;aACjD;SACF;QAED,OAAO,aAAa,CAAA;IACtB,CAAC;CAAA;AAzED,oCAyEC;AAED;;;;;;;GAOG;AACH,SAAsB,SAAS,CAC7B,KAAe,EACf,GAAW,EACX,OAAuB;;QAEvB,UAAU,CAAC,KAAK,CAAC,CAAA;QACjB,QAAQ,CAAC,GAAG,CAAC,CAAA;QAEb,MAAM,iBAAiB,GAAG,MAAM,KAAK,CAAC,oBAAoB,EAAE,CAAA;QAE5D,IAAI,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAA;QAC7B,MAAM,OAAO,GAAG,MAAM,eAAe,CAAC,YAAY,CAAC,GAAG,EAAE,KAAK,EAAE;YAC7D,iBAAiB;SAClB,CAAC,CAAA;QACF,IAAI,OAAO,KAAK,CAAC,CAAC,EAAE;YAClB,MAAM,IAAI,iBAAiB,CACzB,oCAAoC,GAAG,2CAA2C,CACnF,CAAA;SACF;QACD,IAAI,CAAC,KAAK,CAAC,aAAa,OAAO,EAAE,CAAC,CAAA;QAElC,MAAM,UAAU,GAAG,MAAM,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC,CAAA;QAClD,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,CAAA;QAC1B,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC,CAAA;QAE3C,MAAM,aAAa,GAAG,MAAM,KAAK,CAAC,mBAAmB,EAAE,CAAA;QACvD,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAC3B,aAAa,EACb,KAAK,CAAC,gBAAgB,CAAC,iBAAiB,CAAC,CAC1C,CAAA;QAED,IAAI,CAAC,KAAK,CAAC,iBAAiB,WAAW,EAAE,CAAC,CAAA;QAE1C,MAAM,UAAU,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,CAAA;QACtC,IAAI;YACF,MAAM,eAAS,CAAC,aAAa,EAAE,UAAU,EAAE,iBAAiB,CAAC,CAAA;YAC7D,IAAI,IAAI,CAAC,OAAO,EAAE,EAAE;gBAClB,MAAM,aAAO,CAAC,WAAW,EAAE,iBAAiB,CAAC,CAAA;aAC9C;YAED,MAAM,aAAa,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA,CAAC,sBAAsB;YACpE,MAAM,eAAe,GAAG,KAAK,CAAC,yBAAyB,CAAC,WAAW,CAAC,CAAA;YACpE,UAAU,CAAC,IAAI,GAAG,eAAe,CAAA;YACjC,IAAI,CAAC,KAAK,CAAC,cAAc,eAAe,EAAE,CAAC,CAAA;YAC3C,IAAI,eAAe,GAAG,aAAa,EAAE;gBACnC,MAAM,IAAI,KAAK,CACb,kBAAkB,IAAI,CAAC,KAAK,CAC1B,eAAe,GAAG,CAAC,IAAI,GAAG,IAAI,CAAC,CAChC,QAAQ,eAAe,+CAA+C,CACxE,CAAA;aACF;YAED,IAAI,CAAC,KAAK,CAAC,qBAAqB,OAAO,GAAG,CAAC,CAAA;YAC3C,MAAM,eAAe,CAAC,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,CAAC,CAAA;SAC/D;gBAAS;YACR,0CAA0C;YAC1C,IAAI;gBACF,MAAM,KAAK,CAAC,UAAU,CAAC,WAAW,CAAC,CAAA;aACpC;YAAC,OAAO,KAAK,EAAE;gBACd,IAAI,CAAC,KAAK,CAAC,6BAA6B,KAAK,EAAE,CAAC,CAAA;aACjD;SACF;QACD,OAAO,UAAU,CAAA;IACnB,CAAC;CAAA;AA/DD,8BA+DC"}
-\ No newline at end of file

src/cache-base.ts

@@ -1,340 +0,0 @@
-import * as core from '@actions/core'
-import * as exec from '@actions/exec'
-import * as github from '@actions/github'
-import path from 'path'
-import fs from 'fs'
-import {CacheListener} from './cache-reporting'
-import {
-    getCacheKeyPrefix,
-    determineJobContext,
-    saveCache,
-    restoreCache,
-    cacheDebug,
-    isCacheDebuggingEnabled,
-    tryDelete
-} from './cache-utils'
-import {ConfigurationCacheEntryExtractor, GradleHomeEntryExtractor} from './cache-extract-entries'
-
-const CACHE_PROTOCOL_VERSION = 'v6-'
-const RESTORED_CACHE_KEY_KEY = 'restored-cache-key'
-
-export const META_FILE_DIR = '.gradle-build-action'
-export const PROJECT_ROOTS_FILE = 'project-roots.txt'
-const INCLUDE_PATHS_PARAMETER = 'gradle-home-cache-includes'
-const EXCLUDE_PATHS_PARAMETER = 'gradle-home-cache-excludes'
-const STRICT_CACHE_MATCH_PARAMETER = 'gradle-home-cache-strict-match'
-
-/**
- * Represents a key used to restore a cache entry.
- * The Github Actions cache will first try for an exact match on the key.
- * If that fails, it will try for a prefix match on any of the restoreKeys.
- */
-class CacheKey {
-    key: string
-    restoreKeys: string[]
-
-    constructor(key: string, restoreKeys: string[]) {
-        this.key = key
-        this.restoreKeys = restoreKeys
-    }
-}
-
-/**
- * Generates a cache key specific to the current job execution.
- * The key is constructed from the following inputs:
- * - A user-defined prefix (optional)
- * - The cache protocol version
- * - The name of the cache
- * - The runner operating system
- * - The name of the Job being executed
- * - The matrix values for the Job being executed (job context)
- * - The SHA of the commit being executed
- *
- * Caches are restored by trying to match the these key prefixes in order:
- * - The full key with SHA
- * - A previous key for this Job + matrix
- * - Any previous key for this Job (any matrix)
- * - Any previous key for this cache on the current OS
- */
-function generateCacheKey(cacheName: string): CacheKey {
-    const cacheKeyBase = `${getCacheKeyPrefix()}${CACHE_PROTOCOL_VERSION}${cacheName}`
-
-    // At the most general level, share caches for all executions on the same OS
-    const runnerOs = process.env['RUNNER_OS'] || ''
-    const cacheKeyForOs = `${cacheKeyBase}|${runnerOs}`
-
-    // Prefer caches that run this job
-    const cacheKeyForJob = `${cacheKeyForOs}|${github.context.job}`
-
-    // Prefer (even more) jobs that run this job with the same context (matrix)
-    const cacheKeyForJobContext = `${cacheKeyForJob}[${determineJobContext()}]`
-
-    // Exact match on Git SHA
-    const cacheKey = `${cacheKeyForJobContext}-${github.context.sha}`
-
-    if (core.getBooleanInput(STRICT_CACHE_MATCH_PARAMETER)) {
-        return new CacheKey(cacheKey, [cacheKeyForJobContext])
-    }
-
-    return new CacheKey(cacheKey, [cacheKeyForJobContext, cacheKeyForJob, cacheKeyForOs])
-}
-
-export class GradleStateCache {
-    private cacheName: string
-    private cacheDescription: string
-
-    protected readonly gradleUserHome: string
-
-    constructor(gradleUserHome: string) {
-        this.gradleUserHome = gradleUserHome
-        this.cacheName = 'gradle'
-        this.cacheDescription = 'Gradle User Home'
-    }
-
-    init(): void {
-        const actionCacheDir = path.resolve(this.gradleUserHome, '.gradle-build-action')
-        fs.mkdirSync(actionCacheDir, {recursive: true})
-
-        const initScriptsDir = path.resolve(this.gradleUserHome, 'init.d')
-        fs.mkdirSync(initScriptsDir, {recursive: true})
-
-        this.initializeGradleUserHome(this.gradleUserHome, initScriptsDir)
-    }
-
-    cacheOutputExists(): boolean {
-        const cachesDir = path.resolve(this.gradleUserHome, 'caches')
-        if (fs.existsSync(cachesDir)) {
-            cacheDebug(`Cache output exists at ${cachesDir}`)
-            return true
-        }
-        return false
-    }
-
-    /**
-     * Restores the cache entry, finding the closest match to the currently running job.
-     */
-    async restore(listener: CacheListener): Promise<void> {
-        const entryListener = listener.entry(this.cacheDescription)
-
-        const cacheKey = generateCacheKey(this.cacheName)
-
-        cacheDebug(
-            `Requesting ${this.cacheDescription} with
-    key:${cacheKey.key}
-    restoreKeys:[${cacheKey.restoreKeys}]`
-        )
-
-        const cacheResult = await restoreCache(this.getCachePath(), cacheKey.key, cacheKey.restoreKeys, entryListener)
-        if (!cacheResult) {
-            core.info(`${this.cacheDescription} cache not found. Will initialize empty.`)
-            return
-        }
-
-        core.saveState(RESTORED_CACHE_KEY_KEY, cacheResult.key)
-
-        core.info(`Restored ${this.cacheDescription} from cache key: ${cacheResult.key}`)
-
-        try {
-            await this.afterRestore(listener)
-        } catch (error) {
-            core.warning(`Restore ${this.cacheDescription} failed in 'afterRestore': ${error}`)
-        }
-    }
-
-    /**
-     * Restore any extracted cache entries after the main Gradle User Home entry is restored.
-     */
-    async afterRestore(listener: CacheListener): Promise<void> {
-        await this.debugReportGradleUserHomeSize('as restored from cache')
-        await new GradleHomeEntryExtractor(this.gradleUserHome).restore(listener)
-        await new ConfigurationCacheEntryExtractor(this.gradleUserHome).restore(listener)
-        await this.debugReportGradleUserHomeSize('after restoring common artifacts')
-    }
-
-    /**
-     * Saves the cache entry based on the current cache key unless the cache was restored with the exact key,
-     * in which case we cannot overwrite it.
-     *
-     * If the cache entry was restored with a partial match on a restore key, then
-     * it is saved with the exact key.
-     */
-    async save(listener: CacheListener): Promise<void> {
-        const cacheKey = generateCacheKey(this.cacheName).key
-        const restoredCacheKey = core.getState(RESTORED_CACHE_KEY_KEY)
-
-        if (restoredCacheKey && cacheKey === restoredCacheKey) {
-            core.info(`Cache hit occurred on the cache key ${cacheKey}, not saving cache.`)
-            return
-        }
-
-        try {
-            await this.beforeSave(listener)
-        } catch (error) {
-            core.warning(`Save ${this.cacheDescription} failed in 'beforeSave': ${error}`)
-            return
-        }
-
-        core.info(`Caching ${this.cacheDescription} with cache key: ${cacheKey}`)
-        const cachePath = this.getCachePath()
-        const entryListener = listener.entry(this.cacheDescription)
-        await saveCache(cachePath, cacheKey, entryListener)
-
-        return
-    }
-
-    /**
-     * Extract and save any defined extracted cache entries prior to the main Gradle User Home entry being saved.
-     */
-    async beforeSave(listener: CacheListener): Promise<void> {
-        await this.debugReportGradleUserHomeSize('before saving common artifacts')
-        this.deleteExcludedPaths()
-        await Promise.all([
-            new GradleHomeEntryExtractor(this.gradleUserHome).extract(listener),
-            new ConfigurationCacheEntryExtractor(this.gradleUserHome).extract(listener)
-        ])
-        await this.debugReportGradleUserHomeSize(
-            "after extracting common artifacts (only 'caches' and 'notifications' will be stored)"
-        )
-    }
-
-    /**
-     * Delete any file paths that are excluded by the `gradle-home-cache-excludes` parameter.
-     */
-    private deleteExcludedPaths(): void {
-        const rawPaths: string[] = core.getMultilineInput(EXCLUDE_PATHS_PARAMETER)
-        const resolvedPaths = rawPaths.map(x => path.resolve(this.gradleUserHome, x))
-
-        for (const p of resolvedPaths) {
-            cacheDebug(`Deleting excluded path: ${p}`)
-            tryDelete(p)
-        }
-    }
-
-    /**
-     * Determines the paths within Gradle User Home to cache.
-     * By default, this is the 'caches' and 'notifications' directories,
-     * but this can be overridden by the `gradle-home-cache-includes` parameter.
-     */
-    protected getCachePath(): string[] {
-        const rawPaths: string[] = core.getMultilineInput(INCLUDE_PATHS_PARAMETER)
-        rawPaths.push(META_FILE_DIR)
-        const resolvedPaths = rawPaths.map(x => this.resolveCachePath(x))
-        cacheDebug(`Using cache paths: ${resolvedPaths}`)
-        return resolvedPaths
-    }
-
-    private resolveCachePath(rawPath: string): string {
-        if (rawPath.startsWith('!')) {
-            const resolved = this.resolveCachePath(rawPath.substring(1))
-            return `!${resolved}`
-        }
-        return path.resolve(this.gradleUserHome, rawPath)
-    }
-
-    private initializeGradleUserHome(gradleUserHome: string, initScriptsDir: string): void {
-        const propertiesFile = path.resolve(gradleUserHome, 'gradle.properties')
-        fs.appendFileSync(propertiesFile, 'org.gradle.daemon=false')
-
-        const buildScanCapture = path.resolve(initScriptsDir, 'build-scan-capture.init.gradle')
-        fs.writeFileSync(
-            buildScanCapture,
-            `import org.gradle.util.GradleVersion
-
-// Only run against root build. Do not run against included builds.
-def isTopLevelBuild = gradle.getParent() == null
-if (isTopLevelBuild) {
-    def version = GradleVersion.current().baseVersion
-    def atLeastGradle4 = version >= GradleVersion.version("4.0")
-    def atLeastGradle6 = version >= GradleVersion.version("6.0")
-
-    if (atLeastGradle6) {
-        settingsEvaluated { settings ->
-            if (settings.pluginManager.hasPlugin("com.gradle.enterprise")) {
-                registerCallbacks(settings.extensions["gradleEnterprise"].buildScan, settings.rootProject.name)
-            }
-        }
-    } else if (atLeastGradle4) {
-        projectsEvaluated { gradle ->
-            if (gradle.rootProject.pluginManager.hasPlugin("com.gradle.build-scan")) {
-                registerCallbacks(gradle.rootProject.extensions["buildScan"], gradle.rootProject.name)
-            }
-        }
-    }
-}
-
-def registerCallbacks(buildScanExtension, rootProjectName) {
-    buildScanExtension.with {
-        def scanFile = new File("gradle-build-scan.txt")
-        def buildFailed = false
-
-        buildFinished { result ->
-            buildFailed = (result.failure != null)
-        }
-
-        buildScanPublished { buildScan ->
-            scanFile.text = buildScan.buildScanUri
-
-            // Send commands directly to GitHub Actions via STDOUT.
-            def gradleCommand = rootProjectName + " " + gradle.startParameter.taskNames.join(" ")
-            if (buildFailed) {
-                println("::warning ::Gradle build '\${gradleCommand}' FAILED - \${buildScan.buildScanUri}")
-            } else {
-                println("::notice ::Gradle build '\${gradleCommand}' - \${buildScan.buildScanUri}")
-            }
-            println("::set-output name=build-scan-url::\${buildScan.buildScanUri}")
-        }
-    }
-}`
-        )
-
-        const projectRootCapture = path.resolve(initScriptsDir, 'project-root-capture.init.gradle')
-        fs.writeFileSync(
-            projectRootCapture,
-            `
-// Only run against root build. Do not run against included builds.
-def isTopLevelBuild = gradle.getParent() == null
-if (isTopLevelBuild) {
-    settingsEvaluated { settings ->
-        def projectRootEntry = settings.rootDir.absolutePath + "\\n"
-        def projectRootList = new File(settings.gradle.gradleUserHomeDir, "${PROJECT_ROOTS_FILE}")
-        if (!projectRootList.exists() || !projectRootList.text.contains(projectRootEntry)) {
-            projectRootList << projectRootEntry
-        }
-    }
-}`
-        )
-    }
-
-    /**
-     * When cache debugging is enabled, this method will give a detailed report
-     * of the Gradle User Home contents.
-     */
-    private async debugReportGradleUserHomeSize(label: string): Promise<void> {
-        if (!isCacheDebuggingEnabled()) {
-            return
-        }
-        if (!fs.existsSync(this.gradleUserHome)) {
-            return
-        }
-        const result = await exec.getExecOutput('du', ['-h', '-c', '-t', '5M'], {
-            cwd: this.gradleUserHome,
-            silent: true,
-            ignoreReturnCode: true
-        })
-
-        core.info(`Gradle User Home (directories >5M): ${label}`)
-
-        core.info(
-            result.stdout
-                .trimEnd()
-                .replace(/\t/g, '    ')
-                .split('\n')
-                .map(it => {
-                    return `  ${it}`
-                })
-                .join('\n')
-        )
-
-        core.info('-----------------------')
-    }
-}

src/cache-extract-entries.ts

@@ -1,370 +0,0 @@
-import path from 'path'
-import fs from 'fs'
-import * as core from '@actions/core'
-import * as glob from '@actions/glob'
-
-import {META_FILE_DIR, PROJECT_ROOTS_FILE} from './cache-base'
-import {CacheEntryListener, CacheListener} from './cache-reporting'
-import {
-    cacheDebug,
-    getCacheKeyPrefix,
-    hashFileNames,
-    isCacheDebuggingEnabled,
-    restoreCache,
-    saveCache,
-    tryDelete
-} from './cache-utils'
-
-const SKIP_RESTORE_VAR = 'GRADLE_BUILD_ACTION_SKIP_RESTORE'
-
-/**
- * Represents the result of attempting to load or store an extracted cache entry.
- * An undefined cacheKey indicates that the operation did not succeed.
- * The collected results are then used to populate the `cache-metadata.json` file for later use.
- */
-class ExtractedCacheEntry {
-    artifactType: string
-    pattern: string
-    cacheKey: string | undefined
-
-    constructor(artifactType: string, pattern: string, cacheKey: string | undefined) {
-        this.artifactType = artifactType
-        this.pattern = pattern
-        this.cacheKey = cacheKey
-    }
-}
-
-/**
- * Representation of all of the extracted cache entries for this Gradle User Home.
- * This object is persisted to JSON file in the Gradle User Home directory for storing,
- * and subsequently used to restore the Gradle User Home.
- */
-class ExtractedCacheEntryMetadata {
-    entries: ExtractedCacheEntry[] = []
-}
-
-/**
- * The specification for a type of extracted cache entry.
- */
-class ExtractedCacheEntryDefinition {
-    artifactType: string
-    pattern: string
-    bundle: boolean
-    uniqueFileNames = true
-
-    constructor(artifactType: string, pattern: string, bundle: boolean) {
-        this.artifactType = artifactType
-        this.pattern = pattern
-        this.bundle = bundle
-    }
-
-    withNonUniqueFileNames(): ExtractedCacheEntryDefinition {
-        this.uniqueFileNames = false
-        return this
-    }
-}
-
-/**
- * Caches and restores the entire Gradle User Home directory, extracting entries containing common artifacts
- * for more efficient storage.
- */
-abstract class AbstractEntryExtractor {
-    protected readonly gradleUserHome: string
-    private extractorName: string
-
-    constructor(gradleUserHome: string, extractorName: string) {
-        this.gradleUserHome = gradleUserHome
-        this.extractorName = extractorName
-    }
-
-    /**
-     * Restores any artifacts that were cached separately, based on the information in the `cache-metadata.json` file.
-     * Each extracted cache entry is restored in parallel, except when debugging is enabled.
-     */
-    async restore(listener: CacheListener): Promise<void> {
-        const previouslyExtractedCacheEntries = this.loadExtractedCacheEntries()
-
-        const processes: Promise<ExtractedCacheEntry>[] = []
-
-        for (const cacheEntry of previouslyExtractedCacheEntries) {
-            const artifactType = cacheEntry.artifactType
-            const entryListener = listener.entry(cacheEntry.pattern)
-
-            // Handle case where the extracted-cache-entry definitions have been changed
-            const skipRestore = process.env[SKIP_RESTORE_VAR] || ''
-            if (skipRestore.includes(artifactType)) {
-                core.info(`Not restoring extracted cache entry for ${artifactType}`)
-                entryListener.markRequested('SKIP_RESTORE')
-            } else {
-                processes.push(
-                    this.awaitForDebugging(
-                        this.restoreExtractedCacheEntry(
-                            artifactType,
-                            cacheEntry.cacheKey!,
-                            cacheEntry.pattern,
-                            entryListener
-                        )
-                    )
-                )
-            }
-        }
-
-        this.saveMetadataForCacheResults(await Promise.all(processes))
-    }
-
-    private async restoreExtractedCacheEntry(
-        artifactType: string,
-        cacheKey: string,
-        pattern: string,
-        listener: CacheEntryListener
-    ): Promise<ExtractedCacheEntry> {
-        const restoredEntry = await restoreCache([pattern], cacheKey, [], listener)
-        if (restoredEntry) {
-            core.info(`Restored ${artifactType} with key ${cacheKey} to ${pattern}`)
-            return new ExtractedCacheEntry(artifactType, pattern, cacheKey)
-        } else {
-            core.info(`Did not restore ${artifactType} with key ${cacheKey} to ${pattern}`)
-            return new ExtractedCacheEntry(artifactType, pattern, undefined)
-        }
-    }
-
-    /**
-     * Saves any artifacts that are configured to be cached separately, based on the extracted cache entry definitions.
-     * Each entry is extracted and saved in parallel, except when debugging is enabled.
-     */
-    async extract(listener: CacheListener): Promise<void> {
-        // Load the cache entry definitions (from config) and the previously restored entries (from persisted metadata file)
-        const cacheEntryDefinitions = this.getExtractedCacheEntryDefinitions()
-        cacheDebug(
-            `Extracting cache entries for ${this.extractorName}: ${JSON.stringify(cacheEntryDefinitions, null, 2)}`
-        )
-
-        const previouslyRestoredEntries = this.loadExtractedCacheEntries()
-        const cacheActions: Promise<ExtractedCacheEntry>[] = []
-
-        // For each cache entry definition, determine if it has already been restored, and if not, extract it
-        for (const cacheEntryDefinition of cacheEntryDefinitions) {
-            const artifactType = cacheEntryDefinition.artifactType
-            const pattern = cacheEntryDefinition.pattern
-
-            // Find all matching files for this cache entry definition
-            const globber = await glob.create(pattern, {
-                implicitDescendants: false,
-                followSymbolicLinks: false
-            })
-            const matchingFiles = await globber.glob()
-
-            if (matchingFiles.length === 0) {
-                cacheDebug(`No files found to cache for ${artifactType}`)
-                continue
-            }
-
-            if (cacheEntryDefinition.bundle) {
-                // For an extracted "bundle", use the defined pattern and cache all matching files in a single entry.
-                cacheActions.push(
-                    this.awaitForDebugging(
-                        this.saveExtractedCacheEntry(
-                            matchingFiles,
-                            artifactType,
-                            pattern,
-                            cacheEntryDefinition.uniqueFileNames,
-                            previouslyRestoredEntries,
-                            listener.entry(pattern)
-                        )
-                    )
-                )
-            } else {
-                // Otherwise cache each matching file in a separate entry, using the complete file path as the cache pattern.
-                for (const cacheFile of matchingFiles) {
-                    cacheActions.push(
-                        this.awaitForDebugging(
-                            this.saveExtractedCacheEntry(
-                                [cacheFile],
-                                artifactType,
-                                cacheFile,
-                                cacheEntryDefinition.uniqueFileNames,
-                                previouslyRestoredEntries,
-                                listener.entry(cacheFile)
-                            )
-                        )
-                    )
-                }
-            }
-        }
-
-        this.saveMetadataForCacheResults(await Promise.all(cacheActions))
-    }
-
-    private async saveExtractedCacheEntry(
-        matchingFiles: string[],
-        artifactType: string,
-        pattern: string,
-        uniqueFileNames: boolean,
-        previouslyRestoredEntries: ExtractedCacheEntry[],
-        entryListener: CacheEntryListener
-    ): Promise<ExtractedCacheEntry> {
-        const cacheKey = uniqueFileNames
-            ? this.createCacheKeyFromFileNames(artifactType, matchingFiles)
-            : await this.createCacheKeyFromFileContents(artifactType, pattern)
-        const previouslyRestoredKey = previouslyRestoredEntries.find(
-            x => x.artifactType === artifactType && x.pattern === pattern
-        )?.cacheKey
-
-        if (previouslyRestoredKey === cacheKey) {
-            cacheDebug(`No change to previously restored ${artifactType}. Not saving.`)
-        } else {
-            core.info(`Caching ${artifactType} with path '${pattern}' and cache key: ${cacheKey}`)
-            await saveCache([pattern], cacheKey, entryListener)
-        }
-
-        for (const file of matchingFiles) {
-            tryDelete(file)
-        }
-
-        return new ExtractedCacheEntry(artifactType, pattern, cacheKey)
-    }
-
-    protected createCacheKeyFromFileNames(artifactType: string, files: string[]): string {
-        const cacheKeyPrefix = getCacheKeyPrefix()
-        const relativeFiles = files.map(x => path.relative(this.gradleUserHome, x))
-        const key = hashFileNames(relativeFiles)
-
-        cacheDebug(`Generating cache key for ${artifactType} from file names: ${relativeFiles}`)
-
-        return `${cacheKeyPrefix}${artifactType}-${key}`
-    }
-
-    protected async createCacheKeyFromFileContents(artifactType: string, pattern: string): Promise<string> {
-        const cacheKeyPrefix = getCacheKeyPrefix()
-        const key = await glob.hashFiles(pattern)
-
-        cacheDebug(`Generating cache key for ${artifactType} from files matching: ${pattern}`)
-
-        return `${cacheKeyPrefix}${artifactType}-${key}`
-    }
-
-    // Run actions sequentially if debugging is enabled
-    private async awaitForDebugging(p: Promise<ExtractedCacheEntry>): Promise<ExtractedCacheEntry> {
-        if (isCacheDebuggingEnabled()) {
-            await p
-        }
-        return p
-    }
-
-    /**
-     * Load information about the extracted cache entries previously restored/saved. This is loaded from the 'cache-metadata.json' file.
-     */
-    protected loadExtractedCacheEntries(): ExtractedCacheEntry[] {
-        const cacheMetadataFile = this.getCacheMetadataFile()
-        if (!fs.existsSync(cacheMetadataFile)) {
-            return []
-        }
-
-        const filedata = fs.readFileSync(cacheMetadataFile, 'utf-8')
-        cacheDebug(`Loaded cache metadata: ${filedata}`)
-        const extractedCacheEntryMetadata = JSON.parse(filedata) as ExtractedCacheEntryMetadata
-        return extractedCacheEntryMetadata.entries
-    }
-
-    /**
-     * Saves information about the extracted cache entries into the 'cache-metadata.json' file.
-     */
-    private saveMetadataForCacheResults(results: ExtractedCacheEntry[]): void {
-        const extractedCacheEntryMetadata = new ExtractedCacheEntryMetadata()
-        extractedCacheEntryMetadata.entries = results.filter(x => x.cacheKey !== undefined)
-
-        const filedata = JSON.stringify(extractedCacheEntryMetadata)
-        cacheDebug(`Saving cache metadata: ${filedata}`)
-
-        fs.writeFileSync(this.getCacheMetadataFile(), filedata, 'utf-8')
-    }
-
-    private getCacheMetadataFile(): string {
-        const actionMetadataDirectory = path.resolve(this.gradleUserHome, META_FILE_DIR)
-        fs.mkdirSync(actionMetadataDirectory, {recursive: true})
-
-        return path.resolve(actionMetadataDirectory, `${this.extractorName}-entry-metadata.json`)
-    }
-
-    protected abstract getExtractedCacheEntryDefinitions(): ExtractedCacheEntryDefinition[]
-}
-
-export class GradleHomeEntryExtractor extends AbstractEntryExtractor {
-    constructor(gradleUserHome: string) {
-        super(gradleUserHome, 'gradle-home')
-    }
-
-    /**
-     * Return the extracted cache entry definitions, which determine which artifacts will be cached
-     * separately from the rest of the Gradle User Home cache entry.
-     */
-    protected getExtractedCacheEntryDefinitions(): ExtractedCacheEntryDefinition[] {
-        const entryDefinition = (
-            artifactType: string,
-            patterns: string[],
-            bundle: boolean
-        ): ExtractedCacheEntryDefinition => {
-            const resolvedPattern = patterns.map(x => path.resolve(this.gradleUserHome, x)).join('\n')
-            return new ExtractedCacheEntryDefinition(artifactType, resolvedPattern, bundle)
-        }
-
-        return [
-            entryDefinition('generated-gradle-jars', ['caches/*/generated-gradle-jars/*.jar'], false),
-            entryDefinition('wrapper-zips', ['wrapper/dists/*/*/*.zip'], false),
-            entryDefinition('java-toolchains', ['jdks/*.zip', 'jdks/*.tar.gz'], false),
-            entryDefinition('dependencies', ['caches/modules-*/files-*/*/*/*/*'], true),
-            entryDefinition('instrumented-jars', ['caches/jars-*/*'], true),
-            entryDefinition('kotlin-dsl', ['caches/*/kotlin-dsl/*/*'], true)
-        ]
-    }
-}
-
-export class ConfigurationCacheEntryExtractor extends AbstractEntryExtractor {
-    constructor(gradleUserHome: string) {
-        super(gradleUserHome, 'configuration-cache')
-    }
-
-    /**
-     * Handle the case where Gradle User Home has not been fully restored, so that the configuration-cache
-     * entry is not reusable.
-     */
-    async restore(listener: CacheListener): Promise<void> {
-        if (listener.fullyRestored) {
-            return super.restore(listener)
-        }
-
-        core.info('Not restoring configuration-cache state, as Gradle User Home was not fully restored')
-        for (const cacheEntry of this.loadExtractedCacheEntries()) {
-            listener.entry(cacheEntry.pattern).markRequested('NOT_RESTORED')
-        }
-    }
-
-    /**
-     * Extract cache entries for the configuration cache in each project.
-     */
-    protected getExtractedCacheEntryDefinitions(): ExtractedCacheEntryDefinition[] {
-        return this.getProjectRoots().map(projectRoot => {
-            const configCachePath = path.resolve(projectRoot, '.gradle/configuration-cache')
-            return new ExtractedCacheEntryDefinition(
-                'configuration-cache',
-                configCachePath,
-                true
-            ).withNonUniqueFileNames()
-        })
-    }
-
-    /**
-     * For every Gradle invocation, we record the project root directory. This method returns the entire
-     * set of project roots, to allow saving of configuration-cache entries for each.
-     */
-    private getProjectRoots(): string[] {
-        const projectList = path.resolve(this.gradleUserHome, PROJECT_ROOTS_FILE)
-        if (!fs.existsSync(projectList)) {
-            core.info(`Missing project list file ${projectList}`)
-            return []
-        }
-        const projectRoots = fs.readFileSync(projectList, 'utf-8')
-        core.info(`Found project roots '${projectRoots}' in ${projectList}`)
-        return projectRoots.trim().split('\n')
-    }
-}

src/cache-reporting.ts

@@ -1,138 +0,0 @@
-import * as core from '@actions/core'
-
-/**
- * Collects information on what entries were saved and restored during the action.
- * This information is used to generate a summary of the cache usage.
- */
-export class CacheListener {
-    cacheEntries: CacheEntryListener[] = []
-
-    get fullyRestored(): boolean {
-        return this.cacheEntries.every(x => !x.wasRequestedButNotRestored())
-    }
-
-    entry(name: string): CacheEntryListener {
-        for (const entry of this.cacheEntries) {
-            if (entry.entryName === name) {
-                return entry
-            }
-        }
-
-        const newEntry = new CacheEntryListener(name)
-        this.cacheEntries.push(newEntry)
-        return newEntry
-    }
-
-    stringify(): string {
-        return JSON.stringify(this)
-    }
-
-    static rehydrate(stringRep: string): CacheListener {
-        if (stringRep === '') {
-            return new CacheListener()
-        }
-        const rehydrated: CacheListener = Object.assign(new CacheListener(), JSON.parse(stringRep))
-        const entries = rehydrated.cacheEntries
-        for (let index = 0; index < entries.length; index++) {
-            const rawEntry = entries[index]
-            entries[index] = Object.assign(new CacheEntryListener(rawEntry.entryName), rawEntry)
-        }
-        return rehydrated
-    }
-}
-
-/**
- * Collects information on the state of a single cache entry.
- */
-export class CacheEntryListener {
-    entryName: string
-    requestedKey: string | undefined
-    requestedRestoreKeys: string[] | undefined
-    restoredKey: string | undefined
-    restoredSize: number | undefined
-
-    savedKey: string | undefined
-    savedSize: number | undefined
-
-    constructor(entryName: string) {
-        this.entryName = entryName
-    }
-
-    wasRequestedButNotRestored(): boolean {
-        return this.requestedKey !== undefined && this.restoredKey === undefined
-    }
-
-    markRequested(key: string, restoreKeys: string[] = []): CacheEntryListener {
-        this.requestedKey = key
-        this.requestedRestoreKeys = restoreKeys
-        return this
-    }
-
-    markRestored(key: string, size: number | undefined): CacheEntryListener {
-        this.restoredKey = key
-        this.restoredSize = size
-        return this
-    }
-
-    markSaved(key: string, size: number | undefined): CacheEntryListener {
-        this.savedKey = key
-        this.savedSize = size
-        return this
-    }
-
-    markAlreadyExists(key: string): CacheEntryListener {
-        this.savedKey = key
-        this.savedSize = 0
-        return this
-    }
-}
-
-export function logCachingReport(listener: CacheListener): void {
-    if (listener.cacheEntries.length === 0) {
-        return
-    }
-
-    core.info(`---------- Caching Summary -------------
-Restored Entries Count: ${getCount(listener.cacheEntries, e => e.restoredSize)}
-                  Size: ${getSum(listener.cacheEntries, e => e.restoredSize)}
-Saved Entries    Count: ${getCount(listener.cacheEntries, e => e.savedSize)}
-                  Size: ${getSum(listener.cacheEntries, e => e.savedSize)}`)
-
-    core.startGroup('Cache Entry details')
-    for (const entry of listener.cacheEntries) {
-        core.info(`Entry: ${entry.entryName}
-    Requested Key : ${entry.requestedKey ?? ''}
-    Restored  Key : ${entry.restoredKey ?? ''}
-              Size: ${formatSize(entry.restoredSize)}
-    Saved     Key : ${entry.savedKey ?? ''}
-              Size: ${formatSize(entry.savedSize)}`)
-    }
-    core.endGroup()
-}
-
-function getCount(
-    cacheEntries: CacheEntryListener[],
-    predicate: (value: CacheEntryListener) => number | undefined
-): number {
-    return cacheEntries.filter(e => predicate(e) !== undefined).length
-}
-
-function getSum(
-    cacheEntries: CacheEntryListener[],
-    predicate: (value: CacheEntryListener) => number | undefined
-): string {
-    if (cacheEntries.length === 0) {
-        return '0'
-    }
-    return formatSize(cacheEntries.map(e => predicate(e) ?? 0).reduce((p, v) => p + v, 0))
-}
-
-function formatSize(bytes: number | undefined): string {
-    if (bytes === undefined) {
-        return ''
-    }
-    if (bytes === 0) {
-        return '0 (Entry already exists)'
-    }
-    return `${Math.round(bytes / (1024 * 1024))} MB (${bytes} B)`
-}

src/cache-utils.ts

@@ -1,138 +0,0 @@
-import * as core from '@actions/core'
-import * as cache from '@actions/cache'
-import * as crypto from 'crypto'
-import * as path from 'path'
-import * as fs from 'fs'
-
-import {CacheEntryListener} from './cache-reporting'
-
-const JOB_CONTEXT_PARAMETER = 'workflow-job-context'
-const CACHE_DISABLED_PARAMETER = 'cache-disabled'
-const CACHE_READONLY_PARAMETER = 'cache-read-only'
-const CACHE_WRITEONLY_PARAMETER = 'cache-write-only'
-const CACHE_DEBUG_VAR = 'GRADLE_BUILD_ACTION_CACHE_DEBUG_ENABLED'
-const CACHE_PREFIX_VAR = 'GRADLE_BUILD_ACTION_CACHE_KEY_PREFIX'
-
-export function isCacheDisabled(): boolean {
-    return core.getBooleanInput(CACHE_DISABLED_PARAMETER)
-}
-
-export function isCacheReadOnly(): boolean {
-    return core.getBooleanInput(CACHE_READONLY_PARAMETER)
-}
-
-export function isCacheWriteOnly(): boolean {
-    return core.getBooleanInput(CACHE_WRITEONLY_PARAMETER)
-}
-
-export function isCacheDebuggingEnabled(): boolean {
-    return process.env[CACHE_DEBUG_VAR] ? true : false
-}
-
-export function getCacheKeyPrefix(): string {
-    // Prefix can be used to force change all cache keys (defaults to cache protocol version)
-    return process.env[CACHE_PREFIX_VAR] || ''
-}
-
-export function determineJobContext(): string {
-    // By default, we hash the full `matrix` data for the run, to uniquely identify this job invocation
-    // The only way we can obtain the `matrix` data is via the `workflow-job-context` parameter in action.yml.
-    const workflowJobContext = core.getInput(JOB_CONTEXT_PARAMETER)
-    return hashStrings([workflowJobContext])
-}
-
-export function hashFileNames(fileNames: string[]): string {
-    return hashStrings(fileNames.map(x => x.replace(new RegExp(`\\${path.sep}`, 'g'), '/')))
-}
-
-export function hashStrings(values: string[]): string {
-    const hash = crypto.createHash('md5')
-    for (const value of values) {
-        hash.update(value)
-    }
-    return hash.digest('hex')
-}
-
-export async function restoreCache(
-    cachePath: string[],
-    cacheKey: string,
-    cacheRestoreKeys: string[],
-    listener: CacheEntryListener
-): Promise<cache.CacheEntry | undefined> {
-    listener.markRequested(cacheKey, cacheRestoreKeys)
-    try {
-        const restoredEntry = await cache.restoreCache(cachePath, cacheKey, cacheRestoreKeys)
-        if (restoredEntry !== undefined) {
-            listener.markRestored(restoredEntry.key, restoredEntry.size)
-        }
-        return restoredEntry
-    } catch (error) {
-        handleCacheFailure(error, `Failed to restore ${cacheKey}`)
-        return undefined
-    }
-}
-
-export async function saveCache(cachePath: string[], cacheKey: string, listener: CacheEntryListener): Promise<void> {
-    try {
-        const savedEntry = await cache.saveCache(cachePath, cacheKey)
-        listener.markSaved(savedEntry.key, savedEntry.size)
-    } catch (error) {
-        if (error instanceof cache.ReserveCacheError) {
-            listener.markAlreadyExists(cacheKey)
-        }
-        handleCacheFailure(error, `Failed to save cache entry ${cacheKey}`)
-    }
-}
-
-export function cacheDebug(message: string): void {
-    if (isCacheDebuggingEnabled()) {
-        core.info(message)
-    } else {
-        core.debug(message)
-    }
-}
-
-export function handleCacheFailure(error: unknown, message: string): void {
-    if (error instanceof cache.ValidationError) {
-        // Fail on cache validation errors
-        throw error
-    }
-    if (error instanceof cache.ReserveCacheError) {
-        // Reserve cache errors are expected if the artifact has been previously cached
-        core.info(`${message}: ${error}`)
-    } else {
-        // Warn on all other errors
-        core.warning(`${message}: ${error}`)
-        if (error instanceof Error && error.stack) {
-            cacheDebug(error.stack)
-        }
-    }
-}
-
-/**
- * Attempt to delete a file or directory, waiting to allow locks to be released
- */
-export async function tryDelete(file: string): Promise<void> {
-    const stat = fs.lstatSync(file)
-    for (let count = 0; count < 3; count++) {
-        try {
-            if (stat.isDirectory()) {
-                fs.rmdirSync(file, {recursive: true})
-            } else {
-                fs.unlinkSync(file)
-            }
-            return
-        } catch (error) {
-            if (count === 2) {
-                throw error
-            } else {
-                core.warning(String(error))
-                await delay(1000)
-            }
-        }
-    }
-}
-
-async function delay(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms))
-}

src/caches.ts

@@ -1,86 +0,0 @@
-import * as core from '@actions/core'
-import {isCacheDisabled, isCacheReadOnly, isCacheWriteOnly} from './cache-utils'
-import {logCachingReport, CacheListener} from './cache-reporting'
-import {GradleStateCache} from './cache-base'
-
-const CACHE_RESTORED_VAR = 'GRADLE_BUILD_ACTION_CACHE_RESTORED'
-const GRADLE_USER_HOME = 'GRADLE_USER_HOME'
-const CACHE_LISTENER = 'CACHE_LISTENER'
-
-export async function restore(gradleUserHome: string): Promise<void> {
-    // Bypass restore cache on all but first action step in workflow.
-    if (process.env[CACHE_RESTORED_VAR]) {
-        core.info('Cache only restored on first action step.')
-        return
-    }
-    core.exportVariable(CACHE_RESTORED_VAR, true)
-
-    const gradleStateCache = new GradleStateCache(gradleUserHome)
-
-    if (isCacheDisabled()) {
-        core.info('Cache is disabled: will not restore state from previous builds.')
-        // Initialize the Gradle User Home even when caching is disabled.
-        gradleStateCache.init()
-        return
-    }
-
-    if (gradleStateCache.cacheOutputExists()) {
-        core.info('Gradle User Home already exists: will not restore from cache.')
-        // Initialize pre-existing Gradle User Home.
-        gradleStateCache.init()
-        return
-    }
-
-    gradleStateCache.init()
-    // Mark the state as restored so that post-action will perform save.
-    core.saveState(CACHE_RESTORED_VAR, true)
-    // Save the Gradle User Home for the post-action step.
-    core.saveState(GRADLE_USER_HOME, gradleUserHome)
-
-    if (isCacheWriteOnly()) {
-        core.info('Cache is write-only: will not restore from cache.')
-        return
-    }
-
-    await core.group('Restore Gradle state from cache', async () => {
-        const cacheListener = new CacheListener()
-        await gradleStateCache.restore(cacheListener)
-
-        core.saveState(CACHE_LISTENER, cacheListener.stringify())
-    })
-}
-
-export async function save(): Promise<void> {
-    if (!shouldSaveCaches()) {
-        return
-    }
-
-    const cacheListener: CacheListener = CacheListener.rehydrate(core.getState(CACHE_LISTENER))
-
-    if (isCacheReadOnly()) {
-        core.info('Cache is read-only: will not save state for use in subsequent builds.')
-        logCachingReport(cacheListener)
-        return
-    }
-
-    await core.group('Caching Gradle state', async () => {
-        const gradleUserHome = core.getState(GRADLE_USER_HOME)
-        return new GradleStateCache(gradleUserHome).save(cacheListener)
-    })
-
-    logCachingReport(cacheListener)
-}
-
-function shouldSaveCaches(): boolean {
-    if (isCacheDisabled()) {
-        core.info('Cache is disabled: will not save state for later builds.')
-        return false
-    }
-
-    if (!core.getState(CACHE_RESTORED_VAR)) {
-        core.info('Cache will not be saved: not restored in main action step.')
-        return false
-    }
-
-    return true
-}

src/execution.ts

@@ -1,42 +0,0 @@
-import * as core from '@actions/core'
-import * as exec from '@actions/exec'
-import fs from 'fs'
-import path from 'path'
-import * as gradlew from './gradlew'
-
-export async function executeGradleBuild(executable: string | undefined, root: string, args: string[]): Promise<void> {
-    let buildScanUrl: string | undefined
-
-    const buildScanFile = path.resolve(root, 'gradle-build-scan.txt')
-    if (fs.existsSync(buildScanFile)) {
-        fs.unlinkSync(buildScanFile)
-    }
-
-    // Use the provided executable, or look for a Gradle wrapper script to run
-    const toExecute = executable ?? gradlew.locateGradleWrapperScript(root)
-    verifyIsExecutableScript(toExecute)
-    const status: number = await exec.exec(toExecute, args, {
-        cwd: root,
-        ignoreReturnCode: true
-    })
-
-    if (fs.existsSync(buildScanFile)) {
-        buildScanUrl = fs.readFileSync(buildScanFile, 'utf-8')
-    }
-
-    if (status !== 0) {
-        if (buildScanUrl) {
-            core.setFailed(`Gradle build failed: ${buildScanUrl}`)
-        } else {
-            core.setFailed(`Gradle build failed: process exited with status ${status}`)
-        }
-    }
-}
-
-function verifyIsExecutableScript(toExecute: string): void {
-    try {
-        fs.accessSync(toExecute, fs.constants.X_OK)
-    } catch (err) {
-        throw new Error(`Gradle script '${toExecute}' is not executable.`)
-    }
-}

src/gradlew.ts

@@ -1,26 +0,0 @@
-import * as path from 'path'
-import fs from 'fs'
-
-const IS_WINDOWS = process.platform === 'win32'
-
-export function wrapperScriptFilename(): string {
-    return IS_WINDOWS ? 'gradlew.bat' : 'gradlew'
-}
-
-export function installScriptFilename(): string {
-    return IS_WINDOWS ? 'gradle.bat' : 'gradle'
-}
-
-export function locateGradleWrapperScript(buildRootDirectory: string): string {
-    validateGradleWrapper(buildRootDirectory)
-    return path.resolve(buildRootDirectory, wrapperScriptFilename())
-}
-
-function validateGradleWrapper(buildRootDirectory: string): void {
-    const wrapperProperties = path.resolve(buildRootDirectory, 'gradle/wrapper/gradle-wrapper.properties')
-    if (!fs.existsSync(wrapperProperties)) {
-        throw new Error(
-            `Cannot locate a Gradle wrapper properties file at '${wrapperProperties}'. Specify 'gradle-version' or 'gradle-executable' for projects without Gradle wrapper configured.`
-        )
-    }
-}

src/main.ts

@@ -1,75 +0,0 @@
-import * as core from '@actions/core'
-import * as path from 'path'
-import * as os from 'os'
-import {parseArgsStringToArgv} from 'string-argv'
-
-import * as caches from './caches'
-import * as execution from './execution'
-import * as provision from './provision'
-
-/**
- * The main entry point for the action, called by Github Actions for the step.
- */
-export async function run(): Promise<void> {
-    try {
-        const workspaceDirectory = process.env[`GITHUB_WORKSPACE`] || ''
-        const buildRootDirectory = resolveBuildRootDirectory(workspaceDirectory)
-        const gradleUserHome = determineGradleUserHome(buildRootDirectory)
-
-        await caches.restore(gradleUserHome)
-
-        const executable = await provisionGradle(workspaceDirectory)
-        // executable will be undefined if using Gradle wrapper
-        if (executable !== undefined) {
-            core.addPath(path.dirname(executable))
-        }
-
-        // Only execute if arguments have been provided
-        const args: string[] = parseCommandLineArguments()
-        if (args.length > 0) {
-            await execution.executeGradleBuild(executable, buildRootDirectory, args)
-        }
-    } catch (error) {
-        core.setFailed(String(error))
-        if (error instanceof Error && error.stack) {
-            core.info(error.stack)
-        }
-    }
-}
-
-run()
-
-async function provisionGradle(workspaceDirectory: string): Promise<string | undefined> {
-    const gradleVersion = core.getInput('gradle-version')
-    if (gradleVersion !== '' && gradleVersion !== 'wrapper') {
-        return path.resolve(await provision.gradleVersion(gradleVersion))
-    }
-
-    const gradleExecutable = core.getInput('gradle-executable')
-    if (gradleExecutable !== '') {
-        return path.resolve(workspaceDirectory, gradleExecutable)
-    }
-
-    return undefined
-}
-
-function resolveBuildRootDirectory(baseDirectory: string): string {
-    const buildRootDirectory = core.getInput('build-root-directory')
-    const resolvedBuildRootDirectory =
-        buildRootDirectory === '' ? path.resolve(baseDirectory) : path.resolve(baseDirectory, buildRootDirectory)
-    return resolvedBuildRootDirectory
-}
-
-function determineGradleUserHome(rootDir: string): string {
-    const customGradleUserHome = process.env['GRADLE_USER_HOME']
-    if (customGradleUserHome) {
-        return path.resolve(rootDir, customGradleUserHome)
-    }
-
-    return path.resolve(os.homedir(), '.gradle')
-}
-
-function parseCommandLineArguments(): string[] {
-    const input = core.getInput('arguments')
-    return parseArgsStringToArgv(input)
-}

src/post.ts

@@ -1,27 +0,0 @@
-import * as core from '@actions/core'
-import * as caches from './caches'
-
-// Catch and log any unhandled exceptions.  These exceptions can leak out of the uploadChunk method in
-// @actions/toolkit when a failed upload closes the file descriptor causing any in-process reads to
-// throw an uncaught exception.  Instead of failing this action, just warn.
-process.on('uncaughtException', e => handleFailure(e))
-
-/**
- * The post-execution entry point for the action, called by Github Actions after completing all steps for the Job.
- */
-export async function run(): Promise<void> {
-    try {
-        await caches.save()
-    } catch (error) {
-        handleFailure(error)
-    }
-}
-
-function handleFailure(error: unknown): void {
-    core.warning(`Unhandled error saving cache - job will continue: ${error}`)
-    if (error instanceof Error && error.stack) {
-        core.info(error.stack)
-    }
-}
-
-run()

src/provision.ts

@@ -1,161 +0,0 @@
-import * as fs from 'fs'
-import * as os from 'os'
-import * as path from 'path'
-import * as httpm from '@actions/http-client'
-import * as core from '@actions/core'
-import * as cache from '@actions/cache'
-import * as toolCache from '@actions/tool-cache'
-
-import * as gradlew from './gradlew'
-import {handleCacheFailure, isCacheDisabled, isCacheReadOnly} from './cache-utils'
-
-const gradleVersionsBaseUrl = 'https://services.gradle.org/versions'
-
-/**
- * @return Gradle executable path
- */
-export async function gradleVersion(version: string): Promise<string> {
-    switch (version) {
-        case 'current':
-            return gradleCurrent()
-        case 'rc':
-            core.warning(`Specifying gradle-version 'rc' has been deprecated. Use 'release-candidate' instead.`)
-            return gradleReleaseCandidate()
-        case 'release-candidate':
-            return gradleReleaseCandidate()
-        case 'nightly':
-            return gradleNightly()
-        case 'release-nightly':
-            return gradleReleaseNightly()
-        default:
-            return gradle(version)
-    }
-}
-
-async function gradleCurrent(): Promise<string> {
-    const versionInfo = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/current`)
-    return provisionGradle(versionInfo)
-}
-
-async function gradleReleaseCandidate(): Promise<string> {
-    const versionInfo = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/release-candidate`)
-    if (versionInfo && versionInfo.version && versionInfo.downloadUrl) {
-        return provisionGradle(versionInfo)
-    }
-    core.info('No current release-candidate found, will fallback to current')
-    return gradleCurrent()
-}
-
-async function gradleNightly(): Promise<string> {
-    const versionInfo = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/nightly`)
-    return provisionGradle(versionInfo)
-}
-
-async function gradleReleaseNightly(): Promise<string> {
-    const versionInfo = await gradleVersionDeclaration(`${gradleVersionsBaseUrl}/release-nightly`)
-    return provisionGradle(versionInfo)
-}
-
-async function gradle(version: string): Promise<string> {
-    const versionInfo = await findGradleVersionDeclaration(version)
-    if (!versionInfo) {
-        throw new Error(`Gradle version ${version} does not exists`)
-    }
-    return provisionGradle(versionInfo)
-}
-
-async function gradleVersionDeclaration(url: string): Promise<GradleVersionInfo> {
-    return await httpGetGradleVersion(url)
-}
-
-async function findGradleVersionDeclaration(version: string): Promise<GradleVersionInfo | undefined> {
-    const gradleVersions = await httpGetGradleVersions(`${gradleVersionsBaseUrl}/all`)
-    return gradleVersions.find((entry: GradleVersionInfo) => {
-        return entry.version === version
-    })
-}
-
-async function provisionGradle(versionInfo: GradleVersionInfo): Promise<string> {
-    return core.group(`Provision Gradle ${versionInfo.version}`, async () => {
-        return locateGradleAndDownloadIfRequired(versionInfo)
-    })
-}
-
-async function locateGradleAndDownloadIfRequired(versionInfo: GradleVersionInfo): Promise<string> {
-    const installsDir = path.join(os.homedir(), 'gradle-installations/installs')
-    const installDir = path.join(installsDir, `gradle-${versionInfo.version}`)
-    if (fs.existsSync(installDir)) {
-        core.info(`Gradle installation already exists at ${installDir}`)
-        return executableFrom(installDir)
-    }
-
-    const downloadPath = await downloadAndCacheGradleDistribution(versionInfo)
-    await toolCache.extractZip(downloadPath, installsDir)
-    core.info(`Extracted Gradle ${versionInfo.version} to ${installDir}`)
-
-    const executable = executableFrom(installDir)
-    fs.chmodSync(executable, '755')
-    core.info(`Provisioned Gradle executable ${executable}`)
-
-    return executable
-}
-
-async function downloadAndCacheGradleDistribution(versionInfo: GradleVersionInfo): Promise<string> {
-    const downloadPath = path.join(os.homedir(), `gradle-installations/downloads/gradle-${versionInfo.version}-bin.zip`)
-
-    if (isCacheDisabled()) {
-        await downloadGradleDistribution(versionInfo, downloadPath)
-        return downloadPath
-    }
-
-    const cacheKey = `gradle-${versionInfo.version}`
-    try {
-        const restoreKey = await cache.restoreCache([downloadPath], cacheKey)
-        if (restoreKey) {
-            core.info(`Restored Gradle distribution ${cacheKey} from cache to ${downloadPath}`)
-            return downloadPath
-        }
-    } catch (error) {
-        handleCacheFailure(error, `Restore Gradle distribution ${versionInfo.version} failed`)
-    }
-
-    core.info(`Gradle distribution ${versionInfo.version} not found in cache. Will download.`)
-    await downloadGradleDistribution(versionInfo, downloadPath)
-
-    if (!isCacheReadOnly()) {
-        try {
-            await cache.saveCache([downloadPath], cacheKey)
-        } catch (error) {
-            handleCacheFailure(error, `Save Gradle distribution ${versionInfo.version} failed`)
-        }
-    }
-    return downloadPath
-}
-
-async function downloadGradleDistribution(versionInfo: GradleVersionInfo, downloadPath: string): Promise<void> {
-    await toolCache.downloadTool(versionInfo.downloadUrl, downloadPath)
-    core.info(`Downloaded ${versionInfo.downloadUrl} to ${downloadPath} (size ${fs.statSync(downloadPath).size})`)
-}
-
-function executableFrom(installDir: string): string {
-    return path.join(installDir, 'bin', `${gradlew.installScriptFilename()}`)
-}
-
-async function httpGetGradleVersion(url: string): Promise<GradleVersionInfo> {
-    return JSON.parse(await httpGetString(url))
-}
-
-async function httpGetGradleVersions(url: string): Promise<GradleVersionInfo[]> {
-    return JSON.parse(await httpGetString(url))
-}
-
-async function httpGetString(url: string): Promise<string> {
-    const httpClient = new httpm.HttpClient('gradle/gradle-build-action')
-    const response = await httpClient.get(url)
-    return response.readBody()
-}
-
-interface GradleVersionInfo {
-    version: string
-    downloadUrl: string
-}