rubocop 0.87.1 → 0.91.0

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of explicit block argument to avoid writing
+      # block literal that just passes its arguments to another block.
+      #
+      # @example
+      #   # bad
+      #   def with_tmp_dir
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir) { |dir| yield dir } # block just passes arguments
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def nine_times
+      #     9.times { yield }
+      #   end
+      #
+      #   # good
+      #   def with_tmp_dir(&block)
+      #     Dir.mktmpdir do |tmp_dir|
+      #       Dir.chdir(tmp_dir, &block)
+      #     end
+      #   end
+      #
+      #   with_tmp_dir do |dir|
+      #     puts "dir is accessible as a parameter and pwd is set: #{dir}"
+      #   end
+      #
+      #   # good
+      #   def nine_times(&block)
+      #     9.times(&block)
+      #   end
+      #
+      class ExplicitBlockArgument < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Consider using explicit block argument in the '\
+              "surrounding method's signature over `yield`."
+
+        def_node_matcher :yielding_block?, <<~PATTERN
+          (block $_ (args $...) (yield $...))
+        PATTERN
+
+        def initialize(config = nil, options = nil)
+          super
+          @def_nodes = Set.new
+        end
+
+        def on_yield(node)
+          block_node = node.parent
+
+          yielding_block?(block_node) do |send_node, block_args, yield_args|
+            return unless yielding_arguments?(block_args, yield_args)
+
+            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
+        end
+
+        private
+
+        def yielding_arguments?(block_args, yield_args)
+          yield_args.zip(block_args).all? do |yield_arg, block_arg|
+            block_arg && yield_arg.children.first == block_arg.children.first
+          end
+        end
+
+        def add_block_argument(node, corrector)
+          if node.arguments?
+            last_arg = node.arguments.last
+            arg_range = range_with_surrounding_comma(last_arg.source_range, :right)
+            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?
+            corrector.insert_after(node, '(&block)')
+          else
+            corrector.insert_after(node.loc.name, '(&block)')
+          end
+        end
+
+        def block_body_range(block_node, send_node)
+          range_between(
+            send_node.loc.expression.end_pos,
+            block_node.loc.end.end_pos
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -58,8 +58,13 @@ module RuboCop
       #   1e4
       #   12e5
       #
-      class ExponentialNotation < Cop
+      class ExponentialNotation < Base
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          scientific: 'Use a mantissa in [1, 10[.',
+          engineering: 'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.',
+          integral: 'Use an integer as mantissa, without trailing zero.'
+        }.freeze
 
         def on_float(node)
           add_offense(node) if offense?(node)
@@ -104,14 +109,7 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :scientific
-            'Use a mantissa in [1, 10[.'
-          when :engineering
-            'Use an exponent divisible by 3 and a mantissa in [0.1, 1000[.'
-          when :integral
-            'Use an integer as mantissa, without trailing zero.'
-          end
+          MESSAGES[style]
         end
       end
     end

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

@@ -39,8 +39,16 @@ module RuboCop
       #
       #   # good
       #   a.fdiv(b)
-      class FloatDivision < Cop
+      class FloatDivision < Base
         include ConfigurableEnforcedStyle
+        MESSAGES = {
+          left_coerce: 'Prefer using `.to_f` on the left side.',
+          right_coerce: 'Prefer using `.to_f` on the right side.',
+          single_coerce: 'Prefer using `.to_f` on one side only.',
+          fdiv: 'Prefer using `fdiv` for float divisions.'
+        }.freeze
+
+        RESTRICT_ON_SEND = %i[/].freeze
 
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
@@ -77,16 +85,7 @@ module RuboCop
         end
 
         def message(_node)
-          case style
-          when :left_coerce
-            'Prefer using `.to_f` on the left side.'
-          when :right_coerce
-            'Prefer using `.to_f` on the right side.'
-          when :single_coerce
-            'Prefer using `.to_f` on one side only.'
-          when :fdiv
-            'Prefer using `fdiv` for float divisions.'
-          end
+          MESSAGES[style]
         end
       end
     end

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

