rubocop-rails 2.4.1 → 2.6.0

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,50 +3,51 @@
 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.
       #
       # Autocorrect is disabled by default for this cop since it may generate
       # false positives.
       #
       # @example EnforcedStyle: conservative (default)
       #   # bad
-      #   Model.pluck(:id).uniq
+      #   Model.pluck(:id).distinct
       #
       #   # good
-      #   Model.uniq.pluck(:id)
+      #   Model.distinct.pluck(:id)
       #
       # @example EnforcedStyle: aggressive
       #   # bad
       #   # this will return a Relation that pluck is called on
-      #   Model.where(cond: true).pluck(:id).uniq
+      #   Model.where(cond: true).pluck(:id).distinct
       #
       #   # bad
       #   # an association on an instance will return a CollectionProxy
-      #   instance.assoc.pluck(:id).uniq
+      #   instance.assoc.pluck(:id).distinct
       #
       #   # bad
-      #   Model.pluck(:id).uniq
+      #   Model.pluck(:id).distinct
       #
       #   # 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 +67,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 +75,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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # When you define a uniqueness validation in Active Record model,
+      # you also should add a unique index for the column. There are two reasons
+      # First, duplicated records may occur even if Active Record's validation
+      # is defined.
+      # Second, it will cause slow queries. The validation executes a `SELECT`
+      # statement with the target column when inserting/updating a record.
+      # If the column does not have an index and the table is large,
+      # the query will be heavy.
+      #
+      # Note that the cop does nothing if db/schema.rb does not exist.
+      #
+      # @example
+      #   # bad - if the schema does not have a unique index
+      #   validates :account, uniqueness: true
+      #
+      #   # good - if the schema has a unique index
+      #   validates :account, uniqueness: true
+      #
+      #   # good - even if the schema does not have a unique index
+      #   validates :account, length: { minimum: MIN_LENGTH }
+      #
+      class UniqueValidationWithoutIndex < Cop
+        include ActiveRecordHelper
+
+        MSG = 'Uniqueness validation should be with a unique index.'
+
+        def on_send(node)
+          return unless node.method?(:validates)
+          return unless uniqueness_part(node)
+          return if condition_part?(node)
+          return unless schema
+          return if with_index?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def with_index?(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
+
+          # Compatibility for Rails 4.2.
+          add_indicies = schema.add_indicies_by(table_name: table_name(klass))
+
+          (table.indices + add_indicies).any? do |index|
+            index.unique &&
+              (index.columns.to_set == names ||
+               include_column_names_in_expression_index?(index, names))
+          end
+        end
+
+        def include_column_names_in_expression_index?(index, column_names)
+          return false unless (expression_index = index.expression)
+
+          column_names.all? do |column_name|
+            expression_index.include?(column_name)
+          end
+        end
+
+        def column_names(node)
+          arg = node.first_argument
+          return unless arg.str_type? || arg.sym_type?
+
+          ret = [arg.value]
+          names_from_scope = column_names_from_scope(node)
+          ret.concat(names_from_scope) if names_from_scope
+
+          ret.map! do |name|
+            klass = class_node(node)
+            resolve_relation_into_column(
+              name: name.to_s,
+              class_node: klass,
+              table: schema.table_by(name: table_name(klass))
+            )
+          end
+          ret.include?(nil) ? nil : ret.to_set
+        end
+
+        def column_names_from_scope(node)
+          uniq = uniqueness_part(node)
+          return unless uniq.hash_type?
+
+          scope = find_scope(uniq)
+          return unless scope
+
+          case scope.type
+          when :sym, :str
+            [scope.value]
+          when :array
+            array_node_to_array(scope)
+          end
+        end
+
+        def find_scope(pairs)
+          pairs.each_pair.find do |pair|
+            key = pair.key
+            next unless key.sym_type? && key.value == :scope
+
+            break pair.value
+          end
+        end
+
+        def class_node(node)
+          node.each_ancestor.find(&:class_type?)
+        end
+
+        def uniqueness_part(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair.find do |pair|
+            next unless pair.key.sym_type? && pair.key.value == :uniqueness
+
+            break pair.value
+          end
+        end
+
+        def condition_part?(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair.any? do |pair|
+            key = pair.key
+            next unless key.sym_type?
+
+            key.value == :if || key.value == :unless
+          end
+        end
+
+        def array_node_to_array(node)
+          node.values.map do |elm|
+            case elm.type
+            when :str, :sym
+              elm.value
+            else
+              return nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,8 +15,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 +55,14 @@ 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
+
+          spell_checker = DidYouMean::SpellChecker.new(dictionary: environments)
+          similar_names = spell_checker.correct(name)
+
+          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_cops.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'mixin/active_record_helper'
+require_relative 'mixin/index_method'
 require_relative 'mixin/target_rails_version'
 
 require_relative 'rails/action_filter'
@@ -14,6 +16,7 @@ require_relative 'rails/assert_not'
 require_relative 'rails/belongs_to'
 require_relative 'rails/blank'
 require_relative 'rails/bulk_change_table'
+require_relative 'rails/content_tag'
 require_relative 'rails/create_table_with_timestamps'
 require_relative 'rails/date'
 require_relative 'rails/delegate'
@@ -32,18 +35,22 @@ require_relative 'rails/helper_instance_variable'
 require_relative 'rails/http_positional_arguments'
 require_relative 'rails/http_status'
 require_relative 'rails/ignored_skip_action_filter_option'
+require_relative 'rails/index_by'
+require_relative 'rails/index_with'
 require_relative 'rails/inverse_of'
 require_relative 'rails/lexically_scoped_action_filter'
 require_relative 'rails/link_to_blank'
 require_relative 'rails/not_null_column'
 require_relative 'rails/output'
 require_relative 'rails/output_safety'
+require_relative 'rails/pick'
 require_relative 'rails/pluralization_grammar'
 require_relative 'rails/presence'
 require_relative 'rails/present'
 require_relative 'rails/rake_environment'
 require_relative 'rails/read_write_attribute'
 require_relative 'rails/redundant_allow_nil'
+require_relative 'rails/redundant_foreign_key'
 require_relative 'rails/redundant_receiver_in_with_options'
 require_relative 'rails/reflection_class_name'
 require_relative 'rails/refute_methods'
@@ -57,5 +64,6 @@ require_relative 'rails/scope_args'
 require_relative 'rails/skips_model_validations'
 require_relative 'rails/time_zone'
 require_relative 'rails/uniq_before_pluck'
+require_relative 'rails/unique_validation_without_index'
 require_relative 'rails/unknown_env'
 require_relative 'rails/validation'

data/lib/rubocop/rails/inject.rb

@@ -8,7 +8,7 @@ module RuboCop
       def self.defaults!
         path = CONFIG_DEFAULT.to_s
         hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path)
+        config = Config.new(hash, path).tap(&:make_excludes_absolute)
         puts "configuration from #{path}" if ConfigLoader.debug?
         config = ConfigLoader.merge_with_default(config, path, unset_nil: false)
         ConfigLoader.instance_variable_set(:@default_configuration, config)

data/lib/rubocop/rails/schema_loader.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Rails
+    # It loads db/schema.rb and return Schema object.
+    # Cops refers database schema information with this module.
+    module SchemaLoader
+      extend self
+
+      # It parses `db/schema.rb` and return it.
+      # It returns `nil` if it can't find `db/schema.rb`.
+      # So a cop that uses the loader should handle `nil` properly.
+      #
+      # @return [Schema, nil]
+      def load(target_ruby_version)
+        return @schema if defined?(@schema)
+
+        @schema = load!(target_ruby_version)
+      end
+
+      def reset!
+        return unless instance_variable_defined?(:@schema)
+
+        remove_instance_variable(:@schema)
+      end
+
+      def db_schema_path
+        path = Pathname.pwd
+        until path.root?
+          schema_path = path.join('db/schema.rb')
+          return schema_path if schema_path.exist?
+
+          path = path.join('../').cleanpath
+        end
+
+        nil
+      end
+
+      private
+
+      def load!(target_ruby_version)
+        path = db_schema_path
+        return unless path
+
+        ast = parse(path, target_ruby_version)
+        Schema.new(ast)
+      end
+
+      def parse(path, target_ruby_version)
+        klass_name = :"Ruby#{target_ruby_version.to_s.sub('.', '')}"
+        klass = ::Parser.const_get(klass_name)
+        parser = klass.new(RuboCop::AST::Builder.new)
+
+        buffer = Parser::Source::Buffer.new(path, 1)
+        buffer.source = path.read
+
+        parser.parse(buffer)
+      end
+    end
+  end
+end

data/lib/rubocop/rails/schema_loader/schema.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Rails
+    module SchemaLoader
+      # Represent db/schema.rb
+      class Schema
+        attr_reader :tables, :add_indicies
+
+        def initialize(ast)
+          @tables = []
+          @add_indicies = []
+
+          build!(ast)
+        end
+
+        def table_by(name:)
+          tables.find do |table|
+            table.name == name
+          end
+        end
+
+        def add_indicies_by(table_name:)
+          add_indicies.select do |add_index|
+            add_index.table_name == table_name
+          end
+        end
+
+        private
+
+        def build!(ast)
+          raise "Unexpected type: #{ast.type}" unless ast.block_type?
+
+          each_table(ast) do |table_def|
+            @tables << Table.new(table_def)
+          end
+
+          # Compatibility for Rails 4.2.
+          each_add_index(ast) do |add_index_def|
+            @add_indicies << AddIndex.new(add_index_def)
+          end
+        end
+
+        def each_table(ast)
+          case ast.body.type
+          when :begin
+            ast.body.children.each do |node|
+              next unless node.block_type? && node.method?(:create_table)
+
+              yield(node)
+            end
+          else
+            yield ast.body
+          end
+        end
+
+        def each_add_index(ast)
+          ast.body.children.each do |node|
+            next if !node&.send_type? || !node.method?(:add_index)
+
+            yield(node)
+          end
+        end
+      end
+
+      # Represent a table
+      class Table
+        attr_reader :name, :columns, :indices
+
+        def initialize(node)
+          @name = node.send_node.first_argument.value
+          @columns = build_columns(node)
+          @indices = build_indices(node)
+        end
+
+        def with_column?(name:)
+          @columns.any? { |c| c.name == name }
+        end
+
+        private
+
+        def build_columns(node)
+          each_content(node).map do |child|
+            next unless child&.send_type?
+            next if child.method?(:index)
+
+            Column.new(child)
+          end.compact
+        end
+
+        def build_indices(node)
+          each_content(node).map do |child|
+            next unless child&.send_type?
+            next unless child.method?(:index)
+
+            Index.new(child)
+          end.compact
+        end
+
+        def each_content(node)
+          return enum_for(__method__, node) unless block_given?
+
+          case node.body&.type
+          when :begin
+            node.body.children.each do |child|
+              yield(child)
+            end
+          else
+            yield(node.body)
+          end
+        end
+      end
+
+      # Represent a column
+      class Column
+        attr_reader :name, :type, :not_null
+
+        def initialize(node)
+          @name = node.first_argument.value
+          @type = node.method_name
+          @not_null = nil
+
+          analyze_keywords!(node)
+        end
+
+        private
+
+        def analyze_keywords!(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair do |k, v|
+            if k.value == :null
+              @not_null = v.true_type? ? false : true
+            end
+          end
+        end
+      end
+
+      # Represent an index
+      class Index
+        attr_reader :name, :columns, :expression, :unique
+
+        def initialize(node)
+          @columns, @expression = build_columns_or_expr(node.first_argument)
+          @unique = nil
+
+          analyze_keywords!(node)
+        end
+
+        private
+
+        def build_columns_or_expr(columns)
+          if columns.array_type?
+            [columns.values.map(&:value), nil]
+          else
+            [[], columns.value]
+          end
+        end
+
+        def analyze_keywords!(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair do |k, v|
+            case k.value
+            when :name
+              @name = v.value
+            when :unique
+              @unique = true
+            end
+          end
+        end
+      end
+
+      # Represent an `add_index`
+      class AddIndex < Index
+        attr_reader :table_name
+
+        def initialize(node)
+          @table_name = node.first_argument.value
+          @columns, @expression = build_columns_or_expr(node.arguments[1])
+          @unique = nil
+
+          analyze_keywords!(node)
+        end
+      end
+    end
+  end
+end