rubocop 1.8.1 → 1.9.0

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -69,6 +69,11 @@ module RuboCop
       # @api private
       def extract_first_element_over_column_limit(node, elements, max)
         line = node.first_line
+
+        # If the first argument is a hash pair but the method is not parenthesized,
+        # the argument cannot be moved to another line because it cause a syntax error.
+        elements.shift if node.send_type? && !node.parenthesized? && elements.first.pair_type?
+
         i = 0
         i += 1 while within_column_limit?(elements[i], max, line)
         return elements.first if i.zero?

data/lib/rubocop/cop/mixin/comments_help.rb

@@ -9,7 +9,6 @@ module RuboCop
       def source_range_with_comment(node)
         begin_pos = begin_pos_with_comment(node)
         end_pos = end_position_for(node)
-        end_pos += 1 if node.def_type?
 
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -71,11 +71,7 @@ module RuboCop
           add_offense(range, message: message) do |corrector|
             corrector.replace(range, preferred_name)
 
-            node.body&.each_descendant(:lvar) do |var|
-              next unless var.children.first == offending_name
-
-              corrector.replace(var, preferred_name)
-            end
+            correct_node(corrector, node.body, offending_name, preferred_name)
           end
         end
 
@@ -86,6 +82,43 @@ module RuboCop
           variable.loc.expression
         end
 
+        def variable_name_matches?(node, name)
+          if node.masgn_type?
+            node.each_descendant(:lvasgn).any? do |lvasgn_node|
+              variable_name_matches?(lvasgn_node, name)
+            end
+          else
+            node.children.first == name
+          end
+        end
+
+        def correct_node(corrector, node, offending_name, preferred_name)
+          return unless node
+
+          node.each_node(:lvar, :lvasgn, :masgn) do |child_node|
+            next unless variable_name_matches?(child_node, offending_name)
+
+            corrector.replace(child_node, preferred_name) if child_node.lvar_type?
+
+            if child_node.masgn_type? || child_node.lvasgn_type?
+              correct_reassignment(corrector, child_node, offending_name, preferred_name)
+              break
+            end
+          end
+        end
+
+        # If the exception variable is reassigned, that assignment needs to be corrected.
+        # Further `lvar` nodes will not be corrected though since they now refer to a
+        # different variable.
+        def correct_reassignment(corrector, node, offending_name, preferred_name)
+          if node.lvasgn_type?
+            correct_node(corrector, node.child_nodes.first, offending_name, preferred_name)
+          elsif node.masgn_type?
+            # With multiple assign, the assignments are in an array as the last child
+            correct_node(corrector, node.children.last, offending_name, preferred_name)
+          end
+        end
+
         def preferred_name(variable_name)
           preferred_name = cop_config.fetch('PreferredName', 'e')
           if variable_name.to_s.start_with?('_')

data/lib/rubocop/cop/naming/variable_number.rb

@@ -92,7 +92,7 @@ module RuboCop
       #   # good
       #   :some_sym_1
       #
-      # @example AllowedIdentifier: [capture3]
+      # @example AllowedIdentifiers: [capture3]
       #   # good
       #   expect(Open3).to receive(:capture3)
       #

data/lib/rubocop/cop/severity.rb

@@ -6,10 +6,10 @@ module RuboCop
     class Severity
       include Comparable
 
-      NAMES = %i[refactor convention warning error fatal].freeze
+      NAMES = %i[info refactor convention warning error fatal].freeze
 
       # @api private
