rubocop 1.7.0 → 1.10.0

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

@@ -6,6 +6,9 @@ module RuboCop
       # This cop enforces the use of explicit block argument to avoid writing
       # block literal that just passes its arguments to another block.
       #
+      # NOTE: This cop only registers an offense if the block args match the
+      # yield args exactly.
+      #
       # @example
       #   # bad
       #   def with_tmp_dir
@@ -75,7 +78,14 @@ module RuboCop
         private
 
         def yielding_arguments?(block_args, yield_args)
+          yield_args = yield_args.dup.fill(
+            nil,
+            yield_args.length, block_args.length - yield_args.length
+          )
+
           yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            next false unless yield_arg && block_arg
+
             block_arg && yield_arg.children.first == block_arg.children.first
           end
         end
@@ -87,7 +97,7 @@ module RuboCop
             replacement = ' &block'
             replacement = ",#{replacement}" unless arg_range.source.end_with?(',')
             corrector.insert_after(arg_range, replacement) unless last_arg.blockarg_type?
-          elsif node.call_type?
+          elsif node.call_type? || node.zsuper_type?
             corrector.insert_after(node, '(&block)')
           else
             corrector.insert_after(node.loc.name, '(&block)')

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

@@ -5,13 +5,12 @@ module RuboCop
     module Style
       # This cop enforces consistency when using exponential notation
       # for numbers in the code (eg 1.2e4). Different styles are supported:
-      # * `scientific` which enforces a mantissa between 1 (inclusive)
-      #                and 10 (exclusive).
-      # * `engineering` which enforces the exponent to be a multiple of 3
-      #                 and the mantissa to be between 0.1 (inclusive)
-      #                 and 10 (exclusive).
-      # * `integral` which enforces the mantissa to always be a whole number
-      #              without trailing zeroes.
+      #
+      # * `scientific` which enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      # * `engineering` which enforces the exponent to be a multiple of 3 and the mantissa
+      #   to be between 0.1 (inclusive) and 10 (exclusive).
+      # * `integral` which enforces the mantissa to always be a whole number without
+      #   trailing zeroes.
       #
       # @example EnforcedStyle: scientific (default)
       #   # Enforces a mantissa between 1 (inclusive) and 10 (exclusive).

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

@@ -7,6 +7,9 @@ module RuboCop
       # It is recommended to either always use `fdiv` or coerce one side only.
       # This cop also provides other options for code consistency.
       #
+      # This cop is marked as unsafe, because if operand variable is a string object
+      # then `.to_f` will be removed and an error will occur.
+      #
       # @example EnforcedStyle: single_coerce (default)
       #   # bad
       #   a.to_f / b.to_f

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

@@ -11,6 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
+      # This cop can be customized ignored methods with `IgnoredMethods`.
+      #
       # @example EnforcedStyle: annotated (default)
       #
       #   # bad
@@ -58,12 +60,18 @@ module RuboCop
       #
       #   # good
       #   format('%06d', 10)
+      #
+      # @example IgnoredMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
+        include IgnoredMethods
 
         def on_str(node)
-          return unless node.value.include?('%')
-          return if node.each_ancestor(:xstr, :regexp).any?
+          return if format_string_token?(node) || use_ignored_method?(node)
 
           detections = collect_detections(node)
           return if detections.empty?
@@ -88,6 +96,14 @@ module RuboCop
           }
         PATTERN
 
+        def format_string_token?(node)
+          !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
+        end
+
+        def use_ignored_method?(node)
+          (parent = node.parent) && parent.send_type? && ignored_method?(parent.method_name)
+        end
+
         def unannotated_format?(node, detected_style)
           detected_style == :unannotated && !format_string_in_typical_context?(node)
         end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks the usage of pre-2.1 `Hash[args]` method of converting enumerables and
