rubocop 0.76.0 → 0.83.0

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

@@ -51,29 +51,65 @@ module RuboCop
       #   module Baz
       #     # ...
       #   end
+      #
+      # @example EnforcedStyle: always_true
+      #   # The `always_true` style enforces that the frozen string literal
+      #   # comment is set to `true`. This is a stricter option than `always`
+      #   # and forces projects to use frozen string literals.
+      #   # bad
+      #   # frozen_string_literal: false
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
       class FrozenStringLiteralComment < Cop
         include ConfigurableEnforcedStyle
         include FrozenStringLiteral
         include RangeHelp
 
-        MSG = '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`.'
         SHEBANG = '#!'
 
         def investigate(processed_source)
           return if processed_source.tokens.empty?
 
-          if frozen_string_literal_comment_exists?
-            check_for_no_comment(processed_source)
+          case style
+          when :never
+            ensure_no_comment(processed_source)
+          when :always_true
+            ensure_enabled_comment(processed_source)
           else
-            check_for_comment(processed_source)
+            ensure_comment(processed_source)
           end
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :never
+            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
@@ -82,12 +118,27 @@ module RuboCop
 
         private
 
-        def check_for_no_comment(processed_source)
-          unnecessary_comment_offense(processed_source) if style == :never
+        def ensure_no_comment(processed_source)
+          return unless frozen_string_literal_comment_exists?
+
+          unnecessary_comment_offense(processed_source)
         end
 
-        def check_for_comment(processed_source)
-          offense(processed_source) unless style == :never
+        def ensure_comment(processed_source)
+          return if frozen_string_literal_comment_exists?
+
+          missing_offense(processed_source)
+        end
+
+        def ensure_enabled_comment(processed_source)
+          if frozen_string_literal_specified?
+            return if frozen_string_literals_enabled?
+
+            # The comment exists, but is not enabled.
+            disabled_offense(processed_source)
+          else # The comment doesn't exist at all.
+            missing_true_offense(processed_source)
+          end
         end
 
         def last_special_comment(processed_source)
@@ -111,11 +162,22 @@ module RuboCop
           end
         end
 
-        def offense(processed_source)
+        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)
+        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)
+          add_offense(last_special_comment,
+                      location: range,
+                      message: MSG_MISSING_TRUE)
         end
 
         def unnecessary_comment_offense(processed_source)
@@ -127,11 +189,27 @@ module RuboCop
                       message: MSG_UNNECESSARY)
         end
 
+        def disabled_offense(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)
+        end
+
         def remove_comment(corrector, node)
           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)
+        end
+
         def insert_comment(corrector)
           comment = last_special_comment(processed_source)
 

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
@@ -49,8 +60,9 @@ module RuboCop
 
           if body.if_type?
             check_ending_if(body)
-          elsif body.begin_type? && body.children.last.if_type?
-            check_ending_if(body.children.last)
+          elsif body.begin_type?
+            final_expression = body.children.last
+            check_ending_if(final_expression) if final_expression&.if_type?
           end
         end
         alias on_defs on_def
@@ -68,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
@@ -97,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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    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
+      #   parentheses around the block arguments to indicate that you're not
+      #   working with a hash, and suppress RuboCop offenses.
+      #
+      # @example
+      #   # bad
+      #   hash.keys.each { |k| p k }
+      #   hash.values.each { |v| p v }
+      #
+      #   # good
+      #   hash.each_key { |k| p k }
+      #   hash.each_value { |v| p v }
+      class HashEachMethods < Cop
+        include Lint::UnusedArgument
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+
+        def_node_matcher :kv_each, <<~PATTERN
+          (block $(send (send _ ${:keys :values}) :each) ...)
+        PATTERN
+
+        def on_block(node)
+          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)
+          kv_each(node) do |target, method|
+            return unless target.receiver.receiver
+
+            msg = format(message, prefer: "each_#{method[0..-2]}",
+                                  current: "#{method}.each")
+
+            add_offense(target, location: kv_range(target), message: msg)
+          end
+        end
+
+        def check_argument(variable)
+          return unless variable.block_argument?
+
+          (@block_args ||= []).push(variable)
+        end
+
+        def used?(arg)
+          @block_args.find { |var| var.declaration_node.loc == arg.loc }.used?
+        end
+
+        def correct_implicit(node, corrector, method_name)
+          corrector.replace(node, method_name)
+          correct_args(node, corrector)
+        end
+
+        def correct_key_value_each(node, corrector)
+          receiver = node.receiver.receiver
+          name = "each_#{node.receiver.method_name.to_s.chop}"
+          return correct_implicit(node, corrector, name) unless receiver
+
+          new_source = receiver.source + ".#{name}"
+          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, "|#{name}|")
+        end
+
+        def kv_range(outer_node)
+          outer_node.receiver.loc.selector.join(outer_node.loc.selector)
+        end
+      end
+    end
+  end
+end

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

