Gradle

Clone Tools
  • last updated a few seconds ago
Constraints
Constraints: committers
 
Constraints: files
Constraints: dates
Rename 'isCompositeParticipant' to 'isCompositeSubstitution'

Accepted a breaking change.

Calculate the C/C++ source files of a compile task once only during execution, rather than twice (when outputs can be reused from somewhere) or 3 times (when the task action is executed).

Added an initial rough implementation of a `ConfigurableFileCollection` that can be used as a task input property, and which caches the matching files during task execution. This means that these input files are queried once during execution regardless of whether the file collection is used to calculate other input values, such as the header files for a C/C++ compile task, or used by the task action when it runs (which it always will be). This is intended to be evolved into a reusable implementation but currently lives with the native compile tasks.

Also changed the native compile tasks to discard incremental compile analysis state at the end of task execution rather than retain it in memory for the remainder of the build.

Added an internal mechanism for the task executor and input property snapshotting to collaborate with rich input file property types, such as `FileCollection`, so that the property value implementation can finalize the property value early the task execution and cache state during task execution to make input calculation, snapshots and querying faster.

The value implementation can implement `LifecycleAwareTaskProperty` to be notified of when it is permitted to finalize the value and cache state and when it should release that state.

Reduced the cost of traversing a C/C++ include file dependency graph to collect the files visible from a source file.

Avoid creating some garbage for every edge in the C/C++ include file dependency graph (of which there are quite a few).

Changed some anonymous classes to inner classes.

Add support for Swift/C++ interoperability

Add explanatory comments

Refactor dependency substitution for included builds for use with implicit included builds

Coverage for published constraint with reject '+'

- Test error message when required module is rejected

- Updated test fixtures to correctly produce module file with rich constraints

Allow module metadata with missing 'prefer' version

- Updated spec to specify that version, prefer and reject are all optional

- Handle missing prefer when parsing

- Updated test files to verify serialization

Toward 0.15.0

Prepare 0.14.1 release

Add ignored tests for multi-project source dependencies

Log resolution failure environment

Always resolve test publications with experimentFeatures enabled

Now that we can selectively choose which `metadataSource` to resolve

we can always verify the published metadata files with experimental

features enabled. This simplifies the tests.

One test needed to be changed because an optional dependency being

dragged in by spring-core was changing the resolution result when

experimental features were enabled.

StagePasses gradle steps run the build using Java 8 (#3757)

Signed-off-by: Paul Merlin <paul@gradle.com>

Java 9 smoke testing now use a regular TestCoverage and testJavaHome

Signed-off-by: Paul Merlin <paul@gradle.com>

    • -3
    • +3
    /.teamcity/Gradle_Check/model/CIBuildModel.kt
Migrate the Maven publish integration tests to use the same test fixtures as Ivy

This makes things much easier to understand, and explicits some expectations.

Satellite builds run on Java 8 and set java7Home system property (#3752)

* Promotion job use Java 8 to run the build

* Ad-hoc windows tests use Java 8 to run the build

* All promotion build types set java7Home system property

Signed-off-by: Paul Merlin <paul@gradle.com>

Remove unneccessary objects from service registry

This minimizes the memory footprint of service registries

with the following improvements:

The isolation beteen parent and child is now handled by

explicitly checking whether a service came from the same

registry instead of wrapping services in an isolation layer.

The lookup cache has been removed, as the lookup algorithm

is now cheap enough to work without a cache.

The type spec concept has been removed and replaced by a

static "isSatisfiedBy(Type, Type)" method. The cache for the

specs was also removed as a result.

An array of services is only created if there are multiple

implementations for an interface.

Looking up Object.class is no longer supported and it is

no longer tracked as a potential service class.

FunctionalTest always use Java 8 to run the build & set testJavaHome (#3737)

Signed-off-by: Paul Merlin <paul@gradle.com>

Push common `sq` methods up to trait

Let production build environment assertion allow using Java 8 to run the build (#3746)

* Production build environment is Java 8 to run the build

and Java 7 for compilation

and Java 8 for running tests

Signed-off-by: Paul Merlin <paul@gradle.com>

* Account for sys prop name change java7.home -> java7Home

Signed-off-by: Paul Merlin <paul@gradle.com>

Let production build environment assertion allow using Java 8 to run the build (#3746)

and Java 7 for compilation

and Java 8 for running tests

Account for sys prop name change java7.home -> java7Home

Signed-off-by: Paul Merlin <paul@gradle.com>

Remove CompileAllJava7 ci job (#3750)

* Remove CompilleAllJava7

Signed-off-by: Paul Merlin <paul@gradle.com>

* Remove spurious test

Signed-off-by: Paul Merlin <paul@gradle.com>

    • -8
    • +0
    /.teamcity/Gradle_Check/model/CIBuildModel.kt
Enfore looking only for `ivy` or `gradle` metadata when doing resolution

This commit uses the `metadataSources` to make sure that when we re-resolve, we only use the expected metadata source.

This prevents some tests from accidentally passing because we resolve to Ivy after failing with Gradle.

Explicitly use Java 8 to run the distribution builds (#3749)

Signed-off-by: Paul Merlin <paul@gradle.com>

Allow parallel service registry access

Instead of locking around every service access,

allow multiple threads to look up services at

the same time. This requires almost no coordination,,

as most of the state inside a registry is completely

independent of the rest. Every provider can protected its

own state without locking all the others. The only

coordination needed is when stopping, because we need

to ensure that all pending requests are served first.

This is achieved using a request counter.