rubocop 0.51.0 → 0.87.0

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

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking length of classes and modules.
-    module ClassishLength
-      include CodeLength
-
-      private
-
-      def code_length(node)
-        body_line_numbers = line_range(node).to_a[1...-1]
-
-        target_line_numbers = body_line_numbers -
-                              line_numbers_of_inner_nodes(node, :module, :class)
-
-        target_line_numbers.reduce(0) do |length, line_number|
-          source_line = processed_source[line_number]
-          next length if irrelevant_line(source_line)
-          length + 1
-        end
-      end
-
-      def line_numbers_of_inner_nodes(node, *types)
-        line_numbers = Set.new
-
-        node.each_descendant(*types) do |inner_node|
-          line_range = line_range(inner_node)
-          line_numbers.merge(line_range)
-        end
-
-        line_numbers.to_a
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for Rails safe mode.
-    module SafeMode
-      private
-
-      def rails_safe_mode?
-        safe_mode? || rails?
-      end
-
-      def safe_mode?
-        cop_config['SafeMode']
-      end
-
-      def rails?
-        config['Rails'] && config['Rails'].fetch('Enabled')
-      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

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    # Common functionality for checking target rails version.
-    module TargetRailsVersion
-      def minimum_target_rails_version(version)
-        @minimum_target_rails_version = version
-      end
-
-      def support_target_rails_version?(version)
-        @minimum_target_rails_version <= version
-      end
-    end
-  end
-end

