rubocop 0.87.1

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

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for a rescued exception that get shadowed by a
+      # less specific exception being rescued before a more specific
+      # 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
+      #
+      #   # 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
+        include RangeHelp
+
+        MSG = 'Do not shadow rescued Exceptions.'
+
+        def on_rescue(node)
+          return if rescue_modifier?(node)
+
+          _body, *rescues, _else = *node
+          rescued_groups = rescued_groups_for(rescues)
+
+          rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|
+            contains_multiple_levels_of_exceptions?(group)
+          end
+
+          return if !rescue_group_rescues_multiple_levels &&
+                    sorted?(rescued_groups)
+
+          add_offense(node, location: offense_range(rescues))
+        end
+
+        private
+
+        def offense_range(rescues)
+          shadowing_rescue = find_shadowing_rescue(rescues)
+          expression = shadowing_rescue.loc.expression
+          range_between(expression.begin_pos, expression.end_pos)
+        end
+
+        def rescued_groups_for(rescues)
+          rescues.map do |group|
+            rescue_group, = *group
+            evaluate_exceptions(rescue_group)
+          end
+        end
+
+        def contains_multiple_levels_of_exceptions?(group)
+          # Always treat `Exception` as the highest level exception.
+          return true if group.size > 1 && group.include?(Exception)
+
+          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 silence_warnings
+          # Replaces Kernel::silence_warnings since it hides any warnings,
+          # including the RuboCop ones
+          old_verbose = $VERBOSE
+          $VERBOSE = nil
+          yield
+        ensure
+          $VERBOSE = old_verbose
+        end
+
+        def evaluate_exceptions(rescue_group)
+          if rescue_group
+            rescued_exceptions = rescued_exceptions(rescue_group)
+            rescued_exceptions.each_with_object([]) do |exception, converted|
+              begin
+                silence_warnings do
+                  # Avoid printing deprecation warnings about constants
+                  converted << Kernel.const_get(exception)
+                end
+              rescue NameError
+                converted << nil
+              end
+            end
+          else
+            # treat an empty `rescue` as `rescue StandardError`
+            [StandardError]
+          end
+        end
+
+        def sorted?(rescued_groups)
+          rescued_groups.each_cons(2).all? do |x, y|
+            if x.include?(Exception)
+              false
+            elsif y.include?(Exception)
+              true
+            elsif x.none? || y.none?
+              # consider sorted if a group is empty or only contains
+              # `nil`s
+              true
+            else
+              (x <=> y || 0) <= 0
+            end
+          end
+        end
+
+        # @param [RuboCop::AST::Node] rescue_group is a node of array_type
+        def rescued_exceptions(rescue_group)
+          klasses = *rescue_group
+          klasses.map do |klass|
+            next unless klass.const_type?
+
+            klass.source
+          end.compact
+        end
+
+        def find_shadowing_rescue(rescues)
+          rescued_groups = rescued_groups_for(rescues)
+          rescued_groups.zip(rescues).each do |group, res|
+            return res if contains_multiple_levels_of_exceptions?(group)
+          end
+
+          rescued_groups.each_cons(2).with_index do |group_pair, i|
+            return rescues[i] unless sorted?(group_pair)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop looks for use of the same name as outer local variables
+      # 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 - `%<variable>s`.'
+
+        def join_force?(force_class)
+          force_class == VariableForce
+        end
+
+        def before_declaring_variable(variable, variable_table)
+          return if variable.should_be_unused?
+
+          outer_local_variable = variable_table.find_variable(variable.name)
+          return unless outer_local_variable
+
+          message = format(MSG, variable: variable.name)
+          add_offense(variable.declaration_node, message: message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks unexpected overrides of the `Struct` built-in methods
+      # via `Struct.new`.
+      #
+      # @example
+      #   # bad
+      #   Bad = Struct.new(:members, :clone, :count)
+      #   b = Bad.new([], true, 1)
+      #   b.members #=> [] (overriding `Struct#members`)
+      #   b.clone #=> true (overriding `Object#clone`)
+      #   b.count #=> 1 (overriding `Enumerable#count`)
+      #
+      #   # good
+      #   Good = Struct.new(:id, :name)
+      #   g = Good.new(1, "foo")
+      #   g.members #=> [:id, :name]
+      #   g.clone #=> #<struct Good id=1, name="foo">
+      #   g.count #=> 2
+      #
+      class StructNewOverride < Cop
+        MSG = '`%<member_name>s` member overrides `Struct#%<method_name>s`' \
+              ' and it may be unexpected.'
+
+        STRUCT_METHOD_NAMES = Struct.instance_methods
+        STRUCT_MEMBER_NAME_TYPES = %i[sym str].freeze
+
+        def_node_matcher :struct_new, <<~PATTERN
+          (send
+            (const ${nil? cbase} :Struct) :new ...)
+        PATTERN
+
+        def on_send(node)
+          return unless struct_new(node) do
+            node.arguments.each_with_index do |arg, index|
+              # Ignore if the first argument is a class name
+              next if index.zero? && arg.str_type?
+
+              # Ignore if the argument is not a member name
+              next unless STRUCT_MEMBER_NAME_TYPES.include?(arg.type)
+
+              member_name = arg.value
+
+              next unless STRUCT_METHOD_NAMES.include?(member_name.to_sym)
+
+              message = format(MSG, member_name: member_name.inspect,
+                                    method_name: member_name.to_s)
+              add_offense(arg, message: message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for `rescue` blocks with no body.
+      #
+      # @example
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #   end
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     handle_exception
+      #   end
+      #
+      # @example AllowComments: true (default)
+      #
+      #   # good
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # good
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      # @example AllowComments: false
+      #
+      #   # bad
+      #   def some_method
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      #
+      #   # bad
+      #   begin
+      #     do_something
+      #   rescue
+      #     # do nothing
+      #   end
+      class SuppressedException < Cop
+        MSG = 'Do not suppress exceptions.'
+
+        def on_resbody(node)
+          return if node.body
+          return if cop_config['AllowComments'] && comment_between_rescue_and_end?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def comment_between_rescue_and_end?(node)
+          end_line = nil
+          node.each_ancestor(:kwbegin, :def, :defs, :block) do |ancestor|
+            end_line = ancestor.loc.end.line
+            break
+          end
+          return false unless end_line
+
+          processed_source[node.first_line...end_line].any? { |line| comment_line?(line) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop repacks Parser's diagnostics/errors
+      # into RuboCop's offenses.
+      class Syntax < Base
+        def on_other_file
+          add_offense_from_error(processed_source.parser_error) if processed_source.parser_error
+          processed_source.diagnostics.each do |diagnostic|
+            add_offense_from_diagnostic(diagnostic,
+                                        processed_source.ruby_version)
+          end
+          super
+        end
+
+        private
+
+        def add_offense_from_diagnostic(diagnostic, ruby_version)
+          message =
+            "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
+            'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+          add_offense(diagnostic.location,
+                      message: message,
+                      severity: diagnostic.level)
+        end
+
+        def add_offense_from_error(error)
+          message = beautify_message(error.message)
+          add_global_offense(message, severity: :fatal)
+        end
+
+        def beautify_message(message)
+          message = message.capitalize
+          message << '.' unless message.end_with?('.')
+          message
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks to make sure `#to_json` includes an optional argument.
+      # When overriding `#to_json`, callers may invoke JSON
+      # generation via `JSON.generate(your_obj)`.  Since `JSON#generate` allows
+      # for an optional argument, your method should too.
+      #
+      # @example
+      #   # bad
+      #   def to_json
+      #   end
+      #
+      #   # good
+      #   def to_json(*_args)
+      #   end
+      #
+      class ToJSON < Cop
+        MSG = ' `#to_json` requires an optional argument to be parsable ' \
+          'via JSON.generate(obj).'
+
+        def on_def(node)
+          return unless node.method?(:to_json) && node.arguments.empty?
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            # The following used `*_args` because `to_json(*args)` has
+            # an offense of `Lint/UnusedMethodArgument` cop if `*args`
+            # is not used.
+            corrector.insert_after(node.loc.name, '(*_args)')
+          end
+        end
+      end
+    end
+  end
+end