rubocop 0.8.3 → 0.9.0

data/spec/rubocop/cops/if_with_semicolon_spec.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe IfWithSemicolon do
-      let(:iws) { IfWithSemicolon.new }
-
-      it 'registers an offence for one line if/;/end' do
-        inspect_source(iws, ['if cond; run else dont end'])
-        expect(iws.offences.map(&:message)).to eq(
-          ['Never use if x; Use the ternary operator instead.'])
-      end
-
-      it 'can handle modifier conditionals' do
-        inspect_source(iws, ['class Hash',
-                             'end if RUBY_VERSION < "1.8.7"'])
-        expect(iws.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/lambda_spec.rb

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Lambda do
-      let(:lambda) { Lambda.new }
-
-      it 'registers an offence for an old single-line lambda call' do
-        inspect_source(lambda, ['f = lambda { |x| x }'])
-        expect(lambda.offences.size).to eq(1)
-        expect(lambda.messages).to eq([Lambda::SINGLE_MSG])
-      end
-
-      it 'accepts the new lambda literal with single-line body' do
-        inspect_source(lambda, ['lambda = ->(x) { x }',
-                                   'lambda.(1)'])
-        expect(lambda.offences).to be_empty
-      end
-
-      it 'registers an offence for a new multi-line lambda call' do
-        inspect_source(lambda, ['f = ->(x) do',
-                                        '  x',
-                                        'end'])
-        expect(lambda.offences.size).to eq(1)
-        expect(lambda.messages).to eq([Lambda::MULTI_MSG])
-      end
-
-      it 'accepts the old lambda syntax with multi-line body' do
-        inspect_source(lambda, ['l = lambda do |x|',
-                                        '  x',
-                                        'end'])
-        expect(lambda.offences).to be_empty
-      end
-
-      it 'accepts the lambda call outside of block' do
-        inspect_source(lambda, ['l = lambda.test'])
-        expect(lambda.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/leading_comment_space_spec.rb

@@ -1,54 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe LeadingCommentSpace do
-      let(:lcs) { LeadingCommentSpace.new }
-
-      it 'registers an offence for comment without leading space' do
-        inspect_source(lcs,
-                       ['#missing space'])
-        expect(lcs.offences.size).to eq(1)
-      end
-
-      it 'does not register an offence for # followed by no text' do
-        inspect_source(lcs,
-                       ['#'])
-        expect(lcs.offences).to be_empty
-      end
-
-      it 'does not register an offence for more than one space' do
-        inspect_source(lcs,
-                       ['#   heavily indented'])
-        expect(lcs.offences).to be_empty
-      end
-
-      it 'does not register an offence for more than one #' do
-        inspect_source(lcs,
-                       ['###### heavily indented'])
-        expect(lcs.offences).to be_empty
-      end
-
-      it 'does not register an offence for only #s' do
-        inspect_source(lcs,
-                       ['######'])
-        expect(lcs.offences).to be_empty
-      end
-
-      it 'does not register an offence for #! on first line' do
-        inspect_source(lcs,
-                       ['#!/usr/bin/ruby',
-                        'test'])
-        expect(lcs.offences).to be_empty
-      end
-
-      it 'registers an offence for #! after the first line' do
-        inspect_source(lcs,
-                       ['test', '#!/usr/bin/ruby'])
-        expect(lcs.offences.size).to eq(1)
-      end
-    end
-  end
-end

data/spec/rubocop/cops/line_continuation_spec.rb

@@ -1,24 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe LineContinuation do
-      let(:lc) { LineContinuation.new }
-
-      it 'registers an offence for line continuation char' do
-        inspect_source(lc,
-                       ['test = 5 \\', '+ 5'])
-        expect(lc.offences.size).to eq(1)
-      end
-
-      it 'does not register an offence for cont char in a string' do
-        inspect_source(lc,
-                       ['result = "test string\\\n"',
-                        'more'])
-        expect(lc.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/line_length_spec.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe LineLength do
-      let(:ll) { LineLength.new }
-      before { LineLength.config = { 'Max' => 79 } }
-
-      it "registers an offence for a line that's 80 characters wide" do
-        ll.inspect(['#' * 80], nil, nil, nil)
-        expect(ll.offences.size).to eq(1)
-        expect(ll.offences.first.message).to eq('Line is too long. [80/79]')
-      end
-
-      it "accepts a line that's 79 characters wide" do
-        ll.inspect(['#' * 79], nil, nil, nil)
-        expect(ll.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/loop_spec.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe Loop do
-      let(:loop) { Loop.new }
-
-      it 'registers an offence for begin/end/while' do
-        inspect_source(loop, ['begin something; top; end while test'])
-        expect(loop.offences.size).to eq(1)
-      end
-
-      it 'registers an offence for begin/end/until' do
-        inspect_source(loop, ['begin something; top; end until test'])
-        expect(loop.offences.size).to eq(1)
-      end
-
-      it 'accepts normal while' do
-        inspect_source(loop, ['while test; one; two; end'])
-        expect(loop.offences).to be_empty
-      end
-
-      it 'accepts normal until' do
-        inspect_source(loop, ['until test; one; two; end'])
-        expect(loop.offences).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/method_and_variable_snake_case_spec.rb

@@ -1,93 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe MethodAndVariableSnakeCase do
-      let(:snake_case) { MethodAndVariableSnakeCase.new }
-
-      it 'registers an offence for camel case in instance method name' do
-        inspect_source(snake_case,
-                       ['def myMethod',
-                        '  # ...',
-                        'end',
-                       ])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'])
-      end
-
-      it 'registers an offence for camel case in singleton method name' do
-        inspect_source(snake_case,
-                       ['def self.myMethod',
-                        '  # ...',
-                        'end',
-                       ])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'])
-      end
-
-      it 'registers an offence for camel case in local variable name' do
-        inspect_source(snake_case, ['myLocal = 1'])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'])
-      end
-
-      it 'registers an offence for camel case in instance variable name' do
-        inspect_source(snake_case, ['@myAttribute = 3'])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'])
-      end
-
-      it 'registers an offence for camel case in setter name' do
-        inspect_source(snake_case, ['self.mySetter = 2'])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'])
-      end
-
-      it 'registers an offence for capitalized camel case' do
-        inspect_source(snake_case,
-                       ['def MyMethod',
-                        'end',
-                       ])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'])
-      end
-
-      it 'accepts snake case in names' do
-        inspect_source(snake_case,
-                       ['def my_method',
-                        '  my_local_html = 1',
-                        '  self.my_setter = 2',
-                        '  @my_attribute = 3',
-                        'end',
-                       ])
-        expect(snake_case.offences.map(&:message)).to be_empty
-      end
-
-      it 'registers an offence for mixed snake case and camel case' do
-        inspect_source(snake_case,
-                       ['def visit_Arel_Nodes_SelectStatement',
-                        'end'])
-        expect(snake_case.offences.map(&:message)).to eq(
-          ['Use snake_case for methods and variables.'])
-      end
-
-      it 'accepts screaming snake case globals' do
-        inspect_source(snake_case, ['$MY_GLOBAL = 0'])
-        expect(snake_case.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts screaming snake case constants' do
-        inspect_source(snake_case, ['MY_CONSTANT = 0'])
-        expect(snake_case.offences.map(&:message)).to be_empty
-      end
-
-      it 'accepts assigning to camel case constant' do
-        inspect_source(snake_case,
-                       ['Paren = Struct.new :left, :right, :kind'])
-        expect(snake_case.offences.map(&:message)).to be_empty
-      end
-    end
-  end
-end

data/spec/rubocop/cops/method_length_spec.rb

@@ -1,147 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Rubocop
-  module Cop
-    describe MethodLength do
-      let(:method_length) { MethodLength.new }
-      before { MethodLength.config = { 'Max' => 5, 'CountComments' => false } }
-
-      it 'rejects a method with more than 5 lines' do
-        inspect_source(method_length, ['def m()',
-                                       '  a = 1',
-                                       '  a = 2',
-                                       '  a = 3',
-                                       '  a = 4',
-                                       '  a = 5',
-                                       '  a = 6',
-                                       'end'])
-        expect(method_length.offences.size).to eq(1)
-        expect(method_length.offences.map(&:line_number).sort).to eq([1])
-      end
-
-      it 'accepts a method with less than 5 lines' do
-        inspect_source(method_length, ['def m()',
-                                       '  a = 1',
-                                       '  a = 2',
-                                       '  a = 3',
-                                       '  a = 4',
-                                       'end'])
-        expect(method_length.offences).to be_empty
-      end
-
-      it 'does not count blank lines' do
-        inspect_source(method_length, ['def m()',
-                                       '  a = 1',
-                                       '  a = 2',
-                                       '  a = 3',
-                                       '  a = 4',
-                                       '',
-                                       '',
-                                       '  a = 7',
-                                       'end'])
-        expect(method_length.offences).to be_empty
-      end
-
-      it 'accepts empty methods' do
-        inspect_source(method_length, ['def m()',
-                                       'end'])
-        expect(method_length.offences).to be_empty
-      end
-
-      it 'is not fooled by one-liner methods, syntax #1' do
-        inspect_source(method_length, ['def one_line; 10 end',
-                                       'def self.m()',
-                                       '  a = 1',
-                                       '  a = 2',
-                                       '  a = 4',
-                                       '  a = 5',
-                                       '  a = 6',
-                                       'end'])
-        expect(method_length.offences).to be_empty
-      end
-
-      it 'is not fooled by one-liner methods, syntax #2' do
-        inspect_source(method_length, ['def one_line(test) 10 end',
-                                       'def self.m()',
-                                       '  a = 1',
-                                       '  a = 2',
-                                       '  a = 4',
-                                       '  a = 5',
-                                       '  a = 6',
-                                       'end'])
-        expect(method_length.offences).to be_empty
-      end
-
-      it 'checks class methods, syntax #1' do
-        inspect_source(method_length, ['def self.m()',
-                                       '  a = 1',
-                                       '  a = 2',
-                                       '  a = 3',
-                                       '  a = 4',
-                                       '  a = 5',
-                                       '  a = 6',
-                                       'end'])
-        expect(method_length.offences.size).to eq(1)
-        expect(method_length.offences.map(&:line_number).sort).to eq([1])
-      end
-
-      it 'checks class methods, syntax #2' do
-        inspect_source(method_length, ['class K',
-                                       '  class << self',
-                                       '    def m()',
-                                       '      a = 1',
-                                       '      a = 2',
-                                       '      a = 3',
-                                       '      a = 4',
-                                       '      a = 5',
-                                       '      a = 6',
-                                       '    end',
-                                       '  end',
-                                       'end'])
-        expect(method_length.offences.size).to eq(1)
-        expect(method_length.offences.map(&:line_number).sort).to eq([3])
-      end
-
-      it 'properly counts lines when method ends with block' do
-        inspect_source(method_length, ['def m()',
-                                       '  something do',
-                                       '    a = 2',
-                                       '    a = 3',
-                                       '    a = 4',
-                                       '    a = 5',
-                                       '  end',
-                                       'end'])
-        expect(method_length.offences.size).to eq(1)
-        expect(method_length.offences.map(&:line_number).sort).to eq([1])
-      end
-
-      it 'does not count commented lines by default' do
-        inspect_source(method_length, ['def m()',
-                                       '  a = 1',
-                                       '  #a = 2',
-                                       '  a = 3',
-                                       '  #a = 4',
-                                       '  a = 5',
-                                       '  a = 6',
-                                       'end'])
-        expect(method_length.offences).to be_empty
-      end
-
-      it 'has the option of counting commented lines' do
-        MethodLength.config['CountComments'] = true
-        inspect_source(method_length, ['def m()',
-                                       '  a = 1',
-                                       '  #a = 2',
-                                       '  a = 3',
-                                       '  #a = 4',
-                                       '  a = 5',
-                                       '  a = 6',
-                                       'end'])
-        expect(method_length.offences.size).to eq(1)
-        expect(method_length.offences.map(&:line_number).sort).to eq([1])
-      end
-    end
-  end
-end