data/lib/rubocop/cop/performance/caller.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `caller[n]`
-      # can be replaced by `caller(n..n).first`.
-      #
-      # @example
-      #   # bad
-      #   caller[1]
-      #   caller.first
-      #   caller_locations[1]
-      #   caller_locations.first
-      #
-      #   # good
-      #   caller(2..2).first
-      #   caller(1..1).first
-      #   caller_locations(2..2).first
-      #   caller_locations(1..1).first
-      class Caller < Cop
-        MSG_BRACE = 'Use `%<method>s(%<n>d..%<n>d).first`' \
-                    ' instead of `%<method>s[%<m>d]`.'.freeze
-        MSG_FIRST = 'Use `%<method>s(%<n>d..%<n>d).first`' \
-                    ' instead of `%<method>s.first`.'.freeze
-
-        def_node_matcher :slow_caller?, <<-PATTERN
-          {
-            (send nil? {:caller :caller_locations})
-            (send nil? {:caller :caller_locations} int)
-          }
-        PATTERN
-
-        def_node_matcher :caller_with_scope_method?, <<-PATTERN
-          {
-            (send #slow_caller? :first)
-            (send #slow_caller? :[] int)
-          }
-        PATTERN
-
-        def on_send(node)
-          return unless caller_with_scope_method?(node)
-
-          add_offense(node)
-        end
-
-        private
-
-        def message(node)
-          method_name = node.receiver.method_name
-          caller_arg = node.receiver.first_argument
-          n = caller_arg ? int_value(caller_arg) : 1
-
-          if node.method_name == :[]
-            m = int_value(node.first_argument)
-            n += m
-            format(MSG_BRACE, n: n, m: m, method: method_name)
-          else
-            format(MSG_FIRST, n: n, method: method_name)
-          end
-        end
-
-        def int_value(node)
-          node.children[0]
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # Place `when` conditions that use splat at the end
-      # of the list of `when` branches.
-      #
-      # Ruby has to allocate memory for the splat expansion every time
-      # that the `case` `when` statement is run. Since Ruby does not support
-      # fall through inside of `case` `when`, like some other languages do,
-      # the order of the `when` branches does not matter. By placing any
-      # splat expansions at the end of the list of `when` branches we will
-      # reduce the number of times that memory has to be allocated for
-      # the expansion.
-      #
-      # This is not a guaranteed performance improvement. If the data being
-      # processed by the `case` condition is normalized in a manner that favors
-      # hitting a condition in the splat expansion, it is possible that
-      # moving the splat condition to the end will use more memory,
-      # and run slightly slower.
-      #
-      # @example
-      #   # bad
-      #   case foo
-      #   when *condition
-      #     bar
-      #   when baz
-      #     foobar
-      #   end
-      #
-      #   case foo
-      #   when *[1, 2, 3, 4]
-      #     bar
-      #   when 5
-      #     baz
-      #   end
-      #
-      #   # good
-      #   case foo
-      #   when baz
-      #     foobar
-      #   when *condition
-      #     bar
-      #   end
-      #
-      #   case foo
-      #   when 1, 2, 3, 4
-      #     bar
-      #   when 5
-      #     baz
-      #   end
-      class CaseWhenSplat < Cop
-        include AutocorrectAlignment
-
-        MSG = 'Place `when` conditions with a splat ' \
-              'at the end of the `when` branches.'.freeze
-        ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
-        PERCENT_W = '%w'.freeze
-        PERCENT_CAPITAL_W = '%W'.freeze
-        PERCENT_I = '%i'.freeze
-        PERCENT_CAPITAL_I = '%I'.freeze
-
-        def on_case(case_node)
-          when_conditions = case_node.when_branches.flat_map(&:conditions)
-
-          splat_offenses(when_conditions).reverse_each do |condition|
-            range = condition.parent.loc.keyword.join(condition.source_range)
-            variable, = *condition
-            message = variable.array_type? ? ARRAY_MSG : MSG
-            add_offense(condition.parent, location: range, message: message)
-          end
-        end
-
-        private
-
-        def autocorrect(when_node)
-          lambda do |corrector|
-            if needs_reorder?(when_node)
-              reorder_condition(corrector, when_node)
-            else
-              inline_fix_branch(corrector, when_node)
-            end
-          end
-        end
-
-        def replacement(conditions)
-          reordered = conditions.partition(&:splat_type?).reverse
-          reordered.flatten.map(&:source).join(', ')
-        end
-
-        def inline_fix_branch(corrector, when_node)
-          conditions = when_node.conditions
-          range = range_between(conditions[0].loc.expression.begin_pos,
-                                conditions[-1].loc.expression.end_pos)
-
-          corrector.replace(range, replacement(conditions))
-        end
-
-        def reorder_condition(corrector, when_node)
-          when_branches = when_node.parent.when_branches
-
-          return if when_branches.one?
-
-          corrector.remove(when_branch_range(when_node))
-          corrector.insert_after(when_branches.last.source_range,
-                                 reordering_correction(when_node))
-        end
-
-        def reordering_correction(when_node)
-          new_condition = replacement(when_node.conditions)
-
-          if same_line?(when_node, when_node.body)
-            new_condition_with_then(when_node, new_condition)
-          else
-            new_branch_without_then(when_node, new_condition)
-          end
-        end
-
-        def when_branch_range(when_node)
-          next_branch =
-            when_node.parent.when_branches[when_node.branch_index + 1]
-
-          range_between(when_node.source_range.begin_pos,
-                        next_branch.source_range.begin_pos)
-        end
-
-        def new_condition_with_then(node, new_condition)
-          "\n#{indent_for(node)}when " \
-          "#{new_condition} then #{node.body.source}"
-        end
-
-        def new_branch_without_then(node, new_condition)
-          "\n#{indent_for(node)}when #{new_condition}" \
-          "\n#{indent_for(node.body)}#{node.body.source}"
-        end
-
-        def indent_for(node)
-          ' ' * node.loc.column
-        end
-
-        def splat_offenses(when_conditions)
-          found_non_splat = false
-
-          offenses = when_conditions.reverse.map do |condition|
-            found_non_splat ||= non_splat?(condition)
-
-            next if non_splat?(condition)
-
-            condition if found_non_splat
-          end
-
-          offenses.compact
-        end
-
-        def non_splat?(condition)
-          variable, = *condition
-
-          (condition.splat_type? && variable.array_type?) ||
-            !condition.splat_type?
-        end
-
-        def needs_reorder?(when_node)
-          following_branches =
-            when_node.parent.when_branches[(when_node.branch_index + 1)..-1]
-
-          following_branches.any? do |when_branch|
-            when_branch.conditions.any? do |condition|
-              non_splat?(condition)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/performance/casecmp.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where a case-insensitive string comparison
-      # can better be implemented using `casecmp`.
-      #
-      # @example
-      #   @bad
-      #   str.downcase == 'abc'
-      #   str.upcase.eql? 'ABC'
-      #   'abc' == str.downcase
-      #   'ABC'.eql? str.upcase
-      #   str.downcase == str.downcase
-      #
-      #   @good
-      #   str.casecmp('ABC').zero?
-      #   'abc'.casecmp(str).zero?
-      class Casecmp < Cop
-        MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
-        CASE_METHODS = %i[downcase upcase].freeze
-
-        def_node_matcher :downcase_eq, <<-PATTERN
-          (send
-            $(send _ ${:downcase :upcase})
-            ${:== :eql? :!=}
-            ${str (send _ {:downcase :upcase} ...) (begin str)})
-        PATTERN
-
-        def_node_matcher :eq_downcase, <<-PATTERN
-          (send
-            {str (send _ {:downcase :upcase} ...) (begin str)}
-            ${:== :eql? :!=}
-            $(send _ ${:downcase :upcase}))
-        PATTERN
-
-        def on_send(node)
-          return if part_of_ignored_node?(node)
-
-          inefficient_comparison(node) do |range, is_other_part, *methods|
-            ignore_node(node) if is_other_part
-            add_offense(node, location: range, message: format(MSG, *methods))
-          end
-        end
-
-        def autocorrect(node)
-          downcase_eq(node) do
-            receiver, method, arg = *node
-            variable, = *receiver
-            return correction(node, receiver, method, arg, variable)
-          end
-
-          eq_downcase(node) do
-            arg, method, receiver = *node
-            variable, = *receiver
-            return correction(node, receiver, method, arg, variable)
-          end
-        end
-
-        private
-
-        def inefficient_comparison(node)
-          loc = node.loc
-
-          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
-            *_, method = *other
-            range, is_other_part = downcase_eq_range(method, loc, send_downcase)
-
-            yield range, is_other_part, case_method, eq_method
-            return
-          end
-
-          eq_downcase(node) do |eq_method, send_downcase, case_method|
-            range = loc.selector.join(send_downcase.loc.selector)
-            yield range, false, eq_method, case_method
-          end
-        end
-
-        def downcase_eq_range(method, loc, send_downcase)
-          if CASE_METHODS.include?(method)
-            [loc.expression, true]
-          else
-            [loc.selector.join(send_downcase.loc.selector), false]
-          end
-        end
-
-        def correction(node, _receiver, method, arg, variable)
-          lambda do |corrector|
-            corrector.insert_before(node.loc.expression, '!') if method == :!=
-
-            # we want resulting call to be parenthesized
-            # if arg already includes one or more sets of parens, don't add more
-            # or if method call already used parens, again, don't add more
-            replacement = if arg.send_type? || !parentheses?(arg)
-                            "#{variable.source}.casecmp(#{arg.source}).zero?"
-                          else
-                            "#{variable.source}.casecmp#{arg.source}.zero?"
-                          end
-
-            corrector.replace(node.loc.expression, replacement)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/performance/compare_with_block.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Performance
-      # This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
-      # can be replaced by `sort_by(&:foo)`.
-      # This cop also checks `max` and `min` methods.
-      #
-      # @example
-      #   @bad
-      #   array.sort { |a, b| a.foo <=> b.foo }
-      #   array.max { |a, b| a.foo <=> b.foo }
-      #   array.min { |a, b| a.foo <=> b.foo }
-      #   array.sort { |a, b| a[:foo] <=> b[:foo] }
-      #
-      #   @good
-      #   array.sort_by(&:foo)
-      #   array.sort_by { |v| v.foo }
-      #   array.sort_by do |var|
-      #     var.foo
-      #   end
-      #   array.max_by(&:foo)
-      #   array.min_by(&:foo)
-      #   array.sort_by { |a| a[:foo] }
-      class CompareWithBlock < Cop
-        MSG = 'Use `%s_by%s` instead of ' \
-              '`%s { |%s, %s| %s <=> %s }`.'.freeze
-
-        def_node_matcher :compare?, <<-PATTERN
-          (block
-            $(send _ {:sort :min :max})
-            (args (arg $_a) (arg $_b))
-            $send)
-        PATTERN
-
-        def_node_matcher :replaceable_body?, <<-PATTERN
-          (send
-            (send (lvar %1) $_method $...)
-            :<=>
-            (send (lvar %2) _method $...))
-        PATTERN
-
-        def on_block(node)
-          compare?(node) do |send, var_a, var_b, body|
-            replaceable_body?(body, var_a, var_b) do |method, args_a, args_b|
-              return unless slow_compare?(method, args_a, args_b)
-              range = compare_range(send, node)
-
-              add_offense(
-                node,
-                location: range,
-                message: message(send, method, var_a, var_b, args_a)
-              )
-            end
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            send, var_a, var_b, body = compare?(node)
-            method, arg, = replaceable_body?(body, var_a, var_b)
-            replacement =
-              if method == :[]
-                "#{send.method_name}_by { |a| a[#{arg.first.source}] }"
-              else
-                "#{send.method_name}_by(&:#{method})"
-              end
-            corrector.replace(compare_range(send, node),
-                              replacement)
-          end
-        end
-
-        private
-
-        def slow_compare?(method, args_a, args_b)
-          return false unless args_a == args_b
-          if method == :[]
-            return false unless args_a.size == 1
-            key = args_a.first
-            return false unless %i[sym str int].include?(key.type)
-          else
-            return false unless args_a.empty?
-          end
-          true
-        end
-
-        def message(send, method, var_a, var_b, args)
-          compare_method = send.method_name
-          if method == :[]
-            key = args.first
-            instead = " { |a| a[#{key.source}] }"
-            str_a = "#{var_a}[#{key.source}]"
-            str_b = "#{var_b}[#{key.source}]"
-          else
-            instead = "(&:#{method})"
-            str_a = "#{var_a}.#{method}"
-            str_b = "#{var_b}.#{method}"
-          end
-          format(MSG, compare_method, instead,
-                 compare_method, var_a, var_b,
-                 str_a, str_b)
-        end
-
-        def compare_range(send, node)
-          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
-        end
-      end
-    end
-  end
-end