rubocop 0.40.0 → 0.41.0

data/lib/rubocop/ast_node/traversal.rb

@@ -20,13 +20,13 @@ module RuboCop
                            :arg, :restarg, :blockarg, :shadowarg,
                            :kwrestarg, :zsuper, :lambda, :redo, :retry].freeze
       ONE_CHILD_NODE    = [:splat, :kwsplat, :block_pass, :not, :break, :next,
-                           :return, :preexe, :postexe, :match_current_line,
-                           :defined?, :arg_expr].freeze
+                           :preexe, :postexe, :match_current_line, :defined?,
+                           :arg_expr].freeze
       MANY_CHILD_NODES  = [:dstr, :dsym, :xstr, :regexp, :array, :hash, :pair,
                            :irange, :erange, :mlhs, :masgn, :or_asgn, :and_asgn,
                            :undef, :alias, :args, :super, :yield, :or, :and,
                            :while_post, :until_post, :iflipflop, :eflipflop,
-                           :match_with_lvasgn, :begin, :kwbegin].freeze
+                           :match_with_lvasgn, :begin, :kwbegin, :return].freeze
       SECOND_CHILD_ONLY = [:lvasgn, :ivasgn, :cvasgn, :gvasgn, :optarg, :kwarg,
                            :kwoptarg].freeze
 

data/lib/rubocop/cli.rb

@@ -7,7 +7,7 @@ module RuboCop
   class CLI
     include Formatter::TextUtil
 
-    class Finished < Exception; end
+    class Finished < RuntimeError; end
 
     attr_reader :options, :config_store
 
@@ -25,14 +25,7 @@ module RuboCop
       act_on_options
       apply_default_formatter
 
-      runner = Runner.new(@options, @config_store)
-      trap_interrupt(runner)
-      all_passed = runner.run(paths)
-      display_warning_summary(runner.warnings)
-      display_error_summary(runner.errors)
-      maybe_print_corrected_source
-
-      all_passed && !runner.aborting? && runner.errors.empty? ? 0 : 1
+      execute_runner(paths)
     rescue RuboCop::Error => e
       $stderr.puts Rainbow("Error: #{e.message}").red
       return 2
@@ -72,6 +65,18 @@ module RuboCop
       end
     end
 
+    def execute_runner(paths)
+      runner = Runner.new(@options, @config_store)
+
+      trap_interrupt(runner)
+      all_passed = runner.run(paths)
+      display_warning_summary(runner.warnings)
+      display_error_summary(runner.errors)
+      maybe_print_corrected_source
+
+      all_passed && !runner.aborting? && runner.errors.empty? ? 0 : 1
+    end
+
     def handle_exiting_options
       return unless Options::EXITING_OPTIONS.any? { |o| @options.key? o }
 

data/lib/rubocop/comment_config.rb

@@ -6,10 +6,17 @@ module RuboCop
   # and provides a way to check if each cop is enabled at arbitrary line.
   class CommentConfig
     UNNEEDED_DISABLE = 'Lint/UnneededDisable'.freeze
+
+    COP_NAME_PATTERN = '([A-Z][a-z]+/)?(?:[A-Z][a-z]+)+'.freeze
+    COP_NAMES_PATTERN = "(?:#{COP_NAME_PATTERN} , )*#{COP_NAME_PATTERN}".freeze
+    COPS_PATTERN = "(all|#{COP_NAMES_PATTERN})".freeze
+
     COMMENT_DIRECTIVE_REGEXP = Regexp.new(
-      '\A# rubocop : ((?:dis|en)able)\b ((?:[\w/]+,? )+)'.gsub(' ', '\s*')
+      ('\A# rubocop : ((?:dis|en)able)\b ' + COPS_PATTERN).gsub(' ', '\s*')
     )
 
+    CopAnalysis = Struct.new(:line_ranges, :start_line_number)
+
     attr_reader :processed_source
 
     def initialize(processed_source)
