rubocop 0.28.0 → 0.29.0

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

@@ -55,7 +55,8 @@ module RuboCop
         end
 
         def autocorrect(range)
-          @corrections << ->(corrector) { corrector.remove(range) } if range
+          fail CorrectionNotPossible unless range
+          @corrections << ->(corrector) { corrector.remove(range) }
         end
       end
     end

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

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks the spacing inside and after block parameters pipes.
+      #
+      # @example
+      #
+      #   # bad
+      #   {}.each { | x,  y |puts x }
+      #
+      #   # good
+      #   {}.each { |x, y| puts x }
+      class SpaceAroundBlockParameters < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_block(node)
+          _method, args, body = *node
+          opening_pipe, closing_pipe = args.loc.begin, args.loc.end
+          return unless opening_pipe
+
+          check_inside_pipes(args.children, opening_pipe, closing_pipe)
+
+          if body
+            check_space(closing_pipe.end_pos, body.loc.expression.begin_pos,
+                        closing_pipe, 'after closing `|`')
+          end
+
+          check_each_arg(args)
+        end
+
+        private
+
+        def parameter_name
+          'EnforcedStyleInsidePipes'
+        end
+
+        def check_inside_pipes(args, opening_pipe, closing_pipe)
+          first, last = args.first.loc.expression, args.last.loc.expression
+
+          if style == :no_space
+            check_no_space(opening_pipe.end_pos, first.begin_pos,
+                           'Space before first')
+            check_no_space(last.end_pos, closing_pipe.begin_pos,
+                           'Space after last')
+          elsif style == :space
+            check_space(opening_pipe.end_pos, first.begin_pos, first,
+                        'before first block parameter')
+            check_space(last.end_pos, closing_pipe.begin_pos, last,
+                        'after last block parameter')
+            check_no_space(opening_pipe.end_pos, first.begin_pos - 1,
+                           'Extra space before first')
+            check_no_space(last.end_pos + 1, closing_pipe.begin_pos,
+                           'Extra space after last')
+          end
+        end
+
+        def check_each_arg(args)
+          args.children[1..-1].each do |arg|
+            expr = arg.loc.expression
+            check_no_space(range_with_surrounding_space(expr, :left).begin_pos,
+                           expr.begin_pos - 1, 'Extra space before')
+          end
+        end
+
+        def check_space(space_begin_pos, space_end_pos, range, msg)
+          return if space_begin_pos != space_end_pos
+
+          add_offense(range, range, "Space #{msg} missing.")
+        end
+
+        def check_no_space(space_begin_pos, space_end_pos, msg)
+          return if space_begin_pos >= space_end_pos
+
+          range = Parser::Source::Range.new(processed_source.buffer,
+                                            space_begin_pos, space_end_pos)
+          add_offense(range, range, "#{msg} block parameter detected.")
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            case range.source
+            when /^\s+$/ then corrector.remove(range)
+            else              corrector.insert_after(range, ' ')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -24,14 +24,6 @@ module RuboCop
 
           wrong_quotes?(node, style)
         end
-
-        def autocorrect(node)
-          @corrections << lambda do |corrector|
-            replacement = node.loc.begin.is?('"') ? "'" : '"'
-            corrector.replace(node.loc.begin, replacement)
-            corrector.replace(node.loc.end, replacement)
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for inheritance from Struct.new.
+      #
+      # @example
+      #   # bad
+      #   class Person < Struct.new(:first_name, :last_name)
+      #   end
+      #
+      #   # good
+      #   Person = Struct.new(:first_name, :last_name)
+      class StructInheritance < Cop
+        MSG = "Don't extend an instance initialized by `Struct.new`."
+
+        def on_class(node)
+          _name, superclass, _body = *node
+          return unless struct_constructor?(superclass)
+
+          add_offense(node, superclass.loc.expression, MSG)
+        end
+
+        private
+
+        def struct_constructor?(node)
+          if node && node.send_type?
+            receiver, method_name = *node
+
+            receiver &&
+              receiver.const_type? &&
+              receiver.children.last == :Struct &&
+              method_name == :new
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -107,13 +107,17 @@ module RuboCop
             autocorrect_instance(node)
           elsif node.type == :defs && node.children.first.type == :self
             autocorrect_class(node)
+          else
+            fail CorrectionNotPossible
           end
         end
 
         def autocorrect_instance(node)
           method_name, args, body = *node
