rubocop 0.51.0 → 0.52.0

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # Checks for space between a the name of a called method and a left
+      # Checks for space between the name of a called method and a left
       # parenthesis.
       #
       # @example

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

@@ -40,19 +40,6 @@ module RuboCop
           add_offense(node)
         end
 
-        private
-
-        def contains_quotes_or_commas?(node)
-          node.values.any? do |value|
-            literal = value.children.first.to_s.scrub
-
-            # To avoid likely false positives (e.g. a single ' or ")
-            next if literal.gsub(/[^\p{Alnum}]/, '').empty?
-
-            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
-          end
-        end
-
         # rubocop:disable Performance/HashEachMethods
         def autocorrect(node)
           lambda do |corrector|
@@ -68,7 +55,20 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Performance/HashEachMethod
+        # rubocop:enable Performance/HashEachMethods
+
+        private
+
+        def contains_quotes_or_commas?(node)
+          node.values.any? do |value|
+            literal = value.children.first.to_s.scrub
+
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.gsub(/[^\p{Alnum}]/, '').empty?
+
+            QUOTES_AND_COMMAS.any? { |pat| literal =~ pat }
+          end
+        end
       end
     end
   end

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

@@ -36,6 +36,17 @@ module RuboCop
           add_offense(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            node.children.each do |child|
+              range = child.loc.expression
+
+              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
+              corrector.remove_leading(range, 1) if /^:/ =~ range.source
+            end
+          end
+        end
+
         private
 
         def contains_colons_or_commas?(node)
@@ -49,17 +60,6 @@ module RuboCop
             patterns.any? { |pat| literal =~ pat }
           end
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            node.children.each do |child|
-              range = child.loc.expression
-
-              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
-              corrector.remove_leading(range, 1) if /^:/ =~ range.source
-            end
-          end
-        end
       end
     end
   end

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

@@ -33,7 +33,7 @@ module RuboCop
         def_node_matcher :redundant_with_index?, <<-PATTERN
           (block
             $(send
-              _ {:each_with_index :with_index})
+              _ {:each_with_index :with_index} ...)
             (args
               (arg _))
             ...)
@@ -51,7 +51,7 @@ module RuboCop
               if send.method_name == :each_with_index
                 corrector.replace(send.loc.selector, 'each')
               else
-                corrector.remove(send.loc.selector)
+                corrector.remove(with_index_range(send))
                 corrector.remove(send.loc.dot)
               end
             end
@@ -69,7 +69,10 @@ module RuboCop
         end
 
         def with_index_range(send)
-          range_between(send.loc.selector.begin_pos, send.loc.selector.end_pos)
+          range_between(
+            send.loc.selector.begin_pos,
+            send.loc.expression.end_pos
+          )
         end
       end
     end

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

@@ -72,7 +72,7 @@ module RuboCop
         def with_object_range(send)
           range_between(
             send.loc.selector.begin_pos,
-            send.source.length
+            send.loc.expression.end_pos
           )
         end
       end

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

@@ -17,7 +17,7 @@ module RuboCop
       #   # bad
       #
       #   if day.is? :tuesday && month == :jan
-      #     ...
+      #     # ...
       #   end
       #
       # @example
@@ -25,6 +25,8 @@ module RuboCop
       #   # good
       #
       #   if day.is?(:tuesday) && month == :jan
+      #     # ...
+      #   end
       class RequireParentheses < Cop
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
               'precedence.'.freeze

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

@@ -55,11 +55,9 @@ module RuboCop
           )
         end
 
-        private
-
         def autocorrect(node)
           rescued, _, _body = *node
-          range = Parser::Source::Range.new(node.loc.expression,
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
                                             node.loc.keyword.end_pos,
                                             rescued.loc.expression.end_pos)
 
@@ -68,6 +66,8 @@ module RuboCop
           end
         end
 
+        private
+
         def correction(*exceptions)
           correction = valid_exceptions(exceptions).map(&:source).join(', ')
           correction = " #{correction}" unless correction.empty?

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

@@ -10,6 +10,7 @@ module RuboCop
         SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
