rubocop 0.70.0 → 0.75.0

data/lib/rubocop/cop/rails/redundant_allow_nil.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # Checks Rails model validations for a redundant `allow_nil` when
-      # `allow_blank` is present.
-      #
-      # @example
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: true
-      #
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: true
-      #
-      #   # bad
-      #   validates :x, length: { is: 5 }, allow_nil: false, allow_blank: false
-      #
-      #   # good
-      #   validates :x, length: { is: 5 }, allow_blank: true
-      #
-      #   # good
-      #   validates :x, length: { is: 5 }, allow_blank: false
-      #
-      #   # good
-      #   # Here, `nil` is valid but `''` is not
-      #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: false
-      #
-      class RedundantAllowNil < Cop
-        include RangeHelp
-
-        MSG_SAME =
-          '`allow_nil` is redundant when `allow_blank` has the same value.'
-
-        MSG_ALLOW_NIL_FALSE =
-          '`allow_nil: false` is redundant when `allow_blank` is true.'
-
-        def on_send(node)
-          return unless node.method_name == :validates
-
-          allow_nil, allow_blank = find_allow_nil_and_allow_blank(node)
-          return unless allow_nil && allow_blank
-
-          allow_nil_val = allow_nil.children.last
-          allow_blank_val = allow_blank.children.last
-
-          offense(allow_nil_val, allow_blank_val, allow_nil)
-        end
-
-        def autocorrect(node)
-          prv_sib = previous_sibling(node)
-          nxt_sib = next_sibling(node)
-
-          lambda do |corrector|
-            if nxt_sib
-              corrector.remove(range_between(node_beg(node), node_beg(nxt_sib)))
-            elsif prv_sib
-              corrector.remove(range_between(node_end(prv_sib), node_end(node)))
-            else
-              corrector.remove(node.loc.expression)
-            end
-          end
-        end
-
-        private
-
-        def offense(allow_nil_val, allow_blank_val, allow_nil)
-          if allow_nil_val.type == allow_blank_val.type
-            add_offense(allow_nil, message: MSG_SAME)
-          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
-            add_offense(allow_nil, message: MSG_ALLOW_NIL_FALSE)
-          end
-        end
-
-        def find_allow_nil_and_allow_blank(node)
-          allow_nil = nil
-          allow_blank = nil
-
-          node.each_descendant do |descendant|
-            next unless descendant.pair_type?
-
-            key = descendant.children.first.source
-
-            allow_nil = descendant if key == 'allow_nil'
-            allow_blank = descendant if key == 'allow_blank'
-
-            break if allow_nil && allow_blank
-          end
-
-          [allow_nil, allow_blank]
-        end
-
-        def previous_sibling(node)
-          node.parent.children[node.sibling_index - 1]
-        end
-
-        def next_sibling(node)
-          node.parent.children[node.sibling_index + 1]
-        end
-
-        def node_beg(node)
-          node.loc.expression.begin_pos
-        end
-
-        def node_end(node)
-          node.loc.expression.end_pos
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for redundant receiver in `with_options`.
-      # Receiver is implicit from Rails 4.2 or higher.
-      #
-      # @example
-      #   # bad
-      #   class Account < ApplicationRecord
-      #     with_options dependent: :destroy do |assoc|
-      #       assoc.has_many :customers
-      #       assoc.has_many :products
-      #       assoc.has_many :invoices
-      #       assoc.has_many :expenses
-      #     end
-      #   end
-      #
-      #   # good
-      #   class Account < ApplicationRecord
-      #     with_options dependent: :destroy do
-      #       has_many :customers
-      #       has_many :products
-      #       has_many :invoices
-      #       has_many :expenses
-      #     end
-      #   end
-      #
-      # @example
-      #   # bad
-      #   with_options options: false do |merger|
-      #     merger.invoke(merger.something)
-      #   end
-      #
-      #   # good
-      #   with_options options: false do
-      #     invoke(something)
-      #   end
-      #
-      #   # good
-      #   client = Client.new
-      #   with_options options: false do |merger|
-      #     client.invoke(merger.something, something)
-      #   end
-      #
-      #   # ok
-      #   # When `with_options` includes a block, all scoping scenarios
-      #   # cannot be evaluated. Thus, it is ok to include the explicit
-      #   # receiver.
-      #   with_options options: false do |merger|
-      #     merger.invoke
-      #     with_another_method do |another_receiver|
-      #       merger.invoke(another_receiver)
-      #     end
-      #   end
-      class RedundantReceiverInWithOptions < Cop
-        extend TargetRailsVersion
-        include RangeHelp
-
-        minimum_target_rails_version 4.2
-
-        MSG = 'Redundant receiver in `with_options`.'
-
-        def_node_matcher :with_options?, <<-PATTERN
-          (block
-            (send nil? :with_options
-              (...))
-            (args
-              $_arg)
-            $_body)
-        PATTERN
-
-        def_node_search :all_block_nodes_in, <<-PATTERN
-          (block ...)
-        PATTERN
-
-        def_node_search :all_send_nodes_in, <<-PATTERN
-          (send ...)
-        PATTERN
-
-        def on_block(node)
-          with_options?(node) do |arg, body|
-            return if body.nil?
-            return unless all_block_nodes_in(body).count.zero?
-
-            send_nodes = all_send_nodes_in(body)
-
-            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
-              send_nodes.each do |send_node|
-                receiver = send_node.receiver
-                add_offense(send_node, location: receiver.source_range)
-              end
-            end
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver.source_range)
-            corrector.remove(node.loc.dot)
-            corrector.remove(block_argument_range(node))
-          end
-        end
-
-        private
-
-        def block_argument_range(node)
-          block_node = node.each_ancestor(:block).first
-          block_argument = block_node.children[1].source_range
-
-          range_between(
-            search_begin_pos_of_space_before_block_argument(
-              block_argument.begin_pos
-            ),
-            block_argument.end_pos
-          )
-        end
-
-        def search_begin_pos_of_space_before_block_argument(begin_pos)
-          position = begin_pos - 1
-
-          if processed_source.raw_source[position] == ' '
-            search_begin_pos_of_space_before_block_argument(position)
-          else
-            begin_pos
-          end
-        end
-
-        def same_value?(arg_node, recv_node)
-          recv_node && recv_node.children[0] == arg_node.children[0]
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/reflection_class_name.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks if the value of the option `class_name`, in
-      # the definition of a reflection is a string.
-      #
-      # @example
-      #   # bad
-      #   has_many :accounts, class_name: Account
-      #   has_many :accounts, class_name: Account.name
-      #
-      #   # good
-      #   has_many :accounts, class_name: 'Account'
-      class ReflectionClassName < Cop
-        MSG = 'Use a string value for `class_name`.'
-
-        def_node_matcher :association_with_reflection, <<-PATTERN
-          (send nil? {:has_many :has_one :belongs_to} _
-            (hash <$#reflection_class_name ...>)
-          )
-        PATTERN
-
-        def_node_matcher :reflection_class_name, <<-PATTERN
-          (pair (sym :class_name) [!dstr !str !sym])
-        PATTERN
-
-        def on_send(node)
-          association_with_reflection(node) do |reflection_class_name|
-            add_offense(node, location: reflection_class_name.loc.expression)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/refute_methods.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      #
-      # Use `assert_not` methods instead of `refute` methods.
-      #
-      # @example
-      #   # bad
-      #   refute false
-      #   refute_empty [1, 2, 3]
-      #   refute_equal true, false
-      #
-      #   # good
-      #   assert_not false
-      #   assert_not_empty [1, 2, 3]
-      #   assert_not_equal true, false
-      #
-      class RefuteMethods < Cop
-        MSG = 'Prefer `%<assert_method>s` over `%<refute_method>s`.'
-
-        CORRECTIONS = {
-          refute:             'assert_not',
-          refute_empty:       'assert_not_empty',
-          refute_equal:       'assert_not_equal',
-          refute_in_delta:    'assert_not_in_delta',
-          refute_in_epsilon:  'assert_not_in_epsilon',
-          refute_includes:    'assert_not_includes',
-          refute_instance_of: 'assert_not_instance_of',
-          refute_kind_of:     'assert_not_kind_of',
-          refute_nil:         'assert_not_nil',
-          refute_operator:    'assert_not_operator',
-          refute_predicate:   'assert_not_predicate',
-          refute_respond_to:  'assert_not_respond_to',
-          refute_same:        'assert_not_same',
-          refute_match:       'assert_no_match'
-        }.freeze
-
-        OFFENSIVE_METHODS = CORRECTIONS.keys.freeze
-
-        def_node_matcher :offensive?, '(send nil? #refute_method? ...)'
-
-        def on_send(node)
-          return unless offensive?(node)
-
-          message = offense_message(node.method_name)
-          add_offense(node, location: :selector, message: message)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node.loc.selector,
-              CORRECTIONS[node.method_name]
-            )
-          end
-        end
-
-        private
-
-        def refute_method?(method_name)
-          OFFENSIVE_METHODS.include?(method_name)
-        end
-
-        def offense_message(method_name)
-          format(
-            MSG,
-            refute_method: method_name,
-            assert_method: CORRECTIONS[method_name]
-          )
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/rails/relative_date_constant.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks whether constant value isn't relative date.
-      # Because the relative date will be evaluated only once.
-      #
-      # @example
-      #   # bad
-      #   class SomeClass
-      #     EXPIRED_AT = 1.week.since
-      #   end
-      #
-      #   # good
-      #   class SomeClass
-      #     def self.expired_at
-      #       1.week.since
-      #     end
-      #   end
-      class RelativeDateConstant < Cop
-        include RangeHelp
-
-        MSG = 'Do not assign %<method_name>s to constants as it ' \
-              'will be evaluated only once.'
-
-        def on_casgn(node)
-          relative_date_assignment?(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name: method_name))
-          end
-        end
-
-        def on_masgn(node)
-          lhs, rhs = *node
-
-          return unless rhs&.array_type?
-
-          lhs.children.zip(rhs.children).each do |(name, value)|
-            next unless name.casgn_type?
-
-            relative_date?(value) do |method_name|
-              add_offense(node,
-                          location: range_between(name.loc.expression.begin_pos,
-                                                  value.loc.expression.end_pos),
-                          message: format(MSG, method_name: method_name))
-            end
-          end
-        end
-
-        def on_or_asgn(node)
-          relative_date_or_assignment?(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name: method_name))
-          end
-        end
-
-        def autocorrect(node)
-          return unless node.casgn_type?
-
-          scope, const_name, value = *node
-          return unless scope.nil?
-
-          indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
-        end
-
-        private
-
-        def_node_matcher :relative_date_assignment?, <<-PATTERN
-          {
-            (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))
-            (casgn _ _ ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before})))
-            (casgn _ _ ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _))
-          }
-        PATTERN
-
-        def_node_matcher :relative_date_or_assignment?, <<-PATTERN
-          (:or_asgn (casgn _ _) (send _ ${:since :from_now :after :ago :until :before}))
-        PATTERN
-
-        def_node_matcher :relative_date?, <<-PATTERN
-          {
-            ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before}))
-            ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _)
-            (send _ ${:since :from_now :after :ago :until :before})
-          }
-        PATTERN
-      end
-    end
-  end
-end