rubocop 0.13.1 → 0.14.0

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

@@ -2,22 +2,16 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe Tab do
-        subject(:tab) { Tab.new }
+describe Rubocop::Cop::Style::Tab do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for a line indented with tab' do
-          inspect_source(tab, ["\tx = 0"])
-          expect(tab.offences.size).to eq(1)
-        end
+  it 'registers an offence for a line indented with tab' do
+    inspect_source(cop, ["\tx = 0"])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts a line with tab in a string' do
-          inspect_source(tab, ["(x = \"\t\")"])
-          expect(tab.offences).to be_empty
-        end
-      end
-    end
+  it 'accepts a line with tab in a string' do
+    inspect_source(cop, ["(x = \"\t\")"])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,41 +2,35 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe MultilineTernaryOperator do
-        subject(:op) { MultilineTernaryOperator.new }
+describe Rubocop::Cop::Style::MultilineTernaryOperator do
+  subject(:cop) { described_class.new }
 
-        it 'registers offence for a multiline ternary operator expression' do
-          inspect_source(op, ['a = cond ?',
-                              '  b : c'])
-          expect(op.offences.size).to eq(1)
-        end
+  it 'registers offence for a multiline ternary operator expression' do
+    inspect_source(cop, ['a = cond ?',
+                         '  b : c'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts a single line ternary operator expression' do
-          inspect_source(op, ['a = cond ? b : c'])
-          expect(op.offences).to be_empty
-        end
-      end
+  it 'accepts a single line ternary operator expression' do
+    inspect_source(cop, ['a = cond ? b : c'])
+    expect(cop.offences).to be_empty
+  end
+end
 
-      describe NestedTernaryOperator do
-        subject(:op) { NestedTernaryOperator.new }
+describe Rubocop::Cop::Style::NestedTernaryOperator do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for a nested ternary operator expression' do
-          inspect_source(op, ['a ? (b ? b1 : b2) : a2'])
-          expect(op.offences.size).to eq(1)
-        end
+  it 'registers an offence for a nested ternary operator expression' do
+    inspect_source(cop, ['a ? (b ? b1 : b2) : a2'])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts a non-nested ternary operator within an if' do
-          inspect_source(op, ['a = if x',
-                              '  cond ? b : c',
-                              'else',
-                              '  d',
-                              'end'])
-          expect(op.offences).to be_empty
-        end
-      end
-    end
+  it 'accepts a non-nested ternary operator within an if' do
+    inspect_source(cop, ['a = if x',
+                         '  cond ? b : c',
+                         'else',
+                         '  d',
+                         'end'])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,23 +2,17 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe TrailingBlankLines do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::TrailingBlankLines do
+  subject(:cop) { described_class.new }
 
-        it 'accepts final newline' do
-          inspect_source(cop, ['x = 0', ''])
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts final newline' do
+    inspect_source(cop, ['x = 0', ''])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'registers an offence for multiple trailing blank lines' do
-          inspect_source(cop, ['x = 0', '', '', '', ''])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.messages).to eq(['3 trailing blank lines detected.'])
-        end
-      end
-    end
+  it 'registers an offence for multiple trailing blank lines' do
+    inspect_source(cop, ['x = 0', '', '', '', ''])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.messages).to eq(['3 trailing blank lines detected.'])
   end
 end

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

@@ -2,28 +2,22 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe TrailingWhitespace do
-        subject(:cop) { described_class.new }
+describe Rubocop::Cop::Style::TrailingWhitespace do
+  subject(:cop) { described_class.new }
 
-        it 'registers an offence for a line ending with space' do
-          source = ['x = 0 ']
-          inspect_source(cop, source)
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'registers an offence for a line ending with space' do
+    source = ['x = 0 ']
+    inspect_source(cop, source)
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'registers an offence for a line ending with tab' do
-          inspect_source(cop, ["x = 0\t"])
-          expect(cop.offences.size).to eq(1)
-        end
+  it 'registers an offence for a line ending with tab' do
+    inspect_source(cop, ["x = 0\t"])
+    expect(cop.offences.size).to eq(1)
+  end
 
-        it 'accepts a line without trailing whitespace' do
-          inspect_source(cop, ["x = 0\n"])
-          expect(cop.offences).to be_empty
-        end
-      end
-    end
+  it 'accepts a line without trailing whitespace' do
+    inspect_source(cop, ["x = 0\n"])
+    expect(cop.offences).to be_empty
   end
 end

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

