rubocop-rails 2.5.1 → 2.8.0

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Checks SQL heredocs to use `.squish`.
+      #
+      # @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 < Cop
+        include Heredoc
+
+        SQL = 'SQL'
+        SQUISH = '.squish'
+        MSG = 'Use `%<expect>s` instead of `%<current>s`.'
+
+        def on_heredoc(node)
+          return unless offense_detected?(node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.insert_after(node, SQUISH)
+          end
+        end
+
+        private
+
+        def offense_detected?(node)
+          sql_heredoc?(node) && !using_squish?(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 message(node)
+          format(
+            MSG,
+            expect: "#{node.source}#{SQUISH}",
+            current: node.source
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -85,9 +85,7 @@ module RuboCop
             end
 
             # prefer `Time` over `DateTime` class
-            if strict?
-              corrector.replace(node.children.first.source_range, 'Time')
-            end
+            corrector.replace(node.children.first.source_range, 'Time') if strict?
             remove_redundant_in_time_zone(corrector, node)
           end
         end

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

@@ -3,20 +3,23 @@
 module RuboCop
   module Cop
     module Rails
-      # Prefer the use of uniq (or distinct), before pluck instead of after.
+      # Prefer the use of distinct, before pluck instead of after.
       #
-      # The use of uniq before pluck is preferred because it executes within
+      # The use of distinct before pluck is preferred because it executes within
       # the database.
       #
       # This cop has two different enforcement modes. When the EnforcedStyle
       # is conservative (the default) then only calls to pluck on a constant
-      # (i.e. a model class) before uniq are added as offenses.
+      # (i.e. a model class) before distinct are added as offenses.
       #
       # When the EnforcedStyle is aggressive then all calls to pluck before
-      # uniq are added as offenses. This may lead to false positives as the cop
-      # cannot distinguish between calls to pluck on an ActiveRecord::Relation
-      # vs a call to pluck on an ActiveRecord::Associations::CollectionProxy.
+      # distinct are added as offenses. This may lead to false positives
+      # as the cop cannot distinguish between calls to pluck on an
+      # ActiveRecord::Relation vs a call to pluck on an
+      # ActiveRecord::Associations::CollectionProxy.
       #
+      # This cop is unsafe because the behavior may change depending on the
+      # database collation.
       # Autocorrect is disabled by default for this cop since it may generate
       # false positives.
       #
@@ -25,7 +28,7 @@ module RuboCop
       #   Model.pluck(:id).uniq
       #
       #   # good
-      #   Model.uniq.pluck(:id)
+      #   Model.distinct.pluck(:id)
       #
       # @example EnforcedStyle: aggressive
       #   # bad
@@ -40,13 +43,13 @@ module RuboCop
       #   Model.pluck(:id).uniq
       #
       #   # good
-      #   Model.uniq.pluck(:id)
+      #   Model.distinct.pluck(:id)
       #
       class UniqBeforePluck < RuboCop::Cop::Cop
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG = 'Use `%<method>s` before `pluck`.'
+        MSG = 'Use `distinct` before `pluck`.'
         NEWLINE = "\n"
         PATTERN = '[!^block (send (send %<type>s :pluck ...) ' \
                   '${:uniq :distinct} ...)]'
@@ -66,8 +69,7 @@ module RuboCop
 
           return unless method
 
-          add_offense(node, location: :selector,
-                            message: format(MSG, method: method))
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -75,7 +77,7 @@ module RuboCop
             method = node.method_name
 
             corrector.remove(dot_method_with_whitespace(method, node))
-            corrector.insert_before(node.receiver.loc.dot.begin, ".#{method}")
+            corrector.insert_before(node.receiver.loc.dot.begin, '.distinct')
           end
         end
 

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

@@ -34,23 +34,25 @@ module RuboCop
           return unless uniqueness_part(node)
           return if condition_part?(node)
           return unless schema
-          return if with_index?(node)
+
+          klass, table, names = find_schema_information(node)
+          return unless names
+          return if with_index?(klass, table, names)
 
           add_offense(node)
         end
 
         private
 
-        def with_index?(node)
+        def find_schema_information(node)
           klass = class_node(node)
-          return true unless klass # Skip analysis
-
           table = schema.table_by(name: table_name(klass))
-          return true unless table # Skip analysis if it can't find the table
-
           names = column_names(node)
-          return true unless names
 
+          [klass, table, names]
+        end
+
+        def with_index?(klass, table, names)
           # Compatibility for Rails 4.2.
           add_indicies = schema.add_indicies_by(table_name: table_name(klass))
 
@@ -95,6 +97,8 @@ module RuboCop
           scope = find_scope(uniq)
           return unless scope
 
+          scope = unfreeze_scope(scope)
+
           case scope.type
           when :sym, :str
             [scope.value]
@@ -112,6 +116,10 @@ module RuboCop
           end
         end
 
+        def unfreeze_scope(scope)
+          scope.send_type? && scope.method?(:freeze) ? scope.children.first : scope
+        end
+
         def class_node(node)
           node.each_ancestor.find(&:class_type?)
         end
@@ -149,10 +157,6 @@ module RuboCop
             end
           end
         end
-
-        def schema
-          RuboCop::Rails::SchemaLoader.load(target_ruby_version)
-        end
       end
     end
   end

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

@@ -5,6 +5,9 @@ module RuboCop
     module Rails
       # This cop checks that environments called with `Rails.env` predicates
       # exist.
+      # By default the cop allows three environments which Rails ships with:
+      # `development`, `test`, and `production`.
+      # More can be added to the `Environments` config parameter.
       #
       # @example
       #   # bad
@@ -15,8 +18,6 @@ module RuboCop
       #   Rails.env.production?
       #   Rails.env == 'production'
       class UnknownEnv < Cop
-        include NameSimilarity
-
         MSG = 'Unknown environment `%<name>s`.'
         MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
                       'Did you mean `%<similar>s`?'
@@ -57,11 +58,22 @@ module RuboCop
 
         def message(name)
           name = name.to_s.chomp('?')
-          similar = find_similar_name(name, [])
-          if similar
-            format(MSG_SIMILAR, name: name, similar: similar)
-          else
+
+          # DidYouMean::SpellChecker is not available in all versions of Ruby,
+          # and even on versions where it *is* available (>= 2.3), it is not
+          # always required correctly. So we do a feature check first. See:
+          # https://github.com/rubocop-hq/rubocop/issues/7979
+          similar_names = if defined?(DidYouMean::SpellChecker)
+                            spell_checker = DidYouMean::SpellChecker.new(dictionary: environments)
+                            spell_checker.correct(name)
+                          else
+                            []
+                          end
+
+          if similar_names.empty?
             format(MSG, name: name)
+          else
+            format(MSG_SIMILAR, name: name, similar: similar_names.join(', '))
           end
         end
 

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

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces consistent style when using `exists?`.
+      #
+      # Two styles are supported for this cop. When EnforcedStyle is 'exists'
+      # then the cop enforces `exists?(...)` over `where(...).exists?`.
+      #
+      # When EnforcedStyle is 'where' then the cop enforces
+      # `where(...).exists?` over `exists?(...)`.
+      #
+      # @example EnforcedStyle: exists (default)
+      #   # bad
+      #   User.where(name: 'john').exists?
+      #   User.where(['name = ?', 'john']).exists?
+      #   User.where('name = ?', 'john').exists?
+      #   user.posts.where(published: true).exists?
+      #
+      #   # good
+      #   User.exists?(name: 'john')
+      #   User.where('length(name) > 10').exists?
+      #   user.posts.exists?(published: true)
+      #
+      # @example EnforcedStyle: where
+      #   # bad
+      #   User.exists?(name: 'john')
+      #   User.exists?(['name = ?', 'john'])
+      #   User.exists?('name = ?', 'john')
+      #   user.posts.exists?(published: true)
+      #
+      #   # good
+      #   User.where(name: 'john').exists?
+      #   User.where(['name = ?', 'john']).exists?
+      #   User.where('name = ?', 'john').exists?
+      #   user.posts.where(published: true).exists?
+      #   User.where('length(name) > 10').exists?
+      class WhereExists < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
+
+        def_node_matcher :where_exists_call?, <<~PATTERN
+          (send (send _ :where $...) :exists?)
+        PATTERN
+
+        def_node_matcher :exists_with_args?, <<~PATTERN
+          (send _ :exists? $...)
+        PATTERN
+
+        def on_send(node)
+          find_offenses(node) do |args|
+            return unless convertable_args?(args)
+
+            range = correction_range(node)
+            message = format(MSG, good_method: build_good_method(args), bad_method: range.source)
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          args = find_offenses(node)
+
+          lambda do |corrector|
+            corrector.replace(
+              correction_range(node),
+              build_good_method(args)
+            )
+          end
+        end
+
+        private
+
+        def where_style?
+          style == :where
+        end
+
+        def exists_style?
+          style == :exists
+        end
+
+        def find_offenses(node, &block)
+          if exists_style?
+            where_exists_call?(node, &block)
+          elsif where_style?
+            exists_with_args?(node, &block)
+          end
+        end
+
+        def convertable_args?(args)
+          return false if args.empty?
+
+          args.size > 1 || args[0].hash_type? || args[0].array_type?
+        end
+
+        def correction_range(node)
+          if exists_style?
+            node.receiver.loc.selector.join(node.loc.selector)
+          elsif where_style?
+            node.loc.selector.with(end_pos: node.loc.expression.end_pos)
+          end
+        end
+
+        def build_good_method(args)
+          if exists_style?
+            build_good_method_exists(args)
+          elsif where_style?
+            build_good_method_where(args)
+          end
+        end
+
+        def build_good_method_exists(args)
+          if args.size > 1
+            "exists?([#{args.map(&:source).join(', ')}])"
+          else
+            "exists?(#{args[0].source})"
+          end
+        end
+
+        def build_good_method_where(args)
+          if args.size > 1
+            "where(#{args.map(&:source).join(', ')}).exists?"
+          else
+            "where(#{args[0].source}).exists?"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where manually constructed SQL
+      # in `where` can be replaced with `where.not(...)`.
+      #
+      # @example
+      #   # bad
+      #   User.where('name != ?', 'Gabe')
+      #   User.where('name != :name', name: 'Gabe')
+      #   User.where('name IS NOT NULL')
+      #   User.where('name NOT IN (?)', ['john', 'jane'])
+      #   User.where('name NOT IN (:names)', names: ['john', 'jane'])
+      #
+      #   # good
+      #   User.where.not(name: 'Gabe')
+      #   User.where.not(name: nil)
+      #   User.where.not(name: ['john', 'jane'])
+      #
+      class WhereNot < Cop
+        include RangeHelp
+
+        MSG = 'Use `%<good_method>s` instead of manually constructing negated SQL in `where`.'
+
+        def_node_matcher :where_method_call?, <<~PATTERN
+          {
+            (send _ :where (array $str_type? $_ ?))
+            (send _ :where $str_type? $_ ?)
+          }
+        PATTERN
+
+        def on_send(node)
+          where_method_call?(node) do |template_node, value_node|
+            value_node = value_node.first
+
+            range = offense_range(node)
+
+            column_and_value = extract_column_and_value(template_node, value_node)
+            return unless column_and_value
+
+            good_method = build_good_method(*column_and_value)
+            message = format(MSG, good_method: good_method)
+
+            add_offense(node, location: range, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          where_method_call?(node) do |template_node, value_node|
+            value_node = value_node.first
+
+            lambda do |corrector|
+              range = offense_range(node)
+
+              column, value = *extract_column_and_value(template_node, value_node)
+              replacement = build_good_method(column, value)
+
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        NOT_EQ_ANONYMOUS_RE = /\A([\w.]+)\s+!=\s+\?\z/.freeze                  # column != ?
+        NOT_IN_ANONYMOUS_RE = /\A([\w.]+)\s+NOT\s+IN\s+\(\?\)\z/i.freeze       # column NOT IN (?)
+        NOT_EQ_NAMED_RE     = /\A([\w.]+)\s+!=\s+:(\w+)\z/.freeze              # column != :column
+        NOT_IN_NAMED_RE     = /\A([\w.]+)\s+NOT\s+IN\s+\(:(\w+)\)\z/i.freeze   # column NOT IN (:column)
+        IS_NOT_NULL_RE      = /\A([\w.]+)\s+IS\s+NOT\s+NULL\z/i.freeze         # column IS NOT NULL
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def extract_column_and_value(template_node, value_node)
+          value =
+            case template_node.value
+            when NOT_EQ_ANONYMOUS_RE, NOT_IN_ANONYMOUS_RE
+              value_node.source
+            when NOT_EQ_NAMED_RE, NOT_IN_NAMED_RE
+              return unless value_node.hash_type?
+
+              pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
+              pair.value.source
+            when IS_NOT_NULL_RE
+              'nil'
+            else
+              return
+            end
+
+          [Regexp.last_match(1), value]
+        end
+
+        def build_good_method(column, value)
+          if column.include?('.')
+            "where.not('#{column}' => #{value})"
+          else
+            "where.not(#{column}: #{value})"
+          end
+        end
+      end
+    end
+  end
+end