rubocop 0.42.0 → 0.52.1

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

@@ -1,44 +1,67 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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
 
+        LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
+                           'needed.  Use `%q`.'.freeze
+        UPPER_CASE_Q_MSG = 'Use `%Q` instead of `%q`.'.freeze
+
         def on_str(node)
           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)
-          if style == :lower_case_q
-            if type(node) == '%Q'
-              check(node,
-                    'Do not use `%Q` unless interpolation is needed.  ' \
-                    'Use `%q`.')
-            end
-          elsif type(node) == '%q'
-            check(node, 'Use `%Q` instead of `%q`.')
-          end
-        end
+          return if correct_literal_style?(node)
 
-        def check(node, msg)
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
           return if node.children != parse(corrected(node.source)).ast.children
 
-          add_offense(node, :begin, msg)
+          add_offense(node, location: :begin)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, corrected(node.source))
-          end
+        def correct_literal_style?(node)
+          style == :lower_case_q && type(node) == '%q' ||
+            style == :upper_case_q && type(node) == '%Q'
+        end
+
+        def message(_node)
+          style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
         end
 
         def corrected(src)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,18 +5,25 @@ 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
 
         def on_nth_ref(node)
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)
           lambda do |corrector|
             backref, = *node
             parent_type = node.parent ? node.parent.type : nil
-            if [:dstr, :xstr, :regexp].include?(parent_type)
+            if %i[dstr xstr regexp].include?(parent_type)
               corrector.replace(node.source_range,
                                 "{Regexp.last_match(#{backref})}")
             else

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

@@ -1,25 +1,45 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of methods Hash#has_key? and Hash#has_value?
-      # Prefer to use Hash#key? and Hash#value? instead
+      # This cop (by default) checks for uses of methods Hash#has_key? and
+      # Hash#has_value? where it enforces Hash#key? and Hash#value?
+      # It is configurable to enforce the inverse, using `verbose` method
+      # names also.
+      #
+      # @example EnforcedStyle: short (default)
+      #  # bad
+      #  Hash#has_key?
+      #  Hash#has_value?
+      #
+      #  # good
+      #  Hash#key?
+      #  Hash#value?
+      #
+      # @example EnforcedStyle: verbose
+      #  # bad
+      #  Hash#key?
+      #  Hash#value?
+      #
+      #  # good
+      #  Hash#has_key?
+      #  Hash#has_value?
       class PreferredHashMethods < Cop
-        MSG = 'Use `Hash#%s` instead of `Hash#%s`.'.freeze
+        include ConfigurableEnforcedStyle
 
-        PREFERRED_METHODS = [:has_key?, :has_value?].freeze
+        MSG = 'Use `Hash#%<prefer>s` instead of `Hash#%<current>s`.'.freeze
+
+        OFFENDING_SELECTORS = {
+          short: %i[has_key? has_value?],
+          verbose: %i[key? value?]
+        }.freeze
 
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless args.size == 1 &&
-                        PREFERRED_METHODS.include?(method_name)
-
-          add_offense(node, :selector,
-                      format(MSG,
-                             proper_method_name(method_name),
-                             method_name))
+          return unless node.arguments.one? &&
+                        offending_selector?(node.method_name)
+
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -31,8 +51,22 @@ module RuboCop
 
         private
 
+        def message(node)
+          format(MSG,
+                 prefer: proper_method_name(node.method_name),
+                 current: node.method_name)
+        end
+
         def proper_method_name(method_name)
-          method_name.to_s.sub(/has_/, '')
+          if style == :verbose
+            "has_#{method_name}"
+          else
+            method_name.to_s.sub(/has_/, '')
+          end
+        end
+
+        def offending_selector?(method_name)
+          OFFENDING_SELECTORS[style].include?(method_name)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,20 +5,24 @@ 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
 
-        TARGET = s(:send, s(:const, nil, :Proc), :new)
+        def_node_matcher :proc_new?,
+                         '(block $(send (const nil? :Proc) :new) ...)'
 
         def on_block(node)
-          # We're looking for
-          # (block
-          #   (send
-          #     (const nil :Proc) :new)
-          #   ...)
-          block_method, = *node
-
-          add_offense(block_method, :expression) if block_method == TARGET
+          proc_new?(node) do |block_method|
+            add_offense(block_method)
+          end
         end
 
         def autocorrect(node)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -14,37 +13,32 @@ 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")
       #
       #   # good
       #   raise StandardError, "message"
       #   fail "message"
