rubocop 0.26.1 → 0.27.0

data/spec/fixtures/html_formatter/project/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end

data/spec/fixtures/html_formatter/project/app/controllers/books_controller.rb

@@ -0,0 +1,74 @@
+class BooksController < ApplicationController
+  before_action :set_book, only: [:show, :edit, :update, :destroy]
+
+  # GET /books
+  # GET /books.json
+  def index
+    @books = Book.all
+  end
+
+  # GET /books/1
+  # GET /books/1.json
+  def show
+  end
+
+  # GET /books/new
+  def new
+    @book = Book.new
+  end
+
+  # GET /books/1/edit
+  def edit
+  end
+
+  # POST /books
+  # POST /books.json
+  def create
+    @book = Book.new(book_params)
+
+    respond_to do |format|
+      if @book.save
+        format.html { redirect_to @book, notice: 'Book was successfully created.' }
+        format.json { render :show, status: :created, location: @book }
+      else
+        format.html { render :new }
+        format.json { render json: @book.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /books/1
+  # PATCH/PUT /books/1.json
+  def update
+    respond_to do |format|
+      if @book.update(book_params)
+        format.html { redirect_to @book, notice: 'Book was successfully updated.' }
+        format.json { render :show, status: :ok, location: @book }
+      else
+        format.html { render :edit }
+        format.json { render json: @book.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /books/1
+  # DELETE /books/1.json
+  def destroy
+    @book.destroy
+    respond_to do |format|
+      format.html { redirect_to books_url, notice: 'Book was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_book
+      @book = Book.find(params[:id])
+    end
+
+    # Never trust parameters from the scary internet, only allow the white list through.
+    def book_params
+      params.require(:book).permit(:name)
+    end
+end

data/spec/fixtures/html_formatter/project/app/models/book.rb

@@ -0,0 +1,5 @@
+class Book < ActiveRecord::Base
+  def someMethod
+    foo = bar = baz
+  end
+end

data/spec/rubocop/cli_spec.rb

@@ -35,6 +35,43 @@ describe RuboCop::CLI, :isolated_environment do
     end
 
     describe '--auto-correct' do
+      it 'corrects SymbolProc and SpaceBeforeBlockBraces offences' do
+        source = ['foo.map{ |a| a.nil? }']
+        create_file('example.rb', source)
+        expect(cli.run(['-D', '--auto-correct'])).to eq(1)
+        corrected = "foo.map(&:nil?)\n"
+        expect(IO.read('example.rb')).to eq(corrected)
+      end
+
+      it 'corrects complicated cases conservatively' do
+        # Two cops make corrections here; Style/BracesAroundHashParameters, and
+        # Style/AlignHash. Because they make minimal corrections relating only
+        # to their specific areas, and stay away from cleaning up extra
+        # whitespace in the process, the combined changes don't interfere with
+        # eachother and the result is semantically the same as the starting
+        # point.
+        source = ['# encoding: utf-8',
+                  'expect(subject[:address]).to eq({',
+                  "  street1:     '1 Market',",
+                  "  street2:     '#200',",
+                  "  city:        'Some Town',",
+                  "  state:       'CA',",
+                  "  postal_code: '99999-1111'",
+                  '})']
+        create_file('example.rb', source)
+        expect(cli.run(['-D', '--auto-correct'])).to eq(1)
+        corrected =
+          ['# encoding: utf-8',
+           'expect(subject[:address]).to eq(',
+           "  street1:     '1 Market',",
+           "  street2:     '#200',",
+           "  city:        'Some Town',",
+           "  state:       'CA',",
+           "  postal_code: '99999-1111'",
+           ')']
+        expect(IO.read('example.rb')).to eq(corrected.join("\n") + "\n")
+      end
+
       it 'honors Exclude settings in individual cops' do
         source = ['# encoding: utf-8',
                   'puts %x(ls)']
@@ -274,13 +311,13 @@ describe RuboCop::CLI, :isolated_environment do
                                              'end',
                                              ''].join("\n"))
         expect($stdout.string).to eq(['',
-                                      '6   Style/TrailingWhitespace',
-                                      '4   Style/Semicolon',
-                                      '2   Style/SingleLineMethods',
+                                      '10  Style/TrailingWhitespace',
+                                      '5   Style/Semicolon',
+                                      '3   Style/SingleLineMethods',
                                       '1   Style/DefWithParentheses',
                                       '1   Style/EmptyLineBetweenDefs',
                                       '--',
-                                      '14  Total',
+                                      '20  Total',
                                       '',
                                       ''].join("\n"))
       end
@@ -347,7 +384,7 @@ describe RuboCop::CLI, :isolated_environment do
                   'Offenses:',
                   '',
                   'example.rb:4:1: C: [Corrected] Extra empty line detected ' \
-                  'at body beginning.',
+                  'at class body beginning.',
                   'example.rb:4:1: C: [Corrected] Trailing whitespace ' \
                   'detected.',
                   '',
@@ -360,14 +397,14 @@ describe RuboCop::CLI, :isolated_environment do
         create_file('example.rb',
                     ['# encoding: utf-8',
                      'def primes limit',
-                     '  1.upto(limit).find_all { |i| is_prime[i] }',
+                     '  1.upto(limit).select { |i| i.even? }',
                      'end'])
         expect(cli.run(%w(-D --auto-correct))).to eq(1)
         expect($stderr.string).to eq('')
         expect(IO.read('example.rb'))
           .to eq(['# encoding: utf-8',
                   'def primes(limit)',
-                  '  1.upto(limit).select { |i| is_prime[i] }',
+                  '  1.upto(limit).select(&:even?)',
                   'end',
                   ''].join("\n"))
         expect($stdout.string)
@@ -381,10 +418,10 @@ describe RuboCop::CLI, :isolated_environment do
                   'Use def with parentheses when there are parameters.',
                   'def primes limit',
                   '           ^^^^^',
-                  'example.rb:3:17: C: [Corrected] Style/CollectionMethods: ' \
-                  'Prefer select over find_all.',
-                  '  1.upto(limit).find_all { |i| is_prime[i] }',
-                  '                ^^^^^^^^',
+                  'example.rb:3:3: C: [Corrected] Style/SymbolProc: ' \
+                  'Pass &:even? as an argument to select instead of a block.',
+                  '  1.upto(limit).select { |i| i.even? }',
+                  '  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^',
                   '',
                   '1 file inspected, 2 offenses detected, 2 offenses ' \
                   'corrected',
@@ -1181,7 +1218,7 @@ describe RuboCop::CLI, :isolated_environment do
                       'indentation.',
                       '   puts',
                       '^^^',
-                      'example3.rb:2:5: C: Use snake_case for methods.',
+                      'example3.rb:2:5: C: Use snake_case for method names.',
                       'def badName',
                       '    ^^^^^^^',
                       'example3.rb:3:3: C: Use a guard clause instead of ' \
@@ -1923,7 +1960,13 @@ describe RuboCop::CLI, :isolated_environment do
                   ['Style/CollectionMethods:',
                    '  PreferredMethods:',
                    '    select: find_all'])