-          return unless names_match?(method_name, body)
-          return unless (kind = trivial_accessor_kind(method_name, args, body))
+          unless names_match?(method_name, body) &&
+                 (kind = trivial_accessor_kind(method_name, args, body))
+            fail CorrectionNotPossible
+          end
 
           @corrections << lambda do |corrector|
             corrector.replace(
@@ -125,8 +129,10 @@ module RuboCop
 
         def autocorrect_class(node)
           _, method_name, args, body = *node
-          return unless names_match?(method_name, body)
-          return unless (kind = trivial_accessor_kind(method_name, args, body))
+          unless names_match?(method_name, body) &&
+                 (kind = trivial_accessor_kind(method_name, args, body))
+            fail CorrectionNotPossible
+          end
 
           @corrections << lambda do |corrector|
             indent = ' ' * node.loc.column

data/lib/rubocop/cop/util.rb

@@ -141,16 +141,41 @@ module RuboCop
         Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
       end
 
-      def range_with_surrounding_space(range, side = :both)
-        src = @processed_source.buffer.source
-        go_left = side == :left || side == :both
-        go_right = side == :right || side == :both
-        begin_pos = range.begin_pos
+      def range_with_surrounding_comma(range, side = :both, buffer = nil)
+        buffer ||= @processed_source.buffer
+        src = buffer.source
+
+        if side == :both
+          go_left, go_right = true, true
+        else
+          go_left = side == :left
+          go_right = side == :right
+        end
+
+        begin_pos, end_pos = range.begin_pos, range.end_pos
+        begin_pos -= 1 if go_left && src[begin_pos - 1] == ','
+        end_pos += 1 if go_right && src[end_pos] == ','
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_with_surrounding_space(range, side = :both, buffer = nil)
+        buffer ||= @processed_source.buffer
+        src = buffer.source
+
+        if side == :both
+          go_left, go_right = true, true
+        else
+          go_left = side == :left
+          go_right = side == :right
+        end
+
+        begin_pos, end_pos = range.begin_pos, range.end_pos
         begin_pos -= 1 while go_left && src[begin_pos - 1] =~ /[ \t]/
-        end_pos = range.end_pos
+        begin_pos -= 1 if go_left && src[begin_pos - 1] == "\n"
         end_pos += 1 while go_right && src[end_pos] =~ /[ \t]/
         end_pos += 1 if go_right && src[end_pos] == "\n"
-        Parser::Source::Range.new(@processed_source.buffer, begin_pos, end_pos)
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
       def begins_its_line?(range)

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -97,21 +97,6 @@ module RuboCop
         message = offense.corrected? ? green('[Corrected] ') : ''
         message << annotate_message(offense.message)
       end
-
-      def pluralize(number, thing, options = {})
-        text = ''
-
-        if number == 0 && options[:no_for_zero]
-          text = 'no'
-        else
-          text << number.to_s
-        end
-
-        text << " #{thing}"
-        text << 's' unless number == 1
-
-        text
-      end
     end
   end
 end

data/lib/rubocop/options.rb

@@ -9,6 +9,7 @@ module RuboCop
       only:              'Run only the given cop(s).',
       only_guide_cops:  ['Run only cops for rules that link to a',
                          'style guide.'],
+      except:            'Disable the given cop(s).',
       require:           'Require Ruby file.',
       config:            'Specify configuration file.',
       auto_gen_config:  ['Generate a configuration file acting as a',
@@ -34,7 +35,8 @@ module RuboCop
                          'This option applies to the previously',
                          'specified --format, or the default format',
                          'if no format is specified.'],
-      fail_level:        'Minimum severity for exit with error code.',
+      fail_level:       ['Minimum severity (A/R/C/W/E/F) for exit',
+                         'with error code.'],
       show_cops:        ['Shows the given cops, or all cops by',
                          'default, and their configurations for the',
                          'current directory.'],
@@ -62,9 +64,6 @@ module RuboCop
     end
 
     def parse(args)
-      ignore_dropped_options(args)
-      convert_deprecated_options(args)
-
       define_options(args).parse!(args)
 
       validate_compatibility
@@ -72,6 +71,19 @@ module RuboCop
       [@options, args]
     end
 
+    # Cop name validation must be done later than option parsing, so it's not
+    # called from within this class.
+    def self.validate_cop_list(names)
+      return unless names
+
+      namespaces = Cop::Cop.all.types.map { |t| t.to_s.capitalize }
+      names.each do |name|
+        next if Cop::Cop.all.any? { |c| c.cop_name == name } ||
+                namespaces.include?(name)
+        fail ArgumentError, "Unrecognized cop or namespace: #{name}."
+      end
+    end
+
     private
 
     def define_options(args)
@@ -96,13 +108,17 @@ module RuboCop
     end
 
     def add_only_options(opts)
-      option(opts, '--only [COP1,COP2,...]') do |list|
-        @options[:only] = list.split(',').map do |c|
-          Cop::Cop.qualified_cop_name(c, '--only option')
+      add_cop_selection_csv_option('except', opts)
+      add_cop_selection_csv_option('only', opts)
+      option(opts, '--only-guide-cops')
+    end
+
+    def add_cop_selection_csv_option(option, opts)
+      option(opts, "--#{option} [COP1,COP2,...]") do |list|
+        @options[:"#{option}"] = list.split(',').map do |c|
+          Cop::Cop.qualified_cop_name(c, "--#{option} option")
         end
       end
-
-      option(opts, '--only-guide-cops')
     end
 
     def add_configuration_options(opts, args)
@@ -131,9 +147,10 @@ module RuboCop
     end
 
     def add_severity_option(opts)
+      table = RuboCop::Cop::Severity::CODE_TABLE.merge(A: :autocorrect)
       option(opts, '--fail-level SEVERITY',
-             RuboCop::Cop::Severity::NAMES,
-             RuboCop::Cop::Severity::CODE_TABLE) do |severity|
+             RuboCop::Cop::Severity::NAMES + [:autocorrect],
+             table) do |severity|
         @options[:fail_level] = severity
       end
     end
