rubocop 0.55.0 → 0.56.0

data/lib/rubocop/cop/lint/unneeded_cop_enable_directive.rb

@@ -10,6 +10,8 @@ module RuboCop
       # This cop detects instances of rubocop:enable comments that can be
       # removed.
       #
+      # When comment enables all cops at once `rubocop:enable all`
+      # that cop checks whether any cop was actually enabled.
       # @example
       #   # bad
       #   foo = 1
@@ -17,6 +19,19 @@ module RuboCop
       #
       #   # good
       #   foo = 1
+      # @example
+      #   # bad
+      #   # rubocop:disable Metrics/LineLength
+      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:enable Metrics/LineLength
+      #   baz
+      #   # rubocop:enable all
+      #
+      #   # good
+      #   # rubocop:disable Metrics/LineLength
+      #   baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaarrrrrrrrrrrrr
+      #   # rubocop:enable all
+      #   baz
       class UnneededCopEnableDirective < Cop
         include RangeHelp
         include SurroundingSpace
@@ -30,7 +45,7 @@ module RuboCop
             add_offense(
               [comment, name],
               location: range_of_offense(comment, name),
-              message: format(MSG, cop: name)
+              message: format(MSG, cop: all_or_name(name))
             )
           end
         end
@@ -90,8 +105,11 @@ module RuboCop
             range_class.new(buffer, start, comment.loc.expression.end_pos)
           end
         end
+
+        def all_or_name(name)
+          name == 'all' ? 'all cops' : name
+        end
       end
     end
   end
 end
-# rubocop:enable Lint/UnneededCopEnableDirective

data/lib/rubocop/cop/performance/inefficient_hash_search.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop checks for inefficient searching of keys and values within
+      # hashes.
+      #
+      # `Hash#keys.include?` is less efficient than `Hash#key?` because
+      # the former allocates a new array and then performs an O(n) search
+      # through that array, while `Hash#key?` does not allocate any array and
+      # performs a faster O(1) search for the key.
+      #
+      # `Hash#values.include?` is less efficient than `Hash#value?`. While they
+      # both perform an O(n) search through all of the values, calling `values`
+      # allocates a new array while using `value?` does not.
+      #
+      # @example
+      #   # bad
+      #   { a: 1, b: 2 }.keys.include?(:a)
+      #   { a: 1, b: 2 }.keys.include?(:z)
+      #   h = { a: 1, b: 2 }; h.keys.include?(100)
+      #
+      #   # good
+      #   { a: 1, b: 2 }.key?(:a)
+      #   { a: 1, b: 2 }.has_key?(:z)
+      #   h = { a: 1, b: 2 }; h.key?(100)
+      #
+      #   # bad
+      #   { a: 1, b: 2 }.values.include?(2)
+      #   { a: 1, b: 2 }.values.include?('garbage')
+      #   h = { a: 1, b: 2 }; h.values.include?(nil)
+      #
+      #   # good
+      #   { a: 1, b: 2 }.value?(2)
+      #   { a: 1, b: 2 }.has_value?('garbage')
+      #   h = { a: 1, b: 2 }; h.value?(nil)
+      #
+      class InefficientHashSearch < Cop
+        def_node_matcher :inefficient_include?, <<-PATTERN
+          (send $(send _ ${:keys :values}) :include? $_)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node, message: msg(node)) if inefficient_include?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            # Replace `keys.include?` or `values.include?` with the appropriate
+            # `key?`/`value?` method.
+            corrector.replace(
+              node.loc.expression,
+              "#{autocorrect_hash_expression(node)}."\
+              "#{autocorrect_method(node)}(#{autocorrect_argument(node)})"
+            )
+          end
+        end
+
+        private
+
+        def msg(node)
+          "Use `##{autocorrect_method(node)}` instead of "\
+            "`##{current_method(node)}.include?`."
+        end
+
+        def autocorrect_method(node)
+          case current_method(node)
+          when :keys then use_long_method ? 'has_key?' : 'key?'
+          when :values then use_long_method ? 'has_value?' : 'value?'
+          end
+        end
+
+        def current_method(node)
+          node.children[0].method_name
+        end
+
+        def use_long_method
+          preferred_config = config.for_all_cops['Style/PreferredHashMethods']
+          preferred_config &&
+            preferred_config['EnforcedStyle'] == 'long' &&
+            preferred_config['Enabled']
+        end
+
+        def autocorrect_argument(node)
+          node.arguments.first.source
+        end
+
+        def autocorrect_hash_expression(node)
+          node.children[0].children[0].loc.expression.source
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/unneeded_sort.rb

@@ -3,17 +3,52 @@
 module RuboCop
   module Cop
     module Performance