@@ -19,6 +26,8 @@ module RuboCop
     def cop_enabled_at_line?(cop, line_number)
       cop = cop.cop_name if cop.respond_to?(:cop_name)
       disabled_line_ranges = cop_disabled_line_ranges[cop]
+      return true unless disabled_line_ranges
+
       disabled_line_ranges.none? { |range| range.include?(line_number) }
     end
 
@@ -29,57 +38,101 @@ module RuboCop
     private
 
     def analyze
-      disabled_line_ranges = Hash.new { |hash, key| hash[key] = [] }
-      disablement_start_line_numbers = {}
+      analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
 
       each_mentioned_cop do |cop_name, disabled, line, single_line|
-        if single_line
-          disabled_line_ranges[cop_name] << (line..line) if disabled
-        elsif disabled
-          if disablement_start_line_numbers[cop_name]
-            # Cop already disabled on this line, so we end the current disabled
-            # range before we start a new range.
-            start_line = disablement_start_line_numbers.delete(cop_name)
-            disabled_line_ranges[cop_name] << (start_line..line)
-          end
-          disablement_start_line_numbers[cop_name] = line
-        else
-          start_line = disablement_start_line_numbers.delete(cop_name)
-          disabled_line_ranges[cop_name] << (start_line..line) if start_line
-        end
+        analyses[cop_name] =
+          analyze_cop(analyses[cop_name], disabled, line, single_line)
       end
 
-      disablement_start_line_numbers.each do |cop_name, start_line|
-        disabled_line_ranges[cop_name] << (start_line..Float::INFINITY)
+      analyses.each_with_object({}) do |element, hash|
+        cop_name, analysis = *element
+        hash[cop_name] = cop_line_ranges(analysis)
       end
+    end
 
-      disabled_line_ranges
+    def analyze_cop(analysis, disabled, line, single_line)
+      if single_line
+        analyze_single_line(analysis, line, disabled)
+      elsif disabled
+        analyze_disabled(analysis, line)
+      else
+        analyze_rest(analysis, line)
+      end
     end
 
-    def each_mentioned_cop
-      return if processed_source.comments.nil?
+    def analyze_single_line(analysis, line, disabled)
+      return analysis unless disabled
 
-      processed_source.comments.each do |comment|
-        match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
-        next unless match
+      CopAnalysis.new(analysis.line_ranges + [(line..line)],
+                      analysis.start_line_number)
+    end
+
+    def analyze_disabled(analysis, line)
+      if (start_line = analysis.start_line_number)
+        # Cop already disabled on this line, so we end the current disabled
+        # range before we start a new range.
+        return CopAnalysis.new(analysis.line_ranges + [start_line..line], line)
+      end
+
+      CopAnalysis.new(analysis.line_ranges, line)
+    end
+
+    def analyze_rest(analysis, line)
+      if (start_line = analysis.start_line_number)
+        return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
+      end
+
+      CopAnalysis.new(analysis.line_ranges, nil)
+    end
 
-        switch, cops_string = match.captures
+    def cop_line_ranges(analysis)
+      return analysis.line_ranges unless analysis.start_line_number
 
-        cop_names =
-          cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
+      analysis.line_ranges + [(analysis.start_line_number..Float::INFINITY)]
+    end
 
-        disabled = (switch == 'disable')
+    def each_mentioned_cop
+      each_directive do |comment, cop_names, disabled|
         comment_line_number = comment.loc.expression.line
         single_line = !comment_only_line?(comment_line_number)
 
         cop_names.each do |cop_name|
-          cop_name = Cop::Cop.qualified_cop_name(cop_name.strip,
-                                                 processed_source.buffer.name)
-          yield cop_name, disabled, comment_line_number, single_line
+          yield qualified_cop_name(cop_name), disabled, comment_line_number,
+                single_line
         end
       end
     end
 
