| Age | Commit message (Collapse) | Author |
|---|
|
Uses `Array#any?` instead of `Array#each`.
According to benchmarks, `any?` is slightly faster when validation
fails (3%) and noticeably faster when validation passes (up to 60%)
|
|
Fix redundant self offenses
|
|
No performance gain, this can be seen as a cosmetic change to have
shorter lines
|
|
Renaming the existing methods would break the public API, and it is not
worth to alias and/or deprecate existing methods, so this commit
enables Naming/PredicateName and allows the existing methods to preserve
their name
|
|
- Use literal syntax on single line
- Use lambda method on multiple lines
Ref: https://rubystyle.guide/#lambda-multi-line
|
|
Remove redundant `to_s` calls
|
|
Caxlsx is using both `.` and `::`, 220 occurrences vs 280 to invoke
methods on `Axlsx` module.
This commit standardizes the approach towards `.`, which will also allow
shorter lines.
Performance is not affected
```
Comparison:
Axlsx.validate: 8515252.3 i/s
Axlsx::validate: 8512863.7 i/s - same-ish: difference falls within error
```
|
|
`clean_value`'s return value is a `String`. That method will return
`@value.to_s`, or it will call `Axlsx.sanitize`, which will return a
`String` in both conditions (
|
|
Invert nil checks to improve performance
|
|
Fix the following safe offenses:
- Style/OperatorMethodCall
- Style/RandomWithOffset
And use Array.new to avoid an extra allocation:
```
Comparison (IPS):
Array.new(8) { rand(65..89).chr }.join: 492433.7 i/s
(0...8).map { 65.+(rand(25)).chr }.join: 432155.8 i/s - 1.14x (± 0.00) slower
Comparison (Memory):
Array.new(8) { rand(65..89).chr }.join: 440 allocated
(0...8).map { 65.+(rand(25)).chr }.join: 560 allocated - 1.27x more
```
|
|
Check for `nil` before checking for more expensive conditions which
include a method call or an array scan.
Also removes redundant comments on self-explanatory code
|
|
This commit fixes cases that cannot be detected by RuboCop
Ref: https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Style/FormatString
|
|
`%` is an operation on `String` that will return a new `String`, so
the interpolation is redundant
Also adds a missing spec on PivotTable#rels_pn
```
IPS:
uninterpolated: 4045715.7 i/s
interpolated: 2359775.6 i/s - 1.71x (± 0.00) slower
Memory:
uninterpolated: 160 allocated
interpolated: 232 allocated - 1.45x more
```
|
|
`Kernel#format` is faster and will avoid to allocate an array compared
to `String#%`.
```
IPS:
kernel_format: 3877614.2 i/s
string_percent: 3531475.0 i/s - 1.10x (± 0.00) slower
Memory:
kernel_format: 160 allocated
string_percent: 200 allocated - 1.25x more
```
|
|
Avoid unnecessary calls to `parse_options`
|
|
Fix negated if offenses
|
|
`Cell#initialize` is one of the most used methods in the library, so
a small improvement here will make a lot of difference on the overall
performance.
The impact of this change is negligible when `options` has elements
but is substantial when it is empty.
```
Comparison (empty options):
parse unless: 11636650.6 i/s
parse: 8109825.4 i/s - 1.43x (± 0.00) slower
Comparison (1 option):
parse: 3548037.5 i/s
parse unless: 3459029.7 i/s - same-ish: difference falls within error
```
|
|
Should also provide a negligible performance improvement, about 3%
on Ruby 3.2 and 6% on Ruby 2.6 (M1 Pro)
|
|
- Style/ParenthesesAroundCondition
- Style/RedundantParentheses
- Style/TernaryParentheses
`Style/ParenthesesAroundCondition` may be questionable, but a majority
of comparison where not using parentheses, so offenses have been fixed
for uniformity across the codebase
|
|
|
|
Fix Style/SymbolProc offenses
|
|
Fix Style/MutableConstant offenses
|
|
Fix Style/YodaCondition offense
|
|
Fix Style/ConditionalAssignment offenses
|
|
This also provides a performance improvement
```
Comparison (array of 4 elements):
map(&): 3643131.4 i/s
map {}: 3488052.5 i/s - 1.04x (± 0.00) slower
Comparison (array of 20 elements):
map(&): 466013.9 i/s
map {}: 408447.2 i/s - 1.14x (± 0.00) slower
```
|
|
|
|
|
|
|
|
Fix Style/HashEachMethods offense
|
|
|
|
Improve absolute cell reference method
|
|
Fix Style/IfInsideElse offense
|
|
tagliala/chore/fix-redundant-file-extension-in-require-offenses
Fix Style/RedundantFileExtensionInRequire offenses
|
|
Enable Naming cops
|
|
Use #== and #eql? from BasicObject
|
|
Also inverts `string.match(REGEX)` with `REGEX.match(string)` because
of uniformity and because it has been tested 5% more performant on
Ruby 3.2. Performance on older Rubies is the same
```
REGEX.match(string): 1234330.7 i/s
string.match(REGEX): 1172670.1 i/s - 1.05x (± 0.00) slower
```
|
|
Replace `keys.each` with hash iteration
```rb
MY_HASH = {
first: '1',
second: '2',
third: '3'
}
%i[ips memory].each do |benchmark|
Benchmark.send(benchmark) do |x|
x.report("each_key") { MY_HASH.each_key { |k| MY_HASH[k] } }
x.report("keys.each") { MY_HASH.keys.each { |k| MY_HASH[k] } }
x.report("each") { MY_HASH.each { |k, v| v } }
x.compare!
end
end
```
```
IPS Comparison:
each: 4283031.6 i/s
each_key: 3683407.4 i/s - 1.16x (± 0.00) slower
keys.each: 3387425.1 i/s - 1.26x (± 0.00) slower
Memory Comparison:
each_key: 0 allocated
each: 0 allocated - same
keys.each: 40 allocated - Infx more
```
|
|
Also fix safe minor offenses
- Naming/BinaryOperatorParameterName
- Naming/HeredocDelimiterCase
|
|
Axlsx::Row is now an Array, so it is possible to remove the extra
duplicate branch
|
|
Do not use collection literal in loops
|
|
Fix axlsx_styler gem deprecation error
|
|
|
|
|
|
|
|
Also refactors Page margins to avoid code duplication
|
|
Improve cell type from value implementation
|
|
Fix Performance/RedundantBlockCall offense
|
|
Fix Style/LineEndConcatenation offenses
|
|
Enable Security cops
|
|
Fix Style/NonNilCheck offenses
|
