


 last updated a few seconds ago
Thursday 13 Jun
Upgrade Guava from 27.1 to 28.0 (android/jre)


… 4 more files in
changeset.
Wednesday 12 Jun


… 3 more files in
changeset.


… 3 more files in
changeset.


… 3 more files in
changeset.


… 3 more files in
changeset.


… 3 more files in
changeset.
Monday 06 May
Upgrade other ASM dependencies from `6.0` to `7.1`


… 4 more files in
changeset.
Upgrade other ASM dependencies from `6.0` to `7.1`


… 4 more files in
changeset.
Upgrade other ASM dependencies from `6.0` to `7.1`


… 4 more files in
changeset.
Upgrade other ASM dependencies from `6.0` to `7.1` Signedoffby: Pap Lőrinc <lorinc@gradle.com>


… 4 more files in
changeset.
Tuesday 30 Apr
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.
Tuesday 16 Apr
Upgrade to Guava 27.1 Still using the Android variant for now.


… 5 more files in
changeset.
Wednesday 10 Apr
Revert "Upgrade to Guave 27.1" This reverts commit 6db14871d5cdb7a5f7923a3bf3ca121168236307.


… 2 more files in
changeset.


… 2 more files in
changeset.
Thursday 04 Apr
Use Provider<FileSystemLocation> for artifact transforms Using `File` is deprecated.



… 5 more files in
changeset.
Use Provider<FileSystemLocation> for artifact transforms Using `File` is deprecated.



… 5 more files in
changeset.
Monday 18 Mar
Enable caching for Minify transform The minify transform seems to be expensive at times. Let's cache it!
