rubocop-rails 2.0.1 → 2.19.1

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks if collection can be blank-compacted with `compact_blank`.
+      #
+      # @safety
+      #   It is unsafe by default because false positives may occur in the
+      #   blank check of block arguments to the receiver object.
+      #
+      #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.blank? }` and
+      #   `[[1, 2], [3, nil]].compact_blank` are not compatible. The same is true for `blank?`.
+      #   This will work fine when the receiver is a hash object.
+      #
+      #   And `compact_blank!` has different implementations for `Array`, `Hash`, and
+      #   `ActionController::Parameters`.
+      #   `Array#compact_blank!`, `Hash#compact_blank!` are equivalent to `delete_if(&:blank?)`.
+      #   `ActionController::Parameters#compact_blank!` is equivalent to `reject!(&:blank?)`.
+      #   If the cop makes a mistake, autocorrected code may get unexpected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #   collection.reject(&:blank?)
+      #   collection.reject { |_k, v| v.blank? }
+      #
+      #   # good
+      #   collection.compact_blank
+      #
+      #   # bad
+      #   collection.delete_if(&:blank?)            # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      #   collection.delete_if { |_k, v| v.blank? } # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      #   collection.reject!(&:blank?)              # Same behavior as `ActionController::Parameters#compact_blank!`
+      #   collection.reject! { |_k, v| v.blank? }   # Same behavior as `ActionController::Parameters#compact_blank!`
+      #
+      #   # good
+      #   collection.compact_blank!
+      #
+      class CompactBlank < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<preferred_method>s` instead.'
+        RESTRICT_ON_SEND = %i[reject delete_if reject!].freeze
+
+        minimum_target_rails_version 6.1
+
+        def_node_matcher :reject_with_block?, <<~PATTERN
+          (block
+            (send _ {:reject :delete_if :reject!})
+            $(args ...)
+            (send
+              $(lvar _) :blank?))
+        PATTERN
+
+        def_node_matcher :reject_with_block_pass?, <<~PATTERN
+          (send _ {:reject :delete_if :reject!}
+            (block_pass
+              (sym :blank?)))
+        PATTERN
+
+        def on_send(node)
+          return unless bad_method?(node)
+
+          range = offense_range(node)
+          preferred_method = preferred_method(node)
+          add_offense(range, message: format(MSG, preferred_method: preferred_method)) do |corrector|
+            corrector.replace(range, preferred_method)
+          end
+        end
+
+        private
+
+        def bad_method?(node)
+          return true if reject_with_block_pass?(node)
+
+          if (arguments, receiver_in_block = reject_with_block?(node.parent))
+            return use_single_value_block_argument?(arguments, receiver_in_block) ||
+                   use_hash_value_block_argument?(arguments, receiver_in_block)
+          end
+
+          false
+        end
+
+        def use_single_value_block_argument?(arguments, receiver_in_block)
+          arguments.length == 1 && arguments[0].source == receiver_in_block.source
+        end
+
+        def use_hash_value_block_argument?(arguments, receiver_in_block)
+          arguments.length == 2 && arguments[1].source == receiver_in_block.source
+        end
+
+        def offense_range(node)
+          end_pos = if node.parent&.block_type? && node.parent&.send_node == node
+                      node.parent.source_range.end_pos
+                    else
+                      node.source_range.end_pos
+                    end
+
+          range_between(node.loc.selector.begin_pos, end_pos)
+        end
+
+        def preferred_method(node)
+          node.method?(:reject) ? 'compact_blank' : 'compact_blank!'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks legacy syntax usage of `tag`
+      #
+      # NOTE: Allow `tag` when the first argument is a variable because
+      # `tag(name)` is simpler rather than `tag.public_send(name)`.
+      # And this cop will be renamed to something like `LegacyTag` in the future. (e.g. RuboCop Rails 2.0)
+      #
+      # @example
+      #  # bad
+      #  tag(:p)
+      #  tag(:br, class: 'classname')
+      #
+      #  # good
+      #  tag.p
+      #  tag.br(class: 'classname')
+      #  tag(name, class: 'classname')
+      class ContentTag < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.1
+
+        MSG = 'Use `tag.%<preferred_method>s` instead of `tag(%<current_argument>s)`.'
+        RESTRICT_ON_SEND = %i[tag].freeze
+
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
+        def on_send(node)
+          return unless node.receiver.nil?
+          return if node.arguments.count >= 3
+
+          first_argument = node.first_argument
+          return if !first_argument || allowed_argument?(first_argument) || corrected_ancestor?(node)
+
+          preferred_method = node.first_argument.value.to_s.underscore
+          message = format(MSG, preferred_method: preferred_method, current_argument: first_argument.source)
+
+          register_offense(node, message, preferred_method)
+        end
+
+        private
+
+        def corrected_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
+        def allowed_argument?(argument)
+          argument.variable? ||
+            argument.send_type? ||
+            argument.const_type? ||
+            argument.splat_type? ||
+            allowed_name?(argument) ||
+            !argument.respond_to?(:value)
+        end
+
+        def register_offense(node, message, preferred_method)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node, preferred_method)
+
+            @corrected_nodes ||= Set.new.compare_by_identity
+            @corrected_nodes.add(node)
+          end
+        end
+
+        def autocorrect(corrector, node, preferred_method)
+          range = correction_range(node)
+
+          rest_args = node.arguments.drop(1)
+          replacement = "tag.#{preferred_method}(#{rest_args.map(&:source).join(', ')})"
+
+          corrector.replace(range, replacement)
+        end
+
+        def allowed_name?(argument)
+          return false unless argument.str_type? || argument.sym_type?
+
+          !/^[a-zA-Z-][a-zA-Z\-0-9]*$/.match?(argument.value)
+        end
+
+        def correction_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -3,10 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks the migration for which timestamps are not included
-      # when creating a new table.
+      # 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.
       #
+      # NOTE: Allow `timestamps` not written when `id: false` because this emphasizes respecting
+      # user's editing intentions.
+      #
       # @example
       #   # bad
       #   create_table :users
@@ -40,39 +42,44 @@ module RuboCop
       #
       #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
       #   end
-      class CreateTableWithTimestamps < Cop
+      #
+      #   # good
+      #   create_table :users, articles, id: false do |t|
+      #     t.integer :user_id
+      #     t.integer :article_id
+      #   end
+      #
+      class CreateTableWithTimestamps < Base
+        include ActiveRecordMigrationsHelper
+
         MSG = 'Add timestamps when creating a new table.'
+        RESTRICT_ON_SEND = %i[create_table].freeze
 
-        def_node_matcher :create_table_with_block?, <<-PATTERN
-          (block
-            (send nil? :create_table ...)
-            (args (arg _var))
-            _)
+        def_node_search :use_id_false_option?, <<~PATTERN
+          (pair (sym :id) (false))
         PATTERN
 
-        def_node_matcher :create_table_with_timestamps_proc?, <<-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
+        def_node_search :timestamps_included?, <<~PATTERN
           (send _var :timestamps ...)
         PATTERN
 
-        def_node_search :created_at_or_updated_at_included?, <<-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)
+          return if !node.command?(:create_table) || use_id_false_option?(node)
 
           parent = node.parent
 
           if create_table_with_block?(parent)
-            if parent.body.nil? || !time_columns_included?(parent.body)
-              add_offense(parent)
-            end
+            add_offense(parent) if parent.body.nil? || !time_columns_included?(parent.body)
           elsif create_table_with_timestamps_proc?(node)
             # nothing to do
           else

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the correct use of Date methods,
+      # 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
@@ -12,54 +12,58 @@ module RuboCop
       # 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'
+      # 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.
+      # When `EnforcedStyle` is `flexible` then only `Date.today` is prohibited.
       #
-      # @example EnforcedStyle: strict
+      # And you can set a warning for `to_time` with `AllowToTime: false`.
+      # `AllowToTime` is `true` by default to prevent false positive on `DateTime` object.
+      #
+      # @example EnforcedStyle: flexible (default)
       #   # bad
-      #   Date.current
-      #   Date.yesterday
       #   Date.today
-      #   date.to_time
       #
       #   # good
       #   Time.zone.today
       #   Time.zone.today - 1.day
+      #   Date.current
+      #   Date.yesterday
+      #   date.in_time_zone
       #
-      # @example EnforcedStyle: flexible (default)
+      # @example EnforcedStyle: strict
       #   # bad
+      #   Date.current
+      #   Date.yesterday
       #   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
+      # @example AllowToTime: true (default)
+      #   # good
+      #   date.to_time
+      #
+      # @example AllowToTime: false
+      #   # bad
+      #   date.to_time
+      class Date < Base
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
-              '`Time.zone.%<day>s` instead.'
+        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.'
 
-        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
-                   'know nothing about the time zone in use.'
+        RESTRICT_ON_SEND = %i[to_time to_time_in_current_zone].freeze
 
         BAD_DAYS = %i[today current yesterday tomorrow].freeze
 
-        DEPRECATED_METHODS = [
-          { deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }
-        ].freeze
+        DEPRECATED_METHODS = [{ deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }].freeze
 
-        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. ' \
-                         'Use `%<relevant>s` instead.'
+        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. Use `%<relevant>s` instead.'
 
         def on_const(node)
           mod, klass = *node.children
@@ -71,26 +75,24 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver && bad_methods.include?(node.method_name)
-
+          return if allow_to_time? && node.method?(:to_time)
           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))
+          add_offense(node.loc.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
+          DEPRECATED_METHODS.each do |method|
+            next unless node.method?(method[:deprecated].to_sym)
+
+            message = format(DEPRECATED_MSG, deprecated: method[:deprecated], relevant: method[:relevant])
 
-            add_offense(node, location: :selector,
-                              message: format(DEPRECATED_MSG,
-                                              deprecated: deprecated,
-                                              relevant: relevant))
+            add_offense(node.loc.selector, message: message)
           end
         end
 
@@ -104,10 +106,9 @@ module RuboCop
           day = method_name
           day = 'today' if method_name == 'current'
 
-          add_offense(node, location: :selector,
-                            message: format(MSG,
-                                            method_called: method_name,
-                                            day: day))
+          message = format(MSG, method_called: method_name, day: day)
+
+          add_offense(node.loc.selector, message: message)
         end
 
         def extract_method_chain(node)
@@ -140,6 +141,10 @@ module RuboCop
           end
         end
 
+        def allow_to_time?
+          cop_config.fetch('AllowToTime', true)
+        end
+
         def good_days
           style == :strict ? [] : %i[current yesterday tomorrow]
         end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for uses of `default_scope`.
+      #
+      # @example
+      #   # bad
+      #   default_scope -> { where(hidden: false) }
+      #
+      #   # good
+      #   scope :published, -> { where(hidden: false) }
+      #
+      #   # bad
+      #   def self.default_scope
+      #     where(hidden: false)
+      #   end
+      #
+      #   # good
+      #   def self.published
+      #     where(hidden: false)
+      #   end
+      #
+      class DefaultScope < Base
+        MSG = 'Avoid use of `default_scope`. It is better to use explicitly named scopes.'
+        RESTRICT_ON_SEND = %i[default_scope].freeze
+
+        def_node_matcher :method_call?, <<~PATTERN
+          (send nil? :default_scope ...)
+        PATTERN
+
+        def_node_matcher :class_method_definition?, <<~PATTERN
+          (defs _ :default_scope args ...)
+        PATTERN
+
+        def_node_matcher :eigenclass_method_definition?, <<~PATTERN
+          (sclass (self) $(def :default_scope args ...))
+        PATTERN
+
+        def on_send(node)
+          return unless method_call?(node)
+
+          add_offense(node.loc.selector)
+        end
+
+        def on_defs(node)
+          return unless class_method_definition?(node)
+
+          add_offense(node.loc.name)
+        end
+
+        def on_sclass(node)
+          eigenclass_method_definition?(node) do |default_scope|
+            add_offense(default_scope.loc.name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations that could have been created
+      # Looks for delegations that could have been created
       # automatically with the `delegate` method.
       #
       # Safe navigation `&.` is ignored because Rails' `allow_nil`
@@ -24,6 +24,14 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo
       #
+      #   # bad
+      #   def bar
+      #     self.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :self
+      #
       #   # good
       #   def bar
       #     foo&.bar
@@ -52,36 +60,39 @@ module RuboCop
       #
       #   # good
       #   delegate :bar, to: :foo, prefix: true
-      class Delegate < Cop
+      class Delegate < Base
+        extend AutoCorrector
+        include VisibilityHelp
+
         MSG = 'Use `delegate` to define delegations.'
 
-        def_node_matcher :delegate?, <<-PATTERN
+        def_node_matcher :delegate?, <<~PATTERN
           (def _method_name _args
-            (send (send nil? _) _ ...))
+            (send {(send nil? _) (self)} _ ...))
         PATTERN
 
         def on_def(node)
           return unless trivial_delegate?(node)
           return if private_or_protected_delegation(node)
 
-          add_offense(node, location: :keyword)
+          register_offense(node)
         end
 
-        def autocorrect(node)
-          delegation = ["delegate :#{node.body.method_name}",
-                        "to: :#{node.body.receiver.method_name}"]
+        private
+
+        def register_offense(node)
+          add_offense(node.loc.keyword) do |corrector|
+            body = node.body
 
-          if node.method_name == prefixed_method_name(node.body)
-            delegation << ['prefix: true']
-          end
+            receiver = body.receiver.self_type? ? 'self' : ":#{body.receiver.method_name}"
 
-          lambda do |corrector|
-            corrector.replace(node.source_range, delegation.join(', '))
+            delegation = ["delegate :#{body.method_name}", "to: #{receiver}"]
+            delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
+
+            corrector.replace(node, delegation.join(', '))
           end
         end
 
-        private
-
         def trivial_delegate?(def_node)
           delegate?(def_node) &&
             method_name_matches?(def_node.method_name, def_node.body) &&
@@ -94,15 +105,12 @@ module RuboCop
           return false if arg_array.size != argument_array.size
 
           arg_array.zip(argument_array).all? do |arg, argument|
-            arg.arg_type? &&
-              argument.lvar_type? &&
-              arg.children == argument.children
+            arg.arg_type? && argument.lvar_type? && arg.children == argument.children
           end
         end
 
         def method_name_matches?(method_name, body)
-          method_name == body.method_name ||
-            include_prefix_case? && method_name == prefixed_method_name(body)
+          method_name == body.method_name || (include_prefix_case? && method_name == prefixed_method_name(body))
         end
 
         def include_prefix_case?
@@ -110,21 +118,17 @@ module RuboCop
         end
 
         def prefixed_method_name(body)
+          return '' if body.receiver.self_type?
+
           [body.receiver.method_name, body.method_name].join('_').to_sym
         end
 
         def private_or_protected_delegation(node)
-          line = node.first_line
-          private_or_protected_before(line) ||
-            private_or_protected_inline(line)
-        end
-
-        def private_or_protected_before(line)
-          (processed_source[0..line].map(&:strip) & %w[private protected]).any?
+          private_or_protected_inline(node) || node_visibility(node) != :public
         end
 
-        def private_or_protected_inline(line)
-          processed_source[line - 1].strip =~ /\A(private )|(protected )/
+        def private_or_protected_inline(node)
+          processed_source[node.first_line - 1].strip.match?(/\A(private )|(protected )/)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations that pass :allow_blank as an option
+      # Looks for delegations that pass :allow_blank as an option
       # instead of :allow_nil. :allow_blank is not a valid option to pass
       # to ActiveSupport#delegate.
       #
@@ -13,22 +13,21 @@ module RuboCop
       #
       #   # good
       #   delegate :foo, to: :bar, allow_nil: true
-      class DelegateAllowBlank < Cop
+      class DelegateAllowBlank < Base
+        extend AutoCorrector
+
         MSG = '`allow_blank` is not a valid option, use `allow_nil`.'
+        RESTRICT_ON_SEND = %i[delegate].freeze
 
-        def_node_matcher :allow_blank_option, <<-PATTERN
+        def_node_matcher :allow_blank_option, <<~PATTERN
           (send nil? :delegate _ (hash <$(pair (sym :allow_blank) true) ...>))
         PATTERN
 
         def on_send(node)
-          allow_blank_option(node) do |offending_node|
-            add_offense(offending_node)
-          end
-        end
+          return unless (offending_node = allow_blank_option(node))
 
-        def autocorrect(pair_node)
-          lambda do |corrector|
-            corrector.replace(pair_node.key.source_range, 'allow_nil')
+          add_offense(offending_node) do |corrector|
+            corrector.replace(offending_node.key, 'allow_nil')
           end
         end
       end