rubocop 0.51.0 → 0.52.0

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

@@ -4,6 +4,27 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for usage of the %Q() syntax when %q() would do.
+      #
+      # @example EnforcedStyle: lower_case_q (default)
+      #   # The `lower_case_q` style prefers `%q` unless
+      #   # interpolation is needed.
+      #   # bad
+      #   %Q[Mix the foo into the baz.]
+      #   %Q(They all said: 'Hooray!')
+      #
+      #   # good
+      #   %q[Mix the foo into the baz]
+      #   %q(They all said: 'Hooray!')
+      #
+      # @example EnforcedStyle: upper_case_q
+      #   # The `upper_case_q` style requires the sole use of `%Q`.
+      #   # bad
+      #   %q/Mix the foo into the baz./
+      #   %q{They all said: 'Hooray!'}
+      #
+      #   # good
+      #   %Q/Mix the foo into the baz./
+      #   %Q{They all said: 'Hooray!'}
       class PercentQLiterals < Cop
         include PercentLiteral
         include ConfigurableEnforcedStyle
@@ -16,6 +37,12 @@ module RuboCop
           process(node, '%Q', '%q')
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected(node.source))
+          end
+        end
+
         private
 
         def on_percent_literal(node)
@@ -37,12 +64,6 @@ module RuboCop
           style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, corrected(node.source))
-          end
-        end
-
         def corrected(src)
           src.sub(src[1], src[1].swapcase)
         end

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

@@ -5,6 +5,13 @@ module RuboCop
     module Style
       # This cop looks for uses of Perl-style regexp match
       # backreferences like $1, $2, etc.
+      #
+      # @example
+      #   # bad
+      #   puts $1
+      #
+      #   # good
+      #   puts Regexp.last_match(1)
       class PerlBackrefs < Cop
         MSG = 'Avoid the use of Perl-style backrefs.'.freeze
 

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

@@ -8,10 +8,7 @@ module RuboCop
       # It is configurable to enforce the inverse, using `verbose` method
       # names also.
       #
-      # @example
-      #
-      #  # EnforcedStyle: short (default)
-      #
+      # @example EnforcedStyle: short (default)
       #  # bad
       #  Hash#has_key?
       #  Hash#has_value?
@@ -20,10 +17,7 @@ module RuboCop
       #  Hash#key?
       #  Hash#value?
       #
-      # @example
-      #
-      #  # EnforcedStyle: verbose
-      #
+      # @example EnforcedStyle: verbose
       #  # bad
       #  Hash#key?
       #  Hash#value?
@@ -34,7 +28,7 @@ module RuboCop
       class PreferredHashMethods < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `Hash#%s` instead of `Hash#%s`.'.freeze
+        MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'.freeze
 
         OFFENDING_SELECTORS = {
           short: %i[has_key? has_value?],
@@ -58,7 +52,9 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, proper_method_name(node.method_name), node.method_name)
+          format(MSG,
+                 prefer: proper_method_name(node.method_name),
+                 current: node.method_name)
         end
 
         def proper_method_name(method_name)

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

@@ -5,6 +5,14 @@ module RuboCop
     module Style
       # This cops checks for uses of Proc.new where Kernel#proc
       # would be more appropriate.
+      #
+      # @example
+      #   # bad
+      #   p = Proc.new { |n| puts n }
+      #
+      #   # good
+      #   p = proc { |n| puts n }
+      #
       class Proc < Cop
         MSG = 'Use `proc` instead of `Proc.new`.'.freeze
 

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

@@ -13,10 +13,7 @@ module RuboCop
       # will also suggest constructing error objects when the exception is
       # passed multiple arguments.
       #
-      # @example
-      #
-      #   # EnforcedStyle: exploded
-      #
+      # @example EnforcedStyle: exploded (default)
       #   # bad
       #   raise StandardError.new("message")
       #
@@ -26,10 +23,7 @@ module RuboCop
       #   raise MyCustomError.new(arg1, arg2, arg3)
       #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
-      # @example
-      #
-      #   # EnforcedStyle: compact
-      #
+      # @example EnforcedStyle: compact
       #   # bad
       #   raise StandardError, "message"
       #   raise RuntimeError, arg1, arg2, arg3
