rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/block_comments_spec.rb

@@ -1,25 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe BlockComments do
-      let(:block) { BlockComments.new }
-
-      it 'registers an offence for block comments' do
-        inspect_source(block,
-                       ['=begin',
-                        'comment',
-                        '=end'])
-        expect(block.offences.size).to eq(1)
-      end
-
-      it 'accepts regular comments' do
-        inspect_source(block,
-                       ['# comment'])
-        expect(block.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/block_nesting_spec.rb

@@ -1,148 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe BlockNesting do
-      let(:block_nesting) { BlockNesting.new }
-      before { BlockNesting.config = { 'Max' => 2 } }
-
-      it 'accepts `Max` levels of nesting' do
-        source = ['if a',
-                  '  if b',
-                  '    puts b',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [])
-      end
-
-      it 'registers an offence for `Max + 1` levels of `if` nesting' do
-        source = ['if a',
-                  '  if b',
-                  '    if c',
-                  '      puts c',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers a single offence for `Max + 2` levels of `if` nesting' do
-        source = ['if a',
-                  '  if b',
-                  '    if c',
-                  '      if d',
-                  '        puts d',
-                  '      end',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers 2 offences' do
-        source = ['if a',
-                  '  if b',
-                  '    if c',
-                  '      puts c',
-                  '    end',
-                  '  end',
-                  '  if d',
-                  '    if e',
-                  '      puts e',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3, 8])
-      end
-
-      it 'registers an offence for nested `case`' do
-        source = ['if a',
-                  '  if b',
-                  '    case c',
-                  '      when C',
-                  '        puts C',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers an offence for nested `while`' do
-        source = ['if a',
-                  '  if b',
-                  '    while c',
-                  '      puts c',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers an offence for nested modifier `while`' do
-        source = ['if a',
-                  '  if b',
-                  '    begin',
-                  '      puts c',
-                  '    end while c',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers an offence for nested `until`' do
-        source = ['if a',
-                  '  if b',
-                  '    until c',
-                  '      puts c',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers an offence for nested modifier `until`' do
-        source = ['if a',
-                  '  if b',
-                  '    begin',
-                  '      puts c',
-                  '    end until c',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers an offence for nested `for`' do
-        source = ['if a',
-                  '  if b',
-                  '    for c in [1,2] do',
-                  '      puts c',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [3])
-      end
-
-      it 'registers an offence for nested `rescue`' do
-        source = ['if a',
-                  '  if b',
-                  '    begin',
-                  '      puts c',
-                  '    rescue',
-                  '      puts x',
-                  '    end',
-                  '  end',
-                  'end']
-        expect_nesting_offences(source, [5])
-      end
-
-      def expect_nesting_offences(source, lines)
-        inspect_source(block_nesting, source)
-        expect(block_nesting.offences.map(&:line_number)).to eq(lines)
-        expect(block_nesting.messages).to eq(
-          ['Avoid more than 2 levels of block nesting.'] * lines.length)
-      end
-    end
-  end
-end

data/spec/rubocop/cops/blocks_spec.rb

@@ -1,33 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Blocks do
-      let(:blocks) { Blocks.new }
-
-      it 'registers an offence for a multiline block with braces' do
-        inspect_source(blocks, ['each { |x|',
-                                '}'])
-        expect(blocks.messages).to eq([Blocks::MULTI_LINE_MSG])
-      end
-
-      it 'accepts a multiline block with do-end' do
-        inspect_source(blocks, ['each do |x|',
-                                'end'])
-        expect(blocks.offences.map(&:message)).to be_empty
-      end
-
-      it 'registers an offence for a single line block with do-end' do
-        inspect_source(blocks, ['each do |x| end'])
-        expect(blocks.messages).to eq([Blocks::SINGLE_LINE_MSG])
-      end
-
-      it 'accepts a single line block with braces' do
-        inspect_source(blocks, ['each { |x| }'])
-        expect(blocks.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/case_indentation_spec.rb

@@ -1,86 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe CaseIndentation do
-      let(:ind) { CaseIndentation.new }
-
-      it "registers an offence for a when clause that's deeper than case" do
-        source = ['case a',
-                  '    when 0 then return',
-                  '        case b',
-                  '         when 1 then return',
-                  '        end',
-                  'end']
-        inspect_source(ind, source)
-        expect(ind.offences.map(&:message)).to eq(
-          ['Indent when as deep as case.'] * 2)
-      end
-
-      it "accepts a when clause that's equally indented with case" do
-        source = ['y = case a',
-                  '    when 0 then break',
-                  '    when 0 then return',
-                  '      z = case b',
-                  '          when 1 then return',
-                  '          when 1 then break',
-                  '          end',
-                  '    end',
-                  'case c',
-                  'when 2 then encoding',
-                  'end',
-                  '']
-        inspect_source(ind, source)
-        expect(ind.offences).to be_empty
-      end
-
-      it "doesn't get confused by strings with case in them" do
-        source = ['a = "case"',
-                  'case x',
-                  'when 0',
-                  'end',
-                  '']
-        inspect_source(ind, source)
-        expect(ind.offences.map(&:message)).to be_empty
-      end
-
-      it "doesn't get confused by symbols named case or when" do
-        source = ['KEYWORDS = { :case => true, :when => true }',
-                  'case type',
-                  'when 0',
-                  '  ParameterNode',
-                  'when 1',
-                  '  MethodCallNode',
-                  'end',
-                  '']
-        inspect_source(ind, source)
-        expect(ind.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts correctly indented whens in complex combinations' do
-        source = ['each {',
-                  '  case state',
-                  '  when 0',
-                  '    case name',
-                  '    when :a',
-                  '    end',
-                  '  when 1',
-                  '    loop {',
-                  '      case name',
-                  '      when :b',
-                  '      end',
-                  '    }',
-                  '  end',
-                  '}',
-                  'case s',
-                  'when Array',
-                  'end',
-                  '']
-        inspect_source(ind, source)
-        expect(ind.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/class_and_module_camel_case_spec.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe ClassAndModuleCamelCase do
-      let(:camel_case) { ClassAndModuleCamelCase.new }
-
-      it 'registers an offence for underscore in class and module name' do
-        inspect_source(camel_case,
-                       ['class My_Class',
-                        'end',
-                        '',
-                        'module My_Module',
-                        'end',
-                       ])
-        expect(camel_case.offences.size).to eq(2)
-      end
-
-      it 'is not fooled by qualified names' do
-        inspect_source(camel_case,
-                       ['class Top::My_Class',
-                        'end',
-                        '',
-                        'module My_Module::Ala',
-                        'end',
-                       ])
-        expect(camel_case.offences.size).to eq(2)
-      end
-
-      it 'accepts CamelCase names' do
-        inspect_source(camel_case,
-                       ['class MyClass',
-                        'end',
-                        '',
-                        'module Mine',
-                        'end',
-                       ])
-        expect(camel_case.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/class_methods_spec.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe ClassMethods do
-      let(:cm) { ClassMethods.new }
-
-      it 'registers an offence for methods using a class name' do
-        inspect_source(cm,
-                       ['class Test',
-                        '  def Test.some_method',
-                        '    do_something',
-                        '  end',
-                        'end'])
-        expect(cm.offences.size).to eq(1)
-      end
-
-      it 'registers an offence for methods using a module name' do
-        inspect_source(cm,
-                       ['module Test',
-                        '  def Test.some_method',
-                        '    do_something',
-                        '  end',
-                        'end'])
-        expect(cm.offences.size).to eq(1)
-      end
-
-      it 'does not register an offence for methods using self' do
-        inspect_source(cm,
-                       ['module Test',
-                        '  def self.some_method',
-                        '    do_something',
-                        '  end',
-                        'end'])
-        expect(cm.offences).to be_empty
-      end
-
-      it 'does not register an offence outside class/module bodies' do
-        inspect_source(cm,
-                       ['def self.some_method',
-                        '  do_something',
-                        'end'])
-        expect(cm.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/collection_methods_spec.rb

@@ -1,44 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe CollectionMethods do
-      let(:cm) { CollectionMethods.new }
-
-      it 'registers an offence for collect' do
-        inspect_source(cm, ['[1, 2, 3].collect { |e| e + 1 }'])
-        expect(cm.offences.size).to eq(1)
-        expect(cm.offences.map(&:message))
-          .to eq(['Prefer map over collect.'])
-      end
-
-      it 'registers an offence for inject' do
-        inspect_source(cm, ['[1, 2, 3].inject { |e| e + 1 }'])
-        expect(cm.offences.size).to eq(1)
-        expect(cm.offences.map(&:message))
-          .to eq(['Prefer reduce over inject.'])
-      end
-
-      it 'registers an offence for detect' do
-        inspect_source(cm, ['[1, 2, 3].detect { |e| e + 1 }'])
-        expect(cm.offences.size).to eq(1)
-        expect(cm.offences.map(&:message))
-          .to eq(['Prefer find over detect.'])
-      end
-
-      it 'registers an offence for find_all' do
-        inspect_source(cm, ['[1, 2, 3].find_all { |e| e + 1 }'])
-        expect(cm.offences.size).to eq(1)
-        expect(cm.offences.map(&:message))
-          .to eq(['Prefer select over find_all.'])
-      end
-
-      it 'ignores find_all without an explicit receiver' do
-        inspect_source(cm, ['find_all { |e| e + 1 }'])
-        expect(cm.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/colon_method_call_spec.rb

@@ -1,53 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe ColonMethodCall do
-      let(:smc) { ColonMethodCall.new }
-
-      it 'registers an offence for instance method call' do
-        inspect_source(smc,
-                       ['test::method_name'])
-        expect(smc.offences.size).to eq(1)
-      end
-
-      it 'registers an offence for instance method call with arg' do
-        inspect_source(smc,
-                       ['test::method_name(arg)'])
-        expect(smc.offences.size).to eq(1)
-      end
-
-      it 'registers an offence for class method call' do
-        inspect_source(smc,
-                       ['Class::method_name'])
-        expect(smc.offences.size).to eq(1)
-      end
-
-      it 'registers an offence for class method call with arg' do
-        inspect_source(smc,
-                       ['Class::method_name(arg, arg2)'])
-        expect(smc.offences.size).to eq(1)
-      end
-
-      it 'does not register an offence for constant access' do
-        inspect_source(smc,
-                       ['Tip::Top::SOME_CONST'])
-        expect(smc.offences).to be_empty
-      end
-
-      it 'does not register an offence for nested class' do
-        inspect_source(smc,
-                       ['Tip::Top.some_method'])
-        expect(smc.offences).to be_empty
-      end
-
-      it 'does not register an offence for op methods' do
-        inspect_source(smc,
-                       ['Tip::Top.some_method[3]'])
-        expect(smc.offences).to be_empty
-      end
-    end
-  end
-end