rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for redundant `with_object`.
+      #
+      # @example
+      #   # bad
+      #   ary.each_with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      #   # bad
+      #   ary.each.with_object([]) do |v|
+      #     v
+      #   end
+      #
+      #   # good
+      #   ary.each do |v|
+      #     v
+      #   end
+      #
+      class RedundantWithObject < Cop
+        MSG_EACH_WITH_OBJECT = 'Use `each` instead of `each_with_object`.'
+                               .freeze
+        MSG_WITH_OBJECT = 'Remove redundant `with_object`.'.freeze
+
+        def_node_matcher :redundant_with_object?, <<-PATTERN
+          (block
+            $(send _ {:each_with_object :with_object}
+              (_))
+            (args
+              (arg _))
+            ...)
+        PATTERN
+
+        def on_block(node)
+          redundant_with_object?(node) do |send|
+            add_offense(node, location: with_object_range(send))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            redundant_with_object?(node) do |send|
+              if send.method_name == :each_with_object
+                corrector.replace(with_object_range(send), 'each')
+              else
+                corrector.remove(with_object_range(send))
+                corrector.remove(send.loc.dot)
+              end
+            end
+          end
+        end
+
+        private
+
+        def message(node)
+          if node.method_name == :each_with_object
+            MSG_EACH_WITH_OBJECT
+          else
+            MSG_WITH_OBJECT
+          end
+        end
+
+        def with_object_range(send)
+          range_between(
+            send.loc.selector.begin_pos,
+            send.loc.expression.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for regexp literals used as `match-current-line`.
+      # If a regexp literal is in condition, the regexp matches `$_` implicitly.
+      #
+      # @example
+      #   # bad
+      #   if /foo/
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   if /foo/ =~ $_
+      #     do_something
+      #   end
+      class RegexpAsCondition < Cop
+        MSG = 'Do not use regexp literal as a condition.' \
+              ' The regexp literal matches `$_` implicitly.'.freeze
+
+        def on_match_current_line(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -15,53 +14,48 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   if day.is? :tuesday && month == :jan
-      #     ...
+      #     # ...
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   if day.is?(:tuesday) && month == :jan
+      #     # ...
       #   end
       class RequireParentheses < Cop
-        include IfNode
-
         MSG = 'Use parentheses in the method call to avoid confusion about ' \
               'precedence.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-
-          return if parentheses?(node)
-          return if args.empty?
+          return if !node.arguments? || node.parenthesized?
 
-          if ternary?(args.first)
-            check_ternary(args.first, node)
-          elsif predicate?(method_name)
-            # We're only checking predicate methods. There would be false
-            # positives otherwise.
-            check_send(args.last, node)
+          if node.first_argument.if_type? && node.first_argument.ternary?
+            check_ternary(node.first_argument, node)
+          elsif node.predicate_method?
+            check_predicate(node.last_argument, node)
           end
         end
 
         private
 
-        def check_ternary(arg, node)
-          condition, = *arg
-          return unless offense?(condition)
+        def check_ternary(ternary, node)
+          return unless ternary.condition.operator_keyword?
 
-          expr = node.source_range
-          range = Parser::Source::Range.new(expr.source_buffer,
-                                            expr.begin_pos,
-                                            condition.source_range.end_pos)
-          add_offense(range, range)
-        end
+          range = range_between(node.source_range.begin_pos,
+                                ternary.condition.source_range.end_pos)
 
-        def check_send(arg, node)
-          add_offense(node, :expression) if offense?(arg)
+          add_offense(range, location: range)
         end
 
-        def predicate?(method_name)
-          method_name.to_s.end_with?('?')
-        end
+        def check_predicate(predicate, node)
+          return unless predicate.operator_keyword?
 
-        def offense?(node)
-          [:and, :or].include?(node.type)
+          add_offense(node)
         end
       end
     end

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

@@ -1,10 +1,29 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Lint
       # This cop checks for *rescue* blocks targeting the Exception class.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   begin
+      #     do_something
+      #   rescue Exception
+      #     handle_exception
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   begin
+      #     do_something
+      #   rescue ArgumentError
+      #     handle_exception
+      #   end
       class RescueException < Cop
         MSG = 'Avoid rescuing the `Exception` class. ' \
               'Perhaps you meant to rescue `StandardError`?'.freeze
@@ -14,7 +33,7 @@ module RuboCop
           rescue_args = node.children.first.children
           return unless rescue_args.any? { |a| targets_exception?(a) }
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def targets_exception?(rescue_arg_node)

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Check for arguments to `rescue` that will result in a `TypeError`
+      # if an exception is raised.
+      #
+      # @example
+      #   # bad
+      #   begin
+      #     bar
+      #   rescue nil
+      #     baz
+      #   end
+      #
+      #   # bad
+      #   def foo
+      #     bar
+      #   rescue 1, 'a', "#{b}", 0.0, [], {}
+      #     baz
+      #   end
+      #
+      #   # good
+      #   begin
+      #     bar
+      #   rescue
+      #     baz
+      #   end
+      #
+      #   # good
+      #   def foo
+      #     bar
+      #   rescue NameError
+      #     baz
+      #   end
+      class RescueType < Cop
+        include RescueNode
+
+        MSG = 'Rescuing from `%s` will raise a `TypeError` instead of ' \
+              'catching the actual exception.'.freeze
+        INVALID_TYPES = %i[array dstr float hash nil int str sym].freeze
+
+        def on_resbody(node)
+          rescued, _, _body = *node
+          return if rescued.nil?
+          exceptions = *rescued
+          invalid_exceptions = invalid_exceptions(exceptions)
+          return if invalid_exceptions.empty?
+
+          add_offense(
+            node,
+            location: node.loc.keyword.join(rescued.loc.expression),
+            message: format(MSG, invalid_exceptions.map(&:source).join(', '))
+          )
+        end
+
+        def autocorrect(node)
+          rescued, _, _body = *node
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            node.loc.keyword.end_pos,
+                                            rescued.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, correction(*rescued))
+          end
+        end
+
+        private
+
+        def correction(*exceptions)
+          correction = valid_exceptions(exceptions).map(&:source).join(', ')
+          correction = " #{correction}" unless correction.empty?
+
+          correction
+        end
+
+        def valid_exceptions(exceptions)
+          exceptions - invalid_exceptions(exceptions)
+        end
+
+        def invalid_exceptions(exceptions)
+          exceptions.select do |exception|
+            INVALID_TYPES.include?(exception.type)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for the use of a return with a value in a context
+      # where the value will be ignored. (initialize and setter methods)
+      #
+      # @example
+      #
+      #   # bad
+      #   def initialize
+      #     foo
+      #     return :qux if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return 42
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #   def initialize
+      #     foo
+      #     return if bar?
+      #     baz
+      #   end
+      #
+      #   def foo=(bar)
+      #     return
+      #   end
+      class ReturnInVoidContext < Cop
+        MSG = 'Do not return a value in `%s`.'.freeze
+
+        def on_return(return_node)
+          return unless return_node.descendants.any?
+
+          context_node = non_void_context(return_node)
+
+          return unless context_node && context_node.def_type?
+
+          method_name = method_name(context_node)
+
+          return unless method_name && void_context_method?(method_name)
+
+          add_offense(return_node,
+                      location: :keyword,
+                      message: format(message, method_name))
+        end
+
+        private
+
+        def non_void_context(return_node)
+          return_node.each_ancestor(:block, :def, :defs).first
+        end
+
+        def method_name(context_node)
+          context_node.children.first
+        end
+
+        def void_context_method?(method_name)
+          method_name == :initialize || setter_method?(method_name)
+        end
+
+        def setter_method?(method_name)
+          method_name.to_s.end_with?('=') &&
+            !AST::Node::COMPARISON_OPERATORS.include?(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # The safe navigation operator returns nil if the receiver is
+      # nil.  If you chain an ordinary method call after a safe
+      # navigation operator, it raises NoMethodError.  We should use a
+      # safe navigation operator after a safe navigation operator.
+      # This cop checks for the problem outlined above.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   x&.foo.bar
+      #   x&.foo + bar
+      #   x&.foo[bar]
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   x&.foo&.bar
+      #   x&.foo || bar
+      class SafeNavigationChain < Cop
+        extend TargetRubyVersion
+
+        MSG = 'Do not chain ordinary method call' \
+              ' after safe navigation operator.'.freeze
+
+        def_node_matcher :bad_method?, <<-PATTERN
+          (send (csend ...) $_ ...)
+        PATTERN
+
+        minimum_target_ruby_version 2.3
+
+        def on_send(node)
+          bad_method?(node) do |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, '&')
+          end
+        end
+
+        private
+
+        def nil_methods
+          nil.methods + whitelist
+        end
+
+        def whitelist
+          cop_config['Whitelist'].map(&:to_sym)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks if a file which has a shebang line as
+      # its first line is granted execute permission.
+      class ScriptPermission < Cop
+        MSG = "Script 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 if executable?(processed_source)
+          comment = processed_source.comments[0]
+          message = format_message_from(processed_source)
+          add_offense(comment, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |_corrector|
+            FileUtils.chmod('+x', node.loc.expression.source_buffer.name)
+          end
+        end
+
+        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?
+        end
+
+        def format_message_from(processed_source)
+          basename = File.basename(processed_source.buffer.name)
+          format(MSG, basename)
+        end
+      end
+    end
+  end
+end

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