rubocop-rails 2.4.1

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

@@ -0,0 +1,37 @@
+# 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

@@ -0,0 +1,76 @@
+# 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

@@ -0,0 +1,102 @@
+# 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
+      #     EXPIRES = 1.week
+      #
+      #     def self.expired_at
+      #       EXPIRES.since
+      #     end
+      #   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

@@ -0,0 +1,56 @@
+# 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

@@ -0,0 +1,284 @@
+# 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.'
+
+        def_node_matcher :irreversible_schema_statement_call, <<~PATTERN
+          (send nil? ${:execute :remove_belongs_to} ...)
+        PATTERN
+
+        def_node_matcher :drop_table_call, <<~PATTERN
+          (send nil? :drop_table ...)
+        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_reversible_hash_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_reversible_hash_node(node)
+          return if reversible_change_table_call?(node)
+
+          add_offense(
+            node,
+            message: format(
+              MSG, action: "#{node.method_name}(without :from and :to)"
+            )
+          )
+        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 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 &&
+                    reversible_change_table_call?(node)
+
+          add_offense(
+            node,
+            message: format(MSG, action: "change_table(with #{method_name})")
+          )
+        end
+
+        def reversible_change_table_call?(node)
+          case node.method_name
+          when :change, :remove
+            false
+          when :change_default, :change_column_default, :change_table_comment,
+               :change_column_comment
+            all_hash_key?(node.arguments.last, :from, :to)
+          else
+            true
+          end
+        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