-      cli.run(['--format', 'simple', '-c', 'rubocop.yml', 'example1.rb'])
+      cli.run(['--format',
+               'simple',
+               '-c',
+               'rubocop.yml',
+               '--only',
+               'CollectionMethods',
+               'example1.rb'])
       expect($stdout.string)
         .to eq(['== example1.rb ==',
                 'C:  2:  5: Prefer find_all over select.',

data/spec/rubocop/cop/lint/invalid_character_literal_spec.rb

@@ -26,7 +26,7 @@ describe RuboCop::Cop::Lint::InvalidCharacterLiteral do
 
       expect(cop.offenses.size).to eq(1)
       expect(cop.offenses.first.message)
-      .to eq('Invalid character literal; use ?\s')
+        .to eq('Invalid character literal; use ?\s')
       expect(cop.highlights).to eq([' '])
     end
   end

data/spec/rubocop/cop/metrics/abc_size_spec.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe RuboCop::Cop::Metrics::AbcSize, :config do
+  subject(:cop) { described_class.new(config) }
+
+  context 'when Max is 0' do
+    let(:cop_config) { { 'Max' => 0 } }
+
+    it 'accepts an empty method' do
+      inspect_source(cop, ['def method_name',
+                           'end'])
+      expect(cop.offenses).to be_empty
+    end
+
+    it 'registers an offense for an if modifier' do
+      inspect_source(cop, ['def method_name',
+                           '  call_foo if some_condition', # 0 + 2*2 + 1*1
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Assignment Branch Condition size for method_name is too ' \
+                'high. [2.24/0]'])
+      expect(cop.highlights).to eq(['def'])
+      expect(cop.config_to_allow_offenses).to eq('Max' => 3)
+    end
+
+    it 'registers an offense for an assignment of a local variable' do
+      inspect_source(cop, ['def method_name',
+                           '  x = 1',
+                           'end'])
+      expect(cop.messages)
+        .to eq(['Assignment Branch Condition size for method_name is too ' \
+                'high. [1/0]'])
+      expect(cop.config_to_allow_offenses).to eq('Max' => 1)
+    end
+
+    it 'registers an offense for complex content including A, B, and C ' \
+       'scores' do
+      inspect_source(cop,
+                     ['def method_name',
+                      '  my_options = Hash.new if 1 == 1 || 2 == 2', # 1, 3, 2
+                      '  my_options.each do |key, value|',           # 0, 1, 0
+                      '    p key',                                   # 0, 1, 0
+                      '    p value',                                 # 0, 1, 0
+                      '  end',
+                      'end'])
+      expect(cop.messages)
+        .to eq(['Assignment Branch Condition size for method_name is too ' \
+                'high. [6.4/0]']) # square root of 1*1 + 5*5 + 2*2 => 6.4
+    end
+  end
+
+  context 'when Max is 2' do
+    let(:cop_config) { { 'Max' => 2 } }
+
+    it 'accepts two assignments' do
+      inspect_source(cop, ['def method_name',
+                           '  x = 1',
+                           '  y = 2',
+                           'end'])
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  context 'when Max is 1.8' do
+    let(:cop_config) { { 'Max' => 1.8 } }
+
+    it 'accepts a total score of 1.7' do
+      inspect_source(cop, ['def method_name',
+                           '  y = 1 if y == 1',
+                           'end'])
+      expect(cop.offenses).to be_empty
+    end
+  end
+
+  {
+    1.3     => '3.74/1.3',    # no more than 2 decimals reported
+    10.3    => '37.42/10.3',
+    100.321 => '374.2/100.3', # 4 significant digits, so only 1 decimal here
+    1000.3  => '3742/1000'
+  }.each do |max, presentation|
+    context "when Max is #{max}" do
+      let(:cop_config) { { 'Max' => max } }
+
+      it "reports size and max as #{presentation}" do
+        # Build an amount of code large enough to register an offense.
+        code = ['  x = Hash.new if 1 == 1 || 2 == 2'] * max
+
+        inspect_source(cop, ['def method_name',
+                             *code,
+                             'end'])
+        expect(cop.messages)
+          .to eq(['Assignment Branch Condition size for method_name is too ' \
+                  "high. [#{presentation}]"])
+      end
+    end
+  end
+end

data/spec/rubocop/cop/rails/action_filter_spec.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require 'spec_helper'
+require 'tempfile'
 
 describe RuboCop::Cop::Rails::ActionFilter, :config do
   subject(:cop) { described_class.new(config) }

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

@@ -2,8 +2,15 @@
 
 require 'spec_helper'
 
-describe RuboCop::Cop::Style::AccessModifierIndentation, :config do
+describe RuboCop::Cop::Style::AccessModifierIndentation do
   subject(:cop) { described_class.new(config) }
+  let(:config) do
+    c = cop_config.merge('SupportedStyles' => %w(indent outdent))
+    RuboCop::Config
+      .new('Style/AccessModifierIndentation' => c,
+           'Style/IndentationWidth' => { 'Width' => indentation_width })
+  end
+  let(:indentation_width) { 2 }
 
   context 'when EnforcedStyle is set to indent' do
     let(:cop_config) { { 'EnforcedStyle' => 'indent' } }
@@ -216,6 +223,21 @@ describe RuboCop::Cop::Style::AccessModifierIndentation, :config do
                                '  def test; end',
                                'end'].join("\n"))
     end
+
+    context 'when 4 spaces per indent level are used' do
+      let(:indentation_width) { 4 }
+
+      it 'accepts properly indented private' do
+        inspect_source(cop,
+                       ['class Test',
+                        '',
+                        '    private',
+                        '',
+                        '    def test; end',
+                        'end'])
+        expect(cop.offenses).to be_empty
+      end
+    end
   end
 
   context 'when EnforcedStyle is set to outdent' do

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

@@ -129,6 +129,12 @@ describe RuboCop::Cop::Style::AlignHash, :config do
                                     "'dddd'  =>  2"])
     end
 
