sabat-rubocop 0.9.0

data/spec/rubocop/cops/style/not_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/numeric_literals_spec.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/one_line_conditional_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/op_method_spec.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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 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
+end

data/spec/rubocop/cops/style/parameter_lists_spec.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe ParameterLists do
+        let(:list) { ParameterLists.new }
+        before do
+          ParameterLists.config = {
+            'Max' => 4,
+            'CountKeywordArgs' => true
+          }
+        end
+
+        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.offences.size).to eq(1)
+        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
+
+        context 'When CountKeywordArgs is true' do
+          it 'counts keyword arguments as well', ruby: 2.0 do
+            inspect_source(list, ['def meth(a, b, c, d: 1, e: 2)',
+                                  'end'])
+            expect(list.offences.size).to eq(1)
+          end
+        end
+
+        context 'When CountKeywordArgs is false' do
+          before { ParameterLists.config['CountKeywordArgs'] = false }
+
+          it 'it does not count keyword arguments', ruby: 2.0 do
+            inspect_source(list, ['def meth(a, b, c, d: 1, e: 2)',
+                                  'end'])
+            expect(list.offences).to be_empty
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/parentheses_around_condition_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+
+        it 'is not confused by unbalanced parentheses' do
+          inspect_source(pac, ['if (a + b).c()',
+                               'end'])
+          expect(pac.offences).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cops/style/proc_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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
+end

data/spec/rubocop/cops/style/reduce_arguments_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      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).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
+end

data/spec/rubocop/cops/style/regexp_literal_spec.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    module Style
+      describe RegexpLiteral do
+        let(:rl) { RegexpLiteral.new }
+        before { RegexpLiteral.config = { 'MaxSlashes' => 1 } }
+
+        context 'when a regexp uses // delimiters' do
+          context 'when MaxSlashes is 1' do
+            it 'registers an offence for two slashes in regexp' do
+              inspect_source(rl, ['x =~ /home\/\//',
+                                  'y =~ /etc\/top\//'])
+              expect(rl.offences.map(&:message))
+                .to eq(['Use %r for regular expressions matching more ' +
+                        "than 1 '/' character."] * 2)
+            end
+
+            it 'accepts zero or one slash in regexp' do
+              inspect_source(rl, ['x =~ /\/home/',
+                                  'y =~ /\//',
+                                  'z =~ /a/'])
+              expect(rl.offences).to be_empty
+            end
+          end
+
+          context 'when MaxSlashes is 0' do
+            before { RegexpLiteral.config = { 'MaxSlashes' => 0 } }
+
+            it 'registers an offence for one slash in regexp' do
+              inspect_source(rl, ['x =~ /home\//'])
+              expect(rl.offences.map(&:message))
+                .to eq(['Use %r for regular expressions matching more ' +
+                        "than 0 '/' characters."])
+            end
+
+            it 'accepts zero slashes in regexp' do
+              inspect_source(rl, ['z =~ /a/'])
+              expect(rl.offences).to be_empty
+            end
+          end
+        end
+
+        context 'when a regexp uses %r delimiters' do
+          context 'when MaxSlashes is 1' do
+            it 'registers an offence for zero or one slash in regexp' do
+              inspect_source(rl, ['x =~ %r(/home)',
+                                  'y =~ %r(etc)'])
+              expect(rl.offences.map(&:message))
+                .to eq(['Use %r only for regular expressions matching more ' +
+                        "than 1 '/' character."] * 2)
+            end
+
+            it 'accepts regexp with two or more slashes' do
+              inspect_source(rl, ['x =~ %r(/home/)',
+                                  'y =~ %r(/////)'])
+              expect(rl.offences).to be_empty
+            end
+          end
+
+          context 'when MaxSlashes is 0' do
+            before { RegexpLiteral.config = { 'MaxSlashes' => 0 } }
+
+            it 'registers an offence for zero slashes in regexp' do
+              inspect_source(rl, ['y =~ %r(etc)'])
+              expect(rl.offences.map(&:message))
+                .to eq(['Use %r only for regular expressions matching more ' +
+                        "than 0 '/' characters."])
+            end
+
+            it 'accepts regexp with one slash' do
+              inspect_source(rl, ['x =~ %r(/home)'])
+              expect(rl.offences).to be_empty
+            end
+          end
+        end
+      end
+    end
+  end
+end