rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,25 +8,45 @@ module RuboCop
       # exception is rescued.
       #
       # @example
-      # # bad
-      # begin
-      #   something
-      # rescue Exception
-      #   handle_exception
-      # rescue StandardError
-      #   handle_standard_error
-      # end
       #
-      # #good
-      # begin
-      #   something
-      # rescue StandardError
-      #   handle_standard_error
-      # rescue Exception
-      #   handle_exception
-      # end
+      #   # bad
+      #
+      #   begin
+      #     something
+      #   rescue Exception
+      #     handle_exception
+      #   rescue StandardError
+      #     handle_standard_error
+      #   end
+      #
+      #   # good
+      #
+      #   begin
+      #     something
+      #   rescue StandardError
+      #     handle_standard_error
+      #   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
-        MSG = 'Do not shadow rescued Exceptions'.freeze
+        include RescueNode
+
+        MSG = 'Do not shadow rescued Exceptions.'.freeze
 
         def on_rescue(node)
           return if rescue_modifier?(node)
@@ -43,26 +62,25 @@ module RuboCop
           end
 
           return if !rescue_group_rescues_multiple_levels &&
-                    rescued_groups == sort_rescued_groups(rescued_groups)
+                    sorted?(rescued_groups)
 
-          add_offense(node, offense_range(node, rescues))
+          add_offense(node, location: offense_range(rescues))
         end
 
         private
 
-        def offense_range(node, rescues)
+        def offense_range(rescues)
           first_rescue = rescues.first
           last_rescue = rescues.last
           last_exceptions, = *last_rescue
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    first_rescue.loc.expression.begin_pos,
-                                    last_exceptions.loc.expression.end_pos)
-        end
+          # last_rescue clause may not specify exception class
+          end_pos = if last_exceptions
+                      last_exceptions.loc.expression.end_pos
+                    else
+                      last_rescue.loc.keyword.end_pos
+                    end
 
-        def rescue_modifier?(node)
-          node && node.rescue_type? &&
-            (node.parent.nil? || !(node.parent.kwbegin_type? ||
-             node.parent.ensure_type?))
+          range_between(first_rescue.loc.expression.begin_pos, end_pos)
         end
 
         def contains_multiple_levels_of_exceptions?(group)
@@ -72,29 +90,36 @@ module RuboCop
             return !(group.size == 2 && group.include?(NilClass))
           end
 
-          group.any? do |exception|
-            higher_exception = false
-            group.each_with_index do |_e, i|
-              higher_exception ||= begin
-                                     if group[i].nil? || exception.nil?
-                                       false
-                                     else
-                                       group[i] < exception
-                                     end
-                                   end
-            end
+          group.combination(2).any? do |a, b|
+            compare_exceptions(a, b)
+          end
+        end
 
-            higher_exception
+        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)
           if rescue_group
             rescued_exceptions = rescued_exceptions(rescue_group)
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
-                converted << instance_eval(exception, __FILE__, __LINE__)
-              rescue StandardError, ScriptError
+                converted << Kernel.const_get(exception)
+              rescue NameError
                 converted << nil
               end
             end
@@ -104,30 +129,26 @@ module RuboCop
           end
         end
 
-        def sort_rescued_groups(groups)
-          groups.sort do |x, y|
+        def sorted?(rescued_groups)
+          rescued_groups.each_cons(2).all? do |x, y|
             if x.include?(Exception)
-              1
+              false
             elsif y.include?(Exception)
-              -1
-            elsif x.empty? || y.empty?
-              0
+              true
+            elsif x.none? || y.none?
+              # consider sorted if a group is empty or only contains
+              # `nil`s
+              true
             else
-              x <=> y || 0
+              (x <=> y || 0) <= 0
             end
           end
         end
 
-        # @param [RuboCop::Node] rescue_group is a node of array_type
+        # @param [RuboCop::AST::Node] rescue_group is a node of array_type
         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

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,6 +7,30 @@ module RuboCop
       # for block arguments or block local variables.
       # This is a mimic of the warning
       # "shadowing outer local variable - foo" from `ruby -cw`.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   def some_method
+      #     foo = 1
+      #
+      #     2.times do |foo| # shadowing outer `foo`
+      #       do_something(foo)
+      #     end
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   def some_method
+      #     foo = 1
+      #
+      #     2.times do |bar|
+      #       do_something(bar)
+      #     end
+      #   end
       class ShadowingOuterLocalVariable < Cop
         MSG = 'Shadowing outer local variable - `%s`.'.freeze
 
@@ -22,7 +45,7 @@ module RuboCop
           return unless outer_local_variable
 
           message = format(MSG, variable.name)
-          add_offense(variable.declaration_node, :expression, message)
+          add_offense(variable.declaration_node, message: message)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,30 +8,31 @@ module RuboCop
       #
       # @example
       #