-      # This cop is used to identify instances of sorting and then taking
-      # only the first or last element.
+      # This cop is used to identify instances of sorting and then
+      # taking only the first or last element. The same behavior can
+      # be accomplished without a relatively expensive sort by using
+      # `Enumerable#min` instead of sorting and taking the first
+      # element and `Enumerable#max` instead of sorting and taking the
+      # last element. Similarly, `Enumerable#min_by` and
+      # `Enumerable#max_by` can replace `Enumerable#sort_by` calls
+      # after which only the first or last element is used.
       #
       # @example
       #   # bad
-      #   [].sort.first
-      #   [].sort_by(&:length).last
+      #   [2, 1, 3].sort.first
+      #   [2, 1, 3].sort[0]
+      #   [2, 1, 3].sort.at(0)
+      #   [2, 1, 3].sort.slice(0)
       #
       #   # good
-      #   [].min
-      #   [].max_by(&:length)
+      #   [2, 1, 3].min
+      #
+      #   # bad
+      #   [2, 1, 3].sort.last
+      #   [2, 1, 3].sort[-1]
+      #   [2, 1, 3].sort.at(-1)
+      #   [2, 1, 3].sort.slice(-1)
+      #
+      #   # good
+      #   [2, 1, 3].max
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).first
+      #   arr.sort_by(&:foo)[0]
+      #   arr.sort_by(&:foo).at(0)
+      #   arr.sort_by(&:foo).slice(0)
+      #
+      #   # good
+      #   arr.min_by(&:foo)
+      #
+      #   # bad
+      #   arr.sort_by(&:foo).last
+      #   arr.sort_by(&:foo)[-1]
+      #   arr.sort_by(&:foo).at(-1)
+      #   arr.sort_by(&:foo).slice(-1)
+      #
+      #   # good
+      #   arr.max_by(&:foo)
+      #
       class UnneededSort < Cop
         include RangeHelp
 

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Use `assert_not` instead of `assert !`.
+      #
+      # @example
+      #   # bad
+      #   assert !x
+      #
+      #   # good
+      #   assert_not x
+      #
+      class AssertNot < RuboCop::Cop::Cop
+        MSG = 'Prefer `assert_not` over `assert !`.'.freeze
+
+        def_node_matcher :offensive?, '(send nil? :assert (send ... :!))'
+
+        def on_send(node)
+          add_offense(node) if offensive?(node)
+        end
+
+        def autocorrect(node)
+          expression = node.loc.expression
+
+          lambda do |corrector|
+            corrector.replace(
+              expression,
+              corrected_source(expression.source)
+            )
+          end
+        end
+
+        private
+
+        def corrected_source(source)
+          source.gsub(/^assert(\(| ) *! */, 'assert_not\\1')
+        end
+      end
+    end
+  end
+end

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

@@ -3,40 +3,46 @@
 module RuboCop
   module Cop
     module Rails
-      # This cops checks for code that can be changed to `blank?`.
-      # Settings:
-      #   NilOrEmpty: Convert checks for `nil` or `empty?` to `blank?`
-      #   NotPresent: Convert usages of not `present?` to `blank?`
-      #   UnlessPresent: Convert usages of `unless` `present?` to `blank?`
+      # This cop checks for code that can be written with simpler conditionals
+      # using `Object#blank?` defined by Active Support.
       #
-      # @example
-      #   # NilOrEmpty: true
-      #     # bad
-      #     foo.nil? || foo.empty?
-      #     foo == nil || foo.empty?
+      # @example NilOrEmpty: true (default)
+      #   # Converts usages of `nil? || empty?` to `blank?`
       #
-      #     # good
-      #     foo.blank?
+      #   # bad
+      #   foo.nil? || foo.empty?
+      #   foo == nil || foo.empty?
       #
-      #   # NotPresent: true
-      #     # bad
-      #     !foo.present?
+      #   # good
+      #   foo.blank?
       #
-      #     # good
-      #     foo.blank?
+      # @example NotPresent: true (default)
+      #   # Converts usages of `!present?` to `blank?`
       #
-      #   # UnlessPresent: true
-      #     # bad
-      #     something unless foo.present?
-      #     unless foo.present?
-      #       something
-      #     end
+      #   # bad
+      #   !foo.present?
       #
-      #     # good
-      #     something if foo.blank?
-      #     if foo.blank?
-      #       something
-      #     end
+      #   # good
+      #   foo.blank?
+      #
+      # @example UnlessPresent: true (default)
+      #   # Converts usages of `unless present?` to `if blank?`
+      #
+      #   # bad
+      #   something unless foo.present?
+      #
+      #   # good
+      #   something if foo.blank?
+      #
+      #   # bad
+      #   unless foo.present?
+      #     something
+      #   end
+      #
+      #   # good
+      #   if foo.blank?
+      #     something
+      #   end
       class Blank < Cop
         MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
         MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze

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

@@ -51,7 +51,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :create_table_with_timestamps_proc?, <<-PATTERN
-          (send nil? :create_table (sym _) (block-pass (sym :timestamps)))
+          (send nil? :create_table (sym _) ... (block-pass (sym :timestamps)))
         PATTERN
 
         def_node_search :timestamps_included?, <<-PATTERN

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

@@ -63,8 +63,18 @@ module RuboCop
 
           n = node.parent.begin_type? ? node.parent.parent : node.parent
 
-          if with_options_block(n)
-            return true if valid_options?(with_options_block(n))
+          contain_valid_options_in_with_options_block?(n)
+        end
+
+        def contain_valid_options_in_with_options_block?(node)
+          if with_options_block(node)
+            return true if valid_options?(with_options_block(node))
+
+            return false unless node.parent
+
+            return true if contain_valid_options_in_with_options_block?(
+              node.parent.parent
+            )
           end
 
           false

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

@@ -22,7 +22,7 @@ module RuboCop
         MSG = 'Use keyword arguments instead of ' \
               'positional arguments for http call: `%<verb>s`.'.freeze
         KEYWORD_ARGS = %i[
-          headers env params body flash as xhr session method
+          method params session body flash xhr as
         ].freeze
         HTTP_METHODS = %i[get post put patch delete head].freeze
 
@@ -41,11 +41,11 @@ module RuboCop
           end
         end
 
-        # given a pre Rails 5 method: get :new, user_id: @user.id, {}
+        # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
         #
         # @return lambda of auto correct procedure
         # the result should look like:
-        #     get :new, params: { user_id: @user.id }, headers: {}
+        #     get :new, params: { user_id: @user.id }, session: {}
         # the http_method is the method used to call the controller
         # the controller node can be a symbol, method, object or string
         # that represents the path/action on the Rails controller
@@ -56,14 +56,14 @@ module RuboCop
 
           controller_action = http_path.source
           params = convert_hash_data(data.first, 'params')
-          headers = convert_hash_data(data.last, 'headers') if data.size > 1
+          session = convert_hash_data(data.last, 'session') if data.size > 1
           # the range of the text to replace, which is the whole line
           code_to_replace = node.loc.expression
           # what to replace with
           format = parentheses_format(node)
           new_code = format(format, name: node.method_name,
                                     action: controller_action,
-                                    params: params, headers: headers)
+                                    params: params, session: session)
           ->(corrector) { corrector.replace(code_to_replace, new_code) }
         end
 