+      # sequences of values to hashes.
+      #
+      # @example
+      #   # bad
+      #   Hash[ary]
+      #
+      #   # good
+      #   ary.to_h
+      #
+      #   # bad
+      #   Hash[key1, value1, key2, value2]
+      #
+      #   # good
+      #   {key1 => value1, key2 => value2}
+      class HashConversion < Base
+        extend AutoCorrector
+
+        MSG_TO_H = 'Prefer ary.to_h to Hash[ary].'
+        MSG_LITERAL_MULTI_ARG = 'Prefer literal hash to Hash[arg1, arg2, ...].'
+        MSG_LITERAL_HASH_ARG = 'Prefer literal hash to Hash[key: value, ...].'
+        MSG_SPLAT = 'Prefer array_of_pairs.to_h to Hash[*array].'
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        def_node_matcher :hash_from_array?, '(send (const {nil? cbase} :Hash) :[] ...)'
+
+        def on_send(node)
+          return unless hash_from_array?(node)
+
+          # There are several cases:
+          # If there is one argument:
+          #   Hash[ary] => ary.to_h
+          #   Hash[*ary] => don't suggest corrections
+          # If there is 0 or 2+ arguments:
+          #   Hash[a1, a2, a3, a4] => {a1 => a2, a3 => a4}
+          #   ...but don't suggest correction if there is odd number of them (it is a bug)
+          node.arguments.count == 1 ? single_argument(node) : multi_argument(node)
+        end
+
+        private
+
+        def single_argument(node)
+          first_argument = node.first_argument
+          if first_argument.hash_type?
+            add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
+              corrector.replace(node, "{#{first_argument.source}}")
+            end
+          elsif first_argument.splat_type?
+            add_offense(node, message: MSG_SPLAT)
+          else
+            add_offense(node, message: MSG_TO_H) do |corrector|
+              corrector.replace(node, "#{first_argument.source}.to_h")
+            end
+          end
+        end
+
+        def multi_argument(node)
+          if node.arguments.count.odd?
+            add_offense(node, message: MSG_LITERAL_MULTI_ARG)
+          else
+            add_offense(node, message: MSG_LITERAL_MULTI_ARG) do |corrector|
+              corrector.replace(node, args_to_hash(node.arguments))
+            end
+          end
+        end
+
+        def args_to_hash(args)
+          content = args.each_slice(2)
+                        .map { |arg1, arg2| "#{arg1.source} => #{arg2.source}" }
+                        .join(', ')
+          "{#{content}}"
+        end
+      end
+    end
+  end
+end

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

@@ -68,7 +68,8 @@ module RuboCop
           length = cop_config['MinBranchesCount'] || 3
           return length if length.is_a?(Integer) && length.positive?
 
-          raise 'MinBranchesCount needs to be a positive integer!'
+          warn Rainbow('`MinBranchesCount` needs to be a positive integer!').red
+          exit!
         end
       end
     end

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

@@ -82,15 +82,14 @@ module RuboCop
         def autocorrect(corrector, node)
           if node.modifier_form?
             correct_to_elsif_from_modifier_form(corrector, node)
-            end_range = node.parent.loc.end
           else
             correct_to_elsif_from_if_inside_else_form(corrector, node, node.condition)
-            end_range = node.loc.end
           end
-          corrector.remove(range_by_whole_lines(end_range, include_final_newline: true))
-          corrector.remove(
-            range_by_whole_lines(node.if_branch.source_range, include_final_newline: true)
-          )
+          corrector.remove(range_by_whole_lines(find_end_range(node), include_final_newline: true))
+          return unless (if_branch = node.if_branch)
+
+          range = range_by_whole_lines(if_branch.source_range, include_final_newline: true)
+          corrector.remove(range)
         end
 
         def correct_to_elsif_from_modifier_form(corrector, node)
@@ -103,13 +102,26 @@ module RuboCop
 
         def correct_to_elsif_from_if_inside_else_form(corrector, node, condition)
           corrector.replace(node.parent.loc.else, "elsif #{condition.source}")
