MavenDependencyDescriptorTest.groovy

Clone Tools
  • last updated a few seconds ago
Constraints
Constraints: committers
 
Constraints: files
Constraints: dates
Add removeAllFiles() to variant files modification API

Files from an existing 'base' are now also transferred to the new

variant (but can then be removed with removeAllFiles()). This makes:

- The behavior more consistent (before everything was transferred

*except* for the files)

- The 'enrich plain ivy with variants' use case better as you do not

manually have to re-add the files that are already in the configuration

metadata

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 14 more files in changeset.
Add removeAllFiles() to variant files modification API

Files from an existing 'base' are now also transferred to the new

variant (but can then be removed with removeAllFiles()). This makes:

- The behavior more consistent (before everything was transferred

*except* for the files)

- The 'enrich plain ivy with variants' use case better as you do not

manually have to re-add the files that are already in the configuration

metadata

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 14 more files in changeset.
Revert new exclude rule merging

This is a temporary revert to allow ironing out some issues with

the newer implementation.

    • -9
    • +7
    ./MavenDependencyDescriptorTest.groovy
  1. … 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.

    • -9
    • +7
    ./MavenDependencyDescriptorTest.groovy
  1. … 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.

    • -9
    • +7
    ./MavenDependencyDescriptorTest.groovy
  1. … 38 more files in changeset.
Rework algorithm

    • -1
    • +1
    ./MavenDependencyDescriptorTest.groovy
  1. … 72 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 90 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 75 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 91 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 90 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 75 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 75 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 90 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 90 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 90 more files in changeset.
Rework exclude rule merging

As a follow-up 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

- pattern-matching 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 90 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.

    • -7
    • +9
    ./MavenDependencyDescriptorTest.groovy
  1. … 18 more files in changeset.
Use an `ImmutableSet` to represent the configuration hierarchy

ImmutableSets are ordered and optimized for lookups. We happen to

call `contains` a lot on hierarchies, so using a `Set` should

optimize things a little.

    • -4
    • +5
    ./MavenDependencyDescriptorTest.groovy
  1. … 31 more files in changeset.
Omit excludes for Maven optional dependencies

For BOM import support, when a <dependencyManagement> entry has a declared <exclusion>,

we apply this exclusion globally whenever the target module is resolved, regardless of

the path to the module. However, this behaviour is not desired for <optional> dependencies,

and these could not be distinguished from <dependencyManagement> entries after the POM was parsed.

With this change, we retain a 'type' attribute for all dependencies parsed from a Maven POM

file. This allows us to omit any exclusions that are defined for a dependency declared with

<optional>, while retaining them for <dependencyManagement> entries.

    • -13
    • +14
    ./MavenDependencyDescriptorTest.groovy
  1. … 8 more files in changeset.
Refactor ModuleResolveMetadata

Reorganize code in packages, move serialization related code closer to

classes to reduce need of public methods.

    • -0
    • +1
    ./MavenDependencyDescriptorTest.groovy
  1. … 79 more files in changeset.
Refactor ModuleResolveMetadata

Reorganize code in packages, move serialization related code closer to

classes to reduce need of public methods.

    • -0
    • +1
    ./MavenDependencyDescriptorTest.groovy
  1. … 79 more files in changeset.
Move logic that decides to do attribute matching out of ExternalDependencyDescriptor

    • -34
    • +11
    ./MavenDependencyDescriptorTest.groovy
  1. … 3 more files in changeset.
Remove target config from Maven-sourced deps

`MavenDependencyDescriptor.getModuleConfigurations()` was confusing,

as it provided the target scope of the dependency, _plus_ the magic

'optional' configuration name for optional dependencies.

This change removes the concept of a target configuration for a

Maven-sourced dependency: instead we use the scope directly when

building the dependencies for the 'optional' configuration.

foo

    • -20
    • +0
    ./MavenDependencyDescriptorTest.groovy
  1. … 5 more files in changeset.
Renamed `DefaultDependencyMetadata` -> `ExternalDependencyDescriptor`

This type now represents the external representation of a dependency, not the

internal `DependencyMetadata`. Also renamed and polished Ivy/Maven subtypes.

    • -0
    • +293
    ./MavenDependencyDescriptorTest.groovy
  1. … 34 more files in changeset.