rubocop 0.4.0 → 0.8.0

data/spec/rubocop/cops/ternary_operator_spec.rb

@@ -8,16 +8,14 @@ module Rubocop
       let(:op) { MultilineTernaryOperator.new }
 
       it 'registers an offence for a multiline ternary operator expression' do
-        inspect_source(op, 'file.rb', ['a = cond ?',
-                                        '  b : c'])
-        expect(op.offences.map(&:message)).to eq(
-          ['Avoid multi-line ?: (the ternary operator); use if/unless ' +
-           'instead.'])
+        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, 'file.rb', ['a = cond ? b : c'])
-        expect(op.offences.map(&:message)).to be_empty
+        inspect_source(op, ['a = cond ? b : c'])
+        expect(op.offences).to be_empty
       end
     end
 
@@ -25,19 +23,17 @@ module Rubocop
       let(:op) { NestedTernaryOperator.new }
 
       it 'registers an offence for a nested ternary operator expression' do
-        inspect_source(op, 'file.rb', ['a ? (b ? b1 : b2) : a2'])
-        expect(op.offences.map(&:message)).to eq(
-          ['Ternary operators must not be nested. Prefer if/else constructs ' +
-           'instead.'])
+        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, 'file.rb', ['a = if x',
-                                       '  cond ? b : c',
-                                       'else',
-                                       '  d',
-                                       'end'])
-        expect(op.offences.map(&:message)).to be_empty
+        inspect_source(op, ['a = if x',
+                            '  cond ? b : c',
+                            'else',
+                            '  d',
+                            'end'])
+        expect(op.offences).to be_empty
       end
     end
   end

data/spec/rubocop/cops/trailing_whitespace_spec.rb

@@ -9,17 +9,17 @@ module Rubocop
 
       it 'registers an offence for a line ending with space' do
         source = ['x = 0 ']
-        tws.inspect('file.rb', source, nil, nil)
+        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('file.rb', ["x = 0\t"], nil, nil)
+        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('file.rb', ["x = 0\n"], nil, nil)
+        tws.inspect(["x = 0\n"], nil, nil, nil)
         expect(tws.offences).to be_empty
       end
     end

data/spec/rubocop/cops/trivial_accessors_spec.rb

@@ -0,0 +1,329 @@
+# 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
+
+    end # describe TrivialAccessors
+  end # Cop
+end # Rubocop

data/spec/rubocop/cops/unless_else_spec.rb

@@ -8,20 +8,20 @@ module Rubocop
       let(:ue) { UnlessElse.new }
 
       it 'registers an offence for an unless with else' do
-        inspect_source(ue, 'file.rb', ['unless x',
-                                       '  a = 1',
-                                       'else',
-                                       '  a = 0',
-                                       'end'])
+        inspect_source(ue, ['unless x',
+                            '  a = 1',
+                            'else',
+                            '  a = 0',
+                            'end'])
         expect(ue.offences.map(&:message)).to eq(
           ['Never use unless with else. Rewrite these with the ' +
            'positive case first.'])
       end
 
       it 'accepts an unless without else' do
