rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/string_literals_spec.rb

@@ -1,58 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe StringLiterals do
-      let(:sl) { StringLiterals.new }
-
-      it 'registers an offence for double quotes when single quotes suffice' do
-        inspect_source(sl, ['s = "abc"'])
-        expect(sl.offences.size).to eq(1)
-      end
-
-      it 'accepts double quotes when they are needed' do
-        src = ['a = "\n"',
-               'b = "#{encode_severity}:#{sprintf("%3d", line_number)}: #{m}"',
-               'c = "\'"',
-               'd = "#@test"',
-               'e = "#$test"',
-               'f = "#@@test"']
-        inspect_source(sl, src)
-        expect(sl.offences).to be_empty
-      end
-
-      it 'accepts double quotes at the start of regexp literals' do
-        inspect_source(sl, ['s = /"((?:[^\\"]|\\.)*)"/'])
-        expect(sl.offences).to be_empty
-      end
-
-      it 'accepts double quotes with some other special symbols' do
-        pending
-        # "Substitutions in double-quoted strings"
-        # http://www.ruby-doc.org/docs/ProgrammingRuby/html/language.html
-        src = ['g = "\xf9"']
-        inspect_source(sl, src)
-        expect(sl.offences).to be_empty
-      end
-
-      it 'can handle double quotes within embedded expression' do
-        # This seems to be a Parser bug
-        pending do
-          src = ['"#{"A"}"']
-          inspect_source(sl, src)
-          expect(sl.offences).to be_empty
-        end
-      end
-
-      it 'can handle a built-in constant parsed as string' do
-        # Parser will produce str nodes for constants such as __FILE__.
-        src = ['if __FILE__ == $PROGRAM_NAME',
-               'end']
-        inspect_source(sl, src)
-        expect(sl.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/symbol_array_spec.rb

@@ -1,41 +0,0 @@
-# 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,
-                       ['[: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

data/spec/rubocop/cops/symbol_name_spec.rb

@@ -1,119 +0,0 @@
-  # encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    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

data/spec/rubocop/cops/syntax_spec.rb

@@ -1,41 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Syntax do
-      let(:sc) { Syntax.new }
-
-      if RUBY_ENGINE == 'ruby'
-        it 'registers an offence for unused variables', ruby: 2.0 do
-          source = "x = 5\nputs 10"
-          Dir.mktmpdir do |tmpdir|
-            path = File.join(tmpdir, 'file.rb')
-            File.open(path, 'w') { |f| f.write(source) }
-            sc.inspect_file(path)
-          end
-          expect(sc.offences.size).to eq(1)
-          expect(sc.offences.first.message)
-            .to eq('Assigned but unused variable - x')
-        end
-
-        describe '#process_line' do
-          it 'processes warnings correctly' do
-            l, s, m = sc.process_line('admin.rb:1: warning: possibly useless')
-            expect(l).to eq(1)
-            expect(s).to eq(:warning)
-            expect(m).to eq('Possibly useless')
-          end
-
-          it 'processes errors correctly' do
-            l, s, m = sc.process_line('admin.rb:1: unterminated string meets')
-            expect(l).to eq(1)
-            expect(s).to eq(:error)
-            expect(m).to eq('Unterminated string meets')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rubocop/cops/tab_spec.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Tab do
-      let(:tab) { Tab.new }
-
-      it 'registers an offence for a line indented with tab' do
-        tab.inspect(["\tx = 0"], nil, nil, nil)
-        expect(tab.offences.size).to eq(1)
-      end
-
-      it 'accepts a line with tab in a string' do
-        tab.inspect(["(x = \"\t\")"], nil, nil, nil)
-        expect(tab.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/ternary_operator_spec.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe MultilineTernaryOperator do
-      let(:op) { MultilineTernaryOperator.new }
-
-      it 'registers an 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

data/spec/rubocop/cops/trailing_whitespace_spec.rb

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

data/spec/rubocop/cops/trivial_accessors_spec.rb

@@ -1,337 +0,0 @@
-# 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_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
-
-      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