rubocop 0.92.0 → 1.2.0

data/lib/rubocop/cop/style/class_equality_comparison.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of `Object#instance_of?` instead of class comparison
+      # for equality.
+      #
+      # @example
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      class ClassEqualityComparison < Base
+        include RangeHelp
+        include IgnoredMethods
+        extend AutoCorrector
+
+        MSG = 'Use `instance_of?(%<class_name>s)` instead of comparing classes.'
+
+        RESTRICT_ON_SEND = %i[== equal? eql?].freeze
+
+        def_node_matcher :class_comparison_candidate?, <<~PATTERN
+          (send
+            {$(send _ :class) (send $(send _ :class) :name)}
+            {:== :equal? :eql?} $_)
+        PATTERN
+
+        def on_send(node)
+          def_node = node.each_ancestor(:def, :defs).first
+          return if def_node && ignored_method?(def_node.method_name)
+
+          class_comparison_candidate?(node) do |receiver_node, class_node|
+            range = offense_range(receiver_node, node)
+            class_name = class_name(class_node, node)
+
+            add_offense(range, message: format(MSG, class_name: class_name)) do |corrector|
+              corrector.replace(range, "instance_of?(#{class_name})")
+            end
+          end
+        end
+
+        private
+
+        def class_name(class_node, node)
+          if node.children.first.method?(:name)
+            class_node.source.delete('"').delete("'")
+          else
+            class_node.source
+          end
+        end
+
+        def offense_range(receiver_node, node)
+          range_between(receiver_node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/collection_compact.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where custom logic on rejection nils from arrays
+      # and hashes can be replaced with `{Array,Hash}#{compact,compact!}`.
+      #
+      # @example
+      #   # bad
+      #   array.reject { |e| e.nil? }
+      #   array.select { |e| !e.nil? }
+      #
+      #   # good
+      #   array.compact
+      #
+      #   # bad
+      #   hash.reject! { |k, v| v.nil? }
+      #   hash.select! { |k, v| !v.nil? }
+      #
+      #   # good
+      #   hash.compact!
+      #
+      class CollectionCompact < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+
+        RESTRICT_ON_SEND = %i[reject reject! select select!].freeze
+
+        def_node_matcher :reject_method?, <<~PATTERN
+          (block
+            (send
+              _ ${:reject :reject!})
+            $(args ...)
+            (send
+              $(lvar _) :nil?))
+        PATTERN
+
+        def_node_matcher :select_method?, <<~PATTERN
+          (block
+            (send
+              _ ${:select :select!})
+            $(args ...)
+            (send
+              (send
+                $(lvar _) :nil?) :!))
+        PATTERN
+
+        def on_send(node)
+          block_node = node.parent
+          return unless block_node&.block_type?
+
+          return unless (method_name, args, receiver =
+                           reject_method?(block_node) || select_method?(block_node))
+
+          return unless args.last.source == receiver.source
+
+          range = offense_range(node, block_node)
+          good = good_method_name(method_name)
+          message = format(MSG, good: good, bad: range.source)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, good)
+          end
+        end
+
+        private
+
+        def good_method_name(method_name)
+          if method_name.to_s.end_with?('!')
+            'compact!'
+          else
+            'compact'
+          end
+        end
+
+        def offense_range(send_node, block_node)
+          range_between(send_node.loc.selector.begin_pos, block_node.loc.end.end_pos)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/combinable_loops.rb

@@ -49,6 +49,12 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   def method
+      #     each_slice(2) { |slice| do_something(slice) }
+      #     each_slice(3) { |slice| do_something(slice) }
+      #   end
+      #
       class CombinableLoops < Base
         MSG = 'Combine this loop with the previous loop.'
 
@@ -76,7 +82,8 @@ module RuboCop
         def same_collection_looping?(node, sibling)
           sibling&.block_type? &&
             sibling.send_node.method?(node.method_name) &&
-            sibling.send_node.receiver == node.send_node.receiver
+            sibling.send_node.receiver == node.send_node.receiver &&
+            sibling.send_node.arguments == node.send_node.arguments
         end
       end
     end

data/lib/rubocop/cop/style/comment_annotation.rb

@@ -6,6 +6,12 @@ module RuboCop
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
       #
+      # NOTE: With a multiline comment block (where each line is only a
+      # comment), only the first line will be able to register an offense, even
+      # if an annotation keyword starts another line. This is done to prevent
+      # incorrect registering of keywords (eg. `review`) inside a paragraph as an
+      # annotation.
+      #
       # @example
       #   # bad
       #   # TODO make better

