rubocop 0.70.0 → 0.72.0

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

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

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for consistent uses of `request.referer` or
-      # `request.referrer`, depending on the cop's configuration.
-      #
-      # @example EnforcedStyle: referer (default)
-      #   # bad
-      #   request.referrer
-      #
-      #   # good
-      #   request.referer
-      #
-      # @example EnforcedStyle: referrer
-      #   # bad
-      #   request.referer
-      #
-      #   # good
-      #   request.referrer
-      class RequestReferer < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Use `request.%<prefer>s` instead of ' \
-              '`request.%<current>s`.'
-
-        def_node_matcher :referer?, <<-PATTERN
-          (send (send nil? :request) {:referer :referrer})
-        PATTERN
-
-        def on_send(node)
-          referer?(node) do
-            return unless node.method?(wrong_method_name)
-
-            add_offense(node.source_range, location: node.source_range)
-          end
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node, "request.#{style}") }
-        end
-
-        private
-
-        def message(_node)
-          format(MSG, prefer: style, current: wrong_method_name)
-        end
-
-        def wrong_method_name
-          style == :referer ? :referrer : :referer
-        end
-      end
-    end
-  end
-end

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

@@ -1,286 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks whether the change method of the migration file is
-      # reversible.
-      #
-      # @example
-      #   # bad
-      #   def change
-      #     change_table :users do |t|
-      #       t.remove :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     create_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.column :name, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.remove :name
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # @example
-      #   # drop_table
-      #
-      #   # bad
-      #   def change
-      #     drop_table :users
-      #   end
-      #
-      #   # good
-      #   def change
-      #     drop_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      # @example
-      #   # change_column_default
-      #
-      #   # bad
-      #   def change
-      #     change_column_default(:suppliers, :qualification, 'new')
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_column_default(:posts, :state, from: nil, to: "draft")
-      #   end
-      #
-      # @example
-      #   # remove_column
-      #
-      #   # bad
-      #   def change
-      #     remove_column(:suppliers, :qualification)
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_column(:suppliers, :qualification, :string)
-      #   end
-      #
-      # @example
-      #   # remove_foreign_key
-      #
-      #   # bad
-      #   def change
-      #     remove_foreign_key :accounts, column: :owner_id
-      #   end
-      #
-      #   # good
-      #   def change
-      #     remove_foreign_key :accounts, :branches
-      #   end
-      #
-      # @example
-      #   # change_table
-      #
-      #   # bad
-      #   def change
-      #     change_table :users do |t|
-      #       t.remove :name
-      #       t.change_default :authorized, 1
-      #       t.change :price, :string
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     change_table :users do |t|
-      #       t.string :name
-      #     end
-      #   end
-      #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.change :price, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.change :price, :integer
-      #         end
-      #       end
-      #     end
-      #   end
-      #
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
-      class ReversibleMigration < Cop
-        MSG = '%<action>s is not reversible.'
-        IRREVERSIBLE_CHANGE_TABLE_CALLS = %i[
-          change change_default remove
-        ].freeze
-
-        def_node_matcher :irreversible_schema_statement_call, <<-PATTERN
-          (send nil? ${:change_table_comment :execute :remove_belongs_to} ...)
-        PATTERN
-
-        def_node_matcher :drop_table_call, <<-PATTERN
-          (send nil? :drop_table ...)
-        PATTERN
-
-        def_node_matcher :change_column_default_call, <<-PATTERN
-          (send nil? :change_column_default {[(sym _) (sym _)] (splat _)} $...)
-        PATTERN
-
-        def_node_matcher :remove_column_call, <<-PATTERN
-          (send nil? :remove_column $...)
-        PATTERN
-
-        def_node_matcher :remove_foreign_key_call, <<-PATTERN
-          (send nil? :remove_foreign_key _ $_)
-        PATTERN
-
-        def_node_matcher :change_table_call, <<-PATTERN
-          (send nil? :change_table $_ ...)
-        PATTERN
-
-        def on_send(node)
-          return unless within_change_method?(node)
-          return if within_reversible_or_up_only_block?(node)
-
-          check_irreversible_schema_statement_node(node)
-          check_drop_table_node(node)
-          check_change_column_default_node(node)
-          check_remove_column_node(node)
-          check_remove_foreign_key_node(node)
-        end
-
-        def on_block(node)
-          return unless within_change_method?(node)
-          return if within_reversible_or_up_only_block?(node)
-          return if node.body.nil?
-
-          check_change_table_node(node.send_node, node.body)
-        end
-
-        private
-
-        def check_irreversible_schema_statement_node(node)
-          irreversible_schema_statement_call(node) do |method_name|
-            add_offense(node, message: format(MSG, action: method_name))
-          end
-        end
-
-        def check_drop_table_node(node)
-          drop_table_call(node) do
-            unless node.parent.block_type?
-              add_offense(
-                node,
-                message: format(MSG, action: 'drop_table(without block)')
-              )
-            end
-          end
-        end
-
-        def check_change_column_default_node(node)
-          change_column_default_call(node) do |args|
-            unless all_hash_key?(args.last, :from, :to)
-              add_offense(
-                node,
-                message: format(
-                  MSG, action: 'change_column_default(without :from and :to)'
-                )
-              )
-            end
-          end
-        end
-
-        def check_remove_column_node(node)
-          remove_column_call(node) do |args|
-            if args.to_a.size < 3
-              add_offense(
-                node,
-                message: format(MSG, action: 'remove_column(without type)')
-              )
-            end
-          end
-        end
-
-        def check_remove_foreign_key_node(node)
-          remove_foreign_key_call(node) do |arg|
-            if arg.hash_type?
-              add_offense(
-                node,
-                message: format(MSG,
-                                action: 'remove_foreign_key(without table)')
-              )
-            end
-          end
-        end
-
-        def check_change_table_node(node, block)
-          change_table_call(node) do |arg|
-            if target_rails_version < 4.0
-              add_offense(
-                node,
-                message: format(MSG, action: 'change_table')
-              )
-            elsif block.send_type?
-              check_change_table_offense(arg, block)
-            else
-              block.each_child_node(:send) do |child_node|
-                check_change_table_offense(arg, child_node)
-              end
-            end
-          end
-        end
-
-        def check_change_table_offense(receiver, node)
-          method_name = node.method_name
-          return if receiver != node.receiver &&
-                    !IRREVERSIBLE_CHANGE_TABLE_CALLS.include?(method_name)
-
-          add_offense(
-            node,
-            message: format(MSG, action: "change_table(with #{method_name})")
-          )
-        end
-
-        def within_change_method?(node)
-          node.each_ancestor(:def).any? do |ancestor|
-            ancestor.method?(:change)
-          end
-        end
-
-        def within_reversible_or_up_only_block?(node)
-          node.each_ancestor(:block).any? do |ancestor|
-            ancestor.block_type? &&
-              ancestor.send_node.method?(:reversible) ||
-              ancestor.send_node.method?(:up_only)
-          end
-        end
-
-        def all_hash_key?(args, *keys)
-          return false unless args&.hash_type?
-
-          hash_keys = args.keys.map do |key|
-            key.children.first.to_sym
-          end
-
-          hash_keys & keys == keys
-        end
-      end
-    end
-  end
-end