+    it 'registers an offense for misaligned mixed multiline hash keys' do
+      inspect_source(cop, ['hash = { a: 1, b: 2,',
+                           '        c: 3 }'])
+      expect(cop.offenses.size).to eq(1)
+    end
+
     it 'accepts aligned hash keys' do
       inspect_source(cop, ['hash1 = {',
                            '  a: 0,',
@@ -192,6 +198,13 @@ describe RuboCop::Cop::Style::AlignHash, :config do
                                 # in 'key' mode.
                                 '          :ccc  =>2 }'].join("\n"))
     end
+
+    it 'auto-corrects alignment for mixed multiline hash keys' do
+      new_sources = autocorrect_source(cop, ['hash = { a: 1, b: 2,',
+                                             '        c: 3 }'])
+      expect(new_sources).to eq(['hash = { a: 1, b: 2,',
+                                 '         c: 3 }'].join("\n"))
+    end
   end
 
   include_examples 'not on separate lines'

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

@@ -2,8 +2,15 @@
 
 require 'spec_helper'
 
-describe RuboCop::Cop::Style::AlignParameters, :config do
+describe RuboCop::Cop::Style::AlignParameters do
   subject(:cop) { described_class.new(config) }
+  let(:config) do
+    RuboCop::Config.new('Style/AlignParameters' => cop_config,
+                        'Style/IndentationWidth' => {
+                          'Width' => indentation_width
+                        })
+  end
+  let(:indentation_width) { 2 }
 
   context 'aligned with first parameter' do
     let(:cop_config) do
