rubocop 0.13.1 → 0.14.0

data/spec/rubocop/cop/team_spec.rb

@@ -2,157 +2,155 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    describe Team do
-      subject(:team) { Team.new(cop_classes, config, options) }
-      let(:cop_classes) { Cop.all }
-      let(:config) { Config.default_configuration }
-      let(:options) { nil }
-
-      describe '#autocorrect?' do
-        subject { team.autocorrect? }
-
-        context 'when the option argument of .new is omitted' do
-          subject { Team.new(cop_classes, config).autocorrect? }
-          it { should be_false }
-        end
+describe Rubocop::Cop::Team do
+  subject(:team) { described_class.new(cop_classes, config, options) }
+  let(:cop_classes) { Rubocop::Cop::Cop.all }
+  let(:config) { Rubocop::Config.default_configuration }
+  let(:options) { nil }
+
+  describe '#autocorrect?' do
+    subject { team.autocorrect? }
+
+    context 'when the option argument of .new is omitted' do
+      subject { described_class.new(cop_classes, config).autocorrect? }
+      it { should be_false }
+    end
 
-        context 'when { autocorrect: true } is passed to .new' do
-          let(:options) { { autocorrect: true } }
-          it { should be_true }
-        end
-      end
+    context 'when { autocorrect: true } is passed to .new' do
+      let(:options) { { autocorrect: true } }
+      it { should be_true }
+    end
+  end
 
-      describe '#debug?' do
-        subject { team.debug? }
+  describe '#debug?' do
+    subject { team.debug? }
 
-        context 'when the option argument of .new is omitted' do
-          subject { Team.new(cop_classes, config).debug? }
-          it { should be_false }
-        end
+    context 'when the option argument of .new is omitted' do
+      subject { described_class.new(cop_classes, config).debug? }
+      it { should be_false }
+    end
 
-        context 'when { debug: true } is passed to .new' do
-          let(:options) { { debug: true } }
-          it { should be_true }
-        end
-      end
+    context 'when { debug: true } is passed to .new' do
+      let(:options) { { debug: true } }
+      it { should be_true }
+    end
+  end
 
-      describe '#inspect_file', :isolated_environment do
-        include FileHelper
+  describe '#inspect_file', :isolated_environment do
+    include FileHelper
 
-        let(:file_path) { 'example.rb' }
-        let(:offences) { team.inspect_file(file_path) }
+    let(:file_path) { 'example.rb' }
+    let(:offences) { team.inspect_file(file_path) }
 
-        before do
-          create_file(file_path, [
-            '#' * 90,
-            'puts test;'
-          ])
-        end
+    before do
+      create_file(file_path, [
+        '#' * 90,
+        'puts test;'
+      ])
+    end
 
-        it 'returns offences' do
-          expect(offences).not_to be_empty
-          expect(offences.all? { |o| o.is_a?(Offence) }).to be_true
-        end
+    it 'returns offences' do
+      expect(offences).not_to be_empty
+      expect(offences.all? { |o| o.is_a?(Rubocop::Cop::Offence) }).to be_true
+    end
 
-        context 'when Parser cannot parse the file' do
-          before do
-            create_file(file_path, [
-              '#' * 90,
-              'class Test'
-            ])
-          end
-
-          it 'returns only error offences' do
-            expect(offences.size).to eq(1)
-            offence = offences.first
-            expect(offence.cop_name).to eq('Syntax')
-            expect(offence.severity).to eq(:error)
-          end
-        end
+    context 'when Parser cannot parse the file' do
+      before do
+        create_file(file_path, [
+          '#' * 90,
+          'class Test'
+        ])
+      end
 
-        context 'when Parser reports non-fatal warning for the file' do
-          before do
-            create_file(file_path, [
-              '# encoding: utf-8',
-              '#' * 90,
-              'puts *test'
-            ])
-          end
+      it 'returns only error offences' do
+        expect(offences.size).to eq(1)
+        offence = offences.first
+        expect(offence.cop_name).to eq('Syntax')
+        expect(offence.severity).to eq(:error)
+      end
+    end
 
