


 last updated a few seconds ago
Wednesday 19 Jun
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.
Friday 24 May
Do not share exclusion cache For some reason (that I'm obviously not smart enough to figure out), we can't share the exclusion cache for the whole build, because even if its safe, resolution is sensitive to the order of entries in the cache.


… 5 more files in
changeset.
Do not share exclusion cache For some reason (that I'm obviously not smart enough to figure out), we can't share the exclusion cache for the whole build, because even if its safe, resolution is sensitive to the order of entries in the cache.


… 5 more files in
changeset.
Saturday 27 Apr


… 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
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.
Tuesday 04 Sep 2018
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.


… 31 more files in
changeset.
Monday 02 Jul 2018
Refactor ModuleResolveMetadata Reorganize code in packages, move serialization related code closer to classes to reduce need of public methods.


… 79 more files in
changeset.
Refactor ModuleResolveMetadata Reorganize code in packages, move serialization related code closer to classes to reduce need of public methods.


… 79 more files in
changeset.
Friday 16 Mar 2018
Rename id accessors for consistency Use `ComponentIdentifier getId()` Use `ModuleVersionIdentifier getModuleVersionId()`


… 67 more files in
changeset.
Sunday 18 Feb 2018
Deduplicate target confs selected by Ivy dependency For a dependency declared in an Ivy descriptor file, one or more target configurations will be chosen for the selected component, based on the 'confMapping' attribute of the dependency. In some cases, one chosen configuration may be extended by another chosen configuration, rendering the first configuration redundant. With this change, these redundant configurations are removed from the resolution result. There is a breaking change here, in that the 'resolved configuration' resolution result will contain fewer configuration nodes. It will still contain the same modules and artifacts, in the same order. A similar change was made for Maven modules in 9df4ba294cd39aff3b55bbe402bb7b7870a24bf4.


… 4 more files in
changeset.
Saturday 17 Feb 2018
Move logic that decides to do attribute matching out of ExternalDependencyDescriptor


… 3 more files in
changeset.
Sunday 26 Nov 2017
Renamed `DefaultDependencyMetadata` > `ExternalDependencyDescriptor` This type now represents the external representation of a dependency, not the internal `DependencyMetadata`. Also renamed and polished Ivy/Maven subtypes.


… 34 more files in
changeset.
