rubocop 0.70.0 → 0.72.0

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

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks the migration for which timestamps are not included
-      # when creating a new table.
-      # In many cases, timestamps are useful information and should be added.
-      #
-      # @example
-      #   # bad
-      #   create_table :users
-      #
-      #   # bad
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #   end
-      #
-      #   # good
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #
-      #     t.timestamps
-      #   end
-      #
-      #   # good
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #
-      #     t.datetime :created_at, default: -> { 'CURRENT_TIMESTAMP' }
-      #   end
-      #
-      #   # good
-      #   create_table :users do |t|
-      #     t.string :name
-      #     t.string :email
-      #
-      #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
-      #   end
-      class CreateTableWithTimestamps < Cop
-        MSG = 'Add timestamps when creating a new table.'
-
-        def_node_matcher :create_table_with_block?, <<-PATTERN
-          (block
-            (send nil? :create_table ...)
-            (args (arg _var))
-            _)
-        PATTERN
-
-        def_node_matcher :create_table_with_timestamps_proc?, <<-PATTERN
-          (send nil? :create_table (sym _) ... (block-pass (sym :timestamps)))
-        PATTERN
-
-        def_node_search :timestamps_included?, <<-PATTERN
-          (send _var :timestamps ...)
-        PATTERN
-
-        def_node_search :created_at_or_updated_at_included?, <<-PATTERN
-          (send _var :datetime
-            {(sym {:created_at :updated_at})(str {"created_at" "updated_at"})}
-            ...)
-        PATTERN
-
-        def on_send(node)
-          return unless node.command?(:create_table)
-
-          parent = node.parent
-
-          if create_table_with_block?(parent)
-            if parent.body.nil? || !time_columns_included?(parent.body)
-              add_offense(parent)
-            end
-          elsif create_table_with_timestamps_proc?(node)
-            # nothing to do
-          else
-            add_offense(node)
-          end
-        end
-
-        private
-
-        def time_columns_included?(node)
-          timestamps_included?(node) || created_at_or_updated_at_included?(node)
-        end
-      end
-    end
-  end
-end

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

@@ -1,161 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module Cop
-    module Rails
-      # This cop checks for the correct use of Date methods,
-      # such as Date.today, Date.current etc.
-      #
-      # Using `Date.today` is dangerous, because it doesn't know anything about
-      # Rails time zone. You must use `Time.zone.today` instead.
-      #
-      # The cop also reports warnings when you are using `to_time` method,
-      # because it doesn't know about Rails time zone either.
-      #
-      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
-      # then the Date methods `today`, `current`, `yesterday`, and `tomorrow`
-      # are prohibited and the usage of both `to_time`
-      # and 'to_time_in_current_zone' are reported as warning.
-      #
-      # When EnforcedStyle is 'flexible' then only `Date.today` is prohibited
-      # and only `to_time` is reported as warning.
-      #
-      # @example EnforcedStyle: strict
-      #   # bad
-      #   Date.current
-      #   Date.yesterday
-      #   Date.today
-      #   date.to_time
-      #
-      #   # good
-      #   Time.zone.today
-      #   Time.zone.today - 1.day
-      #
-      # @example EnforcedStyle: flexible (default)
-      #   # bad
-      #   Date.today
-      #   date.to_time
-      #
-      #   # good
-      #   Time.zone.today
-      #   Time.zone.today - 1.day
-      #   Date.current
-      #   Date.yesterday
-      #   date.in_time_zone
-      #
-      class Date < Cop
-        include ConfigurableEnforcedStyle
-
-        MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
-              '`Time.zone.%<day>s` instead.'
-
-        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
-                   'know nothing about the time zone in use.'
-
-        BAD_DAYS = %i[today current yesterday tomorrow].freeze
-
-        DEPRECATED_METHODS = [
-          { deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }
-        ].freeze
-
-        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. ' \
-                         'Use `%<relevant>s` instead.'
-
-        def on_const(node)
-          mod, klass = *node.children
-          # we should only check core Date class (`Date` or `::Date`)
-          return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
-
-          check_date_node(node.parent) if klass == :Date
-        end
-
-        def on_send(node)
-          return unless node.receiver && bad_methods.include?(node.method_name)
-
-          return if safe_chain?(node) || safe_to_time?(node)
-
-          check_deprecated_methods(node)
-
-          add_offense(node, location: :selector,
-                            message: format(MSG_SEND, method: node.method_name))
-        end
-        alias on_csend on_send
-
-        private
-
-        def check_deprecated_methods(node)
-          DEPRECATED_METHODS.each do |relevant:, deprecated:|
-            next unless node.method_name == deprecated.to_sym
-
-            add_offense(node, location: :selector,
-                              message: format(DEPRECATED_MSG,
-                                              deprecated: deprecated,
-                                              relevant: relevant))
-          end
-        end
-
-        def check_date_node(node)
-          chain = extract_method_chain(node)
-
-          return if (chain & bad_days).empty?
-
-          method_name = (chain & bad_days).join('.')
-
-          day = method_name
-          day = 'today' if method_name == 'current'
-
-          add_offense(node, location: :selector,
-                            message: format(MSG,
-                                            method_called: method_name,
-                                            day: day))
-        end
-
-        def extract_method_chain(node)
-          [node, *node.each_ancestor(:send)].map(&:method_name)
-        end
-
-        # checks that parent node of send_type
-        # and receiver is the given node
-        def method_send?(node)
-          return false unless node.parent&.send_type?
-
-          node.parent.receiver == node
-        end
-
-        def safe_chain?(node)
-          chain = extract_method_chain(node)
-
-          (chain & bad_methods).empty? || !(chain & good_methods).empty?
-        end
-
-        def safe_to_time?(node)
-          return unless node.method?(:to_time)
-
-          if node.receiver.str_type?
-            zone_regexp = /([+-][\d:]+|\dZ)\z/
-
-            node.receiver.str_content.match(zone_regexp)
-          else
-            node.arguments.one?
-          end
-        end
-
-        def good_days
-          style == :strict ? [] : %i[current yesterday tomorrow]
-        end
-
-        def bad_days
-          BAD_DAYS - good_days
-        end
-
-        def bad_methods
-          %i[to_time to_time_in_current_zone]
-        end
-
-        def good_methods
-          style == :strict ? [] : TimeZone::ACCEPTED_METHODS
-        end
-      end
-    end
-  end
-end