rubocop 0.24.1 → 0.25.0

data/spec/rubocop/cop/style/space_inside_block_braces_spec.rb

@@ -140,6 +140,11 @@ describe RuboCop::Cop::Style::SpaceInsideBlockBraces do
       expect(cop.highlights).to eq(['{|'])
     end
 
+    it 'accepts new lambda syntax' do
+      inspect_source(cop, ['->(x) { x }'])
+      expect(cop.messages).to be_empty
+    end
+
     it 'auto-corrects missing space' do
       new_source = autocorrect_source(cop, 'each {|x| puts }')
       expect(new_source).to eq('each { |x| puts }')
@@ -182,6 +187,11 @@ describe RuboCop::Cop::Style::SpaceInsideBlockBraces do
         expect(cop.highlights).to eq([' '])
       end
 
+      it 'accepts new lambda syntax' do
+        inspect_source(cop, ['->(x) { x }'])
+        expect(cop.messages).to be_empty
+      end
+
       it 'auto-corrects unwanted space' do
         new_source = autocorrect_source(cop, 'each { |x| puts }')
         expect(new_source).to eq('each {|x| puts }')
@@ -256,6 +266,11 @@ describe RuboCop::Cop::Style::SpaceInsideBlockBraces do
           expect(cop.highlights).to eq(['{|'])
         end
 
+        it 'accepts new lambda syntax' do
+          inspect_source(cop, ['->(x) {x}'])
+          expect(cop.messages).to be_empty
+        end
+
         it 'auto-corrects missing space' do
           new_source = autocorrect_source(cop, 'each {|x| puts}')
           expect(new_source).to eq('each { |x| puts}')
@@ -277,6 +292,11 @@ describe RuboCop::Cop::Style::SpaceInsideBlockBraces do
           expect(cop.highlights).to eq([' '])
         end
 
+        it 'accepts new lambda syntax' do
+          inspect_source(cop, ['->(x) {x}'])
+          expect(cop.messages).to be_empty
+        end
+
         it 'auto-corrects unwanted space' do
           new_source = autocorrect_source(cop, 'each { |x| puts}')
           expect(new_source).to eq('each {|x| puts}')

data/spec/rubocop/cop/style/space_inside_brackets_spec.rb

@@ -13,6 +13,22 @@ describe RuboCop::Cop::Style::SpaceInsideBrackets do
        'Space inside square brackets detected.'])
   end
 
+  it 'registers an offense for Hash#[] with symbol key and spaces inside' do
+    inspect_source(cop, ['a[ :key]',
+                         'b[:key ]'])
+    expect(cop.messages).to eq(
+      ['Space inside square brackets detected.',
+       'Space inside square brackets detected.'])
+  end
+
+  it 'registers an offense for Hash#[] with string key and spaces inside' do
+    inspect_source(cop, ['a[\'key\' ]',
+                         'b[ \'key\']'])
+    expect(cop.messages).to eq(
+      ['Space inside square brackets detected.',
+       'Space inside square brackets detected.'])
+  end
+
   it 'accepts space inside strings within square brackets' do
     inspect_source(cop, ["['Encoding:',",
                          " '  Enabled: false']"])
@@ -52,8 +68,16 @@ describe RuboCop::Cop::Style::SpaceInsideBrackets do
 
   it 'auto-corrects unwanted space' do
     new_source = autocorrect_source(cop, ['a = [1, 2 ]',
-                                          'b = [ 1, 2]'])
+                                          'b = [ 1, 2]',
+                                          'c[ :key]',
+                                          'd[:key ]',
+                                          'e["key" ]',
+                                          'f[ "key"]'])
     expect(new_source).to eq(['a = [1, 2]',
-                              'b = [1, 2]'].join("\n"))
+                              'b = [1, 2]',
+                              'c[:key]',
+                              'd[:key]',
+                              'e["key"]',
+                              'f["key"]'].join("\n"))
   end
 end

data/spec/rubocop/cop/style/trailing_comma_spec.rb

@@ -75,6 +75,28 @@ describe RuboCop::Cop::Style::TrailingComma, :config do
       inspect_source(cop, 'some_method')
       expect(cop.offenses).to be_empty
     end