+      #   # bad
+      #
       #   "result is #{something.to_s}"
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   "result is #{something}"
       class StringConversionInInterpolation < Cop
         MSG_DEFAULT = 'Redundant use of `Object#to_s` in interpolation.'.freeze
         MSG_SELF = 'Use `self` instead of `Object#to_s` in ' \
                    'interpolation.'.freeze
 
         def on_dstr(node)
-          node.children.select { |n| n.type == :begin }.each do |begin_node|
+          node.each_child_node(:begin) do |begin_node|
             final_node = begin_node.children.last
-            next unless final_node && final_node.type == :send
 
-            receiver, method_name, *args = *final_node
-            next unless method_name == :to_s && args.empty?
+            next unless final_node && final_node.send_type? &&
+                        final_node.method?(:to_s) && !final_node.arguments?
 
-            add_offense(
-              final_node,
-              :selector,
-              receiver ? MSG_DEFAULT : MSG_SELF
-            )
+            add_offense(final_node, location: :selector)
           end
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             receiver, _method_name, *_args = *node
@@ -46,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/syntax.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,50 +5,53 @@ module RuboCop
     module Lint
       # This is actually not a cop and inspects nothing. It just provides
       # methods to repack Parser's diagnostics/errors into RuboCop's offenses.
-      module Syntax
+      class Syntax < Cop
         PseudoSourceRange = Struct.new(:line, :column, :source_line, :begin_pos,
                                        :end_pos)
 
-        COP_NAME = 'Syntax'.freeze
         ERROR_SOURCE_RANGE = PseudoSourceRange.new(1, 0, '', 0, 1).freeze
 
-        def self.offenses_from_processed_source(processed_source)
-          offenses = []
+        def self.offenses_from_processed_source(processed_source,
+                                                config, options)
+          cop = new(config, options)
 
           if processed_source.parser_error
-            offenses << offense_from_error(processed_source.parser_error)
+            cop.add_offense_from_error(processed_source.parser_error)
           end
 
           processed_source.diagnostics.each do |diagnostic|
-            offenses << offense_from_diagnostic(diagnostic,
-                                                processed_source.ruby_version)
+            cop.add_offense_from_diagnostic(diagnostic,
+                                            processed_source.ruby_version)
           end
 
-          offenses
+          cop.offenses
         end
 
-        def self.offense_from_diagnostic(diagnostic, ruby_version)
-          Offense.new(
-            diagnostic.level,
-            diagnostic.location,
+        def add_offense_from_diagnostic(diagnostic, ruby_version)
+          message =
             "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
-            'configure using `TargetRubyVersion` parameter, under `AllCops`)',
-            COP_NAME
-          )
+            'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+          add_offense(nil,
+                      location: diagnostic.location,
+                      message: message,
+                      severity: diagnostic.level)
         end
 
-        def self.offense_from_error(error)
+        def add_offense_from_error(error)
           message = beautify_message(error.message)
-          Offense.new(:fatal, ERROR_SOURCE_RANGE, message, COP_NAME)
+          add_offense(nil,
+                      location: ERROR_SOURCE_RANGE,
+                      message: message,
+                      severity: :fatal)
         end
 
-        def self.beautify_message(message)
+        private
+
+        def beautify_message(message)
           message = message.capitalize
           message << '.' unless message.end_with?('.')
           message
         end
-
-        private_class_method :beautify_message
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,6 +5,30 @@ module RuboCop
     module Lint
       # This cop checks for underscore-prefixed variables that are actually
       # used.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something(_num)
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each do |num|
+      #     do_something(num)
+      #   end
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   [1, 2, 3].each do |_num|
+      #     do_something # not using `_num`
+      #   end
       class UnderscorePrefixedVariableName < Cop
         MSG = 'Do not use prefix `_` for a variable that is used.'.freeze
 
@@ -21,18 +44,17 @@ module RuboCop
 
         def check_variable(variable)
           return unless variable.should_be_unused?
-          return if variable.references.empty?
           return if variable.references.none?(&:explicit?)
 
           node = variable.declaration_node
 
-          location = if node.type == :match_with_lvasgn
+          location = if node.match_with_lvasgn_type?
                        node.children.first.source_range
                      else
                        node.loc.name
                      end
 
-          add_offense(nil, location)
+          add_offense(nil, location: location)
         end
       end
     end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for using Fixnum or Bignum constant.
+      #
+      # @example
+      #
+      #   # bad
+      #
+      #   1.is_a?(Fixnum)
+      #   1.is_a?(Bignum)
+      #
+      # @example
+      #
+      #   # good
+      #
+      #   1.is_a?(Integer)
+      class UnifiedInteger < Cop
+        MSG = 'Use `Integer` instead of `%s`.'.freeze
+
+        def_node_matcher :fixnum_or_bignum_const, <<-PATTERN
+          (:const {nil? (:cbase)} ${:Fixnum :Bignum})
+        PATTERN
+
+        def on_const(node)
+          klass = fixnum_or_bignum_const(node)
+
+          return unless klass
+
+          add_offense(node, message: format(MSG, klass))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.name, 'Integer')
+          end
+        end
+      end
+    end
+  end
+end