rubocop 0.52.1 → 0.53.0

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

@@ -24,45 +24,41 @@ module RuboCop
       #   x&.foo&.bar
       #   x&.foo || bar
       class SafeNavigationChain < Cop
+        include NilMethods
         extend TargetRubyVersion
 
         MSG = 'Do not chain ordinary method call' \
               ' after safe navigation operator.'.freeze
 
         def_node_matcher :bad_method?, <<-PATTERN
-          (send (csend ...) $_ ...)
+          (send $(csend ...) $_ ...)
         PATTERN
 
         minimum_target_ruby_version 2.3
 
         def on_send(node)
-          bad_method?(node) do |method|
+          bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method)
 
-            loc = node.loc.dot || :selector
-
-            add_offense(node, location: loc)
-          end
-        end
-
-        def autocorrect(node)
-          dot = node.loc.dot
-
-          return unless dot
-
-          lambda do |corrector|
-            corrector.insert_before(dot, '&')
+            method_chain = method_chain(node)
+            location =
+              Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                        safe_nav.loc.expression.end_pos,
+                                        method_chain.loc.expression.end_pos)
+            add_offense(node, location: location)
           end
         end
 
         private
 
-        def nil_methods
-          nil.methods + whitelist
-        end
-
-        def whitelist
-          cop_config['Whitelist'].map(&:to_sym)
+        def method_chain(node)
+          chain = node
+          while chain.send_type?
+            chain = chain.parent if chain.parent &&
+                                    %i[send csend].include?(chain.parent.type)
+            break
+          end
+          chain
         end
       end
     end

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

@@ -5,14 +5,39 @@ module RuboCop
     module Lint
       # This cop checks if a file which has a shebang line as
       # its first line is granted execute permission.
+      #
+      # @example
+      #   # bad
+      #
+      #   # A file which has a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has a shebang line as its first line is
+      #   # granted execute permission.
+      #
+      #   #!/usr/bin/env ruby
+      #   puts 'hello, world'
+      #
+      #   # good
+      #
+      #   # A file which has not a shebang line as its first line is not
+      #   # granted execute permission.
+      #
+      #   puts 'hello, world'
+      #
       class ScriptPermission < Cop
-        MSG = "Script file %s doesn't have execute permission.".freeze
+        MSG = "Script file %<file>s doesn't have execute permission.".freeze
         SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
           return if @options.key?(:stdin)
           return if Platform.windows?
-          return unless start_with_shebang?(processed_source)
+          return unless processed_source.start_with?(SHEBANG)
           return if executable?(processed_source)
           comment = processed_source.comments[0]
           message = format_message_from(processed_source)
@@ -27,21 +52,16 @@ module RuboCop
 
         private
 
-        def start_with_shebang?(processed_source)
-          return false if processed_source[0].nil?
-          processed_source[0].start_with?(SHEBANG)
-        end
-
         def executable?(processed_source)
           # Returns true if stat is executable or if the operating system
           # doesn't distinguish executable files from nonexecutable files.
           # See at: https://github.com/ruby/ruby/blob/ruby_2_4/file.c#L5362
-          File.stat(processed_source.buffer.name).executable?
+          File.stat(processed_source.file_path).executable?
         end
 
         def format_message_from(processed_source)
-          basename = File.basename(processed_source.buffer.name)
-          format(MSG, basename)
+          basename = File.basename(processed_source.file_path)
+          format(MSG, file: basename)
         end
       end
     end

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

@@ -37,8 +37,8 @@ module RuboCop
       #     puts foo
       #   end
       class ShadowedArgument < Cop
-        MSG = 'Argument `%s` was shadowed by a local variable before it was ' \
-              'used.'.freeze
+        MSG = 'Argument `%<argument>s` was shadowed by a local variable ' \
+              'before it was used.'.freeze
 
         def_node_search :uses_var?, '(lvar %)'
 
@@ -58,7 +58,7 @@ module RuboCop
           return unless argument.method_argument? || argument.block_argument?
 
           shadowing_assignment(argument) do |node|
-            message = format(MSG, argument.name)
+            message = format(MSG, argument: argument.name)
 
             add_offense(node, message: message)
           end

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

@@ -45,6 +45,7 @@ module RuboCop
       #
       class ShadowedException < Cop
         include RescueNode
+        include RangeHelp
 
         MSG = 'Do not shadow rescued Exceptions.'.freeze
 

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

@@ -32,7 +32,7 @@ module RuboCop
       #     end
       #   end
       class ShadowingOuterLocalVariable < Cop
-        MSG = 'Shadowing outer local variable - `%s`.'.freeze
+        MSG = 'Shadowing outer local variable - `%<variable>s`.'.freeze
 
         def join_force?(force_class)
           force_class == VariableForce
@@ -44,7 +44,7 @@ module RuboCop
           outer_local_variable = variable_table.find_variable(variable.name)
           return unless outer_local_variable
 