-          if_condition_range = range_between(
-            node.loc.keyword.begin_pos, condition.source_range.end_pos
-          )
-          corrector.replace(if_condition_range, node.if_branch.source)
+          if_condition_range = if_condition_range(node, condition)
+          if (if_branch = node.if_branch)
+            corrector.replace(if_condition_range, if_branch.source)
+          else
+            corrector.remove(range_by_whole_lines(if_condition_range, include_final_newline: true))
+          end
           corrector.remove(condition)
         end
 
+        def find_end_range(node)
+          end_range = node.loc.end
+          return end_range if end_range
+
+          find_end_range(node.parent)
+        end
+
+        def if_condition_range(node, condition)
+          range_between(node.loc.keyword.begin_pos, condition.source_range.end_pos)
+        end
+
         def allow_if_modifier_in_else_branch?(else_branch)
           allow_if_modifier? && else_branch&.modifier_form?
         end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant `if` with boolean literal branches.
+      # It checks only conditions to return boolean value (`true` or `false`) for safe detection.
+      # The conditions to be checked are comparison methods, predicate methods, and double negative.
+      # However, auto-correction is unsafe because there is no guarantee that all predicate methods
+      # will return boolean value. Those methods can be allowed with `AllowedMethods` config.
+      #
+      # @example
+      #   # bad
+      #   if foo == bar
+      #     true
+      #   else
+      #     false
+      #   end
+      #
+      #   # bad
+      #   foo == bar ? true : false
+      #
+      #   # good
+      #   foo == bar
+      #
+      # @example AllowedMethods: ['nonzero?']
+      #   # good
+      #   num.nonzero? ? true : false
+      #
+      class IfWithBooleanLiteralBranches < Base
+        include AllowedMethods
+        extend AutoCorrector
+
+        MSG = 'Remove redundant %<keyword>s with boolean literal branches.'
+        MSG_FOR_ELSIF = 'Use `else` instead of redundant `elsif` with boolean literal branches.'
+
+        def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
+          (if #return_boolean_value? {(true) (false) | (false) (true)})
+        PATTERN
+        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
+
+        def on_if(node)
+          return unless if_with_boolean_literal_branches?(node)
+
+          condition = node.condition
+          range, keyword = offense_range_with_keyword(node, condition)
+
+          add_offense(range, message: message(node, keyword)) do |corrector|
+            replacement = replacement_condition(node, condition)
+
+            if node.elsif?
+              corrector.insert_before(node, "else\n")
+              corrector.replace(node, "#{indent(node.if_branch)}#{replacement}")
+            else
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def offense_range_with_keyword(node, condition)
+          if node.ternary?
+            range = condition.source_range.end.join(node.source_range.end)
+
+            [range, 'ternary operator']
+          else
+            keyword = node.loc.keyword
+
+            [keyword, "`#{keyword.source}`"]
+          end
+        end
+
+        def message(node, keyword)
+          message_template = node.elsif? ? MSG_FOR_ELSIF : MSG
+
+          format(message_template, keyword: keyword)
+        end
+
+        def return_boolean_value?(condition)
+          if condition.begin_type?
+            return_boolean_value?(condition.children.first)
+          elsif condition.or_type?
+            return_boolean_value?(condition.lhs) && return_boolean_value?(condition.rhs)
+          elsif condition.and_type?
+            return_boolean_value?(condition.rhs)
+          else
+            assume_boolean_value?(condition)
+          end
+        end
+
+        def assume_boolean_value?(condition)
+          return false unless condition.send_type?
+          return false if allowed_method?(condition.method_name)
+
+          condition.comparison_method? || condition.predicate_method? || double_negative?(condition)
+        end
+
+        def replacement_condition(node, condition)
+          bang = '!' if opposite_condition?(node)
+
+          if bang && require_parentheses?(condition)
+            "#{bang}(#{condition.source})"
+          else
+            "#{bang}#{condition.source}"
+          end
+        end
+
+        def opposite_condition?(node)
+          !node.unless? && node.if_branch.false_type? || node.unless? && node.if_branch.true_type?
+        end
+
+        def require_parentheses?(condition)
+          condition.and_type? || condition.or_type? ||
+            condition.send_type? && condition.comparison_method?
+        end
+      end
+    end
+  end
+end

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

@@ -157,6 +157,10 @@ module RuboCop
         include OmitParentheses
         extend AutoCorrector
 
+        def self.autocorrect_incompatible_with
+          [Style::NestedParenthesizedCalls]
+        end
+
         def on_send(node)
           send(style, node) # call require_parentheses or omit_parentheses
         end

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

@@ -19,6 +19,10 @@ module RuboCop
 
         MSG = 'Add parentheses to nested method call `%<source>s`.'
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return unless node.parenthesized?
 

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

@@ -50,6 +50,9 @@ module RuboCop
                          end
 
               corrector.replace(node, new_code)
+
+              parent = node.parent
+              corrector.wrap(node, '(', ')') if parent.respond_to?(:method?) && parent.method?(:!)
             end
           end
         end

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

@@ -8,6 +8,9 @@ module RuboCop
       # With `IncludeSemanticChanges` set to `false` by default, this cop
       # does not report offenses for `!x.nil?` and does no changes that might
       # change behavior.
+      # Also `IncludeSemanticChanges` set to `false` with `EnforcedStyle: comparison` of
+      # `Style/NilComparison` cop, this cop does not report offenses for `x != nil` and
+      # does no changes to `!x.nil?` style.
       #
       # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
       # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
@@ -41,6 +44,9 @@ module RuboCop
       class NonNilCheck < Base
         extend AutoCorrector
 
+        MSG_FOR_REPLACEMENT = 'Prefer `%<prefer>s` over `%<current>s`.'
+        MSG_FOR_REDUNDANCY = 'Explicit non-nil checks are usually redundant.'
+
         RESTRICT_ON_SEND = %i[!= nil? !].freeze
 
         def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
@@ -49,11 +55,12 @@ module RuboCop
         def_node_matcher :not_and_nil_check?, '(send (send _ :nil?) :!)'
 
         def on_send(node)
-          return if ignored_node?(node)
-          return unless (offense_node = find_offense_node(node))
+          return if ignored_node?(node) ||
+                    !include_semantic_changes? && nil_comparison_style == 'comparison'
+          return unless register_offense?(node)
 
           message = message(node)
-          add_offense(offense_node, message: message) do |corrector|
+          add_offense(node, message: message) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -73,13 +80,9 @@ module RuboCop
 
         private
 
-        def find_offense_node(node)
-          if not_equal_to_nil?(node)
-            node.loc.selector
-          elsif include_semantic_changes? &&
-                (not_and_nil_check?(node) || unless_and_nil_check?(node))
-            node
-          end
+        def register_offense?(node)
+          not_equal_to_nil?(node) ||
+            include_semantic_changes? && (not_and_nil_check?(node) || unless_and_nil_check?(node))
         end
 
         def autocorrect(corrector, node)
@@ -101,10 +104,11 @@ module RuboCop
         end
 
         def message(node)
-          if node.method?(:!=)
-            'Prefer `!expression.nil?` over `expression != nil`.'
+          if node.method?(:!=) && !include_semantic_changes?
+            prefer = "!#{node.receiver.source}.nil?"
+            format(MSG_FOR_REPLACEMENT, prefer: prefer, current: node.source)
           else
-            'Explicit non-nil checks are usually redundant.'
+            MSG_FOR_REDUNDANCY
           end
         end
 
@@ -138,6 +142,12 @@ module RuboCop
           corrector.replace(node.parent.loc.keyword, 'if')
           corrector.replace(node, receiver.source)
         end
+
+        def nil_comparison_style
+          nil_comparison_conf = config.for_cop('Style/NilComparison')
+
+          nil_comparison_conf['Enabled'] && nil_comparison_conf['EnforcedStyle']
+        end
       end
     end
   end