@@ -2,412 +2,406 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module Style
-      describe TrivialAccessors, :config do
-        subject(:cop) { described_class.new(config) }
-        let(:cop_config) { {} }
+describe Rubocop::Cop::Style::TrivialAccessors, :config do
+  subject(:cop) { described_class.new(config) }
+  let(:cop_config) { {} }
 
-        it 'finds trivial reader' do
-          inspect_source(cop,
-                         ['def foo',
-                          '  @foo',
-                          'end',
-                          '',
-                          'def Foo',
-                          '  @Foo',
-                          'end'])
-          expect(cop.offences.size).to eq(2)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([1, 5])
-        end
+  it 'finds trivial reader' do
+    inspect_source(cop,
+                   ['def foo',
+                    '  @foo',
+                    'end',
+                    '',
+                    'def Foo',
+                    '  @Foo',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([1, 5])
+  end
 
-        it 'finds trivial reader in a class' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          '  def foo',
-                          '    @foo',
-                          '  end',
-                          '  def bar',
-                          '    !foo',
-                          '  end',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([2])
-        end
+  it 'finds trivial reader in a class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def foo',
+                    '    @foo',
+                    '  end',
+                    '  def bar',
+                    '    !foo',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2])
+  end
 
-        it 'finds trivial reader in a class method' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          '  def self.foo',
-                          '    @foo',
-                          '  end',
-                          '  def bar',
-                          '    !foo',
-                          '  end',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([2])
-        end
+  it 'finds trivial reader in a class method' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def self.foo',
+                    '    @foo',
+                    '  end',
+                    '  def bar',
+                    '    !foo',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2])
+  end
 
-        it 'finds trivial reader in a nested class' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          '  class Nested',
-                          '    def foo',
-                          '      @foo',
-                          '    end',
-                          '  end',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([3])
-        end
+  it 'finds trivial reader in a nested class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  class Nested',
+                    '    def foo',
+                    '      @foo',
+                    '    end',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([3])
+  end
 
-        it 'finds trivial readers in a little less trivial class' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          '  def foo',
-                          '    @foo',
-                          '  end',
-                          '  def foo_and_bar',
-                          '    @foo_bar = @foo + @bar',
-                          '  end',
-                          '  def foo_bar',
-                          '    @foo_bar',
-                          '  end',
-                          '  def foo?',
-                          '    foo.present?',
-                          '  end',
-                          '  def bar?',
-                          '    !bar',
-                          '  end',
-                          '  def foobar',
-                          '    foo? ? foo.value : "bar"',
-                          '  end',
-                          '  def bar',
-                          '    foo.bar',
-                          '  end',
-                          '  def foo_required?',
-                          '    super && !bar_required?',
-                          '  end',
-                          '  def self.from_omniauth(auth)',
-                          '    foobars.each do |f|',
-                          '      # do stuff',
-                          '    end',
-                          '  end',
-                          '  def regex',
-                          '    %r{\A#{visit node}\Z}',
-                          '  end',
-                          '  def array',
-                          '    [foo, bar].join',
-                          '  end',
-                          '  def string',
-                          '    "string"',
-                          '  end',
-                          '  def class',
-                          '    Foo.class',
-                          '  end',
-                          ' def with_return',
-                          '   return foo',
-                          ' end',
-                          ' def captures',
-                          '   (length - 1).times.map { |i| self[i + 1] }',
-                          ' end',
-                          ' def foo val',
-                          '   super',
-                          '   @val',
-                          ' end',
-                          'end'])
-          expect(cop.offences.size).to eq(2)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([2, 8])
-        end
+  it 'finds trivial readers in a little less trivial class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def foo',
+                    '    @foo',
+                    '  end',
+                    '  def foo_and_bar',
+                    '    @foo_bar = @foo + @bar',
+                    '  end',
+                    '  def foo_bar',
+                    '    @foo_bar',
+                    '  end',
+                    '  def foo?',
+                    '    foo.present?',
+                    '  end',
+                    '  def bar?',
+                    '    !bar',
+                    '  end',
+                    '  def foobar',
+                    '    foo? ? foo.value : "bar"',
+                    '  end',
+                    '  def bar',
+                    '    foo.bar',
+                    '  end',
+                    '  def foo_required?',
+                    '    super && !bar_required?',
+                    '  end',
+                    '  def self.from_omniauth(auth)',
+                    '    foobars.each do |f|',
+                    '      # do stuff',
+                    '    end',
+                    '  end',
+                    '  def regex',
+                    '    %r{\A#{visit node}\Z}',
+                    '  end',
+                    '  def array',
+                    '    [foo, bar].join',
+                    '  end',
+                    '  def string',
+                    '    "string"',
+                    '  end',
+                    '  def class',
+                    '    Foo.class',
+                    '  end',
+                    ' def with_return',
+                    '   return foo',
+                    ' end',
+                    ' def captures',
+                    '   (length - 1).times.map { |i| self[i + 1] }',
+                    ' end',
+                    ' def foo val',
+                    '   super',
+                    '   @val',
+                    ' end',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2, 8])
+  end
 
