rubocop-rails 2.0.1 → 2.19.1

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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
+      # is conservative (the default) then only `I18n.translate` and `I18n.localize`
+      # calls are added as offenses.
+      #
+      # When the EnforcedStyle is aggressive then all `translate` and `localize` calls
+      # without a receiver are added as offenses.
+      #
+      # @example
+      #   # bad
+      #   I18n.translate :key
+      #   I18n.localize Time.now
+      #
+      #   # good
+      #   I18n.t :key
+      #   I18n.l Time.now
+      #
+      # @example EnforcedStyle: conservative (default)
+      #   # good
+      #   translate :key
+      #   localize Time.now
+      #   t :key
+      #   l Time.now
+      #
+      # @example EnforcedStyle: aggressive
+      #   # bad
+      #   translate :key
+      #   localize Time.now
+      #
+      #   # good
+      #   t :key
+      #   l Time.now
+      #
+      class ShortI18n < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+
+        PREFERRED_METHODS = { translate: :t, localize: :l }.freeze
+
+        RESTRICT_ON_SEND = PREFERRED_METHODS.keys.freeze
+
+        def_node_matcher :long_i18n?, <<~PATTERN
+          (send {nil? (const {nil? cbase} :I18n)} ${:translate :localize} ...)
+        PATTERN
+
+        def on_send(node)
+          return if style == :conservative && !node.receiver
+
+          long_i18n?(node) do |method_name|
+            good_method = PREFERRED_METHODS[method_name]
+            message = format(MSG, good_method: good_method, bad_method: method_name)
+            range = node.loc.selector
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, PREFERRED_METHODS[method_name])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,11 +3,11 @@
 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
       #
-      # Methods may be ignored from this rule by configuring a `Whitelist`.
+      # Methods may be ignored from this rule by configuring a `AllowedMethods`.
       #
       # @example
       #   # bad
@@ -26,7 +26,7 @@ module RuboCop
       #   user.update(website: 'example.com')
       #   FileUtils.touch('file')
       #
-      # @example Whitelist: ["touch"]
+      # @example AllowedMethods: ["touch"]
       #   # bad
       #   DiscussionBoard.decrement_counter(:post_count, 5)
       #   DiscussionBoard.increment_counter(:post_count, 5)
@@ -35,34 +35,57 @@ module RuboCop
       #   # good
       #   user.touch
       #
-      class SkipsModelValidations < Cop
+      class SkipsModelValidations < Base
         MSG = 'Avoid using `%<method>s` because it skips validations.'
 
         METHODS_WITH_ARGUMENTS = %w[decrement!
                                     decrement_counter
                                     increment!
                                     increment_counter
+                                    insert
+                                    insert!
+                                    insert_all
+                                    insert_all!
                                     toggle!
                                     update_all
                                     update_attribute
                                     update_column
                                     update_columns
-                                    update_counters].freeze
+                                    update_counters
+                                    upsert
+                                    upsert_all].freeze
 
-        def_node_matcher :good_touch?, <<-PATTERN
-          (send (const nil? :FileUtils) :touch ...)
+        def_node_matcher :good_touch?, <<~PATTERN
+          {
+            (send (const {nil? cbase} :FileUtils) :touch ...)
+            (send _ :touch {true false})
+          }
+        PATTERN
+
+        def_node_matcher :good_insert?, <<~PATTERN
+          (send _ {:insert :insert!} _ {
+            !(hash ...)
+            (hash <(pair (sym !{:returning :unique_by}) _) ...>)
+          } ...)
         PATTERN
 
         def on_send(node)
-          return if whitelist.include?(node.method_name.to_s)
-          return unless blacklist.include?(node.method_name.to_s)
+          return if allowed_methods.include?(node.method_name.to_s)
+          return unless forbidden_methods.include?(node.method_name.to_s)
           return if allowed_method?(node)
           return if good_touch?(node)