@@ -42,9 +36,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         EXPLODED_MSG = 'Provide an exception class and message ' \
-          'as arguments to `%s`.'.freeze
+          'as arguments to `%<method>s`.'.freeze
         COMPACT_MSG = 'Provide an exception object ' \
-          'as an argument to `%s`.'.freeze
+          'as an argument to `%<method>s`.'.freeze
 
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
@@ -57,8 +51,6 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
           replacement = if style == :compact
                           correction_exploded_to_compact(node)
@@ -69,6 +61,8 @@ module RuboCop
           ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
+        private
+
         def correction_compact_to_exploded(node)
           exception_node, _new, message_node = *node.first_argument
 
@@ -128,9 +122,9 @@ module RuboCop
 
         def message(node)
           if style == :compact
-            format(COMPACT_MSG, node.method_name)
+            format(COMPACT_MSG, method: node.method_name)
           else
-            format(EXPLODED_MSG, node.method_name)
+            format(EXPLODED_MSG, method: node.method_name)
           end
         end
       end

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

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of randomly generated numbers,
+      # added/subtracted with integer literals, as well as those with
+      # Integer#succ and Integer#pred methods. Prefer using ranges instead,
+      # as it clearly states the intentions.
+      #
+      # @example
+      #   # bad
+      #   rand(6) + 1
+      #   1 + rand(6)
+      #   rand(6) - 1
+      #   1 - rand(6)
+      #   rand(6).succ
+      #   rand(6).pred
+      #   Random.rand(6) + 1
+      #   Kernel.rand(6) + 1
+      #   rand(0..5) + 1
+      #
+      #   # good
+      #   rand(1..6)
+      #   rand(1...7)
+      class RandomWithOffset < Cop
+        MSG = 'Prefer ranges when generating random numbers instead of ' \
+          'integers with offsets.'.freeze
+
+        def_node_matcher :integer_op_rand?, <<-PATTERN
+          (send
+            int {:+ :-}
+            (send
+              {nil? (const nil? :Random) (const nil? :Kernel)}
+              :rand
+              {int irange erange}))
+        PATTERN
+
+        def_node_matcher :rand_op_integer?, <<-PATTERN
+          (send
+            (send
+              {nil? (const nil? :Random) (const nil? :Kernel)}
+              :rand
+              {int irange erange})
+            {:+ :-}
+            int)
+        PATTERN
+
+        def_node_matcher :rand_modified?, <<-PATTERN
+          (send
+            (send
+              {nil? (const nil? :Random) (const nil? :Kernel)}
+              :rand
+              {int irange erange})
+            {:succ :pred :next})
+        PATTERN
+
+        def on_send(node)
+          return unless integer_op_rand?(node) ||
+                        rand_op_integer?(node) ||
+                        rand_modified?(node)
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if integer_op_rand?(node)
+              corrector.replace(node.source_range,
+                                corrected_integer_op_rand(node))
+            elsif rand_op_integer?(node)
+              corrector.replace(node.source_range,
+                                corrected_rand_op_integer(node))
+            elsif rand_modified?(node)
+              corrector.replace(node.source_range,
+                                corrected_rand_modified(node))
+            end
+          end
+        end
+
+        private
+
+        def corrected_integer_op_rand(node)
+          left, operator, right = *node
+
+          offset = int_from_int_node(left)
+
+          prefix_node, _, random_node = *right
+
+          prefix = prefix_from_prefix_node(prefix_node)
+          left_int, right_int = boundaries_from_random_node(random_node)
+
+          if operator == :+
+            "#{prefix}(#{offset + left_int}..#{offset + right_int})"
+          else
+            "#{prefix}(#{offset - right_int}..#{offset - left_int})"
+          end
+        end
+
+        def corrected_rand_op_integer(node)
+          left, operator, right = *node
+
+          prefix_node, _, random_node = *left
+
+          offset = int_from_int_node(right)
+
+          prefix = prefix_from_prefix_node(prefix_node)
+          left_int, right_int = boundaries_from_random_node(random_node)
+
+          if operator == :+
+            "#{prefix}(#{left_int + offset}..#{right_int + offset})"
+          else
+            "#{prefix}(#{left_int - offset}..#{right_int - offset})"
+          end
+        end
+
+        def corrected_rand_modified(node)
+          rand, method = *node
+          prefix_node, _, random_node = *rand
+
+          prefix = prefix_from_prefix_node(prefix_node)
+          left_int, right_int = boundaries_from_random_node(random_node)
+
+          if %i[succ next].include?(method)
+            "#{prefix}(#{left_int + 1}..#{right_int + 1})"
+          elsif method == :pred
+            "#{prefix}(#{left_int - 1}..#{right_int - 1})"
+          end
+        end
+
+        def prefix_from_prefix_node(node)
+          if node.nil?
+            'rand'
+          else
+            _, prefix = *node
+            "#{prefix}.rand"
+          end
+        end
+
+        def boundaries_from_random_node(random_node)
+          children = random_node.children
+
+          case random_node.type
+          when :int
+            [0, int_from_int_node(random_node) - 1]
+          when :irange
+            [int_from_int_node(children.first),
+             int_from_int_node(children[1])]
+          when :erange
+            [int_from_int_node(children.first),
+             int_from_int_node(children[1]) - 1]
+          end
+        end
+
+        def int_from_int_node(node)
+          node.children.first
+        end
+      end
+    end
+  end
+end

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