+
+    it 'auto-corrects unwanted comma in an Array literal' do
+      new_source = autocorrect_source(cop, 'VALUES = [1001, 2020, 3333, ]')
+      expect(new_source).to eq('VALUES = [1001, 2020, 3333 ]')
+    end
+
+    it 'auto-corrects unwanted comma in a Hash literal' do
+      new_source = autocorrect_source(cop,
+                                      'MAP = { a: 1001, b: 2020, c: 3333, }')
+      expect(new_source).to eq('MAP = { a: 1001, b: 2020, c: 3333 }')
+    end
+
+    it 'auto-corrects unwanted comma in a method call' do
+      new_source = autocorrect_source(cop, 'some_method(a, b, c, )')
+      expect(new_source).to eq('some_method(a, b, c )')
+    end
+
+    it 'auto-corrects unwanted comma in a method call with hash parameters at' \
+       ' the end' do
+      new_source = autocorrect_source(cop, 'some_method(a, b, c: 0, d: 1, )')
+      expect(new_source).to eq('some_method(a, b, c: 0, d: 1 )')
+    end
   end
 
   context 'with single line list of values' do
@@ -155,6 +177,44 @@ describe RuboCop::Cop::Style::TrailingComma, :config do
                              '})'])
         expect(cop.offenses).to be_empty
       end
+
+      it 'auto-corrects unwanted comma in an Array literal' do
+        new_source = autocorrect_source(cop, ['VALUES = [',
+                                              '           1001,',
+                                              '           2020,',
+                                              '           3333,',
+                                              '         ]'])
+        expect(new_source).to eq(['VALUES = [',
+                                  '           1001,',
+                                  '           2020,',
+                                  '           3333',
+                                  '         ]'].join("\n"))
+      end
+
+      it 'auto-corrects unwanted comma in a Hash literal' do
+        new_source = autocorrect_source(cop, ['MAP = { a: 1001,',
+                                              '        b: 2020,',
+                                              '        c: 3333,',
+                                              '      }'])
+        expect(new_source).to eq(['MAP = { a: 1001,',
+                                  '        b: 2020,',
+                                  '        c: 3333',
+                                  '      }'].join("\n"))
+      end
+
+      it 'auto-corrects unwanted comma in a method call with hash parameters' \
+         ' at the end' do
+        new_source = autocorrect_source(cop, ['some_method(',
+                                              '              a,',
+                                              '              b,',
+                                              '              c: 0,',
+                                              '              d: 1,)'])
+        expect(new_source).to eq(['some_method(',
+                                  '              a,',
+                                  '              b,',
+                                  '              c: 0,',
+                                  '              d: 1)'].join("\n"))
+      end
     end
 
     context 'when EnforcedStyleForMultiline is comma' do
@@ -254,6 +314,19 @@ describe RuboCop::Cop::Style::TrailingComma, :config do
         expect(cop.offenses).to be_empty
       end
 
+      # this is a sad parse error
+      it 'accepts no trailing comma in a method call with a block' \
+         ' paramter at the end' do
+        inspect_source(cop, ['some_method(',
+                             '              a,',
+                             '              b,',
+                             '              c: 0,',
+                             '              d: 1,',
+                             '              &block',
+                             '           )'])
+        expect(cop.offenses).to be_empty
+      end
+
       it 'accepts a multiline word array' do
         inspect_source(cop, ['ingredients = %w(',
                              '  sausage',
@@ -273,6 +346,45 @@ describe RuboCop::Cop::Style::TrailingComma, :config do
                              '})'])
         expect(cop.offenses).to be_empty
       end
+
+      it 'auto-corrects an Array literal with two of the values on the same' \
+         ' line and a trailing comma' do
+        new_source = autocorrect_source(cop, ['VALUES = [',
+                                              '           1001, 2020,',
+                                              '           3333,',
+                                              '         ]'])
+        expect(new_source).to eq(['VALUES = [',
+                                  '           1001, 2020,',
+                                  '           3333',
+                                  '         ]'].join("\n"))
+      end
+
+      it 'auto-corrects missing comma in a Hash literal' do
+        new_source = autocorrect_source(cop, ['MAP = { a: 1001,',
+                                              '        b: 2020,',
+                                              '        c: 3333',
+                                              '}'])
+        expect(new_source).to eq(['MAP = { a: 1001,',
+                                  '        b: 2020,',
+                                  '        c: 3333,',
+                                  '}'].join("\n"))
+      end
+
+      it 'auto-corrects missing comma in a method call with hash parameters' \
+         ' at the end' do
+        new_source = autocorrect_source(cop, ['some_method(',
+                                              '              a,',
+                                              '              b,',
+                                              '              c: 0,',
+                                              '              d: 1',
+                                              '           )'])
+        expect(new_source).to eq(['some_method(',
+                                  '              a,',
+                                  '              b,',
+                                  '              c: 0,',
+                                  '              d: 1,',
+                                  '           )'].join("\n"))
+      end
     end
   end
 end

