rubocop 0.81.0 → 0.85.1

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

@@ -42,7 +42,7 @@ module RuboCop
 
             max += 1 if range_type == :irange
 
-            corrector.replace(node.send_node.source_range,
+            corrector.replace(node.send_node,
                               "#{max - min}.times")
           end
         end

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

@@ -48,15 +48,15 @@ module RuboCop
 
             first_arg, second_arg = *node.arguments
 
-            corrector.replace(first_arg.loc.expression, second_arg.source)
-            corrector.replace(second_arg.loc.expression, first_arg.source)
+            corrector.replace(first_arg, second_arg.source)
+            corrector.replace(second_arg, first_arg.source)
 
             return_value = return_value(node.body)
 
             if return_value_occupies_whole_line?(return_value)
               corrector.remove(whole_line_expression(return_value))
             else
-              corrector.remove(return_value.loc.expression)
+              corrector.remove(return_value)
             end
           end
         end

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

@@ -68,9 +68,7 @@ module RuboCop
 
         def first_argument_unparenthesized?(node)
           parent = node.parent
-          unless parent && %i[send super zsuper].include?(parent.type)
-            return false
-          end
+          return false unless parent && %i[send super zsuper].include?(parent.type)
 
           node.object_id == parent.arguments.first.object_id &&
             !parentheses?(node.parent)

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

@@ -8,7 +8,7 @@ module RuboCop
       # line (compact style), but it can be configured to enforce the `end`
       # to go on its own line (expanded style).
       #
-      # Note: A method definition is not considered empty if it contains
+      # NOTE: A method definition is not considered empty if it contains
       #       comments.
       #
       # @example EnforcedStyle: compact (default)
@@ -57,7 +57,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, corrected(node))
+            corrector.replace(node, corrected(node))
           end
         end
 
@@ -90,10 +90,6 @@ module RuboCop
           compact_style? ? '; ' : "\n#{indent}"
         end
 
-        def comment_lines?(node)
-          processed_source[line_range(node)].any? { |line| comment_line?(line) }
-        end
-
         def compact?(node)
           node.single_line?
         end

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

@@ -38,7 +38,7 @@ module RuboCop
             replacement_method = replacement_method(arg, method)
 
             correction = "#{base_number.source}.#{replacement_method}?"
-            ->(corrector) { corrector.replace(node.source_range, correction) }
+            ->(corrector) { corrector.replace(node, correction) }
           end
         end
 

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

@@ -97,7 +97,7 @@ module RuboCop
               autocorrect_expand_path(corrector, current_path, default_dir)
             elsif (default_dir = pathname_parent_expand_path(node)) ||
                   (default_dir = pathname_new_parent_expand_path(node))
-              corrector.replace(default_dir.loc.expression, '__dir__')
+              corrector.replace(default_dir, '__dir__')
               remove_parent_method(corrector, default_dir)
             end
           end
@@ -145,8 +145,8 @@ module RuboCop
           else
             new_path = "'#{parent_path(stripped_current_path)}'"
 
