rubocop 0.49.1 → 0.52.0

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

@@ -5,6 +5,23 @@ module RuboCop
     module Style
       # This cop checks for the presence of superfluous parentheses around the
       # condition of if/unless/while/until.
+      #
+      # @example
+      #   # bad
+      #   x += 1 while (x < 10)
+      #   foo unless (bar || baz)
+      #
+      #   if (x > 10)
+      #   elsif (x < 3)
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #   foo unless bar || baz
+      #
+      #   if x > 10
+      #   elsif x < 3
+      #   end
       class ParenthesesAroundCondition < Cop
         include SafeAssignment
         include Parentheses
@@ -18,35 +35,35 @@ module RuboCop
         def on_while(node)
           process_control_op(node)
         end
-
-        def on_until(node)
-          process_control_op(node)
-        end
+        alias on_until on_while
 
         private
 
+        def_node_matcher :control_op_condition, <<-PATTERN
+          (begin $_ ...)
+        PATTERN
+
         def process_control_op(node)
           cond = node.condition
 
-          return unless cond.begin_type?
-          return if cond.children.empty?
-          return if modifier_op?(cond.children.first)
-          return if parens_required?(node.children.first)
-          return if safe_assignment?(cond) && safe_assignment_allowed?
+          control_op_condition(cond) do |first_child|
+            return if modifier_op?(first_child)
+            return if parens_required?(node.condition)
+            return if safe_assignment?(cond) && safe_assignment_allowed?
 
-          add_offense(cond, :expression, message(node))
+            add_offense(cond)
+          end
         end
 
         def modifier_op?(node)
           return false if node.if_type? && node.ternary?
           return true if node.rescue_type?
 
-          MODIFIER_NODES.include?(node.type) &&
-            node.modifier_form?
+          MODIFIER_NODES.include?(node.type) && node.modifier_form?
         end
 
         def message(node)
-          kw = node.keyword
+          kw = node.parent.keyword
           article = kw == 'while' ? 'a' : 'an'
           "Don't use parentheses around the condition of #{article} `#{kw}`."
         end

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

@@ -55,8 +55,6 @@ module RuboCop
           "`#{delimiters[0]}` and `#{delimiters[1]}`."
         end
 
-        private
-
         def autocorrect(node)
           type = type(node)
 
@@ -68,12 +66,15 @@ module RuboCop
           end
         end
 
+        private
+
         def on_percent_literal(node)
           type = type(node)
           return if uses_preferred_delimiter?(node, type) ||
-                    contains_preferred_delimiter?(node, type)
+                    contains_preferred_delimiter?(node, type) ||
+                    include_same_character_as_used_for_delimiter?(node, type)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def uses_preferred_delimiter?(node, type)
@@ -87,6 +88,17 @@ module RuboCop
             .any? { |s| preferred_delimiters.any? { |d| s.include?(d) } }
         end
 
+        def include_same_character_as_used_for_delimiter?(node, type)
+          return false unless %w[%w %i].include?(type)
+
+          used_delimiters = matchpairs(begin_source(node)[-1])
+          escaped_delimiters = used_delimiters.map { |d| "\\#{d}" }.join('|')
+
+          node
+            .children.map { |n| string_source(n) }.compact
+            .any? { |s| Regexp.new(escaped_delimiters) =~ s }
+        end
+
         def string_source(node)
           if node.is_a?(String)
             node
@@ -94,6 +106,15 @@ module RuboCop
             node.source
           end
         end
+
+        def matchpairs(begin_delimiter)
+          {
+            '(' => %w[( )],
+            '[' => %w[[ ]],
+            '{' => %w[{ }],
+            '<' => %w[< >]
+          }.fetch(begin_delimiter, [begin_delimiter])
+        end
       end
     end
   end

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)
@@ -25,7 +52,7 @@ module RuboCop
           # 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, message)
+          add_offense(node, location: :begin)
         end
 
         def correct_literal_style?(node)
@@ -33,16 +60,10 @@ module RuboCop
             style == :upper_case_q && type(node) == '%Q'
         end
 
-        def message
+        def message(_node)
           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,11 +5,18 @@ 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)

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?],
@@ -45,7 +39,7 @@ module RuboCop
           return unless node.arguments.one? &&
                         offending_selector?(node.method_name)
 
-          add_offense(node, :selector)
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -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,15 +5,23 @@ 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
 
         def_node_matcher :proc_new?,
-                         '(block $(send (const nil :Proc) :new) ...)'
+                         '(block $(send (const nil? :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|
-            add_offense(block_method, :expression)
+            add_offense(block_method)
           end
         end
 

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,41 +51,40 @@ module RuboCop
           end
         end
 
-        private
-
         def autocorrect(node)
-          new_exception = if style == :compact
-                            correction_exploded_to_compact(node.arguments)
-                          else
-                            correction_compact_to_exploded(node.first_argument)
-                          end
-          replacement = "#{node.method_name} #{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
+          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)
           if node.arguments.size > 1
-            add_offense(node, :expression, message(node.method_name)) do
+            add_offense(node) do
               opposite_style_detected
             end
           else
@@ -108,7 +101,7 @@ module RuboCop
 
           return if acceptable_exploded_args?(first_arg.arguments)
 
-          add_offense(node, :expression, message(node.method_name)) do
+          add_offense(node) do
             opposite_style_detected
           end
         end
@@ -127,11 +120,11 @@ module RuboCop
           arg.hash_type? || arg.splat_type?
         end
 
-        def message(method)
+        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