-          let(:cop_names) { offences.map(&:cop_name) }
+    context 'when Parser reports non-fatal warning for the file' do
+      before do
+        create_file(file_path, [
+          '# encoding: utf-8',
+          '#' * 90,
+          'puts *test'
+        ])
+      end
 
-          it 'returns Parser warning offences' do
-            expect(cop_names).to include('Syntax')
-          end
+      let(:cop_names) { offences.map(&:cop_name) }
 
-          it 'returns offences from cops' do
-            expect(cop_names).to include('LineLength')
-          end
-        end
+      it 'returns Parser warning offences' do
+        expect(cop_names).to include('Syntax')
+      end
 
-        context 'when autocorrection is enabled' do
-          let(:options) { { autocorrect: true } }
-
-          before do
-            create_file(file_path, [
-              '# encoding: utf-8',
-              'puts "string"'
-            ])
-          end
-
-          it 'does autocorrection' do
-            team.inspect_file(file_path)
-            corrected_source = File.read(file_path)
-            expect(corrected_source).to eq([
-              '# encoding: utf-8',
-              "puts 'string'",
-              ''
-            ].join("\n"))
-          end
-
-          it 'still returns offences' do
-            expect(offences.first.cop_name).to eq('StringLiterals')
-          end
-        end
+      it 'returns offences from cops' do
+        expect(cop_names).to include('LineLength')
       end
+    end
 
-      describe '#cops' do
-        subject(:cops) { team.cops }
+    context 'when autocorrection is enabled' do
+      let(:options) { { autocorrect: true } }
 
-        it 'returns cop instances' do
-          expect(cops).not_to be_empty
-          expect(cops.all? { |c| c.is_a?(Cop) }).to be_true
-        end
+      before do
+        create_file(file_path, [
+          '# encoding: utf-8',
+          'puts "string"'
+        ])
+      end
 
-        context 'when only some cop classes are passed to .new' do
-          let(:cop_classes) { [Lint::Void, Style::LineLength] }
+      it 'does autocorrection' do
+        team.inspect_file(file_path)
+        corrected_source = File.read(file_path)
+        expect(corrected_source).to eq([
+          '# encoding: utf-8',
+          "puts 'string'",
+          ''
+        ].join("\n"))
+      end
 
-          it 'returns only intances of the classes' do
-            expect(cops.size).to eq(2)
-            cops.sort! { |a, b| a.name <=> b.name }
-            expect(cops[0].name).to eq('LineLength')
-            expect(cops[1].name).to eq('Void')
-          end
-        end
+      it 'still returns offences' do
+        expect(offences.first.cop_name).to eq('StringLiterals')
+      end
+    end
+  end
+
+  describe '#cops' do
+    subject(:cops) { team.cops }
 
-        context 'when some classes are disabled with config' do
-          before do
-            %w(Void LineLength).each do |cop_name|
-              config.for_cop(cop_name)['Enabled'] = false
-            end
-          end
+    it 'returns cop instances' do
+      expect(cops).not_to be_empty
+      expect(cops.all? { |c| c.is_a?(Rubocop::Cop::Cop) }).to be_true
+    end
+
+    context 'when only some cop classes are passed to .new' do
+      let(:cop_classes) do
+        [Rubocop::Cop::Lint::Void, Rubocop::Cop::Style::LineLength]
+      end
 
-          let(:cop_names) { cops.map(&:name) }
+      it 'returns only intances of the classes' do
+        expect(cops.size).to eq(2)
+        cops.sort! { |a, b| a.name <=> b.name }
+        expect(cops[0].name).to eq('LineLength')
+        expect(cops[1].name).to eq('Void')
+      end
+    end
 
-          it 'does not return intances of the classes' do
-            expect(cops).not_to be_empty
-            expect(cop_names).not_to include('Void')
-            expect(cop_names).not_to include('LineLength')
-          end
+    context 'when some classes are disabled with config' do
+      before do
+        %w(Void LineLength).each do |cop_name|
+          config.for_cop(cop_name)['Enabled'] = false
         end
       end
+
+      let(:cop_names) { cops.map(&:name) }
+
+      it 'does not return intances of the classes' do
+        expect(cops).not_to be_empty
+        expect(cop_names).not_to include('Void')
+        expect(cop_names).not_to include('LineLength')
+      end
     end
   end
 end

