rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/favor_join_spec.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe FavorJoin do
-      let(:fj) { FavorJoin.new }
-
-      it 'registers an offence for an array followed by string' do
-        inspect_source(fj,
-                       ['%w(one two three) * ", "'])
-        expect(fj.offences.size).to eq(1)
-        expect(fj.offences.map(&:message))
-          .to eq([FavorJoin::MSG])
-      end
-
-      it 'does not register an offence for numbers' do
-        inspect_source(fj,
-                       ['%w(one two three) * 4'])
-        expect(fj.offences).to be_empty
-      end
-
-      it 'does not register an offence for ambiguous cases' do
-        inspect_source(fj,
-                       ['test * ", "'])
-        expect(fj.offences).to be_empty
-
-        inspect_source(fj,
-                       ['%w(one two three) * test'])
-        expect(fj.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/favor_modifier_spec.rb

@@ -1,146 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe FavorModifier do
-      let(:if_unless) { IfUnlessModifier.new }
-      let(:while_until) { WhileUntilModifier.new }
-      before { LineLength.config = { 'Max' => 79 } }
-
-      it 'registers an offence for multiline if that fits on one line' do
-        # This if statement fits exactly on one line if written as a modifier.
-        inspect_source(if_unless,
-                       ['if a_condition_that_is_just_short_enough',
-                        '  some_long_metod_name(followed_by_args)',
-                        'end'])
-        expect(if_unless.offences.map(&:message)).to eq(
-          ['Favor modifier if/unless usage when you have a single-line body.' +
-           ' Another good alternative is the usage of control flow &&/||.'])
-      end
-
-      it "accepts multiline if that doesn't fit on one line" do
-        check_too_long(if_unless, 'if')
-      end
-
-      it 'accepts multiline if whose body is more than one line' do
-        check_short_multiline(if_unless, 'if')
-      end
-
-      it 'registers an offence for multiline unless that fits on one line' do
-        inspect_source(if_unless, ['unless a',
-                                  '  b',
-                                  'end'])
-        expect(if_unless.offences.map(&:message)).to eq(
-          ['Favor modifier if/unless usage when you have a single-line body.' +
-           ' Another good alternative is the usage of control flow &&/||.'])
-      end
-
-      it 'accepts code with EOL comment since user might want to keep it' do
-        pending
-        inspect_source(if_unless, ['unless a',
-                                  '  b # A comment',
-                                  'end'])
-        expect(if_unless.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts if-else-end' do
-        inspect_source(if_unless,
-                       ['if args.last.is_a? Hash then args.pop else ' +
-                        'Hash.new end'])
-        expect(if_unless.offences.map(&:message)).to be_empty
-      end
-
-      it "accepts multiline unless that doesn't fit on one line" do
-        check_too_long(while_until, 'unless')
-      end
-
-      it 'accepts multiline unless whose body is more than one line' do
-        check_short_multiline(while_until, 'unless')
-      end
-
-      it 'registers an offence for multiline while that fits on one line' do
-        check_really_short(while_until, 'while')
-      end
-
-      it "accepts multiline while that doesn't fit on one line" do
-        check_too_long(while_until, 'while')
-      end
-
-      it 'accepts multiline while whose body is more than one line' do
-        check_short_multiline(while_until, 'while')
-      end
-
-      it 'registers an offence for multiline until that fits on one line' do
-        check_really_short(while_until, 'until')
-      end
-
-      it "accepts multiline until that doesn't fit on one line" do
-        check_too_long(while_until, 'until')
-      end
-
-      it 'accepts multiline until whose body is more than one line' do
-        check_short_multiline(while_until, 'until')
-      end
-
-      it 'accepts an empty condition' do
-        check_empty(if_unless, 'if')
-        check_empty(if_unless, 'unless')
-        check_empty(while_until, 'while')
-        check_empty(while_until, 'until')
-      end
-
-      it 'accepts if/elsif' do
-        inspect_source(if_unless, ['if test',
-                                   '  something',
-                                   'elsif test2',
-                                   '  something_else',
-                                   'end'])
-        expect(if_unless.offences).to be_empty
-      end
-
-      it 'accepts modifier while' do
-        inspect_source(while_until, ['ala while bala'])
-        expect(while_until.offences).to be_empty
-      end
-
-      it 'accepts modifier until' do
-        inspect_source(while_until, ['ala until bala'])
-        expect(while_until.offences).to be_empty
-      end
-
-      def check_empty(cop, keyword)
-        inspect_source(cop, ["#{keyword} cond",
-                             'end'])
-        expect(cop.offences).to be_empty
-      end
-
-      def check_really_short(cop, keyword)
-        inspect_source(cop, ["#{keyword} a",
-                             '  b',
-                             'end'])
-        expect(cop.offences.map(&:message)).to eq(
-          ['Favor modifier while/until usage when you have a single-line ' +
-           'body.'])
-      end
-
-      def check_too_long(cop, keyword)
-        inspect_source(cop,
-                       ["  #{keyword} a_lengthy_condition_that_goes_on_and_on",
-                        '    some_long_metod_name(followed_by_args)',
-                        '  end'])
-        expect(cop.offences.map(&:message)).to be_empty
-      end
-
-      def check_short_multiline(cop, keyword)
-        inspect_source(cop,
-                       ["#{keyword} ENV['COVERAGE']",
-                        "  require 'simplecov'",
-                        '  SimpleCov.start',
-                        'end'])
-        expect(cop.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/favor_percent_r_spec.rb

@@ -1,29 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe FavorPercentR do
-      let(:fpr) { FavorPercentR.new }
-
-      it 'registers an offence for // with two slashes in regexp' do
-        inspect_source(fpr, ['x =~ /home\/\//',
-                             'y =~ /etc\/top\//'])
-        expect(fpr.offences.map(&:message))
-          .to eq([FavorPercentR::MSG] * 2)
-      end
-
-      it 'accepts // with only one slash in regexp' do
-        inspect_source(fpr, ['x =~ /\/home/',
-                             'y =~ /\//'])
-        expect(fpr.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts %r delimiters for regexp with two or more slashes' do
-        inspect_source(fpr, ['x =~ %r(/home/)'])
-        expect(fpr.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/favor_sprintf_spec.rb

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe FavorSprintf do
-      let(:fs) { FavorSprintf.new }
-
-      it 'registers an offence for a string followed by something' do
-        inspect_source(fs,
-                       ['puts "%d" % 10'])
-        expect(fs.offences.size).to eq(1)
-        expect(fs.offences.map(&:message))
-          .to eq([FavorSprintf::MSG])
-      end
-
-      it 'registers an offence for something followed by an array' do
-        inspect_source(fs,
-                       ['puts x % [10, 11]'])
-        expect(fs.offences.size).to eq(1)
-        expect(fs.offences.map(&:message))
-          .to eq([FavorSprintf::MSG])
-      end
-
-      it 'does not register an offence for numbers' do
-        inspect_source(fs,
-                       ['puts 10 % 4'])
-        expect(fs.offences).to be_empty
-      end
-
-      it 'does not register an offence for ambiguous cases' do
-        inspect_source(fs,
-                       ['puts x % 4'])
-        expect(fs.offences).to be_empty
-
-        inspect_source(fs,
-                       ['puts x % Y'])
-        expect(fs.offences).to be_empty
-      end
-
-      it 'works if the first operand contains embedded expressions' do
-        inspect_source(fs,
-                       ['puts "#{x * 5} %d #{@test}" % 10'])
-        expect(fs.offences.size).to eq(1)
-        expect(fs.offences.map(&:message))
-          .to eq([FavorSprintf::MSG])
-      end
-    end
-  end
-end

data/spec/rubocop/cops/favor_unless_over_negated_if_spec.rb

@@ -1,62 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe FavorUnlessOverNegatedIf do
-      let(:fav_unless) { FavorUnlessOverNegatedIf.new }
-
-      it 'registers an offence for if with exclamation point condition' do
-        inspect_source(fav_unless,
-                       ['if !a_condition',
-                        '  some_method',
-                        'end',
-                        'some_method if !a_condition',
-                       ])
-        expect(fav_unless.offences.map(&:message)).to eq(
-          ['Favor unless (or control flow or) over if for negative ' +
-           'conditions.'] * 2)
-      end
-
-      it 'registers an offence for if with "not" condition' do
-        inspect_source(fav_unless,
-                       ['if not a_condition',
-                        '  some_method',
-                        'end',
-                        'some_method if not a_condition'])
-        expect(fav_unless.offences.map(&:message)).to eq(
-          ['Favor unless (or control flow or) over if for negative ' +
-           'conditions.'] * 2)
-        expect(fav_unless.offences.map(&:line_number)).to eq([1, 4])
-      end
-
-      it 'accepts an if/else with negative condition' do
-        inspect_source(fav_unless,
-                       ['if !a_condition',
-                        '  some_method',
-                        'else',
-                        '  something_else',
-                        'end',
-                        'if not a_condition',
-                        '  some_method',
-                        'elsif other_condition',
-                        '  something_else',
-                        'end'])
-        expect(fav_unless.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts an if where only part of the contition is negated' do
-        inspect_source(fav_unless,
-                       ['if !a_condition && another_condition',
-                        '  some_method',
-                        'end',
-                        'if not a_condition or another_condition',
-                        '  some_method',
-                        'end',
-                        'some_method if not a_condition or another_condition'])
-        expect(fav_unless.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/favor_until_over_negated_while_spec.rb

@@ -1,45 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe FavorUntilOverNegatedWhile do
-      let(:fav_until) { FavorUntilOverNegatedWhile.new }
-
-      it 'registers an offence for while with exclamation point condition' do
-        inspect_source(fav_until,
-                       ['while !a_condition',
-                        '  some_method',
-                        'end',
-                        'some_method while !a_condition',
-                       ])
-        expect(fav_until.offences.map(&:message)).to eq(
-          ['Favor until over while for negative conditions.'] * 2)
-      end
-
-      it 'registers an offence for while with "not" condition' do
-        inspect_source(fav_until,
-                       ['while (not a_condition)',
-                        '  some_method',
-                        'end',
-                        'some_method while not a_condition'])
-        expect(fav_until.offences.map(&:message)).to eq(
-          ['Favor until over while for negative conditions.'] * 2)
-        expect(fav_until.offences.map(&:line_number)).to eq([1, 4])
-      end
-
-      it 'accepts an while where only part of the contition is negated' do
-        inspect_source(fav_until,
-                       ['while !a_condition && another_condition',
-                        '  some_method',
-                        'end',
-                        'while not a_condition or another_condition',
-                        '  some_method',
-                        'end',
-                        'some_method while not a_condition or other_cond'])
-        expect(fav_until.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/handle_exceptions_spec.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe HandleExceptions do
-      let(:he) { HandleExceptions.new }
-
-      it 'registers an offence for empty rescue block' do
-        inspect_source(he,
-                       ['begin',
-                        '  something',
-                        'rescue',
-                        '  #do nothing',
-                        'end'])
-        expect(he.offences.size).to eq(1)
-        expect(he.offences.map(&:message))
-          .to eq([HandleExceptions::MSG])
-      end
-
-      it 'does not register an offence for rescue with body' do
-        inspect_source(he,
-                       ['begin',
-                        '  something',
-                        '  return',
-                        'rescue',
-                        '  file.close',
-                        'end'])
-        expect(he.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/hash_syntax_spec.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe HashSyntax do
-      let(:hash_syntax) { HashSyntax.new }
-
-      it 'registers an offence for hash rocket syntax when new is possible' do
-        inspect_source(hash_syntax, ['x = { :a => 0 }'])
-        expect(hash_syntax.offences.map(&:message)).to eq(
-          ['Ruby 1.8 hash syntax detected'])
-      end
-
-      it 'registers an offence for mixed syntax when new is possible' do
-        inspect_source(hash_syntax, ['x = { :a => 0, b: 1 }'])
-        expect(hash_syntax.offences.map(&:message)).to eq(
-          ['Ruby 1.8 hash syntax detected'])
-      end
-
-      it 'registers an offence for hash rockets in method calls' do
-        inspect_source(hash_syntax, ['func(3, :a => 0)'])
-        expect(hash_syntax.offences.map(&:message)).to eq(
-          ['Ruby 1.8 hash syntax detected'])
-      end
-
-      it 'accepts hash rockets when keys have different types' do
-        inspect_source(hash_syntax, ['x = { :a => 0, "b" => 1 }'])
-        expect(hash_syntax.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts hash rockets when keys special symbols in them' do
-        inspect_source(hash_syntax, ['x = { :"t o" => 0, :"\xab" => 1 }'])
-        expect(hash_syntax.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts new syntax in a hash literal' do
-        inspect_source(hash_syntax, ['x = { a: 0, b: 1 }'])
-        expect(hash_syntax.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts new syntax in method calls' do
-        inspect_source(hash_syntax, ['func(3, a: 0)'])
-        expect(hash_syntax.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end