@@ -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?
@@ -188,11 +188,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_keys.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # transforming the keys of a hash, and tries to use a simpler & faster
+      # call to `transform_keys` instead.
+      #
+      # This can produce false positives if we are transforming an enumerable
+      # of key-value-like pairs that isn't actually a hash, e.g.:
+      # `[[k1, v1], [k2, v2], ...]`
+      #
+      # This cop should only be enabled on Ruby version 2.5 or newer
+      # (`transform_keys` was added in Ruby 2.5.)
+      #
+      # @example
+      #   # bad
+      #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[foo(k)] = v }
+      #   {a: 1, b: 2}.map { |k, v| [k.to_s, v] }
+      #
+      #   # good
+      #   {a: 1, b: 2}.transform_keys { |k| foo(k) }
+      #   {a: 1, b: 2}.transform_keys { |k| k.to_s }
+      class HashTransformKeys < Cop
+        extend TargetRubyVersion
+        include HashTransformMethod
+
+        minimum_target_ruby_version 2.5
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
+            (args
+              (mlhs
+                (arg $_)
+                (arg _val))
+              (arg _memo))
+            ({send csend} (lvar _memo) :[]= $_ $(lvar _val)))
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} !(send _ :each_with_index) {:map :collect})
+              (args
+                (arg $_)
+                (arg _val))
+              (array $_ $(lvar _val))))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                {:map :collect})
+              (args
+                (arg $_)
+                (arg _val))
+              (array $_ $(lvar _val)))
+            :to_h)
+        PATTERN
+
+        private
+
+        def extract_captures(match)
+          key_argname, key_body_expr, val_body_expr = *match
+          Captures.new(key_argname, key_body_expr, val_body_expr)
+        end
+
+        def new_method_name
+          'transform_keys'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop looks for uses of `_.each_with_object({}) {...}`,
+      # `_.map {...}.to_h`, and `Hash[_.map {...}]` that are actually just
+      # transforming the values of a hash, and tries to use a simpler & faster
+      # call to `transform_values` instead.
+      #
+      # This can produce false positives if we are transforming an enumerable
+      # of key-value-like pairs that isn't actually a hash, e.g.:
+      # `[[k1, v1], [k2, v2], ...]`
+      #
+      # This cop should only be enabled on Ruby version 2.4 or newer
+      # (`transform_values` was added in Ruby 2.4.)
+      #
+      # @example
+      #   # bad
+      #   {a: 1, b: 2}.each_with_object({}) { |(k, v), h| h[k] = foo(v) }
+      #   {a: 1, b: 2}.map { |k, v| [k, v * v] }
+      #
+      #   # good
+      #   {a: 1, b: 2}.transform_values { |v| foo(v) }
+      #   {a: 1, b: 2}.transform_values { |v| v * v }
+      class HashTransformValues < Cop
+        include HashTransformMethod
+
+        def_node_matcher :on_bad_each_with_object, <<~PATTERN
+          (block
+            ({send csend}
+              !{(send _ :each_with_index) (array ...)}
+              :each_with_object (hash))
+            (args
+              (mlhs
+                (arg _key)
+                (arg $_))
+              (arg _memo))
+            ({send csend} (lvar _memo) :[]= $(lvar _key) $_))
+        PATTERN
+
+        def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
+          (send
+            (const _ :Hash)
+            :[]
+            (block
+              ({send csend} !(send _ :each_with_index) {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_)))
+        PATTERN
+
+        def_node_matcher :on_bad_map_to_h, <<~PATTERN
+          ({send csend}
+            (block
+              ({send csend}
+                !{(send _ :each_with_index) (array ...)}
+                 {:map :collect})
+              (args
+                (arg _key)
+                (arg $_))
+              (array $(lvar _key) $_))
+            :to_h)
+        PATTERN
+
+        private
+
+        def extract_captures(match)
+          val_argname, key_body_expr, val_body_expr = *match
+          Captures.new(val_argname, val_body_expr, key_body_expr)
+        end
+
+        def new_method_name
+          'transform_values'
+        end
+      end
+    end
+  end
+end