-            corrector.replace(current_path.loc.expression, new_path)
-            corrector.replace(default_dir.loc.expression, '__dir__')
+            corrector.replace(current_path, new_path)
+            corrector.replace(default_dir, '__dir__')
           end
         end
 

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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.
+      #
+      # @example EnforcedStyle: scientific (default)
+      #   # Enforces a mantissa between 1 (inclusive) and 10 (exclusive).
+      #
+      #   # bad
+      #   10e6
+      #   0.3e4
+      #   11.7e5
+      #   3.14e0
+      #
+      #   # good
+      #   1e7
+      #   3e3
+      #   1.17e6
+      #   3.14
+      #
+      # @example EnforcedStyle: engineering
+      #   # Enforces using multiple of 3 exponents,
+      #   # mantissa should be between 0.1 (inclusive) and 1000 (exclusive)
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   12e5
+      #   1232e6
+      #
+      #   # good
+      #   32e6
+      #   10e3
+      #   1.2e6
+      #   1.232e9
+      #
+      # @example EnforcedStyle: integral
+      #   # Enforces the mantissa to have no decimal part and no
+      #   # trailing zeroes.
+      #
+      #   # bad
+      #   3.2e7
+      #   0.1e5
+      #   120e4
+      #
+      #   # good
+      #   32e6
+      #   1e4
+      #   12e5
+      #
+      class ExponentialNotation < Cop
+        include ConfigurableEnforcedStyle
+
+        def on_float(node)
+          add_offense(node) if offense?(node)
+        end
+
+        private
+
+        def scientific?(node)
+          mantissa, = node.source.split('e')
+          mantissa =~ /^-?[1-9](\.\d*[0-9])?$/
+        end
+
+        def engineering?(node)
+          mantissa, exponent = node.source.split('e')
+          return false unless /^-?\d+$/.match?(exponent)
+          return false unless (exponent.to_i % 3).zero?
+          return false if /^-?\d{4}/.match?(mantissa)
+          return false if /^-?0\d/.match?(mantissa)
+          return false if /^-?0.0/.match?(mantissa)
+
+          true
+        end
+
+        def integral(node)
+          mantissa, = node.source.split('e')
+          mantissa =~ /^-?[1-9](\d*[1-9])?$/
+        end
+
+        def offense?(node)
+          return false unless node.source['e']
+
+          case style
+          when :scientific
+            !scientific?(node)
+          when :engineering
+            !engineering?(node)
+          when :integral
+            !integral(node)
+          else
+            false
+          end
+        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
+        end
+      end
+    end
+  end
+end

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

@@ -104,7 +104,7 @@ module RuboCop
 
           corrected = "#{style}(#{node.receiver.source}, #{args})"
 
-          corrector.replace(node.loc.expression, corrected)
+          corrector.replace(node, corrected)
         end
 
         def autocorrect_to_percent(corrector, node)
@@ -119,7 +119,7 @@ module RuboCop
                    "[#{param_args.map(&:source).join(', ')}]"
                  end
 
-          corrector.replace(node.loc.expression, "#{format} % #{args}")
+          corrector.replace(node, "#{format} % #{args}")
         end
       end
     end

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

@@ -5,11 +5,10 @@ module RuboCop
     module Style
       # Use a consistent style for named format string tokens.
       #
-      # **Note:**
-      # `unannotated` style cop only works for strings
+      # NOTE: `unannotated` style cop only works for strings
       # which are passed as arguments to those methods:
       # `printf`, `sprintf`, `format`, `%`.
-      # The reason is that *unannotated* format is very similar
+      # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
       # @example EnforcedStyle: annotated (default)

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

@@ -8,8 +8,7 @@ module RuboCop
       # It will add the comment `# frozen_string_literal: true` to the top of
       # files to enable frozen string literals. Frozen string literals may be
       # default in future Ruby. The comment will be added below a shebang and
-      # encoding comment. The frozen string literal comment is only valid in
-      # Ruby 2.3+.
+      # encoding comment.
       #
       # Note that the cop will ignore files where the comment exists but is set
       # to `false` instead of `true`.
@@ -149,9 +148,7 @@ module RuboCop
           end
 
           next_token = processed_source.tokens[token_number]
-          if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
-            token = next_token
-          end
+          token = next_token if next_token && next_token.text =~ Encoding::ENCODING_PATTERN
 
           token
         end
@@ -216,7 +213,7 @@ module RuboCop
           if comment
             corrector.insert_after(line_range(comment.line), following_comment)
           else
-            corrector.insert_before(line_range(1), preceding_comment)
+            corrector.insert_before(processed_source.buffer.source_range, preceding_comment)
           end
         end
 

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

@@ -35,6 +35,17 @@ module RuboCop
       #   # good
       #   raise 'exception' if something
       #   ok
+      #
+      #   # bad
+      #   if something
+      #     foo || raise('exception')
+      #   else
+      #     ok
+      #   end
+      #
+      #   # good
+      #   foo || raise('exception') if something
+      #   ok
       class GuardClause < Cop
         include MinBodyLength
         include StatementModifier
@@ -69,7 +80,8 @@ module RuboCop
                else
                  opposite_keyword(node)
                end
-          register_offense(node, guard_clause.source, kw)
+
+          register_offense(node, guard_clause_source(guard_clause), kw)
         end
 
         private
@@ -98,13 +110,24 @@ module RuboCop
                       message: format(MSG, example: example))
         end
 