data/lib/rubocop/cop/style/document_dynamic_eval_definition.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # When using `class_eval` (or other `eval`) with string interpolation,
+      # add a comment block showing its appearance if interpolated (a practice used in Rails code).
+      #
+      # @example
+      #   # from activesupport/lib/active_support/core_ext/string/output_safety.rb
+      #
+      #   # bad
+      #   UNSAFE_STRING_METHODS.each do |unsafe_method|
+      #     if 'String'.respond_to?(unsafe_method)
+      #       class_eval <<-EOT, __FILE__, __LINE__ + 1
+      #         def #{unsafe_method}(*params, &block)
+      #           to_str.#{unsafe_method}(*params, &block)
+      #         end
+      #
+      #         def #{unsafe_method}!(*params)
+      #           @dirty = true
+      #           super
+      #         end
+      #       EOT
+      #     end
+      #   end
+      #
+      #   # good
+      #   UNSAFE_STRING_METHODS.each do |unsafe_method|
+      #     if 'String'.respond_to?(unsafe_method)
+      #       class_eval <<-EOT, __FILE__, __LINE__ + 1
+      #         def #{unsafe_method}(*params, &block)       # def capitalize(*params, &block)
+      #           to_str.#{unsafe_method}(*params, &block)  #   to_str.capitalize(*params, &block)
+      #         end                                         # end
+      #
+      #         def #{unsafe_method}!(*params)              # def capitalize!(*params)
+      #           @dirty = true                             #   @dirty = true
+      #           super                                     #   super
+      #         end                                         # end
+      #       EOT
+      #     end
+      #   end
+      #
+      class DocumentDynamicEvalDefinition < Base
+        MSG = 'Add a comment block showing its appearance if interpolated.'
+
+        RESTRICT_ON_SEND = %i[eval class_eval module_eval instance_eval].freeze
+
+        def on_send(node)
+          arg_node = node.first_argument
+          return unless arg_node&.dstr_type?
+
+          add_offense(node.loc.selector) unless comment_docs?(arg_node)
+        end
+
+        private
+
+        def comment_docs?(node)
+          node.each_child_node(:begin).all? do |begin_node|
+            source_line = processed_source.lines[begin_node.first_line - 1]
+            source_line.match?(/\s*#[^{]+/)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/double_negation.rb

@@ -34,6 +34,7 @@ module RuboCop
       # this is rarely a problem in practice.
       class DoubleNegation < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Avoid the use of double negation (`!!`).'
         RESTRICT_ON_SEND = %i[!].freeze
@@ -44,7 +45,11 @@ module RuboCop
           return unless double_negative?(node) && node.prefix_bang?
           return if style == :allowed_in_returns && allowed_in_returns?(node)
 
-          add_offense(node.loc.selector)
+          location = node.loc.selector
+          add_offense(location) do |corrector|
+            corrector.remove(location)
+            corrector.insert_after(node, '.nil?')
+          end
         end
 
         private

data/lib/rubocop/cop/style/explicit_block_argument.rb

@@ -57,12 +57,16 @@ module RuboCop
           yielding_block?(block_node) do |send_node, block_args, yield_args|
             return unless yielding_arguments?(block_args, yield_args)
 
+            def_node = block_node.each_ancestor(:def, :defs).first
+            # if `yield` is being called outside of a method context, ignore
+            # this is not a valid ruby pattern, but can happen in haml or erb,
+            # so this can cause crashes in haml_lint
+            return unless def_node
+
             add_offense(block_node) do |corrector|
               corrector.remove(block_body_range(block_node, send_node))
 
               add_block_argument(send_node, corrector)
-
-              def_node = block_node.each_ancestor(:def, :defs).first
               add_block_argument(def_node, corrector) if @def_nodes.add?(def_node)
             end
           end

data/lib/rubocop/cop/style/for.rb

@@ -49,8 +49,6 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            return unless opposite_style_detected
-
             add_offense(node, message: PREFER_EACH) do |corrector|
               ForToEachCorrector.new(node).call(corrector)
             end
@@ -63,8 +61,6 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
-            return unless opposite_style_detected
-
             add_offense(node, message: PREFER_FOR) do |corrector|
               EachToForCorrector.new(node).call(corrector)
             end

data/lib/rubocop/cop/style/format_string_token.rb

@@ -33,10 +33,31 @@ module RuboCop
       #
       #   # bad
       #   format('%<greeting>s', greeting: 'Hello')
-      #   format('%{greeting}', 'Hello')
+      #   format('%{greeting}', greeting: 'Hello')
       #
       #   # good
       #   format('%s', 'Hello')
+      #
+      # It is allowed to contain unannotated token
+      # if the number of them is less than or equals to
+      # `MaxUnannotatedPlaceholdersAllowed`.
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 0
+      #
+      #   # bad
+      #   format('%06d', 10)
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%<number>06d', number: 10)
+      #
+      # @example MaxUnannotatedPlaceholdersAllowed: 1 (default)
+      #
+      #   # bad
+      #   format('%s %s.', 'Hello', 'world')
+      #
+      #   # good
+      #   format('%06d', 10)
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
 
@@ -44,8 +65,12 @@ module RuboCop
           return unless node.value.include?('%')
           return if node.each_ancestor(:xstr, :regexp).any?
 
-          tokens(node) do |detected_style, token_range|
-            if detected_style == style || unannotated_format?(node, detected_style)
+          detections = collect_detections(node)
+          return if detections.empty?
+          return if allowed_unannotated?(detections)
+
+          detections.each do |detected_style, token_range|
+            if detected_style == style
               correct_style_detected
             else
               style_detected(detected_style)
@@ -112,6 +137,26 @@ module RuboCop
             yield(detected_style, token)
           end
         end
+
+        def collect_detections(node)
+          detections = []
+          tokens(node) do |detected_style, token_range|
+            unless unannotated_format?(node, detected_style)
+              detections << [detected_style, token_range]
+            end
+          end
+          detections
+        end
+
+        def allowed_unannotated?(detections)
+          return false if detections.size > max_unannotated_placeholders_allowed
+
+          detections.all? { |detected_style,| detected_style == :unannotated }
+        end
+
+        def max_unannotated_placeholders_allowed
+          cop_config['MaxUnannotatedPlaceholdersAllowed']
+        end
       end
     end
   end

data/lib/rubocop/cop/style/hash_syntax.rb

@@ -97,10 +97,10 @@ module RuboCop
         end
 
         def no_mixed_keys_check(pairs)
-          if !sym_indices?(pairs)
-            check(pairs, ':', MSG_NO_MIXED_KEYS)
-          else
+          if sym_indices?(pairs)
             check(pairs, pairs.first.inverse_delimiter, MSG_NO_MIXED_KEYS)
+          else
+            check(pairs, ':', MSG_NO_MIXED_KEYS)
           end
         end
 

data/lib/rubocop/cop/style/keyword_parameters_order.rb

@@ -34,6 +34,10 @@ module RuboCop
           add_offense(node) do |corrector|
             if node.parent.find(&:kwoptarg_type?) == node
               corrector.insert_before(node, "#{kwarg_nodes.map(&:source).join(', ')}, ")
+
+              arguments = node.each_ancestor(:def, :defs).first.arguments
+              append_newline_to_last_kwoptarg(arguments, corrector) unless parentheses?(arguments)
+
               remove_kwargs(kwarg_nodes, corrector)
             end
           end
@@ -41,6 +45,14 @@ module RuboCop
 
         private
 
+        def append_newline_to_last_kwoptarg(arguments, corrector)
+          last_argument = arguments.last
+          return if last_argument.kwrestarg_type? || last_argument.blockarg_type?
+
+          last_kwoptarg = arguments.reverse.find(&:kwoptarg_type?)
+          corrector.insert_after(last_kwoptarg, "\n")
+        end
+
         def remove_kwargs(kwarg_nodes, corrector)
           kwarg_nodes.each do |kwarg|
             with_space = range_with_surrounding_space(range: kwarg.source_range)

data/lib/rubocop/cop/style/method_call_with_args_parentheses.rb

@@ -144,25 +144,22 @@ module RuboCop
       #   # good
       #   Array 1
       class MethodCallWithArgsParentheses < Base
+        require_relative 'method_call_with_args_parentheses/omit_parentheses'
+        require_relative 'method_call_with_args_parentheses/require_parentheses'
+
         include ConfigurableEnforcedStyle
         include IgnoredMethods
         include IgnoredPattern
+        include RequireParentheses
+        include OmitParentheses
         extend AutoCorrector
 
-        def initialize(*)
-          super
-          return unless style_configured?
-
-          case style
-          when :require_parentheses
-            extend RequireParentheses
-          when :omit_parentheses
-            extend OmitParentheses
-          end
+        def on_send(node)
+          send(style, node) # call require_parentheses or omit_parentheses
         end
-
-        # @abstract Overridden in style modules
-        def autocorrect(_node); end
+        alias on_csend on_send
+        alias on_super on_send
+        alias on_yield on_send
 
         private