rubocop 0.7.2 → 0.8.0

data/lib/rubocop/version.rb

@@ -2,6 +2,6 @@
 
 module Rubocop
   module Version
-    STRING = '0.7.2'
+    STRING = '0.8.0'
   end
 end

data/rubocop.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
   s.summary = 'Automatic Ruby code style checking tool.'
 
   s.add_runtime_dependency('rainbow', '>= 1.1.4')
+  s.add_runtime_dependency('parser', '~> 2.0.0.beta2')
   s.add_development_dependency('rake', '~> 10.0')
   s.add_development_dependency('rspec', '~> 2.13')
   s.add_development_dependency('yard', '~> 0.8')

data/spec/project_spec.rb

@@ -11,7 +11,7 @@ describe 'RuboCop Project' do
     end
   end
 
-  describe 'source codes' do
+  describe 'source codes', broken: true do
     before { $stdout = StringIO.new }
     after  { $stdout = STDOUT }
 

data/spec/rubocop/cli_spec.rb

@@ -176,17 +176,22 @@ module Rubocop
     end
 
     it 'runs just one cop if --only is passed' do
-      create_file('example.rb', [
-        'x= 0 ',
-        'y '
-      ])
-      expect(cli.run(['--only', 'TrailingWhitespace', 'example.rb'])).to eq(1)
+      create_file('example.rb', ['if x== 0 ',
+                                 "\ty",
+                                 'end'])
+      # IfUnlessModifier depends on the configuration of LineLength.
+      # That configuration might have been set by other spec examples
+      # so we reset it to emulate a start from scratch.
+      Cop::LineLength.config = nil
+
+      expect(cli.run(['--only', 'IfUnlessModifier', 'example.rb'])).to eq(1)
       expect($stdout.string)
         .to eq(['== example.rb ==',
-                'C:  1: Trailing whitespace detected.',
-                'C:  2: Trailing whitespace detected.',
+                'C:  1: Favor modifier if/unless usage when you have a ' +
+                'single-line body. Another good alternative is the usage of ' +
+                'control flow &&/||.',
                 '',
-                '1 file inspected, 2 offences detected',
+                '1 file inspected, 1 offence detected',
                 ''].join("\n"))
     end
 
@@ -400,6 +405,7 @@ module Rubocop
     end
 
     it 'registers an offence for a syntax error' do