@@ -38,9 +38,10 @@ module RuboCop
       #     end
       #   end
       #
-      class For < Cop
+      class For < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         EACH_LENGTH = 'each'.length
         PREFER_EACH = 'Prefer `each` over `for`.'
@@ -48,8 +49,10 @@ module RuboCop
 
         def on_for(node)
           if style == :each
-            add_offense(node, message: PREFER_EACH) do
-              opposite_style_detected
+            return unless opposite_style_detected
+
+            add_offense(node, message: PREFER_EACH) do |corrector|
+              ForToEachCorrector.new(node).call(corrector)
             end
           else
             correct_style_detected
@@ -60,27 +63,20 @@ module RuboCop
           return unless suspect_enumerable?(node)
 
           if style == :for
-            add_offense(node, message: PREFER_FOR) do
-              opposite_style_detected
+            return unless opposite_style_detected
+
+            add_offense(node, message: PREFER_FOR) do |corrector|
+              EachToForCorrector.new(node).call(corrector)
             end
           else
             correct_style_detected
           end
         end
 
-        def autocorrect(node)
-          if style == :each
-            ForToEachCorrector.new(node)
-          else
-            EachToForCorrector.new(node)
-          end
-        end
-
         private
 
         def suspect_enumerable?(node)
-          node.multiline? &&
-            node.send_node.method?(:each) && !node.send_node.arguments?
+          node.multiline? && node.send_node.method?(:each) && !node.send_node.arguments?
         end
       end
     end

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

@@ -35,10 +35,12 @@ module RuboCop
       #   # good
       #   puts '%10s' % 'hoge'
       #
-      class FormatString < Cop
+      class FormatString < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Favor `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
         def_node_matcher :formatter, <<~PATTERN
           {
@@ -58,41 +60,38 @@ module RuboCop
 
             return if detected_style == style
 
-            add_offense(node, location: :selector,
-                              message: message(detected_style))
+            add_offense(node.loc.selector, message: message(detected_style)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
+        private
+
         def message(detected_style)
-          format(MSG,
-                 prefer: method_name(style),
-                 current: method_name(detected_style))
+          format(MSG, prefer: method_name(style), current: method_name(detected_style))
         end
 
         def method_name(style_name)
           style_name == :percent ? 'String#%' : style_name
         end
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           return if variable_argument?(node)
 
-          lambda do |corrector|
-            case node.method_name
-            when :%
-              autocorrect_from_percent(corrector, node)
+          case node.method_name
+          when :%
+            autocorrect_from_percent(corrector, node)
+          when :format, :sprintf
+            case style
+            when :percent
+              autocorrect_to_percent(corrector, node)
             when :format, :sprintf
-              case style
-              when :percent
-                autocorrect_to_percent(corrector, node)
-              when :format, :sprintf
-                corrector.replace(node.loc.selector, style.to_s)
-              end
+              corrector.replace(node.loc.selector, style.to_s)
             end
           end
         end
 
-        private
-
         def autocorrect_from_percent(corrector, node)
           percent_rhs = node.first_argument
           args = case percent_rhs.type

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

@@ -37,20 +37,19 @@ module RuboCop
       #
       #   # good
       #   format('%s', 'Hello')
-      class FormatStringToken < Cop
+      class FormatStringToken < Base
         include ConfigurableEnforcedStyle
 
         def on_str(node)
+          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)
+            if detected_style == style || unannotated_format?(node, detected_style)
               correct_style_detected
             else
               style_detected(detected_style)
-              add_offense(node, location: token_range,
-                                message: message(detected_style))
+              add_offense(token_range, message: message(detected_style))
             end
           end
         end
@@ -65,8 +64,7 @@ module RuboCop
         PATTERN
 
         def unannotated_format?(node, detected_style)
-          detected_style == :unannotated &&
-            !format_string_in_typical_context?(node)
+          detected_style == :unannotated && !format_string_in_typical_context?(node)
         end
 
         def message(detected_style)
@@ -75,11 +73,11 @@ module RuboCop
 
         # rubocop:disable Style/FormatStringToken
         def message_text(style)
-          case style
-          when :annotated then 'annotated tokens (like `%<foo>s`)'
-          when :template then 'template tokens (like `%{foo}`)'
-          when :unannotated then 'unannotated tokens (like `%s`)'
-          end
+          {
+            annotated: 'annotated tokens (like `%<foo>s`)',
+            template: 'template tokens (like `%{foo}`)',
+            unannotated: 'unannotated tokens (like `%s`)'
+          }[style]
         end
         # rubocop:enable Style/FormatStringToken
 

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

@@ -73,10 +73,11 @@ module RuboCop
       #   module Bar
       #     # ...
       #   end
-      class FrozenStringLiteralComment < Cop
+      class FrozenStringLiteralComment < Base
         include ConfigurableEnforcedStyle
         include FrozenStringLiteral
         include RangeHelp
+        extend AutoCorrector
 
         MSG_MISSING_TRUE = 'Missing magic comment `# frozen_string_literal: '\
                            'true`.'
