rubocop 1.9.0 → 1.12.1

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

@@ -21,6 +21,7 @@ module RuboCop
         MSG = 'Replace with `Integer#%<method>s?`.'
         RESTRICT_ON_SEND = %i[== !=].freeze
 
+        # @!method even_odd_candidate?(node)
         def_node_matcher :even_odd_candidate?, <<~PATTERN
           (send
             {(send $_ :% (int 2))

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

@@ -54,6 +54,7 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[expand_path].freeze
 
+        # @!method file_expand_path(node)
         def_node_matcher :file_expand_path, <<~PATTERN
           (send
             (const {nil? cbase} :File) :expand_path
@@ -61,6 +62,7 @@ module RuboCop
             $_)
         PATTERN
 
+        # @!method pathname_parent_expand_path(node)
         def_node_matcher :pathname_parent_expand_path, <<~PATTERN
           (send
             (send
@@ -68,6 +70,7 @@ module RuboCop
                 $_) :parent) :expand_path)
         PATTERN
 
+        # @!method pathname_new_parent_expand_path(node)
         def_node_matcher :pathname_new_parent_expand_path, <<~PATTERN
           (send
             (send

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

@@ -45,6 +45,7 @@ module RuboCop
         MSG = 'Consider using explicit block argument in the '\
               "surrounding method's signature over `yield`."
 
+        # @!method yielding_block?(node)
         def_node_matcher :yielding_block?, <<~PATTERN
           (block $_ (args $...) (yield $...))
         PATTERN
@@ -97,7 +98,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

@@ -55,15 +55,19 @@ module RuboCop
 
         RESTRICT_ON_SEND = %i[/].freeze
 
+        # @!method right_coerce?(node)
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
         PATTERN
+        # @!method left_coerce?(node)
         def_node_matcher :left_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ _)
         PATTERN
+        # @!method both_coerce?(node)
         def_node_matcher :both_coerce?, <<~PATTERN
           (send (send _ :to_f) :/ (send _ :to_f))
         PATTERN
+        # @!method any_coerce?(node)
         def_node_matcher :any_coerce?, <<~PATTERN
           {(send _ :/ (send _ :to_f)) (send (send _ :to_f) :/ _)}
         PATTERN

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

@@ -42,6 +42,7 @@ module RuboCop
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
+        # @!method formatter(node)
         def_node_matcher :formatter, <<~PATTERN
           {
             (send nil? ${:sprintf :format} _ _ ...)
@@ -50,6 +51,7 @@ module RuboCop
           }
         PATTERN
 
+        # @!method variable_argument?(node)
         def_node_matcher :variable_argument?, <<~PATTERN
           (send {str dstr} :% {send_type? lvar_type?})
         PATTERN

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

@@ -89,6 +89,7 @@ module RuboCop
 
         private
 
+        # @!method format_string_in_typical_context?(node)
         def_node_matcher :format_string_in_typical_context?, <<~PATTERN
           {
             ^(send _ {:format :sprintf :printf} %0 ...)

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

@@ -10,9 +10,6 @@ module RuboCop
       # default in future Ruby. The comment will be added below a shebang and
       # encoding comment.
       #
-      # Note that the cop will ignore files where the comment exists but is set
-      # to `false` instead of `true`.
-      #
       # @example EnforcedStyle: always (default)
       #   # The `always` style will always add the frozen string literal comment
       #   # to a file, regardless of the Ruby version or if `freeze` or `<<` are

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

@@ -34,6 +34,7 @@ module RuboCop
 
         STD_STREAMS = %i[STDIN STDOUT STDERR].to_set.freeze
 
+        # @!method const_to_gvar_assignment?(node, name)
         def_node_matcher :const_to_gvar_assignment?, <<~PATTERN
           (gvasgn %1 (const nil? _))
         PATTERN

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

@@ -0,0 +1,108 @@
+# 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.
+      #
+      # Correction code from splat argument (`Hash[*ary]`) is not simply determined. For example,
+      # `Hash[*ary]` can be replaced with `ary.each_slice(2).to_h` but it will be complicated.
+      # So, `AllowSplatArgument` option is true by default to allow splat argument for simple code.
+      #
+      # @example
+      #   # bad
+      #   Hash[ary]
+      #
+      #   # good
+      #   ary.to_h
+      #
+      #   # bad
+      #   Hash[key1, value1, key2, value2]
+      #
+      #   # good
+      #   {key1 => value1, key2 => value2}
+      #
+      # @example AllowSplatArgument: true (default)
+      #   # good
+      #   Hash[*ary]
+      #
+      # @example AllowSplatArgument: false
+      #   # bad
+      #   Hash[*ary]
+      #
+      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
+
+        # @!method hash_from_array?(node)
+        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) unless allowed_splat_argument?
+          else
+            add_offense(node, message: MSG_TO_H) do |corrector|
+              replacement = first_argument.source
+              replacement = "(#{replacement})" if requires_parens?(first_argument)
+              corrector.replace(node, "#{replacement}.to_h")
+            end
+          end
+        end
+
+        def requires_parens?(node)
+          node.call_type? && node.arguments.any? && !node.parenthesized?
+        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))
+
+              parent = node.parent
+              add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+            end
+          end
+        end
+
+        def args_to_hash(args)
+          content = args.each_slice(2)
+                        .map { |arg1, arg2| "#{arg1.source} => #{arg2.source}" }
+                        .join(', ')
+          "{#{content}}"
+        end
+
+        def allowed_splat_argument?
+          cop_config.fetch('AllowSplatArgument', true)
+        end
+      end
+    end
+  end
+end

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