+        def guard_clause_source(guard_clause)
+          parent = guard_clause.parent
+
+          if parent.and_type? || parent.or_type?
+            guard_clause.parent.source
+          else
+            guard_clause.source
+          end
+        end
+
         def too_long_for_single_line?(node, example)
           max = max_line_length
           max && node.source_range.column + example.length > max
         end
 
         def accepted_form?(node, ending = false)
-          accepted_if?(node, ending) || node.condition.multiline?
+          accepted_if?(node, ending) || node.condition.multiline? ||
+            node.parent&.assignment?
         end
 
         def accepted_if?(node, ending)

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop checks for uses of `each_key` and `each_value` Hash methods.
       #
-      # Note: If you have an array of two-element arrays, you can put
+      # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
       #   working with a hash, and suppress RuboCop offenses.
       #
@@ -60,7 +60,7 @@ module RuboCop
         end
 
         def correct_implicit(node, corrector, method_name)
-          corrector.replace(node.loc.expression, method_name)
+          corrector.replace(node, method_name)
           correct_args(node, corrector)
         end
 
@@ -70,14 +70,14 @@ module RuboCop
           return correct_implicit(node, corrector, name) unless receiver
 
           new_source = receiver.source + ".#{name}"
-          corrector.replace(node.loc.expression, new_source)
+          corrector.replace(node, new_source)
         end
 
         def correct_args(node, corrector)
           args = node.parent.arguments
           name, = *args.children.find { |arg| used?(arg) }
 
-          corrector.replace(args.source_range, "|#{name}|")
+          corrector.replace(args, "|#{name}|")
         end
 
         def kv_range(outer_node)

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

@@ -13,11 +13,11 @@ module RuboCop
       # The supported styles are:
       #
       # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
-      #   all symbols for keys
+      # all symbols for keys
       # * hash_rockets - forces use of hash rockets for all hashes
       # * no_mixed_keys - simply checks for hashes with mixed syntaxes
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
-      #   syntax hashes
+      # syntax hashes
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -144,11 +144,11 @@ module RuboCop
             # Prefer { :production? => false } over { production?: false } and
             # similarly for other non-alnum final characters (except quotes,
             # to prefer { "x y": 1 } over { :"x y" => 1 }).
-            return false unless sym_name =~ /[\p{Alnum}"']\z/
+            return false unless /[\p{Alnum}"']\z/.match?(sym_name)
           end
 
           # Most hash keys can be matched against a simple regex.
-          return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
+          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?
@@ -168,11 +168,7 @@ module RuboCop
         end
 
         def autocorrect_ruby19(corrector, pair_node)
-          key = pair_node.key.source_range
-          op = pair_node.loc.operator
-
-          range = key.join(op)
-          range = range_with_surrounding_space(range: range, side: :right)
+          range = range_for_autocorrect_ruby19(pair_node)
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
@@ -180,6 +176,19 @@ module RuboCop
             range,
             range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
           )
+
+          hash_node = pair_node.parent
+          return unless hash_node.parent&.return_type? && !hash_node.braces?
+
+          corrector.wrap(hash_node, '{', '}')
+        end
+
+        def range_for_autocorrect_ruby19(pair_node)
+          key = pair_node.key.source_range
+          operator = pair_node.loc.operator
+
+          range = key.join(operator)
+          range_with_surrounding_space(range: range, side: :right)
         end
 
         def argument_without_space?(node)
@@ -188,11 +197,9 @@ module RuboCop
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)
-          key = pair_node.key.source_range
           op = pair_node.loc.operator
 
-          corrector.insert_after(key, pair_node.inverse_delimiter(true))
-          corrector.insert_before(key, ':')
+          corrector.wrap(pair_node.key, ':', pair_node.inverse_delimiter(true))
           corrector.remove(range_with_surrounding_space(range: op))
         end
 

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

@@ -24,11 +24,8 @@ module RuboCop
       #   {a: 1, b: 2}.transform_values { |v| foo(v) }
       #   {a: 1, b: 2}.transform_values { |v| v * v }
       class HashTransformValues < Cop
-        extend TargetRubyVersion
         include HashTransformMethod
 
-        minimum_target_ruby_version 2.4
-
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
             ({send csend}