-      #   raise RuntimeError.new(arg1, arg2, arg3)
-      #
-      # @example
-      #
-      #   # EnforcedStyle: compact
+      #   raise MyCustomError.new(arg1, arg2, arg3)
+      #   raise MyKwArgError.new(key1: val1, key2: val2)
       #
+      # @example EnforcedStyle: compact
       #   # bad
       #   raise StandardError, "message"
       #   raise RuntimeError, arg1, arg2, arg3
       #
       #   # good
       #   raise StandardError.new("message")
-      #   raise RuntimeError.new(arg1, arg2, arg3)
+      #   raise MyCustomError.new(arg1, arg2, arg3)
       #   fail "message"
       class RaiseArgs < Cop
         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,45 +51,40 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
-          _scope, method, *args = *node
-
-          new_exception = if style == :compact
-                            correction_exploded_to_compact(args)
-                          else
-                            correction_compact_to_exploded(args)
-                          end
-          replacement = "#{method} #{new_exception}"
+          replacement = if style == :compact
+                          correction_exploded_to_compact(node)
+                        else
+                          correction_compact_to_exploded(node)
+                        end
 
           ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
+        private
+
         def correction_compact_to_exploded(node)
-          exception_node, _new, message_node = *node.first
+          exception_node, _new, message_node = *node.first_argument
 
           message = message_node && message_node.source
 
           correction = exception_node.const_name.to_s
           correction = "#{correction}, #{message}" if message
 
-          correction
+          "#{node.method_name} #{correction}"
         end
 
         def correction_exploded_to_compact(node)
-          exception_node, *message_nodes = *node
-
-          messages = message_nodes.map(&:source).join(', ')
+          exception_node, *message_nodes = *node.arguments
+          return node.source if message_nodes.size > 1
 
-          "#{exception_node.const_name}.new(#{messages})"
+          argument = message_nodes.first.source
+          "#{node.method_name} #{exception_node.const_name}.new(#{argument})"
         end
 
         def check_compact(node)
-          _receiver, selector, *args = *node
-
-          if args.size > 1
-            add_offense(node, :expression, message(selector)) do
+          if node.arguments.size > 1
+            add_offense(node) do
               opposite_style_detected
             end
           else
@@ -104,31 +93,38 @@ module RuboCop
         end
 
         def check_exploded(node)
-          _receiver, selector, *args = *node
+          return correct_style_detected unless node.arguments.one?
 
-          if args.size == 1
-            arg, = *args
+          first_arg = node.first_argument
 
-            if arg.type == :send && arg.loc.selector.is?('new')
-              _receiver, _selector, *constructor_args = *arg
+          return unless first_arg.send_type? && first_arg.method?(:new)
 
-              # Allow code like `raise Ex.new(arg1, arg2)`.
-              if constructor_args.size <= 1
-                add_offense(node, :expression, message(selector)) do
-                  opposite_style_detected
-                end
-              end
-            end
-          else
-            correct_style_detected
+          return if acceptable_exploded_args?(first_arg.arguments)
+
+          add_offense(node) do
+            opposite_style_detected
           end
         end
 
-        def message(method)
+        def acceptable_exploded_args?(args)
+          # Allow code like `raise Ex.new(arg1, arg2)`.
+          return true if args.size > 1
+
+          # Disallow zero arguments.
+          return false if args.empty?
+
+          arg = args.first
+
+          # Allow code like `raise Ex.new(kw: arg)`.
+          # Allow code like `raise Ex.new(*args)`.
+          arg.hash_type? || arg.splat_type?
+        end
+
+        def message(node)
           if style == :compact
-            format(COMPACT_MSG, method)
+            format(COMPACT_MSG, method: node.method_name)
           else
-            format(EXPLODED_MSG, method)
+            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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -26,14 +25,17 @@ module RuboCop
       #     something
       #   end
       class RedundantBegin < Cop
-        include OnMethodDef
-
         MSG = 'Redundant `begin` block detected.'.freeze
 
-        def on_method_def(_node, _method_name, _args, body)
-          return unless body && body.type == :kwbegin
+        def on_def(node)
+          check(node)
+        end
+        alias on_defs on_def
 
-          add_offense(body, :begin)
+        def on_block(node)
+          return if target_ruby_version < 2.5
+          return if node.braces?
+          check(node)
         end
 
         def autocorrect(node)
@@ -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