rubocop-rails 2.0.1 → 2.19.1

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

@@ -3,104 +3,104 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of Time methods without zone.
+      # Checks for the use of Time methods without zone.
       #
-      # Built on top of Ruby on Rails style guide (https://github.com/rubocop-hq/rails-style-guide#time)
+      # Built on top of Ruby on Rails style guide (https://rails.rubystyle.guide#time)
       # and the article http://danilenko.org/2012/7/6/rails_timezones/
       #
-      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
-      # then only use of Time.zone is allowed.
+      # Two styles are supported for this cop. When `EnforcedStyle` is 'strict'
+      # then only use of `Time.zone` is allowed.
       #
       # When EnforcedStyle is 'flexible' then it's also allowed
-      # to use Time.in_time_zone.
+      # to use `Time#in_time_zone`.
       #
-      # @example EnforcedStyle: strict
-      #   # `strict` means that `Time` should be used with `zone`.
+      # @safety
+      #   This cop's autocorrection is unsafe because it may change handling time.
       #
+      # @example
       #   # bad
       #   Time.now
-      #   Time.parse('2015-03-02 19:05:37')
-      #
-      #   # bad
-      #   Time.current
-      #   Time.at(timestamp).in_time_zone
+      #   Time.parse('2015-03-02T19:05:37')
       #
       #   # good
+      #   Time.current
       #   Time.zone.now
-      #   Time.zone.parse('2015-03-02 19:05:37')
+      #   Time.zone.parse('2015-03-02T19:05:37')
+      #   Time.zone.parse('2015-03-02T19:05:37Z') # Respect ISO 8601 format with timezone specifier.
       #
       # @example EnforcedStyle: flexible (default)
       #   # `flexible` allows usage of `in_time_zone` instead of `zone`.
       #
-      #   # bad
-      #   Time.now
-      #   Time.parse('2015-03-02 19:05:37')
-      #
       #   # good
-      #   Time.zone.now
-      #   Time.zone.parse('2015-03-02 19:05:37')
+      #   Time.at(timestamp).in_time_zone
       #
-      #   # good
-      #   Time.current
+      # @example EnforcedStyle: strict
+      #   # `strict` means that `Time` should be used with `zone`.
+      #
+      #   # bad
       #   Time.at(timestamp).in_time_zone
-      class TimeZone < Cop
+      class TimeZone < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` ' \
-              'instead.'
+        MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` instead.'
 
-        MSG_ACCEPTABLE = 'Do not use `%<current>s` without zone. ' \
-                         'Use one of %<prefer>s instead.'
+        MSG_ACCEPTABLE = 'Do not use `%<current>s` without zone. Use one of %<prefer>s instead.'
 
-        MSG_LOCALTIME = 'Do not use `Time.localtime` without ' \
-                        'offset or zone.'
-
-        TIMECLASSES = %i[Time DateTime].freeze
+        MSG_LOCALTIME = 'Do not use `Time.localtime` without offset or zone.'
 
         GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
 
-        DANGEROUS_METHODS = %i[now local new parse at current].freeze
+        DANGEROUS_METHODS = %i[now local new parse at].freeze
+
+        ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601 jisx0301 rfc3339 httpdate to_i to_f].freeze
 
-        ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601
-                              jisx0301 rfc3339 httpdate to_i to_f].freeze
+        TIMEZONE_SPECIFIER = /([A-z]|[+-]\d{2}:?\d{2})\z/.freeze
 
         def on_const(node)
           mod, klass = *node
           # we should only check core classes
-          # (`DateTime`, `Time`, `::DateTime` or `::Time`)
+          # (`Time` or `::Time`)
           return unless (mod.nil? || mod.cbase_type?) && method_send?(node)
 
-          check_time_node(klass, node.parent) if TIMECLASSES.include?(klass)
+          check_time_node(klass, node.parent) if klass == :Time
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            # add `.zone`: `Time.at` => `Time.zone.at`
-            corrector.insert_after(node.children[0].source_range, '.zone')
+        private
+
+        def autocorrect(corrector, node)
+          # add `.zone`: `Time.at` => `Time.zone.at`
+          corrector.insert_after(node.children[0], '.zone')
+
+          case node.method_name
+          when :current
             # replace `Time.zone.current` => `Time.zone.now`