@@ -85,7 +86,7 @@ module RuboCop
         MSG_DISABLED = 'Frozen string literal comment must be set to `true`.'
         SHEBANG = '#!'
 
-        def investigate(processed_source)
+        def on_new_investigation
           return if processed_source.tokens.empty?
 
           case style
@@ -98,23 +99,6 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            case style
-            when :never
-              remove_comment(corrector, node)
-            when :always_true
-              if frozen_string_literal_specified?
-                enable_comment(corrector)
-              else
-                insert_comment(corrector)
-              end
-            else
-              insert_comment(corrector)
-            end
-          end
-        end
-
         private
 
         def ensure_no_comment(processed_source)
@@ -160,51 +144,45 @@ module RuboCop
         end
 
         def missing_offense(processed_source)
-          last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment,
-                      location: range,
-                      message: MSG_MISSING)
+          add_offense(range, message: MSG_MISSING) do |corrector|
+            insert_comment(corrector)
+          end
         end
 
         def missing_true_offense(processed_source)
-          last_special_comment = last_special_comment(processed_source)
           range = source_range(processed_source.buffer, 0, 0)
 
-          add_offense(last_special_comment,
-                      location: range,
-                      message: MSG_MISSING_TRUE)
+          add_offense(range, message: MSG_MISSING_TRUE) do |corrector|
+            insert_comment(corrector)
+          end
         end
 
         def unnecessary_comment_offense(processed_source)
-          frozen_string_literal_comment =
-            frozen_string_literal_comment(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
 
-          add_offense(frozen_string_literal_comment,
-                      location: frozen_string_literal_comment.pos,
-                      message: MSG_UNNECESSARY)
+          add_offense(frozen_string_literal_comment.pos, message: MSG_UNNECESSARY) do |corrector|
+            remove_comment(corrector, frozen_string_literal_comment)
+          end
         end
 
         def disabled_offense(processed_source)
-          frozen_string_literal_comment =
-            frozen_string_literal_comment(processed_source)
+          frozen_string_literal_comment = frozen_string_literal_comment(processed_source)
 
-          add_offense(frozen_string_literal_comment,
-                      location: frozen_string_literal_comment.pos,
-                      message: MSG_DISABLED)
+          add_offense(frozen_string_literal_comment.pos, message: MSG_DISABLED) do |corrector|
+            enable_comment(corrector)
+          end
         end
 
         def remove_comment(corrector, node)
-          corrector.remove(range_with_surrounding_space(range: node.pos,
-                                                        side: :right))
+          corrector.remove(range_with_surrounding_space(range: node.pos, side: :right))
         end
 
         def enable_comment(corrector)
           comment = frozen_string_literal_comment(processed_source)
 
-          corrector.replace(line_range(comment.line),
-                            FROZEN_STRING_LITERAL_ENABLED)
+          corrector.replace(line_range(comment.line), FROZEN_STRING_LITERAL_ENABLED)
         end
 
         def insert_comment(corrector)