forked from rubocop/rubocop
-
Notifications
You must be signed in to change notification settings - Fork 2
/
hash_transform_values_spec.rb
145 lines (120 loc) · 4.51 KB
/
hash_transform_values_spec.rb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
# frozen_string_literal: true
RSpec.describe RuboCop::Cop::Style::HashTransformValues, :config do
subject(:cop) { described_class.new(config) }
context 'with inline block' do
it 'flags each_with_object when transform_values could be used' do
expect_offense(<<~RUBY)
x.each_with_object({}) {|(k, v), h| h[k] = foo(v)}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `transform_values` over `each_with_object`.
RUBY
end
end
context 'with multiline block' do
it 'flags each_with_object when transform_values could be used' do
expect_offense(<<~RUBY)
some_hash.each_with_object({}) do |(key, val), memo|
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `transform_values` over `each_with_object`.
memo[key] = val * val
end
RUBY
end
end
context 'with safe navigation operator' do
it 'flags each_with_object when transform_values could be used' do
expect_offense(<<~RUBY)
x&.each_with_object({}) {|(k, v), h| h[k] = foo(v)}
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `transform_values` over `each_with_object`.
RUBY
end
end
it 'does not flag each_with_object when both key & value are transformed' do
expect_no_offenses(<<~RUBY)
x.each_with_object({}) {|(k, v), h| h[k.to_sym] = foo(v)}
RUBY
end
it 'does not flag each_with_object when value transformation uses key' do
expect_no_offenses('x.each_with_object({}) {|(k, v), h| h[k] = k.to_s}')
end
it 'does not flag each_with_object when no transformation occurs' do
expect_no_offenses('x.each_with_object({}) {|(k, v), h| h[k] = v}')
end
it 'does not flag each_with_object when its argument is not modified' do
expect_no_offenses(<<~RUBY)
x.each_with_object({}) {|(k, v), h| other_h[k] = v * v}
RUBY
end
it 'does not flag each_with_object when receiver is array literal' do
expect_no_offenses(<<~RUBY)
[1, 2, 3].each_with_object({}) {|(k, v), h| h[k] = foo(v)}
RUBY
end
it 'flags _.map {...}.to_h when transform_values could be used' do
expect_offense(<<~RUBY)
x.map {|k, v| [k, foo(v)]}.to_h
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `transform_values` over `map {...}.to_h`.
RUBY
end
it 'flags _.map {...}.to_h when transform_values could be used ' \
'when line break before `to_h`' do
expect_offense(<<~RUBY)
x.map {|k, v| [k, foo(v)]}.
^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `transform_values` over `map {...}.to_h`.
to_h
RUBY
expect_correction(<<~RUBY)
x.transform_values {|v| foo(v)}
RUBY
end
it 'does not flag _.map{...}.to_h when both key & value are transformed' do
expect_no_offenses('x.map {|k, v| [k.to_sym, foo(v)]}.to_h')
end
it 'flags Hash[_.map{...}] when transform_values could be used' do
expect_offense(<<~RUBY)
Hash[x.map {|k, v| [k, foo(v)]}]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `transform_values` over `Hash[_.map {...}]`.
RUBY
end
it 'does not flag Hash[_.map{...}] when both key & value are transformed' do
expect_no_offenses('Hash[x.map {|k, v| [k.to_sym, foo(v)]}]')
end
it 'does not flag value transformation in the absence of to_h' do
expect_no_offenses('x.map {|k, v| [k, foo(v)]}')
end
it 'does not flag value transformation when receiver is array literal' do
expect_no_offenses(<<~RUBY)
[1, 2, 3].map {|k, v| [k, foo(v)]}.to_h
RUBY
end
it 'correctly autocorrects each_with_object' do
corrected = autocorrect_source(<<~RUBY)
{a: 1, b: 2}.each_with_object({}) {|(k, v), h| h[k] = foo(v)}
RUBY
expect(corrected).to eq(<<~RUBY)
{a: 1, b: 2}.transform_values {|v| foo(v)}
RUBY
end
it 'correctly autocorrects _.map{...}.to_h without block' do
corrected = autocorrect_source(<<~RUBY)
{a: 1, b: 2}.map {|k, v| [k, foo(v)]}.to_h
RUBY
expect(corrected).to eq(<<~RUBY)
{a: 1, b: 2}.transform_values {|v| foo(v)}
RUBY
end
it 'correctly autocorrects _.map{...}.to_h with block' do
corrected = autocorrect_source(<<~RUBY)
{a: 1, b: 2}.map {|k, v| [k, foo(v)]}.to_h {|k, v| [v, k]}
RUBY
expect(corrected).to eq(<<~RUBY)
{a: 1, b: 2}.transform_values {|v| foo(v)}.to_h {|k, v| [v, k]}
RUBY
end
it 'correctly autocorrects Hash[_.map{...}]' do
corrected = autocorrect_source(<<~RUBY)
Hash[{a: 1, b: 2}.map {|k, v| [k, foo(v)]}]
RUBY
expect(corrected).to eq(<<~RUBY)
{a: 1, b: 2}.transform_values {|v| foo(v)}
RUBY
end
end