


 last updated a few seconds ago
Wednesday 17 Jul
Apply `Anonymous type can be replaced with lambda` inspection the whole project



… 665 more files in
changeset.
Apply `Explicit type can be replaced with <>` inspection the whole project


… 909 more files in
changeset.
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.
Tuesday 21 May
Replace anonymous classes with lambdas



… 710 more files in
changeset.
Replace anonymous classes with lambdas



… 694 more files in
changeset.
Remove synthetic accessors for internal private symbol references



… 901 more files in
changeset.
Remove synthetic accessors for internal private symbol references



… 901 more files in
changeset.
Remove synthetic accessors for internal private symbol references



… 889 more files in
changeset.
Remove synthetic accessors for internal private symbol references



… 896 more files in
changeset.
Remove synthetic accessors for internal private symbol references



… 901 more files in
changeset.
Remove synthetic accessors for internal private symbol references



… 901 more files in
changeset.
Saturday 27 Apr
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.
Wednesday 24 Apr
Spike new exclude rule merging


… 32 more files in
changeset.
Friday 12 Apr
Revert "Use Java 8compatible variant of Guava"


… 25 more files in
changeset.
Revert "Merge pull request #8991 from gradle/lptr/core/useguavajava8" This reverts commit b3c791db65d344ddbe1878b56db41761db385aa5, reversing changes made to 29c75bff79d89cfd6f69335a6bd056f1bdf1d160.


… 25 more files in
changeset.
Wednesday 10 Apr
Work around Java 6 compatibility issues


… 21 more files in
changeset.
Work around Java 6 compatibility issues


… 21 more files in
changeset.
Work around Java 6 compatibility issues


… 21 more files in
changeset.
