rubocop 0.70.0 → 0.75.0

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

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

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

@@ -1,289 +0,0 @@
-# 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
-          change_column_null
-        ].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.each_child_node(:send) do |send_node|
-            if combinable_alter_methods.include?(send_node.method_name)
-              recorder.process(send_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 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