@@ -23,6 +23,7 @@ module RuboCop
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
+        # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
           (block $(send (send _ ${:keys :values}) :each) ...)
         PATTERN

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

@@ -33,6 +33,7 @@ module RuboCop
         MSG = 'Use `%<prefer>s` instead.'
         RESTRICT_ON_SEND = %i[reject select filter].freeze
 
+        # @!method bad_method?(node)
         def_node_matcher :bad_method?, <<~PATTERN
           (block
             (send _ _)

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

@@ -39,6 +39,7 @@ module RuboCop
       class HashLikeCase < Base
         MSG = 'Consider replacing `case-when` with a hash lookup.'
 
+        # @!method hash_like_case?(node)
         def_node_matcher :hash_like_case?, <<~PATTERN
           (case
             _

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

@@ -54,9 +54,10 @@ module RuboCop
       #   # good
       #   {a: 1, b: 2}
       #   {:c => 3, 'd' => 4}
-      class HashSyntax < Cop
+      class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG_19 = 'Use the new Ruby 1.9 hash syntax.'
         MSG_NO_MIXED_KEYS = "Don't mix styles in the same hash."
@@ -104,18 +105,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
-              autocorrect_hash_rockets(corrector, node)
-            elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
-              autocorrect_no_mixed_keys(corrector, node)
-            else
-              autocorrect_ruby19(corrector, node)
-            end
-          end
-        end
-
         def alternative_style
           case style
           when :hash_rockets
@@ -127,6 +116,16 @@ module RuboCop
 
         private
 
+        def autocorrect(corrector, node)
+          if style == :hash_rockets || force_hash_rockets?(node.parent.pairs)
+            autocorrect_hash_rockets(corrector, node)
+          elsif style == :ruby19_no_mixed_keys || style == :no_mixed_keys
+            autocorrect_no_mixed_keys(corrector, node)
+          else
+            autocorrect_ruby19(corrector, node)
+          end
+        end
+
         def sym_indices?(pairs)
           pairs.all? { |p| word_symbol_pair?(p) }
         end
@@ -152,14 +151,16 @@ module RuboCop
           return true if /\A[_a-z]\w*[?!]?\z/i.match?(sym_name)
 
           # For more complicated hash keys, let the parser validate the syntax.
-          parse("{ #{sym_name}: :foo }").valid_syntax?
+          ProcessedSource.new("{ #{sym_name}: :foo }", target_ruby_version).valid_syntax?
         end
 
         def check(pairs, delim, msg)
           pairs.each do |pair|
             if pair.delimiter == delim
               location = pair.source_range.begin.join(pair.loc.operator)
-              add_offense(pair, location: location, message: msg) do
+              add_offense(location, message: msg) do |corrector|
+                autocorrect(corrector, pair)
+
                 opposite_style_detected
               end
             else

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

@@ -32,6 +32,7 @@ module RuboCop
 
         minimum_target_ruby_version 2.5
 
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :each_with_object (hash))
@@ -43,6 +44,7 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= $!`_memo $(lvar _val)))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
@@ -55,6 +57,7 @@ module RuboCop
               (array $_ $(lvar _val))))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
@@ -66,6 +69,7 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :to_h)

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

@@ -29,6 +29,7 @@ module RuboCop
         include HashTransformMethod
         extend AutoCorrector
 
+        # @!method on_bad_each_with_object(node)
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :each_with_object (hash))
@@ -40,6 +41,7 @@ module RuboCop
             ({send csend} (lvar _memo) :[]= $(lvar _key) $!`_memo))
         PATTERN
 
+        # @!method on_bad_hash_brackets_map(node)
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
             (const _ :Hash)
@@ -52,6 +54,7 @@ module RuboCop
               (array $(lvar _key) $_)))
         PATTERN
 
+        # @!method on_bad_map_to_h(node)
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
           ({send csend}
             (block
@@ -63,6 +66,7 @@ module RuboCop
             :to_h)
         PATTERN
 
+        # @!method on_bad_to_h(node)
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
             ({send csend} !#array_receiver? :to_h)

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

@@ -6,6 +6,8 @@ module RuboCop
       # 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
@@ -21,39 +23,62 @@ module RuboCop
       #   # 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.'
 
+        # @!method if_with_boolean_literal_branches?(node)
         def_node_matcher :if_with_boolean_literal_branches?, <<~PATTERN
           (if #return_boolean_value? {(true) (false) | (false) (true)})
         PATTERN
+        # @!method double_negative?(node)
         def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
         def on_if(node)
           return unless if_with_boolean_literal_branches?(node)
 
           condition = node.condition
-          range, keyword = 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
+          range, keyword = offense_range_with_keyword(node, condition)
 
-          add_offense(range, message: format(MSG, keyword: keyword)) do |corrector|
+          add_offense(range, message: message(node, keyword)) do |corrector|
             replacement = replacement_condition(node, condition)
 
-            corrector.replace(node, replacement)
+            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)
@@ -68,6 +93,7 @@ module RuboCop
 
         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