+    def each_directive
+      return if processed_source.comments.nil?
+
+      processed_source.comments.each do |comment|
+        directive = directive_parts(comment)
+        next unless directive
+
+        yield comment, *directive
+      end
+    end
+
+    def directive_parts(comment)
+      match = comment.text.match(COMMENT_DIRECTIVE_REGEXP)
+      return unless match
+
+      switch, cops_string = match.captures
+
+      cop_names =
+        cops_string == 'all' ? all_cop_names : cops_string.split(/,\s*/)
+
+      disabled = (switch == 'disable')
+
+      [cop_names, disabled]
+    end
+
+    def qualified_cop_name(cop_name)
+      Cop::Cop.qualified_cop_name(cop_name.strip, processed_source.buffer.name)
+    end
+
     def all_cop_names
       @all_cop_names ||= Cop::Cop.all.map(&:cop_name).reject do |cop_name|
         cop_name == UNNEEDED_DISABLE

data/lib/rubocop/config.rb

@@ -194,6 +194,19 @@ module RuboCop
         end
     end
 
+    def target_ruby_version
+      @target_ruby_version ||=
+        if File.file?('.ruby-version')
+          @target_ruby_version_source = :dot_ruby_version
+
+          File.read('.ruby-version').to_f
+        else
+          @target_ruby_version_source = :rubocop_yml
+
+          for_all_cops['TargetRubyVersion']
+        end
+    end
+
     private
 
     def warn_about_unrecognized_cops(invalid_cop_names)
@@ -272,14 +285,22 @@ module RuboCop
     end
 
     def check_target_ruby
-      target = for_all_cops['TargetRubyVersion']
-      return unless target
-
-      unless KNOWN_RUBIES.include?(target)
-        raise ValidationError, "Unknown Ruby version #{target.inspect} found " \
-                              'in `TargetRubyVersion` parameter (in ' \
-                              "#{loaded_path}).\nKnown versions: " \
-                              "#{KNOWN_RUBIES.join(', ')}"
+      return unless target_ruby_version
+
+      unless KNOWN_RUBIES.include?(target_ruby_version)
+        msg = "Unknown Ruby version #{target_ruby_version.inspect} found "
+
+        msg +=
+          case @target_ruby_version_source
+          when :dot_ruby_version
+            'in `.ruby-version`.'
+          when :rubocop_yml
+            "in `TargetRubyVersion` parameter (in #{loaded_path})." \
+          end
+
+        msg += "\nKnown versions: #{KNOWN_RUBIES.join(', ')}"
+
+        raise ValidationError, msg
       end
     end
   end

data/lib/rubocop/config_loader.rb

@@ -139,7 +139,7 @@ module RuboCop
       end
 
       def load_yaml_configuration(absolute_path)
-        yaml_code = IO.read(absolute_path)
+        yaml_code = IO.read(absolute_path, encoding: 'UTF-8')
         # At one time, there was a problem with the psych YAML engine under
         # Ruby 1.9.3. YAML.load_file would crash when reading empty .yml files
         # or files that only contained comments and blank lines. This problem

data/lib/rubocop/cop/cop.rb

@@ -193,7 +193,7 @@ module RuboCop
       end
 
       def target_ruby_version
-        @config.for_all_cops['TargetRubyVersion']
+        @config.target_ruby_version
       end
 
       def parse(source, path = nil)

data/lib/rubocop/cop/corrector.rb

@@ -118,6 +118,19 @@ module RuboCop
                                               range.begin_pos + size)
         @source_rewriter.remove(to_remove)
       end
+
+      # Removes `size` characters from the end of the given range.
+      # If `size` is greater than the size of `range`, the removed region can
+      # overrun the beginning of `range`.
+      #
+      # @param [Parser::Source::Range] range
+      # @param [Integer] size
+      def remove_trailing(range, size)
+        to_remove = Parser::Source::Range.new(range.source_buffer,
+                                              range.end_pos - size,
+                                              range.end_pos)
+        @source_rewriter.remove(to_remove)
+      end
     end
   end
 end

data/lib/rubocop/cop/lint/block_alignment.rb

@@ -63,15 +63,7 @@ module RuboCop
 
         def start_for_block_node(block_node)
           # Which node should we align the 'end' with?