+          return if good_insert?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector, message: message(node))
         end
         alias on_csend on_send
 
+        def initialize(*)
+          super
+          @displayed_allowed_warning = false
+          @displayed_forbidden_warning = false
+        end
+
         private
 
         def message(node)
@@ -70,16 +93,30 @@ 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 blacklist
-          cop_config['Blacklist'] || []
+        def forbidden_methods
+          obsolete_result = cop_config['Blacklist']
+          if obsolete_result
+            warn '`Blacklist` has been renamed to `ForbiddenMethods`.' unless @displayed_forbidden_warning
+            @displayed_forbidden_warning = true
+            return obsolete_result
+          end
+
+          cop_config['ForbiddenMethods'] || []
         end
 
-        def whitelist
-          cop_config['Whitelist'] || []
+        def allowed_methods
+          obsolete_result = cop_config['Whitelist']
+          if obsolete_result
+            warn '`Whitelist` has been renamed to `AllowedMethods`.' unless @displayed_allowed_warning
+            @displayed_allowed_warning = true
+
+            return obsolete_result
+          end
+
+          cop_config['AllowedMethods'] || []
         end
       end
     end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Checks SQL heredocs to use `.squish`.
+      #
+      # @safety
+      #   Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
+      #   to be preserved in order to work, thus autocorrection for this cop is not safe.
+      #
+      # @example
+      #   # bad
+      #   <<-SQL
+      #     SELECT * FROM posts;
+      #   SQL
+      #
+      #   <<-SQL
+      #     SELECT * FROM posts
+      #       WHERE id = 1
+      #   SQL
+      #
+      #   execute(<<~SQL, "Post Load")
+      #     SELECT * FROM posts
+      #       WHERE post_id = 1
+      #   SQL
+      #
+      #   # good
+      #   <<-SQL.squish
+      #     SELECT * FROM posts;
+      #   SQL
+      #
+      #   <<~SQL.squish
+      #     SELECT * FROM table
+      #       WHERE id = 1
+      #   SQL
+      #
+      #   execute(<<~SQL.squish, "Post Load")
+      #     SELECT * FROM posts
+      #       WHERE post_id = 1
+      #   SQL
+      #
+      class SquishedSQLHeredocs < Base
+        include Heredoc
+        extend AutoCorrector
+
+        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)
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(node, SQUISH)
+          end
+        end
+
+        private
+
+        def offense_detected?(node)
+          sql_heredoc?(node) && !using_squish?(node) && !singleline_comments_present?(node)
+        end
+
+        def sql_heredoc?(node)
+          delimiter_string(node) == SQL
+        end
+
+        def using_squish?(node)
+          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)
+        end
+      end
+    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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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
+      # on a legacy project.
+      #
+      # If you need to change how your model's name is translated to
+      # a table name, you may want to look at Inflections:
+      # https://api.rubyonrails.org/classes/ActiveSupport/Inflector/Inflections.html
+      #
+      # If you wish to add a prefix in front of your model, or wish to change
+      # the default prefix, `self.table_name_prefix` might better suit your needs:
+      # https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema.html#method-c-table_name_prefix-3D
+      #
+      # STI base classes named `Base` are ignored by this cop.
+      # For more information: https://api.rubyonrails.org/classes/ActiveRecord/Inheritance.html
+      #
+      # @example
+      #   # bad
+      #   self.table_name = 'some_table_name'
+      #   self.table_name = :some_other_name
+      class TableNameAssignment < Base
+        include ActiveRecordHelper
+
+        MSG = 'Do not use `self.table_name =`.'
+
+        def_node_matcher :base_class?, <<~PATTERN
+          (class (const ... :Base) ...)
+        PATTERN
+
+        def on_class(class_node)
+          return if base_class?(class_node)
+
+          find_set_table_name(class_node).each { |node| add_offense(node) }
+        end
+      end
+    end
+  end
+end

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