mirror of
https://gitea.invidious.io/iv-org/shard-ameba.git
synced 2024-08-15 00:53:29 +00:00
Convert Style/VerboseBlock spec
This commit is contained in:
fn ⌃ ⌥
parent
e93dfe9cdc
commit
571969265f
2 changed files with 119 additions and 123 deletions
|
|
@ -5,7 +5,7 @@ module Ameba::Rule::Style
|
|||
|
||||
describe VerboseBlock do
|
||||
it "passes if there is no potential performance improvements" do
|
||||
source = Source.new %(
|
||||
expect_no_issues subject, <<-CRYSTAL
|
||||
(1..3).any?(&.odd?)
|
||||
(1..3).join('.', &.to_s)
|
||||
(1..3).each_with_index { |i, idx| i * idx }
|
||||
|
|
@ -14,192 +14,188 @@ module Ameba::Rule::Style
|
|||
(1..3).map { |i| :foo }
|
||||
(1..3).map { |i| :foo.to_s.split.join('.') }
|
||||
(1..3).map { :foo }
|
||||
)
|
||||
subject.catch(source).should be_valid
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "passes if the block argument is used within the body" do
|
||||
source = Source.new %(
|
||||
expect_no_issues subject, <<-CRYSTAL
|
||||
(1..3).map { |i| i * i }
|
||||
(1..3).map { |j| j * j.to_i64 }
|
||||
(1..3).map { |k| k.to_i64 * k }
|
||||
(1..3).map { |l| l.to_i64 * l.to_i64 }
|
||||
(1..3).map { |m| m.to_s[start: m.to_i64, count: 3]? }
|
||||
(1..3).map { |n| n.to_s.split.map { |z| n.to_i * z.to_i }.join }
|
||||
)
|
||||
subject.catch(source).should be_valid
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "reports if there is a call with a collapsible block" do
|
||||
source = Source.new %(
|
||||
expect_issue subject, <<-CRYSTAL
|
||||
(1..3).any? { |i| i.odd? }
|
||||
)
|
||||
subject.catch(source).should_not be_valid
|
||||
# ^^^^^^^^^^^^^^^^^^^ error: Use short block notation instead: `any?(&.odd?)`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "reports if there is a call with an argument + collapsible block" do
|
||||
source = Source.new %(
|
||||
expect_issue subject, <<-CRYSTAL
|
||||
(1..3).join('.') { |i| i.to_s }
|
||||
)
|
||||
subject.catch(source).should_not be_valid
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short block notation instead: `join('.', &.to_s)`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "reports if there is a call with a collapsible block (with chained call)" do
|
||||
source = Source.new %(
|
||||
expect_issue subject, <<-CRYSTAL
|
||||
(1..3).map { |i| i.to_s.split.reverse.join.strip }
|
||||
)
|
||||
subject.catch(source).should_not be_valid
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short block notation instead: `map(&.to_s.split.reverse.join.strip)`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
context "properties" do
|
||||
it "#exclude_calls_with_block" do
|
||||
source = Source.new %(
|
||||
(1..3).in_groups_of(1) { |i| i.map(&.to_s) }
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
rule
|
||||
.tap(&.exclude_calls_with_block = true)
|
||||
.catch(source).should be_valid
|
||||
rule
|
||||
.tap(&.exclude_calls_with_block = false)
|
||||
.catch(source).should_not be_valid
|
||||
rule.exclude_calls_with_block = true
|
||||
expect_no_issues rule, <<-CRYSTAL
|
||||
(1..3).in_groups_of(1) { |i| i.map(&.to_s) }
|
||||
CRYSTAL
|
||||
rule.exclude_calls_with_block = false
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
(1..3).in_groups_of(1) { |i| i.map(&.to_s) }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short block notation instead: `in_groups_of(1, &.map {...})`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "#exclude_multiple_line_blocks" do
|
||||
source = Source.new %(
|
||||
rule = VerboseBlock.new
|
||||
rule.exclude_multiple_line_blocks = true
|
||||
expect_no_issues rule, <<-CRYSTAL
|
||||
(1..3).any? do |i|
|
||||
i.odd?
|
||||
end
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
rule
|
||||
.tap(&.exclude_multiple_line_blocks = true)
|
||||
.catch(source).should be_valid
|
||||
rule
|
||||
.tap(&.exclude_multiple_line_blocks = false)
|
||||
.catch(source).should_not be_valid
|
||||
CRYSTAL
|
||||
rule.exclude_multiple_line_blocks = false
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
(1..3).any? do |i|
|
||||
# ^^^^^^^^^^^ error: Use short block notation instead: `any?(&.odd?)`
|
||||
i.odd?
|
||||
end
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "#exclude_prefix_operators" do
|
||||
source = Source.new %(
|
||||
rule = VerboseBlock.new
|
||||
rule.exclude_prefix_operators = true
|
||||
expect_no_issues rule, <<-CRYSTAL
|
||||
(1..3).sum { |i| +i }
|
||||
(1..3).sum { |i| -i }
|
||||
(1..3).sum { |i| ~i }
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
rule
|
||||
.tap(&.exclude_prefix_operators = true)
|
||||
.catch(source).should be_valid
|
||||
rule
|
||||
.tap(&.exclude_prefix_operators = false)
|
||||
.tap(&.exclude_operators = false)
|
||||
.catch(source).should_not be_valid
|
||||
CRYSTAL
|
||||
rule.exclude_prefix_operators = false
|
||||
rule.exclude_operators = false
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
(1..3).sum { |i| +i }
|
||||
# ^^^^^^^^^^^^^^ error: Use short block notation instead: `sum(&.+)`
|
||||
(1..3).sum { |i| -i }
|
||||
# ^^^^^^^^^^^^^^ error: Use short block notation instead: `sum(&.-)`
|
||||
(1..3).sum { |i| ~i }
|
||||
# ^^^^^^^^^^^^^^ error: Use short block notation instead: `sum(&.~)`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "#exclude_operators" do
|
||||
source = Source.new %(
|
||||
(1..3).sum { |i| i * 2 }
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
rule
|
||||
.tap(&.exclude_operators = true)
|
||||
.catch(source).should be_valid
|
||||
rule
|
||||
.tap(&.exclude_operators = false)
|
||||
.catch(source).should_not be_valid
|
||||
rule.exclude_operators = true
|
||||
expect_no_issues rule, <<-CRYSTAL
|
||||
(1..3).sum { |i| i * 2 }
|
||||
CRYSTAL
|
||||
rule.exclude_operators = false
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
(1..3).sum { |i| i * 2 }
|
||||
# ^^^^^^^^^^^^^^^^^ error: Use short block notation instead: `sum(&.*(2))`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "#exclude_setters" do
|
||||
source = Source.new %(
|
||||
Char::Reader.new("abc").tap { |reader| reader.pos = 0 }
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
rule
|
||||
.tap(&.exclude_setters = true)
|
||||
.catch(source).should be_valid
|
||||
rule
|
||||
.tap(&.exclude_setters = false)
|
||||
.catch(source).should_not be_valid
|
||||
rule.exclude_setters = true
|
||||
expect_no_issues rule, <<-CRYSTAL
|
||||
Char::Reader.new("abc").tap { |reader| reader.pos = 0 }
|
||||
CRYSTAL
|
||||
rule.exclude_setters = false
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
Char::Reader.new("abc").tap { |reader| reader.pos = 0 }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short block notation instead: `tap(&.pos=(0))`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "#max_line_length" do
|
||||
source = Source.new %(
|
||||
rule = VerboseBlock.new
|
||||
rule.exclude_multiple_line_blocks = false
|
||||
rule.max_line_length = 60
|
||||
expect_no_issues rule, <<-CRYSTAL
|
||||
(1..3).tap &.tap &.tap &.tap &.tap &.tap &.tap do |i|
|
||||
i.to_s.reverse.strip.blank?
|
||||
end
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
.tap(&.exclude_multiple_line_blocks = false)
|
||||
rule
|
||||
.tap(&.max_line_length = 60)
|
||||
.catch(source).should be_valid
|
||||
rule
|
||||
.tap(&.max_line_length = nil)
|
||||
.catch(source).should_not be_valid
|
||||
CRYSTAL
|
||||
rule.max_line_length = nil
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
(1..3).tap &.tap &.tap &.tap &.tap &.tap &.tap do |i|
|
||||
# ^^^^^^^^^^ error: Use short block notation instead: `tap(&.to_s.reverse.strip.blank?)`
|
||||
i.to_s.reverse.strip.blank?
|
||||
end
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "#max_length" do
|
||||
source = Source.new %(
|
||||
(1..3).tap { |i| i.to_s.split.reverse.join.strip.blank? }
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
rule
|
||||
.tap(&.max_length = 30)
|
||||
.catch(source).should be_valid
|
||||
rule
|
||||
.tap(&.max_length = nil)
|
||||
.catch(source).should_not be_valid
|
||||
rule.max_length = 30
|
||||
expect_no_issues rule, <<-CRYSTAL
|
||||
(1..3).tap { |i| i.to_s.split.reverse.join.strip.blank? }
|
||||
CRYSTAL
|
||||
rule.max_length = nil
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
(1..3).tap { |i| i.to_s.split.reverse.join.strip.blank? }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `tap(&.to_s.split.reverse.join.strip.blank?)`
|
||||
CRYSTAL
|
||||
end
|
||||
end
|
||||
|
||||
context "macro" do
|
||||
it "reports in macro scope" do
|
||||
source = Source.new %(
|
||||
expect_issue subject, <<-CRYSTAL
|
||||
{{ (1..3).any? { |i| i.odd? } }}
|
||||
)
|
||||
subject.catch(source).should_not be_valid
|
||||
# ^^^^^^^^^^^^^^^^^^^ error: Use short block notation instead: `any?(&.odd?)`
|
||||
CRYSTAL
|
||||
end
|
||||
end
|
||||
|
||||
it "reports call args and named_args" do
|
||||
short_block_variants = {
|
||||
%|map(&.to_s.[start: 0.to_i64, count: 3]?)|,
|
||||
%|map(&.to_s.[0.to_i64, count: 3]?)|,
|
||||
%|map(&.to_s.[0.to_i64, 3]?)|,
|
||||
%|map(&.to_s.[start: 0.to_i64, count: 3]=("foo"))|,
|
||||
%|map(&.to_s.[0.to_i64, count: 3]=("foo"))|,
|
||||
%|map(&.to_s.[0.to_i64, 3]=("foo"))|,
|
||||
%|map(&.to_s.camelcase(lower: true))|,
|
||||
%|map(&.to_s.camelcase)|,
|
||||
%|map(&.to_s.gsub('_', '-'))|,
|
||||
%|map(&.in?(*{1, 2, 3}, **{foo: :bar}))|,
|
||||
%|map(&.in?(1, *foo, 3, **bar))|,
|
||||
%|join(separator: '.', &.to_s)|,
|
||||
}
|
||||
|
||||
source = Source.new path: "source.cr", code: %(
|
||||
(1..3).map { |i| i.to_s[start: 0.to_i64, count: 3]? }
|
||||
(1..3).map { |i| i.to_s[0.to_i64, count: 3]? }
|
||||
(1..3).map { |i| i.to_s[0.to_i64, 3]? }
|
||||
(1..3).map { |i| i.to_s[start: 0.to_i64, count: 3] = "foo" }
|
||||
(1..3).map { |i| i.to_s[0.to_i64, count: 3] = "foo" }
|
||||
(1..3).map { |i| i.to_s[0.to_i64, 3] = "foo" }
|
||||
(1..3).map { |i| i.to_s.camelcase(lower: true) }
|
||||
(1..3).map { |i| i.to_s.camelcase }
|
||||
(1..3).map { |i| i.to_s.gsub('_', '-') }
|
||||
(1..3).map { |i| i.in?(*{1, 2, 3}, **{foo: :bar}) }
|
||||
(1..3).map { |i| i.in?(1, *foo, 3, **bar) }
|
||||
(1..3).join(separator: '.') { |i| i.to_s }
|
||||
)
|
||||
rule = VerboseBlock.new
|
||||
rule
|
||||
.tap(&.exclude_operators = false)
|
||||
.catch(source).should_not be_valid
|
||||
source.issues.size.should eq(short_block_variants.size)
|
||||
|
||||
source.issues.each_with_index do |issue, i|
|
||||
issue.message.should eq(VerboseBlock::MSG % short_block_variants[i])
|
||||
end
|
||||
rule.exclude_operators = false
|
||||
expect_issue rule, <<-CRYSTAL
|
||||
(1..3).map { |i| i.to_s[start: 0.to_i64, count: 3]? }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.[start: 0.to_i64, count: 3]?)`
|
||||
(1..3).map { |i| i.to_s[0.to_i64, count: 3]? }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.[0.to_i64, count: 3]?)`
|
||||
(1..3).map { |i| i.to_s[0.to_i64, 3]? }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.[0.to_i64, 3]?)`
|
||||
(1..3).map { |i| i.to_s[start: 0.to_i64, count: 3] = "foo" }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.[start: 0.to_i64, count: 3]=("foo"))`
|
||||
(1..3).map { |i| i.to_s[0.to_i64, count: 3] = "foo" }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.[0.to_i64, count: 3]=("foo"))`
|
||||
(1..3).map { |i| i.to_s[0.to_i64, 3] = "foo" }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.[0.to_i64, 3]=("foo"))`
|
||||
(1..3).map { |i| i.to_s.camelcase(lower: true) }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.camelcase(lower: true))`
|
||||
(1..3).map { |i| i.to_s.camelcase }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.camelcase)`
|
||||
(1..3).map { |i| i.to_s.gsub('_', '-') }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.to_s.gsub('_', '-'))`
|
||||
(1..3).map { |i| i.in?(*{1, 2, 3}, **{foo: :bar}) }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.in?(*{1, 2, 3}, **{foo: :bar}))`
|
||||
(1..3).map { |i| i.in?(1, *foo, 3, **bar) }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `map(&.in?(1, *foo, 3, **bar))`
|
||||
(1..3).join(separator: '.') { |i| i.to_s }
|
||||
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ error: Use short [...] `join(separator: '.', &.to_s)`
|
||||
CRYSTAL
|
||||
end
|
||||
|
||||
it "reports rule, pos and message" do
|
||||
|
|
|
|||
|
|
@ -169,7 +169,7 @@ module Ameba::Rule::Style
|
|||
end
|
||||
|
||||
# ameba:disable Metrics/CyclomaticComplexity
|
||||
protected def issue_for_valid(source, call : Crystal::Call, body : Crystal::Call)
|
||||
protected def issue_for_valid(source, call : Crystal::Call, block : Crystal::Block, body : Crystal::Call)
|
||||
return if exclude_calls_with_block && body.block
|
||||
return if exclude_multiple_line_blocks && !same_location_lines?(call, body)
|
||||
return if exclude_prefix_operators && prefix_operator?(body)
|
||||
|
|
@ -182,7 +182,7 @@ module Ameba::Rule::Style
|
|||
return unless valid_line_length?(call, call_code)
|
||||
return unless valid_length?(call_code)
|
||||
|
||||
issue_for call.name_location, call.end_location,
|
||||
issue_for call.name_location, block.end_location,
|
||||
MSG % call_code
|
||||
end
|
||||
|
||||
|
|
@ -218,7 +218,7 @@ module Ameba::Rule::Style
|
|||
return if reference_count(body, arg) > 1
|
||||
|
||||
# add issue if the given nodes pass all of the checks
|
||||
issue_for_valid source, node, body
|
||||
issue_for_valid source, node, block, body
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
|||
Loading…
Reference in a new issue