-            if node.method_name == :current
-              corrector.replace(node.loc.selector, 'now')
-            end
-            # prefer `Time` over `DateTime` class
-            if strict?
-              corrector.replace(node.children.first.source_range, 'Time')
-            end
-            remove_redundant_in_time_zone(corrector, node)
+            corrector.replace(node.loc.selector, 'now')
+          when :new
+            autocorrect_time_new(node, corrector)
           end
+
+          # prefer `Time` over `DateTime` class
+          corrector.replace(node.children.first, 'Time') if strict?
+          remove_redundant_in_time_zone(corrector, node)
         end
 
-        private
+        def autocorrect_time_new(node, corrector)
+          if node.arguments?
+            corrector.replace(node.loc.selector, 'local')
+          else
+            corrector.replace(node.loc.selector, 'now')
+          end
+        end
 
         # remove redundant `.in_time_zone` from `Time.zone.now.in_time_zone`
         def remove_redundant_in_time_zone(corrector, node)
           time_methods_called = extract_method_chain(node)
-          return unless time_methods_called.include?(:in_time_zone) ||
-                        time_methods_called.include?(:zone)
+          return unless time_methods_called.include?(:in_time_zone) || time_methods_called.include?(:zone)
 
           while node&.send_type?
             if node.children.last == :in_time_zone
-              in_time_zone_with_dot =
-                node.loc.selector.adjust(begin_pos: -1)
+              in_time_zone_with_dot = node.loc.selector.adjust(begin_pos: -1)
               corrector.remove(in_time_zone_with_dot)
             end
             node = node.parent
@@ -108,9 +108,10 @@ module RuboCop
         end
 
         def check_time_node(klass, node)
+          return if attach_timezone_specifier?(node.first_argument)
+
           chain = extract_method_chain(node)
           return if not_danger_chain?(chain)
-
           return check_localtime(node) if need_check_localtime?(chain)
 
           method_name = (chain & DANGEROUS_METHODS).join('.')
@@ -119,7 +120,13 @@ module RuboCop
 
           message = build_message(klass, method_name, node)
 
-          add_offense(node, location: :selector, message: message)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def attach_timezone_specifier?(date)
+          date.respond_to?(:value) && TIMEZONE_SPECIFIER.match?(date.value.to_s)
         end
 
         def build_message(klass, method_name, node)
@@ -131,9 +138,7 @@ module RuboCop
             )
           else
             safe_method_name = safe_method(method_name, node)
-            format(MSG,
-                   current: "#{klass}.#{method_name}",
-                   prefer: "Time.zone.#{safe_method_name}")
+            format(MSG, current: "#{klass}.#{method_name}", prefer: "Time.zone.#{safe_method_name}")
           end
         end
 
@@ -153,7 +158,7 @@ module RuboCop
           if (receiver.is_a? RuboCop::AST::Node) && !receiver.cbase_type?
             method_from_time_class?(receiver)
           else
-            TIMECLASSES.include?(method_name)
+            method_name == :Time
           end
         end
 
@@ -177,15 +182,16 @@ module RuboCop
           selector_node = node
 
           while node&.send_type?
-            break if node.method_name == :localtime
+            break if node.method?(:localtime)
 
             node = node.parent
           end
 
           return if node.arguments?
 
-          add_offense(selector_node,
-                      location: :selector, message: MSG_LOCALTIME)
+          add_offense(selector_node.loc.selector, message: MSG_LOCALTIME) do |corrector|
+            autocorrect(corrector, selector_node)
+          end
         end
 
         def not_danger_chain?(chain)
@@ -213,10 +219,7 @@ module RuboCop
         end
 
         def acceptable_methods(klass, method_name, node)
-          acceptable = [
-            "`Time.zone.#{safe_method(method_name, node)}`",
-            "`#{klass}.current`"
-          ]
+          acceptable = ["`Time.zone.#{safe_method(method_name, node)}`", "`#{klass}.current`"]
 
           ACCEPTED_METHODS.each do |am|
             acceptable << "`#{klass}.#{method_name}.#{am}`"