@@ -28,13 +28,15 @@ module RuboCop
         MSG = 'Redundant `begin` block detected.'.freeze
 
         def on_def(node)
-          return unless node.body && node.body.kwbegin_type?
-
-          add_offense(node.body, location: :begin)
+          check(node)
         end
         alias on_defs on_def
 
-        private
+        def on_block(node)
+          return if target_ruby_version < 2.5
+          return if node.braces?
+          check(node)
+        end
 
         def autocorrect(node)
           lambda do |corrector|
@@ -42,6 +44,14 @@ module RuboCop
             corrector.remove(node.loc.end)
           end
         end
+
+        private
+
+        def check(node)
+          return unless node.body && node.body.kwbegin_type?
+
+          add_offense(node.body, location: :begin)
+        end
       end
     end
   end

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

@@ -29,7 +29,8 @@ module RuboCop
 
         COMPARISON_OPERATORS = RuboCop::AST::Node::COMPARISON_OPERATORS
 
-        MSG = 'This conditional expression can just be replaced by `%s`.'.freeze
+        MSG = 'This conditional expression can just be replaced ' \
+              'by `%<msg>s`.'.freeze
 
         def on_if(node)
           return unless offense?(node)
@@ -37,13 +38,19 @@ module RuboCop
           add_offense(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.expression, replacement_condition(node))
+          end
+        end
+
         private
 
         def message(node)
           replacement = replacement_condition(node)
           msg = node.elsif? ? "\n#{replacement}" : replacement
 
-          format(MSG, msg)
+          format(MSG, msg: msg)
         end
 
         def_node_matcher :redundant_condition?, <<-RUBY
@@ -59,12 +66,6 @@ module RuboCop
           redundant_condition?(node) || redundant_condition_inverted?(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement_condition(node))
-          end
-        end
-
         def replacement_condition(node)
           condition = node.condition.source
           expression = invert_expression?(node) ? "!(#{condition})" : condition

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

@@ -31,9 +31,7 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
-        def autocorrect(node)
+        def autocorrect(node) # rubocop:disable Metrics/MethodLength
           lambda do |corrector|
             unless arguments?(node.children)
               corrector.replace(node.source_range, 'nil')
@@ -46,11 +44,14 @@ module RuboCop
             elsif return_value.hash_type?
               add_braces(corrector, return_value) unless return_value.braces?
             end
-            return_kw = range_with_surrounding_space(node.loc.keyword, :right)
+            return_kw = range_with_surrounding_space(range: node.loc.keyword,
+                                                     side: :right)
             corrector.remove(return_kw)
           end
         end
 
+        private
+
         def add_brackets(corrector, node)
           kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '[')