-          message = format(MSG, variable.name)
+          message = format(MSG, variable: variable.name)
           add_offense(variable.declaration_node, message: message)
         end
       end

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

@@ -18,7 +18,7 @@ module RuboCop
       #
       #   1.is_a?(Integer)
       class UnifiedInteger < Cop
-        MSG = 'Use `Integer` instead of `%s`.'.freeze
+        MSG = 'Use `Integer` instead of `%<klass>s`.'.freeze
 
         def_node_matcher :fixnum_or_bignum_const, <<-PATTERN
           (:const {nil? (:cbase)} ${:Fixnum :Bignum})
@@ -29,7 +29,7 @@ module RuboCop
 
           return unless klass
 
-          add_offense(node, message: format(MSG, klass))
+          add_offense(node, message: format(MSG, klass: klass))
         end
 
         def autocorrect(node)

data/lib/rubocop/cop/lint/{unneeded_disable.rb → unneeded_cop_disable_directive.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-# The Lint/UnneededDisable cop needs to be disabled so as to be able to provide
-# a (bad) example of an unneeded disable.
-# rubocop:disable Lint/UnneededDisable
+# The Lint/UnneededCopDisableDirective cop needs to be disabled so as
+# to be able to provide a (bad) example of an unneeded disable.
+# rubocop:disable Lint/UnneededCopDisableDirective
 module RuboCop
   module Cop
     module Lint
@@ -25,10 +25,11 @@ module RuboCop
       #
       #   # good
       #   x += 1
-      class UnneededDisable < Cop
+      class UnneededCopDisableDirective < Cop
         include NameSimilarity
+        include RangeHelp
 
-        COP_NAME = 'Lint/UnneededDisable'.freeze
+        COP_NAME = 'Lint/UnneededCopDisableDirective'.freeze
 
         def check(offenses, cop_disabled_line_ranges, comments)
           unneeded_cops = Hash.new { |h, k| h[k] = Set.new }
@@ -223,7 +224,7 @@ module RuboCop
           ranges
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
-            .map { |r1, r2| r1.end.join(r2.begin).source }
+            .map { |range1, range2| range1.end.join(range2.begin).source }
             .all? { |intervening| intervening =~ /\A\s*,\s*\Z/ }
         end
 
@@ -249,8 +250,13 @@ module RuboCop
         def all_cop_names
           @all_cop_names ||= Cop.registry.names
         end
+
+        def ends_its_line?(range)
+          line = range.source_buffer.source_line(range.last_line)
+          (line =~ /\s*\z/) == range.last_column
+        end
       end
     end
   end
 end
-# rubocop:enable Lint/UnneededDisable
+# rubocop:enable Lint/UnneededCopDisableDirective

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# The Lint/UnneededCopEnableDirective cop needs to be disabled so as
+# to be able to provide a (bad) example of an unneeded enable.
+
+# rubocop:disable Lint/UnneededCopEnableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # This cop detects instances of rubocop:enable comments that can be
+      # removed.
+      #
+      # @example
+      #   # bad
+      #   foo = 1
+      #   # rubocop:enable Metrics/LineLength
+      #
+      #   # good
+      #   foo = 1
+      class UnneededCopEnableDirective < Cop
+        include RangeHelp
+        include SurroundingSpace
+
+        MSG = 'Unnecessary enabling of %<cop>s.'.freeze
+
+        def investigate(processed_source)
+          return if processed_source.blank?
+          offenses = processed_source.comment_config.extra_enabled_comments
+          offenses.each do |comment, name|
+            add_offense(
+              [comment, name],
+              location: range_of_offense(comment, name),
+              message: format(MSG, cop: name)
+            )
+          end
+        end
+
+        def autocorrect(comment_and_name)
+          lambda do |corrector|
+            corrector.remove(range_with_comma(*comment_and_name))
+          end
+        end
+
+        private
+
+        def range_of_offense(comment, name)
+          start_pos = comment_start(comment) + cop_name_indention(comment, name)
+          range_between(start_pos, start_pos + name.size)
+        end
+
+        def comment_start(comment)
+          comment.loc.expression.begin_pos
+        end
+
+        def cop_name_indention(comment, name)
+          comment.text.index(name)
+        end
+
+        def range_with_comma(comment, name)
+          source = comment.loc.expression.source
+
+          begin_pos = cop_name_indention(comment, name)
+          end_pos = begin_pos + name.size
+          begin_pos = reposition(source, begin_pos, -1)
+          end_pos = reposition(source, end_pos, 1)
+
+          comma_pos =
+            if source[begin_pos - 1] == ','
+              :before
+            elsif source[end_pos] == ','
+              :after
+            else
+              :none
+            end
+
+          range_to_remove(begin_pos, end_pos, comma_pos, comment)
+        end
+
+        def range_to_remove(begin_pos, end_pos, comma_pos, comment)
+          start = comment_start(comment)
+          buffer = processed_source.buffer
+          range_class = Parser::Source::Range
+
+          case comma_pos
+          when :before
+            range_class.new(buffer, start + begin_pos - 1, start + end_pos)
+          when :after
+            range_class.new(buffer, start + begin_pos, start + end_pos + 1)
+          else
+            range_class.new(buffer, start, comment.loc.expression.end_pos)
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Lint/UnneededCopEnableDirective

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

@@ -23,6 +23,7 @@ module RuboCop
       #   require 'unloaded_feature'
       class UnneededRequireStatement < Cop
         extend TargetRubyVersion
+        include RangeHelp
 
         minimum_target_ruby_version 2.2
 

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

@@ -40,10 +40,10 @@ module RuboCop
         def on_begin(node)
           expressions = *node
 
-          expressions.each_cons(2) do |e1, e2|
-            next unless flow_expression?(e1)
+          expressions.each_cons(2) do |expression1, expression2|
+            next unless flow_expression?(expression1)
 
-            add_offense(e2)
+            add_offense(expression2)
           end
         end
 

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

@@ -41,8 +41,9 @@ module RuboCop
           URI.decode_www_form_component
         ].freeze
 
