rubocop 0.89.0 → 0.92.0

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

@@ -58,7 +58,7 @@ module RuboCop
       #   1e4
       #   12e5
       #
-      class ExponentialNotation < Cop
+      class ExponentialNotation < Base
         include ConfigurableEnforcedStyle
         MESSAGES = {
           scientific: 'Use a mantissa in [1, 10[.',

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

@@ -39,7 +39,7 @@ 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.',
@@ -48,6 +48,8 @@ module RuboCop
           fdiv: 'Prefer using `fdiv` for float divisions.'
         }.freeze
 
+        RESTRICT_ON_SEND = %i[/].freeze
+
         def_node_matcher :right_coerce?, <<~PATTERN
           (send _ :/ (send _ :to_f))
         PATTERN

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,12 +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`.'
-
-        FORMAT_METHODS = %i[format sprintf %].freeze
+        RESTRICT_ON_SEND = %i[format sprintf %].freeze
 
         def_node_matcher :formatter, <<~PATTERN
           {
@@ -55,48 +55,43 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless FORMAT_METHODS.include?(node.method_name)
-
           formatter(node) do |selector|
             detected_style = selector == :% ? :percent : selector
 
             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,7 +37,7 @@ module RuboCop
       #
       #   # good
       #   format('%s', 'Hello')
-      class FormatStringToken < Cop
+      class FormatStringToken < Base
         include ConfigurableEnforcedStyle
 
         def on_str(node)
@@ -45,13 +45,11 @@ module RuboCop
           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
@@ -66,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)

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)

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

@@ -19,7 +19,7 @@ module RuboCop
       #   FOO = 2
       #   foo = 2
       #   $stdin.read
-      class GlobalVars < Cop
+      class GlobalVars < Base
         MSG = 'Do not introduce global variables.'
 
         # built-in global variables and their English aliases
@@ -72,7 +72,7 @@ module RuboCop
         def check(node)
           global_var, = *node
 
-          add_offense(node, location: :name) unless allowed_var?(global_var)
+          add_offense(node.loc.name) unless allowed_var?(global_var)
         end
       end
     end

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

@@ -17,6 +17,7 @@ module RuboCop
       #   # good
       #   def test
       #     return unless something
+      #
       #     work
       #   end
       #
@@ -46,7 +47,7 @@ module RuboCop
       #   # good
       #   foo || raise('exception') if something
       #   ok
-      class GuardClause < Cop
+      class GuardClause < Base
         include MinBodyLength
         include StatementModifier
 
@@ -105,9 +106,8 @@ module RuboCop
             example = "#{conditional_keyword} #{condition.source}; " \
                       "#{scope_exiting_keyword}; end"
           end
-          add_offense(node,
-                      location: :keyword,
-                      message: format(MSG, example: example))
+
+          add_offense(node.loc.keyword, message: format(MSG, example: example))
         end
 
         def guard_clause_source(guard_clause)

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

@@ -6,6 +6,9 @@ module RuboCop
       # Checks for presence or absence of braces around hash literal as a last
       # array item depending on configuration.
       #
+      # NOTE: This cop will ignore arrays where all items are hashes, regardless of
+      # EnforcedStyle.
+      #
       # @example EnforcedStyle: braces (default)
       #   # bad
       #   [1, 2, one: 1, two: 2]
@@ -13,6 +16,9 @@ module RuboCop
       #   # good
       #   [1, 2, { one: 1, two: 2 }]
       #
+      #   # good
+      #   [{ one: 1 }, { two: 2 }]
+      #
       # @example EnforcedStyle: no_braces
       #   # bad
       #   [1, 2, { one: 1, two: 2 }]
@@ -20,12 +26,15 @@ module RuboCop
       #   # good
       #   [1, 2, one: 1, two: 2]
       #
+      #   # good
+      #   [{ one: 1 }, { two: 2 }]
       class HashAsLastArrayItem < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
         def on_hash(node)
-          return unless last_array_item?(node)
+          return unless (array = containing_array(node))
+          return unless last_array_item?(array, node) && explicit_array?(array)
 
           if braces_style?
             check_braces(node)
@@ -36,11 +45,20 @@ module RuboCop
 
         private
 
-        def last_array_item?(node)
-          parent = node.parent
-          return false unless parent
+        def containing_array(hash_node)
+          parent = hash_node.parent
+          parent if parent&.array_type?
+        end
+
+        def last_array_item?(array, node)
+          return false if array.child_nodes.all?(&:hash_type?)
+
+          array.children.last.equal?(node)
+        end
 
-          parent.array_type? && parent.values.last == node
+        def explicit_array?(array)
+          # an implicit array cannot have an "unbraced" hash
+          array.square_brackets?
         end
 
         def check_braces(node)
@@ -53,6 +71,7 @@ module RuboCop
 
         def check_no_braces(node)
           return unless node.braces?
+          return if node.children.empty? # Empty hash cannot be "unbraced"
 
           add_offense(node, message: 'Omit the braces around the hash.') do |corrector|
             corrector.remove(node.loc.begin)

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

@@ -17,8 +17,9 @@ module RuboCop
       #   # good
       #   hash.each_key { |k| p k }
       #   hash.each_value { |v| p v }
-      class HashEachMethods < Cop
+      class HashEachMethods < Base
         include Lint::UnusedArgument
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
@@ -30,12 +31,6 @@ module RuboCop
           register_kv_offense(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            correct_key_value_each(node, corrector)
-          end
-        end
-
         private
 
         def register_kv_offense(node)
@@ -45,7 +40,9 @@ module RuboCop
             msg = format(message, prefer: "each_#{method[0..-2]}",
                                   current: "#{method}.each")
 
-            add_offense(target, location: kv_range(target), message: msg)
+            add_offense(kv_range(target), message: msg) do |corrector|
+              correct_key_value_each(target, corrector)
+            end
           end
         end