-      CODE_TABLE = { R: :refactor, C: :convention,
+      CODE_TABLE = { I: :info, R: :refactor, C: :convention,
                      W: :warning, E: :error, F: :fatal }.freeze
 
       # @api public
@@ -18,7 +18,7 @@ module RuboCop
       #
       # @return [Symbol]
       #   severity.
-      #   any of `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
+      #   any of `:info`, `:refactor`, `:convention`, `:warning`, `:error` or `:fatal`.
       attr_reader :name
 
       def self.name_from_code(code)

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

@@ -7,7 +7,7 @@ module RuboCop
     module Style
       # This cop checks for non-ascii (non-English) characters
       # in comments. You could set an array of allowed non-ascii chars in
-      # AllowedChars attribute (empty by default).
+      # `AllowedChars` attribute (copyright notice "©" by default).
       #
       # @example
       #   # bad

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

@@ -9,37 +9,77 @@ module RuboCop
       # This is useful if want to make sure that every RuboCop error gets fixed
       # and not quickly disabled with a comment.
       #
+      # Specific cops can be allowed with the `AllowedCops` configuration. Note that
+      # if this configuration is set, `rubocop:disable all` is still disallowed.
+      #
       # @example
       #   # bad
       #   # rubocop:disable Metrics/AbcSize
-      #   def f
+      #   def foo
       #   end
       #   # rubocop:enable Metrics/AbcSize
       #
       #   # good
-      #   def fixed_method_name_and_no_rubocop_comments
+      #   def foo
+      #   end
+      #
+      # @example AllowedCops: [Metrics/AbcSize]
+      #   # good
+      #   # rubocop:disable Metrics/AbcSize
+      #   def foo
       #   end
+      #   # rubocop:enable Metrics/AbcSize
       #
       class DisableCopsWithinSourceCodeDirective < Base
         extend AutoCorrector
 
         # rubocop:enable Lint/RedundantCopDisableDirective
-        MSG = 'Comment to disable/enable RuboCop.'
+        MSG = 'Rubocop disable/enable directives are not permitted.'
+        MSG_FOR_COPS = 'Rubocop disable/enable directives for %<cops>s are not permitted.'
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless rubocop_directive_comment?(comment)
+            directive_cops = directive_cops(comment)
+            disallowed_cops = directive_cops - allowed_cops
 
-            add_offense(comment) do |corrector|
-              corrector.replace(comment, '')
-            end
+            next unless disallowed_cops.any?
+
+            register_offense(comment, directive_cops, disallowed_cops)
           end
         end
 
         private
 
-        def rubocop_directive_comment?(comment)
-          CommentConfig::COMMENT_DIRECTIVE_REGEXP.match?(comment.text)
+        def register_offense(comment, directive_cops, disallowed_cops)
+          message = if any_cops_allowed?
+                      format(MSG_FOR_COPS, cops: "`#{disallowed_cops.join('`, `')}`")
+                    else
+                      MSG
+                    end
+
+          add_offense(comment, message: message) do |corrector|
+            replacement = ''
+
+            if directive_cops.length != disallowed_cops.length
+              replacement = comment.text.sub(/#{Regexp.union(disallowed_cops)},?\s*/, '')
+                                   .sub(/,\s*$/, '')
+            end
+
+            corrector.replace(comment, replacement)
+          end
+        end
+
+        def directive_cops(comment)
+          match = CommentConfig::COMMENT_DIRECTIVE_REGEXP.match(comment.text)
+          match[2] ? match[2].split(',').map(&:strip) : []
+        end
+
+        def allowed_cops
+          Array(cop_config['AllowedCops'])
+        end
+
+        def any_cops_allowed?
+          allowed_cops.any?
         end
       end
     end

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

@@ -3,9 +3,14 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks `eval` method usage. `eval` can receive source location
-      # metadata, that are filename and line number. The metadata is used by
-      # backtraces. This cop recommends to pass the metadata to `eval` method.
+      # This cop ensures that eval methods (`eval`, `instance_eval`, `class_eval`
+      # and `module_eval`) are given filename and line number values (`__FILE__`
+      # and `__LINE__`). This data is used to ensure that any errors raised
+      # within the evaluated code will be given the correct identification
+      # in a backtrace.
+      #
+      # The cop also checks that the line number given relative to `__LINE__` is
+      # correct.
       #
       # @example
       #   # bad
@@ -32,27 +37,17 @@ module RuboCop
       #     end
       #   RUBY
       class EvalWithLocation < Base
-        MSG = 'Pass `__FILE__` and `__LINE__` to `eval` method, ' \
-              'as they are used by backtraces.'
-        MSG_INCORRECT_LINE = 'Use `%<expected>s` instead of `%<actual>s`, ' \
-                             'as they are used by backtraces.'
+        MSG = 'Pass `__FILE__` and `__LINE__` to `%<method_name>s`.'
+        MSG_EVAL = 'Pass a binding, `__FILE__` and `__LINE__` to `eval`.'
+        MSG_INCORRECT_FILE = 'Incorrect file for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
+        MSG_INCORRECT_LINE = 'Incorrect line number for `%<method_name>s`; ' \
+                             'use `%<expected>s` instead of `%<actual>s`.'
 
         RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
 
-        def_node_matcher :eval_without_location?, <<~PATTERN
-          {
-            (send nil? :eval ${str dstr})
-            (send nil? :eval ${str dstr} _)
-            (send nil? :eval ${str dstr} _ #special_file_keyword?)
-            (send nil? :eval ${str dstr} _ #special_file_keyword? _)
-
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr})
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword?)
-            (send _ {:class_eval :module_eval :instance_eval}
-              ${str dstr} #special_file_keyword? _)
-          }
+        def_node_matcher :valid_eval_receiver?, <<~PATTERN
+          { nil? (const {nil? cbase} :Kernel) }
         PATTERN
 
         def_node_matcher :line_with_offset?, <<~PATTERN
@@ -63,17 +58,31 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          eval_without_location?(node) do |code|
-            if with_lineno?(node)
-              on_with_lineno(node, code)
-            else
-              add_offense(node)
-            end
+          # Classes should not redefine eval, but in case one does, it shouldn't
+          # register an offense. Only `eval` without a receiver and `Kernel.eval`
+          # are considered.
+          return if node.method?(:eval) && !valid_eval_receiver?(node.receiver)
+
+          code = node.arguments.first
+          return unless code.str_type? || code.dstr_type?
+
+          file, line = file_and_line(node)
+
+          if line
+            check_file(node, file)
+            check_line(node, code)
+          else
+            register_offense(node)
           end
         end
 
         private
 
+        def register_offense(node)
+          msg = node.method?(:eval) ? MSG_EVAL : format(MSG, method_name: node.method_name)
+          add_offense(node, message: msg)
+        end
+
         def special_file_keyword?(node)
           node.str_type? &&
             node.source == '__FILE__'
@@ -84,6 +93,11 @@ module RuboCop
             node.source == '__LINE__'
         end
 
+        def file_and_line(node)
+          base = node.method?(:eval) ? 2 : 1
+          [node.arguments[base], node.arguments[base + 1]]
+        end
+
         # FIXME: It's a Style/ConditionalAssignment's false positive.
         # rubocop:disable Style/ConditionalAssignment
         def with_lineno?(node)
@@ -95,17 +109,32 @@ module RuboCop
         end
         # rubocop:enable Style/ConditionalAssignment
 
-        def message_incorrect_line(actual, sign, line_diff)
+        def message_incorrect_line(method_name, actual, sign, line_diff)
           expected =
             if line_diff.zero?
               '__LINE__'
             else
               "__LINE__ #{sign} #{line_diff}"
             end
-          format(MSG_INCORRECT_LINE, actual: actual.source, expected: expected)
+
+          format(MSG_INCORRECT_LINE,
+                 method_name: method_name,
+                 actual: actual.source,
+                 expected: expected)
+        end
+
+        def check_file(node, file_node)
+          return true if special_file_keyword?(file_node)
+
+          message = format(MSG_INCORRECT_FILE,
+                           method_name: node.method_name,
+                           expected: '__FILE__',
+                           actual: file_node.source)
+
+          add_offense(file_node, message: message)
         end
 
-        def on_with_lineno(node, code)
+        def check_line(node, code)
           line_node = node.arguments.last
           lineno_range = line_node.loc.expression
           line_diff = string_first_line(code) - lineno_range.first_line
@@ -124,22 +153,22 @@ module RuboCop
           end
         end
 
-        def add_offense_for_same_line(_node, line_node)
+        def add_offense_for_same_line(node, line_node)
           return if special_line_keyword?(line_node)
 
           add_offense(
             line_node.loc.expression,
-            message: message_incorrect_line(line_node, nil, 0)
+            message: message_incorrect_line(node.method_name, line_node, nil, 0)
           )
         end
 
-        def add_offense_for_different_line(_node, line_node, line_diff)
+        def add_offense_for_different_line(node, line_node, line_diff)
           sign = line_diff.positive? ? :+ : :-
           return if line_with_offset?(line_node, sign, line_diff.abs)
 
           add_offense(
             line_node.loc.expression,
-            message: message_incorrect_line(line_node, sign, line_diff.abs)
+            message: message_incorrect_line(node.method_name, line_node, sign, line_diff.abs)
           )
         end
       end

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

@@ -7,6 +7,9 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
+      # This cop is marked as unsafe, because if operand variable is a string object
+      # then `.to_f` will be removed and an error will occur.
+      #
       # @example EnforcedStyle: single_coerce (default)
       #   # bad
       #   a.to_f / b.to_f

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

@@ -11,6 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      #
       # @example EnforcedStyle: annotated (default)
       #
       #   # bad
@@ -58,12 +60,18 @@ module RuboCop
       #
       #   # good
       #   format('%06d', 10)
+      #
+      # @example IgnoredMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
+        include IgnoredMethods
 
         def on_str(node)
-          return unless node.value.include?('%')
-          return if node.each_ancestor(:xstr, :regexp).any?
+          return if format_string_token?(node) || use_ignored_method?(node)
 
           detections = collect_detections(node)
           return if detections.empty?
@@ -88,6 +96,14 @@ module RuboCop
           }
         PATTERN
 
+        def format_string_token?(node)
+          !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
+        end
+
+        def use_ignored_method?(node)
+          (parent = node.parent) && parent.send_type? && ignored_method?(parent.method_name)
+        end
+
         def unannotated_format?(node, detected_style)
           detected_style == :unannotated && !format_string_in_typical_context?(node)
         end

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

@@ -86,9 +86,10 @@ module RuboCop
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
           end
           corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
-          corrector.remove(
-            range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
-          )
+          return unless (if_branch = node.if_branch)
+
+          range = range_by_whole_lines(if_branch.source_range, include_final_newline: true)
+          corrector.remove(range)
         end
 
         def correct_to_elsif_from_modifier_form(corrector, node)
@@ -101,10 +102,12 @@ module RuboCop
 
         def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
           corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
-          if_condition_range = range_between(
-            node.loc.keyword.begin_pos, condition.source_range.end_pos
-          )
-          corrector.replace(if_condition_range, node.if_branch.source)
+          if_condition_range = if_condition_range(node, condition)
+          if (if_branch = node.if_branch)
+            corrector.replace(if_condition_range, if_branch.source)
+          else
+            corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
+          end
           corrector.remove(condition)
         end
 
@@ -115,6 +118,10 @@ module RuboCop
           find_end_range(node.parent)
         end
 
+        def if_condition_range(node, condition)
+          range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end