rubocop 0.51.0 → 0.52.0

data/lib/rubocop/cop/internal_affairs/deprecated_positional_arguments.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module InternalAffairs
-      # Enforces use of keyword arguments for `#add_offense`.
-      #
-      # @example
-      #
-      #   # bad
-      #   add_offense(node, :selector, 'message')
-      #   add_offense(node, :selector, message: 'message')
-      #
-      #   # good
-      #   add_offense(node, location: :selector, message: 'message')
-      #
-      class DeprecatedPositionalArguments < Cop
-        MSG = 'Use of positional arguments on `#add_offense` is ' \
-          'deprecated.'.freeze
-
-        ARGUMENTS = %i[location message severity].freeze
-
-        def on_send(node)
-          return unless node.method_name == :add_offense
-
-          positional_arguments(node) do |arguments|
-            location = range_between(
-              arguments.first.loc.expression.begin_pos,
-              arguments.last.loc.expression.end_pos
-            )
-
-            add_offense(node, location: location)
-          end
-        end
-
-        def autocorrect(node)
-          positional_arguments(node) do |arguments|
-            # Can't autocorrect splat.
-            next if arguments.any?(&:splat_type?)
-
-            lambda do |corrector|
-              arguments.zip(ARGUMENTS).each do |(arg, keyword)|
-                corrector.replace(arg.source_range, "#{keyword}: #{arg.source}")
-              end
-            end
-          end
-        end
-
-        private
-
-        def positional_arguments(node)
-          arguments = extract_arguments(node)
-
-          positional_args =
-            case arguments
-            when :empty?.to_proc then []
-            # Keyword arguments only
-            when ->(args) { args.one? && args.first.hash_type? } then []
-            # Mixed style
-            when ->(args) { args.last.hash_type? } then arguments.drop_last(1)
-            # Positional arguments only
-            else arguments
-            end
-
-          yield positional_args if positional_args.any?
-        end
-
-        def extract_arguments(node)
-          node.arguments.butfirst.take_while do |arg|
-            # Filter out block argument
-            next false if arg.block_pass_type?
-            # Filter out kwsplat
-            next false if arg.hash_type? && arg.each_child_node(:kwsplat).any?
-            # Keep all others
-            true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/layout/space_inside_brackets.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Layout
-      # Checks for spaces inside square brackets.
-      class SpaceInsideBrackets < Cop
-        include SpaceInside
-
-        def specifics
-          [
-            %i[tLBRACK tLBRACK2],
-            :tRBRACK,
-            'square brackets'
-          ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Lint
-      # This cop checks for uses of `rescue` with no error class specified.
-      #
-      # @example
-      #
-      #   # good
-      #   begin
-      #     foo
-      #   rescue BarError
-      #     bar
-      #   end
-      #
-      #   # bad
-      #   begin
-      #     foo
-      #   rescue
-      #     bar
-      #   end
-      class RescueWithoutErrorClass < Cop
-        include RescueNode
-
-        MSG = 'Avoid rescuing without specifying an error class.'.freeze
-
-        def_node_matcher :rescue_without_error_class?, <<-PATTERN
-          (resbody nil? _ _)
-        PATTERN
-
-        def on_resbody(node)
-          return unless rescue_without_error_class?(node) &&
-                        !rescue_modifier?(node)
-
-          add_offense(node, location: :keyword)
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/mixin/space_inside.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking for spaces inside various
-    # kinds of brackets.
-    module SpaceInside
-      include SurroundingSpace
-      MSG = 'Space inside %s detected.'.freeze
-
-      def investigate(processed_source)
-        @processed_source = processed_source
-        each_extraneous_space(processed_source.tokens) do |kind, range|
-          add_offense(range, location: range, message: format(MSG, kind))
-        end
-      end
-
-      def autocorrect(range)
-        ->(corrector) { corrector.remove(range) }
-      end
-
-      private
-
-      def each_extraneous_space(tokens)
-        brackets = Brackets.new(*specifics)
-        tokens.each_cons(2) do |t1, t2|
-          next unless matching_brackets?(brackets, t1, t2)
-
-          # If the second token is a comment, that means that a line break
-          # follows, and that the rules for space inside don't apply.
-          next if t2.type == :tCOMMENT
-          next unless t2.pos.line == t1.pos.line && space_between?(t1, t2)
-
-          yield brackets.kind, range_between_tokens(t1, t2)
-        end
-      end
-
-      def matching_brackets?(brackets, t1, t2)
-        brackets.left_side?(t1) || brackets.right_side?(t2)
-      end
-
-      def range_between_tokens(t1, t2)
-        range_between(t1.pos.end_pos, t2.pos.begin_pos)
-      end
-
-      # Wraps info about the brackets. Makes it easy to check whether a token
-      # is one of the brackets.
-      #
-      # @example Parentheses `()`
-      #   Brackets.new(:tLPAREN, :tRPAREN, 'parentheses')
-      #
-      # @example Square brackets `[]`
-      #   Brackets.new([:tLBRACK, :tLBRACK2], :tRBRACK, 'square brackets')
-      #
-      class Brackets
-        attr_reader :kind
-
-        def initialize(left, right, kind)
-          @left_side_types = [left].flatten
-          @right_side_type = right
-          @kind = kind
-        end
-
-        def left_side?(token)
-          # Left side bracket has to be able to match multiple types
-          # (e.g. :tLBRACK and :tLBRACK2)
-          @left_side_types.include?(token.type)
-        end
-
-        def right_side?(token)
-          @right_side_type == token.type
-        end
-      end
-    end
-  end
-end