+      pending
       create_file('example.rb', [
         '# encoding: utf-8',
         'class Test',
@@ -416,9 +422,10 @@ module Rubocop
     end
 
     it 'can process a file with an invalid UTF-8 byte sequence' do
+      pending
       create_file('example.rb', [
         '# encoding: utf-8',
-        "# \xf9\x29"
+        "# #{'f9'.hex.chr}#{'29'.hex.chr}"
       ])
       expect(cli.run(['--emacs', 'example.rb'])).to eq(0)
     end

data/spec/rubocop/config_spec.rb

@@ -208,7 +208,7 @@ describe Rubocop::Config do
     end
   end
 
-  describe '#validate!', :isolated_environment do
+  describe '#validate', :isolated_environment do
     # TODO: Because Config.load_file now outputs the validation warning,
     #       it is inserting text into the rspec test output here.
     #       The next 2 lines should be removed eventually.
@@ -232,7 +232,7 @@ describe Rubocop::Config do
 
       it 'raises validation error' do
         expect do
-          configuration.validate!
+          configuration.validate
         end.to raise_error(Rubocop::Config::ValidationError) do |error|
           expect(error.message).to start_with('unrecognized cop LyneLenth')
         end
@@ -250,7 +250,7 @@ describe Rubocop::Config do
 
       it 'raises validation error' do
         expect do
-          configuration.validate!
+          configuration.validate
         end.to raise_error(Rubocop::Config::ValidationError) do |error|
           expect(error.message).to
             start_with('unrecognized parameter LineLength:Min')
@@ -396,4 +396,14 @@ describe Rubocop::Config do
       end
     end
   end
+
+  describe 'configuration for SymbolName' do
+    describe 'AllowCamelCase' do
+      it 'is enabled by default' do
+        default_config = Rubocop::Config.default_configuration
+        symbol_name_config = default_config.for_cop('SymbolName')
+        expect(symbol_name_config['AllowCamelCase']).to be_true
+      end
+    end
+  end
 end

data/spec/rubocop/cops/access_control_spec.rb

@@ -0,0 +1,129 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Rubocop
+  module Cop
+    describe AccessControl do
+      let(:a) { AccessControl.new }
+
+      it 'registers an offence for misaligned private' do
+        inspect_source(a,
+                       ['class Test',
+                         '',
+                         'private',
+                         '',
+                         '  def test; end',
+                         'end'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([AccessControl::INDENT_MSG])
+      end
+
+      it 'registers an offence for misaligned private in module' do
+        inspect_source(a,
+                       ['module Test',
+                        '',
+                        'private',
+                        '',
+                        '  def test; end',
+                        'end'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([AccessControl::INDENT_MSG])
+      end
+
+      it 'registers an offence for misaligned private in singleton class' do
+        inspect_source(a,
+                       ['class << self',
+                         '',
+                         'private',
+                         '',
+                         '  def test; end',
+                         'end'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([AccessControl::INDENT_MSG])
+      end
+
+      it 'registers an offence for misaligned protected' do
+        inspect_source(a,
+                       ['class Test',
+                        '',
+                        'protected',
+                        '',
+                        '  def test; end',
+                        'end'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([AccessControl::INDENT_MSG])
+      end
+
+      it 'accepts properly indented private' do
+        inspect_source(a,
+                       ['class Test',
+                        '',
+                        '  private',
+                        '',
+                        '  def test; end',
+                        'end'])
+        expect(a.offences).to be_empty
+      end
+
+      it 'accepts properly indented protected' do
+        inspect_source(a,
+                       ['class Test',
+                        '',
+                        '  protected',
+                        '',
+                        '  def test; end',
+                        'end'])
+        expect(a.offences).to be_empty
+      end
+
+      it 'handles properly nested classes' do
+        inspect_source(a,
+                       ['class Test',
+                        '',
+                        '  class Nested',
+                        '',
+                        '  private',
+                        '',
+                        '    def a; end',
+                        '  end',
+                        '',
+                        '  protected',
+                        '',
+                        '  def test; end',
+                        'end'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([AccessControl::INDENT_MSG])
+      end
+
+      it 'requires blank line before private/protected' do
+        inspect_source(a,
+                       ['class Test',
+                        '  protected',
+                        '',
+                        '  def test; end',
+                        'end'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([AccessControl::BLANK_MSG])
+      end
+
+      it 'requires blank line after private/protected' do
+        inspect_source(a,
+                       ['class Test',
+                        '',
+                        '  protected',
+                        '  def test; end',
+                        'end'])
+        expect(a.offences.size).to eq(1)
+        expect(a.offences.map(&:message))
+          .to eq([AccessControl::BLANK_MSG])
+      end
+    end
+  end
+end

data/spec/rubocop/cops/alias_spec.rb

@@ -9,32 +9,28 @@ module Rubocop
 
       it 'registers an offence for alias with symbol args' do
         inspect_source(a,
-                       'file.rb',
                        ['alias :ala :bala'])
         expect(a.offences.size).to eq(1)
         expect(a.offences.map(&:message))
-          .to eq([Alias::ERROR_MESSAGE])
+          .to eq([Alias::MSG])
       end
 
       it 'registers an offence for alias with bareword args' do
         inspect_source(a,
-                       'file.rb',
                        ['alias ala bala'])
         expect(a.offences.size).to eq(1)
         expect(a.offences.map(&:message))
-          .to eq([Alias::ERROR_MESSAGE])
+          .to eq([Alias::MSG])
       end
 
       it 'does not register an offence for alias_method' do
         inspect_source(a,
-                       'file.rb',
                        ['alias_method :ala, :bala'])
         expect(a.offences).to be_empty
       end
 
       it 'does not register an offence for :alias' do
         inspect_source(a,
-                       'file.rb',
                        ['[:alias, :ala, :bala]'])
         expect(a.offences).to be_empty
       end

data/spec/rubocop/cops/align_parameters_spec.rb

@@ -8,43 +8,45 @@ module Rubocop
       let(:align) { AlignParameters.new }
 
       it 'registers an offence for parameters with single indent' do
-        inspect_source(align, 'file.rb', ['function(a,',
-                                          '  if b then c else d end)'])
-        expect(align.offences.map(&:message)).to eq(
-          ['Align the parameters of a method call if they span more than ' +
-           'one line.'])
+        inspect_source(align, ['function(a,',
+                               '  if b then c else d end)'])
+        expect(align.offences.size).to eq(1)
       end
 
       it 'registers an offence for parameters with double indent' do
-        inspect_source(align, 'file.rb', ['function(a,',
-                                          '    if b then c else d end)'])
-        expect(align.offences.map(&:message)).to eq(
-          ['Align the parameters of a method call if they span more than ' +
-           'one line.'])
+        inspect_source(align, ['function(a,',
+                               '    if b then c else d end)'])
+        expect(align.offences.size).to eq(1)
+      end
+
+      it 'accepts multiline []= method call' do
+        inspect_source(align, ['Test.config["something"] =',
+                                          ' true'])
+        expect(align.offences).to be_empty
       end
 
       it 'accepts correctly aligned parameters' do
-        inspect_source(align, 'file.rb', ['function(a,',
-                                          '         0, 1,',
-                                          '         (x + y),',
-                                          '         if b then c else d end)'])
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, ['function(a,',
+                               '         0, 1,',
+                               '         (x + y),',
+                               '         if b then c else d end)'])
+        expect(align.offences).to be_empty
       end
 
       it 'accepts calls that only span one line' do
-        inspect_source(align, 'file.rb', ['find(path, s, @special[sexp[0]])'])
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, ['find(path, s, @special[sexp[0]])'])
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by a symbol argument" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['add_offence(:convention, index,',
-                        '            ERROR_MESSAGE % kind)'])
-        expect(align.offences.map(&:message)).to be_empty
+                        '            MSG % kind)'])
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by splat operator" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['func1(*a,',
                         '      *b,',
                         '      c)',
@@ -59,7 +61,7 @@ module Rubocop
       end
 
       it "doesn't get confused by extra comma at the end" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['func1(a,',
                         '     b,)'])
         expect(align.offences.map(&:to_s)).to eq(
@@ -68,52 +70,52 @@ module Rubocop
       end
 
       it 'can handle a correctly aligned string literal as first argument' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['add_offence(:convention, x,',
                         '            a)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a string literal as other argument' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['add_offence(:convention,',
                         '            "", a)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by a line break inside a parameter" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['read(path, { headers:    true,',
                         '             converters: :numeric })'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by symbols with embedded expressions" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['send(:"#{name}_comments_path")'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it "doesn't get confused by regexen with embedded expressions" do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['a(/#{name}/)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'accepts braceless hashes' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['run(collection, :entry_name => label,',
                         '                :paginator  => paginator)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'accepts the first parameter being on a new row' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['  match(',
                         '    a,',
                         '    b',
                         '  )'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle heredoc strings' do
@@ -123,31 +125,31 @@ module Rubocop
                '              return value',
                '            end',
                '            EOS']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a method call within a method call' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['a(a1,',
                         '  b(b1,',
                         '    b2),',
                         '  a2)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a call embedded in a string' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['model("#{index(name)}", child)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle do-end' do
-        inspect_source(align, '',
+        inspect_source(align,
                        ['      run(lambda do |e|',
                         "        w = e['warden']",
                         '      end)'])
-        expect(align.offences.map(&:message)).to be_empty
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a call with a block inside another call' do
@@ -155,55 +157,40 @@ module Rubocop
                '    exec_query("info(\'#{row[\'name\']}\')").map { |col|',
                "      col['name']",
                '    })']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a ternary condition with a block reference' do
         src = ['cond ? a : func(&b)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle parentheses used with no parameters' do
         src = ['func()']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
-      end
-
-      it 'can handle a multiline hash as first parameter' do
-        src = ['assert_equal({',
-               '  :space_before => "",',
-               '}, state)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle a multiline hash as second parameter' do
         src = ['tag(:input, {',
                '  :value => value',
                '})']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle method calls without parentheses' do
         src = ['a(b c, d)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
 
       it 'can handle other method calls without parentheses' do
         src = ['chars(Unicode.apply_mapping @wrapped_string, :uppercase)']
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
-      end
-
-      it "doesn't check alignment if tabs are used to indent" do
-        src = ['a(b,',
-               "\tc)"]
-        inspect_source(align, '', src)
-        expect(align.offences.map(&:message)).to be_empty
+        inspect_source(align, src)
+        expect(align.offences).to be_empty
       end
     end
   end