rubocop-rails 2.14.2 → 2.19.1

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Favor `Rails.public_path` over `Rails.root` with `'public'`
+      #
+      # @example
+      #   # bad
+      #   Rails.root.join('public')
+      #   Rails.root.join('public/file.pdf')
+      #   Rails.root.join('public', 'file.pdf')
+      #
+      #   # good
+      #   Rails.public_path
+      #   Rails.public_path.join('file.pdf')
+      #   Rails.public_path.join('file.pdf')
+      #
+      class RootPublicPath < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Rails.public_path`.'
+
+        RESTRICT_ON_SEND = %i[join].to_set.freeze
+
+        PATTERN = %r{\Apublic(/|\z)}.freeze
+
+        def_node_matcher :rails_root_public, <<~PATTERN
+          (send
+            (send
+              $(const {nil? cbase} :Rails) :root) :join
+            (str $#public_path?) $...)
+        PATTERN
+
+        def on_send(node)
+          return unless (rails, maybe_public_path, other_args = rails_root_public(node))
+
+          add_offense(node) do |corrector|
+            first_args = maybe_public_path.gsub(PATTERN, '')
+
+            args = other_args.map(&:source)
+            args.unshift("'#{first_args}'") unless first_args.empty?
+
+            replacement = "#{rails.source}.public_path"
+            replacement += ".join(#{args.join(', ')})" unless args.empty?
+
+            corrector.replace(node, replacement)
+          end
+        end
+
+        private
+
+        def public_path?(string)
+          PATTERN.match?(string)
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,9 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop converts usages of `try!` to `&.`. It can also be configured
-      # to convert `try`. It will convert code to use safe navigation.
+      # Converts usages of `try!` to `&.`. It can also be configured
+      # to convert `try`. It will convert code to use safe navigation
+      # if the target Ruby version is set to 2.3+
       #
       # @example ConvertTry: false (default)
       #   # bad
@@ -39,6 +40,9 @@ module RuboCop
       class SafeNavigation < Base
         include RangeHelp
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         MSG = 'Use safe navigation (`&.`) instead of `%<try>s`.'
         RESTRICT_ON_SEND = %i[try try!].freeze
@@ -47,15 +51,6 @@ module RuboCop
           (send _ ${:try :try!} $_ ...)
         PATTERN
 
-        # Monkey patching for `Style/RedundantSelf` of RuboCop core.
-        # rubocop:disable Style/ClassAndModuleChildren
-        class Style::RedundantSelf
-          def self.autocorrect_incompatible_with
-            [Rails::SafeNavigation]
-          end
-        end
-        # rubocop:enable Style/ClassAndModuleChildren
-
         def self.autocorrect_incompatible_with
           [Style::RedundantSelf]
         end
@@ -75,10 +70,10 @@ module RuboCop
 
         def autocorrect(corrector, node)
           method_node, *params = *node.arguments
-          method = method_node.source[1..-1]
+          method = method_node.source[1..]
 
           range = if node.receiver
-                    range_between(node.loc.dot.begin_pos, node.loc.expression.end_pos)
+                    range_between(node.loc.dot.begin_pos, node.source_range.end_pos)
                   else
                     corrector.insert_before(node, 'self')
                     node

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks to make sure safe navigation isn't used with `blank?` in
+      # Checks to make sure safe navigation isn't used with `blank?` in
       # a conditional.
       #
       # @safety
@@ -31,9 +31,7 @@ module RuboCop
       class SafeNavigationWithBlank < Base
         extend AutoCorrector
 
-        MSG =
-          'Avoid calling `blank?` with the safe navigation operator ' \
-          'in conditionals.'
+        MSG = 'Avoid calling `blank?` with the safe navigation operator in conditionals.'
 
         def_node_matcher :safe_navigation_blank_in_conditional?, <<~PATTERN
           (if $(csend ... :blank?) ...)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop identifies possible cases where Active Record save! or related
+      # Identifies possible cases where Active Record save! or related
       # should be used instead of save because the model might have failed to
       # save and an exception is better than unhandled failure.
       #
@@ -37,7 +37,7 @@ module RuboCop
       #
       #   update_attributes
       #
-      #   # After running rubocop --safe-auto-correct
+      #   # After running rubocop --safe-autocorrect
       #   def update_attributes
       #   end
       #
@@ -121,18 +121,12 @@ module RuboCop
         include NegativeConditional
         extend AutoCorrector
 
-        MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return ' \
-              'value is not checked.'
-        CREATE_MSG = (MSG +
-                      ' Or check `persisted?` on model returned from ' \
-                      '`%<current>s`.').freeze
-        CREATE_CONDITIONAL_MSG = '`%<current>s` returns a model which is ' \
-                                 'always truthy.'
-
-        CREATE_PERSIST_METHODS = %i[create create_or_find_by
-                                    first_or_create find_or_create_by].freeze
-        MODIFY_PERSIST_METHODS = %i[save
-                                    update update_attributes destroy].freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return value is not checked.'
+        CREATE_MSG = "#{MSG} Or check `persisted?` on model returned from `%<current>s`."
+        CREATE_CONDITIONAL_MSG = '`%<current>s` returns a model which is always truthy.'
+
+        CREATE_PERSIST_METHODS = %i[create create_or_find_by first_or_create find_or_create_by].freeze
+        MODIFY_PERSIST_METHODS = %i[save update update_attributes destroy].freeze
         RESTRICT_ON_SEND = (CREATE_PERSIST_METHODS + MODIFY_PERSIST_METHODS).freeze
 
         def self.joining_forces
@@ -244,8 +238,7 @@ module RuboCop
           parent = node.parent
           return false unless parent
 
-          operator_or_single_negative?(parent) ||
-            (conditional?(parent) && node == parent.condition)
+          operator_or_single_negative?(parent) || (conditional?(parent) && node == parent.condition)
         end
 
         def operator_or_single_negative?(node)
@@ -294,9 +287,7 @@ module RuboCop
         # NameSpace::Const != ::Const
         # Const != NameSpace::Const
         def const_matches?(const, allowed_const)
-          parts = allowed_const.split('::').reverse.zip(
-            const.split('::').reverse
-          )
+          parts = allowed_const.split('::').reverse.zip(const.split('::').reverse)
           parts.all? do |(allowed_part, const_part)|
             allowed_part == const_part.to_s
           end
@@ -335,9 +326,7 @@ module RuboCop
         end
 
         def persist_method?(node, methods = RESTRICT_ON_SEND)
-          methods.include?(node.method_name) &&
-            expected_signature?(node) &&
-            !allowed_receiver?(node)
+          methods.include?(node.method_name) && expected_signature?(node) && !allowed_receiver?(node)
         end
 
         # Check argument signature as no arguments or one hash
@@ -345,8 +334,7 @@ module RuboCop
           !node.arguments? ||
             (node.arguments.one? &&
               node.method_name != :destroy &&
-              (node.first_argument.hash_type? ||
-              !node.first_argument.literal?))
+              (node.first_argument.hash_type? || !node.first_argument.literal?))
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the use of the `comment` option when adding a new table or column
+      # Enforces the use of the `comment` option when adding a new table or column
       # to the database during a migration.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for scope calls where it was passed
+      # Checks for scope calls where it was passed
       # a method (usually a scope) instead of a lambda/proc.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces that short forms of `I18n` methods are used:
+      # Enforces that short forms of `I18n` methods are used:
       # `t` instead of `translate` and `l` instead of `localize`.
       #
       # This cop has two different enforcement modes. When the EnforcedStyle
@@ -44,15 +44,12 @@ module RuboCop
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
 
-        PREFERRED_METHODS = {
-          translate: :t,
-          localize: :l
-        }.freeze
+        PREFERRED_METHODS = { translate: :t, localize: :l }.freeze
 
         RESTRICT_ON_SEND = PREFERRED_METHODS.keys.freeze
 
         def_node_matcher :long_i18n?, <<~PATTERN
-          (send {nil? (const nil? :I18n)} ${:translate :localize} ...)
+          (send {nil? (const {nil? cbase} :I18n)} ${:translate :localize} ...)
         PATTERN
 
         def on_send(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of methods which skip
+      # Checks for the use of methods which skip
       # validations which are listed in
       # https://guides.rubyonrails.org/active_record_validations.html#skipping-validations
       #
@@ -57,7 +57,7 @@ module RuboCop
 
         def_node_matcher :good_touch?, <<~PATTERN
           {
-            (send (const nil? :FileUtils) :touch ...)
+            (send (const {nil? cbase} :FileUtils) :touch ...)
             (send _ :touch {true false})
           }
         PATTERN
@@ -93,8 +93,7 @@ module RuboCop
         end
 
         def allowed_method?(node)
-          METHODS_WITH_ARGUMENTS.include?(node.method_name.to_s) &&
-            !node.arguments?
+          METHODS_WITH_ARGUMENTS.include?(node.method_name.to_s) && !node.arguments?
         end
 
         def forbidden_methods

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

@@ -8,7 +8,7 @@ module RuboCop
       #
       # @safety
       #   Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
-      #   to be preserved in order to work, thus auto-correction for this cop is not safe.
+      #   to be preserved in order to work, thus autocorrection for this cop is not safe.
       #
       # @example
       #   # bad
@@ -48,6 +48,7 @@ module RuboCop
         SQL = 'SQL'
         SQUISH = '.squish'
         MSG = 'Use `%<expect>s` instead of `%<current>s`.'
+        SQL_IDENTIFIER_MARKERS = /(".+?")|('.+?')|(\[.+?\])/.freeze
 
         def on_heredoc(node)
           return unless offense_detected?(node)
@@ -60,7 +61,7 @@ module RuboCop
         private
 
         def offense_detected?(node)
-          sql_heredoc?(node) && !using_squish?(node)
+          sql_heredoc?(node) && !using_squish?(node) && !singleline_comments_present?(node)
         end
 
         def sql_heredoc?(node)
@@ -71,12 +72,14 @@ module RuboCop
           node.parent&.send_type? && node.parent&.method?(:squish)
         end
 
+        def singleline_comments_present?(node)
+          sql = node.children.map { |c| c.is_a?(String) ? c : c.source }.join('\n')
+
+          sql.gsub(SQL_IDENTIFIER_MARKERS, '').include?('--')
+        end
+
         def message(node)
-          format(
-            MSG,
-            expect: "#{node.source}#{SQUISH}",
-            current: node.source
-          )
+          format(MSG, expect: "#{node.source}#{SQUISH}", current: node.source)
         end
       end
     end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces the use of squiggly heredoc over `strip_heredoc`.
+      #
+      # @example
+      #
+      #   # bad
+      #   <<EOS.strip_heredoc
+      #     some text
+      #   EOS
+      #
+      #   # bad
+      #   <<-EOS.strip_heredoc
+      #     some text
+      #   EOS
+      #
+      #   # good
+      #   <<~EOS
+      #     some text
+      #   EOS
+      #
+      class StripHeredoc < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        MSG = 'Use squiggly heredoc (`<<~`) instead of `strip_heredoc`.'
+        RESTRICT_ON_SEND = %i[strip_heredoc].freeze
+
+        minimum_target_ruby_version 2.3
+
+        def on_send(node)
+          return unless (receiver = node.receiver)
+          return unless receiver.str_type? || receiver.dstr_type?
+          return unless receiver.respond_to?(:heredoc?) && receiver.heredoc?
+
+          register_offense(node, receiver)
+        end
+
+        private
+
+        def register_offense(node, heredoc)
+          add_offense(node) do |corrector|
+            squiggly_heredoc = heredoc.source.sub(/\A<<(-|~)?/, '<<~')
+
+            corrector.replace(heredoc, squiggly_heredoc)
+            corrector.remove(node.loc.dot)
+            corrector.remove(node.loc.selector)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the absence of explicit table name assignment.
+      # Enforces the absence of explicit table name assignment.
       #
       # `self.table_name=` should only be used for very good reasons,
       # such as not having control over the database, or working

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces that boolean columns are created with default values (`false` or `true`) and
+      # `NOT NULL` constraint.
+      #
+      # @example
+      #   # bad
+      #   add_column :users, :active, :boolean
+      #   t.column :active, :boolean
+      #   t.boolean :active
+      #
+      #   # good
+      #   add_column :users, :active, :boolean, default: true, null: false
+      #   t.column :active, :boolean, default: true, null: false
+      #   t.boolean :active, default: true, null: false
+      #
+      class ThreeStateBooleanColumn < Base
+        MSG = 'Boolean columns should always have a default value and a `NOT NULL` constraint.'
+
+        RESTRICT_ON_SEND = %i[add_column column boolean].freeze
+
+        def_node_matcher :three_state_boolean?, <<~PATTERN
+          {
+            (send nil? :add_column _ $_ {(sym :boolean) (str "boolean")} $_ ?)
+            (send !nil? :column $_ {(sym :boolean) (str "boolean")} $_ ?)
+            (send !nil? :boolean $_ $_ ?)
+          }
+        PATTERN
+
+        def_node_matcher :required_options?, <<~PATTERN
+          (hash <(pair (sym :default) !nil?) (pair (sym :null) false) ...>)
+        PATTERN
+
+        def_node_search :change_column_null?, <<~PATTERN
+          (send nil? :change_column_null {(sym %1) (str %1)} {(sym %2) (str %2)} false)
+        PATTERN
+
+        def on_send(node)
+          three_state_boolean?(node) do |column_node, options_node|
+            options_node = options_node.first
+
+            return if required_options?(options_node)
+
+            def_node = node.each_ancestor(:def, :defs).first
+            table_node = table_node(node)
+            if def_node && (table_node.nil? || change_column_null?(def_node, table_node.value, column_node.value))
+              return
+            end
+
+            add_offense(node)
+          end
+        end
+
+        private
+
+        def table_node(node)
+          case node.method_name
+          when :add_column
+            node.first_argument
+          when :column, :boolean
+            ancestor = node.each_ancestor(:block).find do |n|
+              n.method?(:create_table) || n.method?(:change_table)
+            end
+            ancestor&.send_node&.first_argument
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 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://rails.rubystyle.guide#time)
       # and the article http://danilenko.org/2012/7/6/rails_timezones/
@@ -28,38 +28,34 @@ module RuboCop
       #   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: strict
-      #   # `strict` means that `Time` should be used with `zone`.
-      #
-      #   # bad
-      #   Time.at(timestamp).in_time_zone
-      #
       # @example EnforcedStyle: flexible (default)
       #   # `flexible` allows usage of `in_time_zone` instead of `zone`.
       #
       #   # good
       #   Time.at(timestamp).in_time_zone
+      #
+      # @example EnforcedStyle: strict
+      #   # `strict` means that `Time` should be used with `zone`.
+      #
+      #   # bad
+      #   Time.at(timestamp).in_time_zone
       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.'
+        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].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]/.freeze
+        TIMEZONE_SPECIFIER = /([A-z]|[+-]\d{2}:?\d{2})\z/.freeze
 
         def on_const(node)
           mod, klass = *node
@@ -74,7 +70,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           # add `.zone`: `Time.at` => `Time.zone.at`
-          corrector.insert_after(node.children[0].source_range, '.zone')
+          corrector.insert_after(node.children[0], '.zone')
 
           case node.method_name
           when :current
@@ -85,7 +81,7 @@ module RuboCop
           end
 
           # prefer `Time` over `DateTime` class
-          corrector.replace(node.children.first.source_range, 'Time') if strict?
+          corrector.replace(node.children.first, 'Time') if strict?
           remove_redundant_in_time_zone(corrector, node)
         end
 
@@ -100,13 +96,11 @@ module RuboCop
         # 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
@@ -132,7 +126,7 @@ module RuboCop
         end
 
         def attach_timezone_specifier?(date)
-          date.respond_to?(:value) && TIMEZONE_SPECIFIER.match?(date.value.to_s[-1])
+          date.respond_to?(:value) && TIMEZONE_SPECIFIER.match?(date.value.to_s)
         end
 
         def build_message(klass, method_name, node)
@@ -144,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
 
@@ -227,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}`"
@@ -239,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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of `Time.zone=` method.
+      # 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.
@@ -22,12 +22,12 @@ module RuboCop
         MSG = 'Use `Time.use_zone` with block instead of `Time.zone=`.'
         RESTRICT_ON_SEND = %i[zone=].freeze
 
-        def_node_matcher :time_zone_assignement?, <<~PATTERN
-          (send (const nil? :Time) :zone= ...)
+        def_node_matcher :time_zone_assignment?, <<~PATTERN
+          (send (const {nil? cbase} :Time) :zone= ...)
         PATTERN
 
         def on_send(node)
-          return unless time_zone_assignement?(node)
+          return unless time_zone_assignment?(node)
 
           add_offense(node)
         end