data/spec/rubocop/cop/style/unneeded_percent_q_spec.rb

@@ -6,67 +6,122 @@ describe RuboCop::Cop::Style::UnneededPercentQ do
   subject(:cop) { described_class.new }
 
   context 'with %q strings' do
+    let(:source) do
+      <<-END.strip_indent
+        %q('hi') # line 1
+        %q("hi")
+        %q(hi)
+        %q('"hi"')
+        %q('hi\\t') # line 5
+      END
+    end
+    let(:corrected) do
+      <<-END.strip_indent
+        "'hi'" # line 1
+        '"hi"'
+        'hi'
+        %q('"hi"')
+        %q('hi\\t') # line 5
+      END
+    end
+    before { inspect_source(cop, source) }
+
     it 'registers an offense for only single quotes' do
-      inspect_source(cop, "%q('hi')")
+      expect(cop.offenses.map(&:line)).to include(1)
       expect(cop.messages).to eq(['Use `%q` only for strings that contain ' \
-                                  'both single quotes and double quotes.'])
+                                  'both single quotes and double quotes.'] * 3)
     end
 
     it 'registers an offense for only double quotes' do
-      inspect_source(cop, '%q("hi")')
-      expect(cop.offenses.size).to eq(1)
+      expect(cop.offenses.map(&:line)).to include(2)
+    end
+
+    it 'registers an offense for no quotes' do
+      expect(cop.offenses.map(&:line)).to include(3)
     end
 
     it 'accepts a string with single quotes and double quotes' do
-      inspect_source(cop, %Q(%q('"hi"')))
-      expect(cop.offenses).to be_empty
+      expect(cop.offenses.map(&:line)).not_to include(4)
     end
 
-    it 'normally auto-corrects %q to single quotes' do
-      new_source = autocorrect_source(cop, '%q(hi)')
-      expect(new_source).to eq("'hi'")
+    it 'accepts a string with a tab character' do
+      expect(cop.offenses.map(&:line)).not_to include(5)
     end
 
-    it 'auto-corrects %q to double quotes if necessary' do
-      new_source = autocorrect_source(cop, "%q('hi')")
-      expect(new_source).to eq(%q("'hi'"))
+    it 'auto-corrects' do
+      new_source = autocorrect_source(cop, source)
+      expect(new_source).to eq(corrected)
     end
   end
 
   context 'with %Q strings' do
-    it 'registers an offense for static string with only double quotes' do
-      inspect_source(cop, '%Q("hi")')
+    let(:source) do
+      <<-END.strip_indent
+        %Q(hi) # line 1
+        %Q("hi")
+        %Q(hi\#{4})
+        %Q('"hi"')
+        %Q("\\thi")
+        %Q("hi\#{4}")
+        /%Q?/ # line 7
+      END
+    end
+    let(:corrected) do
+      <<-END.strip_indent
+        "hi" # line 1
+        '"hi"'
+        "hi\#{4}"
+        %Q('"hi"')
+        %Q("\\thi")
+        %Q("hi\#{4}")
+        /%Q?/ # line 7
+      END
+    end
+    before { inspect_source(cop, source) }
+
+    it 'registers an offense for static string without quotes' do
+      expect(cop.offenses.map(&:line)).to include(1)
       expect(cop.messages).to eq(['Use `%Q` only for strings that contain ' \
                                   'both single quotes and double quotes, or ' \
                                   'for dynamic strings that contain double ' \
-                                  'quotes.'])
+                                  'quotes.'] * 3)
+    end
+
+    it 'registers an offense for static string with only double quotes' do
+      expect(cop.offenses.map(&:line)).to include(2)
+    end
+
+    it 'registers an offense for dynamic string without quotes' do
+      expect(cop.offenses.map(&:line)).to include(3)
     end
 
     it 'accepts a string with single quotes and double quotes' do
-      inspect_source(cop, %Q(%Q('"hi"')))
-      expect(cop.offenses).to be_empty
+      expect(cop.offenses.map(&:line)).not_to include(4)
     end
 
-    it 'accepts a dynamic %Q string with double quotes' do
-      inspect_source(cop, '%Q("hi#{4}")')
-      expect(cop.offenses).to be_empty
+    it 'accepts a string with double quotes and tab character' do
+      expect(cop.offenses.map(&:line)).not_to include(5)
     end
 
