rubocop 0.11.1 → 0.12.0

data/lib/rubocop/cop/style/method_and_variable_snake_case.rb

@@ -10,51 +10,66 @@ module Rubocop
         MSG = 'Use snake_case for methods and variables.'
         SNAKE_CASE = /^@?[\da-z_]+[!?=]?$/
 
-        # http://phrogz.net/programmingruby/language.html#table_18.4
-        OPERATOR_METHODS = %w(
-          | ^ & <=> == === =~ > >= < <= << >>
-          + - * / % ** ~ +@ -@ [] []= ` ! != !~
-        ).map(&:to_sym)
-
         def investigate(processed_source)
           ast = processed_source.ast
           return unless ast
           on_node([:def, :defs, :lvasgn, :ivasgn, :send], ast) do |n|
-            name = case n.type
-                   when :def
-                     name_of_instance_method(n)
-                   when :defs
-                     name_of_singleton_method(n)
-                   when :lvasgn, :ivasgn
-                     name_of_variable(n)
-                   when :send
-                     name_of_setter(n)
-                   end
-
-            next unless name
+            range = case n.type
+                    when :def             then name_of_instance_method(n)
+                    when :defs            then name_of_singleton_method(n)
+                    when :lvasgn, :ivasgn then name_of_variable(n)
+                    when :send            then name_of_setter(n)
+                    end
+
+            next unless range
+            name = range.source.to_sym
             next if name =~ SNAKE_CASE || OPERATOR_METHODS.include?(name)
 
-            add_offence(:convention, n.location.expression, MSG)
+            add_offence(:convention, range, MSG)
           end
         end
 
         def name_of_instance_method(def_node)
-          def_node.children.first
+          expr = def_node.loc.expression
+          match = /^def(\s+)([\w]+[!?=]?\b)/.match(expr.source)
+          return unless match
+          space, method_name = match.captures
+          begin_pos = expr.begin_pos + 'def'.length + space.length
+          Parser::Source::Range.new(expr.source_buffer, begin_pos,
+                                    begin_pos + method_name.length)
         end
 
         def name_of_singleton_method(defs_node)
-          defs_node.children[1]
+          scope, method_name, _args, _body = *defs_node
+          after_dot(defs_node, method_name.length,
+                    "def\s+" + Regexp.escape(scope.loc.expression.source))
         end
 
         def name_of_variable(vasgn_node)
-          vasgn_node.children.first
+          expr = vasgn_node.loc.expression
+          name = vasgn_node.children.first
+          Parser::Source::Range.new(expr.source_buffer, expr.begin_pos,
+                                    expr.begin_pos + name.length)
         end
 
         def name_of_setter(send_node)
           receiver, method_name = *send_node
-          return nil unless receiver && receiver.type == :self
-          return nil unless method_name.to_s.end_with?('=')
-          method_name
+          return unless receiver && receiver.type == :self
+          return unless method_name.to_s.end_with?('=')
+          after_dot(send_node, method_name.length - '='.length,
+                    Regexp.escape(receiver.loc.expression.source))
+        end
+
+        # Returns a range containing the method name after the given regexp and
+        # a dot.
+        def after_dot(node, method_name_length, regexp)
+          expr = node.loc.expression
+          match = /\A#{regexp}\s*\.\s*/.match(expr.source)
+          return unless match
+          offset = match[0].length
+          begin_pos = expr.begin_pos + offset
+          Parser::Source::Range.new(expr.source_buffer, begin_pos,
+                                    begin_pos + method_name_length)
         end
       end
     end

data/lib/rubocop/cop/style/method_call_parentheses.rb

@@ -12,6 +12,14 @@ module Rubocop
 
           if args.empty? && node.loc.begin
             add_offence(:convention, node.loc.begin, MSG)
+            do_autocorrect(node)
+          end
+        end
+
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
           end
         end
       end

data/lib/rubocop/cop/style/multiline_if_then.rb

@@ -23,7 +23,7 @@ module Rubocop
           next_thing = if body && body.loc.expression
                          body.loc.expression.begin
                        elsif else_clause && else_clause.loc.expression
-                        else_clause.loc.expression.begin
+                         else_clause.loc.expression.begin
                        else
                          node.loc.end # No body, use "end".
                        end

data/lib/rubocop/cop/style/nil_comparison.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for comparison of something with nil using ==.
+      #
+      # @example
+      #
+      #  # bad
+      #  if x == nil
+      #  if x != nil
+      #
+      #  # good
+      #  if x.nil?
+      #  if !x.nil?
+      class NilComparison < Cop
+        MSG = 'Prefer the use of the nil? predicate.'
+
+        OPS = %w(== === !=)
+
+        NIL_NODE = s(:nil)
+
+        def on_send(node)
+          op = node.loc.selector.source
+
+          if OPS.include?(op)
+            _receiver, _method, args = *node
+
+            if args == NIL_NODE
+              add_offence(:convention, node.loc.selector, MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/signal_exception.rb

@@ -15,12 +15,22 @@ module Rubocop
           check_for_fail(rescue_node)
         end
 
+        def autocorrect_action(node)
+          @corrections << lambda do |corrector|
+            name = command?(:raise, node) ? 'fail' : 'raise'
+            corrector.replace(node.loc.selector, name)
+          end
+        end
+
+        private
+
         def check_for_raise(node)
           return unless node
 
           on_node(:send, node, :rescue) do |send_node|
             if command?(:raise, send_node)
               add_offence(:convention, send_node.loc.selector, FAIL_MSG)
+              do_autocorrect(send_node)
             end
           end
         end
@@ -31,6 +41,7 @@ module Rubocop
           on_node(:send, node, :rescue) do |send_node|
             if command?(:fail, send_node)
               add_offence(:convention, send_node.loc.selector, RAISE_MSG)
+              do_autocorrect(send_node)
             end
           end
         end

data/lib/rubocop/cop/style/space_after_method_name.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for space between a method name and a left parenthesis.
+      class SpaceAfterMethodName < Cop
+        MSG = 'Never put a space between a method name and the opening ' +
+          'parenthesis.'
+
+        def on_def(node)
+          _method_name, args, _body = *node
+          check(args)
+        end
+
+        def on_defs(node)
+          _scope, _method_name, args, _body = *node
+          check(args)
+        end
+
+        def check(args)
+          return unless args.loc.begin && args.loc.begin.is?('(')
+          expr = args.loc.expression
+          pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,
+                                                            expr.begin_pos - 1,
+                                                            expr.begin_pos)
+          if pos_before_left_paren.source =~ /\s/
+            add_offence(:convention, pos_before_left_paren, MSG)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/util.rb

@@ -22,6 +22,23 @@ module Rubocop
       def block_length(block_node)
         block_node.loc.end.line - block_node.loc.begin.line
       end
+
+      def const_name(node)
+        return nil if node.nil? || node.type != :const
+
+        const_names = []
+        const_node = node
+
+        loop do
+          namespace_node, name = *const_node
+          const_names << name
+          break unless namespace_node
+          break if namespace_node.type == :cbase
+          const_node = namespace_node
+        end
+
+        const_names.reverse.join('::')
+      end
     end
   end
 end

data/lib/rubocop/formatter/emacs_style_formatter.rb

@@ -4,8 +4,8 @@ module Rubocop
   module Formatter
     # This formatter displays the report data in format that's
     # easy to process in the Emacs text editor.
-    class EmacsStyleFormatter < SimpleTextFormatter
-      def report_file(file, offences)
+    class EmacsStyleFormatter < BaseFormatter
+      def file_finished(file, offences)
         offences.each do |o|
           output.printf("%s:%d:%d: %s: %s\n",
                         file, o.line, o.real_column, o.encode_severity,

data/lib/rubocop/formatter/file_list_formatter.rb

@@ -9,8 +9,9 @@ module Rubocop
     #
     # /some/file
     # /some/other/file
-    class FileListFormatter < SimpleTextFormatter
-      def report_file(file, offences)
+    class FileListFormatter < BaseFormatter
+      def file_finished(file, offences)
+        return if offences.empty?
         output.printf("%s\n", file)
       end
     end

data/lib/rubocop/formatter/formatter_set.rb

@@ -12,15 +12,12 @@ module Rubocop
         'clang'    => ClangStyleFormatter,
         'emacs'    => EmacsStyleFormatter,
         'json'     => JSONFormatter,
-        'files'    => FileListFormatter
+        'files'    => FileListFormatter,
+        'offences' => OffenceCountFormatter
       }
 
       FORMATTER_APIS = [:started, :file_started, :file_finished, :finished]
 
-      def initialize(report_summary = true)
-        @reports_summary = report_summary
-      end
-
       FORMATTER_APIS.each do |method_name|
         define_method(method_name) do |*args|
           each { |f| f.send(method_name, *args) }
@@ -39,12 +36,7 @@ module Rubocop
 
         output = output_path ? File.open(output_path, 'w') : $stdout
 
-        formatter = formatter_class.new(output)
-        if formatter.respond_to?(:reports_summary=)
-          # TODO: Consider dropping -s/--silent option
-          formatter.reports_summary = @reports_summary
-        end
-        self << formatter
+        self << formatter_class.new(output)
       end
 
       def close_output_files

data/lib/rubocop/formatter/offence_count_formatter.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Rubocop
+  module Formatter
+    # This formatter displays the list of offended cops with a count of how
+    # many offences of their kind were found. Ordered by desc offence count
+    #
+    # Here's the format:
+    #
+    # (26)  LineLength
+    # (3)   OneLineConditional
+    class OffenceCountFormatter < BaseFormatter
+
+      attr_reader :offence_counts
+
+      def started(target_files)
+        super
+        @offence_counts = Hash.new(0)
+      end
+
+      def file_finished(file, offences)
+        offences.each { |o| @offence_counts[o.cop_name] += 1 }
+      end
+
+      def finished(inspected_files)
+        report_summary(inspected_files.count,
+                       ordered_offence_counts(@offence_counts))
+      end
+
+      def report_summary(file_count, offence_counts)
+        output.puts
+
+        offence_count = total_offence_count(offence_counts)
+        offence_counts.each do |cop_name, count|
+          output.puts "#{count.to_s.ljust(offence_count.to_s.length + 2)}" +
+                      "#{cop_name}\n"
+        end
+        output.puts
+      end
+
+      def ordered_offence_counts(offence_counts)
+        Hash[offence_counts.sort_by { |k, v| v }.reverse]
+      end
+
+      def total_offence_count(offence_counts = {})
+        offence_counts.values.inject(0, :+)
+      end
+    end
+  end
+end

data/lib/rubocop/formatter/progress_formatter.rb

@@ -30,8 +30,6 @@ module Rubocop
       def finished(inspected_files)
         output.puts
 
-        return unless reports_summary?
-
         unless @offences_for_files.empty?
           output.puts
           output.puts 'Offences:'

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -6,9 +6,6 @@ module Rubocop
     # Offences are displayed at compact form - just the
     # location of the problem and the associated message.
     class SimpleTextFormatter < BaseFormatter
-      attr_accessor :reports_summary
-      alias_method :reports_summary?, :reports_summary
-
       def started(target_files)
         @total_offence_count = 0
       end
@@ -20,9 +17,7 @@ module Rubocop
       end
 
       def finished(inspected_files)
-        if reports_summary?
-          report_summary(inspected_files.count, @total_offence_count)
-        end
+        report_summary(inspected_files.count, @total_offence_count)
       end
 
       def report_file(file, offences)

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module Rubocop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '0.11.1'
+    STRING = '0.12.0'
 
     MSG = '%s (using Parser %s, running on %s %s %s)'
 

data/spec/project_spec.rb

@@ -9,5 +9,12 @@ describe 'RuboCop Project' do
       expect(Rubocop::Config.load_file('config/default.yml').keys.sort)
         .to eq((['AllCops'] + cop_names).sort)
     end
+    it 'has a description for all cops' do
+      cop_names = Rubocop::Cop::Cop.all.map(&:cop_name)
+      conf = Rubocop::Config.load_file('config/default.yml')
+      cop_names.each do |name|
+        expect(conf[name]['Description']).not_to be_nil
+      end
+    end
   end
 end

data/spec/rubocop/cli_spec.rb

@@ -44,6 +44,8 @@ Usage: rubocop [options] [file1, file2, ...]
         --only COP                   Run just one cop.
         --auto-gen-config            Generate a configuration file acting as a
                                      TODO list.
+        --show-cops                  Shows cops and their config for the
+                                     current directory.
     -f, --format FORMATTER           Choose an output formatter. This option
                                      can be specified multiple times to enable
                                      multiple formatters at the same time.
@@ -53,6 +55,7 @@ Usage: rubocop [options] [file1, file2, ...]
                                        [e]macs
                                        [j]son
                                        [f]iles
+                                       [o]ffences
                                        custom formatter class name
     -o, --out FILE                   Write output to a file instead of STDOUT.
                                      This option applies to the previously
@@ -62,7 +65,6 @@ Usage: rubocop [options] [file1, file2, ...]
     -R, --rails                      Run extra Rails cops.
     -l, --lint                       Run only lint cops.
     -a, --auto-correct               Auto-correct offences.
-    -s, --silent                     Silence summary.
     -n, --no-color                   Disable color output.
     -v, --version                    Display version.
     -V, --verbose-version            Display verbose version.
@@ -207,8 +209,6 @@ Usage: rubocop [options] [file1, file2, ...]
          "#{abs('example1.rb')}:2:2: C: Trailing whitespace detected.",
          "#{abs('example2.rb')}:1:1: C: Missing utf-8 encoding comment.",
          "#{abs('example2.rb')}:1:1: C: Tab detected.",
-         '',
-         '2 files inspected, 6 offences detected',
          ''].join("\n"))
     end
 
@@ -231,8 +231,6 @@ Usage: rubocop [options] [file1, file2, ...]
          "#{abs('example1.rb')}:1:5: C: Trailing whitespace detected.",
          "#{abs('example1.rb')}:2:2: C: Trailing whitespace detected.",
          "#{abs('example2.rb')}:1:1: C: Tab detected.",
-         '',
-         '2 files inspected, 4 offences detected',
          ''].join("\n"))
     end
 
@@ -243,9 +241,18 @@ Usage: rubocop [options] [file1, file2, ...]
                                   'y ',
                                   'puts x'])
       create_file('example2.rb', ['# encoding: utf-8',
-                                  "\tx = 0",
-                                  'puts x'])
-      expect(cli.run(['--format', 'clang', 'example1.rb', 'example2.rb']))
+                                  "\tx",
+                                  'def a',
+                                  '   puts',
+                                  'end'])
+      create_file('example3.rb', ['# encoding: utf-8',
+                                  'def badName',
+                                  '  if something',
+                                  '    test',
+                                  '    end',
+                                  'end'])
+      expect(cli.run(['--format', 'clang', 'example1.rb', 'example2.rb',
+                      'example3.rb']))
         .to eq(1)
       expect($stdout.string)
         .to eq(['example1.rb:2:2: C: Surrounding space missing for operator ' +
@@ -264,10 +271,26 @@ Usage: rubocop [options] [file1, file2, ...]
                 'y ',
                 ' ^',
                 'example2.rb:2:1: C: Tab detected.',
-                "\tx = 0",
-                '^',
+                "\tx",
+                '^^^^^',
+                'example2.rb:4:1: C: Use 2 (not 3) spaces for indentation.',
+                '   puts',
+                '^^^',
+                'example3.rb:2:5: C: Use snake_case for methods and ' +
+                'variables.',
+                'def badName',
+                '    ^^^^^^^',
+                'example3.rb:3:3: C: Favor modifier if/unless usage when ' +
+                'you have a single-line body. Another good alternative is ' +
+                'the usage of control flow &&/||.',
+                '  if something',
+                '  ^^',
+                'example3.rb:5:5: W: end at 5, 4 is not aligned with if at ' +
+                '3, 2',
+                '    end',
+                '    ^^^',
                 '',
-                '2 files inspected, 5 offences detected',
+                '3 files inspected, 9 offences detected',
                 ''].join("\n"))
     end
 
@@ -387,34 +410,80 @@ Usage: rubocop [options] [file1, file2, ...]
       expect($stderr.string).to eq("Unrecognized cop name: 123.\n")
     end
 
-    it 'ommits summary when --silent passed', ruby: 1.9 do
-      create_file('example1.rb', 'puts 0 ')
-      create_file('example2.rb', "\tputs 0")
-      expect(cli.run(['--format',
-                      'emacs',
-                      '--silent',
-                      'example1.rb',
-                      'example2.rb'])).to eq(1)
-      expect($stdout.string).to eq(
-        ["#{abs('example1.rb')}:1:1: C: Missing utf-8 encoding comment.",
-         "#{abs('example1.rb')}:1:7: C: Trailing whitespace detected.",
-         "#{abs('example2.rb')}:1:1: C: Missing utf-8 encoding comment.",
-         "#{abs('example2.rb')}:1:1: C: Tab detected.",
-         ''].join("\n"))
-    end
+    context '--show-cops' do
+      let(:cops) { Cop::Cop.all }
+      let(:global_conf) do
+        config_path = Rubocop::Config.configuration_file_for(Dir.pwd.to_s)
+        Rubocop::Config.configuration_from_file(config_path)
+      end
+      before do
+        cops.each do |cop_class|
+          cop_class.config = global_conf.for_cop(cop_class.cop_name)
+        end
+      end
 
-    it 'ommits summary when --silent passed', ruby: 2.0 do
-      create_file('example1.rb', 'puts 0 ')
-      create_file('example2.rb', "\tputs 0")
-      expect(cli.run(['--format',
-                      'emacs',
-                      '--silent',
-                      'example1.rb',
-                      'example2.rb'])).to eq(1)
-      expect($stdout.string).to eq(
-        ["#{abs('example1.rb')}:1:7: C: Trailing whitespace detected.",
-         "#{abs('example2.rb')}:1:1: C: Tab detected.",
-         ''].join("\n"))
+      subject do
+        expect { cli.run ['--show-cops'] }.to exit_with_code(0)
+        @stdout = $stdout.string
+      end
+      it 'prints all available cops and their description' do
+        subject
+        cops.each do |cop|
+          expect(@stdout).to include cop.cop_name
+          expect(@stdout).to include cop.short_description
+        end
+      end
+
+      it 'prints all types' do
+        subject
+        cops
+          .types
+          .dup
+          .map!(&:to_s)
+          .map!(&:capitalize)
+          .each { |type| expect(@stdout).to include(type) }
+      end
+
+      it 'prints all cops in their right type listing' do
+        subject
+        lines = @stdout.lines
+        lines.slice_before(/Type /).each do |slice|
+          types = cops.types.dup.map!(&:to_s).map!(&:capitalize)
+          current = types.delete(slice.shift[/Type '(?<c>[^'']+)'/, 'c'])
+          # all cops in their type listing
+          cops.with_type(current).each do |cop|
+            expect(slice.any? { |l| l.include? cop.cop_name }).to be_true
+          end
+
+          # no cop in wrong type listing
+          types.each do |type|
+            cops.with_type(type).each do |cop|
+              expect(slice.any? { |l| l.include? cop.cop_name }).to be_false
+            end
+          end
+        end
+      end
+
+      it 'prints the current configuration' do
+        subject
+        out = @stdout.lines.to_a
+        cops.each do |cop|
+          conf = global_conf[cop.cop_name].dup
+          confstrt = out.find_index { |i| i.include?("- #{cop.cop_name}") } + 1
+          c = out[confstrt, conf.keys.size].to_s
+          conf.delete('Description')
+          expect(c).to include(cop.short_description)
+          conf.each do |k, v|
+            # ugly hack to get hash/array content tested
+            if v.kind_of?(Hash) || v.kind_of?(Array)
+              expect(c).to include "#{k}: #{v.to_s.dump[2, -2]}"
+            else
+              expect(c).to include "#{k}: #{v}"
+            end
+
+          end
+        end
+      end
     end
 
     it 'shows config files when --debug is passed', ruby: 2.0 do
@@ -437,7 +506,6 @@ Usage: rubocop [options] [file1, file2, ...]
       create_file('example1.rb', "\tputs 0")
       expect(cli.run(['--format',
                       'emacs',
-                      '--silent',
                       '--debug',
                       'example1.rb'])).to eq(1)
       expect($stdout.string.lines[-1]).to eq(
@@ -718,8 +786,6 @@ Usage: rubocop [options] [file1, file2, ...]
       expect($stdout.string)
         .to eq(["#{abs('example.rb')}:3:3: E: unexpected " +
                 'token $end',
-                '',
-                '1 file inspected, 1 offence detected',
                 ''].join("\n"))
     end
 
@@ -732,8 +798,6 @@ Usage: rubocop [options] [file1, file2, ...]
       expect($stdout.string)
         .to eq(["#{abs('example.rb')}:2:6: W: " +
                 "`*' interpreted as argument prefix",
-                '',
-                '1 file inspected, 1 offence detected',
                 ''].join("\n"))
     end
 
