rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/multiline_if_then_spec.rb

@@ -1,79 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe MultilineIfThen do
-      let(:mit) { MultilineIfThen.new }
-
-      # if
-
-      it 'registers an offence for then in multiline if' do
-        inspect_source(mit, ['if cond then',
-                             'end',
-                             "if cond then\t",
-                             'end',
-                             'if cond then  ',
-                             'end',
-                             'if cond',
-                             'then',
-                             'end',
-                             'if cond then # bad',
-                             'end'])
-        expect(mit.offences.map(&:line_number)).to eq([1, 3, 5, 7, 10])
-      end
-
-      it 'accepts multiline if without then' do
-        inspect_source(mit, ['if cond',
-                             'end'])
-        expect(mit.offences).to be_empty
-      end
-
-      it 'accepts table style if/then/elsif/ends' do
-        inspect_source(mit,
-                       ['if    @io == $stdout then str << "$stdout"',
-                        'elsif @io == $stdin  then str << "$stdin"',
-                        'elsif @io == $stderr then str << "$stderr"',
-                        'else                      str << @io.class.to_s',
-                        'end'])
-        expect(mit.offences).to be_empty
-      end
-
-      it 'does not get confused by a then in a when' do
-        inspect_source(mit,
-                       ['if a',
-                        '  case b',
-                        '  when c then',
-                        '  end',
-                        'end'])
-        expect(mit.offences).to be_empty
-      end
-
-      it 'does not get confused by a commented-out then' do
-        inspect_source(mit,
-                       ['if a # then',
-                        '  b',
-                        'end',
-                        'if c # then',
-                        'end'])
-        expect(mit.offences).to be_empty
-      end
-
-      # unless
-
-      it 'registers an offence for then in multiline unless' do
-        inspect_source(mit, ['unless cond then',
-                             'end'])
-        expect(mit.offences.map(&:message)).to eq(
-          ['Never use then for multi-line if/unless.'])
-      end
-
-      it 'accepts multiline unless without then' do
-        inspect_source(mit, ['unless cond',
-                             'end'])
-        expect(mit.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/not_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Not do
-      let(:a) { Not.new }
-
-      it 'registers an offence for not' do
-        inspect_source(a, ['not test'])
-        expect(a.offences.size).to eq(1)
-      end
-
-      it 'does not register an offence for !' do
-        inspect_source(a, ['!test'])
-        expect(a.offences).to be_empty
-      end
-
-      it 'does not register an offence for :not' do
-        inspect_source(a, ['[:not, :if, :else]'])
-        expect(a.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/numeric_literals_spec.rb

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe NumericLiterals do
-      let(:num) { NumericLiterals.new }
-
-      it 'registers an offence for a long integer without underscores' do
-        inspect_source(num, ['a = 123456'])
-        expect(num.offences.map(&:message)).to eq(
-          ['Add underscores to large numeric literals to improve their ' +
-           'readability.'])
-      end
-
-      it 'registers an offence for an integer with not enough underscores' do
-        inspect_source(num, ['a = 123456_789000'])
-        expect(num.offences.map(&:message)).to eq(
-          ['Add underscores to large numeric literals to improve their ' +
-           'readability.'])
-      end
-
-      # it 'registers an offence for a long float without underscores' do
-      #   inspect_source(num, ['a = 1.234567'])
-      #   expect(num.offences.map(&:message)).to eq(
-      #     ['Add underscores to large numeric literals to improve their ' +
-      #      'readability.'])
-      # end
-
-      it 'accepts long numbers with underscore' do
-        inspect_source(num, ['a = 123_456',
-                             'b = 1.234_56'])
-        expect(num.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts a short integer without underscore' do
-        inspect_source(num, ['a = 123'])
-        expect(num.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts short numbers without underscore' do
-        inspect_source(num, ['a = 123',
-                             'b = 123.456'])
-        expect(num.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/one_line_conditional_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe OneLineConditional do
-      let(:olc) { OneLineConditional.new }
-
-      it 'registers an offence for one line if/then/end' do
-        inspect_source(olc, ['if cond then run else dont end'])
-        expect(olc.offences.map(&:message)).to eq([olc.error_message])
-      end
-    end
-  end
-end

data/spec/rubocop/cops/op_method_spec.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe OpMethod do
-      let(:om) { OpMethod.new }
-
-      it 'registers an offence for arg not named other' do
-        inspect_source(om,
-                       ['def +(another)',
-                        '  another',
-                        'end'])
-        expect(om.offences.size).to eq(1)
-        expect(om.offences.map(&:message))
-          .to eq([sprintf(OpMethod::MSG, '+')])
-      end
-
-      it 'works properly even if the argument is not surrounded with braces' do
-        inspect_source(om,
-                       ['def + another',
-                        '  another',
-                        'end'])
-        expect(om.offences.size).to eq(1)
-        expect(om.offences.map(&:message))
-          .to eq([sprintf(OpMethod::MSG, '+')])
-      end
-
-      it 'does not register an offence for arg named other' do
-        inspect_source(om,
-                       ['def +(other)',
-                        '  other',
-                        'end'])
-        expect(om.offences).to be_empty
-      end
-
-      it 'does not register an offence for []' do
-        inspect_source(om,
-                       ['def [](index)',
-                        '  other',
-                        'end'])
-        expect(om.offences).to be_empty
-      end
-
-      it 'does not register an offence for []=' do
-        inspect_source(om,
-                       ['def []=(index, value)',
-                        '  other',
-                        'end'])
-        expect(om.offences).to be_empty
-      end
-
-      it 'does not register an offence for <<' do
-        inspect_source(om,
-                       ['def <<(cop)',
-                        '  other',
-                        'end'])
-        expect(om.offences).to be_empty
-      end
-
-      it 'does not register an offence for non binary operators' do
-        inspect_source(om,
-                       ['def -@', # Unary minus
-                        'end',
-                        '',
-                        # This + is not a unary operator. It can only be
-                        # called with dot notation.
-                        'def +',
-                        'end',
-                        '',
-                        'def *(a, b)', # Quite strange, but legal ruby.
-                        'end'])
-        expect(om.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/parameter_lists_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe ParameterLists do
-      let(:list) { ParameterLists.new }
-
-      it 'registers an offence for a method def with 5 parameters' do
-        inspect_source(list, ['def meth(a, b, c, d, e)',
-                              'end'])
-        expect(list.messages).to eq(
-          ['Avoid parameter lists longer than 4 parameters.'])
-      end
-
-      it 'accepts a method def with 4 parameters' do
-        inspect_source(list, ['def meth(a, b, c, d)',
-                              'end'])
-        expect(list.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/parentheses_around_condition_spec.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe ParenthesesAroundCondition do
-      let(:pac) { ParenthesesAroundCondition.new }
-
-      it 'registers an offence for parentheses around condition' do
-        inspect_source(pac, ['if (x > 10)',
-                             'elsif (x < 3)',
-                             'end',
-                             'unless (x > 10)',
-                             'end',
-                             'while (x > 10)',
-                             'end',
-                             'until (x > 10)',
-                             'end',
-                             'x += 1 if (x < 10)',
-                             'x += 1 unless (x < 10)',
-                             'x += 1 while (x < 10)',
-                             'x += 1 until (x < 10)',
-                            ])
-        expect(pac.offences.size).to eq(9)
-      end
-
-      it 'accepts condition without parentheses' do
-        inspect_source(pac, ['if x > 10',
-                             'end',
-                             'unless x > 10',
-                             'end',
-                             'while x > 10',
-                             'end',
-                             'until x > 10',
-                             'end',
-                             'x += 1 if x < 10',
-                             'x += 1 unless x < 10',
-                             'x += 1 while x < 10',
-                             'x += 1 until x < 10',
-                            ])
-        expect(pac.offences).to be_empty
-      end
-
-      it 'is not confused by leading brace in subexpression' do
-        inspect_source(pac, ['(a > b) && other ? one : two'])
-        expect(pac.offences).to be_empty
-      end
-
-      # Parentheses are sometimes used to help the editor make nice
-      # indentation of conditions spanning several lines.
-      # it 'accepts parentheses around multiline conditions' do
-      #   inspect_source(pac, ['if (@lex_state != EXPR_BEG &&',
-      #                        '    @lex_state != EXPR_FNAME &&',
-      #                        '    trans[1])',
-      #                        'end'])
-      #   expect(pac.offences.map(&:message)).to be_empty
-      # end
-    end
-  end
-end

data/spec/rubocop/cops/percent_r_spec.rb

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

data/spec/rubocop/cops/proc_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Proc do
-      let(:proc) { Proc.new }
-
-      it 'registers an offence for a Proc.new call' do
-        inspect_source(proc, ['f = Proc.new { |x| puts x }'])
-        expect(proc.offences.size).to eq(1)
-      end
-
-      it 'accepts the proc method' do
-        inspect_source(proc, ['f = proc { |x| puts x }'])
-        expect(proc.offences).to be_empty
-      end
-
-      it 'accepts the Proc.new call outside of block' do
-        inspect_source(proc, ['p = Proc.new'])
-        expect(proc.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/reduce_arguments_spec.rb

@@ -1,57 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe ReduceArguments do
-      let(:reduce_arguments) { ReduceArguments.new }
-
-      it 'find wrong argument names in calls with different syntax' do
-        inspect_source(reduce_arguments,
-                       ['def m',
-                        '  [0, 1].reduce { |c, d| c + d }',
-                        '  [0, 1].reduce{ |c, d| c + d }',
-                        '  [0, 1].reduce(5) { |c, d| c + d }',
-                        '  [0, 1].reduce(5){ |c, d| c + d }',
-                        '  [0, 1].reduce (5) { |c, d| c + d }',
-                        '  [0, 1].reduce(5) { |c, d| c + d }',
-                        'end'])
-        expect(reduce_arguments.offences.size).to eq(6)
-        expect(reduce_arguments.offences
-                               .map(&:line_number).sort).to eq((2..7).to_a)
-      end
-
-      it 'allows calls with proper argument names' do
-        inspect_source(reduce_arguments,
-                       ['def m',
-                        '  [0, 1].reduce { |a, e| a + e }',
-                        '  [0, 1].reduce{ |a, e| a + e }',
-                        '  [0, 1].reduce(5) { |a, e| a + e }',
-                        '  [0, 1].reduce(5){ |a, e| a + e }',
-                        '  [0, 1].reduce (5) { |a, e| a + e }',
-                        '  [0, 1].reduce(5) { |a, e| a + e }',
-                        'end'])
-        expect(reduce_arguments.offences).to be_empty
-      end
-
-      it 'ignores do..end blocks' do
-        inspect_source(reduce_arguments,
-                       ['def m',
-                        '  [0, 1].reduce do |c, d|',
-                        '    c + d',
-                        '  end',
-                        'end'])
-        expect(reduce_arguments.offences).to be_empty
-      end
-
-      it 'ignores :reduce symbols' do
-        inspect_source(reduce_arguments,
-                       ['def m',
-                        '  call_method(:reduce) { |a, b| a + b}',
-                        'end'])
-        expect(reduce_arguments.offences).to be_empty
-      end
-    end
-  end
-end