rubocop 0.49.1 → 0.52.0

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

@@ -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
@@ -47,13 +49,13 @@ module RuboCop
           range = range_between(node.source_range.begin_pos,
                                 ternary.condition.source_range.end_pos)
 
-          add_offense(range, range)
+          add_offense(range, location: range)
         end
 
         def check_predicate(predicate, node)
           return unless predicate.operator_keyword?
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
       end
     end

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

@@ -33,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

@@ -48,28 +48,37 @@ module RuboCop
           invalid_exceptions = invalid_exceptions(exceptions)
           return if invalid_exceptions.empty?
 
-          add_offense(node,
-                      node.loc.keyword.join(rescued.loc.expression),
-                      format(MSG, invalid_exceptions.map(&:source).join(', ')))
+          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
-          exceptions = *rescued
-          valid_exceptions = exceptions - invalid_exceptions(exceptions)
-          correction = valid_exceptions.map(&:source).join(', ')
-          correction = " #{correction}" unless correction.empty?
-          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)
 
           lambda do |corrector|
-            corrector.replace(range, correction)
+            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)

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

@@ -41,7 +41,7 @@ module RuboCop
 
             loc = node.loc.dot || :selector
 
-            add_offense(node, loc)
+            add_offense(node, location: loc)
           end
         end
 

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

@@ -10,12 +10,19 @@ 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)
           comment = processed_source.comments[0]
           message = format_message_from(processed_source)
-          add_offense(comment, :expression, message)
+          add_offense(comment, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |_corrector|
+            FileUtils.chmod('+x', node.loc.expression.source_buffer.name)
+          end
         end
 
         private

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/shadowed_exception.rb

@@ -19,8 +19,6 @@ module RuboCop
       #     handle_standard_error
       #   end
       #
-      # @example
-      #
       #   # good
       #
       #   begin
@@ -30,6 +28,21 @@ module RuboCop
       #   rescue Exception
       #     handle_exception
       #   end
+      #
+      #   # good, however depending on runtime environment.
+      #   #
+      #   # This is a special case for system call errors.
+      #   # System dependent error code depends on runtime environment.
+      #   # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
+      #   # the same error code or different error code depends on environment.
+      #   # This good case is for `Errno::EAGAIN` and `Errno::EWOULDBLOCK` with
+      #   # the same error code.
+      #   begin
+      #     something
+      #   rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+      #     handle_standard_error
+      #   end
+      #
       class ShadowedException < Cop
         include RescueNode
 
@@ -51,7 +64,7 @@ module RuboCop
           return if !rescue_group_rescues_multiple_levels &&
                     sorted?(rescued_groups)
 
-          add_offense(node, offense_range(rescues))
+          add_offense(node, location: offense_range(rescues))
         end
 
         private
@@ -77,7 +90,27 @@ module RuboCop
             return !(group.size == 2 && group.include?(NilClass))
           end
 
-          group.combination(2).any? { |a, b| a && b && a <=> b }
+          group.combination(2).any? do |a, b|
+            compare_exceptions(a, b)
+          end
+        end
+
+        def compare_exceptions(exception, other_exception)
+          if system_call_err?(exception) && system_call_err?(other_exception)
+            # This condition logic is for special case.
+            # System dependent error code depends on runtime environment.
+            # For example, whether `Errno::EAGAIN` and `Errno::EWOULDBLOCK` are
+            # the same error code or different error code depends on runtime
+            # environment. This checks the error code for that.
+            exception.const_get(:Errno) != other_exception.const_get(:Errno) &&
+              exception <=> other_exception
+          else
+            exception && other_exception && exception <=> other_exception
+          end
+        end
+
+        def system_call_err?(error)
+          error && error.ancestors[1] == SystemCallError
         end
 
         def evaluate_exceptions(rescue_group)
@@ -116,12 +149,6 @@ module RuboCop
         def rescued_exceptions(rescue_group)
           klasses = *rescue_group
           klasses.map do |klass|
-            # `rescue nil` is valid syntax in all versions of Ruby. In Ruby
-            # 1.9.3, it effectively disables the `rescue`. In versions
-            # after 1.9.3, a `TypeError` is thrown when the statement is
-            # rescued. In order to account for this, we convert `nil` to
-            # `NilClass`.
-            next 'NilClass' if klass.nil_type?
             next unless klass.const_type?
             klass.source
           end.compact