@@ -766,8 +830,6 @@ Usage: rubocop [options] [file1, file2, ...]
         ["#{abs('example.rb')}:8:80: C: Line is too long. [95/79]",
          "#{abs('example.rb')}:10:5: C: Prefer single-quoted strings when " +
          "you don't need string interpolation or special symbols.",
-         '',
-         '1 file inspected, 2 offences detected',
          ''].join("\n"))
     end
 
@@ -792,8 +854,6 @@ Usage: rubocop [options] [file1, file2, ...]
         ["#{abs('example.rb')}:8:80: C: Line is too long. [95/79]",
          "#{abs('example.rb')}:10:5: C: Prefer single-quoted strings when " +
          "you don't need string interpolation or special symbols.",
-         '',
-         '1 file inspected, 2 offences detected',
          ''].join("\n"))
     end
 
@@ -803,10 +863,7 @@ Usage: rubocop [options] [file1, file2, ...]
         'y("123", 123456) # rubocop:disable all'
       ])
       expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(0)
-      expect($stdout.string).to eq(
-        ['',
-         '1 file inspected, no offences detected',
-         ''].join("\n"))
+      expect($stdout.string).to be_empty
     end
 
     it 'can have selected cops disabled on a single line' do
@@ -819,8 +876,6 @@ Usage: rubocop [options] [file1, file2, ...]
       expect(cli.run(['--format', 'emacs', 'example.rb'])).to eq(1)
       expect($stdout.string).to eq(
         ["#{abs('example.rb')}:3:80: C: Line is too long. [95/79]",
-         '',
-         '1 file inspected, 1 offence detected',
          ''].join("\n"))
     end
 