+          return if @options.key?(:stdin)
           return if Platform.windows?
           return unless start_with_shebang?(processed_source)
           return if executable?(processed_source)

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for shadowed arguments.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   do_something do |foo|
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = 42
+      #     puts foo
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   do_something do |foo|
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     foo = foo + 42
+      #     puts foo
+      #   end
+      #
+      #   def do_something(foo)
+      #     puts foo
+      #   end
+      class ShadowedArgument < Cop
+        MSG = 'Argument `%s` was shadowed by a local variable before it was ' \
+              'used.'.freeze
+
+        def_node_search :uses_var?, '(lvar %)'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def after_leaving_scope(scope, _variable_table)
+          scope.variables.each_value do |variable|
+            check_argument(variable)
+          end
+        end
+
+        private
+
+        def check_argument(argument)
+          return unless argument.method_argument? || argument.block_argument?
+
+          shadowing_assignment(argument) do |node|
+            message = format(MSG, argument.name)
+
+            add_offense(node, message: message)
+          end
+        end
+
+        def shadowing_assignment(argument)
+          return unless argument.referenced?
+
+          assignment_without_argument_usage(argument) do |node, location_known|
+            assignment_without_usage_pos = node.source_range.begin_pos
+
+            references = argument_references(argument)
+
+            # If argument was referenced before it was reassigned
+            # then it's not shadowed
+            next if references.any? do |reference|
+              next true if !reference.explicit? && ignore_implicit_references?
+
+              reference_pos = reference.node.source_range.begin_pos
+
+              reference_pos <= assignment_without_usage_pos
+            end
+
+            yield location_known ? node : argument.declaration_node
+          end
+        end
+
+        # Find the first argument assignment, which doesn't reference the
+        # argument at the rhs. If the assignment occurs inside a branch or
+        # block, it is impossible to tell whether it's executed, so precise
+        # shadowing location is not known.
+        #
+        def assignment_without_argument_usage(argument)
+          argument.assignments.reduce(true) do |location_known, assignment|
+            assignment_node = assignment.meta_assignment_node || assignment.node
+
+            node_within_block_or_conditional =
+              node_within_block_or_conditional?(assignment_node.parent,
+                                                argument.scope.node)
+
+            unless uses_var?(assignment_node, argument.name)
+              # It's impossible to decide whether a branch or block is executed,
+              # so the precise reassignment location is undecidable.
+              next false if node_within_block_or_conditional
+
+              yield(assignment.node, location_known)
+              break
+            end
+
+            location_known
+          end
+        end
+
+        # Check whether the given node is nested into block or conditional.
+        #
+        def node_within_block_or_conditional?(node, stop_search_node)
+          return false if node == stop_search_node
+
+          CONDITIONAL_NODES.include?(node.type) ||
+            node.block_type? ||
+            node_within_block_or_conditional?(node.parent, stop_search_node)
+        end
+
+        # Get argument references without assignments' references
+        #
+        def argument_references(argument)
+          assignment_references = argument
+                                  .assignments
+                                  .flat_map(&:references)
+                                  .map(&:source_range)
+
+          argument.references.reject do |ref|
+            next false unless ref.explicit?
+
+            assignment_references.include?(ref.node.source_range)
+          end
+        end
+
+        def ignore_implicit_references?
+          cop_config['IgnoreImplicitReferences']
+        end
+      end
+    end
+  end
+end

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

@@ -33,12 +33,6 @@ module RuboCop
           end
         end
 
-        private
-
-        def message(node)
-          node.receiver ? MSG_DEFAULT : MSG_SELF
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             receiver, _method_name, *_args = *node
@@ -52,6 +46,12 @@ module RuboCop
             )
           end
         end
+
+        private
+
+        def message(node)
+          node.receiver ? MSG_DEFAULT : MSG_SELF
+        end
       end
     end
   end

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

@@ -1,5 +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
 module RuboCop
   module Cop
     module Lint
@@ -12,6 +15,16 @@ module RuboCop
       # their work. Instead, it waits until it's called in a later stage of the
       # execution. The reason it can't be implemented as a normal cop is that
       # it depends on the results of all other cops to do its work.
+      #
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/LineLength
+      #   x += 1
+      #   # rubocop:enable Metrics/LineLength
+      #
+      #   # good
+      #   x += 1
       class UnneededDisable < Cop
         include NameSimilarity
 
@@ -48,12 +61,15 @@ module RuboCop
           # Eat the entire comment, the preceding space, and the preceding
           # newline if there is one.
           original_begin = range.begin_pos
-          range = range_with_surrounding_space(range, :left, true)
-          range_with_surrounding_space(range, :right,
+          range = range_with_surrounding_space(range: range,
+                                               side: :left,
+                                               newlines: true)
+          range_with_surrounding_space(range: range,
+                                       side: :right,
                                        # Special for a comment that
                                        # begins the file: remove
                                        # the newline at the end.
-                                       original_begin.zero?)
+                                       newlines: original_begin.zero?)
         end
 
         def directive_range_in_list(range, ranges)
@@ -61,13 +77,15 @@ module RuboCop
           # is NOT being removed?
           if ends_its_line?(ranges.last) && trailing_range?(ranges, range)
             # Eat the comma on the left.
-            range = range_with_surrounding_space(range, :left)
+            range = range_with_surrounding_space(range: range, side: :left)
             range = range_with_surrounding_comma(range, :left)
           end
 
           range = range_with_surrounding_comma(range, :right)
           # Eat following spaces up to EOL, but not the newline itself.
-          range_with_surrounding_space(range, :right, false)
+          range_with_surrounding_space(range: range,
+                                       side: :right,
+                                       newlines: false)
         end
 
         def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments,
@@ -75,7 +93,8 @@ module RuboCop
           disabled_ranges = cop_disabled_line_ranges[COP_NAME] || [0..0]
 
           cop_disabled_line_ranges.each do |cop, line_ranges|
-            each_already_disabled(line_ranges, comments) do |comment|
+            each_already_disabled(line_ranges,
+                                  disabled_ranges, comments) do |comment|
               yield comment, cop
             end
 
@@ -88,10 +107,7 @@ module RuboCop
                             cop)
           line_ranges.each_with_index do |line_range, ix|
             comment = comments.find { |c| c.loc.line == line_range.begin }
-
-            unless all_disabled?(comment)
-              next if ignore_offense?(disabled_ranges, line_range)
-            end
+            next if ignore_offense?(disabled_ranges, line_range)
 
             unneeded_cop = find_unneeded(comment, offenses, cop, line_range,
                                          line_ranges[ix + 1])
@@ -99,8 +115,9 @@ module RuboCop
           end
         end
 
-        def each_already_disabled(line_ranges, comments)
+        def each_already_disabled(line_ranges, disabled_ranges, comments)
           line_ranges.each_cons(2) do |previous_range, range|
+            next if ignore_offense?(disabled_ranges, range)
             next if previous_range.end != range.begin
 
             # If a cop is disabled in a range that begins on the same line as
@@ -236,3 +253,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Lint/UnneededDisable

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

@@ -40,7 +40,8 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            range = range_with_surrounding_space(node.loc.expression, :right)
+            range = range_with_surrounding_space(range: node.loc.expression,
+                                                 side: :right)
             corrector.remove(range)
           end
         end