| Age | Commit message (Collapse) | Author |
|---|
|
|
|
|
|
|
|
Add optional interpolation points to icon sets
|
|
Fix Lint/UnusedBlockArgument offenses
|
|
|
|
`class.name` is faster, uses less memory than `class.to_s`, and can
be used in this context.
This micro optimization does not have practical effect, it is just a
reference for the future in case this approach will be needed in
other parts of the library
```
Comparison (IPS):
Object.name: 13528803.0 i/s
Object.to_s: 8213612.0 i/s - 1.65x (± 0.00) slower
Comparison (Memory):
Object.name: 0 allocated
Object.to_s: 40 allocated - Infx more
```
|
|
[ci skip]
Close #298
|
|
---------
Co-authored-by: SarahVanHaute <[email protected]>
Co-authored-by: Geremia Taglialatela <[email protected]>
|
|
Provide documentation to two attribute readers which triggered the
offense.
|
|
Fix offenses in sheet protection
|
|
Ref: https://ruby-doc.org/core-2.6.10/Encoding.html#class-Encoding-label-Changing+an+encoding
|
|
- Lint/AmbiguousOperatorPrecedence
- Style/PerlBackrefs
- Style/StringChars
- Style/UnpackFirst
|
|
Fix Lint/NonLocalExitFromIterator offense
|
|
Require 'cgi' at module level
|
|
All supported Ruby versions now support the `encode` method on strings,
so the conditional check for this method has been removed. Even if the
default encoding on Ruby >= 2.0 is UTF-8, this is not always the case
when the `LANG` environment variable is not set to `C.UTF-8`, so the
`encode` method has been preserved.
Additionally, this commit updates a link to use the `https` protocol for
improved security.
|
|
Previously, `require 'cgi'` was only called in `cell.rb`, but there are
other components in the Axlsx module that also use this dependency,
including `Axlsx::SeriesTitle`, `Axlsx::StrVal`, `Axlsx::Title`
(drawing), `Axlsx::Comment`, `Axlsx::ConditionalFormattingRule`, and
`Axlsx::HeaderFooter`.
By requiring cgi at the module level, we ensure that this dependency is
available to all components in the Axlsx module, which can prevent
issues if someone is requiring specific components that depend on cgi.
This change improves the maintainability and reliability of the codebase
by ensuring that all components have access to the required
dependencies.
Close #282
|
|
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
|
|
Use `each_value` instead of `each` where possible. The performance gain
is minimal (3%).
```
Comparison:
each_value: 4105733.4 i/s
each: 3998011.4 i/s - 1.03x (± 0.00) slower
```
|
|
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
|