data/spec/rubocop/cop/variable_inspector/assignment_spec.rb

@@ -2,215 +2,211 @@
 
 require 'spec_helper'
 
-module Rubocop
-  module Cop
-    module VariableInspector
-      describe Assignment do
-        include ASTHelper
-        include AST::Sexp
-
-        let(:ast) do
-          processed_source = Rubocop::SourceParser.parse(source)
-          processed_source.ast
-        end
+describe Rubocop::Cop::VariableInspector::Assignment do
+  include ASTHelper
+  include AST::Sexp
 
-        let(:source) do
-          <<-END
-            class SomeClass
-              def some_method(flag)
-                puts 'Hello World!'
-
-                if flag > 0
-                  foo = 1
-                end
-              end
-            end
-          END
-        end
+  let(:ast) do
+    processed_source = Rubocop::SourceParser.parse(source)
+    processed_source.ast
+  end
 
-        let(:def_node) do
-          found_node = scan_node(ast, include_origin_node: true) do |node|
-            break node if node.type == :def
-          end
-          fail 'No def node found!' unless found_node
-          found_node
-        end
+  let(:source) do
+    <<-END
+      class SomeClass
+        def some_method(flag)
+          puts 'Hello World!'
 
-        let(:lvasgn_node) do
-          found_node = scan_node(ast) do |node|
-            break node if node.type == :lvasgn
+          if flag > 0
+            foo = 1
           end
-          fail 'No lvasgn node found!' unless found_node
-          found_node
         end
+      end
+    END
+  end
 
-        let(:name) { lvasgn_node.children.first }
-        let(:scope) { Scope.new(def_node) }
-        let(:variable) { Variable.new(name, lvasgn_node, scope) }
-        let(:assignment) { Assignment.new(lvasgn_node, variable) }
+  let(:def_node) do
+    found_node = scan_node(ast, include_origin_node: true) do |node|
+      break node if node.type == :def
+    end
+    fail 'No def node found!' unless found_node
+    found_node
+  end
 
-        describe '.new' do
-          let(:variable) { double('variable') }
+  let(:lvasgn_node) do
+    found_node = scan_node(ast) do |node|
+      break node if node.type == :lvasgn
+    end
+    fail 'No lvasgn node found!' unless found_node
+    found_node
+  end
 
-          context 'when an assignment node is passed' do
-            it 'does not raise error' do
-              node = s(:lvasgn, :foo)
-              expect { Assignment.new(node, variable) }.not_to raise_error
-            end
-          end
+  let(:name) { lvasgn_node.children.first }
+  let(:scope) { Rubocop::Cop::VariableInspector::Scope.new(def_node) }
+  let(:variable) do
+    Rubocop::Cop::VariableInspector::Variable.new(name, lvasgn_node, scope)
+  end
+  let(:assignment) { described_class.new(lvasgn_node, variable) }
 
-          context 'when an argument declaration node is passed' do
-            it 'raises error' do
-              node = s(:arg, :foo)
-              expect { Assignment.new(node, variable) }
-                .to raise_error(ArgumentError)
-            end
-          end
+  describe '.new' do
+    let(:variable) { double('variable') }
 
-          context 'when any other type node is passed' do
-            it 'raises error' do
-              node = s(:def)
-              expect { Assignment.new(node, variable) }
-                .to raise_error(ArgumentError)
-            end
-          end
-        end
+    context 'when an assignment node is passed' do
+      it 'does not raise error' do
+        node = s(:lvasgn, :foo)
+        expect { described_class.new(node, variable) }.not_to raise_error
+      end
+    end
 
-        describe '#name' do
-          it 'returns the variable name' do
-            expect(assignment.name).to eq(:foo)
-          end
-        end
+    context 'when an argument declaration node is passed' do
+      it 'raises error' do
+        node = s(:arg, :foo)
+        expect { described_class.new(node, variable) }
+          .to raise_error(ArgumentError)
+      end
+    end
+
+    context 'when any other type node is passed' do
+      it 'raises error' do
+        node = s(:def)
+        expect { described_class.new(node, variable) }
+          .to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#name' do
+    it 'returns the variable name' do
+      expect(assignment.name).to eq(:foo)
+    end
+  end
 