-    it 'auto-corrects static %Q to double quotes' do
-      new_source = autocorrect_source(cop, '%Q(hi)')
-      # One could argue that the double quotes are not necessary for a static
-      # string, but that's the job of the StringLiterals cop to check.
-      expect(new_source).to eq('"hi"')
+    it 'accepts a dynamic %Q string with double quotes' do
+      expect(cop.offenses.map(&:line)).not_to include(6)
     end
 
-    it 'auto-corrects static %Q with inner double quotes to single quotes' do
-      new_source = autocorrect_source(cop, '%Q("hi")')
-      expect(new_source).to eq(%q('"hi"'))
+    it 'accepts regular expressions starting with %Q' do
+      expect(cop.offenses.map(&:line)).not_to include(7)
     end
 
-    it 'auto-corrects dynamic %Q to double quotes' do
-      new_source = autocorrect_source(cop, '%Q(hi #{func})')
-      expect(new_source).to eq('"hi #{func}"')
+    it 'auto-corrects' do
+      new_source = autocorrect_source(cop, source)
+      expect(new_source).to eq(corrected)
     end
   end
+
+  it 'accepts a heredoc string that contains %q' do
+    inspect_source(cop, ['  s = <<END',
+                         "%q('hi') # line 1",
+                         '%q("hi")',
+                         'END'])
+    expect(cop.offenses).to be_empty
+  end
 end

data/spec/rubocop/cop/style/variable_interpolation_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 describe RuboCop::Cop::Style::VariableInterpolation do
   subject(:cop) { described_class.new }
 
-  it 'registers an offense for interpolated global variables' do
+  it 'registers an offense for interpolated global variables in string' do
     inspect_source(cop,
                    ['puts "this is a #$test"'])
     expect(cop.offenses.size).to eq(1)
@@ -15,6 +15,26 @@ describe RuboCop::Cop::Style::VariableInterpolation do
               ' with expression `#{$test}`.'])
   end
 
+  it 'registers an offense for interpolated global variables in regexp' do
+    inspect_source(cop,
+                   ['puts /this is a #$test/'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.highlights).to eq(['$test'])
+    expect(cop.messages)
+      .to eq(['Replace interpolated variable `$test`' \
+              ' with expression `#{$test}`.'])
+  end
+
+  it 'registers an offense for interpolated global variables in regexp' do
+    inspect_source(cop,
+                   ['puts `this is a #$test`'])
+    expect(cop.offenses.size).to eq(1)
+    expect(cop.highlights).to eq(['$test'])
+    expect(cop.messages)
+      .to eq(['Replace interpolated variable `$test`' \
+              ' with expression `#{$test}`.'])
+  end
+
   it 'registers an offense for interpolated regexp back references' do
     inspect_source(cop,
                    ['puts "this is a #$1"'])

data/spec/rubocop/cop/team_spec.rb

@@ -72,7 +72,7 @@ describe RuboCop::Cop::Team do
       end
 
       it 'returns offenses from cops' do
-        expect(cop_names).to include('Style/LineLength')
+        expect(cop_names).to include('Metrics/LineLength')
       end
     end
 
@@ -112,30 +112,35 @@ describe RuboCop::Cop::Team do
 
     context 'when only some cop classes are passed to .new' do
       let(:cop_classes) do
-        [RuboCop::Cop::Lint::Void, RuboCop::Cop::Style::LineLength]
+        [RuboCop::Cop::Lint::Void, RuboCop::Cop::Metrics::LineLength]
       end
 
       it 'returns only intances of the classes' do
         expect(cops.size).to eq(2)
         cops.sort! { |a, b| a.name <=> b.name }
         expect(cops[0].name).to eq('Lint/Void')
-        expect(cops[1].name).to eq('Style/LineLength')
+        expect(cops[1].name).to eq('Metrics/LineLength')
       end
     end
 
     context 'when some classes are disabled with config' do
-      before do
-        %w(Lint/Void Style/LineLength).each do |cop_name|
-          config.for_cop(cop_name)['Enabled'] = false
+      let(:disabled_config) do
+        %w(
+          Lint/Void
+          Metrics/LineLength
+        ).each_with_object({}) do |cop_name, accum|
+          accum[cop_name] = { 'Enabled' => false }
         end
       end
-
+      let(:config) do
+        RuboCop::ConfigLoader.merge_with_default(disabled_config, '')
+      end
       let(:cop_names) { cops.map(&:name) }
 
       it 'does not return intances of the classes' do
         expect(cops).not_to be_empty
-        expect(cop_names).not_to include('Style/Void')
-        expect(cop_names).not_to include('Style/LineLength')
+        expect(cop_names).not_to include('Lint/Void')
+        expect(cop_names).not_to include('Metrics/LineLength')
       end
     end
   end