@@ -225,12 +228,25 @@ module RuboCop
           acceptable
         end
 
-        # Time.new can be called with a time zone offset
+        # Time.new, Time.at, and Time.now can be called with a time zone offset
         # When it is, that should be considered safe
         # Example:
         # Time.new(1988, 3, 15, 3, 0, 0, "-05:00")
         def offset_provided?(node)
-          node.arguments.size >= 7
+          case node.method_name
+          when :new
+            node.arguments.size == 7 || offset_option_provided?(node)
+          when :at, :now
+            offset_option_provided?(node)
+          end
+        end
+
+        def offset_option_provided?(node)
+          options = node.last_argument
+          options&.hash_type? &&
+            options.each_pair.any? do |pair|
+              pair.key.sym_type? && pair.key.value == :in && !pair.value.nil_type?
+            end
         end
       end
     end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for the use of `Time.zone=` method.
+      #
+      # The `zone` attribute persists for the rest of the Ruby runtime, potentially causing
+      # unexpected behavior at a later time.
+      # Using `Time.use_zone` ensures the code passed in the block is the only place Time.zone is affected.
+      # It eliminates the possibility of a `zone` sticking around longer than intended.
+      #
+      # @example
+      #   # bad
+      #   Time.zone = 'EST'
+      #
+      #   # good
+      #   Time.use_zone('EST') do
+      #   end
+      #
+      class TimeZoneAssignment < Base
+        MSG = 'Use `Time.use_zone` with block instead of `Time.zone=`.'
+        RESTRICT_ON_SEND = %i[zone=].freeze
+
+        def_node_matcher :time_zone_assignment?, <<~PATTERN
+          (send (const {nil? cbase} :Time) :zone= ...)
+        PATTERN
+
+        def on_send(node)
+          return unless time_zone_assignment?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for consistent uses of `to_fs` or `to_formatted_s`,
+      # depending on the cop's configuration.
+      #
+      # @example EnforcedStyle: to_fs (default)
+      #
+      #   # bad
+      #   time.to_formatted_s(:db)
+      #
+      #   # good
+      #   time.to_fs(:db)
+      #
+      # @example EnforcedStyle: to_formatted_s
+      #
+      #   # bad
+      #   time.to_fs(:db)
+      #
+      #   # good
+      #   time.to_formatted_s(:db)
+      #
+      class ToFormattedS < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 7.0
+
+        MSG = 'Use `%<prefer>s` instead.'
+        RESTRICT_ON_SEND = %i[to_formatted_s to_fs].freeze
+
+        def on_send(node)
+          return if node.method?(style)
+
+          add_offense(node.loc.selector, message: format(MSG, prefer: style)) do |corrector|
+            corrector.replace(node.loc.selector, style)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies passing any argument to `#to_s`.
+      #
+      # @safety
+      #   This cop is marked as unsafe because it may detect `#to_s` calls
+      #   that are not related to Active Support implementation.
+      #
+      # @example
+      #
+      #   # bad
+      #   obj.to_s(:delimited)
+      #
+      #   # good
+      #   obj.to_formatted_s(:delimited)
+      #
+      class ToSWithArgument < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        # These types are defined by the following files in ActiveSupport:
+        #   lib/active_support/core_ext/array/conversions.rb
+        #   lib/active_support/core_ext/date/conversions.rb
+        #   lib/active_support/core_ext/date_time/conversions.rb
+        #   lib/active_support/core_ext/numeric/conversions.rb
+        #   lib/active_support/core_ext/range/conversions.rb
+        #   lib/active_support/core_ext/time/conversions.rb
+        #   lib/active_support/time_with_zone.rb
+        EXTENDED_FORMAT_TYPES = Set.new(
+          %i[
+            currency
+            db
+            delimited
+            human
+            human_size
+            inspect
+            iso8601
+            long
+            long_ordinal
+            nsec
+            number
+            percentage
+            phone
+            rfc822
+            rounded
+            short
+            time
+            usec
+          ]
+        )
+
+        MSG = 'Use `to_formatted_s` instead.'
+
+        RESTRICT_ON_SEND = %i[to_s].freeze
+
+        minimum_target_rails_version 7.0
+
+        def on_send(node)
+          return unless rails_extended_to_s?(node)
+
+          add_offense(node.loc.selector) do |corrector|
+            corrector.replace(node.loc.selector, 'to_formatted_s')
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def rails_extended_to_s?(node)
+          node.first_argument&.sym_type? && EXTENDED_FORMAT_TYPES.include?(node.first_argument.value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies top-level `HashWithIndifferentAccess`.
+      # This has been soft-deprecated since Rails 5.1.
+      #
+      # @example
+      #   # bad
+      #   HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      #   # good
+      #   ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      class TopLevelHashWithIndifferentAccess < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.1
+
+        MSG = 'Avoid top-level `HashWithIndifferentAccess`.'
+
+        # @!method top_level_hash_with_indifferent_access?(node)
+        #   @param [RuboCop::AST::ConstNode] node
+        #   @return [Boolean]
+        def_node_matcher :top_level_hash_with_indifferent_access?, <<~PATTERN
+          (const {nil? cbase} :HashWithIndifferentAccess)
+        PATTERN
+
+        # @param [RuboCop::AST::ConstNode] node
+        def on_const(node)
+          return unless top_level_hash_with_indifferent_access?(node)
+          return if node.parent&.class_type? && node.parent.ancestors.any?(&:module_type?)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.insert_before(node.location.name, 'ActiveSupport::')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for the use of exit statements (namely `return`,
+      # `break` and `throw`) in transactions. This is due to the eventual
+      # unexpected behavior when using ActiveRecord >= 7, where transactions
+      # exited using these statements are being rollbacked rather than
+      # committed (pre ActiveRecord 7 behavior).
+      #
+      # As alternatives, it would be more intuitive to explicitly raise an
+      # error when rollback is desired, and to use `next` when commit is
+      # desired.
+      #
+      # @example
+      #   # bad
+      #   ApplicationRecord.transaction do
+      #     return if user.active?
+      #   end
+      #
+      #   # bad
+      #   ApplicationRecord.transaction do
+      #     break if user.active?
+      #   end
+      #
+      #   # bad
+      #   ApplicationRecord.transaction do
+      #     throw if user.active?
+      #   end
+      #
+      #   # bad, as `with_lock` implicitly opens a transaction too
+      #   user.with_lock do
+      #     throw if user.active?
+      #   end
+      #
+      #   # good
+      #   ApplicationRecord.transaction do
+      #     # Rollback
+      #     raise "User is active" if user.active?
+      #   end
+      #
+      #   # good
+      #   ApplicationRecord.transaction do
+      #     # Commit
+      #     next if user.active?
+      #   end
+      class TransactionExitStatement < Base
+        MSG = <<~MSG.chomp
+          Exit statement `%<statement>s` is not allowed. Use `raise` (rollback) or `next` (commit).
+        MSG
+
+        RESTRICT_ON_SEND = %i[transaction with_lock].freeze
+
+        def_node_search :exit_statements, <<~PATTERN
+          ({return | break | send nil? :throw} ...)
+        PATTERN
+
+        def_node_matcher :rescue_body_return_node?, <<~PATTERN
+          (:resbody ...
+            ...
+            ({return | break | send nil? :throw} ...)
+            ...
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless (parent = node.parent)
+          return unless parent.block_type? && parent.body
+
+          exit_statements(parent.body).each do |statement_node|
+            next if statement_node.break_type? && nested_block?(statement_node)
+
+            statement = statement(statement_node)
+            message = format(MSG, statement: statement)
+
+            add_offense(statement_node, message: message)
+          end
+        end
+
+        private
+
+        def statement(statement_node)
+          if statement_node.return_type?
+            'return'
+          elsif statement_node.break_type?
+            'break'
+          else
+            statement_node.method_name
+          end
+        end
+
+        def nested_block?(statement_node)
+          !statement_node.ancestors.find(&:block_type?).method?(:transaction)
+        end
+      end
+    end
+  end
+end