


 last updated a few seconds ago
Wednesday 19 Jun 2019
Revert new exclude rule merging This is a temporary revert to allow ironing out some issues with the newer implementation.


… 38 more files in
changeset.
Revert new exclude rule merging This is a temporary revert to allow ironing out some more issues with the newer implementation.


… 38 more files in
changeset.
Revert new exclude rule merging This is a temporary revert to allow ironing out some issues with the newer implementation.


… 38 more files in
changeset.
Saturday 27 Apr 2019


… 72 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Yet another factory is there to reduce the memory footprint and, as a side effect, make things faster by interning the specs: equivalent specs are interned and indexed, which allows us to optimize unions and intersections of specs. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 90 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 75 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Yet another factory is there to reduce the memory footprint and, as a side effect, make things faster by interning the specs: equivalent specs are interned and indexed, which allows us to optimize unions and intersections of specs. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 91 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Yet another factory is there to reduce the memory footprint and, as a side effect, make things faster by interning the specs: equivalent specs are interned and indexed, which allows us to optimize unions and intersections of specs. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 90 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 75 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 75 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Yet another factory is there to reduce the memory footprint and, as a side effect, make things faster by interning the specs: equivalent specs are interned and indexed, which allows us to optimize unions and intersections of specs. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 90 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Yet another factory is there to reduce the memory footprint and, as a side effect, make things faster by interning the specs: equivalent specs are interned and indexed, which allows us to optimize unions and intersections of specs. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 90 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Yet another factory is there to reduce the memory footprint and, as a side effect, make things faster by interning the specs: equivalent specs are interned and indexed, which allows us to optimize unions and intersections of specs. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 90 more files in
changeset.
Rework exclude rule merging As a followup to #9197, this commit properly fixes the exclude rule merging algorithm, by completely rewriting it. The new merging algorithm works by implementing the minimal set of algebra operations that make sense to minimize computation durations. In order to do this, this commit introduces a number of exclude specs (found in their own package) and factories to create actual implementation of those specs. Specs represent the different kind of excludes we can find:  excluding a group  excluding a module (no group defined)  excluding a group+module  excluding an artifact of a group+module  patternmatching excludes  unions of excludes  intersections of excludes With all those minimal bricks, factories are responsible of generating consistent specs. The dumbest factory will just generate new instances for everything. This is the default factory. Minimally, this factory has to be backed by an optimizing factory, which will take care of handling special cases:  union or intersection of a single spec  union or intersection of 2 specs  when one of them is null  when both are equal Then we have a factory which performs the minimal algebra to minimize specs:  unions of unions  intersections of intersections  union of a union and individual specs  insection of an intersection and individual spec  ... This factory can be as smart as it can, but one must be careful that it's worth it: some previously implemented optimizations (like (A+B).A = A turned out to be costly to detect, and didn't make it the final cut. Yet another factory is there to reduce the memory footprint and, as a side effect, make things faster by interning the specs: equivalent specs are interned and indexed, which allows us to optimize unions and intersections of specs. Last but not least, a caching factory is there to avoid recomputing the same intersections and unions of specs when we have already done the job. This is efficient if the underlying (delegate) specs are easily compared, which is the case thanks to the interning factory. All in all, the delegation chain allows us to make the algorithm fast and hopefully reliable, while making it easier to debug.


… 90 more files in
changeset.
Thursday 25 Apr 2019
Make `JvmPackageName` stateless, since it was only used for validation


… 3 more files in
changeset.
Make `JvmPackageName` stateless, since it was only used for validation


… 3 more files in
changeset.
Move all infrastructure to the new exclude merging package The old package is still here and will be removed in a subsequent commit.


… 18 more files in
changeset.
Saturday 20 Apr 2019
Extend `JvmPackageNameTest` with package names that include `$` and `_`
Tuesday 29 Jan 2019
Rename several classes to fix spelling Signedoffby: Bo Zhang <bo@gradle.com>







… 2 more files in
changeset.
Wednesday 02 Jan 2019
spelling: parameterized Signedoffby: Josh Soref <jsoref@users.noreply.github.com>





… 11 more files in
changeset.
Monday 17 Sep 2018
Provide an explicit `acceptor` and `rejector` to API for choosing dependency version This will permit a single `ResolvedVersionConstraint` to have both a `prefer` and a `require` version.


… 14 more files in
changeset.
Wednesday 29 Aug 2018
Separate `ITaskFactory` from `NamedEntityInstantiator<Task>` so that the instantiator is applied as a decoration over the factory.


… 37 more files in
changeset.
Friday 06 Apr 2018
Honor dependency attributes when they override configuration attributes This commit fixes artifact selection so that when we resolve artifacts, we also use the attributes defined on the dependency itself, if ever. Before, when we were resolving artifacts, only the consumer configuration attributes were used.


… 23 more files in
changeset.
Friday 16 Mar 2018
Provide ResolvedVersionConstraint when resolving component id The 'resolved' version constraint is critical to resolving the component id for a given selector. In order to honour all constraints in the resolution process, this `ResolvedVersionConstraint` will be composed of more than just the constraints for a single selector. With this change, the `ResolvedVersionConstraint` is constructed prior to resolving the id, rather than being constructed as part of that process.


… 14 more files in
changeset.
Rename id accessors for consistency Use `ComponentIdentifier getId()` Use `ModuleVersionIdentifier getModuleVersionId()`


… 67 more files in
changeset.
Polish: metaData > metadata


… 13 more files in
changeset.
Friday 10 Nov 2017
Remove unit test uses of DependencyMetadata.requested


… 14 more files in
changeset.
Thursday 09 Nov 2017
Removed unused `ModuleId` param from `DependencyToComponentIdResolver.resolve()`


… 14 more files in
changeset.
Tuesday 10 Oct 2017
Avoid computing `ModuleIdentifier` multiple times for the same module This commit precomputes a `ModuleIdentifier` from a dependency and passes it around several places where it is used. This saves a bunch of lookups in the module identifier cache, which tend to be pretty expensive. Dependency substitution is also passed the original module identifier, in case no substitution is done. This prevents an additional lookup.


… 23 more files in
changeset.
Saturday 20 May 2017
Create a `ResolvedArtifact` wrapper for each external artifact once per build invocation, rather than once per dependency graph per build invocation.


… 15 more files in
changeset.