-        inspect_source(ue, 'file.rb', ['unless x',
-                                       '  a = 1',
-                                       'end'])
+        inspect_source(ue, ['unless x',
+                            '  a = 1',
+                            'end'])
         expect(ue.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/variable_interpolation_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe VariableInterpolation do
+      let(:vi) { VariableInterpolation.new }
+
+      it 'registers an offence for interpolated global variables' do
+        inspect_source(vi,
+                       ['puts "this is a #$test"'])
+        expect(vi.offences.size).to eq(1)
+        expect(vi.offences.map(&:message))
+          .to eq(['Replace interpolated var $test with expression #{$test}.'])
+      end
+
+      it 'registers an offence for interpolated regexp back references' do
+        inspect_source(vi,
+                       ['puts "this is a #$1"'])
+        expect(vi.offences.size).to eq(1)
+        expect(vi.offences.map(&:message))
+          .to eq(['Replace interpolated var $1 with expression #{$1}.'])
+      end
+
+      it 'registers an offence for interpolated instance variables' do
+        inspect_source(vi,
+                       ['puts "this is a #@test"'])
+        expect(vi.offences.size).to eq(1)
+        expect(vi.offences.map(&:message))
+          .to eq(['Replace interpolated var @test with expression #{@test}.'])
+      end
+
+      it 'registers an offence for interpolated class variables' do
+        inspect_source(vi,
+                       ['puts "this is a #@@t"'])
+        expect(vi.offences.size).to eq(1)
+        expect(vi.offences.map(&:message))
+          .to eq(['Replace interpolated var @@t with expression #{@@t}.'])
+      end
+
+      it 'does not register an offence for variables in expressions' do
+        inspect_source(vi,
+                       ['puts "this is a #{@test} #{@@t} #{$t} #{$1}"'])
+        expect(vi.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/rubocop/cops/when_then_spec.rb

@@ -8,29 +8,29 @@ module Rubocop
       let(:wt) { WhenThen.new }
 
       it 'registers an offence for when x;' do
-        inspect_source(wt, 'file.rb', ['case a',
-                                       'when b; c',
-                                       'end'])
+        inspect_source(wt, ['case a',
+                            'when b; c',
+                            'end'])
         expect(wt.offences.map(&:message)).to eq(
           ['Never use "when x;". Use "when x then" instead.'])
       end
 
       it 'accepts when x then' do
-        inspect_source(wt, 'file.rb', ['case a',
-                                       'when b then c',
-                                       'end'])
+        inspect_source(wt, ['case a',
+                            'when b then c',
+                            'end'])
         expect(wt.offences.map(&:message)).to be_empty
       end
 
       it 'accepts ; separating statements in the body of when' do
-        inspect_source(wt, 'file.rb', ['case a',
-                                       'when b then c; d',
-                                       'end',
-                                       '',
-                                       'case e',
-                                       'when f',
-                                       '  g; h',
-                                       'end'])
+        inspect_source(wt, ['case a',
+                            'when b then c; d',
+                            'end',
+                            '',
+                            'case e',
+                            'when f',
+                            '  g; h',
+                            'end'])
         expect(wt.offences.map(&:message)).to be_empty
       end
     end

data/spec/rubocop/cops/word_array_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe WordArray do
+      let(:wa) { WordArray.new }
+
+      it 'registers an offence for arrays of single quoted strings' do
+        inspect_source(wa,
+                       ["['one', 'two', 'three']"])
+        expect(wa.offences.size).to eq(1)
+      end
+
+      it 'registers an offence for arrays of double quoted strings' do
+        inspect_source(wa,
+                       ['["one", "two", "three"]'])
+        expect(wa.offences.size).to eq(1)
+      end
+
+      it 'does not register an offence for array of non-words' do
+        inspect_source(wa,
+                       ['["one space", "two", "three"]'])
+        expect(wa.offences).to be_empty
+      end
+
+      it 'does not register an offence for array starting with %w' do
+        inspect_source(wa,
+                       ['%w(one two three)'])
+        expect(wa.offences).to be_empty
+      end
+
+      it 'does not register an offence for array with one element' do
+        inspect_source(wa,
+                       ['["three"]'])
+        expect(wa.offences).to be_empty
+      end
+
+      it 'does not register an offence for array with empty strings' do
+        inspect_source(wa,
+                       ['["", "two", "three"]'])
+        expect(wa.offences).to be_empty
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,17 @@
 # encoding: utf-8
 
-if ENV['COVERAGE']
+if ENV['TRAVIS'] || ENV['COVERAGE']
   require 'simplecov'
-  SimpleCov.start
+
+  if ENV['TRAVIS']
+    require 'coveralls'
+    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  end
+
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/vendor/bundle/'
+  end
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
@@ -11,9 +20,8 @@ require 'rspec'
 require 'rubocop'
 require 'rubocop/cli'
 
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+# disable colors in specs
+Sickill::Rainbow.enabled = false
 
 module ExitCodeMatchers
   RSpec::Matchers.define :exit_with_code do |code|
@@ -41,6 +49,8 @@ end
 
 RSpec.configure do |config|
   config.filter_run_excluding ruby: ->(v) { !RUBY_VERSION.start_with?(v.to_s) }
+  config.filter_run_excluding broken: true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
 
   config.expect_with :rspec do |c|
     c.syntax = :expect # disables `should`
@@ -49,8 +59,19 @@ RSpec.configure do |config|
   config.include(ExitCodeMatchers)
 end
 
-def inspect_source(cop, file, source)
-  tokens, sexp, correlations = Rubocop::CLI.rip_source(source)
-  cop.correlations = correlations
-  cop.inspect(file, source, tokens, sexp)
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+def inspect_source(cop, source)
+  ast, comments, tokens, _ = Rubocop::CLI.parse('(string)') do |source_buffer|
+    source_buffer.source = source.join($RS)
+  end
+  cop.inspect(source, tokens, ast, comments)
+end
+
+class Rubocop::Cop::Cop
+  def messages
+    offences.map(&:message)
+  end
 end

data/spec/support/file_helper.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+
+require 'fileutils'
+
+module FileHelper
+  def create_file(file_path, content)
+    file_path = File.expand_path(file_path)
+
+    dir_path = File.dirname(file_path)
+    FileUtils.makedirs dir_path unless File.exists?(dir_path)
+
+    File.open(file_path, 'w') do |file|
+      case content
+      when String
+        file.puts content
+      when Array
+        file.puts content.join("\n")
+      end
+    end
+  end
+end