@@ -1033,6 +1088,15 @@ Usage: rubocop [options] [file1, file2, ...]
           expect($stderr.string).to include('invalid option: --emacs')
         end
       end
+
+      describe '-s/--silent option' do
+        it 'raises error in RuboCop 1.0.0' do
+          # This spec can be removed
+          # once CLI#ignore_dropped_options is removed.
+          expect(cli.run(['--silent'])).to eq(1)
+          expect($stderr.string).to include('invalid option: --silent')
+        end
+      end
     end
 
     describe '-o/--out option' do
@@ -1067,18 +1131,16 @@ Usage: rubocop [options] [file1, file2, ...]
 
         expect(File.read('emacs_output.txt')).to eq([
           "#{abs(target_file)}:2:80: C: Line is too long. [90/79]",
-          '',
-          '1 file inspected, 1 offence detected',
           ''
         ].join("\n"))
       end
     end
 
     describe '#display_error_summary' do
-      it 'displays an error message when errors are present' do
+      it 'displays an error message to stderr when errors are present' do
         msg = 'An error occurred while Encoding cop was inspecting file.rb.'
         cli.display_error_summary([msg])
-        expect($stdout.string.lines.to_a[-6..-5])
+        expect($stderr.string.lines.to_a[-6..-5])
           .to eq(["1 error occurred:\n", "#{msg}\n"])
       end
     end