-        describe '#meta_assignment_node' do
-          context 'when it is += operator assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo += 1
-                end
-              END
-            end
-
-            it 'returns op_asgn node' do
-              expect(assignment.meta_assignment_node.type).to eq(:op_asgn)
-            end
+  describe '#meta_assignment_node' do
+    context 'when it is += operator assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo += 1
           end
+        END
+      end
+
+      it 'returns op_asgn node' do
+        expect(assignment.meta_assignment_node.type).to eq(:op_asgn)
+      end
+    end
 
-          context 'when it is ||= operator assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo ||= 1
-                end
-              END
-            end
-
-            it 'returns or_asgn node' do
-              expect(assignment.meta_assignment_node.type).to eq(:or_asgn)
-            end
+    context 'when it is ||= operator assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo ||= 1
           end
+        END
+      end
 
-          context 'when it is &&= operator assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo &&= 1
-                end
-              END
-            end
-
-            it 'returns and_asgn node' do
-              expect(assignment.meta_assignment_node.type).to eq(:and_asgn)
-            end
+      it 'returns or_asgn node' do
+        expect(assignment.meta_assignment_node.type).to eq(:or_asgn)
+      end
+    end
+
+    context 'when it is &&= operator assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo &&= 1
           end
+        END
+      end
 
-          context 'when it is multiple assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo, bar = [1, 2]
-                end
-              END
-            end
-
-            it 'returns masgn node' do
-              expect(assignment.meta_assignment_node.type).to eq(:masgn)
-            end
+      it 'returns and_asgn node' do
+        expect(assignment.meta_assignment_node.type).to eq(:and_asgn)
+      end
+    end
+
+    context 'when it is multiple assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo, bar = [1, 2]
           end
-        end
+        END
+      end
+
+      it 'returns masgn node' do
+        expect(assignment.meta_assignment_node.type).to eq(:masgn)
+      end
+    end
+  end
 
-        describe '#operator' do
-          context 'when it is normal assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo = 1
-                end
-              END
-            end
-
-            it 'returns =' do
-              expect(assignment.operator).to eq('=')
-            end
+  describe '#operator' do
+    context 'when it is normal assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo = 1
           end
+        END
+      end
 
-          context 'when it is += operator assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo += 1
-                end
-              END
-            end
-
-            it 'returns +=' do
-              expect(assignment.operator).to eq('+=')
-            end
+      it 'returns =' do
+        expect(assignment.operator).to eq('=')
+      end
+    end
+
+    context 'when it is += operator assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo += 1
           end
+        END
+      end
+
+      it 'returns +=' do
+        expect(assignment.operator).to eq('+=')
+      end
+    end
 
-          context 'when it is ||= operator assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo ||= 1
-                end
-              END
-            end
-
-            it 'returns ||=' do
-              expect(assignment.operator).to eq('||=')
-            end
+    context 'when it is ||= operator assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo ||= 1
           end
+        END
+      end
+
+      it 'returns ||=' do
+        expect(assignment.operator).to eq('||=')
+      end
+    end
 
-          context 'when it is &&= operator assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo &&= 1
-                end
-              END
-            end
-
-            it 'returns &&=' do
-              expect(assignment.operator).to eq('&&=')
-            end
+    context 'when it is &&= operator assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo &&= 1
           end
+        END
+      end
+
+      it 'returns &&=' do
+        expect(assignment.operator).to eq('&&=')
+      end
+    end
 
-          context 'when it is multiple assignment' do
-            let(:source) do
-              <<-END
-                def some_method
-                  foo, bar = [1, 2]
-                end
-              END
-            end
-
-            it 'returns =' do
-              expect(assignment.operator).to eq('=')
-            end
+    context 'when it is multiple assignment' do
+      let(:source) do
+        <<-END
+          def some_method
+            foo, bar = [1, 2]
           end
-        end
+        END
+      end
+
+      it 'returns =' do
+        expect(assignment.operator).to eq('=')
       end
     end
   end