-          result = block_node
-
-          while (parent = result.parent)
-            break if !parent || !parent.loc
-            break if parent.loc.line != block_node.loc.line &&
-                     !parent.masgn_type?
-            break unless block_end_align_target?(parent, result)
-            result = parent
-          end
+          result = block_end_align_target(block_node)
 
           # In offense message, we want to show the assignment LHS rather than
           # the entire assignment
@@ -79,6 +71,17 @@ module RuboCop
           result
         end
 
+        def block_end_align_target(node)
+          while (parent = node.parent)
+            break if !parent || !parent.loc
+            break if parent.loc.line != node.loc.line && !parent.masgn_type?
+            break unless block_end_align_target?(parent, node)
+            node = parent
+          end
+
+          node
+        end
+
         def check_block_alignment(start_node, block_node)
           end_loc = block_node.loc.end
           return unless begins_its_line?(end_loc)
@@ -91,19 +94,30 @@ module RuboCop
             compute_do_source_line_column(block_node, end_loc)
           return unless do_source_line_column
 
+          offense(block_node, start_loc, end_loc, do_source_line_column)
+        end
+
+        def offense(block_node, start_loc, end_loc, do_source_line_column)
           error_source_line_column = if style == :start_of_block
                                        do_source_line_column
                                      else
                                        loc_to_source_line_column(start_loc)
                                      end
 
-          fmt = format(
+          message = format_message(start_loc, end_loc, do_source_line_column,
+                                   error_source_line_column)
+
+          add_offense(block_node, end_loc, message)
+        end
+
+        def format_message(start_loc, end_loc, do_source_line_column,
+                           error_source_line_column)
+          format(
             MSG,
             format_source_line_column(loc_to_source_line_column(end_loc)),
             format_source_line_column(error_source_line_column),
             alt_start_msg(start_loc, do_source_line_column)
           )
-          add_offense(block_node, end_loc, fmt)
         end
 
         def compute_do_source_line_column(node, end_loc)

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -34,13 +34,12 @@ module RuboCop
 
         def offending_node?(node)
           return false unless called_on_string?(node)
-          return false unless sprintf?(node) || format?(node) || percent?(node)
+          return false unless method_with_format_args?(node)
           return false if named_mode?(node) || node_with_splat_args?(node)
 
           num_of_format_args, num_of_expected_fields = count_matches(node)
 
           num_of_format_args != :unknown &&
-            num_of_expected_fields != :unknown &&
             num_of_expected_fields != num_of_format_args
         end
 
@@ -53,6 +52,10 @@ module RuboCop
           end
         end
 
+        def method_with_format_args?(node)
+          sprintf?(node) || format?(node) || percent?(node)
+        end
+
         def named_mode?(node)
           receiver_node, _method_name, *args = *node
 

data/lib/rubocop/cop/lint/inherit_exception.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop looks for error classes inheriting from `Exception`.
+      # It is configurable to suggest using either `RuntimeError` (default) or
+      # `StandardError` instead.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   class C < Exception; end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: runtime_error (default)
+      #
+      #   # good
+      #
+      #   class C < RuntimeError; end
+      #
+      # @example
+      #
+      #   # EnforcedStyle: standard_error
+      #
+      #   # good
+      #
+      #   class C < StandardError; end
+      class InheritException < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Inherit from `%s` instead of `Exception`.'.freeze
+        PREFERRED_BASE_CLASS = {
+          runtime_error: 'RuntimeError',
+          standard_error: 'StandardError'
+        }.freeze
+
+        def on_class(node)
+          _class, base_class, _body = *node
+
+          return if base_class.nil?
+
+          check(base_class)
+        end
+
+        private
+
+        def check(node)
+          if node.const_name == 'Exception'
+            add_offense(node, :expression, format(MSG, preferred_base_class))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, preferred_base_class)
+          end
+        end
+
+        def preferred_base_class
+          PREFERRED_BASE_CLASS[style]
+        end
+      end
+    end
+  end
+end