-        MSG = '`%s` method is obsolete and should not be used. Instead, use ' \
-              '`%s`, `%s` or `%s` depending on your specific use case.'.freeze
+        MSG = '`%<uri_method>s` method is obsolete and should not be used. ' \
+              'Instead, use %<replacements>s depending on your specific use ' \
+              'case.'.freeze
 
         def_node_matcher :uri_escape_unescape?, <<-PATTERN
           (send
@@ -52,18 +53,18 @@ module RuboCop
 
         def on_send(node)
           uri_escape_unescape?(node) do |top_level, obsolete_method|
-            replacement_methods = if %i[escape encode].include?(obsolete_method)
-                                    ALTERNATE_METHODS_OF_URI_ESCAPE
-                                  else
-                                    ALTERNATE_METHODS_OF_URI_UNESCAPE
-                                  end
+            replacements = if %i[escape encode].include?(obsolete_method)
+                             ALTERNATE_METHODS_OF_URI_ESCAPE
+                           else
+                             ALTERNATE_METHODS_OF_URI_UNESCAPE
+                           end
 
             double_colon = top_level ? '::' : ''
 
             message = format(
-              MSG,
-              "#{double_colon}URI.#{obsolete_method}",
-              *replacement_methods
+              MSG, uri_method: "#{double_colon}URI.#{obsolete_method}",
+                   replacements: "`#{replacements[0]}`, `#{replacements[1]}` " \
+                                 "or `#{replacements[2]}`"
             )
 
             add_offense(node, message: message)

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

@@ -91,7 +91,7 @@ module RuboCop
       #     delegate :method_a, to: :method_b
       #   end
       class UselessAccessModifier < Cop
-        MSG = 'Useless `%s` access modifier.'.freeze
+        MSG = 'Useless `%<current>s` access modifier.'.freeze
 
         def on_class(node)
           check_node(node.children[2]) # class body
@@ -135,14 +135,14 @@ module RuboCop
           if node.begin_type?
             check_scope(node)
           elsif node.send_type? && node.access_modifier?
-            add_offense(node, message: format(MSG, node.method_name))
+            add_offense(node, message: format(MSG, current: node.method_name))
           end
         end
 
         def check_scope(node)
           cur_vis, unused = check_child_nodes(node, nil, :public)
 
-          add_offense(unused, message: format(MSG, cur_vis)) if unused
+          add_offense(unused, message: format(MSG, current: cur_vis)) if unused
         end
 
         def check_child_nodes(node, unused, cur_vis)
@@ -165,10 +165,12 @@ module RuboCop
         def check_new_visibility(node, unused, new_vis, cur_vis)
           # does this modifier just repeat the existing visibility?
           if new_vis == cur_vis
-            add_offense(node, message: format(MSG, cur_vis))
+            add_offense(node, message: format(MSG, current: cur_vis))
           else
             # was the previous modifier never applied to any defs?
-            add_offense(unused, message: format(MSG, cur_vis)) if unused
+            if unused
+              add_offense(unused, message: format(MSG, current: cur_vis))
+            end
             # once we have already warned about a certain modifier, don't
             # warn again even if it is never applied to any method defs
             unused = node

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

@@ -32,7 +32,7 @@ module RuboCop
       #   end
       class UselessAssignment < Cop
         include NameSimilarity
-        MSG = 'Useless assignment to variable - `%s`.'.freeze
+        MSG = 'Useless assignment to variable - `%<variable>s`.'.freeze
 
         def join_force?(force_class)
           force_class == VariableForce
@@ -65,7 +65,7 @@ module RuboCop
         def message_for_useless_assignment(assignment)
           variable = assignment.variable
 
-          format(MSG, variable.name) +
+          format(MSG, variable: variable.name) +
             message_specification(assignment, variable).to_s
         end