@@ -177,36 +194,6 @@ module RuboCop
       long_opt[2..-1].sub(/ .*/, '').gsub(/-/, '_').to_sym
     end
 
-    def ignore_dropped_options(args)
-      # Currently we don't make -s/--silent option raise error
-      # since those are mostly used by external tools.
-      rejected = args.reject! { |a| %w(-s --silent).include?(a) }
-      return unless rejected
-
-      warn '-s/--silent options is dropped. ' \
-           '`emacs` and `files` formatters no longer display summary.'
-    end
-
-    def convert_deprecated_options(args)
-      args.map! do |arg|
-        case arg
-        when '-e', '--emacs'
-          deprecate("#{arg} option", '--format emacs', '1.0.0')
-          %w(--format emacs)
-        else
-          arg
-        end
-      end.flatten!
-    end
-
-    def deprecate(subject, alternative = nil, version = nil)
-      message =  "#{subject} is deprecated"
-      message << " and will be removed in RuboCop #{version}" if version
-      message << '.'
-      message << " Please use #{alternative} instead." if alternative
-      warn message
-    end
-
     def validate_auto_gen_config_option(args)
       return unless args.any?
 

data/lib/rubocop/processed_source.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require 'astrolabe/builder'
+require 'digest/md5'
 
 module RuboCop
   # ProcessedSource contains objects which are generated by Parser
@@ -48,6 +49,11 @@ module RuboCop
       @diagnostics.none? { |d| [:error, :fatal].include?(d.level) }
     end
 
+    # Raw source checksum for tracking infinite loops.
+    def checksum
+      Digest::MD5.hexdigest(@raw_source)
+    end
+
     private
 
     def parse(source)

data/lib/rubocop/rake_task.rb

@@ -31,7 +31,7 @@ module RuboCop
         end
       end
 
-      setup_subtasks(name)
+      setup_subtasks(name, *args, &task_block)
     end
 
     def run_main_task(verbose)
@@ -73,11 +73,14 @@ module RuboCop
       @formatters = [RuboCop::Options::DEFAULT_FORMATTER]
     end
 
-    def setup_subtasks(name)
+    def setup_subtasks(name, *args, &task_block)
       namespace name do
         desc 'Auto-correct RuboCop offenses'
 
-        task :auto_correct do
+        task(:auto_correct, *args) do |_, task_args|
+          if task_block
+            task_block.call(*[self, task_args].slice(0, task_block.arity))
+          end
           options = full_options.unshift('--auto-correct')
           run_cli(verbose, options)
         end

data/lib/rubocop/runner.rb

@@ -4,6 +4,17 @@ module RuboCop
   # This class handles the processing of files, which includes dealing with
   # formatters and letting cops inspect the files.
   class Runner
+    # An exception indicating that the inspection loop got stuck correcting
+    # offenses back and forth.
+    class InfiniteCorrectionLoop < Exception
+      attr_reader :offenses
+
+      def initialize(path, offenses)
+        super "Infinite loop detected in #{path}."
+        @offenses = offenses
+      end
+    end
+
     attr_reader :errors, :aborting
     alias_method :aborting?, :aborting
 
