rubocop-rails 2.4.1

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that models subclass ApplicationRecord with Rails 5.0.
+      #
+      # @example
+      #
+      #  # good
+      #  class Rails5Model < ApplicationRecord
+      #    # ...
+      #  end
+      #
+      #  # bad
+      #  class Rails4Model < ActiveRecord::Base
+      #    # ...
+      #  end
+      class ApplicationRecord < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = 'Models should subclass `ApplicationRecord`.'
+        SUPERCLASS = 'ApplicationRecord'
+        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'
+
+        # rubocop:disable Layout/ClassStructure
+        include RuboCop::Cop::EnforceSuperclass
+        # rubocop:enable Layout/ClassStructure
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, self.class::SUPERCLASS)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Use `assert_not` instead of `assert !`.
+      #
+      # @example
+      #   # bad
+      #   assert !x
+      #
+      #   # good
+      #   assert_not x
+      #
+      class AssertNot < RuboCop::Cop::Cop
+        MSG = 'Prefer `assert_not` over `assert !`.'
+
+        def_node_matcher :offensive?, '(send nil? :assert (send ... :!) ...)'
+
+        def on_send(node)
+          add_offense(node) if offensive?(node)
+        end
+
+        def autocorrect(node)
+          expression = node.loc.expression
+
+          lambda do |corrector|
+            corrector.replace(
+              expression,
+              corrected_source(expression.source)
+            )
+          end
+        end
+
+        private
+
+        def corrected_source(source)
+          source.gsub(/^assert(\(| ) *! */, 'assert_not\\1')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for belongs_to associations where we control whether the
+      # association is required via the deprecated `required` option instead.
+      #
+      # Since Rails 5, belongs_to associations are required by default and this
+      # can be controlled through the use of `optional: true`.
+      #
+      # From the release notes:
+      #
+      #     belongs_to will now trigger a validation error by default if the
+      #     association is not present. You can turn this off on a
+      #     per-association basis with optional: true. Also deprecate required
+      #     option in favor of optional for belongs_to. (Pull Request)
+      #
+      # In the case that the developer is doing `required: false`, we
+      # definitely want to autocorrect to `optional: true`.
+      #
+      # However, without knowing whether they've set overridden the default
+      # value of `config.active_record.belongs_to_required_by_default`, we
+      # can't say whether it's safe to remove `required: true` or whether we
+      # should replace it with `optional: false` (or, similarly, remove a
+      # superfluous `optional: false`). Therefore, in the cases we're using
+      # `required: true`, we'll simply invert it to `optional: false` and the
+      # user can remove depending on their defaults.
+      #
+      # @example
+      #   # bad
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, required: false
+      #   end
+      #
+      #   # good
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, optional: true
+      #   end
+      #
+      #   # bad
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, required: true
+      #   end
+      #
+      #   # good
+      #   class Post < ApplicationRecord
+      #     belongs_to :blog, optional: false
+      #   end
+      #
+      # @see https://guides.rubyonrails.org/5_0_release_notes.html
+      # @see https://github.com/rails/rails/pull/18937
+      class BelongsTo < Cop
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        SUPERFLOUS_REQUIRE_FALSE_MSG =
+          'You specified `required: false`, in Rails > 5.0 the required ' \
+          'option is deprecated and you want to use `optional: true`.'
+
+        SUPERFLOUS_REQUIRE_TRUE_MSG =
+          'You specified `required: true`, in Rails > 5.0 the required ' \
+          'option is deprecated and you want to use `optional: false`. ' \
+          'In most configurations, this is the default and you can omit ' \
+          'this option altogether'
+
+        def_node_matcher :match_belongs_to_with_options, <<~PATTERN
+          (send _ :belongs_to _
+            (hash <$(pair (sym :required) ${true false}) ...>)
+          )
+        PATTERN
+
+        def on_send(node)
+          match_belongs_to_with_options(node) do |_option_node, option_value|
+            message =
+              if option_value.true_type?
+                SUPERFLOUS_REQUIRE_TRUE_MSG
+              elsif option_value.false_type?
+                SUPERFLOUS_REQUIRE_FALSE_MSG
+              end
+
+            add_offense(node, message: message, location: :selector)
+          end
+        end
+
+        def autocorrect(node)
+          option_node, option_value = match_belongs_to_with_options(node)
+          return unless option_node
+
+          lambda do |corrector|
+            if option_value.true_type?
+              corrector.replace(option_node.loc.expression, 'optional: false')
+            elsif option_value.false_type?
+              corrector.replace(option_node.loc.expression, 'optional: true')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for code that can be written with simpler conditionals
+      # using `Object#blank?` defined by Active Support.
+      #
+      # Interaction with `Style/UnlessElse`:
+      # The configuration of `NotPresent` will not produce an offense in the
+      # context of `unless else` if `Style/UnlessElse` is inabled. This is
+      # to prevent interference between the auto-correction of the two cops.
+      #
+      # @example NilOrEmpty: true (default)
+      #   # Converts usages of `nil? || empty?` to `blank?`
+      #
+      #   # bad
+      #   foo.nil? || foo.empty?
+      #   foo == nil || foo.empty?
+      #
+      #   # good
+      #   foo.blank?
+      #
+      # @example NotPresent: true (default)
+      #   # Converts usages of `!present?` to `blank?`
+      #
+      #   # bad
+      #   !foo.present?
+      #
+      #   # good
+      #   foo.blank?
+      #
+      # @example UnlessPresent: true (default)
+      #   # Converts usages of `unless present?` to `if blank?`
+      #
+      #   # bad
+      #   something unless foo.present?
+      #
+      #   # good
+      #   something if foo.blank?
+      #
+      #   # bad
+      #   unless foo.present?
+      #     something
+      #   end
+      #
+      #   # good
+      #   if foo.blank?
+      #     something
+      #   end
+      #
+      #   # good
+      #   def blank?
+      #     !present?
+      #   end
+      class Blank < Cop
+        MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of ' \
+                             '`%<current>s`.'
+
+        # `(send nil $_)` is not actually a valid match for an offense. Nodes
+        # that have a single method call on the left hand side
+        # (`bar || foo.empty?`) will blow up when checking
+        # `(send (:nil) :== $_)`.
+        def_node_matcher :nil_or_empty?, <<~PATTERN
+          (or
+              {
+                (send $_ :!)
+                (send $_ :nil?)
+                (send $_ :== nil)
+                (send nil :== $_)
+              }
+              {
+                (send $_ :empty?)
+                (send (send (send $_ :empty?) :!) :!)
+              }
+          )
+        PATTERN
+
+        def_node_matcher :not_present?, '(send (send $_ :present?) :!)'
+
+        def_node_matcher :defining_blank?, '(def :blank? (args) ...)'
+
+        def_node_matcher :unless_present?, <<~PATTERN
+          (:if $(send $_ :present?) {nil? (...)} ...)
+        PATTERN
+
+        def on_send(node)
+          return unless cop_config['NotPresent']
+
+          not_present?(node) do |receiver|
+            # accepts !present? if its in the body of a `blank?` method
+            next if defining_blank?(node.parent)
+
+            add_offense(node,
+                        message: format(MSG_NOT_PRESENT,
+                                        prefer: replacement(receiver),
+                                        current: node.source))
+          end
+        end
+
+        def on_or(node)
+          return unless cop_config['NilOrEmpty']
+
+          nil_or_empty?(node) do |var1, var2|
+            return unless var1 == var2
+
+            add_offense(node,
+                        message: format(MSG_NIL_OR_EMPTY,
+                                        prefer: replacement(var1),
+                                        current: node.source))
+          end
+        end
+
+        def on_if(node)
+          return unless cop_config['UnlessPresent']
+          return unless node.unless?
+          return if node.else? && config.for_cop('Style/UnlessElse')['Enabled']
+
+          unless_present?(node) do |method_call, receiver|
+            range = unless_condition(node, method_call)
+
+            add_offense(node,
+                        location: range,
+                        message: format(MSG_UNLESS_PRESENT,
+                                        prefer: replacement(receiver),
+                                        current: range.source))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            method_call, variable1 = unless_present?(node)
+
+            if method_call
+              corrector.replace(node.loc.keyword, 'if')
+              range = method_call.loc.expression
+            else
+              variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
+              range = node.loc.expression
+            end
+
+            corrector.replace(range, replacement(variable1))
+          end
+        end
+
+        private
+
+        def unless_condition(node, method_call)
+          if node.modifier_form?
+            node.loc.keyword.join(node.loc.expression.end)
+          else
+            node.loc.expression.begin.join(method_call.loc.expression)
+          end
+        end
+
+        def replacement(node)
+          node.respond_to?(:source) ? "#{node.source}.blank?" : 'blank?'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This Cop checks whether alter queries are combinable.
+      # If combinable queries are detected, it suggests to you
+      # to use `change_table` with `bulk: true` instead.
+      # This option causes the migration to generate a single
+      # ALTER TABLE statement combining multiple column alterations.
+      #
+      # The `bulk` option is only supported on the MySQL and
+      # the PostgreSQL (5.2 later) adapter; thus it will
+      # automatically detect an adapter from `development` environment
+      # in `config/database.yml` when the `Database` option is not set.
+      # If the adapter is not `mysql2` or `postgresql`,
+      # this Cop ignores offenses.
+      #
+      # @example
+      #   # bad
+      #   def change
+      #     add_column :users, :name, :string, null: false
+      #     add_column :users, :nickname, :string
+      #
+      #     # ALTER TABLE `users` ADD `name` varchar(255) NOT NULL
+      #     # ALTER TABLE `users` ADD `nickname` varchar(255)
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_table :users, bulk: true do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #
+      #     # ALTER TABLE `users` ADD `name` varchar(255) NOT NULL,
+      #     #                     ADD `nickname` varchar(255)
+      #   end
+      #
+      # @example
+      #   # bad
+      #   def change
+      #     change_table :users do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #   end
+      #
+      #   # good
+      #   def change
+      #     change_table :users, bulk: true do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #   end
+      #
+      #   # good
+      #   # When you don't want to combine alter queries.
+      #   def change
+      #     change_table :users, bulk: false do |t|
+      #       t.string :name, null: false
+      #       t.string :nickname
+      #     end
+      #   end
+      #
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
+      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
+      class BulkChangeTable < Cop
+        MSG_FOR_CHANGE_TABLE = <<~MSG.chomp
+          You can combine alter queries using `bulk: true` options.
+        MSG
+        MSG_FOR_ALTER_METHODS = <<~MSG.chomp
+          You can use `change_table :%<table>s, bulk: true` to combine alter queries.
+        MSG
+
+        MYSQL = 'mysql'
+        POSTGRESQL = 'postgresql'
+
+        MIGRATION_METHODS = %i[change up down].freeze
+
+        COMBINABLE_TRANSFORMATIONS = %i[
+          primary_key
+          column
+          string
+          text
+          integer
+          bigint
+          float
+          decimal
+          numeric
+          datetime
+          timestamp
+          time
+          date
+          binary
+          boolean
+          json
+          virtual
+          remove
+          change
+          timestamps
+          remove_timestamps
+        ].freeze
+
+        COMBINABLE_ALTER_METHODS = %i[
+          add_column
+          remove_column
+          remove_columns
+          change_column
+          add_timestamps
+          remove_timestamps
+        ].freeze
+
+        MYSQL_COMBINABLE_TRANSFORMATIONS = %i[
+          rename
+          index
+          remove_index
+        ].freeze
+
+        MYSQL_COMBINABLE_ALTER_METHODS = %i[
+          rename_column
+          add_index
+          remove_index
+        ].freeze
+
+        POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[
+          change_default
+        ].freeze
+
+        POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[
+          change_column_default
+        ].freeze
+
+        def on_def(node)
+          return unless support_bulk_alter?
+          return unless MIGRATION_METHODS.include?(node.method_name)
+          return unless node.body
+
+          recorder = AlterMethodsRecorder.new
+
+          node.body.child_nodes.each do |child_node|
+            if call_to_combinable_alter_method? child_node
+              recorder.process(child_node)
+            else
+              recorder.flush
+            end
+          end
+
+          recorder.offensive_nodes.each { |n| add_offense_for_alter_methods(n) }
+        end
+
+        def on_send(node)
+          return unless support_bulk_alter?
+          return unless node.command?(:change_table)
+          return if include_bulk_options?(node)
+          return unless node.block_node
+
+          send_nodes = node.block_node.body.each_child_node(:send).to_a
+
+          transformations = send_nodes.select do |send_node|
+            combinable_transformations.include?(send_node.method_name)
+          end
+
+          add_offense_for_change_table(node) if transformations.size > 1
+        end
+
+        private
+
+        # @param node [RuboCop::AST::SendNode] (send nil? :change_table ...)
+        def include_bulk_options?(node)
+          # arguments: [{(sym :table)(str "table")} (hash (pair (sym :bulk) _))]
+          options = node.arguments[1]
+          return false unless options
+
+          options.hash_type? &&
+            options.keys.any? { |key| key.sym_type? && key.value == :bulk }
+        end
+
+        def database
+          cop_config['Database'] || database_from_yaml
+        end
+
+        def database_from_yaml
+          return nil unless database_yaml
+
+          case database_yaml['adapter']
+          when 'mysql2'
+            MYSQL
+          when 'postgresql'
+            POSTGRESQL
+          end
+        end
+
+        def database_yaml
+          return nil unless File.exist?('config/database.yml')
+
+          yaml = YAML.load_file('config/database.yml')
+          return nil unless yaml.is_a? Hash
+
+          config = yaml['development']
+          return nil unless config.is_a?(Hash)
+
+          config
+        rescue Psych::SyntaxError
+          nil
+        end
+
+        def support_bulk_alter?
+          case database
+          when MYSQL
+            true
+          when POSTGRESQL
+            # Add bulk alter support for PostgreSQL in 5.2.0
+            # @see https://github.com/rails/rails/pull/31331
+            target_rails_version >= 5.2
+          else
+            false
+          end
+        end
+
+        def call_to_combinable_alter_method?(child_node)
+          child_node.send_type? &&
+            combinable_alter_methods.include?(child_node.method_name)
+        end
+
+        def combinable_alter_methods
+          case database
+          when MYSQL
+            COMBINABLE_ALTER_METHODS + MYSQL_COMBINABLE_ALTER_METHODS
+          when POSTGRESQL
+            COMBINABLE_ALTER_METHODS + POSTGRESQL_COMBINABLE_ALTER_METHODS
+          end
+        end
+
+        def combinable_transformations
+          case database
+          when MYSQL
+            COMBINABLE_TRANSFORMATIONS + MYSQL_COMBINABLE_TRANSFORMATIONS
+          when POSTGRESQL
+            COMBINABLE_TRANSFORMATIONS + POSTGRESQL_COMBINABLE_TRANSFORMATIONS
+          end
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        def add_offense_for_alter_methods(node)
+          # arguments: [{(sym :table)(str "table")} ...]
+          table_node = node.arguments[0]
+          return unless table_node.is_a? RuboCop::AST::BasicLiteralNode
+
+          message = format(MSG_FOR_ALTER_METHODS, table: table_node.value)
+          add_offense(node, message: message)
+        end
+
+        # @param node [RuboCop::AST::SendNode]
+        def add_offense_for_change_table(node)
+          add_offense(node, message: MSG_FOR_CHANGE_TABLE)
+        end
+
+        # Record combinable alter methods and register offensive nodes.
+        class AlterMethodsRecorder
+          def initialize
+            @nodes = []
+            @offensive_nodes = []
+          end
+
+          # @param new_node [RuboCop::AST::SendNode]
+          def process(new_node)
+            # arguments: [{(sym :table)(str "table")} ...]
+            table_node = new_node.arguments[0]
+            if table_node.is_a? RuboCop::AST::BasicLiteralNode
+              flush unless @nodes.all? do |node|
+                node.arguments[0].value.to_s == table_node.value.to_s
+              end
+              @nodes << new_node
+            else
+              flush
+            end
+          end
+
+          def flush
+            @offensive_nodes << @nodes.first if @nodes.size > 1
+            @nodes = []
+          end
+
+          def offensive_nodes
+            flush
+            @offensive_nodes
+          end
+        end
+      end
+    end
+  end
+end