@@ -382,38 +389,42 @@ describe RuboCop::Cop::Style::AlignParameters, :config do
     end
 
     context 'assigned methods' do
-      it 'accepts the first parameter being on a new row' do
-        inspect_source(cop, [' assigned_value = match(',
-                             '   a,',
-                             '   b,',
-                             '   c',
-                             ' )'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'accepts the first parameter being on method row' do
-        inspect_source(cop, [' assigned_value = match(a,',
-                             '   b,',
-                             '   c',
-                             ' )'])
-        expect(cop.offenses).to be_empty
-      end
-
-      it 'autocorrects even when first argument is in wrong position' do
-        original_source = [' assigned_value = match(',
-                           '         a,',
-                           '            b,',
-                           '                    c',
-                           ' )']
-
-        correct_source = [' assigned_value = match(',
-                          '   a,',
-                          '   b,',
-                          '   c',
-                          ' )']
-
-        expect(autocorrect_source(cop, original_source))
-          .to eq(correct_source.join("\n"))
+      context 'with IndentationWidth:Width set to 4' do
+        let(:indentation_width) { 4 }
+
+        it 'accepts the first parameter being on a new row' do
+          inspect_source(cop, [' assigned_value = match(',
+                               '     a,',
+                               '     b,',
+                               '     c',
+                               ' )'])
+          expect(cop.offenses).to be_empty
+        end
+
+        it 'accepts the first parameter being on method row' do
+          inspect_source(cop, [' assigned_value = match(a,',
+                               '     b,',
+                               '     c',
+                               ' )'])
+          expect(cop.offenses).to be_empty
+        end
+
+        it 'autocorrects even when first argument is in wrong position' do
+          original_source = [' assigned_value = match(',
+                             '         a,',
+                             '            b,',
+                             '                    c',
+                             ' )']
+
+          correct_source = [' assigned_value = match(',
+                            '     a,',
+                            '     b,',
+                            '     c',
+                            ' )']
+
+          expect(autocorrect_source(cop, original_source))
+            .to eq(correct_source.join("\n"))
+        end
       end
     end
   end