@@ -30,10 +41,10 @@ module RuboCop
         break if @options[:fail_fast] && !all_passed
       end
 
+      all_passed
+    ensure
       formatter_set.finished(inspected_files.freeze)
       formatter_set.close_output_files
-
-      all_passed
     end
 
     def abort
@@ -58,34 +69,57 @@ module RuboCop
       offenses = do_inspection_loop(file, processed_source)
 
       formatter_set.file_finished(file, offenses.compact.sort.freeze)
+
       offenses
+    rescue InfiniteCorrectionLoop => e
+      formatter_set.file_finished(file, e.offenses.compact.sort.freeze)
+      raise
     end
 
     def do_inspection_loop(file, processed_source)
       offenses = []
 
+      # Keep track of the state of the source. If a cop modifies the source
+      # and another cop undoes it producing identical source we have an
+      # infinite loop.
+      @processed_sources = []
+
       # When running with --auto-correct, we need to inspect the file (which
       # includes writing a corrected version of it) until no more corrections
       # are made. This is because automatic corrections can introduce new
       # offenses. In the normal case the loop is only executed once.
       loop do
+        check_for_infinite_loop(processed_source, offenses)
+
         # The offenses that couldn't be corrected will be found again so we
         # only keep the corrected ones in order to avoid duplicate reporting.
         offenses.select!(&:corrected?)
-
         new_offenses, updated_source_file = inspect_file(processed_source)
         offenses.concat(new_offenses).uniq!
-        break unless updated_source_file
 
         # We have to reprocess the source to pickup the changes. Since the
         # change could (theoretically) introduce parsing errors, we break the
         # loop if we find any.
+        break unless updated_source_file
+
         processed_source = ProcessedSource.from_file(file)
       end
 
       offenses
     end
 
+    # Check whether a run created source identical to a previous run, which
+    # means that we definitely have an infinite loop.
+    def check_for_infinite_loop(processed_source, offenses)
+      checksum = processed_source.checksum
+
+      if @processed_sources.include?(checksum)
+        fail InfiniteCorrectionLoop.new(processed_source.path, offenses)
+      end
+
+      @processed_sources << checksum
+    end
+
     def inspect_file(processed_source)
       config = @config_store.for(processed_source.path)
       team = Cop::Team.new(mobilized_cop_classes(config), config, @options)
@@ -99,20 +133,31 @@ module RuboCop
       @mobilized_cop_classes[config.object_id] ||= begin
         cop_classes = Cop::Cop.all
 
-        if @options[:only]
-          validate_only_option
+        [:only, :except].each { |opt| Options.validate_cop_list(@options[opt]) }
 
+        if @options[:only]
           cop_classes.select! do |c|
-            @options[:only].include?(c.cop_name) || @options[:lint] && c.lint?
+            cop_match?(c, @options[:only]) || @options[:lint] && c.lint?
           end
         else
           filter_cop_classes(cop_classes, config)
         end
 
+        cop_classes.reject! { |c| cop_match?(c, @options[:except]) }
+
         cop_classes
       end
     end
 
+    # Returns true if the cop name or the cop namespace matches any of the
+    # given names.
+    def cop_match?(cop, given_names)
+      return false unless given_names
+
+      given_names.include?(cop.cop_name) ||
+        given_names.include?(cop.cop_type.to_s.capitalize)
+    end
+
     def filter_cop_classes(cop_classes, config)
       # use only cops that link to a style guide if requested
       if style_guide_cops_only?(config)
@@ -126,13 +171,6 @@ module RuboCop
       cop_classes.select!(&:lint?) if @options[:lint]
     end
 
-    def validate_only_option
-      @options[:only].each do |cop_to_run|
-        next unless Cop::Cop.all.none? { |c| c.cop_name == cop_to_run }
-        fail ArgumentError, "Unrecognized cop name: #{cop_to_run}."
-      end
-    end
-
     def run_rails_cops?(config)
       @options[:rails] || config['AllCops']['RunRailsCops']
     end
@@ -157,7 +195,9 @@ module RuboCop
     end
 
     def considered_failure?(offense)
-      !offense.corrected? && offense.severity >= minimum_severity_to_fail
+      # For :autocorrect level, any offense - corrected or not - is a failure.
+      @options[:fail_level] == :autocorrect ||
+        !offense.corrected? && offense.severity >= minimum_severity_to_fail
     end
 
     def minimum_severity_to_fail