-        it 'finds trivial reader with braces' do
-          inspect_source(cop,
-                         ['class Test',
-                          '  # trivial reader with braces',
-                          '  def name()',
-                          '    @name',
-                          '  end',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([3])
-        end
+  it 'finds trivial reader with braces' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  # trivial reader with braces',
+                    '  def name()',
+                    '    @name',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([3])
+  end
 
-        it 'finds trivial writer without braces' do
-          inspect_source(cop,
-                         ['class Test',
-                          '  # trivial writer without braces',
-                          '  def name= name',
-                          '    @name = name',
-                          '  end',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([3])
-        end
+  it 'finds trivial writer without braces' do
+    inspect_source(cop,
+                   ['class Test',
+                    '  # trivial writer without braces',
+                    '  def name= name',
+                    '    @name = name',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([3])
+  end
 
-        it 'does not find trivial writer with function calls' do
-          inspect_source(cop,
-                         ['class TrivialTest',
-                          ' def test=(val)',
-                          '   @test = val',
-                          '   some_function_call',
-                          '   or_more_of_them',
-                          ' end',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'does not find trivial writer with function calls' do
+    inspect_source(cop,
+                   ['class TrivialTest',
+                    ' def test=(val)',
+                    '   @test = val',
+                    '   some_function_call',
+                    '   or_more_of_them',
+                    ' end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'finds trivials with less peculiar methods' do
-          inspect_source(cop,
-                         ['class NilStats',
-                          'def most_traded_pair',
-                          'end',
-                          'def win_ratio',
-                          'end',
-                          'def win_ratio_percentage()',
-                          'end',
-                          'def pips_won',
-                          '  0.0',
-                          'end',
-                          'def gain_at(date)',
-                          '  1',
-                          'end',
-                          'def gain_percentage',
-                          '  0',
-                          'end',
-                          'def gain_breakdown(options = {})',
-                          '  []',
-                          'end',
-                          'def copy_to_all_ratio',
-                          '  nil',
-                          'end',
-                          'def trade_population',
-                          '  {}',
-                          'end',
-                          'def average_leverage',
-                          '  1',
-                          'end',
-                          'def with_yield',
-                          '  yield',
-                          'rescue Error => e',
-                          '  #do stuff',
-                          'end',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'finds trivials with less peculiar methods' do
+    inspect_source(cop,
+                   ['class NilStats',
+                    'def most_traded_pair',
+                    'end',
+                    'def win_ratio',
+                    'end',
+                    'def win_ratio_percentage()',
+                    'end',
+                    'def pips_won',
+                    '  0.0',
+                    'end',
+                    'def gain_at(date)',
+                    '  1',
+                    'end',
+                    'def gain_percentage',
+                    '  0',
+                    'end',
+                    'def gain_breakdown(options = {})',
+                    '  []',
+                    'end',
+                    'def copy_to_all_ratio',
+                    '  nil',
+                    'end',
+                    'def trade_population',
+                    '  {}',
+                    'end',
+                    'def average_leverage',
+                    '  1',
+                    'end',
+                    'def with_yield',
+                    '  yield',
+                    'rescue Error => e',
+                    '  #do stuff',
+                    'end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'finds oneliner trivials' do
-          inspect_source(cop,
-                         ['class Oneliner',
-                          '  def foo; @foo; end',
-                          '  def foo= foo; @foo = foo; end',
-                          'end'])
-          expect(cop.offences.size).to eq(2)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([2, 3])
-        end
+  it 'finds oneliner trivials' do
+    inspect_source(cop,
+                   ['class Oneliner',
+                    '  def foo; @foo; end',
+                    '  def foo= foo; @foo = foo; end',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2, 3])
+  end
 
-        it 'does not find a trivial reader' do
-          inspect_source(cop,
-                         ['def bar',
-                          '  @bar + foo',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'does not find a trivial reader' do
+    inspect_source(cop,
+                   ['def bar',
+                    '  @bar + foo',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'finds trivial writer' do
-          inspect_source(cop,
-                         ['def foo=(val)',
-                          ' @foo = val',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([1])
-        end
+  it 'finds trivial writer' do
+    inspect_source(cop,
+                   ['def foo=(val)',
+                    ' @foo = val',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([1])
+  end
 
-        it 'finds trivial writer in a class' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          '  def foo=(val)',
-                          '    @foo = val',
-                          '  end',
-                          '  def void(no_value)',
-                          '  end',
-                          '  def inspect(sexp)',
-                          '    each(:def, sexp) do |item|',
-                          '      #do stuff',
-                          '    end',
-                          '  end',
-                          '  def if_method(foo)',
-                          '    if true',
-                          '      unless false',
-                          '        #do stuff',
-                          '      end',
-                          '    end',
-                          '  end',
-                          'end'])
-          expect(cop.offences.size).to eq(1)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([2])
-        end
+  it 'finds trivial writer in a class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    '  def foo=(val)',
+                    '    @foo = val',
+                    '  end',
+                    '  def void(no_value)',
+                    '  end',
+                    '  def inspect(sexp)',
+                    '    each(:def, sexp) do |item|',
+                    '      #do stuff',
+                    '    end',
+                    '  end',
+                    '  def if_method(foo)',
+                    '    if true',
+                    '      unless false',
+                    '        #do stuff',
+                    '      end',
+                    '    end',
+                    '  end',
+                    'end'])
+    expect(cop.offences.size).to eq(1)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2])
+  end
 
-        it 'finds trivial accessors in a little less trivial class' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          ' def foo',
-                          ' @foo',
-                          ' end',
-                          ' def foo_and_bar',
-                          ' @foo_bar = @foo + @bar',
-                          ' end',
-                          ' def foo_bar',
-                          ' @foo_bar',
-                          ' end',
-                          ' def bar=(bar_value)',
-                          ' @bar = bar_value',
-                          ' end',
-                          'end'])
-          expect(cop.offences.size).to eq(3)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([2, 8, 11])
-        end
+  it 'finds trivial accessors in a little less trivial class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    ' def foo',
+                    ' @foo',
+                    ' end',
+                    ' def foo_and_bar',
+                    ' @foo_bar = @foo + @bar',
+                    ' end',
+                    ' def foo_bar',
+                    ' @foo_bar',
+                    ' end',
+                    ' def bar=(bar_value)',
+                    ' @bar = bar_value',
+                    ' end',
+                    'end'])
+    expect(cop.offences.size).to eq(3)
+    expect(cop.offences
+             .map(&:line).sort).to eq([2, 8, 11])
+  end
 
-        it 'does not find a trivial writer' do
-          inspect_source(cop,
-                         ['def bar=(value)',
-                          ' @bar = value + 42',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'does not find a trivial writer' do
+    inspect_source(cop,
+                   ['def bar=(value)',
+                    ' @bar = value + 42',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'finds trivial writers in a little less trivial class' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          ' def foo_bar=(foo, bar)',
-                          ' @foo_bar = foo + bar',
-                          ' end',
-                          ' def universal=(answer=42)',
-                          ' @universal = answer',
-                          ' end',
-                          ' def bar=(bar_value)',
-                          ' @bar = bar_value',
-                          ' end',
-                          'end'])
-          expect(cop.offences.size).to eq(2)
-          expect(cop.offences
-                   .map(&:line).sort).to eq([5, 8])
-        end
+  it 'finds trivial writers in a little less trivial class' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    ' def foo_bar=(foo, bar)',
+                    ' @foo_bar = foo + bar',
+                    ' end',
+                    ' def universal=(answer=42)',
+                    ' @universal = answer',
+                    ' end',
+                    ' def bar=(bar_value)',
+                    ' @bar = bar_value',
+                    ' end',
+                    'end'])
+    expect(cop.offences.size).to eq(2)
+    expect(cop.offences
+             .map(&:line).sort).to eq([5, 8])
+  end
 
-        it 'does not find trivial accessors with method calls' do
-          inspect_source(cop,
-                         ['class TrivialFoo',
-                          ' def foo_bar(foo)',
-                          '   foo_bar = foo + 42',
-                          ' end',
-                          ' def foo(value)',
-                          '   foo = []',
-                          '   # do stuff',
-                          '   foo',
-                          ' end',
-                          ' def bar',
-                          '   foo_method',
-                          ' end',
-                          'end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'does not find trivial accessors with method calls' do
+    inspect_source(cop,
+                   ['class TrivialFoo',
+                    ' def foo_bar(foo)',
+                    '   foo_bar = foo + 42',
+                    ' end',
+                    ' def foo(value)',
+                    '   foo = []',
+                    '   # do stuff',
+                    '   foo',
+                    ' end',
+                    ' def bar',
+                    '   foo_method',
+                    ' end',
+                    'end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'does not find trivial writer with exceptions' do
-          inspect_source(cop,
-                         [' def expiration_formatted=(value)',
-                          '   begin',
-                          '     @expiration = foo_stuff',
-                          '   rescue ArgumentError',
-                          '     @expiration = nil',
-                          '   end',
-                          '   self[:expiration] = @expiration',
-                          ' end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'does not find trivial writer with exceptions' do
+    inspect_source(cop,
+                   [' def expiration_formatted=(value)',
+                    '   begin',
+                    '     @expiration = foo_stuff',
+                    '   rescue ArgumentError',
+                    '     @expiration = nil',
+                    '   end',
+                    '   self[:expiration] = @expiration',
+                    ' end'])
+    expect(cop.offences).to be_empty
+  end
 
-        it 'accepts an initialize method looking like a writer' do
-          inspect_source(cop,
-                         [' def initialize(value)',
-                          '   @top = value',
-                          ' end'])
-          expect(cop.offences).to be_empty
-        end
+  it 'accepts an initialize method looking like a writer' do
+    inspect_source(cop,
+                   [' def initialize(value)',
+                    '   @top = value',
+                    ' end'])
+    expect(cop.offences).to be_empty
+  end
 
-        context 'exact name match required' do
-          let(:cop_config) { { 'ExactNameMatch' => true } }
+  context 'exact name match required' do
+    let(:cop_config) { { 'ExactNameMatch' => true } }
 
-          it 'finds only 1 trivial reader' do
-            inspect_source(cop,
-                           ['def foo',
-                            '  @foo',
-                            'end',
-                            '',
-                            'def bar',
-                            '  @barr',
-                            'end'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.offences
-                     .map(&:line).sort).to eq([1])
-          end
+    it 'finds only 1 trivial reader' do
+      inspect_source(cop,
+                     ['def foo',
+                      '  @foo',
+                      'end',
+                      '',
+                      'def bar',
+                      '  @barr',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences
+               .map(&:line).sort).to eq([1])
+    end
 
-          it 'finds only 1 trivial writer' do
-            inspect_source(cop,
-                           ['def foo=(foo)',
-                            '  @foo = foo',
-                            'end',
-                            '',
-                            'def bar=(bar)',
-                            '  @barr = bar',
-                            'end'])
-            expect(cop.offences.size).to eq(1)
-            expect(cop.offences
-                     .map(&:line).sort).to eq([1])
-          end
-        end
+    it 'finds only 1 trivial writer' do
+      inspect_source(cop,
+                     ['def foo=(foo)',
+                      '  @foo = foo',
+                      'end',
+                      '',
+                      'def bar=(bar)',
+                      '  @barr = bar',
+                      'end'])
+      expect(cop.offences.size).to eq(1)
+      expect(cop.offences
+               .map(&:line).sort).to eq([1])
+    end
+  end
 
-        context 'with predicates allowed' do
-          let(:cop_config) { { 'AllowPredicates' => true } }
+  context 'with predicates allowed' do
+    let(:cop_config) { { 'AllowPredicates' => true } }
 
-          it 'ignores accessors ending with a question mark' do
-            inspect_source(cop,
-                           [' def foo?',
-                            '   @foo',
-                            ' end'])
-            expect(cop.offences).to be_empty
-          end
-        end
+    it 'ignores accessors ending with a question mark' do
+      inspect_source(cop,
+                     [' def foo?',
+                      '   @foo',
+                      ' end'])
+      expect(cop.offences).to be_empty
+    end
+  end
 
-        context 'with whitelist defined' do
-          let(:cop_config) { { 'Whitelist' => ['to_foo', 'bar='] } }
+  context 'with whitelist defined' do
+    let(:cop_config) { { 'Whitelist' => ['to_foo', 'bar='] } }
 
-          it 'ignores accessors in the whitelist' do
-            inspect_source(cop,
-                           [' def to_foo',
-                            '   @foo',
-                            ' end'])
-            expect(cop.offences).to be_empty
-          end
-          it 'ignores writers in the whitelist' do
-            inspect_source(cop,
-                           [' def bar=(bar)',
-                            '   @bar = bar',
-                            ' end'])
-            expect(cop.offences).to be_empty
-          end
-        end
-      end
+    it 'ignores accessors in the whitelist' do
+      inspect_source(cop,
+                     [' def to_foo',
+                      '   @foo',
+                      ' end'])
+      expect(cop.offences).to be_empty
+    end
+    it 'ignores writers in the whitelist' do
+      inspect_source(cop,
+                     [' def bar=(bar)',
+                      '   @bar = bar',
+                      ' end'])
+      expect(cop.offences).to be_empty
     end
   end
 end