@@ -103,9 +103,9 @@ module RuboCop
 
         def parentheses_format(node)
           if parentheses?(node)
-            '%<name>s(%<action>s%<params>s%<headers>s)'
+            '%<name>s(%<action>s%<params>s%<session>s)'
           else
-            '%<name>s %<action>s%<params>s%<headers>s'
+            '%<name>s %<action>s%<params>s%<session>s'
           end
         end
       end

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

@@ -3,37 +3,43 @@
 module RuboCop
   module Cop
     module Rails
-      # This cops checks for code that can be changed to `blank?`.
-      # Settings:
-      #   NotNilAndNotEmpty: Convert checks for not `nil` and `not empty?`
-      #                      to `present?`
-      #   NotBlank: Convert usages of not `blank?` to `present?`
-      #   UnlessBlank: Convert usages of `unless` `blank?` to `if` `present?`
+      # This cop checks for code that can be written with simpler conditionals
+      # using `Object#present?` defined by Active Support.
       #
-      # @example
-      #   # NotNilAndNotEmpty: true
-      #     # bad
-      #     !foo.nil? && !foo.empty?
-      #     foo != nil && !foo.empty?
-      #     !foo.blank?
+      # simpler conditionals.
       #
-      #     # good
-      #     foo.present?
+      # @example NotNilAndNotEmpty: true (default)
+      #   # Converts usages of `!nil? && !empty?` to `present?`
       #
-      #   # NotBlank: true
-      #     # bad
-      #     !foo.blank?
-      #     not foo.blank?
+      #   # bad
+      #   !foo.nil? && !foo.empty?
       #
-      #     # good
-      #     foo.present?
+      #   # bad
+      #   foo != nil && !foo.empty?
       #
-      #   # UnlessBlank: true
-      #     # bad
-      #     something unless foo.blank?
+      #   # good
+      #   foo.present?
       #
-      #     # good
-      #     something if  foo.present?
+      # @example NotBlank: true (default)
+      #   # Converts usages of `!blank?` to `present?`
+      #
+      #   # bad
+      #   !foo.blank?
+      #
+      #   # bad
+      #   not foo.blank?
+      #
+      #   # good
+      #   foo.present?
+      #
+      # @example UnlessBlank: true (default)
+      #   # Converts usages of `unless blank?` to `if present?`
+      #
+      #   # bad
+      #   something unless foo.blank?
+      #
+      #   # good
+      #   something if foo.present?
       class Present < Cop
         MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
         MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \