sabat-rubocop 0.9.0

data/spec/rubocop/cops/style/symbol_array_spec.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SymbolArray do
+        let(:sa) { SymbolArray.new }
+
+        it 'registers an offence for arrays of symbols', { ruby: 2.0 } do
+          inspect_source(sa,
+                         ['[:one, :two, :three]'])
+          expect(sa.offences.size).to eq(1)
+        end
+
+        it 'does not reg an offence for array with non-syms', { ruby: 2.0 } do
+          inspect_source(sa,
+                         ['[:one, :two, "three"]'])
+          expect(sa.offences).to be_empty
+        end
+
+        it 'does not reg an offence for array starting with %i',
+           { ruby: 2.0 } do
+          inspect_source(sa,
+                         ['%i(one two three)'])
+          expect(sa.offences).to be_empty
+        end
+
+        it 'does not reg an offence for array with one element',
+           { ruby: 2.0 } do
+          inspect_source(sa,
+                         ['[:three]'])
+          expect(sa.offences).to be_empty
+        end
+
+        it 'does nothing on Ruby 1.9', { ruby: 1.9 } do
+          inspect_source(sa,
+                         ['[:one, :two, :three]'])
+          expect(sa.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/symbol_name_spec.rb

@@ -0,0 +1,122 @@
+  # encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe SymbolName do
+        let(:symbol_name) { SymbolName.new }
+
+        before do
+          SymbolName.config =
+            Config.default_configuration.for_cop('SymbolName')
+        end
+
+        context 'when AllowCamelCase is true' do
+          before do
+            SymbolName.config = {
+              'AllowCamelCase' => true
+            }
+          end
+
+          it 'does not register an offence for camel case in names' do
+            inspect_source(symbol_name,
+                           ['test = :BadIdea'])
+            expect(symbol_name.offences).to be_empty
+          end
+        end
+
+        context 'when AllowCamelCase is false' do
+          before do
+            SymbolName.config = {
+              'AllowCamelCase' => false
+            }
+          end
+
+          it 'registers an offence for camel case in names' do
+            inspect_source(symbol_name,
+                           ['test = :BadIdea'])
+            expect(symbol_name.offences.map(&:message)).to eq(
+              ['Use snake_case for symbols.'])
+          end
+        end
+
+        it 'registers an offence for symbol used as hash label' do
+          inspect_source(symbol_name,
+                         ['{ KEY_ONE: 1, KEY_TWO: 2 }'])
+          expect(symbol_name.offences.map(&:message)).to eq(
+            ['Use snake_case for symbols.'] * 2)
+        end
+
+        it 'accepts snake case in names' do
+          inspect_source(symbol_name,
+                         ['test = :good_idea'])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'accepts snake case in hash label names' do
+          inspect_source(symbol_name,
+                         ['{ one: 1, one_more_3: 2 }'])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'accepts snake case with a prefix @ in names' do
+          inspect_source(symbol_name,
+                         ['test = :@good_idea'])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'accepts snake case with ? suffix' do
+          inspect_source(symbol_name,
+                         ['test = :good_idea?'])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'accepts snake case with ! suffix' do
+          inspect_source(symbol_name,
+                         ['test = :good_idea!'])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'accepts snake case with = suffix' do
+          inspect_source(symbol_name,
+                         ['test = :good_idea='])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'accepts special cases - !, [] and **' do
+          inspect_source(symbol_name,
+                         ['test = :**',
+                          'test = :!',
+                          'test = :[]',
+                          'test = :[]='])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'accepts special cases - ==, <=>, >, <, >=, <=' do
+          inspect_source(symbol_name,
+                         ['test = :==',
+                          'test = :<=>',
+                          'test = :>',
+                          'test = :<',
+                          'test = :>=',
+                          'test = :<='])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'can handle an alias of and operator without crashing' do
+          inspect_source(symbol_name,
+                         ['alias + add'])
+          expect(symbol_name.offences).to be_empty
+        end
+
+        it 'registers an offence for SCREAMING_symbol_name' do
+          inspect_source(symbol_name,
+                         ['test = :BAD_IDEA'])
+          expect(symbol_name.offences.size).to eq(1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe Tab do
+        let(:tab) { Tab.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 'accepts a line with tab in a string' do
+          inspect_source(tab, ["(x = \"\t\")"])
+          expect(tab.offences).to be_empty
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe MultilineTernaryOperator do
+        let(:op) { MultilineTernaryOperator.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 'accepts a single line ternary operator expression' do
+          inspect_source(op, ['a = cond ? b : c'])
+          expect(op.offences).to be_empty
+        end
+      end
+
+      describe NestedTernaryOperator do
+        let(:op) { NestedTernaryOperator.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 '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
+  end
+end

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

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

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

@@ -0,0 +1,338 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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).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).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).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).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).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).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_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).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).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).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).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).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
+
+        it 'accepts an initialize method looking like a writer' do
+          inspect_source(trivial_accessors_finder,
+                         [' def initialize(value)',
+                          '   @top = value',
+                          ' end'])
+          expect(trivial_accessors_finder.offences).to be_empty
+        end
+      end
+    end
+  end
+end