rubocop 1.9.1 → 1.13.0

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
@@ -82,9 +85,7 @@ module RuboCop
           elsif (default_dir = pathname_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 
-            add_offense(node, message: PATHNAME_MSG) do |corrector|
-              autocorrect(corrector, node)
-            end
+            add_offense(node, message: PATHNAME_MSG) { |corrector| autocorrect(corrector, node) }
           elsif (default_dir = pathname_new_parent_expand_path(node))
             return unless unrecommended_argument?(default_dir)
 

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)')
@@ -105,10 +106,7 @@ module RuboCop
         end
 
         def block_body_range(block_node, send_node)
-          range_between(
-            send_node.loc.expression.end_pos,
-            block_node.loc.end.end_pos
-          )
+          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
         end
       end
     end

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 ...)
@@ -145,10 +146,7 @@ module RuboCop
             next if seq.percent?
 
             detected_style = seq.style
-            token = contents.begin.adjust(
-              begin_pos: seq.begin_pos,
-              end_pos:   seq.end_pos
-            )
+            token = contents.begin.adjust(begin_pos: seq.begin_pos, end_pos: seq.end_pos)
 
             yield(detected_style, token)
           end

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
@@ -79,8 +76,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
-                           'true`.'
+        MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: true`.'
         MSG_MISSING = 'Missing frozen string literal comment.'
         MSG_UNNECESSARY = 'Unnecessary frozen string literal comment.'
         MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
@@ -146,17 +142,13 @@ module RuboCop
         def missing_offense(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(range, message: MSG_MISSING) do |corrector|
-            insert_comment(corrector)
-          end
+          add_offense(range, message: MSG_MISSING) { |corrector| insert_comment(corrector) }
         end
 
         def missing_true_offense(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(range, message: MSG_MISSING_TRUE) do |corrector|
-            insert_comment(corrector)
-          end
+          add_offense(range, message: MSG_MISSING_TRUE) { |corrector| insert_comment(corrector) }
         end
 
         def unnecessary_comment_offense(processed_source)

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/guard_clause.rb

@@ -99,12 +99,9 @@ module RuboCop
 
         def register_offense(node, scope_exiting_keyword, conditional_keyword)
           condition, = node.node_parts
-          example = [scope_exiting_keyword,
-                     conditional_keyword,
-                     condition.source].join(' ')
+          example = [scope_exiting_keyword, conditional_keyword, condition.source].join(' ')
           if too_long_for_single_line?(node, example)
-            example = "#{conditional_keyword} #{condition.source}; " \
-                      "#{scope_exiting_keyword}; end"
+            example = "#{conditional_keyword} #{condition.source}; #{scope_exiting_keyword}; end"
           end
 
           add_offense(node.loc.keyword, message: format(MSG, example: example))
@@ -126,8 +123,7 @@ module RuboCop
         end
 
         def accepted_form?(node, ending: false)
-          accepted_if?(node, ending) || node.condition.multiline? ||
-            node.parent&.assignment?
+          accepted_if?(node, ending) || node.condition.multiline? || node.parent&.assignment?
         end
 
         def accepted_if?(node, ending)

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

@@ -0,0 +1,133 @@
+# 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?
+            register_offense_for_hash(node, first_argument)
+          elsif first_argument.splat_type?
+            add_offense(node, message: MSG_SPLAT) unless allowed_splat_argument?
+          elsif use_zip_method_without_argument?(first_argument)
+            register_offense_for_zip_method(node, first_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 use_zip_method_without_argument?(first_argument)
+          return false unless first_argument&.send_type?
+
+          first_argument.method?(:zip) && first_argument.arguments.empty?
+        end
+
+        def register_offense_for_hash(node, hash_argument)
+          add_offense(node, message: MSG_LITERAL_HASH_ARG) do |corrector|
+            corrector.replace(node, "{#{hash_argument.source}}")
+
+            parent = node.parent
+            add_parentheses(parent, corrector) if parent&.send_type? && !parent.parenthesized?
+          end
+        end
+
+        def register_offense_for_zip_method(node, zip_method)
+          add_offense(node, message: MSG_TO_H) do |corrector|
+            if zip_method.parenthesized?
+              corrector.insert_before(zip_method.loc.end, '[]')
+            else
+              corrector.insert_after(zip_method, '([])')
+            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
@@ -37,8 +38,7 @@ module RuboCop
           kv_each(node) do |target, method|
             return unless target.receiver.receiver
 
-            msg = format(message, prefer: "each_#{method[0..-2]}",
-                                  current: "#{method}.each")
+            msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
 
             add_offense(kv_range(target), message: msg) do |corrector|
               correct_key_value_each(target, corrector)

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
             _
@@ -51,8 +52,7 @@ module RuboCop
           return if node.when_branches.size < min_branches_count
 
           hash_like_case?(node) do |condition_nodes, body_nodes|
-            if nodes_of_same_type?(condition_nodes) &&
-               nodes_of_same_type?(body_nodes)
+            if nodes_of_same_type?(condition_nodes) && nodes_of_same_type?(body_nodes)
               add_offense(node)
             end
           end

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
@@ -138,7 +137,7 @@ module RuboCop
         end
 
         def acceptable_19_syntax_symbol?(sym_name)
-          sym_name.sub!(/\A:/, '')
+          sym_name.delete_prefix!(':')
 
           if cop_config['PreferHashRocketsForNonAlnumEndingSymbols'] &&
              # Prefer { :production? => false } over { production?: false } and
@@ -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
@@ -173,10 +174,7 @@ module RuboCop
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
-          corrector.replace(
-            range,
-            range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: ")
-          )
+          corrector.replace(range, range.source.sub(/^:(.*\S)\s*=>\s*$/, "#{space}\\1: "))
 
           hash_node = pair_node.parent
           return unless hash_node.parent&.return_type? && !hash_node.braces?
@@ -193,8 +191,7 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? &&
-            node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
@@ -214,8 +211,7 @@ module RuboCop
         end
 
         def force_hash_rockets?(pairs)
-          cop_config['UseHashRocketsWithSymbolValues'] &&
-            pairs.map(&:value).any?(&:sym_type?)
+          cop_config['UseHashRocketsWithSymbolValues'] && pairs.map(&:value).any?(&:sym_type?)
         end
       end
     end