rubocop 0.6.1 → 0.7.0

data/spec/rubocop/cops/space_after_control_keyword_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SpaceAfterControlKeyword do
+      let(:ap) { SpaceAfterControlKeyword.new }
+
+      it 'registers an offence for normal if' do
+        inspect_source(ap, 'file.rb',
+                       ['if(test) then result end'])
+        expect(ap.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for modifier unless' do
+        inspect_source(ap, 'file.rb', ['action unless(test)'])
+
+        expect(ap.offences.size).to eq(1)
+      end
+
+      it 'does not get confused by keywords' do
+        inspect_source(ap, 'file.rb', ['[:if, :unless].action'])
+        expect(ap.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/space_around_equals_in_default_parameter_spec.rb

@@ -13,8 +13,18 @@ module Rubocop
           ['Surrounding space missing in default value assignment.'] * 2)
       end
 
+      it 'registers an offence for assignment of empty string without space' do
+        inspect_source(space, 'file.rb', ['def f(x, y="", z=1)', 'end'])
+        expect(space.offences.size).to eq(2)
+      end
+
+      it 'registers an offence for assignment of empty list without space' do
+        inspect_source(space, 'file.rb', ['def f(x, y=[])', 'end'])
+        expect(space.offences.size).to eq(1)
+      end
+
       it 'accepts default value assignment with space' do
-        inspect_source(space, 'file.rb', ['def f(x, y = 0, z = 1)', 'end'])
+        inspect_source(space, 'file.rb', ['def f(x, y = 0, z = {})', 'end'])
         expect(space.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/space_inside_hash_literal_braces_spec.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SpaceInsideHashLiteralBraces do
+      let(:sihlb) { SpaceInsideHashLiteralBraces.new }
+      before do
+        SpaceInsideHashLiteralBraces.config = {
+          'EnforcedStyleIsWithSpaces' => true
+        }
+      end
+
+      it 'registers an offence for hashes with no spaces by default' do
+        inspect_source(sihlb, '',
+                       ['h = {a: 1, b: 2}',
+                        'h = {a => 1 }'])
+        expect(sihlb.offences.map(&:message)).to eq(
+          ['Space inside hash literal braces missing.'] * 3)
+      end
+
+      it 'registers an offence for hashes with no spaces if so configured' do
+        inspect_source(sihlb, '',
+                       ['h = {a: 1, b: 2}',
+                        'h = {a => 1 }'])
+        expect(sihlb.offences.map(&:message)).to eq(
+          ['Space inside hash literal braces missing.'] * 3)
+      end
+
+      it 'registers an offence for hashes with spaces if so configured' do
+        SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+          false
+        inspect_source(sihlb, '',
+                       ['h = { a: 1, b: 2 }'])
+        expect(sihlb.offences.map(&:message)).to eq(
+          ['Space inside hash literal braces detected.'] * 2)
+      end
+
+      it 'accepts hashes with spaces by default' do
+        inspect_source(sihlb, '',
+                       ['h = { a: 1, b: 2 }',
+                        'h = { a => 1 }'])
+        expect(sihlb.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts hashes with no spaces if so configured' do
+        SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+          false
+        inspect_source(sihlb, '',
+                       ['h = {a: 1, b: 2}',
+                        'h = {a => 1}'])
+        expect(sihlb.offences.map(&:message)).to be_empty
+      end
+
+      it 'accepts empty hashes without spaces by default' do
+        inspect_source(sihlb, '', ['h = {}'])
+        expect(sihlb.offences).to be_empty
+      end
+
+      it 'accepts empty hashes without spaces if configured false' do
+        SpaceInsideHashLiteralBraces.config['EnforcedStyleIsWithSpaces'] =
+          false
+        inspect_source(sihlb, '', ['h = {}'])
+        expect(sihlb.offences).to be_empty
+      end
+
+      it 'accepts empty hashes without spaces even if configured true' do
+        inspect_source(sihlb, '', ['h = {}'])
+        expect(sihlb.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/symbol_array_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe SymbolArray do
+      let(:sa) { SymbolArray.new }
+
+      it 'registers an offence for arrays of symbols', { ruby: 2.0 } do
+        inspect_source(sa,
+                       'file.rb',
+                       ['[:one, :two, :three]'])
+        expect(sa.offences.size).to eq(1)
+      end
+
+      it 'does nothing on Ruby 1.9', { ruby: 1.9 } do
+        inspect_source(sa,
+                       'file.rb',
+                       ['[:one, :two, :three]'])
+        expect(sa.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/trivial_accessors_spec.rb

@@ -0,0 +1,332 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe TrivialAccessors do
+      let(:trivial_accessors_finder) { TrivialAccessors.new }
+
+      before :each do
+        trivial_accessors_finder.offences.clear
+      end
+
+      it 'finds trivial reader' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['def foo',
+                        '  @foo',
+                        'end',
+                        '',
+                        'def Foo',
+                        '  @Foo',
+                        'end'])
+        expect(trivial_accessors_finder.offences.size).to eq(2)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([1, 5])
+      end
+
+      it 'finds trivial reader in a class' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['class TrivialFoo',
+                        '  def foo',
+                        '    @foo',
+                        '  end',
+                        '  def bar',
+                        '    !foo',
+                        '  end',
+                        'end'])
+        expect(trivial_accessors_finder.offences.size).to eq(1)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([2])
+      end
+
+      it 'finds trivial reader in a nested class' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['class TrivialFoo',
+                        '  class Nested',
+                        '    def foo',
+                        '      @foo',
+                        '    end',
+                        '  end',
+                        'end'])
+        expect(trivial_accessors_finder.offences.size).to eq(1)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([3])
+      end
+
+      it 'finds trivial readers in a little less trivial class' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['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(trivial_accessors_finder.offences.size).to eq(2)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([2, 8])
+      end
+
+      it 'finds trivial reader with braces' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['class Test',
+                        '  # trivial reader with braces',
+                        '  def name()',
+                        '    @name',
+                        '  end',
+                        'end'])
+        expect(trivial_accessors_finder.offences.size).to eq(1)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([3])
+      end
+
+      it 'finds trivial writer without braces' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['class Test',
+                        '  # trivial writer without braces',
+                        '  def name= name',
+                        '    @name = name',
+                        '  end',
+                        'end'])
+        expect(trivial_accessors_finder.offences.size).to eq(1)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([3])
+      end
+
+      it 'does not find trivial writer with function calls' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['class TrivialTest',
+                        ' def test=(val)',
+                        '   @test = val',
+                        '   some_function_call',
+                        '   or_more_of_them',
+                        ' end',
+                        'end'])
+        expect(trivial_accessors_finder.offences).to be_empty
+      end
+
+      it 'finds trivials with less peculiar methods' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['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= value',
+                        '  @value = 0.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(trivial_accessors_finder.offences).to be_empty
+      end
+
+      it 'finds oneliner trivials' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['class Oneliner',
+                        '  def foo; @foo; end',
+                        '  def foo= foo; @foo = foo; end',
+                        'end'])
+        expect(trivial_accessors_finder.offences.size).to eq(2)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([2, 3])
+      end
+
+      it 'does not find a trivial reader' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['def bar',
+                        '  @bar + foo',
+                        'end'])
+        expect(trivial_accessors_finder.offences).to be_empty
+      end
+
+      it 'finds trivial writer' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['def foo=(val)',
+                        ' @foo = val',
+                        'end'])
+        expect(trivial_accessors_finder.offences.size).to eq(1)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([1])
+      end
+
+      it 'finds trivial writer in a class' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['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(trivial_accessors_finder.offences.size).to eq(1)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([2])
+      end
+
+      it 'finds trivial accessors in a little less trivial class' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['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(trivial_accessors_finder.offences.size).to eq(3)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([2, 8, 11])
+      end
+
+      it 'does not find a trivial writer' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['def bar=(value)',
+                        ' @bar = value + 42',
+                        'end'])
+        expect(trivial_accessors_finder.offences).to be_empty
+      end
+
+      it 'finds trivial writers in a little less trivial class' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['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(trivial_accessors_finder.offences.size).to eq(2)
+        expect(trivial_accessors_finder.offences
+                 .map(&:line_number).sort).to eq([5, 8])
+      end
+
+      it 'does not find trivial accessors with method calls' do
+        inspect_source(trivial_accessors_finder, '',
+                       ['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(trivial_accessors_finder.offences).to be_empty
+      end
+
+      it 'does not find trivial writer with exceptions' do
+        inspect_source(trivial_accessors_finder, '',
+                       [' def expiration_formatted=(value)',
+                        '   begin',
+                        '     @expiration = foo_stuff',
+                        '   rescue ArgumentError',
+                        '     @expiration = nil',
+                        '   end',
+                        '   self[:expiration] = @expiration',
+                        ' end'])
+        expect(trivial_accessors_finder.offences).to be_empty
+      end
+
+    end # describe TrivialAccessors
+  end # Cop
+end # Rubocop